Beispiel #1
0
func loginHandlerV2(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, form loginFormV2) {
	user := &models.Account{}
	if exists, _ := models.CheckUserExists(form.Id, form.Type); !exists {
		writeResponse(request.RequestURI, resp,
			nil, errors.NewError(errors.AuthError, "该用户还未注册"))
		return
	}
	user.FindPass(form.Id, form.Type, Md5(form.Password))
	if len(user.Id) == 0 {
		writeResponse(request.RequestURI, resp,
			nil, errors.NewError(errors.AuthError))
		return
	}

	if user.TimeLimit < 0 {
		writeResponse(request.RequestURI, resp,
			nil, errors.NewError(errors.AuthError, "账户已禁用"))
		return
	}

	token := Uuid() + "-" + strconv.FormatInt(time.Now().AddDate(0, 0, 30).Unix(), 10)
	redis.SetOnlineUser(token, user.Id)

	data := map[string]interface{}{
		"access_token": token,
		"userid":       user.Id,
		//"last_login_time": user.LastLogin.Unix(),
	}
	writeResponse(request.RequestURI, resp, data, nil)
}
Beispiel #2
0
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)
}
Beispiel #3
0
func setGroupHandler(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {

	form := p.(setGroupForm)

	group := &models.Group{
		Gid:     form.Id,
		Name:    form.Name,
		Profile: form.Profile,
		Desc:    form.Desc,
		Creator: user.Id,
		Time:    time.Now(),
	}

	if form.Address.String() != "" {
		group.Addr = &form.Address
		loc := models.Addr2Loc(form.Address)
		group.Loc = &loc
	}

	var err error
	if len(form.Id) == 0 {
		err = group.Save()
		if err == nil {
			redis.JoinGroup(user.Id, group.Gid, true)
		}
	} else {
		err = group.Update()
	}

	writeResponse(request.RequestURI, resp, map[string]string{"group_id": group.Gid}, err)
}
Beispiel #4
0
func regHandlerV2(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, form regFormV2) {

	exists, err := models.CheckUserExists(form.Id, form.Type)
	if err != nil {
		writeResponse(request.RequestURI, resp,
			nil, errors.NewError(errors.DbError))
		return
	}
	if exists {
		writeResponse(request.RequestURI, resp,
			nil, errors.NewError(errors.UserExistError))
		return
	}

	dbw, err := getNewWallet()
	if err != nil {
		writeResponse(request.RequestURI, resp,
			nil, errors.NewError(errors.DbError, "创建钱包失败"))
		return
	}

	user := &models.Account{
		Role:     form.Type,
		Password: Md5(form.Password),
		Nickname: form.Nickname,
		Profile:  form.Profile,
		Gender:   form.Gender,
		Birth:    form.Birthday,
		Wallet:   *dbw,
		RegTime:  time.Now(),
	}

	switch form.Type {
	case models.AccountPhone:
		user.Phone = form.Id
	case models.AccountWeibo:
		user.Weibo = form.Id
	case models.AccountEmail:
		fallthrough
	default:
		user.Email = form.Id
	}

	if err := user.Save(); err != nil {
		writeResponse(request.RequestURI, resp, nil, err)
		return
	}

	token := Uuid() + "-" + strconv.FormatInt(time.Now().AddDate(0, 0, 30).Unix(), 10)
	data := map[string]string{"access_token": token, "userid": user.Id}
	writeResponse(request.RequestURI, resp, data, nil)

	redis.LogRegister(user.Id, form.Type)
	redis.SetOnlineUser(token, user.Id)

	// ws push
	//regNotice(user.Id, redis)
}
Beispiel #5
0
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})
}
Beispiel #6
0
func blacklistHandler(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {
	form := p.(relationshipForm)

	redis.SetRelationship(user.Id, form.Userids, models.RelBlacklist, form.Blacklist)

	writeResponse(request.RequestURI, resp, map[string]interface{}{"ExpEffect": Awards{}}, nil)
}
Beispiel #7
0
/*
func (this loginForm) getUserId() string {
	return this.Userid
}
*/
func weiboLogin(uid, password string, redis *models.RedisLogger) (bool, *models.Account, error) {
	user := &models.Account{}
	exists, err := user.FindByWeibo(strings.ToLower(uid))
	if err != nil {
		return false, nil, err
	}

	p := Md5(password)
	registered := user.RegTime.Unix() > 0

	if registered {
		if user.Password != p {
			user.SetPassword(p)
		}
		return false, user, nil
	}
	weiboUser, err := GetWeiboUserInfo(uid, password)
	if err != nil {
		return false, nil, err
	}

	user.Nickname = weiboUser.ScreenName
	if find, _ := user.Exists("nickname"); find {
		user.Nickname = "wb_" + user.Nickname
	}
	user.Password = p
	if !strings.HasPrefix(weiboUser.Gender, "f") {
		user.Gender = "male"
	} else {
		user.Gender = "female"
	}

	user.Weibo = uid
	user.Url = weiboUser.Url
	user.Profile = weiboUser.Avatar
	//user.Addr = &models.Address{Desc: weiboUser.Location}
	user.About = weiboUser.Description
	user.Role = models.AccountWeibo
	user.RegTime = time.Now()

	dbw, err := getNewWallet()
	if err != nil {
		return true, nil, err
	}
	user.Wallet = *dbw

	if !exists {
		if err := user.Save(); err != nil {
			return true, nil, err
		}
	}
	redis.LogRegister(user.Id, user.Role)

	// ws push
	regNotice(user.Id, redis)

	return true, user, nil
}
Beispiel #8
0
func userAuthRequestHandler(r *http.Request, w http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {

	form := p.(authRequestForm)
	err := user.SetAuthInfo(form.Type, form.Images, form.Desc)
	redis.AddAuthCoach(user.Id)

	writeResponse(r.RequestURI, w, nil, err)
}
Beispiel #9
0
func logoutHandler(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {
	redis.DelOnlineUser(p.TokenId())
	if len(user.Devs) > 0 {
		user.RmDevice(user.Devs[0])
	}
	writeResponse(request.RequestURI, resp, nil, nil)

}
Beispiel #10
0
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
}
Beispiel #11
0
func friendCountHandler(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account) {
	follows, followers, friends, blacklist := redis.FriendCount(user.Id)
	respData := map[string]int{
		"friend_count":    friends,
		"attention_count": follows,
		"fans_count":      followers,
		"defriend_count":  blacklist,
	}
	writeResponse(request.RequestURI, resp, respData, nil)
}
Beispiel #12
0
func getQiniuTokenHandler(r *http.Request, w http.ResponseWriter,
	redis *models.RedisLogger) {
	token := redis.GetQiniuUpToken()
	//log.Println(token)
	if len(token) == 0 {
		token = uptoken("test")
		redis.SetQiniuUpToken(token)
	}

	writeResponse(r.RequestURI, w, map[string]string{"token": token}, nil)
}
Beispiel #13
0
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)
}
Beispiel #14
0
func retentionHandler(w http.ResponseWriter, redis *models.RedisLogger, form retentionForm) {
	if ok, err := checkToken(redis, form.Token); !ok {
		writeResponse(w, err)
		return
	}

	date := time.Now()
	if form.Date > 0 {
		date = time.Unix(form.Date, 0)
	}
	r := redis.Retention(date)
	writeResponse(w, map[string]interface{}{"retention": r})
}
Beispiel #15
0
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)
}
Beispiel #16
0
func regNotice(uid string, redis *models.RedisLogger) {
	notice := &models.Event{
		Type: models.EventWallet,
		Time: time.Now().Unix(),
		Data: models.EventData{
			Type: models.EventTx,
			Id:   uid,
			From: uid,
			Body: []models.MsgBody{
				{Type: "rule", Content: "1"},
			},
		},
	}
	redis.Notice(notice.Bytes())
}
Beispiel #17
0
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
}
Beispiel #18
0
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()})
}
Beispiel #19
0
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})
}
Beispiel #20
0
func loginHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, form loginForm) {
	user := &models.Account{}
	var err error
	var reg bool
	token := Uuid() + "-" + strconv.FormatInt(time.Now().AddDate(0, 0, 30).Unix(), 10)

	switch form.Type {
	case "weibo":
		reg, user, err = weiboLogin(form.Userid, form.Password, redis)
	case "weixin":
		writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.UnimplementedError))
		return
	case "usrpass":
		fallthrough
	default:
		var find bool
		if find, err = user.FindByUserPass(strings.ToLower(form.Userid), Md5(form.Password)); !find {
			if err == nil {
				err = errors.NewError(errors.AuthError)
			}
		}
	}

	if err != nil {
		writeResponse(request.RequestURI, resp, nil, err)
		return
	}

	if user.TimeLimit < 0 {
		writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.AuthError, "账户已禁用"))
		return
	}

	redis.SetOnlineUser(token, user.Id)

	data := map[string]interface{}{
		"access_token":    token,
		"userid":          user.Id,
		"register":        reg,
		"last_login_time": user.LastLogin.Unix(),
		"ExpEffect":       Awards{},
	}
	writeResponse(request.RequestURI, resp, data, nil)
}
Beispiel #21
0
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})
}
Beispiel #22
0
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)
}
Beispiel #23
0
func recvHeartHandler(r *http.Request, w http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {

	form := p.(recvHeartForm)

	// ws push
	event := &models.Event{
		Type: models.EventSystem,
		Time: time.Now().Unix(),
		Data: models.EventData{
			Type: models.EventRecvHeart,
			Id:   user.Id,
			From: user.Id,
			To:   form.Sender,
			Body: []models.MsgBody{
				{Type: "userid", Content: user.Id},
			},
		},
	}

	awards := Awards{}
	if form.Accept {
		redis.SetRelationship(user.Id, []string{form.Sender}, models.RelFriend, true)
		event.Save()
		redis.PubMsg(models.EventSystem, form.Sender, event.Bytes())
		awards.Wealth = 1 * models.Satoshi
		GiveAwards(user, awards, redis)
	}
	redis.SetHeartRecv(user.Id, false)
	writeResponse(r.RequestURI, w, map[string]interface{}{"ExpEffect": awards}, nil)
}
Beispiel #24
0
func registerHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger, form userRegForm) {
	user := &models.Account{}
	t := ""
	if phone, _ := strconv.ParseUint(form.Email, 10, 64); phone > 0 {
		user.Phone = form.Email
		t = models.AccountPhone
	} else {
		user.Email = strings.ToLower(form.Email)
		t = models.AccountEmail
	}

	if exists, _ := user.Exists(t); exists {
		writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.UserExistError))
		return
	}
	//user.Nickname = form.Nickname
	user.Password = Md5(form.Password)
	user.Role = t
	user.RegTime = time.Now()
	dbw, err := getNewWallet()
	if err != nil {
		writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.DbError, "wallet: "+err.Error()))
		return
	}
	user.Wallet = *dbw

	if err := user.Save(); err != nil {
		writeResponse(request.RequestURI, resp, nil, err)
	} else {
		token := Uuid() + "-" + strconv.FormatInt(time.Now().AddDate(0, 0, 30).Unix(), 10)
		data := map[string]string{"access_token": token, "userid": user.Id}
		writeResponse(request.RequestURI, resp, data, nil)

		redis.LogRegister(user.Id, t)
		redis.SetOnlineUser(token, user.Id)

		// ws push
		regNotice(user.Id, redis)
	}
}
Beispiel #25
0
func joinGroupHandler(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {

	form := p.(joinGroupForm)

	redis.JoinGroup(user.Id, form.Gid, !form.Leave)
	writeResponse(request.RequestURI, resp, nil, nil)

	event := &models.Event{
		Type: "message",
		Data: models.EventData{
			From: user.Id,
			To:   form.Gid,
		},
	}
	if !form.Leave {
		event.Data.Type = "subscribe"
	} else {
		event.Data.Type = "unsubscribe"
	}

	redis.PubMsg(event.Data.Type, user.Id, event.Bytes())
}
Beispiel #26
0
func articleInfoHandler(request *http.Request, resp http.ResponseWriter,
	redis *models.RedisLogger, user *models.Account, p Parameter) {
	form := p.(articleInfoForm)
	article := &models.Article{}
	if find, err := article.FindById(form.Id); !find {
		if err == nil {
			err = errors.NewError(errors.NotExistsError)
		}
		writeResponse(request.RequestURI, resp, nil, err)
		return
	}

	event := &models.Event{}
	//event.Data.Type = models.EventThumb
	event.Data.Id = article.Id.Hex()
	event.Data.To = user.Id
	event.Clear() // clear all events about this article

	u := &models.Account{}
	u.FindByUserid(article.Author)
	author := convertUser(u, redis)
	jsonStruct := convertArticle(user, article, author)

	jsonStruct.Relation = redis.Relationship(user.Id, article.Author)
	switch jsonStruct.Relation {
	case models.RelFriend:
		jsonStruct.Relation = "FRIENDS"
	case models.RelFollowing:
		jsonStruct.Relation = "ATTENTION"
	case models.RelFollower:
		jsonStruct.Relation = "FANS"
	case models.RelBlacklist:
		jsonStruct.Relation = "DEFRIEND"
	}

	writeResponse(request.RequestURI, resp, jsonStruct, nil)
}
Beispiel #27
0
func GiveAwards(user *models.Account, awards Awards, redis *models.RedisLogger) error {
	if awards.Level < 0 || awards.Score < 0 {
		panic("invalid level or score")
	}
	if _, err := sendCoin(user.Wallet.Addr, awards.Wealth); err != nil {
		return err
	}
	redis.SendCoins(user.Id, awards.Wealth)

	err := user.UpdateProps(models.Props{
		Physical: awards.Physical,
		Literal:  awards.Literal,
		Mental:   awards.Mental,
		//Wealth:   awards.Wealth,
		Score: awards.Score,
		//Level: awards.Level,
	})
	if err != nil {
		return err
	}

	if lvl := models.Score2Level(user.Props.Score + awards.Score); lvl > user.Level() {
		// ws push
		event := &models.Event{
			Type: models.EventNotice,
			Time: time.Now().Unix(),
			Data: models.EventData{
				Type: models.EventLevelUP,
				To:   user.Id,
			},
		}
		event.Save()
		redis.PubMsg(event.Type, event.Data.To, event.Bytes())
	}

	return nil
}
Beispiel #28
0
func followHandler(request *http.Request, resp http.ResponseWriter,
	client *ApnClient, redis *models.RedisLogger, user *models.Account, p Parameter) {

	form := p.(relationshipForm)

	for _, peer := range form.Userids {
		if redis.Relationship(peer, user.Id) == models.RelBlacklist {
			writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.DbError, "对方已屏蔽了你!"))
			return
		}
	}

	redis.SetRelationship(user.Id, form.Userids, models.RelFollowing, form.Follow)
	writeResponse(request.RequestURI, resp, map[string]interface{}{"ExpEffect": Awards{}}, nil)

	for _, userid := range form.Userids {
		u := &models.Account{}
		u.FindByUserid(userid)

		event := &models.Event{
			Type: models.EventMsg,
			Time: time.Now().Unix(),
			Data: models.EventData{
				Type: models.EventSub,
				Id:   user.Id + "-" + u.Id,
				From: user.Id,
				To:   u.Id,
				Body: []models.MsgBody{
					{Type: "nikename", Content: user.Nickname},
					{Type: "image", Content: user.Profile},
				},
			},
		}

		if form.Follow {
			/*
				if err := event.Save(); err == nil {
					redis.IncrEventCount(u.Id, event.Data.Type, 1)
				}
			*/
			event.Upsert()

			event.Data.Body = append(event.Data.Body,
				models.MsgBody{Type: "new_count", Content: "1"})
			redis.PubMsg(models.EventMsg, u.Id, event.Bytes())

			// apple push
			if u.Push {
				go sendApn(client, user.Nickname+"关注了你!", u.EventCount("", ""), u.Devs...)
			}
		} else {
			//count := u.DelEvent(models.EventSub, user.Id, user.Id, u.Id)
			//redis.IncrEventCount(u.Id, models.EventSub, -count)
			event.Delete()
		}
	}
}
Beispiel #29
0
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)
}
Beispiel #30
0
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)
}