bilibili-go-common/app/admin/main/growup/service/offlineactivity.go

package service

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/jinzhu/gorm"
	"github.com/pkg/errors"
	"go-common/app/admin/main/growup/conf"
	"go-common/app/admin/main/growup/dao"
	"go-common/app/admin/main/growup/dao/shell"
	"go-common/app/admin/main/growup/model/offlineactivity"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/net/http/blademaster"
	"io/ioutil"
	"math/rand"
	"sort"
	"strconv"
	"strings"
	"time"
)

const (
	uploadFilePath = "/data/uploadfiles/"
	dateFmt        = "20060102"
	exportMaxCount = 1000
)

func (s *Service) offlineactivityCheckSendDbProc() {
	defer func() {
		if r := recover(); r != nil {
			r = errors.WithStack(r.(error))
			log.Error("write stat data Runtime error caught, try recover: %+v", r)
			go s.offlineactivityCheckSendDbProc()
		}
	}()
	var timer = time.NewTicker(60 * time.Second)
	for {
		select {
		case <-timer.C:
		case <-s.chanCheckDb:
		}
		s.checkResultNotSendingOrder()
	}
}

func (s *Service) offlineactivityCheckShellOrderProc() {
	defer func() {
		if r := recover(); r != nil {
			r = errors.WithStack(r.(error))
			log.Error("write stat data Runtime error caught, try recover: %+v", r)
			go s.offlineactivityCheckShellOrderProc()
		}
	}()
	var timer = time.NewTimer(10 * time.Second)
	var timerStart = false
	var resultIds []int64
	for {
		select {
		case orderID := <-s.chanCheckShellOrder:
			var all = []*offlineactivity.OfflineActivityResult{orderID}
			for {
			drain:
				for {
					select {
					case orderID := <-s.chanCheckShellOrder:
						all = append(all, orderID)
						if len(all) >= 100 {
							break drain
						}
					default:
						break drain
					}
				}
				s.checkShellOrder(context.Background(), all)
				if len(all) < 100 {
					break
				}
				all = nil
			}
		case resultID := <-s.chanCheckActivity:
			if !timerStart {
				timer.Reset(10 * time.Second)
				timerStart = true
			}
			resultIds = append(resultIds, resultID)
		case <-timer.C:
			// 去检查对应活动的状态
			timerStart = false
			var ids []int64
			ids = append(ids, resultIds...)
			s.checkActivityState(context.Background(), ids)
			// clear map
			resultIds = nil
		}
	}
}

//PreAddOfflineActivity just test add resutl
func (s *Service) PreAddOfflineActivity(ctx context.Context, arg *offlineactivity.AddActivityArg) (res *offlineactivity.PreAddActivityResult, err error) {
	if arg == nil {
		return
	}
	res = new(offlineactivity.PreAddActivityResult)

	var bonusList = arg.BonusList
	var hasBonus = false
	res.BonusType = arg.BonusType
	for _, bonus := range bonusList {
		if bonus.TotalMoney <= 0 {
			err = fmt.Errorf("bonus money < 0, money=%f", bonus.TotalMoney)
			log.Error(err.Error())
			return
		}
		res.TotalMoney += bonus.TotalMoney
		if bonus.Filename != "" {
			var fullpath = uploadFilePath + bonus.Filename
			var filecontent []byte
			filecontent, err = ioutil.ReadFile(fullpath)
			if err != nil {
				log.Error("read file fail, path=%s", fullpath)
				return
			}
			bonus.Mids = string(filecontent)
			bonus.MidList = dao.ParseMidsFromString(bonus.Mids)
			bonus.MemberCount = int64(len(bonus.MidList))
			if bonus.MemberCount == 0 {
				log.Warn("no mid for this bonus, bonus：money=%d", bonus.TotalMoney)
				continue
			}
		} else {
			bonus.MidList = dao.ParseMidsFromString(bonus.Mids)
			bonus.MemberCount = int64(len(bonus.MidList))
			if bonus.MemberCount == 0 {
				log.Warn("no mid for this bonus, bonus：money=%d", bonus.TotalMoney)
				continue
			}
		}
		res.MemberCount += bonus.MemberCount
		hasBonus = true
	}
	// 如果一个bonus都没有，则什么也不做
	if !hasBonus {
		log.Error("no bonus")
		err = fmt.Errorf("没有获奖人员信息/解析文件失败(请上传csv/txt等文本格式文件)")
		return
	}

	return
}

