openbilibili/app/admin/main/growup/service/speical_award.go

package service

import (
	"bytes"
	"context"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

	"go-common/app/admin/main/growup/dao"
	"go-common/app/admin/main/growup/dao/resource"
	"go-common/app/admin/main/growup/model"
	"go-common/app/admin/main/growup/util"

	"go-common/library/database/sql"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/xstr"
)

const (
	awardEditable = iota + 1
	awardInfoEditable
	awardDivisionEditable
	awardPrizeEditable
	awardResourceEditable
)

const (
	_awardResourceTypeRule   = 1
	_awardResourceTypeDetail = 3
	_awardResourceTypeQ      = 5
	_awardResourceTypeA      = 6
)

func awardEditPerms(award *model.Award) (res map[int]bool) {
	var (
		now           = time.Now()
		notDisplay    = award.DisplayStatus == 1
		notFinished   = award.OpenStatus == 1
		preCycleStart = now.Before(award.CycleStart)
	)
	res = map[int]bool{
		awardEditable:         notDisplay || notFinished,
		awardInfoEditable:     notDisplay || preCycleStart,
		awardDivisionEditable: notDisplay || preCycleStart,
		awardPrizeEditable:    notDisplay || notFinished,
		awardResourceEditable: notDisplay || notFinished,
	}
	return
}

func (s *Service) generateAwardID() (awardID int64, err error) {
	awardID, err = util.NewSnowFlake().Generate()
	return
}

func (s *Service) validateAwardCycle(c context.Context, awardID int64, start, end time.Time) (ok bool, err error) {
	// simplified version: check all
	awardBases, err := s.dao.ListAward(c)
	if err != nil {
		return
	}
	between := func(t, a, b time.Time) bool {
		return !(t.Before(a) || t.After(b))
	}
	for _, v := range awardBases {
		if awardID == v.AwardID || v.DisplayStatus != 2 {
			continue
		}
		if between(start, v.CycleStart, v.CycleEnd) || between(end, v.CycleStart, v.CycleEnd) {
			ok = false
			return
		}
	}
	ok = true
	return
}

// AddAward .
func (s *Service) AddAward(c context.Context, arg *model.AddAwardArg, username string) (awardID int64, err error) {
	// 1. validation
	if !(arg.DisplayStatus == 1 || arg.DisplayStatus == 2) {
		err = ecode.RequestErr
		return
	}
	// 2. args
	// generate awardID
	awardID, err = s.generateAwardID()
	if err != nil {
		return
	}
	// cycle
	start := util.ToDayStart(time.Unix(arg.CycleStart, 0))
	end := util.ToDayEnd(time.Unix(arg.CycleEnd, 0))
	if arg.CycleStart > 0 && arg.CycleEnd > 0 && arg.DisplayStatus == 2 {
		var validCycle bool
		validCycle, err = s.validateAwardCycle(c, awardID, start, end)
		if err != nil {
			return
		}
		if !validCycle {
			err = ecode.Error(ecode.RequestErr, "评选周期重叠")
			return
		}
	}
	// total
	totalWinner, totalBonus := 0, 0
	if len(arg.Prizes) > 0 {
		for _, v := range arg.Prizes {
			totalWinner += v.Quota
			totalBonus += v.Bonus * v.Quota
		}
	}
	// 3. tx insert
	var (
		cycleStart   = start.Format("2006-01-02 15:04:05")
		cycleEnd     = end.Format("2006-01-02 15:04:05")
		announce     = util.ToDayNoon(time.Unix(arg.AnnounceDate, 0))
		announceDate = announce.Format("2006-01-02")
		openTime     = announce.Format("2006-01-02 15:04:05")
	)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		_, err = dao.AddAward(tx, awardID, arg.AwardName, cycleStart, cycleEnd, announceDate, openTime,
			arg.DisplayStatus, totalWinner, totalBonus, username)
		if err != nil {
			return
		}
		if len(arg.Divisions) > 0 {
			fields, values := saveDivisionStr(awardID, arg.Divisions)
			if values != "" {
				_, err = dao.SaveDivisions(tx, fields, values)
				if err != nil {
					return
				}
			}
		}
		if len(arg.Prizes) > 0 {
			fields, values := savePrizesStr(awardID, arg.Prizes)
			if values != "" {
				_, err = dao.SavePrizes(tx, fields, values)
				if err != nil {
					return
				}
			}
		}
		if arg.Resources != nil {
			fields, values := saveResourcesStr(awardID, arg.Resources)
			if values != "" {
				_, err = dao.SaveResource(tx, fields, values)
				if err != nil {
					return
				}
			}
		}
		return nil
	})

	return
}

