fix:

controller/activity.go

@@ -1,12 +1,14 @@
 package controller
 
 import (
+	"fmt"
 	"github.com/codinl/go-logger"
 	"github.com/gin-gonic/gin"
 	"mh-server/lib/auth"
 	"mh-server/lib/status"
 	"mh-server/lib/utils"
 	"mh-server/model"
+	"time"
 )
 
 func UserRedeemCodeList(c *gin.Context) {
@@ -65,8 +67,10 @@ func UserMemberRenewalState(c *gin.Context) {
 		return
 	}
 	var activityMemberRenewal model.ActivityMemberRenewal
-	err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).StateEq(1).
+	//err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).StateEq(1).
-		One(&activityMemberRenewal)
+	//	One(&activityMemberRenewal)
+	err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).OrderDescByID().
+		Limit(1).One(&activityMemberRenewal)
 	if err != nil && err != model.RecordNotFound {
 		logger.Error("activity member renewal err:", err)
 		RespJson(c, status.InternalServerError, nil)
@@ -74,16 +78,18 @@ func UserMemberRenewalState(c *gin.Context) {
 	}
 	isPop := true
 
-	if err == model.RecordNotFound {
+	if err == model.RecordNotFound || uint32(user.MemberExpire.Unix()) != activityMemberRenewal.MemberSerial {
-		if user.MemberExpire.After(utils.Now().AddDate(0, -1, 0)) &&
+		//if user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0)) &&
-			user.MemberExpire.Before(utils.Now()) {
+		//	user.MemberExpire.After(utils.Now()) {
+		if user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0)) {
 			activityMemberRenewal = model.ActivityMemberRenewal{
-				ActivityId:  1,
+				ActivityId:   1,
-				Uid:         uc.Uid,
+				Uid:          uc.Uid,
-				State:       1,
+				State:        1,
-				StartTime:   utils.Now(),
+				StartTime:    utils.Now(),
-				IsPop:       true,
+				IsPop:        true,
-				MemberLevel: user.MemberLevel,
+				MemberLevel:  user.MemberLevel,
+				MemberSerial: uint32(user.MemberExpire.Unix()),
 			}
 
 			err = model.DB.Create(&activityMemberRenewal).Error
@@ -92,10 +98,23 @@ func UserMemberRenewalState(c *gin.Context) {
 				RespJson(c, status.InternalServerError, nil)
 				return
 			}
+			go func() {
+				renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, model.UserRenewalLogActionPop)
+				userLog := &model.UserRenewalLog{
+					Uid:          uc.Uid,
+					Action:       model.UserRenewalLogActionPop,
+					MemberExpire: user.MemberExpire,
+					Type:         0,
+					RenewalNum:   renewalLog.RenewalNum + 1,
+					Serial:       uint32(user.MemberExpire.Unix()),
+				}
+				_ = userLog.Add()
+			}()
+
 			isPop = false
 		}
 	}