//AddOfflineActivity add offline activity
func (s *Service) AddOfflineActivity(ctx context.Context, arg *offlineactivity.AddActivityArg) (res *offlineactivity.AddActivityResult, err error) {
	if arg == nil {
		return
	}
	var bonusList = arg.BonusList
	var hasBonus = false
	var bc = ctx.(*blademaster.Context)
	var cookie, _ = bc.Request.Cookie("username")
	if cookie != nil {
		arg.Creator = cookie.Value
	}
	for _, bonus := range bonusList {
		if bonus.TotalMoney <= 0 {
			err = fmt.Errorf("bonus money < 0, money=%f", bonus.TotalMoney)
			log.Error(err.Error())
			return
		}
		if bonus.Filename != "" {
			var fullpath = uploadFilePath + bonus.Filename
			var filecontent []byte
			filecontent, err = ioutil.ReadFile(fullpath)
			if err != nil {
				log.Error("read file fail, path=%s", fullpath)
				return
			}
			bonus.Mids = string(filecontent)
		} else {
			bonus.MidList = dao.ParseMidsFromString(bonus.Mids)
			bonus.MemberCount = int64(len(bonus.MidList))
			if bonus.MemberCount == 0 {
				log.Warn("no mid for this bonus, bonus：money=%d", bonus.TotalMoney)
				continue
			}
		}

		hasBonus = true
	}
	// 如果一个bonus都没有，则什么也不做
	if !hasBonus {
		log.Error("no bonus")
		err = fmt.Errorf("no bonus info")
		return
	}

	go func() {
		err = s.dao.OfflineActivityAddActivity(context.Background(), arg)
		if err != nil {
			log.Error("offline add fail")
			return
		}
		log.Info("offline add ok")
		if len(s.chanCheckDb) == 0 {
			s.chanCheckDb <- 1
		}
	}()

	return
}

//ShellCallback shell callback
func (s *Service) ShellCallback(ctx context.Context, arg *shell.OrderCallbackParam) (err error) {
	if arg == nil {
		log.Error("arg is nil")
		return ecode.RequestErr
	}
	var result = shell.OrderCallbackJSON{}
	if err = json.Unmarshal([]byte(arg.MsgContent), &result); err != nil {
		log.Error("msgid=%s, unmarshal msg content fail, err=%s, msgcontent=%s", err, arg.MsgID, string(arg.MsgContent))
		return
	}
	log.Info("order id=%s, handle shell callback, status=%s", result.ThirdOrderNo, result.Status)
	if result.CustomerID != conf.Conf.ShellConf.CustomID {
		log.Error("order id=%s, customerid not the same, give=%s, expect=%s", result.ThirdOrderNo, result.CustomerID, conf.Conf.ShellConf.CustomID)
		return
	}
	orderInfo, err := s.dao.ShellCallbackUpdate(ctx, &result, arg.MsgID)
	if err == nil {
		s.queueToUpdateActivityState(orderInfo.ResultID)
	}
	return
}