func saveWinnerStr(winnersM map[int64]*model.AwardWinner) (fields, values string) {
	if len(winnersM) == 0 {
		return
	}
	fields = "award_id,mid,division_id,prize_id,tag_id"
	var buf bytes.Buffer
	for _, v := range winnersM {
		buf.WriteString("(")
		buf.WriteString(strconv.FormatInt(v.AwardID, 10))
		buf.WriteByte(',')
		buf.WriteString(strconv.FormatInt(v.MID, 10))
		buf.WriteByte(',')
		buf.WriteString(strconv.FormatInt(v.DivisionID, 10))
		buf.WriteByte(',')
		buf.WriteString(strconv.FormatInt(v.PrizeID, 10))
		buf.WriteByte(',')
		buf.WriteString(strconv.FormatInt(v.TagID, 10))
		buf.WriteString(")")
		buf.WriteByte(',')
	}
	if buf.Len() > 0 {
		buf.Truncate(buf.Len() - 1)
	}
	values = buf.String()
	values += " ON DUPLICATE KEY UPDATE division_id=VALUES(division_id), prize_id=VALUES(prize_id), tag_id=VALUES(tag_id), is_deleted=0"
	buf.Reset()
	return
}

func saveDivisionStr(awardID int64, divisions []*model.AwardDivision) (fields, values string) {
	if len(divisions) == 0 {
		return
	}
	vs := make([]string, 0)
	for i, v := range divisions {
		vs = append(vs, fmt.Sprintf("(%d,%d,'%s',%d)", awardID, i+1, v.DivisionName, v.TagID))
	}
	if len(vs) > 0 {
		fields = "award_id,division_id,division_name,tag_id"
		values = strings.Join(vs, ",") + " ON DUPLICATE KEY UPDATE division_name=VALUES(division_name), tag_id=VALUES(tag_id), is_deleted=0"
	}
	return
}

func savePrizesStr(awardID int64, prizes []*model.AwardPrize) (fields, values string) {
	if len(prizes) == 0 {
		return
	}
	vs := make([]string, 0)
	for i, v := range prizes {
		vs = append(vs, fmt.Sprintf("(%d,%d,%d,%d)", awardID, i+1, v.Bonus, v.Quota))
	}
	if len(vs) > 0 {
		fields = "award_id,prize_id,bonus,quota"
		values = strings.Join(vs, ",") + " ON DUPLICATE KEY UPDATE bonus=VALUES(bonus), quota=VALUES(quota), is_deleted=0"
	}
	return
}

func delResourcesStr(awardID int64, arg *model.AwardResource) (delWhere string) {
	if len(arg.QA) == 0 {
		return fmt.Sprintf("award_id = %d AND resource_type IN (%d,%d)", awardID, _awardResourceTypeQ, _awardResourceTypeA)
	}
	idx := make([]int64, 0)
	for i := range arg.QA {
		idx = append(idx, int64(i+1))
	}
	return fmt.Sprintf("award_id = %d AND resource_type IN (%d,%d) AND resource_index NOT IN (%s)",
		awardID, _awardResourceTypeQ, _awardResourceTypeA, xstr.JoinInts(idx))
}

func saveResourcesStr(awardID int64, arg *model.AwardResource) (fields, values string) {
	if arg == nil {
		return
	}
	vs := make([]string, 0)
	vs = append(vs, fmt.Sprintf("(%d,%d,1,'%s')", awardID, _awardResourceTypeRule, arg.Rule))
	vs = append(vs, fmt.Sprintf("(%d,%d,1,'%s')", awardID, _awardResourceTypeDetail, arg.Detail))
	if len(arg.QA) > 0 {
		for i, qa := range arg.QA {
			vs = append(vs, fmt.Sprintf("(%d,%d,%d,'%s')", awardID, _awardResourceTypeQ, i+1, qa.Q))
			vs = append(vs, fmt.Sprintf("(%d,%d,%d,'%s')", awardID, _awardResourceTypeA, i+1, qa.A))
		}
	}
	if len(vs) > 0 {
		fields = "award_id,resource_type,resource_index,content"
		values = strings.Join(vs, ",") + " ON DUPLICATE KEY UPDATE content=VALUES(content), is_deleted=0"
	}
	return
}