-	if activityMemberRenewal.StartTime.AddDate(0, 0, 7).Before(utils.Now()) {
+	if activityMemberRenewal.StartTime.AddDate(0, 0, model.MemberRenewalExpiration).Before(utils.Now()) {
 		activityMemberRenewal.State = 3
 		_, err = model.NewActivityMemberRenewalQuerySet(model.DB).IDEq(activityMemberRenewal.ID).GetUpdater().
 			SetState(3).UpdateNum()
@@ -145,14 +164,37 @@ func UserMemberRenewalInfo(c *gin.Context) {
 	}
 
 	var userCoupons []model.UserCoupon
+	//err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(renewal.ActivityId).
+	//	StateEq(1).All(&userCoupons)
+	now := time.Now()
 	err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(renewal.ActivityId).
-		StateEq(1).All(&userCoupons)
+		ActiveStartLte(now).ActiveEndGte(now).All(&userCoupons)
 	if err != nil {
 		logger.Error("userCoupons err:", err)
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
-
+	user := model.GetUserByUid(uc.Uid)
+	exist, err := model.QueryRecordExist(
+		fmt.Sprintf("SELECT * FROM user_renewal_log WHERE uid = %d AND action=2 AND serial=%d",
+			uc.Uid, user.MemberExpire.Unix()))
+	if err != nil {
+		logger.Error("user log exist err:", err)
+	}
+	if err == nil && !exist {
+		go func() {
+			renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, model.UserRenewalLogActionEnterActivity)
+			userLog := &model.UserRenewalLog{
+				Uid:          uc.Uid,
+				Action:       model.UserRenewalLogActionEnterActivity,
+				MemberExpire: user.MemberExpire,
+				Type:         0,
+				RenewalNum:   renewalLog.RenewalNum + 1,
+				Serial:       uint32(user.MemberExpire.Unix()),
+			}
+			_ = userLog.Add()
+		}()
+	}
 	userCouponMap := make(map[uint32]*model.UserCoupon, 0)
 	for i, _ := range userCoupons {
 		userCouponMap[userCoupons[i].CouponId] = &userCoupons[i]
@@ -164,7 +206,7 @@ func UserMemberRenewalInfo(c *gin.Context) {
 			coupons[i].IsDraw = true
 		}
 	}
-	down := 7*24*3600 - (utils.Now().Unix() - renewal.StartTime.Unix())
+	down := model.MemberRenewalExpiration*24*3600 - (utils.Now().Unix() - renewal.StartTime.Unix())
 	ret := map[string]interface{}{
 		"coupon_list": coupons,
 		"renewal":     renewal,
@@ -193,8 +235,36 @@ func UserMemberRenewalCouponDraw(c *gin.Context) {
 		RespOK(c, nil)
 		return
 	}
+	user := model.GetUserByUid(uc.Uid)
+	var activityMemberRenewal model.ActivityMemberRenewal
+	err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().
+		Limit(1).One(&activityMemberRenewal)
+	if err != nil {
+		logger.Error("activity member renewal err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+	if !user.IsMember() ||
+		activityMemberRenewal.State == 3 {
+		logger.Error("user coupon err")
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	var userCoupons []model.UserCoupon
+	err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityTypeEq(1).
+		StateEq(1).All(&userCoupons)
+	if err != nil {
+		logger.Error("coupons err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+	userCouponMap := make(map[uint32]int, 0)
+	for i, _ := range userCoupons {
+		userCouponMap[userCoupons[i].CouponId] = i
+	}
 	var coupons []model.Coupon
-	err := model.NewCouponQuerySet(model.DB).IDIn(req.CouponIds...).All(&coupons)
+	err = model.NewCouponQuerySet(model.DB).IDIn(req.CouponIds...).All(&coupons)
 	if err != nil {
 		logger.Error("coupons err:", err)
 		RespJson(c, status.InternalServerError, nil)
@@ -202,6 +272,32 @@ func UserMemberRenewalCouponDraw(c *gin.Context) {
 	}
 
 	for i, _ := range coupons {
+		_, ok := userCouponMap[coupons[i].ID]
+		if ok {
+			continue
+		}
+
+		go func() {
+			action := 0
+			if coupons[i].MemberLevel == 2 {
+				action = model.UserRenewalLogActionPickGold
+			} else if coupons[i].MemberLevel == 4 {
+				action = model.UserRenewalLogActionPickPlatinum
+			} else if coupons[i].MemberLevel == 5 {
+				action = model.UserRenewalLogActionPickBlackGold
+			}
+			renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
+			userLog := &model.UserRenewalLog{
+				Uid:          uc.Uid,
+				Action:       uint32(action),
+				MemberExpire: user.MemberExpire,
+				Type:         0,
+				RenewalNum:   renewalLog.RenewalNum + 1,
+				Serial:       uint32(user.MemberExpire.Unix()),
+			}
+			_ = userLog.Add()
+		}()
+
 		userCoupon := &model.UserCoupon{
 			Uid:          uc.Uid,
 			CouponId:     coupons[i].ID,
@@ -210,8 +306,8 @@ func UserMemberRenewalCouponDraw(c *gin.Context) {
 			ActivityId:   coupons[i].ActivityId,
 			Value:        coupons[i].Value,
 			State:        1,
-			ActiveStart:  coupons[i].ActiveStart,
+			ActiveStart:  time.Now(),
-			ActiveEnd:    coupons[i].ActiveEnd,
+			ActiveEnd:    time.Now().AddDate(0, 0, model.MemberRenewalExpiration),
 			MemberLevel:  coupons[i].MemberLevel,
 		}
 
@@ -252,7 +348,9 @@ func MemberRenewalUserCouponList(c *gin.Context) {
 	}
 
 	qs := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid)
-
+	if req.State != 0 {
+		qs = qs.StateEq(req.State)
+	}
 	count, err := qs.Count()
 	if err != nil {
 		logger.Error("count err:", err)
@@ -268,7 +366,20 @@ func MemberRenewalUserCouponList(c *gin.Context) {
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
+	ids := make([]uint32, 0)
+	for i, _ := range coupons {
+		if coupons[i].ActiveEnd.Before(time.Now()) && coupons[i].State != 3 {
+			ids = append(ids, coupons[i].ID)
+			coupons[i].State = 3
+		}
+	}
 
+	if len(ids) > 0 {
+		err = model.NewUserCouponQuerySet(model.DB).IDIn(ids...).GetUpdater().SetState(3).Update()
+		if err != nil {
+			logger.Error("update user coupon err:", err)
+		}
+	}
 	ret := map[string]interface{}{
 		"list":       coupons,
 		"total_page": totalPage,

controller/game_card.go

@@ -38,7 +38,9 @@ func GameCardList(c *gin.Context) {
 		Page:     1,
 		PageSize: 10,
 	}
+
 	if c.ShouldBindJSON(&req) != nil {
+		logger.Error("para err")
 		RespJson(c, status.BadRequest, nil)
 		return
 	}
@@ -175,8 +177,9 @@ func GameCardHotSearch(c *gin.Context) {
 func HomeCarouselList(c *gin.Context) {
 	uc := auth.GetCurrentUser(c)
 	if uc == nil {
-		RespJson(c, status.Unauthorized, nil)
+		//RespJson(c, status.Unauthorized, nil)
-		return
+		//return
+		uc = &auth.UserClaims{Uid: 0}
 	}
 	carouselList, err := model.GetHomeCarouselList()
 	if err != nil {
@@ -184,9 +187,21 @@ func HomeCarouselList(c *gin.Context) {
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
+
+	var activityMemberRenewal model.ActivityMemberRenewal
+	if uc.Uid != 0 {
+		err = model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().
+			Limit(1).One(&activityMemberRenewal)
+		if err != nil && err != model.RecordNotFound {
+			logger.Error("activity member renewal err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+	}
 	user := model.GetUserByUid(uc.Uid)
-	if user.MemberExpire.After(utils.Now().AddDate(0, -1, 0)) &&
+	if uc.Uid == 0 || !user.IsMember() || !(user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0))) ||
-		user.MemberExpire.Before(utils.Now()) {
+		activityMemberRenewal.State == 3 {
+		//	&& user.MemberExpire.After(utils.Now()))
 		list := make([]model.HomeCarousel, 0, len(carouselList))
 		for i, _ := range carouselList {
 			if carouselList[i].ActivityType == 1 {
@@ -196,6 +211,7 @@ func HomeCarouselList(c *gin.Context) {
 		}
 		carouselList = list
 	}
+
 	RespOK(c, carouselList)
 }
 
@@ -397,16 +413,16 @@ func PushWXPayNotice(c *gin.Context) {
 		logger.Info("开通会员 支付成功:")
 		logger.Info("用户uid:", notifyInfo.OutTradeNo)
 
-		//uid, err := strconv.Atoi(notify.OutTradeNo)
-		//if err != nil {
-		//	logger.Error("err:", err)
-		//	return
-		//}
 		record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
 		err := record.GetByOpenNo()
 		if err != nil {
 			logger.Error("err:", err)
 		}
+		if record.State == 2 {
+			ret.ReturnCode = "SUCCESS"
+			RespBodyXML(c, ret)
+			return
+		}
 
 		remark := ""
 		if record.MemberLevel == 2 {
@@ -424,20 +440,11 @@ func PushWXPayNotice(c *gin.Context) {
 		if err != nil {
 			logger.Error("err:", err)
 		} else {
-			//expireTime := user.MemberExpire.AddDate(1, 0, 0)
-			//if user.MemberLevel == 1 {
-			//	expireTime = time.Now().AddDate(1, 0, 0)
-			//}
 			expireTime := time.Now().AddDate(1, 0, 0)
 			if user.MemberExpire.After(time.Now()) {
 				expireTime = user.MemberExpire.AddDate(1, 0, 0)
 			}
 
-			//configInfo, err := model.PayConfigInfo()
-			//if err != nil {
-			//	logger.Error("err:", err)
-			//	return
-			//}
 			memberConfig, err := model.GetMemberConfig(record.MemberLevel)
 			if err != nil {
 				logger.Error("GetMemberConfig err:", err)
@@ -450,11 +457,17 @@ func PushWXPayNotice(c *gin.Context) {
 			_, err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).
 				SetMemberExpire(expireTime).SetDeposit(memberConfig.MemberDeposit).SetOpenMemberTime(openMemberTime).
 				UpdateNum()
-			//err = model.UserUpdate(&model.User{Uid: uint32(record.Uid), MemberLevel: record.MemberLevel, MemberExpire: expireTime, Deposit: memberConfig.MemberDeposit})
 			if err != nil {
 				logger.Error("err:", err)
 				return
 			}
+			if record.UserCouponId > 0 {
+				err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
+					SetState(2).SetUseTime(utils.Now()).Update()
+				if err != nil {
+					logger.Error("update user coupon state err:", err)
+				}
+			}
 
 			var invite model.UserInvite
 			err = model.NewUserInviteQuerySet(model.DB).ToUidEq(record.Uid).OrderDescByID().Limit(1).One(&invite)
@@ -495,56 +508,49 @@ func PushWXPayNotice(c *gin.Context) {
 
 					if invite.FromUid != 0 {
 						inviteUser := model.GetUserByUid(invite.FromUid)
-						if inviteUser.UserType != 2 /*不是店员*/ && user.MemberLevel != 2 { // 邀请 新用户推送一次
+						if inviteUser != nil {
-							err = model.SendUserVm(inviteUser.Uid, record.MemberLevel, 1)
+							if inviteUser.UserType != 2 /*不是店员*/ && user.MemberLevel != 2 { // 邀请 新用户推送一次
+								err = model.SendUserVm(inviteUser.Uid, record.MemberLevel, 1)
+								if err != nil {
+									logger.Error("send user vm err:", err)
+								}
+							}
+
+							err = model.SendUserVm(user.Uid, record.MemberLevel, 0)
 							if err != nil {
 								logger.Error("send user vm err:", err)
 							}
-						}
 
-						err = model.SendUserVm(user.Uid, record.MemberLevel, 0)
+							openMemberChannel := model.OpenMemberChannelUserInvite
-						if err != nil {
+							userQs := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater()
-							logger.Error("send user vm err:", err)
-						}
 
-						openMemberChannel := model.OpenMemberChannelUserInvite
+							if inviteUser.UserType == 2 {
-						userQs := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater()
+								openMemberChannel = model.OpenMemberChannelStorePromotion
+								model.AddCooperativeMemberPromotion(inviteUser.CooperativeBusinessId,
+									uint32(inviteUser.StoreId), inviteUser.Uid, int(record.MemberLevel))
 
-						if inviteUser.UserType == 2 {
+								userQs = userQs.SetCooperativeBusinessId(inviteUser.CooperativeBusinessId).
-							openMemberChannel = model.OpenMemberChannelStorePromotion
+									SetCooperativeName(inviteUser.CooperativeName)
-							model.AddCooperativeMemberPromotion(inviteUser.CooperativeBusinessId,
+							}
-								uint32(inviteUser.StoreId), inviteUser.Uid, int(record.MemberLevel))
 
-							userQs = userQs.SetCooperativeBusinessId(inviteUser.CooperativeBusinessId).
+							_, err = userQs.SetOpenMemberChannel(openMemberChannel).UpdateNum()
-								SetCooperativeName(inviteUser.CooperativeName)
+							if err != nil {
-						}
+								logger.Error("err:", err)
-
+							}
-						_, err = userQs.SetOpenMemberChannel(openMemberChannel).UpdateNum()
-						if err != nil {
-							logger.Error("err:", err)
 						}
 					}
 				}
 			}
 
 			if user.MemberLevel != 2 {
-				//err = model.CodeSendToUser(user.Uid, model.CodeTypeMemberCard30, model.RedeemCodeActivityTypeStore)
-				//if err != nil {
-				//	logger.Error("code send to user err:", err)
-				//}
 			}
 
 			model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)
 		}
-
+		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
-		if record.UserCouponId > 0 {
+		if err != nil {
-			_, err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
+			logger.Error("update user open member record state:err", err)
-				SetState(2).SetUseTime(utils.Now()).UpdateNum()
-			if err != nil {
-				logger.Error("update user coupon state err:", err)
-			}
 		}
-
 		fmt.Println("notify.TotalFee:", notifyInfo.TotalFee)
 		fmt.Println("notify.OutTradeNo:", notifyInfo.OutTradeNo)
 
@@ -555,12 +561,13 @@ func PushWXPayNotice(c *gin.Context) {
 			logger.Error("err:", err)
 			return
 		}
+		if record.State == 2 {
+			ret.ReturnCode = "SUCCESS"
+			RespBodyXML(c, ret)
+			return
+		}
 
-		//configInfo, err := model.PayConfigInfo()
+		//if record.State != 2 {
-		//if err != nil {
-		//	logger.Error("err:", err)
-		//	return
-		//}
 		user := model.GetUserByUid(record.Uid)
 		if user == nil {
 			logger.Error("user nil")
@@ -585,13 +592,19 @@ func PushWXPayNotice(c *gin.Context) {
 		fundRecord.FundType = model.FundTypeMemberDeposit
 		fundRecord.Remark = remark
 
-		num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetDeposit(memberConfig.MemberDeposit).UpdateNum()
+		num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().
+			SetDeposit(memberConfig.MemberDeposit).UpdateNum()
 		if err != nil {
 			logger.Error("update deposit err:", err)
 		}
 		if num == 0 {
 			logger.Error("update deposit num is 0")
 		}
+		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
+		if err != nil {
+			logger.Error("update user open member record state:err", err)
+		}
+		//}
 	} else if notifyInfo.Attach == wxpay.WxPayBuyGoods {
 		_, err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(notifyInfo.OutTradeNo).GetUpdater().
 			SetPayTime(time.Now()).
@@ -636,11 +649,17 @@ func PushWXPayNotice(c *gin.Context) {
 		if err != nil {
 			logger.Error("err:", err)
 		}
+		if record.State == 2 {
+			ret.ReturnCode = "SUCCESS"
+			RespBodyXML(c, ret)
+			return
+		}
+
 		fmt.Println("UpgradeMember:", record.Uid)
 		var user model.User
 		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
 		if err != nil {
-			logger.Error("err:", err)
+			logger.Error("user err:", err)
 			return
 		}
 		memberConfig, err := model.GetMemberConfig(record.MemberLevel)
@@ -648,6 +667,20 @@ func PushWXPayNotice(c *gin.Context) {
 			logger.Error("GetMemberConfig err:", err)
 			return
 		}
+		var fundRecordRecord model.FundRecord
+		err = model.NewFundRecordQuerySet(model.DB).UidEq(record.Uid).FundTypeEq(model.FundTypeMemberFee).
+			CreatedAtGte(time.Now().Add(-10 * time.Minute)).One(&fundRecordRecord)
+		if err == nil && fundRecordRecord.OutTradeNo != "" {
+			var userOpenMemberRecord model.UserOpenMemberRecord
+			err := model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(fundRecordRecord.OutTradeNo).One(&userOpenMemberRecord)
+			if err != nil {
+				logger.Error("user open member record err:", err)
+				return
+			}
+			if userOpenMemberRecord.CreatedAt.After(record.CreatedAt) {
+				record.MemberExpire = record.MemberExpire.AddDate(1, 0, 0)
+			}
+		}
 
 		_, err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetMemberLevel(record.MemberLevel).
 			SetMemberExpire(record.MemberExpire).SetDeposit(memberConfig.MemberDeposit).UpdateNum()
@@ -673,6 +706,17 @@ func PushWXPayNotice(c *gin.Context) {
 
 		model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)
 
+		if record.UserCouponId > 0 {
+			_, err = model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).GetUpdater().
+				SetState(2).SetUseTime(utils.Now()).UpdateNum()
+			if err != nil {
+				logger.Error("update user coupon state err:", err)
+			}
+		}
+		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
+		if err != nil {
+			logger.Error("update user open member record state:err", err)
+		}
 		fundRecord.Uid = uint32(record.Uid)
 		fundRecord.FundType = model.FundTypeUpgradeMember
 		fundRecord.Remark = "升级会员"
@@ -683,6 +727,11 @@ func PushWXPayNotice(c *gin.Context) {
 			logger.Error("err:", err)
 			return
 		}
+		if record.State == 2 {
+			ret.ReturnCode = "SUCCESS"
+			RespBodyXML(c, ret)
+			return
+		}
 		var user model.User
 		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
 		if err != nil {
@@ -696,6 +745,10 @@ func PushWXPayNotice(c *gin.Context) {
 			logger.Error("err:", err)
 			return
 		}
+		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
+		if err != nil {
+			logger.Error("update user open member record state:err", err)
+		}
 		fundRecord.Uid = uint32(record.Uid)
 		fundRecord.FundType = model.FundTypeMemberExpireDelay
 		fundRecord.Remark = "会员过期滞纳金"
@@ -705,6 +758,11 @@ func PushWXPayNotice(c *gin.Context) {
 		if err != nil {
 			logger.Error("err:", err)
 		}
+		if record.State == 2 {
+			ret.ReturnCode = "SUCCESS"
+			RespBodyXML(c, ret)
+			return
+		}
 		fmt.Println("UpgradeMember:", record.Uid)
 		//var user model.User
 		//err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
@@ -741,7 +799,10 @@ func PushWXPayNotice(c *gin.Context) {
 				logger.Error("deliver task sub add err:", err)
 			}
 		}
-
+		_, err = model.NewUserOpenMemberRecordQuerySet(model.DB).IDEq(record.ID).GetUpdater().SetState(2).UpdateNum()
+		if err != nil {
+			logger.Error("update user open member record state:err", err)
+		}
 		fundRecord.Uid = uint32(record.Uid)
 		fundRecord.FundType = model.FundTypeExpressFee
 		fundRecord.Remark = "共享卡收回卡快递费"

controller/user.go

@@ -254,7 +254,8 @@ func OpenMember(c *gin.Context) {
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
-	if req.UserCouponId != 0 {
+
+	if user.IsMember() && req.UserCouponId != 0 {
 		var coupon model.UserCoupon
 		err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&coupon)
 		if err != nil {
@@ -266,6 +267,27 @@ func OpenMember(c *gin.Context) {
 		if coupon.Uid == uc.Uid && coupon.MemberLevel == req.MemberLevel &&
 			coupon.ActivityId == 1 && coupon.State == 1 {
 			totalFee -= coupon.Value
+
+			go func() {
+				action := 0
+				if coupon.MemberLevel == 2 {
+					action = model.UserRenewalLogActionUseGold
+				} else if coupon.MemberLevel == 4 {
+					action = model.UserRenewalLogActionUsePlatinum
+				} else if coupon.MemberLevel == 5 {
+					action = model.UserRenewalLogActionUseBlackGold
+				}
+				renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
+				userLog := &model.UserRenewalLog{
+					Uid:          uc.Uid,
+					Action:       uint32(action),
+					MemberExpire: user.MemberExpire,
+					Type:         1,
+					RenewalNum:   renewalLog.RenewalNum + 1,
+					Serial:       uint32(user.MemberExpire.Unix()),
+				}
+				_ = userLog.Add()
+			}()
 		} else {
 			req.UserCouponId = 0
 		}
@@ -304,7 +326,8 @@ func OpenMember(c *gin.Context) {
 
 func UpgradeMember(c *gin.Context) {
 	req := struct {
-		MemberLevel uint32 `json:"member_level"` // 昵称
+		MemberLevel  uint32 `json:"member_level"` // 昵称
+		UserCouponId uint32 `json:"user_coupon_id"`
 	}{}
 	if c.ShouldBindJSON(&req) != nil {
 		logger.Error("parameter err")
@@ -396,6 +419,45 @@ func UpgradeMember(c *gin.Context) {
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
+
+	if user.IsMember() && req.UserCouponId != 0 {
+		var coupon model.UserCoupon
+		err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&coupon)
+		if err != nil {
+			logger.Error("coupon err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+
+		if coupon.Uid == uc.Uid && coupon.MemberLevel == req.MemberLevel &&
+			coupon.ActivityId == 1 && coupon.State == 1 && coupon.ActiveEnd.After(time.Now()) {
+			totalFee -= int64(coupon.Value)
+
+			go func() {
+				action := 0
+				if coupon.MemberLevel == 2 {
+					action = model.UserRenewalLogActionUseGold
+				} else if coupon.MemberLevel == 4 {
+					action = model.UserRenewalLogActionUsePlatinum
+				} else if coupon.MemberLevel == 5 {
+					action = model.UserRenewalLogActionUseBlackGold
+				}
+				renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
+				userLog := &model.UserRenewalLog{
+					Uid:          uc.Uid,
+					Action:       uint32(action),
+					MemberExpire: user.MemberExpire,
+					Type:         2,
+					RenewalNum:   renewalLog.RenewalNum + 1,
+					Serial:       uint32(user.MemberExpire.Unix()),
+				}
+				_ = userLog.Add()
+			}()
+		} else {
+			req.UserCouponId = 0
+		}
+	}
+
 	//webPay, err := wxpay.WebPay(uid, totalFee, user.WxOpenID, "N", wxpay.WxPayMember)
 	//if err != nil {
 	//	logger.Error(errors.New("WebPay err"))
@@ -406,7 +468,8 @@ func UpgradeMember(c *gin.Context) {
 	memberExpire := time.Now().AddDate(1*int(memberYare), 0, count*30)
 	orderSn := model.GetOrderSn()
 	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn,
-		MemberLevel: req.MemberLevel, OrderType: 9, MemberExpire: memberExpire}.Insert()
+		MemberLevel: req.MemberLevel, OrderType: 9, MemberExpire: memberExpire,
+		UserCouponId: req.UserCouponId}.Insert()
 	if err != nil {
 		logger.Error(errors.New("WebPay err"))
 		RespJson(c, status.InternalServerError, nil)
@@ -431,7 +494,8 @@ func UpgradeMember(c *gin.Context) {
 
 func UpgradeMemberInfo(c *gin.Context) {
 	req := struct {
-		MemberLevel uint32 `json:"member_level"` // 昵称
+		MemberLevel  uint32 `json:"member_level"` // 昵称
+		UserCouponId uint32 `json:"user_coupon_id"`
 	}{}
 	if c.ShouldBindJSON(&req) != nil {
 		logger.Error("parameter err")
@@ -519,6 +583,26 @@ func UpgradeMemberInfo(c *gin.Context) {
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
+	//fmt.Println("MemberLevel:", req.MemberLevel)
+	//fmt.Println("UserCouponId:", req.UserCouponId)
+	//fmt.Println("totalFee:", totalFee)
+	var coupon model.UserCoupon
+	if user.IsMember() && req.UserCouponId != 0 {
+		err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&coupon)
+		if err != nil {
+			logger.Error("coupon err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+		//fmt.Println("coupon:", coupon)
+		if coupon.Uid == uc.Uid && coupon.MemberLevel == req.MemberLevel &&
+			coupon.ActivityType == 1 && coupon.State == 1 && coupon.ActiveEnd.After(time.Now()) {
+			totalFee -= int64(coupon.Value)
+			//fmt.Println("Value:", coupon.Value)
+		} else {
+			req.UserCouponId = 0
+		}
+	}
 
 	RespOK(c, map[string]interface{}{
 		"deduction_fee":    deductionFee,   // 会员抵扣费
@@ -526,6 +610,7 @@ func UpgradeMemberInfo(c *gin.Context) {
 		"member_mend_fee":  memberMendFee,  // 会员补费
 		"deposit_mend_fee": depositMendFee, // 补押金
 		"total_fee":        totalFee,       // 总费用
+		"coupon":           coupon.Value,
 	})
 }
 

model/analyse.go

@@ -1,8 +1,59 @@
 package model
 
+import (
+	"github.com/codinl/go-logger"
+	"time"
+)
+
+//go:generate goqueryset -in analyse.go
+
 type Statistic struct {
 	Model
 
 	Count uint32 `json:"count"`             // 计数
 	Type  uint32 `json:"type" gorm:"index"` // 类型:1-
+
+}
+
+const (
+	UserRenewalLogActionPop           = 1 // 弹窗
+	UserRenewalLogActionEnterActivity = 2 // 进入活动
+	UserRenewalLogActionPickGold      = 3 // 领取黄金会员
+	UserRenewalLogActionPickPlatinum  = 4 // 领取白金会员
+	UserRenewalLogActionPickBlackGold = 5 // 领取黑金会员
+	UserRenewalLogActionUseGold       = 6 // 使用黄金会员
+	UserRenewalLogActionUsePlatinum   = 7 // 使用白金会员
+	UserRenewalLogActionUseBlackGold  = 8 // 使用黑金会员
+)
+
+// gen:qs
+type UserRenewalLog struct {
+	Model
+
+	Uid          uint32    `json:"uid"`
+	Action       uint32    `json:"action"`
+	MemberExpire time.Time `json:"member_expire"`
+	Type         uint32    `json:"type"` // 类型:1-续费 2-升级
+	RenewalNum   uint32    `json:"renewal_num"`
+	Serial       uint32    `json:"serial"`
+	// user_renewal_log
+}
+
+func (l *UserRenewalLog) Add() error {
+	err := DB.Create(l).Error
+	if err != nil {
+		logger.Error("user log add err:", err)
+		return err
+	}
+	return nil
+}
+
+func GetActionUserRenewalLog(uid, action uint32) (UserRenewalLog, error) {
+	var userRenewalLog UserRenewalLog
+	err := NewUserRenewalLogQuerySet(DB).UidEq(uid).ActionEq(action).OrderDescByID().Limit(1).One(&userRenewalLog)
+	if err != nil && err != RecordNotFound {
+		logger.Error("user renewal log err:", err)
+		return userRenewalLog, err
+	}
+	return userRenewalLog, nil
 }

model/autogenerated_analyse.go

@@ -0,0 +1,901 @@
+// Code generated by go-queryset. DO NOT EDIT.
+package model
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/jinzhu/gorm"
+)
+
+// ===== BEGIN of all query sets
+
+// ===== BEGIN of query set UserRenewalLogQuerySet
+
+// UserRenewalLogQuerySet is an queryset type for UserRenewalLog
+type UserRenewalLogQuerySet struct {
+	db *gorm.DB
+}
+
+// NewUserRenewalLogQuerySet constructs new UserRenewalLogQuerySet
+func NewUserRenewalLogQuerySet(db *gorm.DB) UserRenewalLogQuerySet {
+	return UserRenewalLogQuerySet{
+		db: db.Model(&UserRenewalLog{}),
+	}
+}
+
+func (qs UserRenewalLogQuerySet) w(db *gorm.DB) UserRenewalLogQuerySet {
+	return NewUserRenewalLogQuerySet(db)
+}
+
+func (qs UserRenewalLogQuerySet) Select(fields ...UserRenewalLogDBSchemaField) UserRenewalLogQuerySet {
+	names := []string{}
+	for _, f := range fields {
+		names = append(names, f.String())
+	}
+
+	return qs.w(qs.db.Select(strings.Join(names, ",")))
+}
+
+// Create is an autogenerated method
+// nolint: dupl
+func (o *UserRenewalLog) Create(db *gorm.DB) error {
+	return db.Create(o).Error
+}
+
+// Delete is an autogenerated method
+// nolint: dupl
+func (o *UserRenewalLog) Delete(db *gorm.DB) error {
+	return db.Delete(o).Error
+}
+
+// ActionEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionEq(action uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("action = ?", action))
+}
+
+// ActionGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionGt(action uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("action > ?", action))
+}
+
+// ActionGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionGte(action uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("action >= ?", action))
+}
+
+// ActionIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionIn(action ...uint32) UserRenewalLogQuerySet {
+	if len(action) == 0 {
+		qs.db.AddError(errors.New("must at least pass one action in ActionIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("action IN (?)", action))
+}
+
+// ActionLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionLt(action uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("action < ?", action))
+}
+
+// ActionLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionLte(action uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("action <= ?", action))
+}
+
+// ActionNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionNe(action uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("action != ?", action))
+}
+
+// ActionNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) ActionNotIn(action ...uint32) UserRenewalLogQuerySet {
+	if len(action) == 0 {
+		qs.db.AddError(errors.New("must at least pass one action in ActionNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("action NOT IN (?)", action))
+}
+
+// All is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) All(ret *[]UserRenewalLog) error {
+	return qs.db.Find(ret).Error
+}
+
+// Count is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) Count() (int, error) {
+	var count int
+	err := qs.db.Count(&count).Error
+	return count, err
+}
+
+// CreatedAtEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) CreatedAtEq(createdAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("created_at = ?", createdAt))
+}
+
+// CreatedAtGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) CreatedAtGt(createdAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("created_at > ?", createdAt))
+}
+
+// CreatedAtGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) CreatedAtGte(createdAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("created_at >= ?", createdAt))
+}
+
+// CreatedAtLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) CreatedAtLt(createdAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("created_at < ?", createdAt))
+}
+
+// CreatedAtLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) CreatedAtLte(createdAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("created_at <= ?", createdAt))
+}
+
+// CreatedAtNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) CreatedAtNe(createdAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("created_at != ?", createdAt))
+}
+
+// Delete is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) Delete() error {
+	return qs.db.Delete(UserRenewalLog{}).Error
+}
+
+// DeleteNum is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeleteNum() (int64, error) {
+	db := qs.db.Delete(UserRenewalLog{})
+	return db.RowsAffected, db.Error
+}
+
+// DeleteNumUnscoped is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeleteNumUnscoped() (int64, error) {
+	db := qs.db.Unscoped().Delete(UserRenewalLog{})
+	return db.RowsAffected, db.Error
+}
+
+// DeletedAtEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtEq(deletedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
+}
+
+// DeletedAtGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtGt(deletedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
+}
+
+// DeletedAtGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtGte(deletedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
+}
+
+// DeletedAtIsNotNull is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtIsNotNull() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
+}
+
+// DeletedAtIsNull is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtIsNull() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at IS NULL"))
+}
+
+// DeletedAtLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtLt(deletedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
+}
+
+// DeletedAtLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtLte(deletedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
+}
+
+// DeletedAtNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) DeletedAtNe(deletedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
+}
+
+// GetDB is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) GetDB() *gorm.DB {
+	return qs.db
+}
+
+// GetUpdater is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) GetUpdater() UserRenewalLogUpdater {
+	return NewUserRenewalLogUpdater(qs.db)
+}
+
+// IDEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDEq(ID uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("id = ?", ID))
+}
+
+// IDGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDGt(ID uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("id > ?", ID))
+}
+
+// IDGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDGte(ID uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("id >= ?", ID))
+}
+
+// IDIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDIn(ID ...uint32) UserRenewalLogQuerySet {
+	if len(ID) == 0 {
+		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("id IN (?)", ID))
+}
+
+// IDLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDLt(ID uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("id < ?", ID))
+}
+
+// IDLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDLte(ID uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("id <= ?", ID))
+}
+
+// IDNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDNe(ID uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("id != ?", ID))
+}
+
+// IDNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) IDNotIn(ID ...uint32) UserRenewalLogQuerySet {
+	if len(ID) == 0 {
+		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("id NOT IN (?)", ID))
+}
+
+// Limit is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) Limit(limit int) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Limit(limit))
+}
+
+// MemberExpireEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) MemberExpireEq(memberExpire time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("member_expire = ?", memberExpire))
+}
+
+// MemberExpireGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) MemberExpireGt(memberExpire time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("member_expire > ?", memberExpire))
+}
+
+// MemberExpireGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) MemberExpireGte(memberExpire time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("member_expire >= ?", memberExpire))
+}
+
+// MemberExpireLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) MemberExpireLt(memberExpire time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("member_expire < ?", memberExpire))
+}
+
+// MemberExpireLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) MemberExpireLte(memberExpire time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("member_expire <= ?", memberExpire))
+}
+
+// MemberExpireNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) MemberExpireNe(memberExpire time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("member_expire != ?", memberExpire))
+}
+
+// Offset is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) Offset(offset int) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Offset(offset))
+}
+
+// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
+// if nothing was fetched
+func (qs UserRenewalLogQuerySet) One(ret *UserRenewalLog) error {
+	return qs.db.First(ret).Error
+}
+
+// OrderAscByAction is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByAction() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("action ASC"))
+}
+
+// OrderAscByCreatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByCreatedAt() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("created_at ASC"))
+}
+
+// OrderAscByDeletedAt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByDeletedAt() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("deleted_at ASC"))
+}
+
+// OrderAscByID is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByID() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("id ASC"))
+}
+
+// OrderAscByMemberExpire is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByMemberExpire() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("member_expire ASC"))
+}
+
+// OrderAscByRenewalNum is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByRenewalNum() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("renewal_num ASC"))
+}
+
+// OrderAscBySerial is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscBySerial() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("serial ASC"))
+}
+
+// OrderAscByType is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByType() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("type ASC"))
+}
+
+// OrderAscByUid is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByUid() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("uid ASC"))
+}
+
+// OrderAscByUpdatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderAscByUpdatedAt() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("updated_at ASC"))
+}
+
+// OrderDescByAction is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByAction() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("action DESC"))
+}
+
+// OrderDescByCreatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByCreatedAt() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("created_at DESC"))
+}
+
+// OrderDescByDeletedAt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByDeletedAt() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("deleted_at DESC"))
+}
+
+// OrderDescByID is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByID() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("id DESC"))
+}
+
+// OrderDescByMemberExpire is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByMemberExpire() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("member_expire DESC"))
+}
+
+// OrderDescByRenewalNum is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByRenewalNum() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("renewal_num DESC"))
+}
+
+// OrderDescBySerial is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescBySerial() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("serial DESC"))
+}
+
+// OrderDescByType is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByType() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("type DESC"))
+}
+
+// OrderDescByUid is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByUid() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("uid DESC"))
+}
+
+// OrderDescByUpdatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) OrderDescByUpdatedAt() UserRenewalLogQuerySet {
+	return qs.w(qs.db.Order("updated_at DESC"))
+}
+
+// RenewalNumEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumEq(renewalNum uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("renewal_num = ?", renewalNum))
+}
+
+// RenewalNumGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumGt(renewalNum uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("renewal_num > ?", renewalNum))
+}
+
+// RenewalNumGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumGte(renewalNum uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("renewal_num >= ?", renewalNum))
+}
+
+// RenewalNumIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumIn(renewalNum ...uint32) UserRenewalLogQuerySet {
+	if len(renewalNum) == 0 {
+		qs.db.AddError(errors.New("must at least pass one renewalNum in RenewalNumIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("renewal_num IN (?)", renewalNum))
+}
+
+// RenewalNumLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumLt(renewalNum uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("renewal_num < ?", renewalNum))
+}
+
+// RenewalNumLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumLte(renewalNum uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("renewal_num <= ?", renewalNum))
+}
+
+// RenewalNumNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumNe(renewalNum uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("renewal_num != ?", renewalNum))
+}
+
+// RenewalNumNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) RenewalNumNotIn(renewalNum ...uint32) UserRenewalLogQuerySet {
+	if len(renewalNum) == 0 {
+		qs.db.AddError(errors.New("must at least pass one renewalNum in RenewalNumNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("renewal_num NOT IN (?)", renewalNum))
+}
+
+// SerialEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialEq(serial uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("serial = ?", serial))
+}
+
+// SerialGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialGt(serial uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("serial > ?", serial))
+}
+
+// SerialGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialGte(serial uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("serial >= ?", serial))
+}
+
+// SerialIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialIn(serial ...uint32) UserRenewalLogQuerySet {
+	if len(serial) == 0 {
+		qs.db.AddError(errors.New("must at least pass one serial in SerialIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("serial IN (?)", serial))
+}
+
+// SerialLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialLt(serial uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("serial < ?", serial))
+}
+
+// SerialLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialLte(serial uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("serial <= ?", serial))
+}
+
+// SerialNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialNe(serial uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("serial != ?", serial))
+}
+
+// SerialNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) SerialNotIn(serial ...uint32) UserRenewalLogQuerySet {
+	if len(serial) == 0 {
+		qs.db.AddError(errors.New("must at least pass one serial in SerialNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("serial NOT IN (?)", serial))
+}
+
+// TypeEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeEq(typeValue uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("type = ?", typeValue))
+}
+
+// TypeGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeGt(typeValue uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("type > ?", typeValue))
+}
+
+// TypeGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeGte(typeValue uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("type >= ?", typeValue))
+}
+
+// TypeIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeIn(typeValue ...uint32) UserRenewalLogQuerySet {
+	if len(typeValue) == 0 {
+		qs.db.AddError(errors.New("must at least pass one typeValue in TypeIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("type IN (?)", typeValue))
+}
+
+// TypeLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeLt(typeValue uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("type < ?", typeValue))
+}
+
+// TypeLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeLte(typeValue uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("type <= ?", typeValue))
+}
+
+// TypeNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeNe(typeValue uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("type != ?", typeValue))
+}
+
+// TypeNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) TypeNotIn(typeValue ...uint32) UserRenewalLogQuerySet {
+	if len(typeValue) == 0 {
+		qs.db.AddError(errors.New("must at least pass one typeValue in TypeNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("type NOT IN (?)", typeValue))
+}
+
+// UidEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidEq(uid uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("uid = ?", uid))
+}
+
+// UidGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidGt(uid uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("uid > ?", uid))
+}
+
+// UidGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidGte(uid uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("uid >= ?", uid))
+}
+
+// UidIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidIn(uid ...uint32) UserRenewalLogQuerySet {
+	if len(uid) == 0 {
+		qs.db.AddError(errors.New("must at least pass one uid in UidIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("uid IN (?)", uid))
+}
+
+// UidLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidLt(uid uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("uid < ?", uid))
+}
+
+// UidLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidLte(uid uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("uid <= ?", uid))
+}
+
+// UidNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidNe(uid uint32) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("uid != ?", uid))
+}
+
+// UidNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UidNotIn(uid ...uint32) UserRenewalLogQuerySet {
+	if len(uid) == 0 {
+		qs.db.AddError(errors.New("must at least pass one uid in UidNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("uid NOT IN (?)", uid))
+}
+
+// UpdatedAtEq is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UpdatedAtEq(updatedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
+}
+
+// UpdatedAtGt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UpdatedAtGt(updatedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
+}
+
+// UpdatedAtGte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UpdatedAtGte(updatedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
+}
+
+// UpdatedAtLt is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UpdatedAtLt(updatedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
+}
+
+// UpdatedAtLte is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UpdatedAtLte(updatedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
+}
+
+// UpdatedAtNe is an autogenerated method
+// nolint: dupl
+func (qs UserRenewalLogQuerySet) UpdatedAtNe(updatedAt time.Time) UserRenewalLogQuerySet {
+	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
+}
+
+// SetAction is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetAction(action uint32) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.Action)] = action
+	return u
+}
+
+// SetCreatedAt is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetCreatedAt(createdAt time.Time) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.CreatedAt)] = createdAt
+	return u
+}
+
+// SetDeletedAt is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetDeletedAt(deletedAt *time.Time) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.DeletedAt)] = deletedAt
+	return u
+}
+
+// SetID is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetID(ID uint32) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.ID)] = ID
+	return u
+}
+
+// SetMemberExpire is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetMemberExpire(memberExpire time.Time) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.MemberExpire)] = memberExpire
+	return u
+}
+
+// SetRenewalNum is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetRenewalNum(renewalNum uint32) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.RenewalNum)] = renewalNum
+	return u
+}
+
+// SetSerial is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetSerial(serial uint32) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.Serial)] = serial
+	return u
+}
+
+// SetType is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetType(typeValue uint32) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.Type)] = typeValue
+	return u
+}
+
+// SetUid is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetUid(uid uint32) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.Uid)] = uid
+	return u
+}
+
+// SetUpdatedAt is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) SetUpdatedAt(updatedAt time.Time) UserRenewalLogUpdater {
+	u.fields[string(UserRenewalLogDBSchema.UpdatedAt)] = updatedAt
+	return u
+}
+
+// Update is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) Update() error {
+	return u.db.Updates(u.fields).Error
+}
+
+// UpdateNum is an autogenerated method
+// nolint: dupl
+func (u UserRenewalLogUpdater) UpdateNum() (int64, error) {
+	db := u.db.Updates(u.fields)
+	return db.RowsAffected, db.Error
+}
+
+// ===== END of query set UserRenewalLogQuerySet
+
+// ===== BEGIN of UserRenewalLog modifiers
+
+// UserRenewalLogDBSchemaField describes database schema field. It requires for method 'Update'
+type UserRenewalLogDBSchemaField string
+
+// String method returns string representation of field.
+// nolint: dupl
+func (f UserRenewalLogDBSchemaField) String() string {
+	return string(f)
+}
+
+// UserRenewalLogDBSchema stores db field names of UserRenewalLog
+var UserRenewalLogDBSchema = struct {
+	ID           UserRenewalLogDBSchemaField
+	CreatedAt    UserRenewalLogDBSchemaField
+	UpdatedAt    UserRenewalLogDBSchemaField
+	DeletedAt    UserRenewalLogDBSchemaField
+	Uid          UserRenewalLogDBSchemaField
+	Action       UserRenewalLogDBSchemaField
+	MemberExpire UserRenewalLogDBSchemaField
+	Type         UserRenewalLogDBSchemaField
+	RenewalNum   UserRenewalLogDBSchemaField
+	Serial       UserRenewalLogDBSchemaField
+}{
+
+	ID:           UserRenewalLogDBSchemaField("id"),
+	CreatedAt:    UserRenewalLogDBSchemaField("created_at"),
+	UpdatedAt:    UserRenewalLogDBSchemaField("updated_at"),
+	DeletedAt:    UserRenewalLogDBSchemaField("deleted_at"),
+	Uid:          UserRenewalLogDBSchemaField("uid"),
+	Action:       UserRenewalLogDBSchemaField("action"),
+	MemberExpire: UserRenewalLogDBSchemaField("member_expire"),
+	Type:         UserRenewalLogDBSchemaField("type"),
+	RenewalNum:   UserRenewalLogDBSchemaField("renewal_num"),
+	Serial:       UserRenewalLogDBSchemaField("serial"),
+}
+
+// Update updates UserRenewalLog fields by primary key
+// nolint: dupl
+func (o *UserRenewalLog) Update(db *gorm.DB, fields ...UserRenewalLogDBSchemaField) error {
+	dbNameToFieldName := map[string]interface{}{
+		"id":            o.ID,
+		"created_at":    o.CreatedAt,
+		"updated_at":    o.UpdatedAt,
+		"deleted_at":    o.DeletedAt,
+		"uid":           o.Uid,
+		"action":        o.Action,
+		"member_expire": o.MemberExpire,
+		"type":          o.Type,
+		"renewal_num":   o.RenewalNum,
+		"serial":        o.Serial,
+	}
+	u := map[string]interface{}{}
+	for _, f := range fields {
+		fs := f.String()
+		u[fs] = dbNameToFieldName[fs]
+	}
+	if err := db.Model(o).Updates(u).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return err
+		}
+
+		return fmt.Errorf("can't update UserRenewalLog %v fields %v: %s",
+			o, fields, err)
+	}
+
+	return nil
+}
+
+// UserRenewalLogUpdater is an UserRenewalLog updates manager
+type UserRenewalLogUpdater struct {
+	fields map[string]interface{}
+	db     *gorm.DB
+}
+
+// NewUserRenewalLogUpdater creates new UserRenewalLog updater
+// nolint: dupl
+func NewUserRenewalLogUpdater(db *gorm.DB) UserRenewalLogUpdater {
+	return UserRenewalLogUpdater{
+		fields: map[string]interface{}{},
+		db:     db.Model(&UserRenewalLog{}),
+	}
+}
+
+// ===== END of UserRenewalLog modifiers
+
+// ===== END of all query sets

