crazy_fox_backend_api/service/waiter.go

package service

import (
	"crazy-fox-backend-api/utils/zaplog"
	"fmt"
	"strconv"
	"strings"
	"time"

	"crazy-fox-backend-api/config"
	"crazy-fox-backend-api/model"
	"crazy-fox-backend-api/repo"
	"crazy-fox-backend-api/repo/okeys"
	"crazy-fox-backend-api/utils"

	"github.com/dablelv/go-huge-util/conv"
	jsoniter "github.com/json-iterator/go"
	"github.com/pkg/errors"
	"github.com/xuri/excelize/v2"
)

// fansService 客服模块
type waiterService struct{}

func (This *waiterService) Waiters(req *model.WaitersReq, account string) (waiters model.WaiterListInfo, err error) {

	waiters.AdminList = User.GetChildrenUsersByGid(req.Aid, req.Gid, account)

	adminIds := utils.SliceColumn[model.UserInfo, int64](waiters.AdminList, "id")
	waiters.List, waiters.Total = repo.SearchOnePage[model.TWaiterInfo](req.Page, req.PageSize, " where admin_id in (?)", adminIds)

	usersIdNameMap := make(map[int64]string, len(waiters.AdminList))
	for _, user := range waiters.AdminList {
		usersIdNameMap[user.Id] = user.Name
	}

	for i, waiter := range waiters.List {
		waiters.List[i].AdminName = usersIdNameMap[waiter.AdminId]
	}

	return waiters, err
}

func (This *waiterService) SaveWaiters(req *model.TWaiterInfo) error {
	if req.Id == 0 {
		req.CreatedAt = utils.CurDateTime()
	}

	_, err := repo.Upsert(req)

	return errors.WithStack(err)
}

func (This *waiterService) Vips(req *model.VipsReq, account string) (vipsShow []model.VipShowConfig, total int64) {

	waiters, err := This.Waiters(&model.WaitersReq{Aid: req.Aid, Gid: req.Gid}, account)
	if err != nil || len(waiters.List) == 0 {
		return
	}

	waiterNicMap := make(map[int64]string, len(waiters.List))
	kids := make([]int64, 0, len(waiters.List))
	for _, waiter := range waiters.List {
		if !utils.InSlice(waiter.Id, kids) {
			kids = append(kids, waiter.Id)
			waiterNicMap[waiter.Id] = waiter.FbNick
		}
	}

	where1, where2 := This.buildVipListWhere(&req.SearchInfo, kids)
	vipsShow, total = repo.Waiter.GetPageVipInfo(req.Page, req.PageSize, where1, where2)
	if utils.IsEmpty(vipsShow) {
		return
	}

	uids := utils.SliceColumn[model.VipShowConfig, int64](vipsShow, "uid")

	paidStats := repo.Search[model.PaidStat]("Where `uid` in (?)", uids)
	paidStaMap := utils.ArrayColumns(paidStats, "Uid")

	vipList := make([]model.VipShowConfig, 0, len(vipsShow))
	for _, one := range vipsShow {
		paidStat := paidStaMap[strconv.FormatInt(one.Uid, 10)]

		one.LastLoginTime = one.LastTime
		one.Payed = paidStat.Amount
		one.LastPayTime = utils.ToSecond(paidStat.UpdatedAt, time.DateTime)
		one.KNick = waiterNicMap[one.Kid]

		if len(req.SearchInfo.PayedRange) == 2 && (req.SearchInfo.PayedRange[0] != 0 || req.SearchInfo.PayedRange[1] != 0) {
			if !(req.SearchInfo.PayedRange[0] <= one.Payed && one.Payed <= req.SearchInfo.PayedRange[1]) {
				total--
				continue
			}
		}

		if len(req.SearchInfo.LastPayTimeRange) == 2 {
			if !(req.SearchInfo.LastPayTimeRange[0]/1000 <= one.LastPayTime && one.LastPayTime <= req.SearchInfo.LastPayTimeRange[1]/1000) {
				total--
				continue
			}
		}

		vipList = append(vipList, one)
	}

	return vipList, total
}