// UpdateAward .
func (s *Service) UpdateAward(c context.Context, arg *model.SaveAwardArg) (err error) {
	// 1.
	if !(arg.DisplayStatus == 1 || arg.DisplayStatus == 2) || arg.AwardID == 0 {
		return ecode.Error(ecode.RequestErr, "illegal param")
	}
	awardID := arg.AwardID
	award, err := s.dao.Award(c, awardID)
	if err != nil {
		return
	}
	if award == nil {
		err = ecode.Error(ecode.RequestErr, "illegal award_id")
		return
	}
	//
	permission := awardEditPerms(award)
	if !permission[awardEditable] {
		err = ecode.Error(ecode.RequestErr, "award no longer editable")
		return
	}
	// sum
	totalQuota, totalBonus := 0, 0
	if len(arg.Prizes) > 0 {
		for _, v := range arg.Prizes {
			totalQuota += v.Quota
			totalBonus += v.Bonus * v.Quota
		}
	}
	newAward := &model.Award{
		AwardName:     arg.AwardName,
		CycleStart:    util.ToDayStart(time.Unix(arg.CycleStart, 0)),
		CycleEnd:      util.ToDayEnd(time.Unix(arg.CycleEnd, 0)),
		AnnounceDate:  time.Unix(arg.AnnounceDate, 0),
		OpenTime:      util.ToDayNoon(time.Unix(arg.AnnounceDate, 0)),
		DisplayStatus: arg.DisplayStatus,
		TotalQuota:    totalQuota,
		TotalBonus:    totalBonus,
	}

	if permission[awardInfoEditable] && arg.DisplayStatus == 2 {
		if !newAward.CycleStart.Equal(award.CycleStart) || !newAward.CycleEnd.Equal(award.CycleEnd) {
			var ok bool
			ok, err = s.validateAwardCycle(c, awardID, newAward.CycleStart, newAward.CycleEnd)
			if err != nil {
				return
			}
			if !ok {
				err = ecode.Error(ecode.RequestErr, "评选周期重叠")
				return
			}
		}
	}

	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		// lock
		award, err = dao.SelectAwardForUpdate(tx, awardID)
		if err != nil {
			return
		}
		if award == nil {
			return ecode.Error(ecode.RequestErr, "award not found")
		}
		//// award info
		if permission[awardInfoEditable] {
			updateAwardStr := fmt.Sprintf(`award_name='%s', cycle_start='%s', cycle_end='%s', 
		announce_date='%s', open_time='%s', display_status=%d, total_quota=%d, total_bonus=%d`,
				newAward.AwardName,
				newAward.CycleStart.Format("2006-01-02 15:04:05"),
				newAward.CycleEnd.Format("2006-01-02 15:04:05"),
				newAward.AnnounceDate.Format("2006-01-02"),
				newAward.OpenTime.Format("2006-01-02 15:04:05"),
				newAward.DisplayStatus, newAward.TotalQuota, newAward.TotalBonus)
			_, err = dao.UpdateAward(tx, awardID, updateAwardStr)
			if err != nil {
				return
			}
		}
		//// divisions
		if permission[awardDivisionEditable] {
			switch {
			case len(arg.Divisions) == 0:
				_, err = dao.DelDivisionAll(tx, awardID)
				if err != nil {
					return
				}
			default:
				// del
				argDivisionIDs := make([]int64, 0)
				for i, v := range arg.Divisions {
					v.DivisionID = int64(i + 1)
					argDivisionIDs = append(argDivisionIDs, v.DivisionID)
				}
				_, err = dao.DelDivisionsExclude(tx, awardID, argDivisionIDs)
				if err != nil {
					return
				}
				// save
				fields, values := saveDivisionStr(awardID, arg.Divisions)
				_, err = dao.SaveDivisions(tx, fields, values)
				if err != nil {
					return
				}
			}
		}
		//// prizes
		if permission[awardPrizeEditable] {
			switch {
			case len(arg.Prizes) == 0:
				_, err = dao.DelPrizeAll(tx, awardID)
				if err != nil {
					return
				}
			default:
				// del
				argPrizeIDs := make([]int64, 0)
				for i, v := range arg.Prizes {
					v.PrizeID = int64(i + 1)
					argPrizeIDs = append(argPrizeIDs, v.PrizeID)
				}
				_, err = dao.DelPrizesExclude(tx, awardID, argPrizeIDs)
				if err != nil {
					return
				}
				fields, values := savePrizesStr(awardID, arg.Prizes)
				_, err = dao.SavePrizes(tx, fields, values)
				if err != nil {
					return
				}
			}
		}
		//// resources
		if permission[awardResourceEditable] {
			switch {
			case arg.Resources == nil:
				_, err = dao.DelResources(tx, fmt.Sprintf("award_id = %d", awardID))
				if err != nil {
					return
				}
			default:
				delWhere := delResourcesStr(awardID, arg.Resources)
				_, err = dao.DelResources(tx, delWhere)
				if err != nil {
					return
				}
				fields, values := saveResourcesStr(awardID, arg.Resources)
				_, err = dao.SaveResource(tx, fields, values)
				if err != nil {
					return
				}
			}
		}
		return nil
	})
	return err
}

