minghui/mh_server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1、增加尊享会员兑换码兑换流程；

Browse Source
This commit is contained in:
chenlin 2025-06-03 16:05:17 +08:00
parent d2e296c90a
commit ac708767d7
2 changed files with 363 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
model/coupon.go
View File

@ -7,7 +7,7 @@ const (
RenewalMemberActivityId = 1 // 会员续费优惠券
OpenMemberActivityId = 4 // 开通会员优惠券
CommonSaleActivityId = 5 // 零售销售（普通会员）
PrivilegeMemberActivityId = 6 // 零售销售（尊享会员
PrivilegeMemberActivityId = 6 // 零售销售（尊享会员)
VmActivityId = 9 // 积分兑换优惠券
NewMachineActivityId = 10 // 主机预订券
OpenPrivilegeMemberActivityType = 11 // 开通尊享会员优惠券

367
model/redeem_code.go
View File

@ -5,6 +5,8 @@ import (
"errors"
"fmt"
"github.com/codinl/go-logger"
"github.com/jinzhu/gorm"
"mh-server/lib/utils"
"strings"
"time"
)
@ -20,6 +22,7 @@ const (
CodeTypeMemberPlatinumMember = "member-card-platinum-member"
CodeTypeMemberBlackGoldMember = "member-card-black-gold-member"
CodeTypeDeductionCoupon5 = "deduction-coupon-5"
CodeTypeMemberPrivilegeMember = "member-card-privilege-member" // 尊享会员兑换码
)
const (
@ -137,7 +140,7 @@ func UserRedeemCodeList(uid uint32, status string) ([]UserRedeemCode, error) {
return append(holdList, usedList...), nil
}
// 会员兑换码兑换
// UserRedeemCodeConvert 会员兑换码兑换
func UserRedeemCodeConvert(uid uint32, serialCode string) error {
var userRedeem UserRedeemCode
err := NewUserRedeemCodeQuerySet(DB).UidEq(uid).SerialCodeEq(serialCode).One(&userRedeem)
@ -149,6 +152,10 @@ func UserRedeemCodeConvert(uid uint32, serialCode string) error {
return errors.New("user redeem code not exist")
}
if userRedeem.CodeType == CodeTypeMemberPrivilegeMember { // 尊享会员兑换码
return PrivilegeUserRedeemCodeConvert(uid, serialCode)
}
begin := DB.Begin()
num, err := NewRedeemCodeQuerySet(begin).SerialCodeEq(serialCode).GetUpdater().SetStatus(RedeemCodeStatusUsed).UpdateNum()
if err != nil {
@ -162,10 +169,6 @@ func UserRedeemCodeConvert(uid uint32, serialCode string) error {
return err
}
//qsUserRedeem := NewUserRedeemCodeQuerySet(begin).UidEq(uid).SerialCodeEq(serialCode).GetUpdater()
//if userRedeem.CodeType == CodeTypeMemberGoldMember {
// //qsUserRedeem = qsUserRedeem.SetCodeType()
//}
updateNum, err := NewUserRedeemCodeQuerySet(begin).UidEq(uid).SerialCodeEq(serialCode).GetUpdater().
SetStatus(UserRedeemCodeStatusUsed).SetConvertTime(time.Now()).UpdateNum()
if err != nil {
@ -178,6 +181,7 @@ func UserRedeemCodeConvert(uid uint32, serialCode string) error {
begin.Rollback()
return err
}
user := GetUserByUid(uid)
qs := NewUserQuerySet(begin).UidEq(uid).GetUpdater()
if user.MemberLevel != 1 && user.MemberLevel != 3 &&
@ -240,6 +244,359 @@ func UserRedeemCodeConvert(uid uint32, serialCode string) error {
return nil
}
// PrivilegeUserRedeemCodeConvert 尊享会员兑换码兑换
func PrivilegeUserRedeemCodeConvert(uid uint32, serialCode string) error {
begin := DB.Begin()
// 更新 redeem_code 表状态
num, err := NewRedeemCodeQuerySet(begin).SerialCodeEq(serialCode).
GetUpdater().SetStatus(RedeemCodeStatusUsed).UpdateNum()
if err != nil || num == 0 {
logger.Error("update redeem_code status failed:", err)
begin.Rollback()
return err
}
// 更新 user_redeem_code 表状态
updateNum, err := NewUserRedeemCodeQuerySet(begin).UidEq(uid).SerialCodeEq(serialCode).
GetUpdater().SetStatus(UserRedeemCodeStatusUsed).SetConvertTime(time.Now()).UpdateNum()
if err != nil || updateNum == 0 {
logger.Error("update user_redeem_code status failed:", err)
begin.Rollback()
return err
}
// 更新尊享会员邀请记录，并发放优惠券
err = UpdatePrivilegeMember(uid, begin)
if err != nil {
logger.Error("UpdatePrivilegeMember err:", err)
begin.Rollback()
return err
}
err = begin.Commit().Error
if err != nil {
logger.Error("transaction commit failed:", err)
begin.Rollback()
return err
}
return nil
}
// UpdatePrivilegeMember 更新尊享会员邀请记录，并发放优惠券
func UpdatePrivilegeMember(uid uint32, db *gorm.DB) error {
logger.Info("兑换码开通尊享会员")
record := &UserOpenMemberRecord{
Uid: uid,
MemberLevel: MemberLevelPrivilege,
}
memberRecord := &UserMemberRecord{
Uid: record.Uid,
AfterMemberLevel: record.MemberLevel,
}
newTime := time.Now()
privilegeMemberNew := &PrivilegeMember{}
var spendType uint32 // 开通类型： 1-未开通 2-开通会员 3-续费
var user User
err := NewUserQuerySet(db).UidEq(record.Uid).One(&user)
if err != nil {
logger.Error("err:", err)
return err
} else {
var privilegeMember PrivilegeMember
err = NewPrivilegeMemberQuerySet(db).UidEq(record.Uid).One(&privilegeMember)
if err != nil && err != RecordNotFound {
logger.Error("PrivilegeMember:", err)
return err
}
var expireTime time.Time
expireTime = newTime.AddDate(1, 0, 0)
if err == RecordNotFound { // 没有记录，用户新开通尊享会员
spendType = 2 // 2-开通会员
memberRecord.OpenMemberTime = newTime
memberRecord.Type = 9 // 开通会员类型
privilegeMemberNew.Uid = record.Uid
privilegeMemberNew.Tel = user.Tel
privilegeMemberNew.MemberLevel = MemberLevelPrivilege
privilegeMemberNew.MemberExpire = &expireTime
privilegeMemberNew.OpenMemberTime = &newTime
privilegeMemberNew.ExtendStatus = ExtendWaitActive
} else { // 有记录，用户续费尊享会员
spendType = 3 // 3-续费
memberRecord.OpenMemberTime = *privilegeMember.OpenMemberTime
memberRecord.BeforeMemberLevel = privilegeMember.MemberLevel
memberRecord.BeforeMemberExpire = *privilegeMember.MemberExpire
memberRecord.Serial = uint32(privilegeMember.MemberExpire.Unix())
if privilegeMember.MemberExpire.After(newTime) {
expireTime = privilegeMember.MemberExpire.AddDate(1, 0, 0)
}
memberRecord.Type = 10 // 续费会员类型
userUpdateQs := NewPrivilegeMemberQuerySet(db).UidEq(record.Uid).GetUpdater().
SetMemberLevel(record.MemberLevel).SetMemberExpire(&expireTime).SetExtendStatus(ExtendWaitActive)
_, err = userUpdateQs.UpdateNum()
if err != nil {
logger.Error("err:", err)
return err
}
}
memberRecord.AfterMemberExpire = expireTime
memberRecord.OpenMemberLevel = record.MemberLevel
// 邀请记录
var invite UserInvite
err = NewUserInviteQuerySet(db).ToUidEq(record.Uid).OrderDescByCreatedAt().Limit(1).One(&invite)
if err != nil && err != RecordNotFound {
logger.Error("err:", err)
} else {
if err == nil {
effectiveStoreInfo, err := GetUserEffectiveStore(invite.FromUid)
if err != nil {
logger.Error("GetUserEffectiveStore err:", err)
effectiveStoreInfo.StoreID = 0
}
privilegeMemberNew.StoreId = effectiveStoreInfo.StoreID
if invite.Action == 1 { // 首次开通会员
qs := NewUserInviteQuerySet(db).IDEq(invite.ID).GetUpdater()
invite.RenewHide = 1 // 自动
qs = qs.SetMemberOpenTime(newTime).SetMemberLevel(record.MemberLevel)
_, err = qs.SetMemberType(2).SetMemberStatus(2).
SetAction(2).SetSpendType(spendType).SetMemberGenre(record.MemberGenre).UpdateNum()
if err != nil {
logger.Error("update user invite action spend type err:", err)
}
if invite.UserInviteRecordId != 0 {
err = NewUserInviteRecordQuerySet(db).IDEq(invite.UserInviteRecordId).GetUpdater().
SetAction(2).SetSpendType(spendType).SetMemberLevel(record.MemberLevel).
SetActionTime(newTime).SetMemberGenre(record.MemberGenre).SetRenewHide(invite.RenewHide).Update()
if err != nil {
logger.Error("update user invite record err:", err)
}
}
} else { // 续费会员-用户直接续费
inviteRecordNew := &UserInviteRecord{
ToUid: invite.ToUid,
FromUid: invite.FromUid,
StoreId: effectiveStoreInfo.StoreID,
Action: 2,
SpendType: spendType,
MemberLevel: record.MemberLevel,
First: 0,
Scan: 0, // 自动生成
ActionTime: newTime,
MemberGenre: record.MemberGenre,
RenewHide: 1,
}
err = db.Create(inviteRecordNew).Error
if err != nil {
logger.Error("create invite record err:", err)
}
userInviteNew := &UserInvite{
FromUid: invite.FromUid,
UserType: invite.UserType,
StoreId: effectiveStoreInfo.StoreID,
StoreType: invite.StoreType,
MemberOpenTime: time.Now(),
MemberType: 2,
MemberStatus: 2,
ToUid: invite.ToUid,
Action: 2,
SpendType: spendType,
MemberLevel: record.MemberLevel,
UserInviteRecordId: inviteRecordNew.ID,
FirstInvite: 0,
Scan: 0,
MemberGenre: record.MemberGenre,
RenewHide: 1,
//MemberOpenTime: invite.MemberOpenTime,
}
err = db.Create(userInviteNew).Error
if err != nil {
logger.Error("create invite record err:", err)
}
}
if invite.FromUid != 0 {
logger.Info("invite.FromUid != 0")
fmt.Println("invite.FromUid != 0")
inviteUser := GetUserByUid(invite.FromUid)
if inviteUser != nil && inviteUser.UserType == 2 {
// 记录对应的数量
switch spendType {
case 2: // 开通
fmt.Println("用户开通------")
AddCooperativeMemberPromotion(inviteUser.CooperativeBusinessId,
uint32(effectiveStoreInfo.StoreID), inviteUser.Uid, int(record.MemberLevel),
int(record.MemberGenre))
case 3: // 续费
fmt.Println("用户续费---")
AddCooperativeMemberRenewal(inviteUser.CooperativeBusinessId,
uint32(invite.StoreId), inviteUser.Uid, int(record.MemberLevel),
int(record.MemberGenre), true)
}
}
}
} else if err == RecordNotFound { // 没有邀请记录，完全是用户自己开通会员，自己续费；按产品要求也需要有记录
inviteRecordNew := &UserInviteRecord{
ToUid: user.Uid,
Action: 2,
SpendType: spendType,
MemberLevel: record.MemberLevel,
First: 0,
Scan: 0, // 自动生成
ActionTime: newTime,
MemberGenre: record.MemberGenre,
RenewHide: 1,
}
err = db.Create(inviteRecordNew).Error
if err != nil {
logger.Error("create invite record err:", err)
}
// 记录对应的数量
switch spendType {
case 2: // 开通
fmt.Println("用户开通------")
AddCooperativeMemberPromotion(user.CooperativeBusinessId, 0, 0,
int(record.MemberLevel), int(record.MemberGenre))
case 3: // 续费
fmt.Println("用户续费---")
AddCooperativeMemberRenewal(user.CooperativeBusinessId, 0, 0,
int(record.MemberLevel), int(record.MemberGenre), true)
}
}
}
if spendType == 2 { // 开通会员，新建尊享会员记录
err = db.Create(privilegeMemberNew).Error
if err != nil {
logger.Error("create invite record err:", err)
}
}
err = db.Create(memberRecord).Error
if err != nil {
logger.Error("create member record err:", err)
}
}
// 发放优惠券
var coupons []Coupon
err = NewCouponQuerySet(db).ActivityIdEq(PrivilegeMemberActivityId).All(&coupons)
if err != nil {
logger.Error("coupons err:", err)
return err
}
for i, _ := range coupons {
if coupons[i].ActivityType == 6 || coupons[i].ActivityType == 7 { // 15元周边券，20元配件券，发4张
for j := 0; j < 4; j++ {
couponCode, err := utils.GenerateRandomNumber19()
if err != nil {
logger.Error("GenerateRandomNumber19err:", err)
}
userCoupon := &UserCoupon{
Uid: record.Uid,
CouponId: coupons[i].ID,
CouponType: coupons[i].CouponType,
ActivityType: coupons[i].ActivityType,
ActivityId: coupons[i].ActivityId,
Value: coupons[i].Value,
State: 1,
ActiveStart: time.Now(),
ActiveEnd: time.Now().AddDate(0, 6, 0),
UseTime: time.Time{},
MemberLevel: coupons[i].MemberLevel,
Approach: 0,
PromotionalSales: 0,
RedeemCode: "",
CategoryNumber: coupons[i].CategoryNumber,
CommodityNumber: coupons[i].CommodityNumber,
Code: couponCode,
}
err = db.Create(userCoupon).Error
if err != nil {
logger.Error("user coupon err:", err)
continue
}
}
} else if coupons[i].ActivityType == 8 { // 20元游戏券，发3张
for j := 0; j < 3; j++ {
couponCode, err := utils.GenerateRandomNumber19()
if err != nil {
logger.Error("GenerateRandomNumber19err:", err)
}
userCoupon := &UserCoupon{
Uid: record.Uid,
CouponId: coupons[i].ID,
CouponType: coupons[i].CouponType,
ActivityType: coupons[i].ActivityType,
ActivityId: coupons[i].ActivityId,
Value: coupons[i].Value,
State: 1,
ActiveStart: time.Now(),
ActiveEnd: time.Now().AddDate(0, 6, 0),
UseTime: time.Time{},
MemberLevel: coupons[i].MemberLevel,
Approach: 0,
PromotionalSales: 0,
RedeemCode: "",
CategoryNumber: coupons[i].CategoryNumber,
CommodityNumber: coupons[i].CommodityNumber,
Code: couponCode,
}
err = db.Create(userCoupon).Error
if err != nil {
logger.Error("user coupon err:", err)
continue
}
}
} else if coupons[i].ActivityType == 9 { // 贴膜券，2张
for j := 0; j < 2; j++ {
couponCode, err := utils.GenerateRandomNumber19()
if err != nil {
logger.Error("GenerateRandomNumber19err:", err)
}
userCoupon := &UserCoupon{
Uid: record.Uid,
CouponId: coupons[i].ID,
CouponType: coupons[i].CouponType,
ActivityType: coupons[i].ActivityType,
ActivityId: coupons[i].ActivityId,
Value: coupons[i].Value,
State: 1,
ActiveStart: time.Now(),
ActiveEnd: time.Now().AddDate(1, 0, 0),
UseTime: time.Time{},
MemberLevel: coupons[i].MemberLevel,
Approach: 0,
PromotionalSales: 0,
RedeemCode: "",
CategoryNumber: coupons[i].CategoryNumber,
CommodityNumber: coupons[i].CommodityNumber,
Code: couponCode,
}
err = db.Create(userCoupon).Error
if err != nil {
logger.Error("user coupon err:", err)
continue
}
}
}
}
return nil
}
func CodeSendToUser(uid uint32, codeType string, activityType uint32) error {
count, err := NewUserRedeemCodeQuerySet(DB).UidEq(uid).Count()
if err != nil {