func (This *waiterService) buildVipListWhere(searchInfo *model.VipSearchInfo, kids []int64) (string, string) {

	//where1 := fmt.Sprintf("Where kid In (%s) ", utils.Implode(kids, ","))
	where1 := "Where true "

	if !utils.IsEmpty(searchInfo.Uid) {
		where1 += fmt.Sprintf("And `uid` = %d ", searchInfo.Uid)
	}
	if !utils.IsEmpty(searchInfo.Kids) {
		where1 += fmt.Sprintf("And `kid` In (%s) ", utils.Implode(searchInfo.Kids, ","))
	}
	if !utils.IsEmpty(searchInfo.Statuses) {
		where1 += fmt.Sprintf("And `status` In (%s) ", utils.Implode(searchInfo.Statuses, ","))
	}
	if len(searchInfo.AskLimitRange) == 2 && (searchInfo.AskLimitRange[0] != 0 || searchInfo.AskLimitRange[1] != 0) {
		where1 += fmt.Sprintf("And `ask_limit` Between %d And %d ", searchInfo.AskLimitRange[0], searchInfo.AskLimitRange[1])
	}
	if len(searchInfo.LastAskTsRange) == 2 {
		where1 += fmt.Sprintf("And `last_ask_ts` Between %d And %d ", searchInfo.LastAskTsRange[0]/1000, searchInfo.LastAskTsRange[1]/1000)
	}
	if len(searchInfo.AskSsTsRange) == 2 {
		where1 += fmt.Sprintf("And `ask_ss_ts` Between %d And %d ", searchInfo.AskSsTsRange[0]/1000, searchInfo.AskSsTsRange[1]/1000)
	}
	searchInfo.Content = strings.TrimSpace(searchInfo.Content)
	if !utils.IsEmpty(searchInfo.Content) {
		msg := fmt.Sprintf("%%%s%%", searchInfo.Content)
		where1 += fmt.Sprintf("And `content` Like '%s' ", msg)
	}
	searchInfo.Country = strings.TrimSpace(searchInfo.Country)
	if !utils.IsEmpty(searchInfo.Country) {
		country := fmt.Sprintf("%%%s%%", searchInfo.Country)
		where1 += fmt.Sprintf("And `country` Like '%s' ", country)
	}
	if !utils.IsEmpty(searchInfo.Langs) {
		where1 += fmt.Sprintf("And `lang` In ('%s') ", utils.Implode(searchInfo.Langs, "','"))
	}

	where2 := "Where True "
	searchInfo.FbNick = strings.TrimSpace(searchInfo.FbNick)
	if !utils.IsEmpty(searchInfo.FbNick) {
		fbNick := fmt.Sprintf("%%%s%%", searchInfo.FbNick)
		where2 += fmt.Sprintf("And `nick` like '%s'", fbNick)
	}
	searchInfo.Email = strings.TrimSpace(searchInfo.Email)
	if !utils.IsEmpty(searchInfo.Email) {
		email := fmt.Sprintf("%%%s%%", searchInfo.Email)
		where2 += fmt.Sprintf("And `email` like '%s'", email)
	}
	if !utils.IsEmpty(searchInfo.IsFbs) {
		where2 += fmt.Sprintf("And `isFb` In (%s)  ", utils.Implode(searchInfo.IsFbs, ","))
	}
	if len(searchInfo.LastLoginTimeRange) == 2 {
		where2 += fmt.Sprintf("And `lasttime` Between %d And %d ", searchInfo.LastLoginTimeRange[0]/1000, searchInfo.LastLoginTimeRange[1]/1000)
	}

	return where1, where2
}

func (This *waiterService) SaveVips(vips []model.TVipInfo) error {

	if len(vips) == 0 {
		return nil
	}

	uids := utils.SliceColumn[model.TVipInfo, int64](vips, "uid")
	existUids := repo.GetExistIds[model.TUserinfo, int64](uids, "uid")

	for _, vip := range vips {
		if !utils.InSlice(vip.Uid, existUids) {
			return errors.New(fmt.Sprintf("玩家UID: %d 不存在", vip.Uid))
		}
	}

	_, err := repo.Upsert(vips)

	return errors.WithStack(err)
}

