You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
924 lines
24 KiB
924 lines
24 KiB
package service |
|
|
|
import ( |
|
"fmt" |
|
"sort" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/admin/main/creative/model/task" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
//TaskGroupRewards for task group & rewards. |
|
func (s *Service) TaskGroupRewards(ids []int64) (res map[int64][]*task.TaskGroupReward, err error) { |
|
tgrs := []*task.TaskGroupReward{} |
|
if err = s.DB.Model(&task.TaskGroupReward{}).Where("task_group_id IN (?)", ids).Where("state>=0").Find(&tgrs).Error; err != nil { |
|
log.Error("s.TaskGroupRewards ids(%+v) error(%v)", ids, err) |
|
} |
|
if len(tgrs) == 0 { |
|
return |
|
} |
|
|
|
res = make(map[int64][]*task.TaskGroupReward) |
|
for _, v := range tgrs { |
|
if v != nil { |
|
res[v.TaskGroupID] = append(res[v.TaskGroupID], v) |
|
} |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) getRewards(rids []int64) (res []*task.RewardResult) { |
|
_, rewardMap := s.loadRewards() |
|
if len(rids) == 0 || len(rewardMap) == 0 { |
|
return |
|
} |
|
|
|
sort.Slice(rids, func(i, j int) bool { |
|
return rids[i] < rids[j] |
|
}) |
|
res = make([]*task.RewardResult, 0, len(rids)) |
|
for _, rid := range rids { |
|
if v, ok := rewardMap[rid]; ok { |
|
res = append(res, &task.RewardResult{ |
|
RewardID: v.ID, |
|
RewardName: v.Name, |
|
}) |
|
} |
|
} |
|
return |
|
} |
|
|
|
//AddTaskGroup for add task group. |
|
func (s *Service) AddTaskGroup(v *task.TaskGroup, rewardsIDs []int64) (id int64, err error) { |
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
v.CTime = now |
|
tx := s.DB.Begin() |
|
v.State = task.StateHide |
|
if err = tx.Create(v).Error; err != nil { |
|
log.Error("addGroup error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"rank": v.ID, |
|
}).Error; err != nil { |
|
log.Error("addGroup error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if len(rewardsIDs) > 0 { |
|
valReward := make([]string, 0, len(rewardsIDs)) |
|
valRewardArgs := make([]interface{}, 0) |
|
for _, rid := range rewardsIDs { |
|
valReward = append(valReward, "(?, ?, ?, ?, ?, ?)") |
|
valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now) |
|
} |
|
sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_grouptask_reward (task_group_id, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ",")) |
|
if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil { |
|
log.Error("addGroup link reward error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
} |
|
tx.Commit() |
|
return v.ID, nil |
|
} |
|
|
|
//EditTaskGroup for edit task group. |
|
func (s *Service) EditTaskGroup(v *task.TaskGroup, rewardsIDs []int64) (id int64, err error) { |
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
tg := &task.TaskGroup{} |
|
if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", v.ID).Find(tg).Error; err != nil { |
|
log.Error("EditTaskGroup link reward error(%v)", err) |
|
return |
|
} |
|
if tg == nil { |
|
return |
|
} |
|
|
|
tx := s.DB.Begin() |
|
if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"root_type": v.RootType, |
|
"type": v.Type, |
|
}).Error; err != nil { |
|
log.Error("editGroup error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if len(rewardsIDs) > 0 { |
|
var tgr task.TaskGroupReward |
|
if err = tx.Where("task_group_id =?", v.ID).Delete(&tgr).Error; err != nil { |
|
log.Error("editGroup delete old group id(%d)|error(%v)", v.ID, err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
valReward := make([]string, 0, len(rewardsIDs)) |
|
valRewardArgs := make([]interface{}, 0) |
|
for _, rid := range rewardsIDs { |
|
valReward = append(valReward, "(?, ?, ?, ?, ?, ?)") |
|
valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now) |
|
} |
|
sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_grouptask_reward (task_group_id, reward_id, state, comment, ctime, mtime) VALUES %s ON DUPLICATE KEY UPDATE task_group_id=VALUES(task_group_id), reward_id=VALUES(reward_id)", strings.Join(valReward, ",")) |
|
if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil { |
|
log.Error("editGroup link reward error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
} |
|
tx.Commit() |
|
return v.ID, nil |
|
} |
|
|
|
//OrderTaskGroup for order task group. |
|
func (s *Service) OrderTaskGroup(v *task.OrderTask) (err error) { |
|
tg := &task.TaskGroup{} |
|
if err = s.DB.Find(tg, v.ID).Error; err != nil { |
|
log.Error("orderGroup error(%v)", err) |
|
return |
|
} |
|
stg := &task.TaskGroup{} |
|
if err = s.DB.Find(stg, v.SwitchID).Error; err != nil { |
|
log.Error("orderGroup error(%v)", err) |
|
return |
|
} |
|
|
|
tx := s.DB.Begin() |
|
if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.ID).Updates( |
|
map[string]interface{}{ |
|
"rank": v.SwitchRank, |
|
}, |
|
).Error; err != nil { |
|
log.Error("orderGroup error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
if err = tx.Model(&task.TaskGroup{}).Where("id=?", v.SwitchID).Updates( |
|
map[string]interface{}{ |
|
"rank": v.Rank, |
|
}, |
|
).Error; err != nil { |
|
log.Error("orderGroup error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
tx.Commit() |
|
return |
|
} |
|
|
|
//UpStateGroup for update task group. |
|
func (s *Service) UpStateGroup(id int64, state int8) (err error) { |
|
tg := &task.TaskGroup{} |
|
if err = s.DB.Find(tg, id).Error; err != nil { |
|
log.Error("UpStateGroup id(%d) error(%v)", id, err) |
|
return |
|
} |
|
if tg.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", id).Updates(map[string]interface{}{ |
|
"state": state, |
|
}).Error; err != nil { |
|
log.Error("UpStateGroup id(%d) state(%d) error(%v)", id, state, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
//TaskGroup for task group. |
|
func (s *Service) TaskGroup(id int64) (res *task.TaskGroup, err error) { |
|
var tg task.TaskGroup |
|
if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", id).Find(&tg).Error; err != nil { |
|
log.Error("s.TaskGroup id (%d) error(%v)", id, err) |
|
return |
|
} |
|
if tg.ID == 0 { |
|
return |
|
} |
|
|
|
tgrsMap, _ := s.TaskGroupRewards([]int64{id}) |
|
if rs, ok := tgrsMap[id]; ok { |
|
rids := make([]int64, 0, len(rs)) |
|
for _, r := range rs { |
|
if r != nil { |
|
rids = append(rids, r.RewardID) |
|
} |
|
} |
|
tg.Reward = s.getRewards(rids) |
|
} |
|
|
|
res = &tg |
|
return |
|
} |
|
|
|
//AddSubtask for add sub task. |
|
func (s *Service) AddSubtask(v *task.Task, rewardsIDs []int64) (id int64, err error) { |
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
v.CTime = now |
|
v.MTime = now |
|
v.State = task.StateHide |
|
tx := s.DB.Begin() |
|
if err = tx.Create(v).Error; err != nil { |
|
log.Error("AddSubtask error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
if v.ID == 0 { |
|
log.Error("AddSubtask v.ID(%d)", v.ID) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if err = tx.Model(&task.Task{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"rank": v.ID, |
|
}).Error; err != nil { |
|
log.Error("AddSubtask error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if len(rewardsIDs) > 0 { |
|
valReward := make([]string, 0, len(rewardsIDs)) |
|
valRewardArgs := make([]interface{}, 0) |
|
for _, rid := range rewardsIDs { |
|
valReward = append(valReward, "(?, ?, ?, ?, ?, ?)") |
|
valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now) |
|
} |
|
sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_task_reward (task_id, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ",")) |
|
if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil { |
|
log.Error("AddSubtask link reward error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
} |
|
tx.Commit() |
|
return v.ID, nil |
|
} |
|
|
|
//EditSubtask for edit sub task. |
|
func (s *Service) EditSubtask(v *task.Task, rewardsIDs []int64) (id int64, err error) { |
|
tk := &task.Task{} |
|
if err = s.DB.Model(&task.TaskGroup{}).Where("id=?", v.ID).Find(tk).Error; err != nil { |
|
return |
|
} |
|
if tk == nil { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
v.CTime = tk.CTime |
|
v.MTime = now |
|
v.State = tk.State //编辑不更新状态 |
|
tx := s.DB.Begin() |
|
if err = tx.Save(v).Error; err != nil { //Save将包括执行更新SQL时的所有字段，即使它没有更改 |
|
log.Error("editSubtask error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if len(rewardsIDs) > 0 { |
|
var tr task.TaskReward |
|
if err = tx.Where("task_id =?", v.ID).Delete(&tr).Error; err != nil { |
|
log.Error("editSubtask delete old task id(%d)|error(%v)", v.ID, err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
valReward := make([]string, 0, len(rewardsIDs)) |
|
valRewardArgs := make([]interface{}, 0) |
|
for _, rid := range rewardsIDs { |
|
valReward = append(valReward, "(?, ?, ?, ?, ?, ?)") |
|
valRewardArgs = append(valRewardArgs, v.ID, rid, task.StateNormal, v.Comment, now, now) |
|
} |
|
sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_task_reward (task_id, reward_id, state, comment, ctime, mtime) VALUES %s ON DUPLICATE KEY UPDATE task_id=VALUES(task_id), reward_id=VALUES(reward_id)", strings.Join(valReward, ",")) |
|
if err = tx.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil { |
|
log.Error("editSubtask link reward error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
} |
|
tx.Commit() |
|
return v.ID, nil |
|
} |
|
|
|
//OrderSubTask for order sub task. |
|
func (s *Service) OrderSubTask(v *task.OrderTask) (err error) { |
|
tg := &task.Task{} |
|
if err = s.DB.Find(tg, v.ID).Error; err != nil { |
|
log.Error("OrderSubTask error(%v)", err) |
|
return |
|
} |
|
stg := &task.Task{} |
|
if err = s.DB.Find(stg, v.SwitchID).Error; err != nil { |
|
log.Error("OrderSubTask error(%v)", err) |
|
return |
|
} |
|
|
|
tx := s.DB.Begin() |
|
if err = tx.Model(&task.Task{}).Where("id=?", v.ID).Updates( |
|
map[string]interface{}{ |
|
"rank": v.SwitchRank, |
|
}, |
|
).Error; err != nil { |
|
log.Error("OrderSubTask error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
if err = tx.Model(&task.Task{}).Where("id=?", v.SwitchID).Updates( |
|
map[string]interface{}{ |
|
"rank": v.Rank, |
|
}, |
|
).Error; err != nil { |
|
log.Error("OrderSubTask error(%v)", err) |
|
tx.Rollback() |
|
return |
|
} |
|
tx.Commit() |
|
return |
|
} |
|
|
|
//UpStateSubTask for update sub task state. |
|
func (s *Service) UpStateSubTask(id int64, state int8) (err error) { |
|
tg := &task.Task{} |
|
if err = s.DB.Find(tg, id).Error; err != nil { |
|
return |
|
} |
|
if tg.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
if err = s.DB.Model(&task.Task{}).Where("id=?", id).Updates(map[string]interface{}{ |
|
"state": state, |
|
}).Error; err != nil { |
|
log.Error("UpStateSubTask id(%d) state(%d) error(%v)", id, state, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
//TransferSubtask for transfer one sub task from some one group to another one. |
|
func (s *Service) TransferSubtask(id, gid int64) (err error) { |
|
tg := &task.TaskGroup{} |
|
if err = s.DB.Find(tg, gid).Error; err != nil { |
|
return |
|
} |
|
if tg.ID == 0 { |
|
err = ecode.CreativeNewcomerGroupIDErr |
|
return |
|
} |
|
|
|
tk := &task.Task{} |
|
if err = s.DB.Find(tk, id).Error; err != nil { |
|
return |
|
} |
|
if tk.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
if err = s.DB.Model(&task.Task{}).Where("id=?", id).Updates(map[string]interface{}{ |
|
"group_id": gid, |
|
}).Error; err != nil { |
|
log.Error("transferSubtask id(%+v) gid(%d) error(%v)", id, gid, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
//Task for task. |
|
func (s *Service) Task(id int64) (res *task.Task, err error) { |
|
var t task.Task |
|
if err = s.DB.Model(&task.Task{}).Where("id=?", id).Find(&t).Error; err != nil { |
|
log.Error("s.Task id (%d) error(%v)", id, err) |
|
return |
|
} |
|
if t.ID == 0 { |
|
return |
|
} |
|
|
|
trsMap, _ := s.TaskRewards([]int64{id}) |
|
if rs, ok := trsMap[id]; ok { |
|
rids := make([]int64, 0, len(rs)) |
|
for _, r := range rs { |
|
if r != nil { |
|
rids = append(rids, r.RewardID) |
|
} |
|
} |
|
t.Reward = s.getRewards(rids) |
|
} |
|
res = &t |
|
return |
|
} |
|
|
|
//TaskRewards for task & rewards. |
|
func (s *Service) TaskRewards(ids []int64) (res map[int64][]*task.TaskReward, err error) { |
|
trs := []*task.TaskReward{} |
|
if err = s.DB.Model(&task.TaskReward{}).Where("state>=0 AND task_id IN (?)", ids).Find(&trs).Error; err != nil { |
|
log.Error("s.TaskRewards ids(%+v) error(%v)", ids, err) |
|
return |
|
} |
|
if len(trs) == 0 { |
|
return |
|
} |
|
|
|
res = make(map[int64][]*task.TaskReward) |
|
for _, v := range trs { |
|
if v != nil { |
|
res[v.TaskID] = append(res[v.TaskID], v) |
|
} |
|
} |
|
return |
|
} |
|
|
|
//TasksByGroupIDsMap for task map |
|
func (s *Service) TasksByGroupIDsMap(gids []int64) (res map[int64][]*task.Task, err error) { |
|
tks := []*task.Task{} |
|
if err = s.DB.Model(&task.Task{}).Where("state>=0 AND type>0 AND group_id IN (?)", gids).Find(&tks).Error; err != nil { |
|
log.Error("s.TasksByGroupIDsMap id (%+v) error(%v)", gids, err) |
|
return |
|
} |
|
if len(tks) == 0 { |
|
return |
|
} |
|
|
|
tkMap := make(map[int64]*task.Task) |
|
tgMap := make(map[int64][]*task.Task) |
|
ids := make([]int64, 0, len(tks)) |
|
for _, v := range tks { |
|
if v == nil { |
|
continue |
|
} |
|
if v.Rank == 0 { |
|
v.Rank = v.ID |
|
} |
|
ids = append(ids, v.ID) |
|
tkMap[v.ID] = v |
|
tgMap[v.GroupID] = append(tgMap[v.GroupID], v) |
|
} |
|
|
|
trsMap, _ := s.TaskRewards(ids) |
|
for _, id := range ids { |
|
rs, ok := trsMap[id] |
|
if !ok || len(rs) == 0 { |
|
continue |
|
} |
|
rids := make([]int64, 0, len(rs)) |
|
for _, r := range rs { |
|
if r != nil { |
|
rids = append(rids, r.RewardID) |
|
} |
|
} |
|
tkMap[id].Reward = s.getRewards(rids) |
|
} |
|
|
|
res = make(map[int64][]*task.Task) |
|
for _, gid := range gids { |
|
tks, ok := tgMap[gid] |
|
if !ok || len(tks) == 0 { |
|
continue |
|
} |
|
for _, tk := range tks { |
|
if v, ok := tkMap[tk.ID]; ok { |
|
res[gid] = append(res[gid], v) |
|
} |
|
} |
|
} |
|
for _, v := range res { |
|
sort.Slice(v, func(i, j int) bool { |
|
return v[i].Rank < v[j].Rank |
|
}) |
|
} |
|
return |
|
} |
|
|
|
//TaskList for task list |
|
func (s *Service) TaskList(ty int8) (res []*task.TaskGroup, err error) { |
|
tgs := []*task.TaskGroup{} |
|
db := s.DB.Model(&task.TaskGroup{}).Where("state>=0 AND root_type>0 AND type>0") |
|
if ty > 0 { |
|
db = db.Where("type=?", ty) |
|
} |
|
|
|
if err = db.Find(&tgs).Error; err != nil { |
|
log.Error("TaskList %v\n", err) |
|
return |
|
} |
|
if len(tgs) == 0 { |
|
return |
|
} |
|
|
|
gids := make([]int64, 0, len(tgs)) |
|
tgMap := make(map[int64]*task.TaskGroup) |
|
for _, v := range tgs { |
|
if v == nil { |
|
continue |
|
} |
|
gids = append(gids, v.ID) |
|
tgMap[v.ID] = v |
|
} |
|
|
|
tgrsMap, _ := s.TaskGroupRewards(gids) |
|
for _, id := range gids { |
|
if rs, ok := tgrsMap[id]; ok { |
|
if len(rs) == 0 { |
|
continue |
|
} |
|
rids := make([]int64, 0, len(rs)) |
|
for _, r := range rs { |
|
if r != nil { |
|
rids = append(rids, r.RewardID) |
|
} |
|
} |
|
tgMap[id].Reward = s.getRewards(rids) |
|
} |
|
} |
|
|
|
tkMap, _ := s.TasksByGroupIDsMap(gids) |
|
res = tgs |
|
for _, v := range res { |
|
if v == nil { |
|
continue |
|
} |
|
if g, ok := tgMap[v.ID]; ok { |
|
v.Reward = g.Reward |
|
} |
|
if tks, ok := tkMap[v.ID]; ok { |
|
v.Tasks = tks |
|
} |
|
} |
|
|
|
sort.Slice(res, func(i, j int) bool { |
|
return res[i].Rank < res[j].Rank |
|
}) |
|
return |
|
} |
|
|
|
//loadRewards for task reward. |
|
func (s *Service) loadRewards() (res []*task.Reward, rwMap map[int64]*task.Reward) { |
|
var ( |
|
rds = []*task.Reward{} |
|
err error |
|
) |
|
|
|
if err = s.DB.Order("id ASC").Find(&rds).Error; err != nil { |
|
log.Error("loadRewards error(%v)", err) |
|
return |
|
} |
|
|
|
res = make([]*task.Reward, 0, len(rds)) |
|
rwMap = make(map[int64]*task.Reward) |
|
top := make(map[int64]*task.Reward) |
|
for _, v := range rds { |
|
if v == nil { |
|
continue |
|
} |
|
rwMap[v.ID] = v |
|
|
|
if v.ParentID == 0 { |
|
top[v.ID] = v //映射一级对象 |
|
res = append(res, v) //追加一级对象 |
|
} |
|
} |
|
|
|
for _, ch := range rds { |
|
if ch == nil { |
|
continue |
|
} |
|
if p, ok := top[ch.ParentID]; ok && p != nil && p.Type == ch.Type { //为一级对象增加子对象，注:要append满足条件的ch，若append p 则会造成递归导致stack overflow |
|
p.Children = append(p.Children, ch) |
|
} |
|
} |
|
return |
|
} |
|
|
|
//RewardTree for reward tree. |
|
func (s *Service) RewardTree() (res []*task.Reward) { |
|
res, _ = s.loadRewards() |
|
return |
|
} |
|
|
|
//ViewReward for view one reward. |
|
func (s *Service) ViewReward(id int64) (res *task.Reward, err error) { |
|
rd := task.Reward{} |
|
if err = s.DB.Model(&task.Reward{}).Where("id=?", id).Find(&rd).Error; err != nil { |
|
return |
|
} |
|
res = &rd |
|
return |
|
} |
|
|
|
//AddReward for add one reward. |
|
func (s *Service) AddReward(v *task.Reward) (id int64, err error) { |
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
v.CTime = now |
|
v.MTime = now |
|
if err = s.DB.Create(v).Error; err != nil { |
|
log.Error("AddReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
return v.ID, nil |
|
} |
|
|
|
//EditReward for edit one reward. |
|
func (s *Service) EditReward(v *task.Reward) (id int64, err error) { |
|
rd := &task.Reward{} |
|
if err = s.DB.Model(&task.Reward{}).Where("id=?", v.ID).Find(rd).Error; err != nil { |
|
return |
|
} |
|
if rd == nil { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
v.CTime = rd.CTime |
|
v.MTime = time.Now().Format("2006-01-02 15:04:05") |
|
v.State = rd.State //编辑不更新状态 |
|
if err = s.DB.Save(v).Error; err != nil { |
|
log.Error("EditReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
return v.ID, nil |
|
} |
|
|
|
//UpStateReward for update reward state. |
|
func (s *Service) UpStateReward(id int64, state int8) (err error) { |
|
rd := &task.Reward{} |
|
if err = s.DB.Find(rd, id).Error; err != nil { |
|
return |
|
} |
|
if rd.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
if rd.ParentID != 0 { //如果是子分类直接更新并返回 |
|
if err = s.DB.Model(&task.Reward{}).Where("id=?", id).Updates(map[string]interface{}{ |
|
"state": state, |
|
}).Error; err != nil { |
|
log.Error("UpStateReward parent id(%d) state(%d) error(%v)", id, state, err) |
|
} |
|
return |
|
} |
|
|
|
rds := []*task.Reward{} |
|
if err = s.DB.Model(&task.Reward{}).Where("parent_id=?", id).Find(&rds).Error; err != nil { |
|
log.Error("UpStateReward get childen by parent id(%d) error(%v)", rd.ParentID, err) |
|
return |
|
} |
|
ids := make([]int64, 0, len(rds)+1) |
|
for _, v := range rds { |
|
if v != nil { |
|
ids = append(ids, v.ID) //追加子分类id |
|
} |
|
} |
|
|
|
ids = append(ids, id) //追加父分类id |
|
if err = s.DB.Model(&task.Reward{}).Where("id IN (?)", ids).Updates(map[string]interface{}{ |
|
"state": state, |
|
}).Error; err != nil { |
|
log.Error("UpStateReward childen ids(%+v) error(%v)", ids, err) |
|
} |
|
return |
|
} |
|
|
|
//ViewGiftReward for view gift. |
|
func (s *Service) ViewGiftReward(v *task.GiftReward) (res *task.GiftReward, err error) { |
|
var gfs []*task.GiftReward |
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Find(&gfs).Error; err != nil { |
|
log.Error("ViewGiftReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
if len(gfs) == 0 { |
|
return |
|
} |
|
|
|
res = &task.GiftReward{ |
|
RootType: v.RootType, |
|
TaskType: v.TaskType, |
|
} |
|
var ( |
|
state int8 |
|
comment string |
|
) |
|
rids := make([]int64, 0, len(gfs)) |
|
for _, gf := range gfs { |
|
if gf != nil { |
|
state = gf.State |
|
comment = gf.Comment |
|
rids = append(rids, gf.RewardID) |
|
} |
|
} |
|
res.State = state |
|
res.Comment = comment |
|
res.Reward = s.getRewards(rids) |
|
return |
|
} |
|
|
|
//ListGiftReward for get gift list. |
|
func (s *Service) ListGiftReward() (res []*task.GiftReward, err error) { |
|
gfs := []*task.GiftReward{} |
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type>0 AND task_type>0").Find(&gfs).Error; err != nil { |
|
log.Error("ListGiftReward error(%v)", err) |
|
return |
|
} |
|
if len(gfs) == 0 { |
|
return |
|
} |
|
|
|
gfMap := make(map[int64][]*task.GiftReward) |
|
for _, v := range gfs { |
|
if v != nil { |
|
gfMap[v.TaskType] = append(gfMap[v.TaskType], v) |
|
} |
|
} |
|
|
|
tys := make([]int64, 0, len(gfMap)) |
|
for k := range gfMap { |
|
tys = append(tys, k) |
|
} |
|
sort.Slice(tys, func(i, j int) bool { |
|
return tys[i] < tys[j] |
|
}) |
|
|
|
res = make([]*task.GiftReward, 0, len(tys)) |
|
for _, ty := range tys { |
|
gfs, ok := gfMap[ty] |
|
if !ok && len(gfs) == 0 { |
|
continue |
|
} |
|
var rt uint8 |
|
if task.CheckRootType(uint8(ty)) { |
|
rt = task.TaskManagement |
|
} else { |
|
rt = task.AchievementManagement |
|
} |
|
re := &task.GiftReward{ |
|
RootType: rt, |
|
TaskType: ty, |
|
} |
|
|
|
var ( |
|
state int8 |
|
comment string |
|
) |
|
rids := make([]int64, 0, len(gfs)) |
|
for _, gf := range gfs { |
|
if gf != nil { |
|
state = gf.State |
|
comment = gf.Comment |
|
rids = append(rids, gf.RewardID) |
|
} |
|
} |
|
re.State = state |
|
re.Comment = comment |
|
re.Reward = s.getRewards(rids) |
|
res = append(res, re) |
|
} |
|
return |
|
} |
|
|
|
//AddGiftReward for add gift rewards. |
|
func (s *Service) AddGiftReward(v *task.GiftReward, rewardsIDs []int64) (rows int64, err error) { |
|
var gfs []*task.GiftReward |
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=? AND reward_id IN (?)", v.RootType, v.TaskType, rewardsIDs).Find(&gfs).Error; err != nil { |
|
log.Error("UpGiftReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
if len(gfs) != 0 { |
|
hitMap := make(map[int64]struct{}) |
|
for _, gf := range gfs { |
|
hitMap[gf.RewardID] = struct{}{} |
|
} |
|
for _, rid := range rewardsIDs { |
|
if _, ok := hitMap[rid]; ok { |
|
err = ecode.CreativeNewcomerDuplicateGiftRewardIDErr |
|
log.Error("AddGiftReward rid(%d) error(%v)", rid, err) |
|
return |
|
} |
|
} |
|
} |
|
|
|
valReward := make([]string, 0, len(rewardsIDs)) |
|
valRewardArgs := make([]interface{}, 0) |
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
for _, rid := range rewardsIDs { |
|
valReward = append(valReward, "(?, ?, ?, ?, ?, ?, ?)") |
|
valRewardArgs = append(valRewardArgs, v.RootType, v.TaskType, rid, task.StateNormal, v.Comment, now, now) |
|
} |
|
sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_gift_reward (root_type, task_type, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ",")) |
|
if err = s.DB.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil { |
|
log.Error("AddGiftReward error(%v)", err) |
|
return |
|
} |
|
return s.DB.RowsAffected, nil |
|
} |
|
|
|
//EditGiftReward for edit gift rewards. |
|
func (s *Service) EditGiftReward(v *task.GiftReward, rewardsIDs []int64) (rows int64, err error) { |
|
var ( |
|
gfs []*task.GiftReward |
|
state int8 |
|
) |
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Find(&gfs).Error; err != nil { |
|
log.Error("EditGiftReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
if len(gfs) == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
for _, gf := range gfs { //获取原来的状态 |
|
state = gf.State |
|
break |
|
} |
|
|
|
var gf task.GiftReward |
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type =?", v.RootType).Where("task_type =?", v.TaskType).Delete(&gf).Error; err != nil { |
|
log.Error("EditGiftReward delete old id(%d)|error(%v)", v.ID, err) |
|
return |
|
} |
|
|
|
valReward := make([]string, 0, len(rewardsIDs)) |
|
valRewardArgs := make([]interface{}, 0) |
|
now := time.Now().Format("2006-01-02 15:04:05") |
|
for _, rid := range rewardsIDs { |
|
valReward = append(valReward, "(?, ?, ?, ?, ?, ?, ?)") |
|
valRewardArgs = append(valRewardArgs, v.RootType, v.TaskType, rid, state, v.Comment, now, now) |
|
} |
|
sqlRewardStr := fmt.Sprintf("INSERT INTO newcomers_gift_reward (root_type, task_type, reward_id, state, comment, ctime, mtime) VALUES %s", strings.Join(valReward, ",")) |
|
if err = s.DB.Exec(sqlRewardStr, valRewardArgs...).Error; err != nil { |
|
log.Error("EditGiftReward error(%v)", err) |
|
return |
|
} |
|
return s.DB.RowsAffected, nil |
|
} |
|
|
|
//UpGiftReward for update gift reward. |
|
func (s *Service) UpGiftReward(v *task.GiftReward) (rows int64, err error) { |
|
var gfs []*task.GiftReward |
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Find(&gfs).Error; err != nil { |
|
log.Error("UpGiftReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
if len(gfs) == 0 { |
|
return |
|
} |
|
|
|
if err = s.DB.Model(&task.GiftReward{}).Where("root_type=? AND task_type=?", v.RootType, v.TaskType).Updates(map[string]interface{}{ |
|
"state": v.State, |
|
}).Error; err != nil { |
|
log.Error("UpGiftReward v(%+v) error(%v)", v, err) |
|
return |
|
} |
|
return s.DB.RowsAffected, nil |
|
} |
|
|
|
//BatchOnline for subtask & grouptask with state,rank and so on. |
|
func (s *Service) BatchOnline(tgs []*task.TaskGroup) (err error) { |
|
tasks := make([]*task.Task, 0) |
|
groups := make([]*task.TaskGroup, 0, len(tgs)) |
|
for _, v := range tgs { |
|
groups = append(groups, &task.TaskGroup{ |
|
ID: v.ID, |
|
Rank: v.Rank, |
|
State: v.State, |
|
RootType: v.RootType, |
|
Type: v.Type, |
|
}) |
|
tasks = append(tasks, v.Tasks...) |
|
} |
|
|
|
valGroups := make([]string, 0, len(groups)) |
|
valGroupArgs := make([]interface{}, 0) |
|
for _, v := range groups { |
|
valGroups = append(valGroups, "(?, ?, ?)") |
|
valGroupArgs = append(valGroupArgs, v.ID, v.State, v.Rank) |
|
} |
|
sqlGroupStr := fmt.Sprintf("INSERT INTO newcomers_task_group (id, state, rank) VALUES %s ON DUPLICATE KEY UPDATE state=VALUES(state), rank=VALUES(rank)", strings.Join(valGroups, ",")) |
|
if err = s.DB.Exec(sqlGroupStr, valGroupArgs...).Error; err != nil { |
|
log.Error("BatchOnline update groups error(%v)", err) |
|
return |
|
} |
|
|
|
valTasks := make([]string, 0, len(tasks)) |
|
valTaskArgs := make([]interface{}, 0) |
|
for _, v := range tasks { |
|
valTasks = append(valTasks, "(?, ?, ?, ?)") |
|
valTaskArgs = append(valTaskArgs, v.ID, v.State, v.Rank, v.GroupID) |
|
} |
|
sqlTaskStr := fmt.Sprintf("INSERT INTO newcomers_task (id, state, rank, group_id) VALUES %s ON DUPLICATE KEY UPDATE state=VALUES(state), rank=VALUES(rank), group_id=VALUES(group_id)", strings.Join(valTasks, ",")) |
|
if err = s.DB.Exec(sqlTaskStr, valTaskArgs...).Error; err != nil { |
|
log.Error("BatchOnline update tasks error(%v)", err) |
|
} |
|
return |
|
}
|
|
|