// ListAward .
func (s *Service) ListAward(c context.Context, from, limit int) (total int64, data []*model.AwardListModel, err error) {
	data = make([]*model.AwardListModel, 0)
	var (
		awardToWinnerC map[int64]int
		awards         []*model.Award
		divisions      []*model.AwardDivision
	)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		total, err = dao.CountAward(tx)
		if err != nil {
			return
		}
		if total == 0 {
			return
		}
		awards, err = dao.ListAward(tx, from, limit)
		if err != nil {
			return
		}
		if len(awards) == 0 {
			return
		}
		awardIDs := make([]int64, 0)
		for _, v := range awards {
			awardIDs = append(awardIDs, v.AwardID)
		}
		divisions, err = dao.ListAwardsDivision(tx, fmt.Sprintf("award_id IN (%s)", xstr.JoinInts(awardIDs)))
		if err != nil {
			return
		}
		awardToWinnerC, err = dao.GroupCountAwardWinner(tx, fmt.Sprintf("award_id IN (%s)", xstr.JoinInts(awardIDs)))
		if err != nil {
			return
		}
		return nil
	})
	if err != nil || total == 0 || len(awards) == 0 {
		return
	}
	// divisions group by award_id
	var (
		tagIDToName      map[int64]string
		awardToDivisions = make(map[int64][]*model.AwardDivision)
	)
	tagIDToName, err = resource.VideoCategoryIDToName(c)
	if err != nil {
		return
	}
	for _, division := range divisions {
		if _, ok := awardToDivisions[division.AwardID]; !ok {
			awardToDivisions[division.AwardID] = make([]*model.AwardDivision, 0)
		}
		awardToDivisions[division.AwardID] = append(awardToDivisions[division.AwardID], division)
	}
	for _, award := range awards {
		v := &model.AwardListModel{
			ID:              award.ID,
			AwardID:         award.AwardID,
			AwardName:       award.AwardName,
			CycleStart:      award.CycleStart.Unix(),
			CycleEnd:        award.CycleEnd.Unix(),
			TotalQuota:      award.TotalQuota,
			TotalBonus:      award.TotalBonus,
			AnnounceDate:    award.AnnounceDate.Unix(),
			OpenStatus:      award.OpenStatus,
			OpenTime:        award.OpenTime.Unix(),
			CTime:           award.CTime.Unix(),
			CreatedBy:       award.CreatedBy,
			SelectionStatus: 1,
			Tags:            make([]string, 0),
			DivisionNames:   make([]string, 0),
		}
		// status
		if count, ok := awardToWinnerC[v.AwardID]; ok && count == v.TotalQuota {
			v.SelectionStatus = 2
		}
		tagIDs := make([]int64, 0)
		for _, division := range awardToDivisions[v.AwardID] {
			tagIDs = append(tagIDs, division.TagID)
			v.DivisionNames = append(v.DivisionNames, division.DivisionName)
		}
		for _, tagID := range tagIDs {
			v.Tags = append(v.Tags, tagIDToName[tagID])
		}
		data = append(data, v)
	}
	return
}