func (This *waiterService) SaveImportVips(vips []model.VipBasicInfo) error {

	if len(vips) == 0 {
		return nil
	}

	uids := utils.SliceColumn[model.VipBasicInfo, int64](vips, "uid")
	existUids := repo.GetExistIds[model.TUserinfo, int64](uids, "uid")

	for _, vip := range vips {
		if !utils.InSlice(vip.Uid, existUids) {
			return errors.New(fmt.Sprintf("玩家UID: %d 不存在", vip.Uid))
		}
	}

	_, err := repo.Upsert(vips)

	return errors.WithStack(err)
}

func (This *waiterService) SendInvite(req *model.VipInviteReq) error {

	if len(req.Uids) == 0 {
		return errors.New("玩家列表为空")
	}

	// 获取邀请间隔
	vipWaiterConf := This.VipWaiterConf()
	if utils.IsEmpty(vipWaiterConf) {
		vipWaiterConf = model.VipWaiterConf{
			VipActiveMsgId: 0,
			InviteGapDays:  30,
		}
	}

	curTime := utils.CurTimestamp()

	vips := repo.Search[model.TVipInfo](" where uid in (?)", req.Uids)
	//vips := repo.Waiter.GetVipList(array.Int64ArrToString(req.Uids, ","))

	inviteCache := make(map[string]any, len(vips))
	logs := make([]model.TServiceLog, 0, len(vips))

	for i, vip := range vips {
		// 判断距离上次邀请是否已过 X 天
		if curTime-vip.LastAskTs < 86400*vipWaiterConf.InviteGapDays {
			return errors.New(fmt.Sprintf("邀请失败,用户：%d 距离上次邀请小于%d天", vip.Uid, vipWaiterConf.InviteGapDays))
		}

		vip.AskLimit = vip.AskLimit + 1
		vip.LastAskTs = curTime
		vip.Status = config.WaiterVipStatusWaitActive
		vip.Rid = req.Rid
		vips[i] = vip

		askData := model.WaiterAskStruct{
			Kid: vip.Kid,
			Rid: vip.Rid,
		}

		content, err := jsoniter.MarshalToString(askData)
		if err != nil {
			return errors.Wrap(err, "WaiterAskStruct Marshal 失败")
		}

		// 邀请 redis 标志
		inviteCache[okeys.WaiterInviteKey(vip.Uid)] = content

		// 操作日志
		logs = append(logs, model.TServiceLog{Kid: vip.Kid, Uid: vip.Uid, Operation: config.WaiterLogTypeInvite})
	}

	if err := This.SaveVips(vips); err != nil {
		return errors.WithMessage(err, "邀请失败")
	}

	repo.MSetCache(inviteCache)

	This.SaveOpLog(logs...)

	return nil
}

func (This *waiterService) ActiveUser(uids []int64, account string) error {
	activeConf := This.VipWaiterConf()
	if activeConf.VipActiveMsgId == 0 {
		zaplog.Error(fmt.Sprintf("邮件语言模板为空:%v", activeConf), nil)
		return errors.New("邮件模板为空")
	}
	curTime := utils.CurTimestamp()
	logs := make([]model.TServiceLog, 0, 2)
	var vipInfoUidList []string

	//vipInfoList := repo.Waiter.GetVipList(array.Int64ArrToString(uids, ","))
	vipInfoList := repo.Search[model.TVipInfo](" where uid in (?)", uids)
	for _, vipInfo := range vipInfoList {
		// 发送激活奖励邮件
		if vipInfo.Status == config.WaiterVipStatusWaitActive {
			// 解析激活奖励
			rewards := repo.SearchOneField[model.TActivateReward, []model.PropPrize]("reward", "Where id = ?", vipInfo.Rid)
			// 发放激活奖励
			mailReq := model.TSysMailSchedule{
				SysMailScheduleSub: model.SysMailScheduleSub{
					TemplateId: activeConf.VipActiveMsgId,
					Rewards:    rewards,
					Operator:   account,
					CreateTime: curTime,
					Uids:       conv.ToAny[string](vipInfo.Uid),
				},
				Days: 7,
			}
			if err := SysMail.MailSend(&mailReq); err != nil {
				zaplog.Error(fmt.Sprintf("发送奖励邮件失败:%v", vipInfo.Uid), err)
				continue
				//return errors.WithMessage(err, "发送失败")
			}

			logs = append(logs, model.TServiceLog{Uid: vipInfo.Uid, Kid: vipInfo.Kid, Operation: config.WaiterLogTypeAward})
		}

		// 变更状态
		vipInfo.Status = config.WaiterVipStatusActivated
		vipInfo.AskSsTs = curTime
		if err := This.SaveVips([]model.TVipInfo{vipInfo}); err != nil {
			zaplog.Error(fmt.Sprintf("用户状态变更失败:%v", vipInfo.Uid), err)
			continue
			//return errors.WithMessage(err, "用户状态变更失败")
		}

		logs = append(logs, model.TServiceLog{Uid: vipInfo.Uid, Kid: vipInfo.Kid, Operation: config.WaiterLogTypeActive})
		vipInfoUidList = append(vipInfoUidList, okeys.WaiterInviteKey(vipInfo.Uid))
	}

	// 记录操作日志
	This.SaveOpLog(logs...)

	// 删除邀请key
	repo.DelCache(vipInfoUidList...)

	return nil
}

