services/service/luckdraw/luckdraw.go

package luckdraw

import (
	"errors"
	"fmt"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/activityinfo"
	"spaceofcheng/services/models/course"
	"spaceofcheng/services/models/luckdraw"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/service"
	"spaceofcheng/services/utils"
	"time"

	"github.com/astaxie/beego"
)

// LuckdrawServ 系统处理
type LuckdrawServ struct {
	ctx       *utils.Context
	dao       *luckdraw.LuckDrawDao
	courseDAO *course.CourseDAO
	adao      *activityinfo.ActivityinfoDao
}

// NewLuckdrawServ 初始化
func NewLuckdrawServ(ctx *utils.Context) *LuckdrawServ {
	return &LuckdrawServ{
		ctx:       ctx,
		dao:       luckdraw.NewDAO(ctx),
		courseDAO: course.NewCourseDAO(ctx),
		adao:      activityinfo.NewActivityinfoDao(ctx),
	}
}

// GetLuckDrawTpl 获取抽奖模板
func (s *LuckdrawServ) GetLuckDrawTpl() ([]model.TaLuckdrawTpl, error) {
	org := s.ctx.Get("org").(model.SysOrg)
	tpls, err := s.dao.GetLuckDrawTpl(org.OrgId)
	return tpls, err
}

