mh_server/model/redeem_code.go

package model

import (
	"crypto/sha512"
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"strings"
	"time"
)

const (
	RedeemCodeStatusStock = "stocking"  // 库存
	RedeemCodeStatusHold  = "user-hold" // 用户持有
	RedeemCodeStatusUsed  = "used"      // 已使用
)
const (
	CodeTypeMemberCard30 = "member-card-30"
)

const (
	RedeemCodeSecretKey = "046033a527d1b723ed0a1012e6518d490"
)

const (
	UserRedeemCodeStatusHold = "user-hold"
	UserRedeemCodeStatusUsed = "used"
)

const (
	RedeemCodeActivityTypeStore      = 1 // 门店赠送
	RedeemCodeActivityTypeUserInvite = 2 // 用户邀请

)

//go:generate goqueryset -in redeem_code.go
// gen:qs
type RedeemCode struct {
	Model

	SerialCode     string    `json:"serial_code"  gorm:"index;comment:'兑换编码'"` // 兑换编码
	CodeType       string    `json:"code_type"`                                // memberCard
	Status         string    `json:"status" gorm:"index;comment:'兑换状态'"`       // stocking user-hold used
	CodeSecret     string    `json:"code_secret"`                              // 兑换密码
	EffectiveTime  time.Time `json:"effective_time"`                           // 生效时间
	ExpirationTime time.Time `json:"expiration_time"`                          // 过期时间
}

// gen:qs
type UserRedeemCode struct {
	Model
	Uid          uint32    `json:"uid" gorm:"index;comment:'用户id'"`
	Status       string    `json:"status" gorm:"index;comment:'兑换状态'"`       // user-hold used
	SerialCode   string    `json:"serial_code"  gorm:"index;comment:'兑换编码'"` // 兑换编码
	CodeType     string    `json:"code_type"`                                // memberCard
	ConvertTime  time.Time `json:"convert_time"`                             // 绑定时间
	ActivityType uint32    `json:"activity_type"`                            // 1-门店赠送 2-用户邀请
}

//type BindingRedeemCodeRecord struct {
//	Model
//}

// 会员兑换码
// 用户押金
// 支付押金
// 押金
// 开通会员
// 管理端 发 会员 Sign  校验

func RedeemSecretCode(redeem string) string {
	semen := redeem[:13] + strings.ToUpper(RedeemCodeSecretKey)
	shaer := sha512.New()
	shaer.Write([]byte(semen))
	r := shaer.Sum(nil)
	hs := fmt.Sprintf("%x", r)
	return hs[:7]
}

func UserRedeemCodeList(uid uint32) ([]UserRedeemCode, error) {
	var userRedeems []UserRedeemCode
	err := NewUserRedeemCodeQuerySet(DB).UidEq(uid).OrderDescByID().All(&userRedeems)
	if err != nil && err != RecordNotFound {
		logger.Error("user redeem code err:", err)
		return userRedeems, err
	}
	if len(userRedeems) == 0 {
		return userRedeems, nil
	}
	holdList := make([]UserRedeemCode, 0)
	usedList := make([]UserRedeemCode, 0)
	for i, _ := range userRedeems {
		if userRedeems[i].Status == UserRedeemCodeStatusHold {
			holdList = append(holdList, userRedeems[i])
		} else {
			usedList = append(usedList, userRedeems[i])
		}
	}

	return append(holdList, usedList...), nil
}

func UserRedeemCodeConvert(uid uint32, serialCode string) error {
	var userRedeem UserRedeemCode
	err := NewUserRedeemCodeQuerySet(DB).UidEq(uid).SerialCodeEq(serialCode).One(&userRedeem)
	if err != nil {
		logger.Error("user redeem code err:", err)
		return err
	}
	if userRedeem.Status != UserRedeemCodeStatusHold {
		return errors.New("user redeem code not exist")
	}

	begin := DB.Begin()
	num, err := NewRedeemCodeQuerySet(begin).SerialCodeEq(serialCode).GetUpdater().SetStatus(RedeemCodeStatusUsed).UpdateNum()
	if err != nil {
		logger.Error("user redeem code err:", err)
		begin.Rollback()
		return err
	}
	if num == 0 {
		logger.Error("num is 0 err:")
		begin.Rollback()
		return err
	}
	updateNum, err := NewUserRedeemCodeQuerySet(begin).UidEq(uid).SerialCodeEq(serialCode).GetUpdater().
		SetStatus(UserRedeemCodeStatusUsed).SetConvertTime(time.Now()).UpdateNum()
	if err != nil {
		logger.Error("user redeem code err:", err)
		begin.Rollback()
		return err
	}
	if updateNum == 0 {
		logger.Error("num is 0 err:")
		begin.Rollback()
		return err
	}
	user := GetUserByUid(uid)
	qs := NewUserQuerySet(begin).UidEq(uid).GetUpdater()
	if user.MemberLevel == 1 {
		qs = qs.SetMemberLevel(3)
	}

	if user.MemberExpire.After(time.Now()) {
		qs = qs.SetMemberExpire(user.MemberExpire.AddDate(0, 0, 30))
	} else {
		qs = qs.SetMemberExpire(time.Now().AddDate(0, 0, 30))
	}
	userNum, err := qs.UpdateNum()
	if err != nil {
		logger.Error("user redeem code err:", err)
		begin.Rollback()
		return err
	}
	if userNum == 0 {
		logger.Error("num is 0 err:")
		begin.Rollback()
		return err
	}
	err = begin.Commit().Error
	if err != nil {
		logger.Error("user redeem code err:", err)
		begin.Rollback()
		return err
	}

	return nil
}

func CodeSendToUser(uid uint32, codeType string) error {
	count, err := NewUserRedeemCodeQuerySet(DB).UidEq(uid).Count()
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	if count > 24 {
		logger.Error("redeem code limit 24")
		return errors.New("redeem code limit 24")
	}
	var redeemCode RedeemCode
	err = NewRedeemCodeQuerySet(DB).StatusEq(RedeemCodeStatusStock).CodeTypeEq(codeType).Limit(1).One(&redeemCode)
	if err != nil {
		logger.Errorf("err:%#v", err)
		return err
	}

	begin := DB.Begin()

	sql := fmt.Sprintf("UPDATE redeem_code SET `status` ='%s' WHERE id =%d", RedeemCodeStatusHold, redeemCode.ID)
	err = begin.Exec(sql).Error
	if err != nil {
		logger.Errorf("err:%#v", err)
		begin.Rollback()
		return err
	}
	userRedeemCode := &UserRedeemCode{
		Uid:          uid,
		Status:       UserRedeemCodeStatusHold,
		SerialCode:   redeemCode.SerialCode,
		CodeType:     redeemCode.CodeType,
		ActivityType: RedeemCodeActivityTypeUserInvite,
	}
	err = begin.Create(userRedeemCode).Error
	if err != nil {
		logger.Errorf("err:%#v", err)
		begin.Rollback()
		return err
	}
	err = begin.Commit().Error
	if err != nil {
		logger.Errorf("err:%#v", err)
		begin.Rollback()
		return err
	}
	return nil
}