// DelUsers 批量删除用户
func (This *waiterService) DelUsers(uids []int64, account string) error {
	_ = repo.Delete[model.TVipInfo]("uid", uids)
	var list []string
	for _, uid := range uids {
		list = append(list, okeys.WaiterInviteKey(uid))
	}
	repo.DelCache(list...)
	return nil
}

func (This *waiterService) CloseUser(uid int64) error {

	vipInfo := repo.SearchOne[model.TVipInfo]("Where `uid` = ?", uid)

	// 变更状态
	vipInfo.Status = config.WaiterVipStatusClosed
	if err := This.SaveVips([]model.TVipInfo{vipInfo}); err != nil {
		return errors.WithMessage(err, "用户状态变更失败")
	}

	// 记录操作日志
	This.SaveOpLog(model.TServiceLog{Uid: uid, Kid: vipInfo.Kid, Operation: config.WaiterLogTypeClosed})

	return nil
}

func (This *waiterService) Logs(req *model.WaitersReq, account string) (list []model.WaiterShowLog, total int64) {

	waiters, err := This.Waiters(&model.WaitersReq{Aid: req.Aid, Gid: req.Gid}, account)
	if err != nil || len(waiters.List) == 0 {
		return
	}

	waiterNicMap := make(map[int64]string, len(waiters.List))
	kids := make([]int64, 0, len(waiters.List))
	for _, waiter := range waiters.List {
		if !utils.InSlice(waiter.Id, kids) {
			kids = append(kids, waiter.Id)
			waiterNicMap[waiter.Id] = waiter.FbNick
		}
	}

	where := fmt.Sprintf("Where kid in (%s)", utils.Implode(kids, ","))

	list, total = repo.Waiter.GetPageLogInfo(req.Page, req.PageSize, where, req.Keyword)
	if utils.IsEmpty(list) {
		return
	}

	for i := 0; i < len(list); i++ {
		one := &list[i]
		one.KNick = waiterNicMap[one.Kid]
	}

	return
}

func (This *waiterService) LogEdit(req *model.WaiterLogEditReq) error {

	logInfo := repo.SearchOne[model.TServiceLog]("Where `id` = ?", req.Id)
	if logInfo.Id == 0 {
		return errors.New("日志记录未找到")
	}

	logInfo.StartTs = req.StartTs
	logInfo.EndTs = req.EndTs
	logInfo.Content = req.Content

	if err := repo.Update(&logInfo, "id"); err != nil {
		return errors.WithMessage(err, "日志记录更新失败")
	}

	return nil
}

func (This *waiterService) ActiveRewards(req *model.PageInfo) (list []model.TActivateReward, total int64) {

	return repo.SearchOnePage[model.TActivateReward](req.Page, req.PageSize, "")
}

func (This *waiterService) SaveOpLog(logs ...model.TServiceLog) {

	curTime := utils.CurTimestamp()
	for i := range logs {
		logs[i].CreateAt = curTime
	}

	_, _ = repo.Insert(logs)
}

func (This *waiterService) VipWaiterConf() (conf model.VipWaiterConf) {
	commonConf, err := Config.GetCommonConf(okeys.VipServiceConf())
	if err != nil {
		return
	}

	if err = jsoniter.UnmarshalFromString(commonConf.Conf, &conf); err != nil {
		return
	}

	return
}

