func userInfoHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, p Parameter) { user := &models.Account{} form := p.(getInfoForm) if find, err := user.FindByUserid(form.Userid); !find { if err == nil { err = errors.NewError(errors.NotExistsError) } writeResponse(request.RequestURI, resp, nil, err) return } info := convertUser(user, redis) //info.Pet = userPet(info.Props.Level) info.ScoreRank, _ = user.PropIndex("score", user.Props.Score) if uid := redis.OnlineUser(p.TokenId()); len(uid) > 0 { relation := redis.Relationship(uid, user.Id) switch relation { case models.RelFriend: info.Relation = "FRIENDS" case models.RelFollowing: info.Relation = "ATTENTION" case models.RelFollower: info.Relation = "FANS" case models.RelBlacklist: info.Relation = "DEFRIEND" } } writeResponse(request.RequestURI, resp, info, nil) }
func checkTokenHandler(c martini.Context, p Parameter, redis *models.RedisLogger, r *http.Request, w http.ResponseWriter) { uid := redis.OnlineUser(p.TokenId()) if len(uid) == 0 { writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError)) } fmt.Println("===", p.TokenId(), uid) c.Map(&models.Account{Id: uid}) }
func checkToken(r *models.RedisLogger, t string) (valid bool, err error) { uid := r.OnlineUser(t) if len(uid) == 0 { err = errors.NewError(errors.AccessError) valid = false return } valid = true return }
func articlePostHandler(w http.ResponseWriter, redis *models.RedisLogger, form postForm) { uid := redis.OnlineUser(form.Token) if len(uid) == 0 { writeResponse(w, errors.NewError(errors.AccessError)) return } user := &models.Account{Id: uid} article := &models.Article{ Parent: form.Id, Author: form.Author, PubTime: time.Now(), //Tags: []string{form.Tags}, } switch v := form.Tags.(type) { case string: article.Tags = []string{v} case []string: article.Tags = v } if len(article.Tags) == 0 { article.Tags = []string{"SPORT_LOG"} } if len(form.Author) == 0 { article.Author = user.Id } article.Content = form.Contents article.Title = form.Title article.Images = form.Image if len(article.Images) > 0 { article.Image = article.Images[0] } /* article.Contents = append(article.Contents, models.Segment{ContentType: "TEXT", ContentText: form.Contents}) */ if err := article.Save(); err != nil { writeResponse(w, err) return } writeResponse(w, map[string]string{"article_id": article.Id.Hex()}) }
func taskAuthListHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, form taskAuthListForm) { userid := redis.OnlineUser(form.Token) if len(userid) == 0 { writeResponse(w, errors.NewError(errors.AccessError)) return } pass := make([]bool, len(form.Auths)) for i, _ := range form.Auths { taskAuthFunc(userid, &form.Auths[i], redis) pass[i] = form.Auths[i].Pass } writeResponse(w, map[string][]bool{"pass": pass}) }
func taskAuthHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, form taskAuthForm) { userid := redis.OnlineUser(form.Token) if len(userid) == 0 { writeResponse(w, errors.NewError(errors.AccessError)) return } a := &taskAuth{ Userid: form.Userid, Id: form.Id, Pass: form.Pass, Reason: form.Reason, } if err := taskAuthFunc(userid, a, redis); err != nil { writeResponse(w, err) return } writeResponse(w, map[string]bool{"pass": form.Pass}) }
func wsPushHandler(request *http.Request, resp http.ResponseWriter, redisLogger *models.RedisLogger) { conn, err := upgrader.Upgrade(resp, request, nil) if err != nil { conn.WriteJSON(errors.NewError(errors.HttpError, err.Error())) return } defer conn.Close() r := wsAuthResp{} var auth wsAuth conn.ReadJSON(&auth) //log.Println("check token:", auth.Token) if !checkTokenValid(auth.Token) { //log.Println("check token valid") redisLogger.DelOnlineUser(auth.Token) conn.WriteJSON(r) return } uid := redisLogger.OnlineUser(auth.Token) user := &models.Account{} if find, _ := user.FindByUserid(uid); !find || user.TimeLimit < 0 { r.TimeLimit = user.TimeLimit conn.WriteJSON(r) return } //redisLogger.LogLogin(user.Id) days := user.LoginDays loginCount := user.LoginCount + 1 d := nowDate() if user.LastLogin.Unix() < d.Unix() { // check wether first time login of one day days++ if user.LastLogin.Unix() < d.Unix()-24*3600 { days = 1 } loginCount = 1 } //fmt.Println(uid, "loginCount", loginCount) user.SetLastLogin(days, loginCount, time.Now()) r.Userid = uid r.LastLog = user.LastLogin.Unix() r.LoginCount = loginCount if err := conn.WriteJSON(r); err != nil { return } if len(uid) == 0 { return } redisLogger.LogVisitor(user.Id) psc := redisLogger.PubSub(user.Id) go func(conn *websocket.Conn) { //wg.Add(1) //defer log.Println("ws thread closed") //defer wg.Done() redisLogger.SetOnline(user.Id, user.Actor, true, 0) start := time.Now() defer psc.Close() for { event := &models.Event{} err := conn.ReadJSON(event) if err != nil { //log.Println(err) dur := int64(time.Since(start) / time.Second) redisLogger.SetOnline(user.Id, user.Actor, false, dur) user.UpdateStat(models.StatOnlineTime, dur) return } //log.Println("recv msg:", event.Type) switch event.Type { case models.EventMsg: m := &models.Message{ From: event.Data.From, To: event.Data.To, Body: event.Data.Body, Time: time.Now(), } if event.Data.Type == models.EventChat || event.Data.Type == models.EventGChat { m.Type = event.Data.Type m.Save() event.Data.Id = m.Id.Hex() event.Time = m.Time.Unix() redisLogger.PubMsg(m.Type, m.To, event.Bytes()) } case models.EventStatus: //fmt.Println(user.Id, event.Data.Body) switch event.Data.Type { case "loc": var lat, lng float64 var locaddr string for _, body := range event.Data.Body { switch body.Type { case "latlng": //log.Println("latlng:", body.Content) loc := strings.Split(body.Content, ",") if len(loc) != 2 { break } lat, _ = strconv.ParseFloat(loc[0], 64) lng, _ = strconv.ParseFloat(loc[1], 64) case "locaddr": //log.Println("locaddr:", body.Content) locaddr = body.Content } } user.UpdateLocation(models.Location{Lat: lat, Lng: lng}, locaddr) case "device": for _, body := range event.Data.Body { switch body.Type { case "token": token := body.Content //log.Println("device token:", token) user.AddDevice(token) } } } default: log.Println("unhandled message type:", event.Type) } } }(conn) for { switch v := psc.Receive().(type) { case redis.Message: //log.Printf("%s: message: %s\n", v.Channel, v.Data) event := &models.Event{} if err := json.Unmarshal(v.Data, event); err != nil { log.Println("parse push message error:", err) continue } // subscribe group if event.Data.Type == models.EventSub && event.Data.From == user.Id { if err := redisLogger.Subscribe(psc, event.Data.To); err != nil { log.Println(err) } continue } // unsubscribe group if event.Data.Type == models.EventUnsub && event.Data.From == user.Id { if err := redisLogger.Unsubscribe(psc, event.Data.To); err != nil { log.Println(err) } continue } if err := conn.WriteMessage(websocket.TextMessage, v.Data); err != nil { log.Println(err) return } case redis.Subscription: //log.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count) case error: //log.Println(v) return } } }
func fileUploadHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger /*, user *models.Account*/, form fileUploadForm) { user := &models.Account{} if len(form.Token) > 0 { id := redis.OnlineUser(form.Token) if find, _ := user.FindByUserid(id); !find { writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.NotFoundError)) return } } var file models.File filedata, header, err := request.FormFile("filedata") if err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileNotFoundError)) return } if form.Width > 0 || form.Height > 0 { img, _, err := image.Decode(filedata) if err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.InvalidFileError)) return } fid, err := Weedfs.Master().AssignN(2) if err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileUploadError)) return } file.Fid = fid thumbnail := resize.Thumbnail(uint(form.Width), uint(form.Height), img, resize.MitchellNetravali) vol, err := Weedfs.Volume(fid, "") if err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileUploadError)) return } buf := &bytes.Buffer{} if err := jpeg.Encode(buf, thumbnail, nil); err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileUploadError)) return } length, err := vol.Upload(fid, 0, header.Filename, "image/jpeg", buf) if err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileUploadError)) return } file.Length = length filedata.Seek(0, 0) if _, err := vol.Upload(fid, 1, header.Filename, header.Header.Get("Content-Type"), filedata); err != nil { log.Println(err) writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileUploadError)) return } } else { fid, length, err := Weedfs.Master().Submit(header.Filename, header.Header.Get("Content-Type"), filedata) if err != nil { writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.FileUploadError)) return } //log.Println(fid, length, header.Filename, header.Header.Get("Content-Type")) file.Fid = fid file.Length = length } filedata.Seek(0, 0) file.Name = header.Filename file.ContentType = header.Header.Get("Content-Type") file.Md5 = FileMd5(filedata) file.Owner = user.Id file.UploadDate = time.Now() if err := file.Save(); err != nil { writeResponse(request.RequestURI, resp, nil, err) return } url, _, _ := Weedfs.GetUrl(file.Fid) respData := map[string]interface{}{"fileid": file.Fid, "fileurl": url} writeResponse(request.RequestURI, resp, respData, nil) }