// DetailAward .
func (s *Service) DetailAward(c context.Context, awardID int64) (data *model.AwardDetail, err error) {
	data = &model.AwardDetail{}
	var (
		winners        = 0
		typeIdxContent map[int]map[int]string
	)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		data.Award, err = dao.Award(tx, awardID)
		if err != nil {
			return
		}
		if data.Award == nil {
			err = ecode.Errorf(ecode.RequestErr, "award not found, awardID{%d}", awardID)
			return
		}
		data.Divisions, err = dao.ListDivision(tx, awardID)
		if err != nil {
			return
		}
		data.Prizes, err = dao.ListPrize(tx, awardID)
		if err != nil {
			return
		}
		typeIdxContent, err = dao.ListResource(tx, awardID)
		if err != nil {
			return
		}
		total, err := dao.CountAwardWinner(tx, awardID, "")
		if err != nil {
			return
		}
		winners = int(total)
		return nil
	})
	if err != nil {
		return
	}

	data.Award.SelectionStatus = 1
	if data.Award.TotalQuota == winners {
		data.Award.SelectionStatus = 2
	}
	// tags
	if len(data.Divisions) > 0 {
		var tagNames map[int64]string
		tagNames, err = resource.VideoCategoryIDToName(c)
		if err != nil {
			return
		}
		for _, division := range data.Divisions {
			if tagName, ok := tagNames[division.TagID]; ok {
				division.Tag = tagName
			}
		}
	}

	data.Resources = &model.AwardResource{
		Rule:   typeIdxContent[1][1],
		Detail: typeIdxContent[3][1],
		QA:     make([]*model.AwardQA, 0),
	}
	questions, answers := typeIdxContent[5], typeIdxContent[6]
	if len(questions) > 0 && len(answers) > 0 {
		for idx, question := range questions {
			data.Resources.QA = append(data.Resources.QA, &model.AwardQA{Index: idx, Q: question, A: answers[idx]})
		}
	}
	sort.Slice(data.Resources.QA, func(i, j int) bool {
		return data.Resources.QA[i].Index < data.Resources.QA[j].Index
	})

	data.Award.GenStr()

	return
}

// ListAwardWinner .
func (s *Service) ListAwardWinner(c context.Context, arg *model.QueryAwardWinnerArg) (total int64, res []*model.AwardWinner, err error) {
	res = make([]*model.AwardWinner, 0)
	if pass := s.validateQueryAwardWinner(c, arg); !pass {
		return
	}
	where := s.queryAwardWinnerWhere(arg)
	var (
		winnerInfo   map[int64]*model.AwardWinner   // <mid, *winner>
		prizeInfo    map[int64]*model.AwardPrize    // <prize_id, *prize>
		divisionInfo map[int64]*model.AwardDivision // <division_id, *division>
		mids         = make([]int64, 0)
	)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		total, err = dao.CountAwardWinner(tx, arg.AwardID, where)
		if err != nil {
			return
		}
		if total == 0 {
			return
		}
		winnerInfo, err = dao.QueryAwardWinner(tx, arg.AwardID, fmt.Sprintf("%s ORDER BY id DESC LIMIT %d,%d", where, arg.From, arg.Limit))
		if err != nil {
			return
		}
		if len(winnerInfo) > 0 {
			// divisions
			divisionInfo, err = dao.DivisionInfo(tx, arg.AwardID)
			if err != nil {
				return
			}
			// prizes
			prizeInfo, err = dao.PrizeInfo(tx, arg.AwardID)
			if err != nil {
				return
			}
		}
		return nil
	})
	if err != nil || total == 0 || len(winnerInfo) == 0 {
		return
	}
	categories, err := resource.VideoCategoryIDToName(c)
	if err != nil {
		return
	}
	for mid := range winnerInfo {
		mids = append(mids, mid)
	}
	upNames, err := resource.NamesByMIDs(c, mids)
	if err != nil {
		return
	}
	for mid, info := range winnerInfo {
		if division, ok := divisionInfo[info.DivisionID]; ok {
			info.DivisionName = division.DivisionName
		}
		if prize, ok := prizeInfo[info.PrizeID]; ok {
			info.Bonus = prize.Bonus
		}
		// tag
		if data, ok := categories[info.TagID]; ok {
			info.Tag = data
		}
		// nickname
		if nickname, ok := upNames[mid]; ok {
			info.Nickname = nickname
		}
	}
	res = make([]*model.AwardWinner, 0)
	for _, v := range winnerInfo {
		res = append(res, v)
	}
	return
}