// GetLuckDrawList 获取抽奖列表
func (s *LuckdrawServ) GetLuckDrawList(caseids, name, status string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	list, err := s.dao.GetLuckDrawList(caseids, name, status, page, pageSize)
	if err != nil {
		utils.LogError("获取抽奖信息失败: " + err.Error())
		return nil, errors.New("获取抽奖信息失败")
	}
	total, err := s.dao.GetLuckDrawCount(caseids, name, status)
	if err != nil {
		utils.LogError("获取抽奖信息失败: " + err.Error())
		return nil, errors.New("获取抽奖信息失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetLuckDrawRecordList 获取抽奖记录列表
func (s *LuckdrawServ) GetLuckDrawRecordList(luckdrawid, tel string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	list, err := s.dao.GetLuckDrawRecord(luckdrawid, tel, page, pageSize)
	if err != nil {
		utils.LogError("获取抽奖记录信息失败: " + err.Error())
		return nil, errors.New("获取抽奖记录信息失败")
	}
	total, err := s.dao.GetLuckDrawRecordCount(luckdrawid, tel)
	if err != nil {
		utils.LogError("获取抽奖记录信息失败: " + err.Error())
		return nil, errors.New("获取抽奖记录信息失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}
func (s *LuckdrawServ) GetLuckDrawRecordExcel(id, tel string) ([]luckdraw.RecordWithPhone, error) {
	list, err := s.dao.GetLuckDrawRecordExcel(id, tel)
	if err != nil {
		utils.LogError("获取抽奖记录Excel失败: " + err.Error())
		return nil, errors.New("获取抽奖记录Excel失败")
	}
	return list, nil
}

// GetLuckDrawShareList 获取抽奖分享记录列表
func (s *LuckdrawServ) GetLuckDrawShareList(luckdrawid, tel string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	list, err := s.dao.GetLuckDrawShare(luckdrawid, tel, page, pageSize)
	if err != nil {
		utils.LogError("获取抽奖分享记录信息失败: " + err.Error())
		return nil, errors.New("获取抽奖分享记录信息失败")
	}
	total, err := s.dao.GetLuckDrawShareCount(luckdrawid, tel)
	if err != nil {
		utils.LogError("获取抽奖分享记录信息失败: " + err.Error())
		return nil, errors.New("获取抽奖分享记录信息失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetLuckDrawInfoByID 获取单个抽奖记录
func (s *LuckdrawServ) GetLuckDrawInfoByID(luckdrawid string) (*luckdraw.LuckDrawInfo, error) {
	info, err := s.dao.GetLuckDrawInfoByID(luckdrawid)
	if err != nil {
		utils.LogError("获取抽奖信息失败: " + err.Error())
		return nil, errors.New("获取抽奖信息失败")
	}
	return info, nil
}

// SaveLuckDraw 保存抽奖信息
func (s *LuckdrawServ) SaveLuckDraw(luckdraw *luckdraw.LuckDrawInfo) (*model.TaLuckdraw, error) {
	if luckdraw.CaseId == "" {
		return nil, utils.LogError("请选择所属案场！")
	}
	if luckdraw.Name == "" {
		return nil, utils.LogError("请输入活动标题！")
	}
	if luckdraw.BeginDate.IsZero() || luckdraw.EndDate.IsZero() {
		return nil, utils.LogError("请选择活动时间！")
	}
	if luckdraw.TplId == "" {
		return nil, utils.LogError("请选择活动模板！")
	}
	if luckdraw.LuckdrawRule == "" {
		return nil, utils.LogError("请填写规则说明！")
	}
	if luckdraw.ActivityMainImg == "" {
		return nil, utils.LogError("请上传活动主图")
	}
	var newInfo *model.TaLuckdraw
	var err error
	var info = model.TaActivityShareInfo{
		ActivityMainImg: luckdraw.ActivityMainImg,
		ActivityTitle:   luckdraw.ActivityTitle,
		ActivityType:    models.ACTIVITY_LUCK,
		ShareContent:    luckdraw.ShareContent,
		ShareImg:        luckdraw.ShareImg,
	}
	beego.Error(info)
	if luckdraw.Id == "" {
		org := s.ctx.Get("org").(model.SysOrg)
		luckdraw.OrgId = org.OrgId
		user := s.ctx.Get("user").(model.SysUser)
		luckdraw.CreateUser = user.UserId
		newInfo, err = s.dao.InsertLuckdraw(luckdraw.TaLuckdraw)
		if err != nil {
			utils.LogError("保存抽奖信息失败: " + err.Error())
			return nil, errors.New("保存抽奖信息失败")
		}
		info.ActivityId = newInfo.Id
		err = s.adao.AddActivityInfo(info)
		if err != nil {
			utils.LogError("保存抽奖信息失败: " + err.Error())
			return nil, errors.New("保存抽奖信息失败")
		}
	} else {
		beego.Error("____________joinNum___________")
		beego.Error(luckdraw.JoinNum)
		if luckdraw.JoinedNum > 0 {
			var cols = []string{
				"name",
				"luckdraw_rule",
				"remark",
			}
			err = s.dao.UpdateLuckDraw(luckdraw.TaLuckdraw, cols)
			if err != nil {
				utils.LogError("更新抽奖信息失败: " + err.Error())
				return nil, errors.New("更新抽奖信息失败")
			}

			err = s.dao.UpdatePrizeDesc(luckdraw.Prizes)
			if err != nil {
				utils.LogError("更新抽奖信息失败: " + err.Error())
				return nil, errors.New("更新抽奖信息失败")
			}
			info.ActivityId = luckdraw.Id
			err = s.adao.DeleteInfo(info.ActivityId)
			if err != nil {
				utils.LogError("更新抽奖信息失败: " + err.Error())
				return nil, errors.New("更新抽奖信息失败")
			}
			err = s.adao.AddActivityInfo(info)
			if err != nil {
				utils.LogError("更新抽奖信息失败: " + err.Error())
				return nil, errors.New("更新抽奖信息失败")
			}
			return &luckdraw.TaLuckdraw, nil
		}
		var cols = []string{
			"name",
			"tpl_id",
			"luckdraw_rule",
			"begin_date",
			"end_date",
			"case_id",
			"remark",
			"join_num",
			"join_type",
			"num_type",
			"num_interval",
			"luckdraw_num",
			"share_type",
			"share_add_num",
			"is_sys_luckdraw",
			"is_internal_default"}
		err = s.dao.UpdateLuckDraw(luckdraw.TaLuckdraw, cols)
		if err != nil {
			utils.LogError("更新抽奖信息失败: " + err.Error())
			return nil, errors.New("更新抽奖信息失败")
		}
		newInfo = &luckdraw.TaLuckdraw
		info.ActivityId = newInfo.Id
		err = s.adao.DeleteInfo(info.ActivityId)
		if err != nil {
			utils.LogError("更新抽奖信息失败: " + err.Error())
			return nil, errors.New("更新抽奖信息失败")
		}
		err = s.adao.AddActivityInfo(info)
		// 删除奖品内定信息
		err = s.dao.DelLuckDrawDefault(luckdraw.Id)
		if err != nil {
			utils.LogError("删除抽奖内定信息失败: " + err.Error())
			return nil, errors.New("更新抽奖信息失败")
		}
		// 删除抽奖图片信息
		err = s.dao.DelLuckDrawImgs(luckdraw.Id)
		if err != nil {
			utils.LogError("删除抽奖图片信息失败: " + err.Error())
			return nil, errors.New("更新抽奖信息失败")
		}
		// 删除奖品信息
		err = s.dao.DelLuckDrawPrize(luckdraw.Id)
		if err != nil {
			utils.LogError("删除奖品信息失败: " + err.Error())
			return nil, errors.New("更新奖品信息失败")
		}

		// 删除该抽奖对应的设置信息
		err = s.dao.DelLuckDrawSet(luckdraw.Id)
		if err != nil {
			utils.LogError("删除奖品信息失败: " + err.Error())
			return nil, errors.New("更新奖品信息失败")
		}
	}

	// 保存抽奖图片信息
	err = s.dao.SaveLuckDrawImgs(luckdraw.Imgs, newInfo.Id)
	if err != nil {
		utils.LogError("保存抽奖图片信息失败: " + err.Error())
		return nil, errors.New("保存抽奖图片信息失败")
	}

	// 保存奖品信息
	err = s.dao.SaveLuckDrawPrizes(luckdraw.Prizes, newInfo)
	if err != nil {
		utils.LogError("保存奖品信息失败: " + err.Error())
		return nil, errors.New("保存奖品信息失败：" + err.Error())
	}
	return newInfo, nil
}

// OpenLuckDraw 启动游戏
func (s *LuckdrawServ) OpenLuckDraw(id string) error {
	ld, err := s.dao.GetLuckDrawByID(id)
	if err != nil {
		utils.LogError("获取游戏信息失败: " + err.Error())
		return errors.New("获取游戏信息失败")
	}
	if ld.Status != models.STATUS_READY {
		return errors.New("游戏状态异常，请刷新后重试！")
	}
	var luckdraw = model.TaLuckdraw{
		Id:     id,
		Status: models.STATUS_NORMAL,
	}
	err = s.dao.UpdateLuckDraw(luckdraw, []string{
		"status",
	})
	return err
}

// StopLuckDraw 暂停游戏
func (s *LuckdrawServ) StopLuckDraw(id string) error {
	// 判断
	ld, err := s.dao.GetLuckDrawByID(id)
	if err != nil {
		utils.LogError("获取游戏信息失败: " + err.Error())
		return errors.New("获取游戏信息失败")
	}
	if ld.Status != models.STATUS_NORMAL {
		return errors.New("游戏状态异常，请刷新后重试！")
	}

	var luckdraw = model.TaLuckdraw{
		Id:     id,
		Status: models.STATUS_READY,
	}
	err = s.dao.UpdateLuckDraw(luckdraw, []string{
		"status",
	})
	return err
}

// DelLuckDraw 删除游戏
func (s *LuckdrawServ) DelLuckDraw(id string) error {
	// 判断
	ld, err := s.dao.GetLuckDrawByID(id)
	if err != nil {
		utils.LogError("获取游戏信息失败: " + err.Error())
		return errors.New("获取游戏信息失败")
	}
	if ld.Status != models.STATUS_READY {
		return errors.New("游戏状态异常，请刷新后重试！")
	}
	var luckdraw = model.TaLuckdraw{
		Id:     id,
		Status: models.STATUS_DEL,
	}
	err = s.dao.UpdateLuckDraw(luckdraw, []string{
		"status",
	})
	return err
}

// GetLuckDraw 获取抽奖信息
func (s *LuckdrawServ) GetLuckDraw(id string) (*luckdraw.LuckDraw, error) {
	luck, err := s.dao.GetLuckDraw(id)
	if err != nil {
		return nil, err
	}
	return luck, nil
}

// LuckDraw 抽奖
func (s *LuckdrawServ) LuckDraw(id string, user *model.TaCustomer) (*model.TaLuckdrawPrize, *model.TaPrizeDetail, error) {
	prize, prizeDetail, recored, err := s.dao.LuckDraw(id, user)
	if err != nil {
		utils.LogError("抽奖失败：", err)
		return nil, nil, err
	}

	utils.LogInfo("抽奖记录ID: " + recored.Id)

	custQRCode := model.TaCustomerCourseQrcode{
		CustomerCourseId: recored.Id,
		CustomerQrcode:   utils.GenerateQRCode(),
		CreateDate:       time.Now(),
		Status:           models.STATUS_NORMAL,
		QrcodeType:       models.QRCODE_TYPE_PRIZE,
	}

	if err := s.courseDAO.SaveCustomerCourseQrcode(&custQRCode); err != nil {
		utils.LogError("插入中奖二维码失败: " + err.Error())
		return nil, nil, errors.New("写入中奖二维码失败")
	}

	if prize.IsReality == models.BOOL_TRUE {
		// 推送微信消息
		userMap := s.ctx.Get("userMap").(model.TaUserMapping)
		clienturl := s.ctx.Get("clienturl").(string)
		tplID := s.ctx.Get("tplid").(string)

		cs, err := models.GetCaseByID(recored.CaseId)
		if err != nil {
			utils.LogError("推送微信消息失败, 查询案场信息出错: " + err.Error())
			// 但是不返回错误
			return nil, nil, nil
		}

		caseName := cs.CaseName
		remarkTpl := "请在%s日前, 前往%s兑换"

		message := utils.Message{
			To: utils.ClientID{ID: userMap.Openid},
			Data: map[string]interface{}{
				"orgid": recored.OrgId,
				"tplid": tplID,
				"link":  clienturl,
				"data": map[string]string{
					"first":    "中奖成功提醒",
					"keyword1": prize.PrizeName,
					"keyword2": time.Now().Local().Format("2006-01-02"),
					"remark":   fmt.Sprintf(remarkTpl, recored.VerificationEnd.Format("2006-01-02"), caseName),
				},
			},
		}

		go utils.SendWechat(message)
	}

	return prize, prizeDetail, nil
}

func (s *LuckdrawServ) PrizeWriteOff(recordid string, userid string) error {
	err := s.dao.PrizeWriteOff(recordid, userid)
	if err != nil {
		utils.LogError("奖品核销失败: " + err.Error())
		return errors.New("奖品核销失败")
	}
	return nil
}

func (s *LuckdrawServ) GetWinning(prizes []model.TaLuckdrawPrize) (*model.TaLuckdrawPrize, error) {
	prize, err := s.dao.GetWinning(prizes)
	if err != nil {
		return nil, err
	}
	return prize, nil
}

func (s *LuckdrawServ) GetLuckDrawByID(id string) (*luckdraw.LuckDraw, error) {
	luck, err := s.dao.GetLuckDrawByID(id)
	if err != nil {
		utils.LogError("获取抽奖信息失败: " + err.Error())
		return nil, errors.New("获取抽奖信息失败")
	}
	return luck, nil
}

func (s *LuckdrawServ) GetCaseAddressByLuckDarw(luckdraw string) (string, error) {
	address, err := s.dao.GetCaseAddressByLuckDarw(luckdraw)
	if err != nil {
		utils.LogError("获取案场地址失败: " + err.Error())
		return "", errors.New("获取案场地址失败")
	}
	return address, nil
}

func (s *LuckdrawServ) UpdateLuckDrawEndDate(id string) error {
	err := s.dao.UpdateLuckDrawEndDate(id)
	if err != nil {
		utils.LogError("更新活动结束时间失败: " + err.Error())
		return errors.New("更新活动结束时间失败")
	}
	return nil
}

func (s *LuckdrawServ) GetPrizes(luckdrawid string) ([]model.TaLuckdrawPrize, error) {
	prize, err := s.dao.GetPrizes(luckdrawid)
	if err != nil {
		utils.LogError("获取奖品信息失败: " + err.Error())
		return nil, errors.New("获取奖品信息失败")
	}
	return prize, nil
}

func (s *LuckdrawServ) UpdateStock(prize *model.TaLuckdrawPrize) error {
	err := s.dao.UpdateStock(prize)
	if err != nil {
		utils.LogError("修改库存失败: " + err.Error())
		return errors.New("修改库存失败")
	}
	return nil
}

func (s *LuckdrawServ) GetPrizeStock(luckdrawid string) ([]model.TaLuckdrawPrize, error) {
	prize, err := s.dao.GetPrizeStock(luckdrawid)
	if err != nil {
		utils.LogError("判断奖项库存失败: " + err.Error())
		return nil, errors.New("判断奖项库存失败")
	}
	return prize, nil
}

func (s *LuckdrawServ) GetPrizeByID(id string) (model.TaLuckdrawPrize, error) {
	prize, err := s.dao.GetPrizeByID(id)
	if err != nil {
		utils.LogError("根据id获取奖品信息失败: " + err.Error())
		return prize, errors.New("根据id获取奖品信息失败")
	}
	return prize, nil
}

func (s *LuckdrawServ) SaveRecord(record model.TaLuckdrawRecord) (*model.TaLuckdrawRecord, error) {
	newRecord, err := s.dao.SaveRecord(record)
	if err != nil {
		utils.LogError("保存抽奖记录失败: " + err.Error())
		return nil, errors.New("保存抽奖记录失败")
	}

	return newRecord, nil
}

func (s *LuckdrawServ) GetPrizeDetail(prizeid string) ([]model.TaPrizeDetail, error) {
	detail, err := s.dao.GetPrizeDetail(prizeid)
	if err != nil {
		utils.LogError("获取未领取的奖品详情失败: " + err.Error())
		return nil, errors.New("获取未领取的奖品详情失败")
	}
	return detail, nil
}

func (s *LuckdrawServ) UpdatePrizeDetail(detail model.TaPrizeDetail) error {
	err := s.dao.UpdatePrizeDetail(detail)
	if err != nil {
		utils.LogError("更新库存明细为已领取失败: " + err.Error())
		return errors.New("更新库存明细为已领取失败")
	}
	return nil
}

func (s *LuckdrawServ) UpdateRecord(record *luckdraw.LuckInfo) error {
	err := s.dao.UpdateRecord(record)
	if err != nil {
		utils.LogError("核销更新抽奖记录表失败: " + err.Error())
		return errors.New("核销更新抽奖记录表失败")
	}
	return nil
}

func (s *LuckdrawServ) SaveWirteOff(writeoff model.TaLuckdrawWriteoff) (*model.TaLuckdrawWriteoff, error) {
	newWriteoff, err := s.dao.SaveWirteOff(writeoff)
	if err != nil {
		utils.LogError("保存核销信息失败: " + err.Error())
		return nil, errors.New("保存核销信息失败")
	}
	return newWriteoff, nil
}

func (s *LuckdrawServ) GetUserRecordByLuckDraw(userid string, luckdrawid string) ([]model.TaLuckdrawRecord, error) {
	record, err := s.dao.GetUserRecordByLuckDraw(userid, luckdrawid)
	if err != nil {
		utils.LogError("获取用户的抽奖信息失败: " + err.Error())
		return nil, errors.New("获取用户的抽奖信息失败")
	}
	return record, nil
}

// GetUserLuckDrawByLuckDraw 获取用户抽奖信息
func (s *LuckdrawServ) GetUserLuckDrawByLuckDraw(user model.TaCustomer, luckdrawid string) (*model.TaLuckdrawRecord, *model.TaLuckdrawCustomer, error) {
	// 获取用户抽奖设置信息
	customerSet, err := s.dao.GetUserLuckDrawSet(user, luckdrawid)
	if err != nil {
		utils.LogError("获取用户抽奖设置失败: " + err.Error())
		return nil, nil, errors.New("获取用户抽奖设置失败")
	}
	record, err := s.dao.GetUserLuckDrawByLuckDraw(user.CustomerId, luckdrawid)
	if err != nil {
		utils.LogError("获取用户的抽奖信息失败: " + err.Error())
		return nil, nil, errors.New("获取用户的抽奖信息失败")
	}
	return record, customerSet, nil
}

func (s *LuckdrawServ) GetDetailByRecord(recordid string) (*model.TaPrizeDetail, error) {
	detail, err := s.dao.GetDetailByRecord(recordid)
	if err != nil {
		utils.LogError("获取detail失败: " + err.Error())
		return nil, errors.New("获取detail失败")
	}
	return detail, nil
}

func (s *LuckdrawServ) GetUserLuckDraw(userid string) ([]luckdraw.UserRecord, error) {
	record, err := s.dao.GetUserLuckDraw(userid)
	if err != nil {
		utils.LogError("获取用户的抽奖信息失败: " + err.Error())
		return nil, errors.New("获取用户的抽奖信息失败")
	}
	return record, nil

}

func (s *LuckdrawServ) GetRecordByLuckDraw(luckdrawid string) ([]model.TaLuckdrawRecord, error) {
	record, err := s.dao.GetRecordByLuckDraw(luckdrawid)
	if err != nil {
		utils.LogError("获取抽奖记录失败: " + err.Error())
		return nil, errors.New("获取抽奖记录失败")
	}
	return record, nil
}

func (s *LuckdrawServ) GetRecordByID(id string) (*luckdraw.LuckInfo, error) {
	record, err := s.dao.GetRecordByID(id)
	if err != nil {
		utils.LogError("获取抽奖记录明细失败: " + err.Error())
		return nil, errors.New("获取抽奖记录明细失败")
	}
	return record, nil
}

func (s *LuckdrawServ) GetUserByTel(tel string) (*model.SysUser, error) {
	user, err := s.dao.GetUserByTel(tel)
	if err != nil {
		utils.LogError("根据 tel 获取用户人员信息失败: " + err.Error())
		return nil, errors.New("根据 tel 获取用户人员信息失败")
	}
	return user, nil

}

func (s *LuckdrawServ) SaveLuckDrawShareData(dt *model.TaShareLuckyRecord) error {
	err := s.dao.SaveLuckDrawShareData(dt)
	if err != nil {
		utils.LogError("保存用户分享信息失败: " + err.Error())
		return errors.New("保存用户分享信息失败")
	}
	return nil

}
func (s *LuckdrawServ) GetLuckDrawShareData(luckID, from, to, caseID string) ([]model.TaShareLuckyRecord, error) {
	share, err := s.dao.GetLuckDrawShareData(luckID, from, to, caseID)
	if err != nil {
		utils.LogError("获取抽奖分享失败: " + err.Error())
		return nil, errors.New("获取抽奖分享失败")
	}
	return share, nil
}

// UpdateShareNum 更新抽奖次数
func (s *LuckdrawServ) UpdateShareNum(luckdraw *luckdraw.LuckDraw, fromid string) error {
	err := s.dao.UpdateShareNum(luckdraw, fromid)
	return err
}