openbilibili/app/interface/main/creative/dao/newcomer/task.go

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()
}