//OfflineActivityQueryActivity query activity
func (s *Service) OfflineActivityQueryActivity(ctx context.Context, arg *offlineactivity.QueryActivityByIDArg) (res *offlineactivity.QueryActivityResult, err error) {
	var db = s.dao.OfflineActivityGetDB()
	// make sure it's valid
	var limit, offset = arg.CheckPageValidation()
	if arg.ExportFormat() != "" {
		limit = exportMaxCount
	}
	var now = time.Now()
	if arg.FromDate == "" {
		arg.FromDate = now.AddDate(0, -1, 0).Format(dateFmt)
	}
	if arg.ToDate == "" {
		arg.ToDate = now.Format(dateFmt)
	}
	// 1.查询 OfflineActivityInfo 与 OfflineActivityBonus 数据，然后聚合
	var activityList []*offlineactivity.OfflineActivityInfo
	var total = 1
	if arg.ID != 0 {
		if err = db.Where("id=?", arg.ID).Find(&activityList).Error; err != nil && err != gorm.ErrRecordNotFound {
			log.Error("fail to get from db, err=%s", err)
			return
		}
		total = len(activityList)
	} else {
		if arg.FromDate == "" || arg.ToDate == "" {
			log.Error("request error, fromdate or todate is nill")
			err = ecode.RequestErr
			return
		}

		var todate, e = time.Parse(dateFmt, arg.ToDate)
		err = e
		if err != nil {
			log.Error("todate format err, todate=%s, err=%s", arg.ToDate, err)
			return
		}
		todate = todate.AddDate(0, 0, 1)
		var todatestr = todate.Format(dateFmt)
		if err = db.Table(offlineactivity.TableOfflineActivityInfo).Where("ctime>=? and ctime<=?", arg.FromDate, todatestr).Count(&total).Error; err != nil {
			log.Error("fail to get from db, err=%s", err)
			return
		}

		if err = db.Where("ctime>=? and ctime<=?", arg.FromDate, todatestr).Order("id desc").Offset(offset).Limit(limit).Find(&activityList).Error; err != nil {
			log.Error("fail to get from db, err=%s", err)
			return
		}
	}

	var activityIDs []int64
	for _, v := range activityList {
		activityIDs = append(activityIDs, v.ID)
	}
	if len(activityList) == 0 {
		log.Warn("0 activity list")
		return
	}

	// 查询bonus info
	var bonusList []*offlineactivity.OfflineActivityBonus
	if err = db.Where("activity_id in (?)", activityIDs).Find(&bonusList).Error; err != nil {
		log.Error("fail to get from db, err=%s", err)
		return
	}

	res = new(offlineactivity.QueryActivityResult)
	var activityMap = make(map[int64]*offlineactivity.QueryActivityInfo, len(activityList))
	for _, v := range activityList {
		var info = new(offlineactivity.QueryActivityInfo)
		info.CopyFromActivityDB(v)
		activityMap[info.ID] = info
	}

	for _, v := range bonusList {
		var info, _ = activityMap[v.ActivityID]
		if info == nil {
			continue
		}
		info.TotalMoney += offlineactivity.GetMoneyFromDb(v.TotalMoney)
		info.MemberCount += v.MemberCount
	}

	for _, v := range activityList {
		if info, ok := activityMap[v.ID]; ok {
			res.Result = append(res.Result, info)
		}
	}

	res.PageResult = arg.ToPageResult(total)
	return
}

// OfflineActivityQueryUpBonusSummary query up bonus info
func (s *Service) OfflineActivityQueryUpBonusSummary(ctx context.Context, arg *offlineactivity.QueryUpBonusByMidArg) (res *offlineactivity.QueryUpBonusByMidResult, err error) {
	var limit, offset = arg.CheckPageValidation()
	if arg.ExportFormat() != "" {
		limit = exportMaxCount
	}
	// 查询所有的 result for mid
	// 区分已结算、未结算
	// 已结算= 成功， 未结算= 初始、发送、等待
	upResult, total, err := s.dao.OfflineActivityGetUpBonusResult(ctx, true, limit, offset, "mid=?", arg.Mid)
	if err != nil {
		log.Error("get from up result fail, err=%s", err)
		return
	}
	res = new(offlineactivity.QueryUpBonusByMidResult)
	res.PageResult = arg.ToPageResult(total)

	var bonusMap = make(map[int64]*offlineactivity.UpSummaryBonusInfo)
	for _, v := range upResult {
		var bonusInfo, ok = bonusMap[v.Mid]
		if !ok {
			bonusInfo = &offlineactivity.UpSummaryBonusInfo{
				Mid: v.Mid,
			}
			bonusMap[v.Mid] = bonusInfo
		}
		switch offlineactivity.ActivityState(v.State) {
		case offlineactivity.ActivityStateSucess:
			bonusInfo.BilledMoney += offlineactivity.GetMoneyFromDb(v.BonusMoney)
			if bonusInfo.TmpBillTime < v.MTime {
				bonusInfo.TmpBillTime = v.MTime
			}
		case offlineactivity.ActivityStateInit, offlineactivity.ActivityStateSending, offlineactivity.ActivityStateWaitResult:
			bonusInfo.UnbilledMoney += offlineactivity.GetMoneyFromDb(v.BonusMoney)
		}
	}

	for _, v := range bonusMap {
		v.Finish()
		res.Result = append(res.Result, v)
	}
	return
}