// ExportAwardWinner .
func (s *Service) ExportAwardWinner(c context.Context, arg *model.QueryAwardWinnerArg) (res []byte, err error) {
	records, err := s.listAwardWinnerAll(c, arg)
	if err != nil {
		return
	}
	data := make([][]string, 0, len(records)+1)
	data = append(data, model.AwardWinnerExportFields())
	for _, v := range records {
		data = append(data, v.ExportStrings())
	}
	if res, err = FormatCSV(data); err != nil {
		log.Error("FormatCSV error(%v)", err)
	}
	return
}

func (s *Service) listAwardWinnerAll(c context.Context, arg *model.QueryAwardWinnerArg) (records []*model.AwardWinner, err error) {
	records = make([]*model.AwardWinner, 0)
	if pass := s.validateQueryAwardWinner(c, arg); !pass {
		return
	}
	where := s.queryAwardWinnerWhere(arg)
	var (
		winnerInfo   map[int64]*model.AwardWinner   // <mid, *winner>
		prizeInfo    map[int64]*model.AwardPrize    // <prize_id, *prize>
		divisionInfo map[int64]*model.AwardDivision // <division_id, *division>
		mids         = make([]int64, 0)
	)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		winnerInfo, err = dao.QueryAwardWinner(tx, arg.AwardID, fmt.Sprintf("%s ORDER BY id DESC", where))
		if err != nil {
			return
		}
		if len(winnerInfo) > 0 {
			// divisions
			divisionInfo, err = dao.DivisionInfo(tx, arg.AwardID)
			if err != nil {
				return
			}
			// prizes
			prizeInfo, err = dao.PrizeInfo(tx, arg.AwardID)
			if err != nil {
				return
			}
		}
		return nil
	})
	if err != nil {
		return
	}
	if len(winnerInfo) == 0 {
		return
	}
	categories, err := resource.VideoCategoryIDToName(c)
	if err != nil {
		return
	}
	for mid := range winnerInfo {
		mids = append(mids, mid)
	}
	upNames, err := resource.NamesByMIDs(c, mids)
	if err != nil {
		return
	}
	for mid, info := range winnerInfo {
		if division, ok := divisionInfo[info.DivisionID]; ok {
			info.DivisionName = division.DivisionName
		}
		if prize, ok := prizeInfo[info.PrizeID]; ok {
			info.Bonus = prize.Bonus
		}
		// tag
		if data, ok := categories[info.TagID]; ok {
			info.Tag = data
		}
		// nickname
		if nickname, ok := upNames[mid]; ok {
			info.Nickname = nickname
		}
	}
	for _, v := range winnerInfo {
		records = append(records, v)
	}
	return
}

func (s *Service) validateQueryAwardWinner(c context.Context, arg *model.QueryAwardWinnerArg) (pass bool) {
	if arg.Nickname != "" {
		mid, err := resource.MidByNickname(c, arg.Nickname)
		if err != nil || mid == 0 {
			return
		}
		if arg.MID == 0 {
			arg.MID = mid
		}
		if arg.MID != mid {
			log.Error("illegal mid(%d) and nickname(%s) pair", arg.MID, arg.Nickname)
			return
		}
	}
	return true
}

func (s *Service) queryAwardWinnerWhere(arg *model.QueryAwardWinnerArg) string {
	str := ""
	if arg.MID > 0 {
		str += fmt.Sprintf(" AND mid=%d", arg.MID)
	}
	if arg.TagID > 0 {
		str += fmt.Sprintf(" AND tag_id=%d", arg.TagID)
	}
	return str
}