func (This *waiterService) SaveVipWaiterConf(req *model.VipWaiterConf) error {

	confContent, err := jsoniter.MarshalToString(req)
	if err != nil {
		return errors.Wrap(err, "转json失败")
	}

	// 更新数据库
	if err = Config.UpdateCommonConf(model.CommonConf{Type: okeys.VipServiceConf(), Name: "vip用户专属客服配置", Conf: confContent}); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func (This *waiterService) SaveRewards(req *model.TActivateReward) error {
	_, err := repo.Upsert(req)

	return errors.WithStack(err)
}

func (This *waiterService) SendMailRewards(req *model.SendMailRewardsConf, account string) error {

	if len(req.Uids) == 0 {
		return errors.New("玩家列表为空")
	}

	// 发送邮件
	mailReq := model.TSysMailSchedule{
		SysMailScheduleSub: model.SysMailScheduleSub{
			TemplateId: req.MsgId,
			Rewards:    req.Rewards,
			Operator:   account,
			CreateTime: utils.CurTimestamp(),
			Uids:       utils.Implode(req.Uids, ","),
		},
		Days: 7,
	}
	if err := SysMail.MailSend(&mailReq); err != nil {
		return err
	}
	//vips := repo.Waiter.GetVipList(array.Int64ArrToString(req.Uids, ","))
	vips := repo.Search[model.TVipInfo](" where uid in (?)", req.Uids)

	logs := make([]model.TServiceLog, 0, len(vips))
	for _, vip := range vips {
		logs = append(logs, model.TServiceLog{Uid: vip.Uid, Kid: vip.Kid, Operation: config.WaiterLogTypeEmail})
	}

	This.SaveOpLog(logs...)

	return nil
}

func (This *waiterService) handleVipsImport(sheets [][][]string, params map[string]any) (err error) {
	if len(sheets) < 1 || len(sheets[0]) <= 1 {
		return errors.New("导入数据为空")
	}

	aid, gid, account := This.parseExcelParams(params)

	waiters, err := This.Waiters(&model.WaitersReq{Aid: aid, Gid: gid}, account)

	waiterIds := utils.SliceColumn[model.TWaiterInfo, int64](waiters.List, "id")

	vips := make([]model.VipBasicInfo, 0, len(sheets[0]))
	for i := 1; i < len(sheets[0]); i++ {
		var one model.VipBasicInfo

		// 解析行配置
		if err = utils.DestructAssign(sheets[0][i], &one.Uid, &one.Kid, &one.Content, &one.Country, &one.Lang); err != nil {
			return err
		}

		if one.Uid == 0 {
			continue
		}

		if !utils.IsEmpty(one.Lang) && !utils.InSlice(one.Lang, config.LangTitle) {
			return errors.New(fmt.Sprintf("语言: %s 未找到, 请检查后重新填写", one.Lang))
		}

		if !utils.InSlice(one.Kid, waiterIds) {
			return errors.New(fmt.Sprintf("客服id: %d 不在你的管辖范围内", one.Kid))
		}

		vips = append(vips, one)
	}

	return This.SaveImportVips(vips)
}

func (This *waiterService) handleVipsExport(xlsx *excelize.File, fileName *string, params map[string]any) (err error) {

	aid, gid, account := This.parseExcelParams(params)

	req := &model.VipsReq{
		WaitersReq: model.WaitersReq{
			Aid: aid,
			Gid: gid,
		},
	}

	list, _ := This.Vips(req, account)

	// 工作表1
	sheetName := "基础配置"
	if err = xlsx.SetSheetName("Sheet1", sheetName); err != nil {
		return errors.WithStack(err)
	}

	titles := []string{"玩家UID", "关联客服ID", "备注", "国家", "语言"}
	if err = xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	for i, info := range list {

		rowSlice := []any{info.Uid, info.Kid, info.Content, info.Country, info.Lang}

		if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", i+2), &rowSlice); err != nil {
			return errors.WithStack(err)
		}
	}

	*fileName = "VIP用户列表"

	return err
}

func (This *waiterService) parseExcelParams(params map[string]any) (int64, int64, string) {
	aid := conv.ToAny[int64](params["aid"])
	gid := conv.ToAny[int64](params["gid"])
	account := conv.ToAny[string](params["account"])

	return aid, gid, account
}