model/autogenerated_coupon.go

@@ -387,6 +387,62 @@ func (qs ActivityMemberRenewalQuerySet) MemberLevelNotIn(memberLevel ...uint32)
 	return qs.w(qs.db.Where("member_level NOT IN (?)", memberLevel))
 }
 
+// MemberSerialEq is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialEq(memberSerial uint32) ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Where("member_serial = ?", memberSerial))
+}
+
+// MemberSerialGt is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialGt(memberSerial uint32) ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Where("member_serial > ?", memberSerial))
+}
+
+// MemberSerialGte is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialGte(memberSerial uint32) ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Where("member_serial >= ?", memberSerial))
+}
+
+// MemberSerialIn is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialIn(memberSerial ...uint32) ActivityMemberRenewalQuerySet {
+	if len(memberSerial) == 0 {
+		qs.db.AddError(errors.New("must at least pass one memberSerial in MemberSerialIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("member_serial IN (?)", memberSerial))
+}
+
+// MemberSerialLt is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialLt(memberSerial uint32) ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Where("member_serial < ?", memberSerial))
+}
+
+// MemberSerialLte is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialLte(memberSerial uint32) ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Where("member_serial <= ?", memberSerial))
+}
+
+// MemberSerialNe is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialNe(memberSerial uint32) ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Where("member_serial != ?", memberSerial))
+}
+
+// MemberSerialNotIn is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) MemberSerialNotIn(memberSerial ...uint32) ActivityMemberRenewalQuerySet {
+	if len(memberSerial) == 0 {
+		qs.db.AddError(errors.New("must at least pass one memberSerial in MemberSerialNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("member_serial NOT IN (?)", memberSerial))
+}
+
 // Offset is an autogenerated method
 // nolint: dupl
 func (qs ActivityMemberRenewalQuerySet) Offset(offset int) ActivityMemberRenewalQuerySet {
@@ -435,6 +491,12 @@ func (qs ActivityMemberRenewalQuerySet) OrderAscByMemberLevel() ActivityMemberRe
 	return qs.w(qs.db.Order("member_level ASC"))
 }
 
+// OrderAscByMemberSerial is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) OrderAscByMemberSerial() ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Order("member_serial ASC"))
+}
+
 // OrderAscByStartTime is an autogenerated method
 // nolint: dupl
 func (qs ActivityMemberRenewalQuerySet) OrderAscByStartTime() ActivityMemberRenewalQuerySet {
@@ -495,6 +557,12 @@ func (qs ActivityMemberRenewalQuerySet) OrderDescByMemberLevel() ActivityMemberR
 	return qs.w(qs.db.Order("member_level DESC"))
 }
 
+// OrderDescByMemberSerial is an autogenerated method
+// nolint: dupl
+func (qs ActivityMemberRenewalQuerySet) OrderDescByMemberSerial() ActivityMemberRenewalQuerySet {
+	return qs.w(qs.db.Order("member_serial DESC"))
+}
+
 // OrderDescByStartTime is an autogenerated method
 // nolint: dupl
 func (qs ActivityMemberRenewalQuerySet) OrderDescByStartTime() ActivityMemberRenewalQuerySet {
@@ -745,6 +813,13 @@ func (u ActivityMemberRenewalUpdater) SetMemberLevel(memberLevel uint32) Activit
 	return u
 }
 
+// SetMemberSerial is an autogenerated method
+// nolint: dupl
+func (u ActivityMemberRenewalUpdater) SetMemberSerial(memberSerial uint32) ActivityMemberRenewalUpdater {
+	u.fields[string(ActivityMemberRenewalDBSchema.MemberSerial)] = memberSerial
+	return u
+}
+
 // SetStartTime is an autogenerated method
 // nolint: dupl
 func (u ActivityMemberRenewalUpdater) SetStartTime(startTime time.Time) ActivityMemberRenewalUpdater {
@@ -801,44 +876,47 @@ func (f ActivityMemberRenewalDBSchemaField) String() string {
 
 // ActivityMemberRenewalDBSchema stores db field names of ActivityMemberRenewal
 var ActivityMemberRenewalDBSchema = struct {
-	ID          ActivityMemberRenewalDBSchemaField
+	ID           ActivityMemberRenewalDBSchemaField
-	CreatedAt   ActivityMemberRenewalDBSchemaField
+	CreatedAt    ActivityMemberRenewalDBSchemaField
-	UpdatedAt   ActivityMemberRenewalDBSchemaField
+	UpdatedAt    ActivityMemberRenewalDBSchemaField
-	DeletedAt   ActivityMemberRenewalDBSchemaField
+	DeletedAt    ActivityMemberRenewalDBSchemaField
-	ActivityId  ActivityMemberRenewalDBSchemaField
+	ActivityId   ActivityMemberRenewalDBSchemaField
-	Uid         ActivityMemberRenewalDBSchemaField
+	Uid          ActivityMemberRenewalDBSchemaField
-	State       ActivityMemberRenewalDBSchemaField
+	State        ActivityMemberRenewalDBSchemaField
-	StartTime   ActivityMemberRenewalDBSchemaField
+	StartTime    ActivityMemberRenewalDBSchemaField
-	IsPop       ActivityMemberRenewalDBSchemaField
+	IsPop        ActivityMemberRenewalDBSchemaField
-	MemberLevel ActivityMemberRenewalDBSchemaField
+	MemberLevel  ActivityMemberRenewalDBSchemaField
+	MemberSerial ActivityMemberRenewalDBSchemaField
 }{
 
-	ID:          ActivityMemberRenewalDBSchemaField("id"),
+	ID:           ActivityMemberRenewalDBSchemaField("id"),
-	CreatedAt:   ActivityMemberRenewalDBSchemaField("created_at"),
+	CreatedAt:    ActivityMemberRenewalDBSchemaField("created_at"),
-	UpdatedAt:   ActivityMemberRenewalDBSchemaField("updated_at"),
+	UpdatedAt:    ActivityMemberRenewalDBSchemaField("updated_at"),
-	DeletedAt:   ActivityMemberRenewalDBSchemaField("deleted_at"),
+	DeletedAt:    ActivityMemberRenewalDBSchemaField("deleted_at"),
-	ActivityId:  ActivityMemberRenewalDBSchemaField("activity_id"),
+	ActivityId:   ActivityMemberRenewalDBSchemaField("activity_id"),
-	Uid:         ActivityMemberRenewalDBSchemaField("uid"),
+	Uid:          ActivityMemberRenewalDBSchemaField("uid"),
-	State:       ActivityMemberRenewalDBSchemaField("state"),
+	State:        ActivityMemberRenewalDBSchemaField("state"),
-	StartTime:   ActivityMemberRenewalDBSchemaField("start_time"),
+	StartTime:    ActivityMemberRenewalDBSchemaField("start_time"),
-	IsPop:       ActivityMemberRenewalDBSchemaField("is_pop"),
+	IsPop:        ActivityMemberRenewalDBSchemaField("is_pop"),
-	MemberLevel: ActivityMemberRenewalDBSchemaField("member_level"),
+	MemberLevel:  ActivityMemberRenewalDBSchemaField("member_level"),
+	MemberSerial: ActivityMemberRenewalDBSchemaField("member_serial"),
 }
 
 // Update updates ActivityMemberRenewal fields by primary key
 // nolint: dupl
 func (o *ActivityMemberRenewal) Update(db *gorm.DB, fields ...ActivityMemberRenewalDBSchemaField) error {
 	dbNameToFieldName := map[string]interface{}{
-		"id":           o.ID,
+		"id":            o.ID,
-		"created_at":   o.CreatedAt,
+		"created_at":    o.CreatedAt,
-		"updated_at":   o.UpdatedAt,
+		"updated_at":    o.UpdatedAt,
-		"deleted_at":   o.DeletedAt,
+		"deleted_at":    o.DeletedAt,
-		"activity_id":  o.ActivityId,
+		"activity_id":   o.ActivityId,
-		"uid":          o.Uid,
+		"uid":           o.Uid,
-		"state":        o.State,
+		"state":         o.State,
-		"start_time":   o.StartTime,
+		"start_time":    o.StartTime,
-		"is_pop":       o.IsPop,
+		"is_pop":        o.IsPop,
-		"member_level": o.MemberLevel,
+		"member_level":  o.MemberLevel,
+		"member_serial": o.MemberSerial,
 	}
 	u := map[string]interface{}{}
 	for _, f := range fields {

model/autogenerated_user.go

@@ -4905,6 +4905,12 @@ func (qs OperationLogQuerySet) OrderAscByStoreName() OperationLogQuerySet {
 	return qs.w(qs.db.Order("store_name ASC"))
 }
 
+// OrderAscBySysUid is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) OrderAscBySysUid() OperationLogQuerySet {
+	return qs.w(qs.db.Order("sys_uid ASC"))
+}
+
 // OrderAscByUid is an autogenerated method
 // nolint: dupl
 func (qs OperationLogQuerySet) OrderAscByUid() OperationLogQuerySet {
@@ -5001,6 +5007,12 @@ func (qs OperationLogQuerySet) OrderDescByStoreName() OperationLogQuerySet {
 	return qs.w(qs.db.Order("store_name DESC"))
 }
 
+// OrderDescBySysUid is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) OrderDescBySysUid() OperationLogQuerySet {
+	return qs.w(qs.db.Order("sys_uid DESC"))
+}
+
 // OrderDescByUid is an autogenerated method
 // nolint: dupl
 func (qs OperationLogQuerySet) OrderDescByUid() OperationLogQuerySet {
@@ -5273,6 +5285,62 @@ func (qs OperationLogQuerySet) StoreNameNotlike(storeName string) OperationLogQu
 	return qs.w(qs.db.Where("store_name NOT LIKE ?", storeName))
 }
 
+// SysUidEq is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidEq(sysUid uint32) OperationLogQuerySet {
+	return qs.w(qs.db.Where("sys_uid = ?", sysUid))
+}
+
+// SysUidGt is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidGt(sysUid uint32) OperationLogQuerySet {
+	return qs.w(qs.db.Where("sys_uid > ?", sysUid))
+}
+
+// SysUidGte is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidGte(sysUid uint32) OperationLogQuerySet {
+	return qs.w(qs.db.Where("sys_uid >= ?", sysUid))
+}
+
+// SysUidIn is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidIn(sysUid ...uint32) OperationLogQuerySet {
+	if len(sysUid) == 0 {
+		qs.db.AddError(errors.New("must at least pass one sysUid in SysUidIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("sys_uid IN (?)", sysUid))
+}
+
+// SysUidLt is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidLt(sysUid uint32) OperationLogQuerySet {
+	return qs.w(qs.db.Where("sys_uid < ?", sysUid))
+}
+
+// SysUidLte is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidLte(sysUid uint32) OperationLogQuerySet {
+	return qs.w(qs.db.Where("sys_uid <= ?", sysUid))
+}
+
+// SysUidNe is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidNe(sysUid uint32) OperationLogQuerySet {
+	return qs.w(qs.db.Where("sys_uid != ?", sysUid))
+}
+
+// SysUidNotIn is an autogenerated method
+// nolint: dupl
+func (qs OperationLogQuerySet) SysUidNotIn(sysUid ...uint32) OperationLogQuerySet {
+	if len(sysUid) == 0 {
+		qs.db.AddError(errors.New("must at least pass one sysUid in SysUidNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("sys_uid NOT IN (?)", sysUid))
+}
+
 // UidEq is an autogenerated method
 // nolint: dupl
 func (qs OperationLogQuerySet) UidEq(uid uint32) OperationLogQuerySet {
@@ -5463,6 +5531,13 @@ func (u OperationLogUpdater) SetStoreName(storeName string) OperationLogUpdater
 	return u
 }
 
+// SetSysUid is an autogenerated method
+// nolint: dupl
+func (u OperationLogUpdater) SetSysUid(sysUid uint32) OperationLogUpdater {
+	u.fields[string(OperationLogDBSchema.SysUid)] = sysUid
+	return u
+}
+
 // SetUid is an autogenerated method
 // nolint: dupl
 func (u OperationLogUpdater) SetUid(uid uint32) OperationLogUpdater {
@@ -5510,6 +5585,7 @@ var OperationLogDBSchema = struct {
 	UpdatedAt             OperationLogDBSchemaField
 	DeletedAt             OperationLogDBSchemaField
 	Uid                   OperationLogDBSchemaField
+	SysUid                OperationLogDBSchemaField
 	Description           OperationLogDBSchemaField
 	OperationType         OperationLogDBSchemaField
 	CorrelationId         OperationLogDBSchemaField
@@ -5528,6 +5604,7 @@ var OperationLogDBSchema = struct {
 	UpdatedAt:             OperationLogDBSchemaField("updated_at"),
 	DeletedAt:             OperationLogDBSchemaField("deleted_at"),
 	Uid:                   OperationLogDBSchemaField("uid"),
+	SysUid:                OperationLogDBSchemaField("sys_uid"),
 	Description:           OperationLogDBSchemaField("description"),
 	OperationType:         OperationLogDBSchemaField("operation_type"),
 	CorrelationId:         OperationLogDBSchemaField("correlation_id"),
@@ -5550,6 +5627,7 @@ func (o *OperationLog) Update(db *gorm.DB, fields ...OperationLogDBSchemaField)
 		"updated_at":              o.UpdatedAt,
 		"deleted_at":              o.DeletedAt,
 		"uid":                     o.Uid,
+		"sys_uid":                 o.SysUid,
 		"description":             o.Description,
 		"operation_type":          o.OperationType,
 		"correlation_id":          o.CorrelationId,
@@ -6255,6 +6333,12 @@ func (qs UserInviteQuerySet) OrderDescByUserType() UserInviteQuerySet {
 	return qs.w(qs.db.Order("user_type DESC"))
 }
 
+// PreloadToUser is an autogenerated method
+// nolint: dupl
+func (qs UserInviteQuerySet) PreloadToUser() UserInviteQuerySet {
+	return qs.w(qs.db.Preload("ToUser"))
+}
+
 // StoreIdEq is an autogenerated method
 // nolint: dupl
 func (qs UserInviteQuerySet) StoreIdEq(storeId uint64) UserInviteQuerySet {
@@ -6423,6 +6507,18 @@ func (qs UserInviteQuerySet) ToUidNotIn(toUid ...uint32) UserInviteQuerySet {
 	return qs.w(qs.db.Where("to_uid NOT IN (?)", toUid))
 }
 
+// ToUserIsNotNull is an autogenerated method
+// nolint: dupl
+func (qs UserInviteQuerySet) ToUserIsNotNull() UserInviteQuerySet {
+	return qs.w(qs.db.Where("to_user IS NOT NULL"))
+}
+
+// ToUserIsNull is an autogenerated method
+// nolint: dupl
+func (qs UserInviteQuerySet) ToUserIsNull() UserInviteQuerySet {
+	return qs.w(qs.db.Where("to_user IS NULL"))
+}
+
 // UpdatedAtEq is an autogenerated method
 // nolint: dupl
 func (qs UserInviteQuerySet) UpdatedAtEq(updatedAt time.Time) UserInviteQuerySet {
@@ -6647,6 +6743,7 @@ var UserInviteDBSchema = struct {
 	ToUid          UserInviteDBSchemaField
 	StoreType      UserInviteDBSchemaField
 	MemberLevel    UserInviteDBSchemaField
+	ToUser         UserInviteDBSchemaField
 }{
 
 	ID:             UserInviteDBSchemaField("id"),
@@ -6662,6 +6759,7 @@ var UserInviteDBSchema = struct {
 	ToUid:          UserInviteDBSchemaField("to_uid"),
 	StoreType:      UserInviteDBSchemaField("store_type"),
 	MemberLevel:    UserInviteDBSchemaField("member_level"),
+	ToUser:         UserInviteDBSchemaField("to_user"),
 }
 
 // Update updates UserInvite fields by primary key
@@ -6681,6 +6779,7 @@ func (o *UserInvite) Update(db *gorm.DB, fields ...UserInviteDBSchemaField) erro
 		"to_uid":           o.ToUid,
 		"store_type":       o.StoreType,
 		"member_level":     o.MemberLevel,
+		"to_user":          o.ToUser,
 	}
 	u := map[string]interface{}{}
 	for _, f := range fields {
@@ -8053,6 +8152,12 @@ func (qs UserOpenMemberRecordQuerySet) OrderAscByOrderType() UserOpenMemberRecor
 	return qs.w(qs.db.Order("order_type ASC"))
 }
 
+// OrderAscByState is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) OrderAscByState() UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Order("state ASC"))
+}
+
 // OrderAscByUid is an autogenerated method
 // nolint: dupl
 func (qs UserOpenMemberRecordQuerySet) OrderAscByUid() UserOpenMemberRecordQuerySet {
@@ -8065,6 +8170,12 @@ func (qs UserOpenMemberRecordQuerySet) OrderAscByUpdatedAt() UserOpenMemberRecor
 	return qs.w(qs.db.Order("updated_at ASC"))
 }
 
+// OrderAscByUserCouponId is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) OrderAscByUserCouponId() UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Order("user_coupon_id ASC"))
+}
+
 // OrderDescByCreatedAt is an autogenerated method
 // nolint: dupl
 func (qs UserOpenMemberRecordQuerySet) OrderDescByCreatedAt() UserOpenMemberRecordQuerySet {
@@ -8113,6 +8224,12 @@ func (qs UserOpenMemberRecordQuerySet) OrderDescByOrderType() UserOpenMemberReco
 	return qs.w(qs.db.Order("order_type DESC"))
 }
 
+// OrderDescByState is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) OrderDescByState() UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Order("state DESC"))
+}
+
 // OrderDescByUid is an autogenerated method
 // nolint: dupl
 func (qs UserOpenMemberRecordQuerySet) OrderDescByUid() UserOpenMemberRecordQuerySet {
@@ -8125,6 +8242,12 @@ func (qs UserOpenMemberRecordQuerySet) OrderDescByUpdatedAt() UserOpenMemberReco
 	return qs.w(qs.db.Order("updated_at DESC"))
 }
 
+// OrderDescByUserCouponId is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) OrderDescByUserCouponId() UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Order("user_coupon_id DESC"))
+}
+
 // OrderIdEq is an autogenerated method
 // nolint: dupl
 func (qs UserOpenMemberRecordQuerySet) OrderIdEq(orderId uint32) UserOpenMemberRecordQuerySet {
@@ -8237,6 +8360,62 @@ func (qs UserOpenMemberRecordQuerySet) OrderTypeNotIn(orderType ...uint32) UserO
 	return qs.w(qs.db.Where("order_type NOT IN (?)", orderType))
 }
 
+// StateEq is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateEq(state uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("state = ?", state))
+}
+
+// StateGt is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateGt(state uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("state > ?", state))
+}
+
+// StateGte is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateGte(state uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("state >= ?", state))
+}
+
+// StateIn is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateIn(state ...uint32) UserOpenMemberRecordQuerySet {
+	if len(state) == 0 {
+		qs.db.AddError(errors.New("must at least pass one state in StateIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("state IN (?)", state))
+}
+
+// StateLt is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateLt(state uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("state < ?", state))
+}
+
+// StateLte is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateLte(state uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("state <= ?", state))
+}
+
+// StateNe is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateNe(state uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("state != ?", state))
+}
+
+// StateNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) StateNotIn(state ...uint32) UserOpenMemberRecordQuerySet {
+	if len(state) == 0 {
+		qs.db.AddError(errors.New("must at least pass one state in StateNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("state NOT IN (?)", state))
+}
+
 // UidEq is an autogenerated method
 // nolint: dupl
 func (qs UserOpenMemberRecordQuerySet) UidEq(uid uint32) UserOpenMemberRecordQuerySet {
@@ -8329,6 +8508,62 @@ func (qs UserOpenMemberRecordQuerySet) UpdatedAtNe(updatedAt time.Time) UserOpen
 	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
 }
 
+// UserCouponIdEq is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdEq(userCouponId uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("user_coupon_id = ?", userCouponId))
+}
+
+// UserCouponIdGt is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdGt(userCouponId uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("user_coupon_id > ?", userCouponId))
+}
+
+// UserCouponIdGte is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdGte(userCouponId uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("user_coupon_id >= ?", userCouponId))
+}
+
+// UserCouponIdIn is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdIn(userCouponId ...uint32) UserOpenMemberRecordQuerySet {
+	if len(userCouponId) == 0 {
+		qs.db.AddError(errors.New("must at least pass one userCouponId in UserCouponIdIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("user_coupon_id IN (?)", userCouponId))
+}
+
+// UserCouponIdLt is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdLt(userCouponId uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("user_coupon_id < ?", userCouponId))
+}
+
+// UserCouponIdLte is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdLte(userCouponId uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("user_coupon_id <= ?", userCouponId))
+}
+
+// UserCouponIdNe is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdNe(userCouponId uint32) UserOpenMemberRecordQuerySet {
+	return qs.w(qs.db.Where("user_coupon_id != ?", userCouponId))
+}
+
+// UserCouponIdNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserOpenMemberRecordQuerySet) UserCouponIdNotIn(userCouponId ...uint32) UserOpenMemberRecordQuerySet {
+	if len(userCouponId) == 0 {
+		qs.db.AddError(errors.New("must at least pass one userCouponId in UserCouponIdNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("user_coupon_id NOT IN (?)", userCouponId))
+}
+
 // SetCreatedAt is an autogenerated method
 // nolint: dupl
 func (u UserOpenMemberRecordUpdater) SetCreatedAt(createdAt time.Time) UserOpenMemberRecordUpdater {
@@ -8385,6 +8620,13 @@ func (u UserOpenMemberRecordUpdater) SetOrderType(orderType uint32) UserOpenMemb
 	return u
 }
 
+// SetState is an autogenerated method
+// nolint: dupl
+func (u UserOpenMemberRecordUpdater) SetState(state uint32) UserOpenMemberRecordUpdater {
+	u.fields[string(UserOpenMemberRecordDBSchema.State)] = state
+	return u
+}
+
 // SetUid is an autogenerated method
 // nolint: dupl
 func (u UserOpenMemberRecordUpdater) SetUid(uid uint32) UserOpenMemberRecordUpdater {
@@ -8399,6 +8641,13 @@ func (u UserOpenMemberRecordUpdater) SetUpdatedAt(updatedAt time.Time) UserOpenM
 	return u
 }
 
+// SetUserCouponId is an autogenerated method
+// nolint: dupl
+func (u UserOpenMemberRecordUpdater) SetUserCouponId(userCouponId uint32) UserOpenMemberRecordUpdater {
+	u.fields[string(UserOpenMemberRecordDBSchema.UserCouponId)] = userCouponId
+	return u
+}
+
 // Update is an autogenerated method
 // nolint: dupl
 func (u UserOpenMemberRecordUpdater) Update() error {
@@ -8437,6 +8686,8 @@ var UserOpenMemberRecordDBSchema = struct {
 	OrderType    UserOpenMemberRecordDBSchemaField
 	MemberLevel  UserOpenMemberRecordDBSchemaField
 	MemberExpire UserOpenMemberRecordDBSchemaField
+	UserCouponId UserOpenMemberRecordDBSchemaField
+	State        UserOpenMemberRecordDBSchemaField
 }{
 
 	ID:           UserOpenMemberRecordDBSchemaField("id"),
@@ -8449,22 +8700,26 @@ var UserOpenMemberRecordDBSchema = struct {
 	OrderType:    UserOpenMemberRecordDBSchemaField("order_type"),
 	MemberLevel:  UserOpenMemberRecordDBSchemaField("member_level"),
 	MemberExpire: UserOpenMemberRecordDBSchemaField("member_expire"),
+	UserCouponId: UserOpenMemberRecordDBSchemaField("user_coupon_id"),
+	State:        UserOpenMemberRecordDBSchemaField("state"),
 }
 
 // Update updates UserOpenMemberRecord fields by primary key
 // nolint: dupl
 func (o *UserOpenMemberRecord) Update(db *gorm.DB, fields ...UserOpenMemberRecordDBSchemaField) error {
 	dbNameToFieldName := map[string]interface{}{
-		"id":            o.ID,
+		"id":             o.ID,
-		"created_at":    o.CreatedAt,
+		"created_at":     o.CreatedAt,
-		"updated_at":    o.UpdatedAt,
+		"updated_at":     o.UpdatedAt,
-		"deleted_at":    o.DeletedAt,
+		"deleted_at":     o.DeletedAt,
-		"uid":           o.Uid,
+		"uid":            o.Uid,
-		"open_no":       o.OpenNo,
+		"open_no":        o.OpenNo,
-		"order_id":      o.OrderId,
+		"order_id":       o.OrderId,
-		"order_type":    o.OrderType,
+		"order_type":     o.OrderType,
-		"member_level":  o.MemberLevel,
+		"member_level":   o.MemberLevel,
-		"member_expire": o.MemberExpire,
+		"member_expire":  o.MemberExpire,
+		"user_coupon_id": o.UserCouponId,
+		"state":          o.State,
 	}
 	u := map[string]interface{}{}
 	for _, f := range fields {

model/coupon.go

@@ -5,6 +5,9 @@ import "time"
 const (
 	CouponTypeDeduction = "deduction" // 抵扣
 )
+const (
+	MemberRenewalExpiration = 7
+)
 
 //go:generate goqueryset -in coupon.go
 // gen:qs
@@ -58,12 +61,13 @@ type Activity struct {
 type ActivityMemberRenewal struct {
 	Model
 
-	ActivityId  uint32    `json:"activity_id" gorm:"index"`
+	ActivityId   uint32    `json:"activity_id" gorm:"index"`
-	Uid         uint32    `json:"uid"`
+	Uid          uint32    `json:"uid"`
-	State       uint32    `json:"state"  gorm:"column:state;comment:'状态'"`                 // 1-进行中 2-已完成 3-已过期
+	State        uint32    `json:"state"  gorm:"column:state;comment:'状态'"`                 // 1-进行中 2-已完成 3-已过期
-	StartTime   time.Time `json:"start_time" gorm:"column:start_time;comment:'开始时间'"`      // 开始时间
+	StartTime    time.Time `json:"start_time" gorm:"column:start_time;comment:'开始时间'"`      // 开始时间
-	IsPop       bool      `json:"is_pop"  gorm:"column:is_pop;comment:'是否弹窗'"`             // 是否弹窗
+	IsPop        bool      `json:"is_pop"  gorm:"column:is_pop;comment:'是否弹窗'"`             // 是否弹窗
-	MemberLevel uint32    `json:"member_level"  gorm:"column:member_level;comment:'会员等级'"` // 会员等级
+	MemberLevel  uint32    `json:"member_level"  gorm:"column:member_level;comment:'会员等级'"` // 会员等级
+	MemberSerial uint32    `json:"member_serial"`                                           // 会员有效
 	//StartUseTime time.Time `json:"start_use_time" gorm:"column:start_use_time;comment:'开始使用时间'"` // 开始使用时间
 
 }

model/game_card.go

@@ -92,11 +92,14 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 		count     int
 		err       error
 	)
-	page -= 1
+	page = page - 1
 	if page < 0 {
 		page = 0
 		//return cards, 0, errors.New("page is err")
 	}
+	if pageSize == 0 {
+		pageSize = 10
+	}
 	//count, err := NewGameCardQuerySet(DB).Count()
 	//if err != nil {
 	//	logger.Error("NewGameCardQuerySet err:", err)
@@ -160,11 +163,9 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 			//	logger.Error("GetGameIdByType err:", err)
 			//	return cards, 0, err
 			//}
-			//
 			//for i, _ := range cardStocks {
 			//	gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
 			//}
-			//
 			//if len(gameIds) <= 0 {
 			//	return cards, 0, nil
 			//}
@@ -185,6 +186,7 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 				}
 			}
 
+			cardStocks = []GameCardGoodsStock{}
 			err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).RentStockGt(0).
 				OrderDescByRentStock().All(&cardStocks)
 			if err != nil {
@@ -199,6 +201,7 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 				}
 			}
 
+			cardStocks = []GameCardGoodsStock{}
 			err = NewGameCardGoodsStockQuerySet(DB).RentStockEq(0).All(&cardStocks)
 			if err != nil {
 				logger.Error("GetGameIdByType err:", err)
@@ -211,7 +214,10 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 					gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
 				}
 			}
-			qs = qs.IDIn(gameIds...)
+
+			if len(gameIds) > 0 {
+				qs = qs.IDIn(gameIds...)
+			}
 		} else {
 			var cardStocks []GameCardGoodsStock
 			err := NewGameCardGoodsStockQuerySet(DB).RentStockGt(0).
@@ -228,6 +234,7 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 				}
 			}
 