// ReplaceAwardWinner .
func (s *Service) ReplaceAwardWinner(c context.Context, awardID, prevMID, mid int64) (err error) {
	records, err := s.dao.ListAwardRecord(c, awardID, fmt.Sprintf("AND (mid=%d OR mid=%d)", prevMID, mid))
	if err != nil {
		return
	}
	midsM := make(map[int64]bool)
	for _, v := range records {
		midsM[v.MID] = true
	}
	if !midsM[prevMID] {
		return ecode.Errorf(ecode.RequestErr, "mid(%d) not in award(%d)", prevMID, awardID)
	}
	if !midsM[mid] {
		return ecode.Errorf(ecode.RequestErr, "mid(%d) not in award(%d)", mid, awardID)
	}

	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		// lock award
		award, err := dao.SelectAwardForUpdate(tx, awardID)
		if err != nil {
			return
		}
		if award == nil {
			return ecode.Error(ecode.RequestErr, "award not found")
		}
		if award.OpenStatus != 1 {
			return ecode.Error(ecode.RequestErr, "illegal operation")
		}
		// winner info
		res, err := dao.QueryAwardWinner(tx, awardID, fmt.Sprintf("AND (mid=%d OR mid=%d)", prevMID, mid))
		if err != nil {
			return
		}
		prevWinner, ok := res[prevMID]
		if !ok {
			return ecode.Error(ecode.RequestErr, "invalid old winner")
		}
		if _, ok = res[mid]; ok {
			return ecode.Error(ecode.RequestErr, "invalid new winner")
		}
		// replace
		rows, err := dao.DelWinner(tx, awardID, fmt.Sprintf(" AND mid=%d", prevMID))
		if err != nil {
			return
		}
		if rows != 1 {
			return ecode.Error(ecode.ServerErr, "failed to del old winner")
		}
		fields, values := saveWinnerStr(map[int64]*model.AwardWinner{
			awardID: {
				AwardID:    awardID,
				MID:        mid,
				DivisionID: prevWinner.DivisionID,
				PrizeID:    prevWinner.PrizeID,
				TagID:      prevWinner.TagID,
			},
		})
		rows, err = dao.SaveWinners(tx, fields, values)
		if err != nil {
			return
		}
		if rows != 1 {
			return ecode.Error(ecode.ServerErr, "failed to add new winner")
		}
		return
	})
	return
}

// SaveAwardResult .
func (s *Service) SaveAwardResult(c context.Context, arg *model.AwardResult) (err error) {
	var (
		awardID      = arg.AwardID
		winnersM     = make(map[int64]*model.AwardWinner)
		prizeWinnerC = make(map[int64]int)
		divisionInfo map[int64]*model.AwardDivision
	)
	divisionInfo, err = s.dao.AwardDivisionInfo(c, awardID)
	if err != nil {
		return
	}
	for divisionI, division := range arg.Divisions {
		divisionID := int64(divisionI + 1)
		for prizeI, prize := range division.Prizes {
			prizeID := int64(prizeI + 1)
			prizeWinnerC[prizeID] += len(prize.MIDs)
			for _, mid := range prize.MIDs {
				if _, ok := winnersM[mid]; ok {
					return ecode.Error(ecode.RequestErr, "UID重复，请重新录入")
				}
				winnersM[mid] = &model.AwardWinner{
					MID:        mid,
					AwardID:    awardID,
					DivisionID: divisionID,
					PrizeID:    prizeID,
					TagID:      divisionInfo[divisionID].TagID,
				}
			}
		}
	}
	mids := make([]int64, 0, len(winnersM))
	for k := range winnersM {
		mids = append(mids, k)
	}
	if len(winnersM) == 0 {
		return ecode.Error(ecode.RequestErr, "奖项人数不符，保存失败")
	}
	// 是否已报名专项奖
	{
		var winnerRecords []*model.AwardRecord
		winnerRecords, err = s.dao.ListAwardRecord(c, awardID, fmt.Sprintf("AND mid IN (%s)", xstr.JoinInts(mids)))
		if err != nil {
			return
		}
		if len(winnersM) != len(winnerRecords) {
			var (
				awardRecordM = make(map[int64]bool)
				unSignedMIDs []int64
			)
			for _, rcr := range winnerRecords {
				awardRecordM[rcr.MID] = true
			}
			for _, mid := range mids {
				if !awardRecordM[mid] {
					unSignedMIDs = append(unSignedMIDs, mid)
				}
			}
			return ecode.Errorf(ecode.RequestErr, "%s 未报名专项奖，保存失败", xstr.JoinInts(unSignedMIDs))
		}
	}
	// 是否已签约激励
	{
		var signedUPs map[int64]struct{}
		signedUPs, err = s.dao.GetUpInfoByState(c, "up_info_video", mids, 3)
		if err != nil {
			return
		}
		if len(mids) != len(signedUPs) {
			var unSignedMIDs []int64
			for _, mid := range mids {
				if _, ok := signedUPs[mid]; !ok {
					unSignedMIDs = append(unSignedMIDs, mid)
				}
			}
			return ecode.Errorf(ecode.RequestErr, "%s 非签约状态，保存失败", xstr.JoinInts(unSignedMIDs))
		}
	}
	// save winners
	updateAwardStr := fmt.Sprintf("open_time = '%s'", time.Unix(arg.OpenTime, 0).Format("2006-01-02 15:04:05"))
	fields, values := saveWinnerStr(winnersM)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		award, err := dao.SelectAwardForUpdate(tx, awardID)
		if err != nil {
			return
		}
		if award == nil {
			return ecode.Errorf(ecode.RequestErr, "award not found, awardID{%d}", awardID)
		}
		if award.OpenStatus != 1 {
			return ecode.Error(ecode.RequestErr, "已发奖，不能再修改名单")
		}
		if award.TotalQuota != len(mids) {
			return ecode.Error(ecode.RequestErr, "奖项人数不符，保存失败")
		}
		prizeInfo, err := dao.PrizeInfo(tx, awardID)
		if err != nil {
			return
		}
		for prizeID, info := range prizeInfo {
			if prizeWinnerC[prizeID] != info.Quota {
				return ecode.Error(ecode.RequestErr, "奖项人数不符，保存失败")
			}
		}
		_, err = dao.UpdateAward(tx, awardID, updateAwardStr)
		if err != nil {
			return
		}
		_, err = dao.DelWinnerAll(tx, awardID)
		if err != nil {
			return
		}
		_, err = dao.SaveWinners(tx, fields, values)
		if err != nil {
			return
		}
		return nil
	})
	return
}