//OfflineActivityQueryUpBonusByActivity get bonus info group by activity
func (s *Service) OfflineActivityQueryUpBonusByActivity(ctx context.Context, arg *offlineactivity.QueryUpBonusByMidArg) (res *offlineactivity.QueryUpBonusByActivityResult, err error) {
	var limit, offset = arg.CheckPageValidation()
	if arg.ExportFormat() != "" {
		limit = exportMaxCount
	}
	// 查询所有的 result for mid
	// 区分已结算、未结算
	// 已结算= 成功， 未结算= 初始、发送、等待
	upResult, total, err := s.dao.OfflineActivityGetUpBonusByActivityResult(ctx, limit, offset, arg.Mid)
	if err != nil {
		log.Error("get from up result fail, err=%s", err)
		return
	}
	res = new(offlineactivity.QueryUpBonusByActivityResult)
	res.PageResult = arg.ToPageResult(total)

	// [mid][activity_id], 按Activity做聚合
	var bonusMap = make(map[int64]map[int64]*offlineactivity.UpSummaryBonusInfo)
	for _, v := range upResult {
		var bonusActivityMap, ok = bonusMap[v.Mid]
		if !ok {
			bonusActivityMap = make(map[int64]*offlineactivity.UpSummaryBonusInfo)
			bonusMap[v.Mid] = bonusActivityMap
		}
		bonusInfo, ok := bonusActivityMap[v.ActivityID]
		if !ok {
			bonusInfo = &offlineactivity.UpSummaryBonusInfo{
				Mid:        v.Mid,
				ActivityID: v.ActivityID,
			}
			bonusActivityMap[v.ActivityID] = bonusInfo
		}
		var bonusMoney = offlineactivity.GetMoneyFromDb(v.BonusMoney)
		switch offlineactivity.ActivityState(v.State) {
		case offlineactivity.ActivityStateSucess:
			bonusInfo.BilledMoney += bonusMoney
			if bonusInfo.TmpBillTime < v.MTime {
				bonusInfo.TmpBillTime = v.MTime
			}
			bonusInfo.TotalBonusMoney += bonusMoney
		case offlineactivity.ActivityStateInit, offlineactivity.ActivityStateSending, offlineactivity.ActivityStateWaitResult:
			bonusInfo.UnbilledMoney += bonusMoney
			bonusInfo.TotalBonusMoney += bonusMoney
		}
	}

	for _, activityMap := range bonusMap {
		for _, v := range activityMap {
			v.Finish()
			res.Result = append(res.Result, v)
		}
	}
	return
}