+			cardStocks = []GameCardGoodsStock{}
 			err = NewGameCardGoodsStockQuerySet(DB).RentStockEq(0).All(&cardStocks)
 			if err != nil {
 				logger.Error("GetGameIdByType err:", err)
@@ -240,14 +247,23 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 					gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
 				}
 			}
-			qs = qs.IDIn(gameIds...)
+			if len(gameIds) > 0 {
+				qs = qs.IDIn(gameIds...)
+			}
 		}
 	}
 
-	if count == 0 {
+	//if count == 0 {
-		count, err = qs.Count()
+	//
+	//}
+	count, err = qs.Count()
+	if err != nil {
+		logger.Error("count err:", err)
 	}
 	totalPage = uint32(count/pageSize + 1)
+	if count%pageSize == 0 {
+		totalPage = uint32(count / pageSize)
+	}
 	//err = qs.OrderDescByCreatedAt().Offset(page * pageSize).Limit(pageSize).All(&cards)
 	if sortType != 1 {
 		err = qs.Offset(page * pageSize).Limit(pageSize).All(&cards)
@@ -255,6 +271,8 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 			logger.Error("err:", err)
 			return cards, 0, err
 		}
+
+		GameCardListSetStockState(cards, storeId)
 	} else {
 		err = qs.All(&cards)
 		if err != nil && err != RecordNotFound {
@@ -275,7 +293,13 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 				list = append(list, v)
 			}
 		}