// AwardResult .
func (s *Service) AwardResult(c context.Context, awardID int64) (res *model.AwardResult, err error) {
	var (
		award        *model.Award
		winners      []*model.AwardWinner
		prizeInfo    map[int64]*model.AwardPrize
		divisionInfo map[int64]*model.AwardDivision
		data         = make(map[int64]map[int64][]int64)
	)
	err = s.dao.DoInTx(c, func(tx *sql.Tx) (err error) {
		award, err = dao.Award(tx, awardID)
		if err != nil {
			return
		}
		if award == nil {
			err = ecode.Errorf(ecode.RequestErr, "award not found, awardID{%d}", awardID)
			return
		}
		winners, err = dao.AwardWinnerAll(tx, awardID)
		if err != nil {
			return
		}
		// divisions
		divisionInfo, err = dao.DivisionInfo(tx, awardID)
		if err != nil {
			return
		}
		// prizes
		prizeInfo, err = dao.PrizeInfo(tx, awardID)
		if err != nil {
			return
		}
		return nil
	})
	if err != nil {
		return
	}
	// init
	for divisionID := range divisionInfo {
		data[divisionID] = make(map[int64][]int64)
		for prizeID := range prizeInfo {
			data[divisionID][prizeID] = make([]int64, 0)
		}
	}
	// mids
	for _, v := range winners {
		data[v.DivisionID][v.PrizeID] = append(data[v.DivisionID][v.PrizeID], v.MID)
	}
	// res
	res = &model.AwardResult{
		AwardID:      awardID,
		OpenTime:     award.OpenTime.Unix(),
		AnnounceDate: award.AnnounceDate.Unix(),
		CycleEnd:     award.CycleEnd.Unix(),
		Divisions:    make([]*model.AwardDivisionResult, 0),
	}
	for divisionID, division := range divisionInfo {
		dv := &model.AwardDivisionResult{
			DivisionID:   divisionID,
			DivisionName: division.DivisionName,
			Prizes:       make([]*model.AwardPrizeResult, 0),
		}
		for prizeID := range prizeInfo {
			mids := data[divisionID][prizeID]
			dv.Prizes = append(dv.Prizes, &model.AwardPrizeResult{MIDs: mids, PrizeID: prizeID})
		}
		sort.Slice(dv.Prizes, func(i, j int) bool {
			return dv.Prizes[i].PrizeID < dv.Prizes[j].PrizeID
		})
		res.Divisions = append(res.Divisions, dv)
	}
	sort.Slice(res.Divisions, func(i, j int) bool {
		return res.Divisions[i].DivisionID < res.Divisions[j].DivisionID
	})

	return
}