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.
572 lines
19 KiB
572 lines
19 KiB
package newcomer |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
|
|
"database/sql" |
|
"go-common/app/interface/main/creative/model/newcomer" |
|
"go-common/library/log" |
|
"go-common/library/xstr" |
|
"strings" |
|
) |
|
|
|
const ( |
|
// select |
|
_getUserTaskBindSQL = "SELECT count(id) FROM newcomers_task_user_%s WHERE mid=?" |
|
_getGiftRewardSQL = "SELECT reward_id FROM newcomers_gift_reward WHERE state=0 AND task_type=?" |
|
_getTaskGroupRewardSQL = "SELECT reward_id FROM newcomers_grouptask_reward WHERE state=0 AND task_group_id=?" |
|
_getIsReceivedSQL = "SELECT count(id) FROM newcomers_reward_receive WHERE mid=?" |
|
_getRewardReceiveStateSQL = "SELECT task_group_id FROM newcomers_reward_receive WHERE mid=?" |
|
_getRewardReceiveSQL = "SELECT id, mid, task_gift_id, task_group_id, reward_id, reward_type, state, receive_time, ctime, mtime FROM newcomers_reward_receive WHERE mid=? AND state IN (0,1,2) ORDER BY receive_time ASC" |
|
_getRewardSQL = "SELECT id, parent_id, type, state, is_active, prize_id, prize_unit, expire, name, logo, comment, unlock_logo, name_extra, ctime, mtime FROM newcomers_reward WHERE state=0" |
|
_getUserTaskByMIDSQL = "SELECT id, mid, task_id, task_group_id, task_type, state, task_bind_time, ctime, mtime FROM newcomers_task_user_%s WHERE state=-1 AND mid=?" |
|
_getTaskSQL = "SELECT id, group_id, type, state, target_type, target_value, title, `desc`, comment, ctime, mtime, rank, extra, fan_range, up_time, down_time FROM newcomers_task WHERE state IN (0,1) ORDER BY rank ASC" |
|
_getAllTaskGroupRewardSQL = "SELECT id,task_group_id,reward_id,state,comment,ctime,mtime FROM newcomers_grouptask_reward WHERE state=0" |
|
_getAllGiftRewardSQL = "SELECT id,root_type,task_type,reward_id,state,comment,ctime,mtime FROM newcomers_gift_reward WHERE state=0" |
|
_getUserTaskSQL = "SELECT task_id,state FROM newcomers_task_user_%s WHERE mid=?" |
|
_getRewardReceiveByIDSQL = "SELECT id, mid, task_gift_id, task_group_id, reward_id, reward_type, state, receive_time, ctime, mtime FROM newcomers_reward_receive WHERE mid=? AND id=?" |
|
_getTaskGroupSQL = "SELECT id, rank, state, root_type, type, ctime, mtime FROM newcomers_task_group WHERE state=0" |
|
_getTaskRewardSQL = "SELECT id,task_id,reward_id,state,comment,ctime,mtime FROM newcomers_task_reward WHERE state=0" |
|
_getRewardReceiveByOldInfo = "SELECT id, mid, oid, type, reward_id, reward_type, state, ctime, mtime FROM newcomers_reward_receive_%s WHERE mid=? AND oid=? AND type=? AND reward_id=?" |
|
// insert |
|
// _inRewardReceiveSQL = "INSERT INTO newcomers_reward_receive (mid, task_gift_id, task_group_id, reward_id, reward_type, state, receive_time, ctime, mtime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)" |
|
// update |
|
_upRewardReceiveSQL = "UPDATE newcomers_reward_receive SET state=? WHERE mid=? AND id=?" |
|
_upRewardReceiveSQL2 = "UPDATE newcomers_reward_receive_%s SET state=? WHERE mid=? AND id=?" |
|
// update |
|
_upUserTaskSQL = "UPDATE newcomers_task_user_%s SET state=? WHERE mid=? AND task_id=?" |
|
) |
|
|
|
// getTableName by mid%100 |
|
func getTableName(mid int64) string { |
|
return fmt.Sprintf("%02d", mid%100) |
|
} |
|
|
|
// UserTaskBind determine if the user has bound the task |
|
func (d *Dao) UserTaskBind(c context.Context, mid int64) (res int64, err error) { |
|
row := d.db.QueryRow(c, fmt.Sprintf(_getUserTaskBindSQL, getTableName(mid)), mid) |
|
if err = row.Scan(&res); err != nil { |
|
log.Error("UserTaskBind d.db.QueryRow error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// IsRewardReceived if the basic reward and the gift award have been received |
|
func (d *Dao) IsRewardReceived(c context.Context, mid int64, rid int64, rewardType int8) (res bool, err error) { |
|
sqlStr := _getIsReceivedSQL |
|
if rewardType == newcomer.RewardGiftType { |
|
sqlStr += fmt.Sprintf(" AND task_gift_id=?") |
|
} else { |
|
sqlStr += fmt.Sprintf(" AND task_group_id=?") |
|
} |
|
row := d.db.QueryRow(c, sqlStr, mid, rid) |
|
count := 0 |
|
if err = row.Scan(&count); err != nil { |
|
log.Error("isRewardReceived d.db.Query error(%v)", err) |
|
return |
|
} |
|
if count > 0 { |
|
return true, nil |
|
} |
|
return |
|
} |
|
|
|
// RewardReceivedGroup get []task_group_id by []group_id |
|
func (d *Dao) RewardReceivedGroup(c context.Context, mid int64, ids []int64) (res []int, err error) { |
|
if len(ids) == 0 { |
|
return |
|
} |
|
sqlStr := _getRewardReceiveStateSQL |
|
sqlStr += fmt.Sprintf(" AND task_group_id IN (%s)", xstr.JoinInts(ids)) |
|
rows, err := d.db.Query(c, sqlStr, mid) |
|
if err != nil { |
|
log.Error("RewardReceivedGroup d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make([]int, 0) |
|
for rows.Next() { |
|
gid := 0 |
|
if err = rows.Scan(&gid); err != nil { |
|
log.Error("RewardReceivedGroup rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, gid) |
|
} |
|
|
|
return |
|
} |
|
|
|
// GiftRewards get the rewards of gift by task_type |
|
func (d *Dao) GiftRewards(c context.Context, taskType int8) (res []int64, err error) { |
|
rows, err := d.db.Query(c, _getGiftRewardSQL, taskType) |
|
if err != nil { |
|
log.Error("GiftRewards d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make([]int64, 0) |
|
for rows.Next() { |
|
var r int64 |
|
if err = rows.Scan(&r); err != nil { |
|
log.Error("GiftRewards rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
|
|
return |
|
} |
|
|
|
// TaskGroupRewards get the rewards of gift by group_id |
|
func (d *Dao) TaskGroupRewards(c context.Context, groupID int64) (res []int64, err error) { |
|
rows, err := d.db.Query(c, _getTaskGroupRewardSQL, groupID) |
|
if err != nil { |
|
log.Error("TaskGroupRewards d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make([]int64, 0) |
|
for rows.Next() { |
|
var r int64 |
|
if err = rows.Scan(&r); err != nil { |
|
log.Error("TaskGroupRewards rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
|
|
return |
|
} |
|
|
|
// RewardCompleteState judge the completion of the task |
|
func (d *Dao) RewardCompleteState(c context.Context, mid int64, tids []int64) (res int64, err error) { |
|
sqlStr := fmt.Sprintf(_getUserTaskSQL, getTableName(mid)) |
|
sqlStr += fmt.Sprintf(" AND task_id IN (%s)", xstr.JoinInts(tids)) |
|
rows, err := d.db.Query(c, sqlStr, mid) |
|
if err != nil { |
|
log.Error("RewardCompleteState d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = 0 |
|
for rows.Next() { |
|
t := &newcomer.Task{} |
|
if err = rows.Scan(&t.ID, &t.CompleteSate); err != nil { |
|
log.Error("RewardCompleteState rows.Scan error(%v)", err) |
|
return |
|
} |
|
if t.CompleteSate == newcomer.TaskIncomplete { |
|
res++ |
|
} |
|
} |
|
return |
|
} |
|
|
|
// RewardReceive add reward receive records. |
|
func (d *Dao) RewardReceive(c context.Context, places string, args []interface{}) (int64, error) { |
|
var ( |
|
res sql.Result |
|
err error |
|
) |
|
|
|
sqlStr := fmt.Sprintf("INSERT INTO newcomers_reward_receive(mid, task_gift_id, task_group_id, reward_id, reward_type, state) VALUES %s", places) |
|
res, err = d.db.Exec(c, sqlStr, args...) |
|
if err != nil { |
|
log.Error("RewardReceive tx.Exec error(%v)", err) |
|
return 0, err |
|
} |
|
|
|
return res.LastInsertId() |
|
} |
|
|
|
// RewardActivate activate reward. |
|
func (d *Dao) RewardActivate(c context.Context, mid, id int64) (int64, error) { |
|
res, err := d.db.Exec(c, _upRewardReceiveSQL, newcomer.RewardActivatedNotClick, mid, id) |
|
if err != nil { |
|
log.Error("RewardActivate d.db.Exec mid(%d) id(%d) error(%v)", mid, id, err) |
|
return 0, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
//RewardReceives get reward receive by mid. |
|
func (d *Dao) RewardReceives(c context.Context, mid int64) (res map[int8][]*newcomer.RewardReceive, err error) { |
|
rows, err := d.db.Query(c, _getRewardReceiveSQL, mid) |
|
if err != nil { |
|
log.Error("RewardReceives d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make(map[int8][]*newcomer.RewardReceive) |
|
for rows.Next() { |
|
r := &newcomer.RewardReceive{} |
|
if err = rows.Scan(&r.ID, &r.MID, &r.TaskGiftID, &r.TaskGroupID, &r.RewardID, &r.RewardType, &r.State, &r.ReceiveTime, &r.CTime, &r.MTime); err != nil { |
|
log.Error("RewardReceives rows.Scan error(%v)", err) |
|
return |
|
} |
|
res[r.RewardType] = append(res[r.RewardType], r) |
|
} |
|
return |
|
} |
|
|
|
//Rewards get all reward receive. |
|
func (d *Dao) Rewards(c context.Context) (res []*newcomer.Reward, err error) { |
|
rows, err := d.db.Query(c, _getRewardSQL) |
|
if err != nil { |
|
log.Error("Rewards d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*newcomer.Reward, 0) |
|
for rows.Next() { |
|
r := &newcomer.Reward{} |
|
if err = rows.Scan(&r.ID, &r.ParentID, &r.Type, &r.State, &r.IsActive, &r.PriceID, &r.PrizeUnit, &r.Expire, &r.Name, &r.Logo, &r.Comment, &r.UnlockLogo, &r.NameExtra, &r.CTime, &r.MTime); err != nil { |
|
log.Error("Rewards rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
return |
|
} |
|
|
|
// BindTasks user bind tasks |
|
func (d *Dao) BindTasks(c context.Context, mid int64, places string, args []interface{}) (res int64, err error) { |
|
sqlStr := fmt.Sprintf("INSERT INTO newcomers_task_user_%s(mid , task_id , task_group_id , task_type , state) VALUES %s", getTableName(mid), places) |
|
result, err := d.db.Exec(c, sqlStr, args...) |
|
if err != nil { |
|
log.Error("BindTasks d.db.Exec error(%v)", err) |
|
return |
|
} |
|
return result.LastInsertId() |
|
} |
|
|
|
// GiftRewardCount get received gift reward count |
|
func (d *Dao) GiftRewardCount(c context.Context, mid int64, ids []int64) (res int64, err error) { |
|
if len(ids) == 0 { |
|
return |
|
} |
|
sqlStr := fmt.Sprintf("SELECT count(DISTINCT task_gift_id) FROM newcomers_reward_receive WHERE mid=? AND task_gift_id IN (%s)", xstr.JoinInts(ids)) |
|
row := d.db.QueryRow(c, sqlStr, mid) |
|
err = row.Scan(&res) |
|
if err != nil { |
|
log.Error("GiftRewardCount d.db.QueryRow error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// BaseRewardCount get received base reward count |
|
func (d *Dao) BaseRewardCount(c context.Context, mid int64, ids []int64) (res int64, err error) { |
|
if len(ids) == 0 { |
|
return |
|
} |
|
sqlStr := fmt.Sprintf("SELECT count(DISTINCT task_group_id) FROM newcomers_reward_receive WHERE mid=? AND task_group_id IN (%s)", xstr.JoinInts(ids)) |
|
row := d.db.QueryRow(c, sqlStr, mid) |
|
err = row.Scan(&res) |
|
if err != nil { |
|
log.Error("BaseRewardCount d.db.QueryRow error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
//Tasks get all task. |
|
func (d *Dao) Tasks(c context.Context) (res []*newcomer.Task, err error) { |
|
rows, err := d.db.Query(c, _getTaskSQL) |
|
if err != nil { |
|
log.Error("Tasks d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*newcomer.Task, 0) |
|
|
|
for rows.Next() { |
|
r := &newcomer.Task{} |
|
if err = rows.Scan(&r.ID, &r.GroupID, &r.Type, &r.State, &r.TargetType, &r.TargetValue, &r.Title, &r.Desc, &r.Comment, &r.CTime, &r.MTime, &r.Rank, &r.Extra, &r.FanRange, &r.UpTime, &r.DownTime); err != nil { |
|
log.Error("Tasks rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
return |
|
} |
|
|
|
//UserTasksByMID get user unfinish task by mid. |
|
func (d *Dao) UserTasksByMID(c context.Context, mid int64) (res []*newcomer.UserTask, err error) { |
|
rows, err := d.db.Query(c, fmt.Sprintf(_getUserTaskByMIDSQL, getTableName(mid)), mid) |
|
if err != nil { |
|
log.Error("UserTasksByMID d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*newcomer.UserTask, 0) |
|
for rows.Next() { |
|
r := &newcomer.UserTask{} |
|
if err = rows.Scan(&r.ID, &r.MID, &r.TaskID, &r.TaskGroupID, &r.TaskType, &r.State, &r.TaskBindTime, &r.CTime, &r.MTime); err != nil { |
|
log.Error("UserTasksByMID rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, r) |
|
} |
|
return |
|
} |
|
|
|
// UpUserTask update user task finish state |
|
func (d *Dao) UpUserTask(c context.Context, mid, tid int64) (int64, error) { |
|
res, err := d.db.Exec(c, fmt.Sprintf(_upUserTaskSQL, getTableName(mid)), 0, mid, tid) |
|
if err != nil { |
|
log.Error("RewardActivate d.db.Exec mid(%d) id(%d) error(%v)", mid, tid, err) |
|
return 0, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// UserTaskType Determining the type of task that users have |
|
func (d *Dao) UserTaskType(c context.Context, mid int64) (res int8, err error) { |
|
sqlStr := fmt.Sprintf("SELECT count(DISTINCT task_type) FROM newcomers_task_user_%s WHERE mid=?", getTableName(mid)) |
|
row := d.db.QueryRow(c, sqlStr, mid) |
|
if err = row.Scan(&res); err != nil { |
|
log.Error("UserTaskType row.Scan(&res) mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// AllTaskGroupRewards get all TaskGroupRewards for cache |
|
func (d *Dao) AllTaskGroupRewards(c context.Context) (res map[int64][]*newcomer.TaskGroupReward, err error) { |
|
rows, err := d.db.Query(c, _getAllTaskGroupRewardSQL) |
|
if err != nil { |
|
log.Error("AllTaskGroupRewards d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make(map[int64][]*newcomer.TaskGroupReward) |
|
for rows.Next() { |
|
t := &newcomer.TaskGroupReward{} |
|
if err = rows.Scan(&t.ID, &t.TaskGroupID, &t.RewardID, &t.State, &t.Comment, &t.CTime, &t.MTime); err != nil { |
|
log.Error("AllTaskGroupRewards rows.Scan error(%v)", err) |
|
return |
|
} |
|
res[t.TaskGroupID] = append(res[t.TaskGroupID], t) |
|
} |
|
return |
|
} |
|
|
|
// AllGiftRewards get all GiftRewards for cache |
|
func (d *Dao) AllGiftRewards(c context.Context) (res map[int8][]*newcomer.GiftReward, err error) { |
|
rows, err := d.db.Query(c, _getAllGiftRewardSQL) |
|
if err != nil { |
|
log.Error("AllTaskGroupRewards d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
res = make(map[int8][]*newcomer.GiftReward) |
|
for rows.Next() { |
|
t := &newcomer.GiftReward{} |
|
if err = rows.Scan(&t.ID, &t.RootType, &t.TaskType, &t.RewardID, &t.State, &t.Comment, &t.CTime, &t.MTime); err != nil { |
|
log.Error("AllTaskGroupRewards rows.Scan error(%v)", err) |
|
return |
|
} |
|
res[t.TaskType] = append(res[t.TaskType], t) |
|
} |
|
return |
|
} |
|
|
|
// UserTasks get user tasks |
|
func (d *Dao) UserTasks(c context.Context, mid int64) (res []*newcomer.Task, err error) { |
|
sqlStr := fmt.Sprintf(_getUserTaskSQL, getTableName(mid)) |
|
rows, err := d.db.Query(c, sqlStr, mid) |
|
if err != nil { |
|
log.Error("UserTasks d.db.Query mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make([]*newcomer.Task, 0) |
|
for rows.Next() { |
|
t := &newcomer.Task{} |
|
if err = rows.Scan(&t.ID, &t.CompleteSate); err != nil { |
|
log.Error("UserTasks rows.Scan mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
res = append(res, t) |
|
} |
|
return |
|
} |
|
|
|
// RewardReceiveByID get rewardReceive by receiveID |
|
func (d *Dao) RewardReceiveByID(c context.Context, mid, receiveID int64) (res *newcomer.RewardReceive, err error) { |
|
row := d.db.QueryRow(c, _getRewardReceiveByIDSQL, mid, receiveID) |
|
res = &newcomer.RewardReceive{} |
|
if err = row.Scan(&res.ID, &res.MID, &res.TaskGiftID, &res.TaskGroupID, &res.RewardID, &res.RewardType, &res.State, &res.ReceiveTime, &res.CTime, &res.MTime); err != nil { |
|
log.Error("RewardIDByReceiveID row.Scan error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// TaskGroups get task-group |
|
func (d *Dao) TaskGroups(c context.Context) (res []*newcomer.TaskGroupEntity, err error) { |
|
rows, err := d.db.Query(c, _getTaskGroupSQL) |
|
if err != nil { |
|
log.Error("TaskGroups d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make([]*newcomer.TaskGroupEntity, 0) |
|
for rows.Next() { |
|
t := &newcomer.TaskGroupEntity{} |
|
if err = rows.Scan(&t.ID, &t.Rank, &t.State, &t.RootType, &t.Type, &t.CTime, &t.MTime); err != nil { |
|
log.Error("TaskGroups rows.Scan error(%v)", err) |
|
return |
|
} |
|
res = append(res, t) |
|
} |
|
return |
|
} |
|
|
|
// TaskRewards get task-rewards |
|
func (d *Dao) TaskRewards(c context.Context) (res map[int64][]*newcomer.TaskRewardEntity, err error) { |
|
rows, err := d.db.Query(c, _getTaskRewardSQL) |
|
if err != nil { |
|
log.Error("TaskRewards d.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
res = make(map[int64][]*newcomer.TaskRewardEntity) |
|
for rows.Next() { |
|
t := &newcomer.TaskRewardEntity{} |
|
if err = rows.Scan(&t.ID, &t.TaskID, &t.RewardID, &t.State, &t.Comment, &t.CTime, &t.MTime); err != nil { |
|
log.Error("TaskRewards rows.Scan error(%v)", err) |
|
return |
|
} |
|
res[t.TaskID] = append(res[t.TaskID], t) |
|
} |
|
return |
|
} |
|
|
|
// RewardReceive2 add reward receive records. |
|
func (d *Dao) RewardReceive2(c context.Context, mid int64, rrs []*newcomer.RewardReceive2) (res int64, err error) { |
|
if len(rrs) == 0 { |
|
return 0, nil |
|
} |
|
|
|
tx, err := d.db.Begin(c) |
|
if err != nil { |
|
log.Error("RewardReceive2 d.db.Begin mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
|
|
place := make([]string, 0) |
|
args := make([]interface{}, 0) |
|
for _, v := range rrs { |
|
place = append(place, "(?, ?, ?, ?, ? ,?)") |
|
if v.Type == newcomer.RewardBaseType { |
|
args = append(args, v.MID, 0, v.OID, v.RewardID, v.RewardType, v.State) |
|
} else if v.Type == newcomer.RewardGiftType { |
|
args = append(args, v.MID, v.OID, 0, v.RewardID, v.RewardType, v.State) |
|
} |
|
} |
|
placeStr := strings.Join(place, ",") |
|
sqlStr := fmt.Sprintf("INSERT INTO newcomers_reward_receive(mid, task_gift_id, task_group_id, reward_id, reward_type, state) VALUES %s", placeStr) |
|
_, err = tx.Exec(sqlStr, args...) |
|
if err != nil { |
|
if rollbackErr := tx.Rollback(); rollbackErr != nil { |
|
log.Error("RewardReceive2 tx.Rollback mid(%d)|error(%v)", mid, rollbackErr) |
|
} |
|
log.Error("RewardReceive2 tx.Exec mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
|
|
// insert to new table |
|
placeNew := make([]string, 0) |
|
argsNew := make([]interface{}, 0) |
|
for _, v := range rrs { |
|
placeNew = append(placeNew, "(?, ?, ?, ?, ? ,?)") |
|
argsNew = append(argsNew, v.MID, v.OID, v.Type, v.RewardID, v.RewardType, v.State) |
|
} |
|
placeStrNew := strings.Join(placeNew, ",") |
|
sqlStrNew := fmt.Sprintf("INSERT INTO newcomers_reward_receive_%s(mid, oid, type, reward_id, reward_type, state) VALUES %s", getTableName(mid), placeStrNew) |
|
result, err := tx.Exec(sqlStrNew, argsNew...) |
|
if err != nil { |
|
if rollbackErr := tx.Rollback(); rollbackErr != nil { |
|
log.Error("RewardReceive2 tx.Rollback mid(%d)|error(%v)", mid, rollbackErr) |
|
} |
|
log.Error("RewardReceive2 tx.Exec mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
if err = tx.Commit(); err != nil { |
|
log.Error("RewardReceive2 tx.Commit() mid(%d)|error(%v)", mid, err) |
|
return |
|
} |
|
|
|
return result.LastInsertId() |
|
} |
|
|
|
// RewardReceiveByOldInfo get rewardReceive2 by old info |
|
func (d *Dao) RewardReceiveByOldInfo(c context.Context, r *newcomer.RewardReceive) (res *newcomer.RewardReceive2, err error) { |
|
sqlStr := fmt.Sprintf(_getRewardReceiveByOldInfo, getTableName(r.MID)) |
|
var ( |
|
oid int64 |
|
ty int8 |
|
) |
|
if r.TaskGiftID == 0 && r.TaskGroupID != 0 { |
|
oid = r.TaskGroupID |
|
ty = newcomer.RewardBaseType |
|
} else if r.TaskGroupID == 0 && r.TaskGiftID != 0 { |
|
oid = r.TaskGiftID |
|
ty = newcomer.RewardGiftType |
|
} |
|
row := d.db.QueryRow(c, sqlStr, r.MID, oid, ty, r.RewardID) |
|
res = &newcomer.RewardReceive2{} |
|
if err = row.Scan(&res.ID, &res.MID, &res.OID, &res.Type, &res.RewardID, &res.RewardType, &res.State, &res.CTime, &res.MTime); err != nil { |
|
log.Error("RewardReceiveByOldInfo row.Scan error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RewardActivate2 activate reward double write |
|
func (d *Dao) RewardActivate2(c context.Context, mid, oid, nid int64) (int64, error) { |
|
tx, err := d.db.Begin(c) |
|
if err != nil { |
|
log.Error("RewardActivate2 d.db.Begin mid(%d)|error(%v)", mid, err) |
|
return 0, err |
|
} |
|
|
|
_, err = tx.Exec(_upRewardReceiveSQL, newcomer.RewardActivatedNotClick, mid, oid) |
|
if err != nil { |
|
if rollbackErr := tx.Rollback(); rollbackErr != nil { |
|
log.Error("RewardActivate2 tx.Rollback mid(%d)|error(%v)", mid, rollbackErr) |
|
} |
|
log.Error("RewardActivate2 tx.Exec mid(%d)|error(%v)", mid, err) |
|
return 0, err |
|
} |
|
|
|
// update new table |
|
sqlStr := fmt.Sprintf(_upRewardReceiveSQL2, getTableName(mid)) |
|
res, err := tx.Exec(sqlStr, newcomer.RewardActivatedNotClick, mid, nid) |
|
if err != nil { |
|
if rollbackErr := tx.Rollback(); rollbackErr != nil { |
|
log.Error("RewardActivate2 tx.Rollback mid(%d)|error(%v)", mid, rollbackErr) |
|
} |
|
log.Error("RewardActivate2 tx.Exec mid(%d)|error(%v)", mid, err) |
|
return 0, err |
|
} |
|
if err = tx.Commit(); err != nil { |
|
log.Error("RewardActivate2 tx.Commit() mid(%d)|error(%v)", mid, err) |
|
return 0, err |
|
} |
|
|
|
return res.RowsAffected() |
|
}
|
|
|