-		if uint32(page) < totalPage && totalPage != 1 {
+		count = len(list)
+		totalPage = uint32(count/pageSize + 1)
+		if count%pageSize == 0 {
+			totalPage = uint32(count / pageSize)
+		}
+
+		if uint32(page) < totalPage-1 && totalPage != 1 {
 			cards = list[page*pageSize : (page+1)*pageSize]
 		} else {
 			cards = list[page*pageSize:]
@@ -297,6 +321,7 @@ func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId
 	//for i, _ := range cardStocks {
 	//	cardStockMap[cardStocks[i].GameCardId] += cardStocks[i].RentStock
 	//}
+
 	for i, _ := range cards {
 		//stock, ok := cardStockMap[uint64(cards[i].ID)]
 		//if ok {
@@ -417,25 +442,39 @@ func GetGameCardInfo(id uint64, storeId uint32) (GameCard, error) {
 	}
 
 	var cardStock GameCardGoodsStock
-	err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).StoreIdEq(uint64(storeId)).One(&cardStock)
+	if storeId != 0 {
-	if err != nil && err != RecordNotFound {
+		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).StoreIdEq(uint64(storeId)).One(&cardStock)
-		logger.Error("err:", err)
+		if err != nil && err != RecordNotFound {
-		return game, nil
+			logger.Error("err:", err)
-	}
+			return game, nil
-	if cardStock.RentStock > 0 {
+		}
-		game.StockState = 1
+		if cardStock.RentStock > 0 {
-		return game, nil
+			game.StockState = 1
-	}
+			return game, nil
+		}
 
-	err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).
+		cardStock = GameCardGoodsStock{}
-		StoreIdNe(uint64(storeId)).RentStockGt(0).One(&cardStock)
+		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).
-	if err != nil && err != RecordNotFound {
+			StoreIdNe(uint64(storeId)).RentStockGt(0).One(&cardStock)
-		logger.Error("err:", err)
+		if err != nil && err != RecordNotFound {
-		return game, nil
+			logger.Error("err:", err)
-	}
+			return game, nil
-	if cardStock.RentStock > 0 {
+		}
-		game.StockState = 2
+		if cardStock.RentStock > 0 {
-		return game, nil
+			game.StockState = 2
+			return game, nil
+		}
+	} else {
+		cardStock = GameCardGoodsStock{}
+		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).RentStockGt(0).One(&cardStock)
+		if err != nil && err != RecordNotFound {
+			logger.Error("err:", err)
+			return game, nil
+		}
+		if cardStock.RentStock > 0 {
+			game.StockState = 1
+			return game, nil
+		}
 	}
 
 	game.StockState = 3
