func articleNewsHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, user *models.Account, p Parameter) { form := p.(articleNewsForm) followings := redis.Friends(models.RelFollowing, user.Id) //followings = append(followings, user.Id) // self included //fmt.Println(followings) count, err := models.NewArticles(followings, form.Id) writeResponse(r.RequestURI, w, bson.M{"count": count}, err) }
func adminLoginHandler(w http.ResponseWriter, redis *models.RedisLogger, form jsgenLoginForm) { user := &models.Account{} log.Println(form.Username, form.Password) h := md5.New() io.WriteString(h, form.Password) pwd := fmt.Sprintf("%x", h.Sum(nil)) find := false var err error if find, err = user.FindByUserPass(strings.ToLower(form.Username), pwd); !find { if err == nil { err = AuthError } else { err = DbError } } if err != nil { writeResponse(w, false, nil, nil, err) return } redis.LogLogin(user.Id) info := &User{ Id: user.Id, Name: user.Nickname, Nickname: user.Nickname, Email: "", Locked: user.TimeLimit != 0, Social: social{}, Sex: user.Gender, Role: 1, Avatar: user.Profile, Desc: user.About, Date: user.RegTime.Unix() * 1000, Score: user.Score, ReadTime: 0, LastLogin: user.LastLogin.Unix() * 1000, FollowList: redis.Friends(models.RelFollowing, user.Id), TagsList: []string{}, Articles: user.ArticleCount(), Collections: 0, MarkList: []int{}, Unread: []string{}, ReceiveList: []string{}, SendList: []string{}, } info.Follow, info.Fans, _, _ = redis.FriendCount(user.Id) writeResponse(w, true, info, nil, nil) }
func taskReferralsHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, user *models.Account) { if user.Taskid > len(models.NewTasks) { writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError)) return } task := models.NewTasks[user.Taskid] excludes := redis.TaskSharers() friends := redis.Friends(models.RelFriend, user.Id) excludes = append(excludes, user.Id) excludes = append(excludes, friends...) users, _ := user.TaskReferrals(task.Type, excludes) var referrals []*referral for i, _ := range users { ref := &referral{ Userid: users[i].Id, Nickname: users[i].Nickname, Profile: users[i].Profile, Gender: users[i].Gender, Images: users[i].Photos, Birthday: users[i].Birth, Lastlog: users[i].LastLogin.Unix(), Location: users[i].Loc, } if users[i].Ratios.RunRecv > 0 { ref.RunRatio = float32(users[i].Ratios.RunAccept) / float32(users[i].Ratios.RunRecv) } if users[i].Ratios.PostRecv > 0 { ref.PostRatio = float32(users[i].Ratios.PostAccept) / float32(users[i].Ratios.PostRecv) } if users[i].Ratios.PKRecv > 0 { ref.PkRatio = float32(users[i].Ratios.PKAccept) / float32(users[i].Ratios.PKRecv) } if task.Type == models.TaskRunning || task.Type == models.TaskGame { rec, _ := users[i].LastRecord("run") ref.LastId = rec.Id.Hex() ref.LastTime = rec.PubTime.Unix() } else if task.Type == models.TaskPost { article := users[i].LatestArticle() ref.LastId = article.Id.Hex() ref.LastTime = article.PubTime.Unix() } referrals = append(referrals, ref) } respData := map[string]interface{}{"referrals": referrals} writeResponse(r.RequestURI, w, respData, nil) }
func socialListHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, form socialListForm) { user := &models.Account{Id: form.Userid} var ids []string switch form.Type { case "FRIENDS": ids = redis.Friends(models.RelFriend, user.Id) case "ATTENTION": ids = redis.Friends(models.RelFollowing, user.Id) case "FANS": ids = redis.Friends(models.RelFollower, user.Id) case "DEFRIEND": ids = redis.Friends(models.RelBlacklist, user.Id) case "WEIBO": ids = redis.Friends("weibo", user.Id) } users, err := models.Users(ids, &form.Paging) if err != nil { writeResponse(request.RequestURI, resp, nil, err) return } lb := make([]leaderboardResp, len(users)) for i, _ := range users { lb[i].Userid = users[i].Id lb[i].Score = users[i].Props.Score lb[i].Level = users[i].Level() lb[i].Profile = users[i].Profile lb[i].Nickname = users[i].Nickname lb[i].Gender = users[i].Gender lb[i].LastLog = users[i].LastLogin.Unix() lb[i].Birth = users[i].Birth lb[i].Location = users[i].Loc lb[i].Phone = users[i].Phone lb[i].Actor = users[i].Actor } respData := map[string]interface{}{ "members_list": lb, "page_frist_id": form.Paging.First, "page_last_id": form.Paging.Last, } writeResponse(request.RequestURI, resp, respData, nil) return }
func recommendHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, user *models.Account, p Parameter) { form := p.(recommendForm) excludes := redis.Friends(models.RelFollowing, user.Id) excludes = append(excludes, redis.Friends(models.RelBlacklist, user.Id)...) users, _ := user.Recommend(excludes) var list []*leaderboardResp for i, _ := range users { if users[i].Id == user.Id { continue } rel := redis.Relationship(user.Id, users[i].Id) if rel == models.RelFollowing || rel == models.RelFriend { continue } lb := &leaderboardResp{ Userid: users[i].Id, Score: users[i].Props.Score, Level: users[i].Level(), Profile: users[i].Profile, Nickname: users[i].Nickname, Gender: users[i].Gender, LastLog: users[i].LastLogin.Unix(), Birth: users[i].Birth, Location: users[i].Loc, Addr: users[i].LocAddr, Phone: users[i].Phone, Actor: users[i].Actor, } lb.Distance, _ = redis.RecStats(users[i].Id) lb.Status = users[i].LatestArticle().Title list = append(list, lb) } respData := map[string]interface{}{ "members_list": list, "page_frist_id": form.Paging.First, "page_last_id": form.Paging.Last, } writeResponse(r.RequestURI, w, respData, nil) }
func importContactsHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, user *models.Account, p Parameter) { form := p.(importContactsForm) var result []*userJsonStruct users, _ := models.FindUsersByPhones(form.Contacts) ids := redis.Friends(models.RelFollowing, user.Id) for j, _ := range users { i := 0 for ; i < len(ids); i++ { if users[j].Id == ids[i] || users[j].Id == user.Id { break } } if i >= len(ids) { result = append(result, convertUser(&users[j], redis)) } } writeResponse(r.RequestURI, w, map[string]interface{}{"users": result}, nil) }
func articleListHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, user *models.Account, p Parameter) { var articles []models.Article var err error form := p.(articleListForm) if len(form.Tag) > 0 { _, articles, err = models.GetArticles(form.Tag, &form.Paging, true) } else if form.Circle { followings := redis.Friends(models.RelFollowing, user.Id) followings = append(followings, user.Id) // self included _, articles, err = models.GetFollowingsArticles(followings, &form.Paging) } else { excludes := redis.Friends(models.RelFollowing, user.Id) excludes = append(excludes, redis.Friends(models.RelBlacklist, user.Id)...) excludes = append(excludes, user.Id) recommends, _ := user.Recommend(excludes) ids := []string{} for i, _ := range recommends { ids = append(ids, recommends[i].Id) } _, articles, err = models.GetRecommendArticles(ids, &form.Paging) } jsonStructs := make([]*articleJsonStruct, len(articles)) for i, _ := range articles { u := &models.Account{} u.FindByUserid(articles[i].Author) author := convertUser(u, redis) jsonStructs[i] = convertArticle(user, &articles[i], author) } respData := make(map[string]interface{}) respData["page_frist_id"] = form.Paging.First respData["page_last_id"] = form.Paging.Last //respData["page_item_count"] = total respData["articles_without_content"] = jsonStructs writeResponse(request.RequestURI, resp, respData, err) }
func gamelbHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, user *models.Account, p Parameter) { form := p.(gamelbForm) if form.Index <= 0 { form.Index = 0 } if form.Count <= 0 { form.Count = 20 } gt := gameType(form.Game) var ids []string var kvs []models.KV switch form.Query { case "FRIEND": ids = redis.Friends(models.RelFriend, user.Id) if len(ids) == 0 { break } ids = append(ids, user.Id) if form.Index*form.Count >= len(ids) { break } start := form.Index * form.Count end := start + form.Count if end > len(ids) { end = len(ids) } scores := redis.UserGameScores(gt, ids...) if len(scores) != len(ids) { scores = make([]int64, len(ids)) } kvs = make([]models.KV, len(ids)) for i, _ := range kvs { kvs[i].K = ids[i] kvs[i].V = scores[i] if ids[i] == user.Id { kvs[i].V = int64(form.Score) } } sort.Sort(sort.Reverse(models.KVSlice(kvs))) kvs = kvs[start:end] ids = []string{} for _, kv := range kvs { ids = append(ids, kv.K) } case "TOP": fallthrough default: maxScore := 0 if scores := redis.UserGameScores(gt, user.Id); len(scores) == 1 { maxScore = int(scores[0]) } redis.SetGameScore(gt, user.Id, form.Score) // current score kvs = redis.GameScores(gt, form.Index*form.Count, form.Count) redis.SetGameScore(gt, user.Id, maxScore) // recover max score for i, kv := range kvs { ids = append(ids, kv.K) if kv.K == user.Id { kvs[i].V = int64(form.Score) } } } var respData struct { List []*leaderboardResp `json:"members_list"` } users, _ := models.FindUsersByIds(1, ids...) index := 0 for _, kv := range kvs { for i, _ := range users { if users[i].Id == kv.K { respData.List = append(respData.List, &leaderboardResp{ Userid: users[i].Id, Score: kv.V, Rank: form.Index*form.Count + index + 1, Level: users[i].Level(), Profile: users[i].Profile, Nickname: users[i].Nickname, Actor: users[i].Actor, Gender: users[i].Gender, LastLog: users[i].LastGameTime(gt).Unix(), Birth: users[i].Birth, Location: users[i].Loc, Phone: users[i].Phone, }) index++ break } } } writeResponse(r.RequestURI, w, respData, nil) }
func leaderboardHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, user *models.Account, form leaderboardForm) { if form.Paging.Count == 0 { form.Paging.Count = models.DefaultPageSize } start := 0 stop := 0 switch form.Type { case "FRIEND": ids := redis.Friends("friend", user.Id) friends, err := models.Users(ids, &form.Paging) if err != nil { writeResponse(request.RequestURI, resp, nil, err) return } lb := make([]leaderboardResp, len(friends)) for i, _ := range friends { lb[i].Userid = friends[i].Id lb[i].Score = friends[i].Props.Score lb[i].Level = friends[i].Level() lb[i].Profile = friends[i].Profile lb[i].Nickname = friends[i].Nickname lb[i].Gender = friends[i].Gender lb[i].Actor = friends[i].Actor lb[i].LastLog = friends[i].LastLogin.Unix() lb[i].Birth = friends[i].Birth lb[i].Location = friends[i].Loc lb[i].Phone = friends[i].Phone } respData := map[string]interface{}{ "members_list": lb, "page_frist_id": form.Paging.First, "page_last_id": form.Paging.Last, } writeResponse(request.RequestURI, resp, respData, nil) return case "USER_AROUND": rank := redis.LBDisRank(form.Info) if rank < 0 { writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.NotExistsError, "user not exist")) return } if form.Paging.Count < 0 { start = rank stop = rank break } start = rank - form.Paging.Count if start < 0 { start = 0 } stop = rank + form.Paging.Count case "TOP": fallthrough default: start, stop = leaderboardPaging(&form.Paging) } kv := redis.GetDisLB(start, stop) ids := make([]string, len(kv)) for i, _ := range kv { ids[i] = kv[i].K } users, _ := models.FindUsersByIds(0, ids...) lb := make([]leaderboardResp, len(kv)) for i, _ := range kv { lb[i].Userid = kv[i].K lb[i].Rank = start + i + 1 lb[i].Score = kv[i].V for _, user := range users { if user.Id == kv[i].K { lb[i].Nickname = user.Nickname lb[i].Profile = user.Profile break } } } page_first := 0 page_last := 0 if len(lb) > 0 { page_first = lb[0].Rank page_last = lb[len(lb)-1].Rank } respData := map[string]interface{}{ "members_list": lb, "page_frist_id": strconv.Itoa(page_first), "page_last_id": strconv.Itoa(page_last), } writeResponse(request.RequestURI, resp, respData, nil) }
func getFollowersHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, user *models.Account) { writeResponse(request.RequestURI, resp, redis.Friends(models.RelFollower, user.Id), nil) }
func gameResultHandler(r *http.Request, w http.ResponseWriter, redis *models.RedisLogger, user *models.Account, p Parameter) { form := p.(gameResultForm) var respData struct { Total []*leaderboardResp `json:"total_list"` Friends []*leaderboardResp `json:"friends_list"` Score int `json:"total_score"` Percent int `json:"percent"` PerFriend int `json:"percentFri"` } if form.Count == 0 { form.Count = 3 } gt := gameType(form.Type) if scores := redis.UserGameScores(gt, user.Id); len(scores) == 1 { respData.Score = int(scores[0]) } redis.SetGameScore(gt, user.Id, form.Score) // current score kvs := redis.GameScores(gt, 0, form.Count) var ids []string for _, kv := range kvs { ids = append(ids, kv.K) } ranks := redis.UserGameRanks(gt, user.Id) redis.SetGameScore(gt, user.Id, respData.Score) // recover max score n := redis.GameUserCount(gt) - 1 //log.Println(ranks, n) if len(ranks) == 1 && n > 0 && form.Score > 0 { respData.Percent = int(float64(n-ranks[0]) / float64(n) * 100.0) } //log.Println(ids) users, _ := models.FindUsersByIds(1, ids...) index := 0 for _, kv := range kvs { for i, _ := range users { if users[i].Id == kv.K { respData.Total = append(respData.Total, &leaderboardResp{ Userid: users[i].Id, Score: kv.V, Rank: index + 1, Level: users[i].Level(), Profile: users[i].Profile, Nickname: users[i].Nickname, Gender: users[i].Gender, LastLog: users[i].LastGameTime(gt).Unix(), Birth: users[i].Birth, Location: users[i].Loc, Phone: users[i].Phone, Actor: users[i].Actor, }) index++ break } } } ids = redis.Friends(models.RelFriend, user.Id) if len(ids) > 0 { total := len(ids) ids = append(ids, user.Id) scores := redis.UserGameScores(gt, ids...) if len(scores) != len(ids) { scores = make([]int64, total) } kvs = make([]models.KV, total+1) for i, _ := range ids { kvs[i].K = ids[i] kvs[i].V = scores[i] if ids[i] == user.Id { kvs[i].V = int64(form.Score) } } sort.Sort(sort.Reverse(models.KVSlice(kvs))) lb := kvs if len(kvs) > 3 { kvs = kvs[0:3] } ids = []string{} for _, kv := range kvs { ids = append(ids, kv.K) } users, _ = models.FindUsersByIds(1, ids...) index := 0 rank := 0 for i, _ := range lb { if lb[i].K == user.Id { rank = i break } } for _, kv := range kvs { for i, _ := range users { if users[i].Id == kv.K { respData.Friends = append(respData.Friends, &leaderboardResp{ Userid: users[i].Id, Score: kv.V, Rank: index + 1, Level: users[i].Level(), Profile: users[i].Profile, Nickname: users[i].Nickname, Gender: users[i].Gender, LastLog: users[i].LastGameTime(gt).Unix(), Birth: users[i].Birth, Location: users[i].Loc, Phone: users[i].Phone, Actor: users[i].Actor, }) index++ break } } } if total > 0 { respData.PerFriend = int(float64(total-rank) / float64(total) * 100.0) } } writeResponse(r.RequestURI, w, respData, nil) }