//OfflineActivityQueryActivityByMonth activity by month
func (s *Service) OfflineActivityQueryActivityByMonth(ctx context.Context, arg *offlineactivity.QueryActvityMonthArg) (res *offlineactivity.QueryActivityMonthResult, err error) {
	var db = s.dao.OfflineActivityGetDB()

	var bonusInfo []*offlineactivity.OfflineActivityBonus
	var limit, offset = 100, 0
	var lastCount = limit
	for limit == lastCount {
		var bonusInfoTmp []*offlineactivity.OfflineActivityBonus
		if err = db.Find(&bonusInfoTmp).Error; err != nil {
			log.Error("get from db fail, err=%s", err)
			return
		}
		bonusInfo = append(bonusInfo, bonusInfoTmp...)
		lastCount = len(bonusInfoTmp)
		offset += lastCount
	}

	var now = time.Now()
	var dateStr = now.Format(dateFmt)
	var monthDataMap = make(map[string]*offlineactivity.ActivityMonthInfo)
	for _, v := range bonusInfo {
		var date = v.CTime.Time().Format("200601")
		var monthData, ok = monthDataMap[date]
		if !ok {
			monthData = &offlineactivity.ActivityMonthInfo{
				CreateTime: date,
			}
			monthDataMap[date] = monthData
			monthData.GenerateDay = dateStr
		}
		monthData.AddBonus(v)
	}

	var monthInfoS []*offlineactivity.ActivityMonthInfo
	for _, v := range monthDataMap {
		monthInfoS = append(monthInfoS, v)
		v.Finish()
	}

	sort.Slice(monthInfoS, func(i, j int) bool {
		return monthInfoS[i].CreateTime > monthInfoS[j].CreateTime
	})

	var lastIndex = len(monthInfoS) - 1
	if lastIndex >= 0 {
		monthInfoS[lastIndex].TotalMoneyAccumulate = monthInfoS[lastIndex].TotalBonusMoneyMonth
	}

	for i := len(monthInfoS) - 1; i > 0; i-- {
		monthInfoS[i-1].TotalMoneyAccumulate = monthInfoS[i].TotalMoneyAccumulate + monthInfoS[i-1].TotalBonusMoneyMonth
	}

	res = new(offlineactivity.QueryActivityMonthResult)
	res.Result = monthInfoS
	return
}

/*
	查询对应的activity_result表state=0 && bonus_type = 1 && ctime <= 86400
	for each item state=0 and activity_id = ? limit 100
		if 没有order_id，
			生成order_id，写入数据库, result表与shellorder表
			写入成功，记录等待发送
		if 有order id，
			// 说明已经经历过上一步，但是发送失败？那么加入到检查order id的队列
			记录等待发送

	批量进行发送-> shell
	if	发送成功
		更新所有的item状态 -> 1
	else if 失败：
		错误码是8002999997->order_id有重复
		更新所有的item order id = ''，等待重试
*/
func (s *Service) checkResultNotSendingOrder() {
	var db, err = gorm.Open("mysql", conf.Conf.ORM.Growup.DSN)
	if err != nil {
		log.Error("open db fail, dsn=%s", conf.Conf.ORM.Growup.DSN)
		return
	}
	defer db.Close()
	db.LogMode(false)
	// 查询对应的activity_result表state=0 && bonus_type = 1 && diff(ctime) <= 86400
	var minTime = time.Now().Add(-time.Hour * 24)
	var limit = 100
	var lastCount = limit
	var lastID int64
	for limit == lastCount {
		var needSendResult = make([]*offlineactivity.OfflineActivityResult, limit)
		if err = db.Select("id, mid, bonus_money, order_id, activity_id, bonus_id").
			Where("state=0 and bonus_type=1 and ctime>=? and id>?", minTime, lastID).Limit(limit).
			Find(&needSendResult).Error; err != nil {
			log.Error("get result fail, err=%s", err)
			return
		}

		lastCount = len(needSendResult)
		var now = time.Now()
		var sendRequestResult []*offlineactivity.OfflineActivityResult
		for _, activityResult := range needSendResult {
			if activityResult.ID > lastID {
				lastID = activityResult.ID
			}
			// if 没有order_id，
			if activityResult.OrderID == "" {
				activityResult.OrderID = generateOrderID(activityResult, now)
				if err = s.offlineActivityUpdateResultForSend(db, activityResult); err != nil {
					log.Warn("fail update result, err=%s, will retry next time", err)
					continue
				}
				log.Info("update result ok, mid=%d, activity_id=%d, order_id=%s", activityResult.Mid, activityResult.ActivityID, activityResult.OrderID)
				sendRequestResult = append(sendRequestResult, activityResult)
			} else {
				// if 有order id，
				go func(res *offlineactivity.OfflineActivityResult) {
					s.chanCheckShellOrder <- res
					log.Info("order has id, need to check, order id=%s, mid=%d, activityid=%d, bonusid=%d",
						res.OrderID, res.Mid, res.ActivityID, res.BonusID)
				}(activityResult)
			}
			if len(sendRequestResult) >= 10 {
				err = s.sendRequestAndUpdate(db, sendRequestResult)
				if err != nil {
					log.Error("send request err, err=%s", err)
				} else {
					log.Info("send to shell ok, length=%d", len(sendRequestResult))
				}

				sendRequestResult = nil
			}
		}
		if len(sendRequestResult) > 0 {
			err = s.sendRequestAndUpdate(db, sendRequestResult)
			if err != nil {
				log.Error("send request err, err=%s", err)
			} else {
				log.Info("send to shell ok, length=%d", len(sendRequestResult))
			}
		}
	}

}