@@ -499,6 +538,9 @@ func GetGameCardSearch(name string, page, pageSize int, storeId uint32) ([]GameC
 	cardMap := make(map[uint32]GameCard, 0)
 	cardIds := make([]uint64, 0, len(cards))
 	for i, _ := range cards {
+		if cards[i].ID == 914 {
+			continue
+		}
 		cardIds = append(cardIds, uint64(cards[i].ID))
 		cardMap[cards[i].ID] = cards[i]
 	}
@@ -533,14 +575,17 @@ func GetGameCardSearch(name string, page, pageSize int, storeId uint32) ([]GameC
 			}
 		}
 	}
+	totalPage = cardCount.Count/uint32(pageSize) + 1
+	if cardCount.Count%uint32(pageSize) == 0 {
+		totalPage = cardCount.Count / uint32(pageSize)
+	}
 
-	if uint32(page) < totalPage && totalPage != 1 {
+	if uint32(page) < totalPage-1 && totalPage != 1 {
 		cards = list[page*pageSize : (page+1)*pageSize]
 	} else {
 		cards = list[page*pageSize:]
 	}
 
-	totalPage = cardCount.Count/uint32(pageSize) + 1
 	return cards, totalPage, nil
 }
 
@@ -1683,6 +1728,93 @@ func (m *AssistantMemberPromotionReq) List() ([]InviteMemberReport, int, error)
 	return reports, totalPage, nil
 }
 
