services/service/gymcard/gymcard.go

package gymcard

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/customer"
	"spaceofcheng/services/models/gymcard"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/service"
	"spaceofcheng/services/utils"
	"strings"
	"time"
)

// GymcardServ 系统处理
type GymcardServ struct {
	ctx  *utils.Context
	dao  *gymcard.GymcardDAO
	cdao *customer.CustomerDAO
}

// NewGymcardServ 初始化
func NewGymcardServ(ctx *utils.Context) *GymcardServ {
	return &GymcardServ{
		ctx:  ctx,
		dao:  gymcard.NewGymcardDAO(ctx),
		cdao: customer.NewCustomerDAO(ctx),
	}
}

// GetGymcardList 根据案场id获取健身卡列表
func (s *GymcardServ) GetGymcardList(caseID string, pagenavi ...int) ([]gymcard.Gymcard, int64, error) {
	filters := []string{}
	if caseID != "" {
		if err := utils.NewAuthEngine(s.ctx).CheckCase(caseID); err != nil {
			return nil, 0, err
		}

		filters = []string{
			"case_id='" + caseID + "'",
		}
	} else {
		casesRaw := s.ctx.Get("cases")
		if casesRaw == nil {
			return nil, 0, errors.New("请设置过滤案场")
		}

		cases := casesRaw.([]model.SysUserCase)
		caseIDs := []string{}
		for _, cs := range cases {
			caseIDs = append(caseIDs, cs.CaseId)
		}

		filters = []string{
			"case_id in ('" + strings.Join(caseIDs, "','") + "')",
		}
	}

	limit := utils.GetPageNaviLimit(pagenavi...)
	res, total, err := s.dao.GetGymcard(filters, limit)
	if err != nil {
		utils.LogError("查询卡列表失败: " + err.Error())
		return nil, 0, errors.New("查询卡列表失败")
	}

	return res, total, nil
}