func (s *Service) sendRequestAndUpdate(db *gorm.DB, sendRequestResult []*offlineactivity.OfflineActivityResult) (err error) {
	switch {
	default:
		var res *shell.OrderResponse
		if res, err = s.sendShellOrder(context.Background(), sendRequestResult); err != nil || res == nil {
			if err != nil {
				log.Error("fail to send to shell order, err=%s", err)
			}
			break
		}
		var ids []int64
		for _, v := range sendRequestResult {
			ids = append(ids, v.ID)
		}
		// 需要区分是否返回 错误码是8002999997,表示有重复
		if res.Errno == 8002999997 {
			log.Error("fail to send request, err=%d, msg=%s，重复！", res.Errno, res.Msg)
			// 将order id 更新为""
			if err = db.Table(offlineactivity.TableOfflineActivityResult).Where("id in (?)", ids).
				Update("order_id=''").Error; err != nil {
				log.Error("fail to update order id for duplicate order, id=%v", ids)
				break
			}
			return
		} else if res.Errno != 0 {
			log.Error("fail to send request, err=%d, msg=%s", res.Errno, res.Msg)
			return
		}

		if err = db.Table(offlineactivity.TableOfflineActivityResult).Where("id in (?)", ids).
			Update("state", offlineactivity.ActivityStateWaitResult).Error; err != nil {
			log.Error("fail to update state, id=%v", ids)
			break
		}
		log.Info("send request to shell order")
	}
	return
}

func generateOrderID(result *offlineactivity.OfflineActivityResult, tm time.Time) string {
	var order = fmt.Sprintf("%s%04d%010d%04d", time.Now().Format("20060102150405"), (result.ActivityID*100+result.BonusID)%10000, result.Mid, rand.Int()%10000)
	if len(order) > 32 {
		order = order[:32]
	}
	return order
}

func (s *Service) offlineActivityUpdateResultForSend(db *gorm.DB, result *offlineactivity.OfflineActivityResult) (err error) {
	if result == nil {
		err = fmt.Errorf("nil pointer")
		return
	}
	var tx = db.Begin()
	defer func() {
		if r := recover(); r != nil || err != nil {
			tx.Rollback()
		}
	}()
	// create
	var query = tx.Select("order_id").Where("order_id=''").Save(result)
	err = db.Error
	if err != nil {
		log.Error("err save offline result, err=%s", err)
		return
	}
	if query.RowsAffected == 0 {
		var msg = fmt.Sprintf("update order fail, it may already be sent, result_id=%d, mid=%d, activity_id=%d", result.ID, result.Mid, result.ActivityID)
		log.Warn(msg)
		err = fmt.Errorf(msg)
		return
	}
	var shellOrder = offlineactivity.OfflineActivityShellOrder{
		OrderID:  result.OrderID,
		ResultID: result.ID,
	}
	if err = tx.Save(&shellOrder).Error; err != nil {
		log.Error("err insert offline shell order, err=%s", err)
		return
	}

	return tx.Commit().Error
}