+func GameCardListSetStockState(list []GameCard, storeId uint32) {
+	gameCardIds := make([]uint64, 0, len(list))
+	for i, _ := range list {
+		gameCardIds = append(gameCardIds, uint64(list[i].ID))
+	}
+	if len(gameCardIds) == 0 {
+		return
+	}
+	//gameIds := make([]uint32, 0)
+	gameIdMap := make(map[uint32]uint32)
+	if storeId != 0 {
+		var cardStocks []GameCardGoodsStock
+		err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdIn(gameCardIds...).
+			RentStockGt(0).All(&cardStocks)
+		if err != nil {
+			logger.Error("GetGameIdByType err:", err)
+		}
+		for i, _ := range cardStocks {
+			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
+			if !ok {
+				//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
+				gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
+			}
+		}
+
+		err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).GameCardIdIn(gameCardIds...).
+			RentStockGt(0).All(&cardStocks)
+		if err != nil {
+			logger.Error("GetGameIdByType err:", err)
+		}
+		for i, _ := range cardStocks {
+			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
+			if !ok {
+				//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
+				gameIdMap[uint32(cardStocks[i].GameCardId)] = 2
+			}
+		}
+
+		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockEq(0).All(&cardStocks)
+		if err != nil {
+			logger.Error("GetGameIdByType err:", err)
+		}
+		for i, _ := range cardStocks {
+			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
+			if !ok {
+				//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
+				gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
+			}
+		}
+
+	} else {
+		var cardStocks []GameCardGoodsStock
+		err := NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockGt(0).
+			All(&cardStocks)
+		if err != nil {
+			logger.Error("GetGameIdByType err:", err)
+		}
+		for i, _ := range cardStocks {
+			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
+			if !ok {
+				gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
+			}
+		}
+
+		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockEq(0).All(&cardStocks)
+		if err != nil {
+			logger.Error("GetGameIdByType err:", err)
+		}
+		for i, _ := range cardStocks {
+			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
+			if !ok {
+				gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
+			}
+		}
+
+	}
+
+	for i, _ := range list {
+		v, ok := gameIdMap[uint32(list[i].ID)]
+		if ok {
+			//gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
+			list[i].StockState = v
+		}
+		//gameCardIds = append(gameCardIds, uint64(list[i].ID))
+	}
+}
+
 func InviteMemberReportListSetUser(list []InviteMemberReport) []InviteMemberReport {
 	uids := make([]uint32, 0, len(list))
 	for i, _ := range list {

model/model_test.go

@@ -116,7 +116,8 @@ func InitTestDB() {
 		//&OperationLog{},
 		//&DeliverTask{},
 		//&DeliverTaskSub{},
-
+		&User{},
+		// 优惠券
 		&GameCard{},
 		&ActivityMemberRenewal{},
 		&Activity{},
@@ -124,6 +125,7 @@ func InitTestDB() {
 		&Coupon{},
 		&UserOpenMemberRecord{},
 		&HomeCarousel{},
+		&UserRenewalLog{},
 	)
 
 	fmt.Println("DB init success")
@@ -159,65 +161,74 @@ func InitDBProd() {
 	DBProd.LogMode(false)
 	DBProd.SingularTable(true)
 	DBProd.AutoMigrate(
-	//&RedeemCode{},
+		//&RedeemCode{},
-	//&UserRedeemCode{},
+		//&UserRedeemCode{},
-	//&GameCardGoods{},
+		//&GameCardGoods{},
 
-	//&UserShareCardBill{},
+		//&UserShareCardBill{},
-	//&ShareCardBillGame{},
+		//&ShareCardBillGame{},
-	//&UserShareCard{},
+		//&UserShareCard{},
-	//&ShareCardVmRecord{},
+		//&ShareCardVmRecord{},
-	//&UserShareCardVm{},
+		//&UserShareCardVm{},
-	//&ShareCardDateVm{},
+		//&ShareCardDateVm{},
-	//&ShareCardGameVm{},
+		//&ShareCardGameVm{},
-	//&ShareCardRetrieve{},
+		//&ShareCardRetrieve{},
-	//&ShareCardRetrieveCard{},
+		//&ShareCardRetrieveCard{},
-	//&GameCardLabel{},
+		//&GameCardLabel{},
-	//&CardIssueFeedback{},
+		//&CardIssueFeedback{},
 
-	//&GameCard{},
+		//&GameCard{},
-	//&FundRecord{},
+		//&FundRecord{},
-	//&User{},
+		//&User{},
 
-	//&GameCard{},
+		//&GameCard{},
-	//&FundRecord{},
+		//&FundRecord{},
-	//&User{},
+		//&User{},
-	//&UserAttendance{},
+		//&UserAttendance{},
-	//&UserAttendanceRecord{},
+		//&UserAttendanceRecord{},
 
-	//&Store{},
+		//&Store{},
-	//&GameCard{},
+		//&GameCard{},
-	//&GameCardGoods{},
+		//&GameCardGoods{},
-	//&GameCardGoodsStock{},
+		//&GameCardGoodsStock{},
-	//&User{},
+		//&User{},
-	//&Order{},
+		//&Order{},
-	//&OrderCard{},
+		//&OrderCard{},
-	//
+		//
-	//&OperationLog{},
+		//&OperationLog{},
-	//&CooperativeBusiness{},
+		//&CooperativeBusiness{},
-	//&CooperativeMemberDeduct{},
+		//&CooperativeMemberDeduct{},
-	//&CooperativeAssistantMemberDeduct{},
+		//&CooperativeAssistantMemberDeduct{},
-	//
+		//
-	//&CooperativeMemberPromotion{},
+		//&CooperativeMemberPromotion{},
-	//&CooperativeMemberPromotionStore{},
+		//&CooperativeMemberPromotionStore{},
-	//&CooperativeMemberPromotionDay{},
+		//&CooperativeMemberPromotionDay{},
-	//&CooperativeMemberPromotionStoreDay{},
+		//&CooperativeMemberPromotionStoreDay{},
-	//&InviteMemberReport{},
+		//&InviteMemberReport{},
-	//&CooperativeDeductSettle{},
+		//&CooperativeDeductSettle{},
-	//&XcxRole{},
+		//&XcxRole{},
 
-	// 商城
+		// 商城
-	//&Goods{},
+		//&Goods{},
-	//&GoodsCat{},
+		//&GoodsCat{},
-	//&GoodsAttribute{},
+		//&GoodsAttribute{},
-	//&GoodsAttributeCombo{},
+		//&GoodsAttributeCombo{},
-	//&Spec{},
+		//&Spec{},
-	//&SpecValue{},
+		//&SpecValue{},
-	//&GoodsOrder{},
+		//&GoodsOrder{},
-	//&OperationLog{},
+		//&OperationLog{},
-	//&DeliverTask{},
+		//&DeliverTask{},
-	//&DeliverTaskSub{},
+		//&DeliverTaskSub{},
 
+		// 优惠券
+		&GameCard{},
+		&ActivityMemberRenewal{},
+		&Activity{},
+		&UserCoupon{},
+		&Coupon{},
+		&UserOpenMemberRecord{},
+		&HomeCarousel{},
+		&UserRenewalLog{},
 	)
 
 	if err := DBProd.DB().Ping(); err != nil {
@@ -1425,10 +1436,53 @@ func TestByte(t *testing.T) {
 }
 
 func TestSlice(t *testing.T) {
-	var p [100]int
+	//var p [100]int
-	var m interface{} = [...]int{99: 0}
+	//var m interface{} = [...]int{99: 0}
-	fmt.Println(p == m)
+	//fmt.Println(p == m)
-	fmt.Println("p:", p)
+	//fmt.Println("p:", p)
-	fmt.Println("m:", m)
+	//fmt.Println("m:", m)
+
+	user := User{
+		Uid:    123123,
+		WxName: "hfiue",
+	}
+
+	fmt.Printf("user:%#v", user)
+	fmt.Println("")
+	fmt.Printf("user:%+v", user)
+	fmt.Println("")
+}
+
+func TestUserUpgradeMemberRecord(t *testing.T) {
+
+	UserUpgradeMemberRecord()
+}
+
+// 导出升级会员数据
+func UserUpgradeMemberRecord() {
+	InitDBProd()
+	var users []User
+	err := NewUserQuerySet(DBProd).MemberLevelEq(4).All(&users)
+	if err != nil {
+		fmt.Println("user err:", err)
+	}
+	uids := ""
+	for i, _ := range users {
+		t := users[i].OpenMemberTime.AddDate(1, 0, 0).Unix() - users[i].MemberExpire.Unix()
+
+		if (t > 0 && t > 20*3600) || (t < 0 && t < -20*3600) {
+			fmt.Println("user:",
+				users[i].MemberExpire.Format(utils.TimeFormat),
+				users[i].OpenMemberTime.Format(utils.TimeFormat),
+				users[i].CreatedAt.Format(utils.TimeFormat))
+			uids += fmt.Sprintf("%d,", users[i].Uid)
+
+		}
+	}
+	fmt.Println("uids:", uids[:len(uids)-1])
+}
+
+func TestOrderUpdater_SetUserAddressId(t *testing.T) {
+	//var users []User
 
 }

model/user.go

@@ -47,7 +47,7 @@ type User struct {
 	ShopAssistantName     string    `json:"shop_assistant_name"`                  // 店员名称
 	Version               uint32    `json:"-"`                                    //
 	UserVm                *UserVm   `json:"user_vm" gorm:"-"`                     //
-
+	InviteTime            time.Time `json:"invite_time"`
 	//RoleId                uint32    `json:"role_id"`                              // 角色id
 
 }
@@ -251,7 +251,7 @@ func UserUpdate(user *User) error {
 	return nil
 }
 
-//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单 8-购买商品订单退货 9-升级会员
+//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单 8-购买商品订单退货 9-升级会员 10-开通 续费
 
 // gen:qs
 type UserOpenMemberRecord struct {
@@ -264,6 +264,7 @@ type UserOpenMemberRecord struct {
 	MemberLevel  uint32    `json:"member_level"`
 	MemberExpire time.Time `json:"member_expire"`               // 会员到期时间
 	UserCouponId uint32    `json:"user_coupon_id" gorm:"index"` // 优惠券id
+	State        uint32    `json:"state"`                       // 1-未处理 2-已处理
 
 	Order             *Order             `json:"order"  gorm:"-"`
 	ShareCardRetrieve *ShareCardRetrieve `json:"share_card_retrieve"  gorm:"-"`

router/router_app.go

@@ -115,7 +115,7 @@ func ConfigAppRouter(r gin.IRouter) {
 
 	my := api.Group("user/my")
 	{
-		my.Use(auth.UserAccessAuth) //
+		my.Use(auth.UserAccessAuth)
 
 		my.POST("history_browsing", controller.HistoryBrowsingList)    // 浏览记录
 		my.POST("history_browsing/del", controller.HistoryBrowsingDel) // 浏览记录删除
@@ -133,12 +133,12 @@ func ConfigAppRouter(r gin.IRouter) {
 		order.POST("express_company/list", controller.ExpressCompanyList) // 物流公司列表
 		order.POST("order/wx_pay/success", controller.WXPaySuccess)       // 微信支付成功
 		order.POST("cancel", controller.OrderCancel)                      // 取消租卡
-		order.Use(auth.UserAccessAuth)                                    //
+		order.Use(auth.UserAccessAuth)
-		order.POST("create", controller.RentCardOrderCreate)              // 创建租卡
+		order.POST("create", controller.RentCardOrderCreate)      // 创建租卡
-		order.POST("pay", controller.OrderPay)                            // 租卡订单支付
+		order.POST("pay", controller.OrderPay)                    // 租卡订单支付
-		order.POST("list", controller.RentCardOrderList)                  // 租卡订单列表
+		order.POST("list", controller.RentCardOrderList)          // 租卡订单列表
-		order.POST("revert", controller.OrderRevert)                      // 租卡订单归还
+		order.POST("revert", controller.OrderRevert)              // 租卡订单归还
-		order.POST("revert/cancel", controller.OrderRevertCancel)         // 取消归还
+		order.POST("revert/cancel", controller.OrderRevertCancel) // 取消归还
 		//order.POST("express_fee/refund", controller.ExpressFeeRefund) // 物流费退款
 		order.POST("confirm_receipt", controller.ConfirmReceipt) // 订单确认收货
 	}