func (r Rate) GetRateById(Db *gorp.DbMap, id int64) Rate {
Db.SelectOne(&r, "select * from Rate where Id = ?", id)
if r.Id != 0 {
r.Votes = r.GetVotes(Db)
}
return r
}
func UserGet(ren render.Render, params martini.Params, dbmap *gorp.DbMap, s sessions.Session) {
var usr User
log.Println(params)
err := dbmap.SelectOne(&usr, "SELECT * from users WHERE id = $1", s.Get("userId"))
PanicIf(err)
ren.JSON(200, usr)
}
func FindArticleWithReadReceipts(dbmap *gorp.DbMap, id int64) (*Article, error) {
var a Article
err := dbmap.SelectOne(&a, "select * from articles where id = $1", id)
a.AddReadReceipts(dbmap)
return &a, err
}
func GetBySlug(db *gorp.DbMap, slug string) (WikiPage, bool) {
w := WikiPage{}
err := db.SelectOne(&w, "select * from WikiPage where Title = ?", slug)
if err != nil {
return w, false
}
return w, true
}
func (r Rate) GetRate(Db *gorp.DbMap, itemType int64, itemId int64) Rate {
if r.Id != 0 {
return r
}
Db.SelectOne(&r, "select * from Rate where ItemId = ? and ItemType = ?",
itemId, itemType)
r.Votes = r.GetVotes(Db)
return r
}
func CheckPhone(db *gorp.DbMap, phone string) (User, error) {
var user = User{}
db.SelectOne(&user, "select * from User where Phone = ? limit 1",
phone)
if user.Id != 0 {
return user, errors.New("User found")
}
return user, nil
}
func GetAddr(db *gorp.DbMap, addr string) (Address, error) {
var a Address
var err error
db.SelectOne(&a, "select * from Address where RawText = ?", addr)
if a.Id == 0 || a.RawText == "" {
err = errors.New(ErrorNotFound)
}
return a, err
}
func GetAddrById(db *gorp.DbMap, id int64) (Address, error) {
var a Address
var err error
db.SelectOne(&a, "select * from Address where Id = ?", id)
if a.Id == 0 || a.RawText == "" {
err = errors.New(ErrorNotFound)
}
return a, err
}
func GetGoodsById(gid string, dbmap *gorp.DbMap) (GoodInfo, error) {
var ginfo GoodInfo
err := dbmap.SelectOne(&ginfo, "SELECT * FROM GOODS WHERE G_ID=?", gid)
if err != nil {
glog.V(1).Infof("[DEBUG:] Search goods by id:%v fail:%v", gid, err)
return ginfo, err
}
return ginfo, nil
}
func PlayerInit(playerId int, gameId string, gs GameService, ws *websocket.Conn, db *gorp.DbMap) error {
log.Printf("Player is connected: %#v", playerId)
game, _, err := gs.GetGame(db, gameId, playerId)
if err != nil {
log.Printf("Couldn't get player and/or game")
return err
}
if game.State == "start" {
log.Printf("Player %#v rejoining game in play", playerId)
board, err := getBoard(gameId, db)
if err != nil {
log.Printf("Can't get TTT board: %#v", err)
return err
}
log.Printf("Got board, getting nicer one: %#v", board)
niceBoard, err := board.getBoard()
if err != nil {
log.Printf("Unable to get nice board: %#v", err)
return err
}
log.Printf("Got board for player %#v: %#v", playerId, board)
// There may not be a board yet so just try and send it
ws.WriteJSON(Message{
"type": "update",
"state": game.State,
"board": niceBoard,
})
} else {
ws.WriteJSON(Message{
"type": "update",
"state": game.State,
"board": nil,
})
}
// check to make sure this player has a turn row
turn := TicTacToe_Turn{}
err = db.SelectOne(&turn, "select * from tictactoe_turn where game=? and player=?", gameId, playerId)
if err != nil {
turn.Game = gameId
turn.Player = playerId
turn.Move = -1
err = db.Insert(&turn)
if err != nil {
log.Printf("Unable to insert initial turn row: %#v", err)
return err
}
}
gs.SendHost(gameId, Message{"type": "join"})
return nil
}
func Authenticate(user *User, dbmap *gorp.DbMap) bool {
var db_user User
err := dbmap.SelectOne(&db_user, "SELECT * FROM CUSTOMER WHERE CUS_TEL=?", user.PhoneNumber)
//count,err := dbmap.SelectInt("SELECT count(*) FROM CUSTOMER WHERE CUS_TEL=?",user.PhoneNumber)
if err != nil {
return false
}
glog.V(4).Infof("User Info:%v", db_user)
return user.Password == db_user.Password
}
func (ph *Station) GetNearestStation(dbMap *gorp.DbMap, latitudeF, longitudeF float64) error {
latitude := strconv.FormatFloat(latitudeF, 'f', 6, 64)
longitude := strconv.FormatFloat(longitudeF, 'f', 6, 64)
err := dbMap.SelectOne(ph, "SELECT * FROM station_info WHERE ( 3959 * acos( cos( radians('"+latitude+"') ) * cos( radians( latitude ) ) * cos( radians( longitude ) - radians('"+longitude+"') ) + sin( radians('"+latitude+"') ) * sin( radians( latitude ) ) ) ) < '300' ORDER BY ( 3959 * acos( cos( radians('"+latitude+"') ) * cos( radians( latitude ) ) * cos( radians( longitude ) - radians('"+longitude+"') ) + sin( radians('"+latitude+"') ) * sin( radians( latitude ) ) ) ) ASC LIMIT 0, 1")
// err = dbMap.SelectOne(ph, "SELECT * FROM station_info WHERE station_code = ?", 2)
if err != nil {
return err
}
return nil
}
func MustGet(db *gorp.DbMap, name string) (Tag, bool) {
t := Tag{}
exist := false
if tagExist(db, name) {
db.SelectOne(&t, "select * from Tag where Title = ?", name)
exist = true
} else {
t, _ = createTag(db, Tag{Title: name})
}
return t, exist
}
func getStationDetails(dbMap *gorp.DbMap, code string) PathReturnFormat {
var station model.Station
err := dbMap.SelectOne(&station, "SELECT * FROM station_info WHERE station_code = ?", code)
if err != nil {
fmt.Println("error retreiving station info")
}
var pathReturnFormat PathReturnFormat
pathReturnFormat.Lat = station.Latitude
pathReturnFormat.Long = station.Longitude
pathReturnFormat.Name = station.StationName
return pathReturnFormat
}
func Login(r *http.Request, render render.Render, db *gorp.DbMap, s sessions.Session) {
user := User{}
email, password := r.FormValue("email"), r.FormValue("password")
err := db.SelectOne(&user, "Select * from users where email=? ", email)
//tmp_pass, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
//err := db.QueryRow("select id, password from users where email=$1", email).Scan(&userId, &dbPasswd)
if err != nil || bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)) != nil {
render.HTML(400, "404", "")
}
s.Set("userId", user.Id)
render.HTML(200, "dashboard", "")
}
func RequireLogin(ren render.Render, req *http.Request, s sessions.Session, dbmap *gorp.DbMap, c martini.Context) {
var usr User
err := dbmap.SelectOne(&usr, "SELECT * from users WHERE id = $1", s.Get("userId"))
if err != nil {
ren.JSON(http.StatusForbidden, nil)
return
}
c.Map(usr)
}
func GetUser(r render.Render, dbmap *gorp.DbMap, params martini.Params, res http.ResponseWriter) {
tel := params["tel"]
//get userinfo
var u User
err := dbmap.SelectOne(&u, "SELECT * FROM CUSTOMER WHERE CUS_TEL=?", tel)
//err := db.QueryRow("SELECT CUS_NAME,CUS_ADDR,CUS_EMAIL,CUS_TEL,CUS_PW FROM CUSTOMER WHERE CUS_TEL=?",tel).Scan(&u.Name,&u.Address,&u.Email,&u.PhoneNumber,&u.Password)
if err != nil {
glog.V(1).Infof("[DEBUG:] Search customer by tel:%v fail:%v", tel, err)
r.JSON(http.StatusConflict, map[string]string{"message": "DB ERROR"})
return
}
r.JSON(200, u)
}
func PostLogin(req *http.Request, dbmap *gorp.DbMap, s sessions.Session) (int, string) {
var userId string
email, password := req.FormValue("email"), req.FormValue("password")
err := dbmap.SelectOne(&userId, "select id from users where email=$1 and password=$2", email, Md5(password))
if err != nil {
return 401, "Unauthorized"
}
s.Set("userId", userId)
return 200, "User id is " + userId
}
func GetPost(args martini.Params, r render.Render, dbmap *gorp.DbMap) {
var post models.Post
err := dbmap.SelectOne(&post, "SELECT * FROM posts WHERE id = ?", args["id"])
if err != nil {
jsonError := &models.JSONError{
Error: "Post not found",
}
r.JSON(404, jsonError)
} else {
r.JSON(200, post)
}
}
func GetSite(Db *gorp.DbMap, fullurl string) (Site, error) {
fullurl = n(fullurl)
w := Site{}
u, _ := url.Parse(fullurl)
err := Db.SelectOne(&w, "select * from Site where Domain="+
" ?", u.Host)
if err != nil {
fmt.Println(err)
return w, err
}
if w.Id == 0 {
fmt.Println("Site not exist")
return w, errors.New("not exist")
}
return w, nil
}
func GetPage(Db *gorp.DbMap, fullurl string) (SitePage, error) {
fullurl = n(fullurl)
w := SitePage{}
u, _ := url.Parse(fullurl)
err := Db.SelectOne(&w, "select * from SitePage where SiteId"+
" in (select Id from Site where Domain = ?) and Url = ?",
u.Host, u.RequestURI())
if err != nil || w.Url == "" {
fmt.Println(err)
return w, errors.New("not exist")
}
w.Url = fullurl
return w, nil
}
func (u *User) Confirm(db *gorp.DbMap, code int64, userid int64) error {
var uc = UserConfirmation{}
err := db.SelectOne(&uc, "select * from UserConfirmation where UserId = ? and Code = ?"+
" and Tried = 0 and Created > ?", userid, code, time.Now().Truncate(5*
time.Minute).UnixNano())
if err != nil {
return err
}
if uc.Id == 0 {
return errors.New("Confirmation not found")
}
u.Registered = true
_, err = db.Update(u)
if err != nil {
return err
}
return nil
}
func (u *User) CheckLogin(db *gorp.DbMap, login string) (User, error) {
var user = User{}
ph, _ := phone.Normalize(login)
if ph == "" {
ph = login
}
if login == "" {
return user, errors.New("User not found")
}
err := db.SelectOne(&user, "select * from User where Phone = ? or Email = ?"+
" or NickName = ? limit 1", ph, login, login)
if err != nil {
return user, errors.New("User not found")
}
if user.Id == 0 {
return user, errors.New("User not found")
}
return user, nil
}
func playerMove(msg Message, gameId string, playerId int, gs GameService, ws *websocket.Conn, db *gorp.DbMap, log *log.Logger) error {
log.Printf("Sending move to host")
turn := TicTacToe_Turn{}
err := db.SelectOne(&turn, "select * from tictactoe_turn where game=? and player=?", gameId, playerId)
if err != nil {
log.Printf("Unable to get turn in move: %#v", err)
return err
}
// the player move comes as an integer from [0-8] representing the location of the move
// TODO: assert this is the case before saving
turn.Move = int(msg["move"].(float64))
_, err = db.Update(&turn)
if err != nil {
log.Printf("Failed to update moving player: %#v", err)
return err
}
// send notice to the host that we've moved so it can attempt to resolve the current round
gs.SendHost(gameId, msg)
return nil
}
func GetGeoObject(db *gorp.DbMap, slug string) (*GeoObject, error) {
g := new(GeoObject)
err := db.SelectOne(g, "select * from GeoObject where Slug = ?", slug)
return g, err
}
// helpers
func getBoard(gameId string, db *gorp.DbMap) (*TicTacToe_Board, error) {
board := &TicTacToe_Board{}
err := db.SelectOne(board, "select * from tictactoe_board where game=?", gameId)
return board, err
}
func hostMove(msg Message, gameId string, playerId int, gs GameService, ws *websocket.Conn, db *gorp.DbMap, log *log.Logger) error {
log.Printf("Checking player move")
var players []*Player
_, err := db.Select(&players, "select * from players where game=?", gameId)
if err != nil {
log.Printf("Failed to select players during move for game %v", gameId)
return err
}
resolveRound := true
for _, p := range players {
if p.Role == Host {
continue
}
turn := TicTacToe_Turn{}
err = db.SelectOne(&turn, "select * from tictactoe_turn where game=? and player=?", gameId, p.Id)
if err != nil {
log.Printf("Couldn't get turn %#v", err)
return err
}
if turn.Move == -1 {
resolveRound = false
}
}
if !resolveRound {
log.Printf("Round cannot be resolved")
return nil // not an error, just nothing to do
}
board, err := getBoard(gameId, db)
if err != nil {
log.Printf("Couldn't get board: %#v", err)
return err
}
// all players have set their moves, update the board
thisRound := []int{0, 0, 0, 0, 0, 0, 0, 0, 0}
for _, p := range players {
if p.Role == Host {
continue
}
turn := TicTacToe_Turn{}
err = db.SelectOne(&turn, "select * from tictactoe_turn where game=? and player=?", gameId, p.Id)
if err != nil {
log.Printf("Couldn't get turn %#v", err)
return err
}
if thisRound[turn.Move] == 0 {
thisRound[turn.Move] = p.Id
} else {
thisRound[turn.Move] = 0 // two players went in the same spot
}
}
niceBoard, err := board.getBoard()
if err != nil {
log.Printf("Error getting board: %#v", err)
return err
}
for i, v := range niceBoard {
if v == 0 {
niceBoard[i] = thisRound[i]
}
}
board.setBoard(niceBoard)
count, err := db.Update(board)
if err != nil || count == 0 {
log.Printf("Unable to save board after move: %v", err)
return err
}
for _, p := range players {
if p.Role == Host {
continue
}
turn := TicTacToe_Turn{}
err = db.SelectOne(&turn, "select * from tictactoe_turn where game=? and player=?", gameId, p.Id)
if err != nil {
log.Printf("Couldn't get turn %#v", err)
return err
}
turn.Move = -1
log.Printf("Resetting player %v turn", p.Id)
count, err := db.Update(&turn)
if count == 0 || err != nil {
log.Printf("Failed to update player turn: %#v -- %#v", err, p.Id)
return err
}
}
gs.Broadcast(gameId, Message{
"type": "update",
"board": niceBoard,
"state": "start",
})
ws.WriteJSON(Message{
"type": "update",
"board": niceBoard,
"state": "start",
})
return nil
}
func PostersGetBySlug(db *gorp.DbMap, slug string) (Poster, error) {
var p Poster
err := db.SelectOne(&p, "select * from Poster where Slug = ?", slug)
return p, err
}
func GetBySlug(db *gorp.DbMap, slug string) (ChangeLog, error) {
var res ChangeLog
err := db.SelectOne(&res, "select * from ChangeLog where Slug = ?", slug)
res.Rate = res.Rate.GetRate(db, 6, res.Id)
return res, err
}
func Get(db *gorp.DbMap, id int64) (ChangeLog, error) {
var res ChangeLog
err := db.SelectOne(&res, "select * from ChangeLog where Id = ?", id)
res.Rate = res.Rate.GetRate(db, 6, res.Id)
return res, err
}