func (s *Service) sendShellOrder(ctx context.Context, needSendResult []*offlineactivity.OfflineActivityResult) (res *shell.OrderResponse, err error) {
	if len(needSendResult) == 0 {
		log.Warn("no need to send, len=0")
		return
	}
	var nowtime = time.Now()
	var now = time.Now().UnixNano() / int64(time.Millisecond)
	var request = shell.OrderRequest{
		ProductName: "活动奖励",
		NotifyURL:   conf.Conf.ShellConf.CallbackURL,
		Rate:        "1.0",
		SignType:    "MD5",
		Timestamp:   strconv.Itoa(int(beginOfDay(nowtime).UnixNano() / int64(time.Millisecond))),
	}
	for _, item := range needSendResult {
		var money = fmt.Sprintf("%0.2f", float64(offlineactivity.GetMoneyFromDb(item.BonusMoney)))
		var orderInfo = shell.OrderInfo{
			Mid:          item.Mid,
			Brokerage:    money,
			ThirdCoin:    money,
			ThirdOrderNo: item.OrderID,
			ThirdCtime:   strconv.Itoa(int(now)),
		}
		request.Data = append(request.Data, orderInfo)
	}
	//log.Info("request=%+v", request)
	res, err = s.shellClient.SendOrderRequest(ctx, &request)
	if err != nil || res == nil {
		log.Error("fail to send request, err=%s", err)
	} else {
		log.Info("send shell request, msg=%s, errno=%d", res.Msg, res.Errno)
	}
	return
}

/*
2.定单查询 - 查询定单的状态，
	for each state=0 and 存在order id
		去贝壳查询该定单状态
		if 定单不存在
			设置order id='', state=0 // 清除定单，等待重新发送
		else if 定单成功
			设置state=10
		else if 定单失败
			设置state=11
*/
// 最大不要超过100个订单
func (s *Service) checkShellOrder(ctx context.Context, values []*offlineactivity.OfflineActivityResult) (err error) {
	if len(values) == 0 {
		err = fmt.Errorf("values slice 0 length")
		return
	}
	var orderMap = make(map[string]*offlineactivity.OfflineActivityResult, len(values))
	var orderIds []string
	for i, v := range values {
		if i > 99 {
			break
		}
		orderIds = append(orderIds, v.OrderID)
		orderMap[v.OrderID] = v
	}
	var orderIDString = strings.Join(orderIds, ",")
	var orderCheckRequest = shell.OrderCheckRequest{
		Timestamp:     time.Now().UnixNano() / int64(time.Millisecond),
		ThirdOrderNos: orderIDString,
	}
	res, err := s.shellClient.SendCheckOrderRequest(ctx, &orderCheckRequest)
	if err != nil {
		log.Error("fail to check order, order id=%s, err=%s", orderIDString, err)
		return
	}
	// 区分找到的订单和未找到的订单
	// 订单找到，更新状态
	for _, v := range res.Orders {
		log.Info("order find, orderid=%s, current status=%s", v.ThirdOrderNo, v.Status)
		// 删除已找到的订单
		delete(orderMap, v.ThirdOrderNo)
		var resultJSON = shell.OrderCallbackJSON{
			Status:       v.Status,
			ThirdOrderNo: v.ThirdOrderNo,
			Mid:          v.Mid,
		}
		// 更新订单结果
		var orderInfo, e = s.dao.ShellCallbackUpdate(ctx, &resultJSON, "checkorder")
		if e == nil {
			s.queueToUpdateActivityState(orderInfo.ID)
		}
	}
	// 订单未找到,重新发送请求
	var needSendRequest []*offlineactivity.OfflineActivityResult
	for _, v := range orderMap {
		needSendRequest = append(needSendRequest, v)
	}
	err = s.sendRequestAndUpdate(s.dao.OfflineActivityGetDB(), needSendRequest)
	if err != nil {
		log.Error("send order request fail, err=%s", err)
		return
	}
	return
}
func (s *Service) checkActivityState(ctx context.Context, values []int64) (err error) {
	if len(values) == 0 {
		log.Warn("no activity need to check")
		return
	}
	//
	upResult, err := s.dao.OfflineActivityGetUpBonusResultSelect(ctx, "distinct(activity_id) as activity_id", "id in (?)", values)
	for _, v := range upResult {
		var _, e = s.dao.UpdateActivityState(ctx, v.ActivityID)
		if e != nil {
			log.Error("err when update activity state, err=%s", e)
		}
	}
	return
}

func (s *Service) queueToUpdateActivityState(resultID int64) {
	s.chanCheckActivity <- resultID
}

func beginOfDay(t time.Time) time.Time {
	year, month, day := t.Date()
	return time.Date(year, month, day, 0, 0, 0, 0, t.Location())
}