func newRecordHandler(request *http.Request, resp http.ResponseWriter,
redis *models.RedisLogger, user *models.Account, p Parameter) {
form := p.(newRecordForm)
rec := &models.Record{
Uid: user.Id,
Task: form.Task,
Type: form.Record.Type,
StartTime: time.Unix(form.Record.BeginTime, 0),
EndTime: time.Unix(form.Record.EndTime, 0),
PubTime: time.Now(),
}
awards := Awards{}
level := user.Level()
switch form.Record.Type {
case "post":
rec.Status = models.StatusFinish
if form.Task > 0 {
rec.Coin = (2 + level) * models.Satoshi
awards = Awards{
Score: 2 + level,
Literal: 2 + level,
Wealth: rec.Coin,
}
} else {
rec.Coin = 2 * models.Satoshi
awards = Awards{
Score: 2,
Literal: 2,
Wealth: rec.Coin,
}
}
GiveAwards(user, awards, redis)
redis.AddPost(user.Id, "", 1)
user.UpdateStat(models.StatArticles, 1)
case "game":
if form.Task > 0 {
awards = gameAwards(level, form.Record.GameScore, true)
//user.AddTask(models.Tasks[form.Task-1].Type, form.Task, nil)
rec.Status = models.StatusFinish
} else {
if form.Record.GameScore >= 100 &&
user.Stat != nil && user.Stat.LastGameTime < nowDate().Unix() {
awards = gameAwards(level, form.Record.GameScore, false)
}
user.UpdateStat(models.StatLastGameTime, time.Now().Unix())
}
GiveAwards(user, awards, redis)
rec.Game = &models.GameRecord{
Type: form.Record.GameType,
Name: form.Record.GameName,
Duration: form.Record.Duration,
Score: form.Record.GameScore,
Magic: int(awards.Mental),
}
rec.Coin = awards.Wealth
redis.AddGameTime(user.Id, int(form.Record.Duration))
user.UpdateStat(models.StatGameTime, form.Record.Duration)
redis.SetGameMaxScore(gameType(rec.Game.Type), user.Id, rec.Game.Score)
user.SetGameTime(gameType(rec.Game.Type), time.Now())
case "run":
if rec.Task > 0 {
rec.Delete()
}
rec.Sport = &models.SportRecord{
Source: form.Record.Source,
Duration: form.Record.Duration,
Distance: form.Record.Distance,
Weight: form.Record.Weight,
Mood: form.Record.Mood,
HeartRate: form.Record.HeartRate,
Pics: form.Record.Pics,
}
if rec.Sport.Weight == 0 {
rec.Sport.Weight = user.Weight
}
// update weight
if rec.Sport.Weight != user.Weight {
user.SetInfo(&models.SetInfo{Weight: rec.Sport.Weight})
}
if form.Record.Duration > 0 {
rec.Sport.Speed = float64(form.Record.Distance) / float64(form.Record.Duration)
}
rec.Status = models.StatusAuth
redis.AddRecord(user.Id, 1)
user.UpdateStat(models.StatRecords, 1)
/*
if len(form.Record.Source) > 0 {
level := user.Level()
awards = Awards{
Physical: 30 + level,
Wealth: 30 * models.Satoshi,
Score: 30 + level,
}
GiveAwards(user, awards, redis)
redis.UpdateRecLB(user.Id, rec.Sport.Distance, int(rec.Sport.Duration))
rec.Coin = awards.Wealth
rec.Status = models.StatusFinish
}
*/
default:
log.Println("Unknown record type:", form.Record.Type)
}
// assign task id
if rec.Task == 0 {
rec.Task = rec.PubTime.Unix()
}
if err := rec.Save(); err != nil {
writeResponse(request.RequestURI, resp, nil, err)
return
}
if rec.Type == "run" {
article := &models.Article{
Author: user.Id,
PubTime: time.Now(),
Loc: user.Loc,
Record: rec.Id.Hex(),
Type: models.ArticleRecord,
}
if !form.Public {
article.Privilege = models.PrivPrivate
}
if err := article.Save(); err == nil {
redis.AddPost(user.Id, "", 1)
user.UpdateStat(models.StatArticles, 1)
}
}
if form.Task > 0 {
user.UpdateTask(int(form.Task), rec.Status)
/*
if rec.Status == models.StatusFinish {
// 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: "task_id", Content: strconv.Itoa(int(form.Task))},
{Type: "literature_value", Content: strconv.FormatInt(awards.Literal, 10)},
{Type: "magic_value", Content: strconv.FormatInt(awards.Mental, 10)},
{Type: "coin_value", Content: strconv.FormatInt(awards.Wealth, 10)},
},
},
}
event.Save()
redis.PubMsg(event.Type, event.Data.To, event.Bytes())
}
*/
}
respData := map[string]interface{}{
"record_id": rec.Id.Hex(),
"ExpEffect": awards,
}
writeResponse(request.RequestURI, resp, respData, nil)
}
func setInfoHandler(request *http.Request, resp http.ResponseWriter, redis *models.RedisLogger,
user *models.Account, p Parameter) {
form := p.(setInfoForm)
setinfo := &models.SetInfo{
Phone: form.UserInfo.Phone,
Nickname: form.UserInfo.Nickname,
Height: form.UserInfo.Height,
Weight: form.UserInfo.Weight,
Birth: form.UserInfo.Birth,
Gender: form.UserInfo.Gender,
Sign: form.UserInfo.Sign,
Emotion: form.UserInfo.Emotion,
Profession: form.UserInfo.Profession,
Hobby: form.UserInfo.Hobby,
Hometown: form.UserInfo.Hometown,
OftenAppear: form.UserInfo.OftenAppear,
CoverImage: form.UserInfo.CoverImage,
Setinfo: user.Setinfo,
SetinfoAll: user.SetinfoAll,
}
addr := &models.Address{
Country: form.UserInfo.Country,
Province: form.UserInfo.Province,
City: form.UserInfo.City,
Area: form.UserInfo.Area,
Desc: form.UserInfo.LocDesc,
}
if addr.String() != "" {
setinfo.Address = addr
}
if len(setinfo.Phone) > 0 && setinfo.Phone != user.Phone {
user.Phone = setinfo.Phone
//setinfo.Setinfo = false
if b, _ := user.Exists("phone"); b {
writeResponse(request.RequestURI, resp, nil,
errors.NewError(errors.UserExistError, "绑定失败，当前手机号已绑定"))
return
}
}
if len(setinfo.Nickname) > 0 && setinfo.Nickname != user.Nickname {
u := &models.Account{}
if find, _ := u.FindByNickname(setinfo.Nickname); find {
writeResponse(request.RequestURI, resp, nil, errors.NewError(errors.UserExistError, "昵称已被占用"))
return
}
}
awards := Awards{}
if !user.Setinfo || !user.SetinfoAll {
ratio := calcInfo(user, setinfo)
if ratio >= 80 && !user.Setinfo {
setinfo.Setinfo = true
awards.Wealth = 30 * models.Satoshi
awards.Score = 30
}
if ratio == 100 && !user.SetinfoAll {
setinfo.SetinfoAll = true
awards.Wealth = 50 * models.Satoshi
awards.Score = 50
}
}
if err := user.SetInfo(setinfo); err != nil {
writeResponse(request.RequestURI, resp, nil, err)
return
}
GiveAwards(user, awards, redis)
writeResponse(request.RequestURI, resp, map[string]interface{}{"ExpEffect": awards}, nil)
user.UpdateAction(ActInfo, nowDate())
//redis.SetOnlineUser(form.Token, user, false)
}