// GetCustomerGymBycustomerId 根据客户id获取客户所有健身卡列表
func (s *GymcardServ) GetCustomerGymBycustomerId(page, pageSize int) (map[string]interface{}, error) {
	customer := s.ctx.Get("customer").(model.TaCustomer)
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	customerGym, err := s.dao.GetCustomerGymByCustomerId(customer.CustomerId, page, pageSize)
	if err != nil {
		utils.LogError("获取健身卡列表失败：" + err.Error())
		return nil, errors.New("获取健身卡列表失败")
	}
	total, err := s.dao.GetCustomerGymCountByCustomerId(customer.CustomerId)
	if err != nil {
		utils.LogError("获取健身卡列表失败：" + err.Error())
		return nil, errors.New("获取健身卡列表失败")
	}
	return map[string]interface{}{
		"list":     customerGym,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetCustomerGymByPhone 根据用户手机号获取用户健身卡列表
func (s *GymcardServ) GetCustomerGymByPhone(phone string) ([]gymcard.CustomerGym, error) {
	customerGym, err := s.dao.GetCustomerGymByPhone(phone)
	if err != nil {
		utils.LogError("获取健身卡列表失败：" + err.Error())
		return nil, errors.New("获取健身卡列表失败")
	}
	return customerGym, nil
}

// GetGymcardDetailById 根据id获取健身卡详情
func (s *GymcardServ) GetGymcardDetailById(gymcardId string) (*gymcard.Gymcard, error) {
	gymcard, err := s.dao.GetGymcardById(gymcardId)
	if err != nil {
		utils.LogError("获取健身卡详情失败" + err.Error())
		return nil, errors.New("获取健身卡详情失败")
	}
	return gymcard, nil
}

// GetCustomerGymDetailById 根据id获取客户健身卡详情
func (s *GymcardServ) GetCustomerGymDetailById(customerGymId string) (*gymcard.CustomerGym, error) {
	customerGym, err := s.dao.GetCustomerGymById(customerGymId)
	if err != nil {
		utils.LogError("获取健身卡详情失败" + err.Error())
		return nil, errors.New("获取健身卡详情失败")
	}
	return customerGym, err
}

// SaveGymcard 保存游泳健身卡
func (s *GymcardServ) SaveGymcard(newGym gymcard.Gymcard) (*gymcard.Gymcard, error) {
	var cardGym = model.TaGymCard{}
	var err error
	if newGym.GymCardId == "" {
		cardGym, err = s.dao.AddGymcard(newGym.TaGymCard)
		if err != nil {
			utils.LogError("保存健身卡信息失败" + err.Error())
			return nil, errors.New("保存健身卡信息失败")
		}
		err = s.dao.AddGymcardImg(cardGym.GymCardId, newGym.CardImageUrl)
		if err != nil {
			utils.LogError("保存健身卡信息失败" + err.Error())
			return nil, errors.New("保存健身卡信息失败")
		}
		err = s.dao.AddGymcardShare(cardGym.GymCardId, newGym.CardShareInfo, newGym.CardUseRule, newGym.CardUseInstruction)
		if err != nil {
			utils.LogError("保存健身卡信息失败" + err.Error())
			return nil, errors.New("保存健身卡信息失败")
		}
		if newGym.SendType == "channel" {
			err = s.dao.AddCardChannel(cardGym.GymCardId, newGym.ChannelId)
		}
	} else {
		err = s.dao.EditGymcardImg(newGym.GymCardId, newGym.CardImageUrl)
		// if err != nil {
		// 	utils.LogError("保存健身卡信息失败" + err.Error())
		// 	return nil, errors.New("保存健身卡信息失败")
		// }
		err = s.dao.EditGymcardShare(newGym.GymCardId, newGym.CardShareInfo, newGym.CardUseRule, newGym.CardUseInstruction)
		// if err != nil {
		// 	utils.LogError("保存健身卡信息失败" + err.Error())
		// 	return nil, errors.New("保存健身卡信息失败")
		// }
	}
	if err != nil {
		utils.LogError("保存健身卡信息失败" + err.Error())
		return nil, errors.New("保存健身卡信息失败")
	}
	return &newGym, nil
}

// SendGymCardToUser 给客户发卡
func (s *GymcardServ) SendGymCardToUser(gymcardId, sysuserId string) (*model.TaCustomerGym, error) {
	var customerGym *model.TaCustomerGym
	customer := s.ctx.Get("customer").(model.TaCustomer)
	var sysuser *model.SysUser
	gymCard, err := s.dao.GetGymcardById(gymcardId)
	if err != nil {
		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
		return nil, errors.New("发送游泳健身卡给客户失败")
	}
	if gymCard.TotalCount-gymCard.SentCount < 1 {
		return nil, errors.New("健身卡剩余数量不足！")
	}
	sysuser, err = s.cdao.GetUserByID(sysuserId)
	if err != nil {
		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
		return nil, errors.New("发送游泳健身卡给客户失败")
	}
	gymCard.SentCount = gymCard.SentCount + 1

	customerGym, err = s.dao.SendGymcardToCustomer(&gymCard.TaGymCard, customer.CustomerId, sysuserId, sysuser.RealName, models.RECEIVEING_TYPE_SALES)
	if err != nil {
		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
		return nil, errors.New("发送游泳健身卡给客户失败")
	}

	err = s.dao.EditGymcard(&gymCard.TaGymCard)
	if err != nil {
		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
		return nil, errors.New("发送游泳健身卡给客户失败")
	}
	return customerGym, nil
}

// // SendGymCardToUser 后台给客户发卡
// func (s *GymcardServ) BackSendGymCardToUser(gymcardId, sysuserId, customerId string) (*model.TaCustomerGym, error) {
// 	var customerGym *model.TaCustomerGym
// 	var sysuser *model.SysUser
// 	gymCard, err := s.dao.GetGymcardById(gymcardId)
// 	if err != nil {
// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
// 		return nil, errors.New("发送游泳健身卡给客户失败")
// 	}
// 	if gymCard.TotalCount-gymCard.SentCount < 1 {
// 		return nil, errors.New("健身卡剩余数量不足！")
// 	}
// 	sysuser, err = s.cdao.GetUserByID(sysuserId)
// 	if err != nil {
// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
// 		return nil, errors.New("发送游泳健身卡给客户失败")
// 	}
// 	gymCard.SentCount = gymCard.SentCount + 1
// 	customerGym, err = s.dao.SendGymcardToCustomer(&gymCard.TaGymCard, customerId, sysuserId, sysuser.RealName,)
// 	if err != nil {
// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
// 		return nil, errors.New("发送游泳健身卡给客户失败")
// 	}

// 	err = s.dao.EditGymcard(&gymCard.TaGymCard)
// 	if err != nil {
// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
// 		return nil, errors.New("发送游泳健身卡给客户失败")
// 	}
// 	return customerGym, nil
// }

// UpdateCustomerGym 核销游泳健身卡
func (s *GymcardServ) UpdateCustomerGym(customerGymId, caseid string) error {
	var gymCard *gymcard.Gymcard
	customerGym, err := s.dao.GetCustomerGymById(customerGymId)
	if err != nil {
		utils.LogError("核销游泳健身卡失败" + err.Error())
		return errors.New("核销游泳健身卡失败")
	}
	if caseid != customerGym.CaseId {
		utils.LogError("核销游泳健身卡失败")
		return errors.New("您的健身卡不在本案场")
	}
	gymCard, err = s.dao.GetGymcardById(customerGym.GymCardId)
	if err != nil {
		utils.LogError("核销游泳健身卡失败" + err.Error())
		return errors.New("核销游泳健身卡失败")
	}
	if gymCard.GymTypeId == "once" {
		customerGym.Status = models.STATUS_DEL
		customerGym.CardStatus = models.CARD_COUPON_USED
		gymCard.UsedCount = gymCard.UsedCount + 1
	} else {
		if customerGym.StartDate.IsZero() {
			now := time.Now()
			customerGym.StartDate = time.Now()
			switch gymCard.GymTypeId {
			case "month":
				end, _ := time.ParseDuration("720h")
				customerGym.EndDate = now.Add(end)
			case "quarter":
				end, _ := time.ParseDuration("2160h")
				customerGym.EndDate = now.Add(end)
			case "year":
				end, _ := time.ParseDuration("8760h")
				customerGym.EndDate = now.Add(end)
			}
			gymCard.UsedCount = gymCard.UsedCount + 1
		}
	}
	if customerGym.EndDate.After(time.Now()) {
		customerGym.Status = models.STATUS_DEL
	}
	err = s.dao.UpdateCustomerGym(customerGym.TaCustomerGym)
	if err != nil {
		utils.LogError("核销游泳健身卡失败" + err.Error())
		return errors.New("核销游泳健身卡失败")
	}
	err = s.dao.EditGymcard(&gymCard.TaGymCard)
	if err != nil {
		utils.LogError("核销游泳健身卡失败" + err.Error())
		return errors.New("核销游泳健身卡失败")
	}
	err = s.dao.AddGymcardUsage(customerGym.TaCustomerGym)
	return err

}
func (s *GymcardServ) deleteGymCard(gymcardId string) error {
	gymCard, err := s.dao.GetGymcardById(gymcardId)
	if err != nil {
		utils.LogError("删除健身卡失败" + err.Error())
		return errors.New("删除健身卡失败")
	}
	err = s.dao.DeleteGymcard(gymcardId)
	if err != nil {
		utils.LogError("删除健身卡失败" + err.Error())
		return errors.New("删除健身卡失败")
	}
	err = s.dao.DeleteCardImg(gymcardId)
	if err != nil {
		utils.LogError("删除健身卡失败" + err.Error())
		return errors.New("删除健身卡失败")
	}
	err = s.dao.DeleteCardShare(gymcardId)
	if err != nil {
		utils.LogError("删除健身卡失败" + err.Error())
		return errors.New("删除健身卡失败")
	}
	if gymCard.SendType == "channel" {
		err = s.dao.DeleteCardChannel(gymcardId)
		if err != nil {
			utils.LogError("删除健身卡失败" + err.Error())
			return errors.New("删除健身卡失败")
		}
	}
	return err

}

// GiveCardToCustomer 赠送健身卡
func (s *GymcardServ) GiveCardToCustomer(gymcardId, uids string) error {
	gymCard, err := s.dao.GetGymcardById(gymcardId)
	if err != nil {
		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
		return errors.New("发送游泳健身卡给客户失败")
	}
	arrUID := strings.Split(uids, ",")
	if gymCard.TotalCount-gymCard.SentCount < len(arrUID) {
		return errors.New("健身卡剩余数量不足！")
	}

	for _, uid := range arrUID {
		_, err := s.dao.SendGymcardToCustomer(&gymCard.TaGymCard, uid, "", "", models.RECEIVEING_TYPE_GIVE)
		if err != nil {
			utils.LogError("发送游泳健身卡给客户失败" + err.Error())
			return errors.New("发送游泳健身卡给客户失败")
		}
		gymCard.SentCount = gymCard.SentCount + 1
	}
	err = s.dao.EditGymcard(&gymCard.TaGymCard)
	if err != nil {
		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
		return errors.New("发送游泳健身卡给客户失败")
	}
	return nil
}