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)
}
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()
}
}
}
func sendHeartHandler(r *http.Request, w http.ResponseWriter,
redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(sendHeartForm)
receivers := redis.HeartReceivers(user.Id)
if len(receivers) == 0 {
writeResponse(r.RequestURI, w, nil, nil)
}
var target string
for _, recv := range receivers {
if recv != user.Id {
target = recv
break
}
}
// ws push
event := &models.Event{
Type: models.EventSystem,
Time: time.Now().Unix(),
Data: models.EventData{
Type: models.EventSendHeart,
Id: user.Id,
From: user.Id,
To: target,
Body: []models.MsgBody{
{Type: "record_id", Content: form.Record},
{Type: "userid", Content: user.Id},
},
},
}
if len(target) > 0 {
event.Save()
redis.PubMsg(models.EventSystem, target, event.Bytes())
redis.LogHeartSend(user.Id)
redis.SetHeartRecv(target, true)
}
writeResponse(r.RequestURI, w, nil, nil)
}
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())
}
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
}
func taskSharedHandler(r *http.Request, w http.ResponseWriter,
redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(taskSharedForm)
u := &models.Account{}
u.FindByUserid(form.Sender)
// ws push
event := &models.Event{
Type: models.EventSystem,
Time: time.Now().Unix(),
Data: models.EventData{
Id: user.Id,
From: user.Id,
To: form.Sender,
},
}
var article *models.Article
switch form.Type {
case models.TaskRunning:
event.Data.Type = models.EventRunShared
article = &models.Article{
Author: user.Id,
PubTime: time.Now(),
Contents: []models.Segment{
{ContentType: "TEXT", ContentText: "我和" + u.Nickname + "约好一起跑步，有想一起参加的吗？" +
"\n跑步地点： " + form.Addr +
"\n跑步时间： " + time.Unix(form.Time, 0).Format("2006-01-02 3:04 PM")},
{ContentType: "IMAGE", ContentText: form.Image},
},
}
case models.TaskPost:
article := &models.Article{}
if find, _ := article.FindById(form.ArticleId); find {
article.SetThumb(user.Id, true)
}
event.Data.Type = models.EventPostShared
case models.TaskGame:
event.Data.Type = models.EventPKShared
result := u.Nickname + " 主动PK " + user.Nickname + "大获全胜。"
if u.Props.Score < user.Props.Score {
result = u.Nickname + " 主动PK " + user.Nickname + "大败亏输。"
}
article = &models.Article{
Author: user.Id,
Type: "pk",
PubTime: time.Now(),
Contents: []models.Segment{
{ContentType: "TEXT", ContentText: result},
{ContentType: "IMAGE", ContentText: form.Image},
},
}
default:
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError))
return
}
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())
user.UpdateRatio(form.Type, true)
if article != nil {
article.Save()
}
awards.Wealth = 1 * models.Satoshi
GiveAwards(user, awards, redis)
}
redis.SetTaskShare(user.Id, false)
writeResponse(r.RequestURI, w, map[string]interface{}{"ExpEffect": awards}, nil)
}
func taskShareHandler(r *http.Request, w http.ResponseWriter,
redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(taskShareForm)
if form.TaskId > len(models.NewTasks) {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError))
return
}
//task := models.NewTasks[form.TaskId]
// ws push
event := &models.Event{
Type: models.EventSystem,
Time: time.Now().Unix(),
Data: models.EventData{
//Type: models.EventRunShare,
Id: user.Id,
From: user.Id,
To: form.Userid,
},
}
switch form.Type {
case models.TaskRunning:
record, _ := user.LastRecord("run")
latlng := strconv.FormatFloat(form.Lat, 'f', 7, 64) + "," +
strconv.FormatFloat(form.Lng, 'f', 7, 64)
event.Data.Type = models.EventRunShare
event.Data.Body = []models.MsgBody{
{Type: "record_id", Content: record.Id.Hex()},
{Type: "latlng", Content: latlng},
{Type: "locaddr", Content: form.Addr},
{Type: "time", Content: strconv.FormatInt(form.Time, 10)},
{Type: "addr_image", Content: form.Image},
}
case models.TaskPost:
event.Data.Type = models.EventPostShare
article := user.LatestArticle()
event.Data.Body = []models.MsgBody{
{Type: "article_id", Content: article.Id.Hex()},
}
case models.TaskGame:
record, _ := user.LastRecord("run")
event.Data.Type = models.EventPKShare
event.Data.Body = []models.MsgBody{
{Type: "record_id", Content: record.Id.Hex()},
}
default:
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError))
return
}
event.Save()
redis.PubMsg(event.Type, event.Data.To, event.Bytes())
u := &models.Account{Id: form.Userid}
u.UpdateRatio(form.Type, false)
redis.SetTaskShare(form.Userid, true)
if _, err := consumeCoin(user.Wallet.Addr, form.Coin); err == nil {
redis.ConsumeCoins(user.Id, form.Coin)
}
writeResponse(r.RequestURI, w, nil, nil)
}
func articleThumbHandler(request *http.Request, resp http.ResponseWriter,
client *ApnClient, redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(articleThumbForm)
article := &models.Article{}
if find, err := article.FindById(form.Id); !find {
e := errors.NewError(errors.NotExistsError, "文章不存在!")
if err != nil {
e = errors.NewError(errors.DbError)
}
writeResponse(request.RequestURI, resp, nil, e)
return
}
if redis.Relationship(article.Author, user.Id) == models.RelBlacklist {
writeResponse(request.RequestURI, resp, nil,
errors.NewError(errors.AccessError, "对方屏蔽了你!"))
return
}
if err := article.SetThumb(user.Id, form.Status); err != nil {
writeResponse(request.RequestURI, resp, nil, err)
return
}
awards := Awards{}
if form.Status {
awards = Awards{Score: 1, Wealth: 1 * models.Satoshi}
GiveAwards(user, awards, redis)
}
writeResponse(request.RequestURI, resp, map[string]interface{}{"ExpEffect": awards}, nil)
author := &models.Account{Id: article.Author}
// ws push
event := &models.Event{
Type: models.EventArticle,
Time: time.Now().Unix(),
Data: models.EventData{
Type: models.EventThumb,
Id: article.Id.Hex(),
From: user.Id,
To: author.Id,
Body: []models.MsgBody{
{Type: "total_count", Content: strconv.Itoa(article.ThumbCount + 1)},
{Type: "image", Content: article.Image},
},
},
}
if form.Status {
author.FindByUserid(article.Author)
/*
if err := event.Save(); err == nil {
redis.IncrEventCount(article.Author, event.Data.Type, 1)
}
*/
event.Upsert()
event.Data.Body = append(event.Data.Body,
models.MsgBody{Type: "new_count",
Content: strconv.Itoa(models.EventCount(event.Data.Type, event.Data.Id, event.Data.To))})
redis.PubMsg(models.EventArticle, article.Author, event.Bytes())
// apple push
if author.Push {
go sendApn(client, user.Nickname+"赞了你的主题!", author.EventCount("", ""), author.Devs...)
}
} else {
//count := author.DelEvent(models.EventThumb, article.Id.Hex(), user.Id, author.Id)
//redis.IncrEventCount(author.Id, models.EventThumb, -count)
event.Delete()
}
//user.UpdateAction(ActThumb, nowDate())
}
func newArticleHandler(request *http.Request, resp http.ResponseWriter,
client *ApnClient, redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(newArticleForm)
article := &models.Article{
Author: user.Id,
Contents: form.Contents,
PubTime: time.Now(),
Parent: form.Parent,
//Tags: form.Tags,
Loc: form.Location,
Type: form.Type,
}
article.Title, article.Images = articleCover(form.Contents)
if len(article.Images) > 0 {
article.Image = article.Images[0]
}
/*
if len(article.Tags) == 0 {
article.Tags = []string{"SPORT_LOG"}
}
*/
awards := Awards{}
parent := &models.Article{}
if len(form.Parent) > 0 {
if find, err := parent.FindById(form.Parent); !find {
e := errors.NewError(errors.NotExistsError, "文章不存在!")
if err != nil {
e = errors.NewError(errors.DbError)
}
writeResponse(request.RequestURI, resp, nil, e)
return
}
if redis.Relationship(parent.Author, user.Id) == models.RelBlacklist {
writeResponse(request.RequestURI, resp, nil,
errors.NewError(errors.AccessError, "对方屏蔽了你!"))
return
}
awards = Awards{Literal: 1 + user.Level(), Score: 1 + user.Level()}
} else {
if user.Stat != nil && user.Stat.LastArticleTime < nowDate().Unix() {
awards = Awards{Literal: 2 + user.Level(), Wealth: 2 * models.Satoshi, Score: 2 + user.Level()}
}
user.UpdateStat(models.StatLastArticleTime, time.Now().Unix())
}
if article.Type == models.ArticleRecord {
article.Coaches = []string{user.Id}
}
if article.Type == models.ArticleCoach {
if parent.Author != user.Id &&
user.Actor != models.ActorCoach && user.Actor != models.ActorAdmin {
writeResponse(request.RequestURI, resp, nil,
errors.NewError(errors.AccessError))
return
}
if err := article.Save(); err != nil {
log.Println(err)
writeResponse(request.RequestURI, resp, nil, err)
return
}
// ws push
event := &models.Event{
Type: models.EventArticle,
Time: time.Now().Unix(),
Data: models.EventData{
Type: models.EventCoach,
Id: parent.Id.Hex(),
From: user.Id,
//To: parent.Author,
Body: []models.MsgBody{
{Type: "total_count", Content: strconv.Itoa(parent.CoachReviewCount + 1)},
{Type: "image", Content: user.Profile},
},
},
}
for _, coach := range parent.Coaches {
if coach == user.Id {
continue
}
event.Data.To = coach
event.Save()
redis.PubMsg(models.EventArticle, coach, event.Bytes())
}
respData := map[string]interface{}{
"ExpEffect": Awards{},
}
writeResponse(request.RequestURI, resp, respData, nil)
return
}
if err := article.Save(); err != nil {
log.Println(err)
writeResponse(request.RequestURI, resp, nil, err)
return
}
t := ""
stat := models.StatArticles
if len(form.Parent) > 0 {
t = models.ArticleComment
stat = models.StatComments
}
redis.AddPost(user.Id, t, 1)
user.UpdateStat(stat, 1)
if err := GiveAwards(user, awards, redis); err != nil {
log.Println(err)
writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.DbError))
return
}
// comment
if len(form.Parent) > 0 && parent.Author != user.Id {
//u := &models.User{Id: parent.Author}
author := &models.Account{}
author.FindByUserid(parent.Author)
// ws push
event := &models.Event{
Type: models.EventArticle,
Time: time.Now().Unix(),
Data: models.EventData{
Type: models.EventComment,
Id: parent.Id.Hex(),
From: user.Id,
To: parent.Author,
Body: []models.MsgBody{
{Type: "total_count", Content: strconv.Itoa(parent.ReviewCount + 1)},
{Type: "image", Content: parent.Image},
},
},
}
/*
if err := event.Save(); err == nil {
redis.IncrEventCount(parent.Author, event.Data.Type, 1)
}
*/
event.Save()
event.Data.Body = append(event.Data.Body,
models.MsgBody{Type: "new_count",
Content: strconv.Itoa(models.EventCount(event.Data.Type, event.Data.Id, event.Data.To))})
redis.PubMsg(models.EventArticle, parent.Author, event.Bytes())
// apple push
if author.Push {
go sendApn(client, user.Nickname+"评论了你的主题!", author.EventCount("", ""), author.Devs...)
}
}
respData := map[string]interface{}{
//"articles_without_content": convertArticle(article),
"ExpEffect": awards,
}
writeResponse(request.RequestURI, resp, respData, nil)
}
func txHandler(r *http.Request, w http.ResponseWriter,
client *ApnClient, redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(txForm)
if form.FromAddr == form.ToAddr {
writeResponse(r.RequestURI, w, map[string]string{"txid": ""}, nil)
return
}
if form.Value <= 0 {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError, "无效的金额"))
return
}
receiver := &models.Account{}
if find, err := receiver.FindByWalletAddr(form.ToAddr); !find {
e := errors.NewError(errors.NotFoundError, "无效的收款地址")
if err != nil {
e = errors.NewError(errors.DbError, "无效的钱包地址")
}
writeResponse(r.RequestURI, w, nil, e)
return
}
if redis.Relationship(receiver.Id, user.Id) == models.RelBlacklist {
writeResponse(r.RequestURI, w, nil,
errors.NewError(errors.AccessError, "对方屏蔽了你!"))
return
}
wal, err := getWallet(user.Wallet.Id, user.Wallet.Key)
if err != nil {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.DbError, "获取钱包失败"))
return
}
outputs, amount, err := getUnspent(form.FromAddr, wal.Keys, form.Value)
if err != nil {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.DbError, "获取账户信息失败"))
return
}
//log.Println("amount:", amount, "value:", form.Value)
if form.Value > amount {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.AccessError, "余额不足"))
return
}
article := &models.Article{}
if strings.ToLower(form.Type) == "reward" && len(form.Id) > 0 {
if b, e := article.FindById(form.Id); !b {
err := errors.NewError(errors.NotExistsError, "文章不存在!")
if e != nil {
err = errors.NewError(errors.DbError)
}
writeResponse(r.RequestURI, w, nil, err)
return
}
}
changeAddr := form.FromAddr
if len(changeAddr) == 0 {
changeAddr = wal.Keys[0].PubKey
}
rawtx, err := CreateRawTx2(outputs, amount, form.Value, form.ToAddr, changeAddr)
if err != nil {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.DbError))
return
}
txid, err := sendRawTx(rawtx)
if err != nil {
writeResponse(r.RequestURI, w, nil, errors.NewError(errors.DbError))
return
}
redis.Transaction(user.Id, receiver.Id, form.Value)
// ws push
event := &models.Event{
Type: models.EventWallet,
Time: time.Now().Unix(),
}
//log.Println("tx type:", strings.ToLower(form.Type))
switch strings.ToLower(form.Type) {
case "reward":
article.Reward(user.Id, form.Value)
event.Data = models.EventData{
Type: models.EventReward,
Id: article.Id.Hex(),
From: user.Id,
To: receiver.Id,
Body: []models.MsgBody{
{Type: "nikename", Content: user.Nickname},
{Type: "image", Content: article.Image},
{Type: "total_count", Content: strconv.FormatInt(article.TotalReward, 10)},
//{Type: "new_count", Content: strconv.Itoa(models.EventCount(models.EventReward, article.Id.Hex()) + 1)},
},
}
default:
event.Data = models.EventData{
Type: models.EventTx,
Id: user.Id + "-" + receiver.Id,
From: user.Id,
To: receiver.Id,
Body: []models.MsgBody{
{Type: "nikename", Content: user.Nickname},
{Type: "image", Content: user.Profile},
{Type: "total_count", Content: strconv.FormatInt(form.Value, 10)},
},
}
}
if user.Id != receiver.Id {
/*
if err := event.Save(); err == nil {
redis.IncrEventCount(receiver.Id, event.Data.Type, 1)
}
*/
event.Save()
event.Data.Body = append(event.Data.Body,
models.MsgBody{Type: "new_count",
Content: strconv.Itoa(models.EventCount(event.Data.Type, event.Data.Id, event.Data.To))})
redis.PubMsg("wallet", receiver.Id, event.Bytes())
}
if receiver.Push {
msg := user.Nickname + "通过转帐发送给你" +
strconv.FormatFloat(float64(form.Value)/float64(models.Satoshi), 'f', 8, 64) + "个贝币"
if event.Data.Type == models.EventReward {
msg = user.Nickname + "给你的文章打赏了" +
strconv.FormatFloat(float64(form.Value)/float64(models.Satoshi), 'f', 8, 64) + "个贝币"
}
go sendApn(client, msg, receiver.EventCount("", ""), receiver.Devs...)
}
writeResponse(r.RequestURI, w, map[string]string{"txid": txid}, nil)
}
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 taskAuthFunc(userid string, auth *taskAuth, redis *models.RedisLogger) error {
user := &models.Account{}
user.FindByUserid(auth.Userid)
record := &models.Record{Uid: user.Id, Task: auth.Id}
record.FindByTask(auth.Id)
awards := controllers.Awards{}
parent := &models.Article{}
parent.FindByRecord(record.Id.Hex())
if len(parent.Id) > 0 && len(auth.Reason) > 0 {
review := &models.Article{
Parent: parent.Id.Hex(),
Author: userid,
Title: auth.Reason,
Type: models.ArticleCoach,
Contents: []models.Segment{{ContentType: "TEXT", ContentText: auth.Reason}},
PubTime: time.Now(),
}
review.Save()
}
if auth.Pass {
level := user.Level()
awards = controllers.Awards{
Physical: 3 + level,
Wealth: 3 * models.Satoshi,
Score: 3 + level,
}
awards.Level = models.Score2Level(user.Props.Score+awards.Score) - level
controllers.GiveAwards(user, awards, redis)
if record.Sport != nil {
redis.UpdateRecLB(user.Id, record.Sport.Distance, int(record.Sport.Duration))
}
record.SetStatus(models.StatusFinish, auth.Reason, awards.Wealth)
if auth.Id < 1000 {
user.UpdateTask(int(auth.Id), models.StatusFinish)
}
} else {
record.SetStatus(models.StatusUnFinish, auth.Reason, 0)
if auth.Id < 1000 {
user.UpdateTask(int(auth.Id), models.StatusUnFinish)
}
parent.SetPrivilege(models.PrivPrivate)
}
// ws push
event := &models.Event{
Type: models.EventNotice,
Time: time.Now().Unix(),
Data: models.EventData{
Type: models.EventTaskDone,
To: user.Id,
Body: []models.MsgBody{
{Type: "physique_value", Content: strconv.FormatInt(awards.Physical, 10)},
{Type: "coin_value", Content: strconv.FormatInt(awards.Wealth, 10)},
},
},
}
if auth.Id < 1000 {
event.Data.Body = append(event.Data.Body, models.MsgBody{Type: "task_id", Content: strconv.Itoa(int(auth.Id))})
}
if !auth.Pass {
event.Data.Type = models.EventTaskFailure
}
redis.PubMsg(event.Type, event.Data.To, event.Bytes())
event.Save()
event = &models.Event{
Type: models.EventArticle,
Time: time.Now().Unix(),
Data: models.EventData{
Type: models.EventCoachPass,
Id: parent.Id.Hex(),
From: userid,
To: parent.Author,
Body: []models.MsgBody{
{Type: "total_count", Content: strconv.Itoa(parent.CoachReviewCount + 1)},
{Type: "image", Content: ""},
},
},
}
if !auth.Pass {
event.Data.Type = models.EventCoachNPass
}
event.Save()
redis.PubMsg(event.Type, event.Data.To, event.Bytes())
return nil
}
