fix:会员共享卡

controller/game_card.go

@@ -560,6 +560,26 @@ func PushWXPayNotice(c *gin.Context) {
 		}
 
 		model.CreateUserRentCardByMemberLevel(record.Uid, record.MemberLevel, memberConfig.CardMax)
+	} else if notify.Attach == wxpay.WxPayMemberExpireDelay {
+		record := &model.UserOpenMemberRecord{OpenNo: notify.OutTradeNo}
+		err := record.GetByOpenNo()
+		if err != nil {
+			logger.Error("err:", err)
+			return
+		}
+		var user model.User
+		err = model.NewUserQuerySet(model.DB).UidEq(record.Uid).One(&user)
+		if err != nil {
+			logger.Error("err:", err)
+			return
+		}
+
+		_, err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(record.Uid).MemberExpireEq(user.MemberExpire).GetUpdater().
+			SetIsPay(1).UpdateNum()
+		if err != nil {
+			logger.Error("err:", err)
+			return
+		}
 	}
 
 	logger.Debug("微信推动支付通知")

controller/mall.go

@@ -8,6 +8,7 @@ import (
 	"mh-server/lib/status"
 	"mh-server/lib/wxpay"
 	"mh-server/model"
+	"time"
 )
 
 func MallGoodsList(c *gin.Context) {
@@ -131,13 +132,6 @@ func MallOrderCreate(c *gin.Context) {
 		DeliveryFee:       goods.DeliveryFee,
 		DeliveryStatus:    model.DeliveryStatusUnDeliver,
 	}
-	err = order.Create(tx)
-	if err != nil {
-		logger.Error("err:", err)
-		tx.Rollback()
-		RespJson(c, status.InternalServerError, nil)
-		return
-	}
 
 	// TODO 减少库存
 	// TODO 确认下是在支付后减少，还是下单后？
@@ -165,6 +159,69 @@ func MallOrderCreate(c *gin.Context) {
 		//}
 	}
 
+	if goods.DeliveryFee == 0 {
+		order.PayTime = time.Now()
+		order.PayStatus = model.PayStatusOK
+		//_, err := model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(notify.OutTradeNo).GetUpdater().
+		//	SetPayTime(time.Now()).
+		//	SetPayStatus(model.PayStatusOK).UpdateNum()
+		//if err != nil {
+		//	logger.Error("err:", err)
+		//}
+		//var goodsOrder model.GoodsOrder
+		//err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(notify.OutTradeNo).One(&goodsOrder)
+		//if err != nil {
+		//	logger.Error("err:", err)
+		//}
+		err = order.Create(tx)
+		if err != nil {
+			logger.Error("err:", err)
+			tx.Rollback()
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+
+		err = model.OrderUpdateGoodsStock(order.GoodsId, order.Quantity, tx)
+		if err != nil {
+			tx.Rollback()
+			logger.Error("err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+
+		err = model.UserVmUpdate(order.Uid, int(order.Amount)*-1, model.VmEventExchangeGoods, "兑换奖品")
+		if err != nil {
+			tx.Rollback()
+			logger.Error("err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+
+		err = tx.Commit().Error
+		if err != nil {
+			tx.Rollback()
+			logger.Error("err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+
+		ret := map[string]interface{}{
+			"order_id": order.ID,
+			"order":    order,
+		}
+
+		RespOK(c, ret)
+		return
+	}
+
+	err = order.Create(tx)
+	if err != nil {
+		logger.Error("err:", err)
+		tx.Rollback()
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
 	err = tx.Commit().Error
 	if err != nil {
 		tx.Rollback()

controller/user.go

@@ -582,28 +582,38 @@ func RefundDeposit(c *gin.Context) {
 		return
 	}
 
-	count, err := model.NewDepositRefundRecordQuerySet(model.DB).UidEq(uc.Uid).StatusNotIn(model.DepositRefundStatusRefunded, model.DepositRefundStatusRefused).Count()
+	resp, err := model.MemberExpireDelaying(uc.Uid)
-	if err != nil || count > 0 {
-		logger.Error("count is not 0")
-		RespJson(c, status.RefundDepositSubmitted, nil)
-		return
-	}
-	record := &model.DepositRefundRecord{
-		Uid:         uc.Uid,
-		Status:      model.DepositRefundStatusUnconfirmed,
-		Amount:      user.Deposit,
-		Operator:    0,
-		ConfirmTime: time.Time{},
-	}
-
-	err = model.DB.Create(record).Error
 	if err != nil {
-		logger.Error("err:", err)
+		logger.Errorf("err:", err)
 		RespJson(c, status.InternalServerError, nil)
 		return
 	}
+	isSurrender, _ := resp["is_surrender"]
 
-	RespOK(c, nil)
+	if isSurrender == 0 {
+		count, err := model.NewDepositRefundRecordQuerySet(model.DB).UidEq(uc.Uid).StatusNotIn(model.DepositRefundStatusRefunded, model.DepositRefundStatusRefused).Count()
+		if err != nil || count > 0 {
+			logger.Error("count is not 0")
+			RespJson(c, status.RefundDepositSubmitted, nil)
+			return
+		}
+		record := &model.DepositRefundRecord{
+			Uid:         uc.Uid,
+			Status:      model.DepositRefundStatusUnconfirmed,
+			Amount:      user.Deposit,
+			Operator:    0,
+			ConfirmTime: time.Time{},
+		}
+
+		err = model.DB.Create(record).Error
+		if err != nil {
+			logger.Error("err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+	}
+
+	RespOK(c, resp)
 }
 
 func UserDepositRefundRecordList(c *gin.Context) {
@@ -623,6 +633,82 @@ func UserDepositRefundRecordList(c *gin.Context) {
 	RespOK(c, resp)
 }
 
+func UserMemberExpireDelayingInfo(c *gin.Context) {
+	uc := auth.GetCurrentUser(c)
+	if uc == nil {
+		RespJson(c, status.Unauthorized, nil)
+		return
+	}
+
+	unreturnedOrders, err := model.IsUserHaveUnreturnedOrder(uc.Uid)
+	if err != nil {
+		logger.Error("err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+	if unreturnedOrders {
+		logger.Error("unreturnedOrders")
+		RespJson(c, status.HaveUnreturnedOrders, nil)
+		return
+	}
+
+	resp, err := model.MemberExpireDelaying(uc.Uid)
+	if err != nil {
+		logger.Errorf("err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	RespOK(c, resp)
+}
+
+func UserMemberExpireDelayingPay(c *gin.Context) {
+	uc := auth.GetCurrentUser(c)
+	if uc == nil {
+		RespJson(c, status.Unauthorized, nil)
+		return
+	}
+
+	var user model.User
+	err := model.NewUserQuerySet(model.DB).UidEq(uc.Uid).One(&user)
+	if err != nil {
+		logger.Error("user err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	var userMemberExpireDelay model.UserMemberExpireDelay
+	err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(uc.Uid).MemberExpireEq(user.MemberExpire).One(&userMemberExpireDelay)
+	if err != nil {
+		logger.Error("user member expire delay err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	orderSn := model.GetOrderSn()
+	webPay, err := wxpay.WebPay(orderSn, uint32(userMemberExpireDelay.DelayAmount), user.WxOpenID, "N", wxpay.WxPayMemberExpireDelay)
+	if err != nil {
+		logger.Error(errors.New("WebPay err"))
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, OrderId: 0, OrderType: 3}.Insert()
+	if err != nil {
+		logger.Error(errors.New("WebPay err"))
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	ret := make(map[string]interface{}, 0)
+	ret["is_surrender"] = 1
+	ret["expire_days"] = userMemberExpireDelay.ExpireDays
+	ret["daily_fee"] = userMemberExpireDelay.DailyFee
+	ret["delay_amount"] = userMemberExpireDelay.DelayAmount
+	ret["web_pay"] = webPay
+	RespOK(c, ret)
+	return
+}
+
 func MemberConfigList(c *gin.Context) {
 	//uc := auth.GetCurrentUser(c)
 	//if uc == nil {
@@ -650,5 +736,5 @@ func MemberConfigList(c *gin.Context) {
 //  会员列表 开通会员 下订单 借卡 还卡
 //  会员升级
 //  299会员 升级
-// 订单 会员导数据
+//  订单 会员导数据
-// 退押金记录
+//  退押金记录

controller/user_share_card.go

@@ -0,0 +1,108 @@
+package controller
+
+import (
+	"errors"
+	"github.com/codinl/go-logger"
+	"github.com/gin-gonic/gin"
+	"mh-server/lib/auth"
+	"mh-server/lib/status"
+	"mh-server/model"
+)
+
+func UserShareCardBillCreate(c *gin.Context) {
+	req := struct {
+		GameCardList []model.CardInfo `json:"game_card_list"`
+		StoreId      uint32           `json:"store_id"`
+		SendCardType uint32           `json:"send_card_type"` // 1-送卡 2-邮寄
+	}{}
+	if c.ShouldBindJSON(&req) != nil {
+		logger.Error("parameter err")
+		RespJson(c, status.BadRequest, nil)
+		return
+	}
+	uc := auth.GetCurrentUser(c)
+	if uc == nil {
+		RespJson(c, status.Unauthorized, nil)
+		return
+	}
+	if len(req.GameCardList) == 0 || req.StoreId == 0 || req.SendCardType == 0 {
+		logger.Error(errors.New("req err"))
+		RespJson(c, status.Unauthorized, nil)
+		return
+	}
+	billSn := model.GetShareCardBillSn()
+	begin := model.DB.Begin()
+	shareCardBill := &model.UserShareCardBill{
+		Uid:          uc.Uid,
+		BillSn:       billSn,
+		State:        model.ShareCardBillStateInCheck,
+		SendCardType: req.SendCardType,
+		StoreId:      req.StoreId,
+	}
+	err := begin.Create(shareCardBill).Error
+	if err != nil {
+		begin.Rollback()
+		logger.Error("user share card bill create err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+	for _, info := range req.GameCardList {
+		var cardBill = model.ShareCardBillGame{
+			UserShareCardBillId: shareCardBill.ID,
+			Uid:                 uc.Uid,
+			GameCardId:          info.GameCardId,
+			BillSn:              billSn,
+			Count:               info.Count,
+			State:               model.ShareCardStateInCheck,
+		}
+		err := begin.Create(&cardBill).Error
+		if err != nil {
+			begin.Rollback()
+			logger.Error("share card bill game create err:", err)
+			RespJson(c, status.InternalServerError, nil)
+			return
+		}
+	}
+
+	err = begin.Commit().Error
+	if err != nil {
+		begin.Rollback()
+		logger.Error("share card bill game create err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	RespOK(c, nil)
+	return
+}
+
+func UserShareCardBillList(c *gin.Context) {
+	req := struct {
+		Page     int `json:"cur_page"`
+		PageSize int `json:"page_size"`
+	}{}
+	if c.ShouldBindJSON(&req) != nil {
+		logger.Error("parameter err")
+		RespJson(c, status.BadRequest, nil)
+		return
+	}
+	uc := auth.GetCurrentUser(c)
+	if uc == nil {
+		RespJson(c, status.Unauthorized, nil)
+		return
+	}
+	list, totalPage, err := model.GetUserShareCardBillList(uc.Uid, req.Page, req.PageSize)
+	if err != nil {
+		logger.Error("share card bill game create err:", err)
+		RespJson(c, status.InternalServerError, nil)
+		return
+	}
+
+	ret := map[string]interface{}{
+		"list":       list,
+		"cur_page":   req.Page,
+		"total_page": totalPage,
+	}
+	RespOK(c, ret)
+	return
+}

lib/wxpay/wx_pay.go

@@ -34,11 +34,12 @@ const (
 	//wxPayNotifyUrl = "api/v1/wxpay/notice"
 	wxPayNotifyUrl = "/api/v1/wxpay/notice"
 
-	WxPayMember        = "member_pay"     // 会员
+	WxPayMember            = "member_pay"          // 会员
-	WxPayRentCard      = "rent_card_pay"  // 租卡
+	WxPayRentCard          = "rent_card_pay"       // 租卡
-	WxPayDeposit       = "deposit_pay"    // 押金
+	WxPayDeposit           = "deposit_pay"         // 押金
-	WxPayExchangeGoods = "exchange_goods" // 兑换商品
+	WxPayExchangeGoods     = "exchange_goods"      // 兑换商品
-	WxPayUpgradeMember = "upgrade_member" // 多级会员
+	WxPayUpgradeMember     = "upgrade_member"      // 多级会员
+	WxPayMemberExpireDelay = "member_expire_delay" // 会员过期滞纳金
 
 	//NotifyUrl = "https://switch.deovo.com:8001/api/v1/wxpay/notice" // TODO  数据库配置 生产
 	//NotifyUrl = "https://dev.switch.deovo.com:8004/api/v1/wxpay/notice" // TODO 测试

model/autogenerated_user.go

@@ -3398,6 +3398,892 @@ func NewUserInviteUpdater(db *gorm.DB) UserInviteUpdater {
 
 // ===== END of UserInvite modifiers
 
+// ===== BEGIN of query set UserMemberExpireDelayQuerySet
+
+// UserMemberExpireDelayQuerySet is an queryset type for UserMemberExpireDelay
+type UserMemberExpireDelayQuerySet struct {
+	db *gorm.DB
+}
+
+// NewUserMemberExpireDelayQuerySet constructs new UserMemberExpireDelayQuerySet
+func NewUserMemberExpireDelayQuerySet(db *gorm.DB) UserMemberExpireDelayQuerySet {
+	return UserMemberExpireDelayQuerySet{
+		db: db.Model(&UserMemberExpireDelay{}),
+	}
+}
+
+func (qs UserMemberExpireDelayQuerySet) w(db *gorm.DB) UserMemberExpireDelayQuerySet {
+	return NewUserMemberExpireDelayQuerySet(db)
+}
+
+func (qs UserMemberExpireDelayQuerySet) Select(fields ...UserMemberExpireDelayDBSchemaField) UserMemberExpireDelayQuerySet {
+	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 *UserMemberExpireDelay) Create(db *gorm.DB) error {
+	return db.Create(o).Error
+}
+
+// Delete is an autogenerated method
+// nolint: dupl
+func (o *UserMemberExpireDelay) Delete(db *gorm.DB) error {
+	return db.Delete(o).Error
+}
+
+// All is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) All(ret *[]UserMemberExpireDelay) error {
+	return qs.db.Find(ret).Error
+}
+
+// Count is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) Count() (int, error) {
+	var count int
+	err := qs.db.Count(&count).Error
+	return count, err
+}
+
+// CreatedAtEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) CreatedAtEq(createdAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("created_at = ?", createdAt))
+}
+
+// CreatedAtGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) CreatedAtGt(createdAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("created_at > ?", createdAt))
+}
+
+// CreatedAtGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) CreatedAtGte(createdAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("created_at >= ?", createdAt))
+}
+
+// CreatedAtLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) CreatedAtLt(createdAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("created_at < ?", createdAt))
+}
+
+// CreatedAtLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) CreatedAtLte(createdAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("created_at <= ?", createdAt))
+}
+
+// CreatedAtNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) CreatedAtNe(createdAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("created_at != ?", createdAt))
+}
+
+// DailyFeeEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeEq(dailyFee uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("daily_fee = ?", dailyFee))
+}
+
+// DailyFeeGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeGt(dailyFee uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("daily_fee > ?", dailyFee))
+}
+
+// DailyFeeGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeGte(dailyFee uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("daily_fee >= ?", dailyFee))
+}
+
+// DailyFeeIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeIn(dailyFee ...uint32) UserMemberExpireDelayQuerySet {
+	if len(dailyFee) == 0 {
+		qs.db.AddError(errors.New("must at least pass one dailyFee in DailyFeeIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("daily_fee IN (?)", dailyFee))
+}
+
+// DailyFeeLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeLt(dailyFee uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("daily_fee < ?", dailyFee))
+}
+
+// DailyFeeLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeLte(dailyFee uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("daily_fee <= ?", dailyFee))
+}
+
+// DailyFeeNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeNe(dailyFee uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("daily_fee != ?", dailyFee))
+}
+
+// DailyFeeNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DailyFeeNotIn(dailyFee ...uint32) UserMemberExpireDelayQuerySet {
+	if len(dailyFee) == 0 {
+		qs.db.AddError(errors.New("must at least pass one dailyFee in DailyFeeNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("daily_fee NOT IN (?)", dailyFee))
+}
+
+// DelayAmountEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountEq(delayAmount uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("delay_amount = ?", delayAmount))
+}
+
+// DelayAmountGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountGt(delayAmount uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("delay_amount > ?", delayAmount))
+}
+
+// DelayAmountGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountGte(delayAmount uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("delay_amount >= ?", delayAmount))
+}
+
+// DelayAmountIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountIn(delayAmount ...uint32) UserMemberExpireDelayQuerySet {
+	if len(delayAmount) == 0 {
+		qs.db.AddError(errors.New("must at least pass one delayAmount in DelayAmountIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("delay_amount IN (?)", delayAmount))
+}
+
+// DelayAmountLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountLt(delayAmount uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("delay_amount < ?", delayAmount))
+}
+
+// DelayAmountLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountLte(delayAmount uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("delay_amount <= ?", delayAmount))
+}
+
+// DelayAmountNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountNe(delayAmount uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("delay_amount != ?", delayAmount))
+}
+
+// DelayAmountNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DelayAmountNotIn(delayAmount ...uint32) UserMemberExpireDelayQuerySet {
+	if len(delayAmount) == 0 {
+		qs.db.AddError(errors.New("must at least pass one delayAmount in DelayAmountNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("delay_amount NOT IN (?)", delayAmount))
+}
+
+// Delete is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) Delete() error {
+	return qs.db.Delete(UserMemberExpireDelay{}).Error
+}
+
+// DeleteNum is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeleteNum() (int64, error) {
+	db := qs.db.Delete(UserMemberExpireDelay{})
+	return db.RowsAffected, db.Error
+}
+
+// DeleteNumUnscoped is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeleteNumUnscoped() (int64, error) {
+	db := qs.db.Unscoped().Delete(UserMemberExpireDelay{})
+	return db.RowsAffected, db.Error
+}
+
+// DeletedAtEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtEq(deletedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
+}
+
+// DeletedAtGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtGt(deletedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
+}
+
+// DeletedAtGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtGte(deletedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
+}
+
+// DeletedAtIsNotNull is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtIsNotNull() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
+}
+
+// DeletedAtIsNull is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtIsNull() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at IS NULL"))
+}
+
+// DeletedAtLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtLt(deletedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
+}
+
+// DeletedAtLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtLte(deletedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
+}
+
+// DeletedAtNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) DeletedAtNe(deletedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
+}
+
+// ExpireDaysEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysEq(expireDays uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("expire_days = ?", expireDays))
+}
+
+// ExpireDaysGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysGt(expireDays uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("expire_days > ?", expireDays))
+}
+
+// ExpireDaysGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysGte(expireDays uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("expire_days >= ?", expireDays))
+}
+
+// ExpireDaysIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysIn(expireDays ...uint32) UserMemberExpireDelayQuerySet {
+	if len(expireDays) == 0 {
+		qs.db.AddError(errors.New("must at least pass one expireDays in ExpireDaysIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("expire_days IN (?)", expireDays))
+}
+
+// ExpireDaysLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysLt(expireDays uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("expire_days < ?", expireDays))
+}
+
+// ExpireDaysLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysLte(expireDays uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("expire_days <= ?", expireDays))
+}
+
+// ExpireDaysNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysNe(expireDays uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("expire_days != ?", expireDays))
+}
+
+// ExpireDaysNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) ExpireDaysNotIn(expireDays ...uint32) UserMemberExpireDelayQuerySet {
+	if len(expireDays) == 0 {
+		qs.db.AddError(errors.New("must at least pass one expireDays in ExpireDaysNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("expire_days NOT IN (?)", expireDays))
+}
+
+// GetDB is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) GetDB() *gorm.DB {
+	return qs.db
+}
+
+// GetUpdater is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) GetUpdater() UserMemberExpireDelayUpdater {
+	return NewUserMemberExpireDelayUpdater(qs.db)
+}
+
+// IDEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDEq(ID uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("id = ?", ID))
+}
+
+// IDGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDGt(ID uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("id > ?", ID))
+}
+
+// IDGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDGte(ID uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("id >= ?", ID))
+}
+
+// IDIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDIn(ID ...uint32) UserMemberExpireDelayQuerySet {
+	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 UserMemberExpireDelayQuerySet) IDLt(ID uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("id < ?", ID))
+}
+
+// IDLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDLte(ID uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("id <= ?", ID))
+}
+
+// IDNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDNe(ID uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("id != ?", ID))
+}
+
+// IDNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IDNotIn(ID ...uint32) UserMemberExpireDelayQuerySet {
+	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))
+}
+
+// IsPayEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayEq(isPay uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("is_pay = ?", isPay))
+}
+
+// IsPayGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayGt(isPay uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("is_pay > ?", isPay))
+}
+
+// IsPayGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayGte(isPay uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("is_pay >= ?", isPay))
+}
+
+// IsPayIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayIn(isPay ...uint32) UserMemberExpireDelayQuerySet {
+	if len(isPay) == 0 {
+		qs.db.AddError(errors.New("must at least pass one isPay in IsPayIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("is_pay IN (?)", isPay))
+}
+
+// IsPayLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayLt(isPay uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("is_pay < ?", isPay))
+}
+
+// IsPayLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayLte(isPay uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("is_pay <= ?", isPay))
+}
+
+// IsPayNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayNe(isPay uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("is_pay != ?", isPay))
+}
+
+// IsPayNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) IsPayNotIn(isPay ...uint32) UserMemberExpireDelayQuerySet {
+	if len(isPay) == 0 {
+		qs.db.AddError(errors.New("must at least pass one isPay in IsPayNotIn"))
+		return qs.w(qs.db)
+	}
+	return qs.w(qs.db.Where("is_pay NOT IN (?)", isPay))
+}
+
+// Limit is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) Limit(limit int) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Limit(limit))
+}
+
+// MemberExpireEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) MemberExpireEq(memberExpire time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("member_expire = ?", memberExpire))
+}
+
+// MemberExpireGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) MemberExpireGt(memberExpire time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("member_expire > ?", memberExpire))
+}
+
+// MemberExpireGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) MemberExpireGte(memberExpire time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("member_expire >= ?", memberExpire))
+}
+
+// MemberExpireLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) MemberExpireLt(memberExpire time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("member_expire < ?", memberExpire))
+}
+
+// MemberExpireLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) MemberExpireLte(memberExpire time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("member_expire <= ?", memberExpire))
+}
+
+// MemberExpireNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) MemberExpireNe(memberExpire time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("member_expire != ?", memberExpire))
+}
+
+// Offset is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) Offset(offset int) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Offset(offset))
+}
+
+// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
+// if nothing was fetched
+func (qs UserMemberExpireDelayQuerySet) One(ret *UserMemberExpireDelay) error {
+	return qs.db.First(ret).Error
+}
+
+// OrderAscByCreatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByCreatedAt() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("created_at ASC"))
+}
+
+// OrderAscByDailyFee is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByDailyFee() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("daily_fee ASC"))
+}
+
+// OrderAscByDelayAmount is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByDelayAmount() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("delay_amount ASC"))
+}
+
+// OrderAscByDeletedAt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByDeletedAt() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("deleted_at ASC"))
+}
+
+// OrderAscByExpireDays is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByExpireDays() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("expire_days ASC"))
+}
+
+// OrderAscByID is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByID() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("id ASC"))
+}
+
+// OrderAscByIsPay is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByIsPay() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("is_pay ASC"))
+}
+
+// OrderAscByMemberExpire is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByMemberExpire() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("member_expire ASC"))
+}
+
+// OrderAscByUid is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByUid() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("uid ASC"))
+}
+
+// OrderAscByUpdatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderAscByUpdatedAt() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("updated_at ASC"))
+}
+
+// OrderDescByCreatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByCreatedAt() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("created_at DESC"))
+}
+
+// OrderDescByDailyFee is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByDailyFee() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("daily_fee DESC"))
+}
+
+// OrderDescByDelayAmount is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByDelayAmount() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("delay_amount DESC"))
+}
+
+// OrderDescByDeletedAt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByDeletedAt() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("deleted_at DESC"))
+}
+
+// OrderDescByExpireDays is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByExpireDays() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("expire_days DESC"))
+}
+
+// OrderDescByID is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByID() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("id DESC"))
+}
+
+// OrderDescByIsPay is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByIsPay() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("is_pay DESC"))
+}
+
+// OrderDescByMemberExpire is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByMemberExpire() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("member_expire DESC"))
+}
+
+// OrderDescByUid is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByUid() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("uid DESC"))
+}
+
+// OrderDescByUpdatedAt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) OrderDescByUpdatedAt() UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Order("updated_at DESC"))
+}
+
+// UidEq is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidEq(uid uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("uid = ?", uid))
+}
+
+// UidGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidGt(uid uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("uid > ?", uid))
+}
+
+// UidGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidGte(uid uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("uid >= ?", uid))
+}
+
+// UidIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidIn(uid ...uint32) UserMemberExpireDelayQuerySet {
+	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 UserMemberExpireDelayQuerySet) UidLt(uid uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("uid < ?", uid))
+}
+
+// UidLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidLte(uid uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("uid <= ?", uid))
+}
+
+// UidNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidNe(uid uint32) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("uid != ?", uid))
+}
+
+// UidNotIn is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UidNotIn(uid ...uint32) UserMemberExpireDelayQuerySet {
+	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 UserMemberExpireDelayQuerySet) UpdatedAtEq(updatedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
+}
+
+// UpdatedAtGt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UpdatedAtGt(updatedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
+}
+
+// UpdatedAtGte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UpdatedAtGte(updatedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
+}
+
+// UpdatedAtLt is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UpdatedAtLt(updatedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
+}
+
+// UpdatedAtLte is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UpdatedAtLte(updatedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
+}
+
+// UpdatedAtNe is an autogenerated method
+// nolint: dupl
+func (qs UserMemberExpireDelayQuerySet) UpdatedAtNe(updatedAt time.Time) UserMemberExpireDelayQuerySet {
+	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
+}
+
+// SetCreatedAt is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetCreatedAt(createdAt time.Time) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.CreatedAt)] = createdAt
+	return u
+}
+
+// SetDailyFee is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetDailyFee(dailyFee uint32) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.DailyFee)] = dailyFee
+	return u
+}
+
+// SetDelayAmount is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetDelayAmount(delayAmount uint32) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.DelayAmount)] = delayAmount
+	return u
+}
+
+// SetDeletedAt is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetDeletedAt(deletedAt *time.Time) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.DeletedAt)] = deletedAt
+	return u
+}
+
+// SetExpireDays is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetExpireDays(expireDays uint32) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.ExpireDays)] = expireDays
+	return u
+}
+
+// SetID is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetID(ID uint32) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.ID)] = ID
+	return u
+}
+
+// SetIsPay is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetIsPay(isPay uint32) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.IsPay)] = isPay
+	return u
+}
+
+// SetMemberExpire is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetMemberExpire(memberExpire time.Time) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.MemberExpire)] = memberExpire
+	return u
+}
+
+// SetUid is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetUid(uid uint32) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.Uid)] = uid
+	return u
+}
+
+// SetUpdatedAt is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) SetUpdatedAt(updatedAt time.Time) UserMemberExpireDelayUpdater {
+	u.fields[string(UserMemberExpireDelayDBSchema.UpdatedAt)] = updatedAt
+	return u
+}
+
+// Update is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) Update() error {
+	return u.db.Updates(u.fields).Error
+}
+
+// UpdateNum is an autogenerated method
+// nolint: dupl
+func (u UserMemberExpireDelayUpdater) UpdateNum() (int64, error) {
+	db := u.db.Updates(u.fields)
+	return db.RowsAffected, db.Error
+}
+
+// ===== END of query set UserMemberExpireDelayQuerySet
+
+// ===== BEGIN of UserMemberExpireDelay modifiers
+
+// UserMemberExpireDelayDBSchemaField describes database schema field. It requires for method 'Update'
+type UserMemberExpireDelayDBSchemaField string
+
+// String method returns string representation of field.
+// nolint: dupl
+func (f UserMemberExpireDelayDBSchemaField) String() string {
+	return string(f)
+}
+
+// UserMemberExpireDelayDBSchema stores db field names of UserMemberExpireDelay
+var UserMemberExpireDelayDBSchema = struct {
+	ID           UserMemberExpireDelayDBSchemaField
+	CreatedAt    UserMemberExpireDelayDBSchemaField
+	UpdatedAt    UserMemberExpireDelayDBSchemaField
+	DeletedAt    UserMemberExpireDelayDBSchemaField
+	Uid          UserMemberExpireDelayDBSchemaField
+	MemberExpire UserMemberExpireDelayDBSchemaField
+	DelayAmount  UserMemberExpireDelayDBSchemaField
+	ExpireDays   UserMemberExpireDelayDBSchemaField
+	DailyFee     UserMemberExpireDelayDBSchemaField
+	IsPay        UserMemberExpireDelayDBSchemaField
+}{
+
+	ID:           UserMemberExpireDelayDBSchemaField("id"),
+	CreatedAt:    UserMemberExpireDelayDBSchemaField("created_at"),
+	UpdatedAt:    UserMemberExpireDelayDBSchemaField("updated_at"),
+	DeletedAt:    UserMemberExpireDelayDBSchemaField("deleted_at"),
+	Uid:          UserMemberExpireDelayDBSchemaField("uid"),
+	MemberExpire: UserMemberExpireDelayDBSchemaField("member_expire"),
+	DelayAmount:  UserMemberExpireDelayDBSchemaField("delay_amount"),
+	ExpireDays:   UserMemberExpireDelayDBSchemaField("expire_days"),
+	DailyFee:     UserMemberExpireDelayDBSchemaField("daily_fee"),
+	IsPay:        UserMemberExpireDelayDBSchemaField("is_pay"),
+}
+
+// Update updates UserMemberExpireDelay fields by primary key
+// nolint: dupl
+func (o *UserMemberExpireDelay) Update(db *gorm.DB, fields ...UserMemberExpireDelayDBSchemaField) error {
+	dbNameToFieldName := map[string]interface{}{
+		"id":            o.ID,
+		"created_at":    o.CreatedAt,
+		"updated_at":    o.UpdatedAt,
+		"deleted_at":    o.DeletedAt,
+		"uid":           o.Uid,
+		"member_expire": o.MemberExpire,
+		"delay_amount":  o.DelayAmount,
+		"expire_days":   o.ExpireDays,
+		"daily_fee":     o.DailyFee,
+		"is_pay":        o.IsPay,
+	}
+	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 UserMemberExpireDelay %v fields %v: %s",
+			o, fields, err)
+	}
+
+	return nil
+}
+
+// UserMemberExpireDelayUpdater is an UserMemberExpireDelay updates manager
+type UserMemberExpireDelayUpdater struct {
+	fields map[string]interface{}
+	db     *gorm.DB
+}
+
+// NewUserMemberExpireDelayUpdater creates new UserMemberExpireDelay updater
+// nolint: dupl
+func NewUserMemberExpireDelayUpdater(db *gorm.DB) UserMemberExpireDelayUpdater {
+	return UserMemberExpireDelayUpdater{
+		fields: map[string]interface{}{},
+		db:     db.Model(&UserMemberExpireDelay{}),
+	}
+}
+
+// ===== END of UserMemberExpireDelay modifiers
+
 // ===== BEGIN of query set UserOpenMemberRecordQuerySet
 
 // UserOpenMemberRecordQuerySet is an queryset type for UserOpenMemberRecord

model/game_card.go

@@ -204,6 +204,11 @@ const (
 	GameCardGoodsStatusCustomerHold = 3 // 客户持有
 )
 
+const (
+	GameCardGoodsTypeShare  = "user_share" // 用户共享
+	GameCardGoodsTypeCommon = "common"     // 公共
+)
+
 // gen:qs
 type GameCardGoods struct {
 	Model
@@ -212,6 +217,7 @@ type GameCardGoods struct {
 	Status       uint8  `json:"status"`                     // 状态:1-库存中 2-在途 3-客户持有
 	StoreId      uint64 `json:"store_id"`                   // 门店id
 	Provider     string `json:"provider"`                   // 供应商
+	CardType     string `json:"card_type" gorm:"index"`     //
 }
 
 func (*GameCardGoods) TableName() string {

model/model_test.go

@@ -104,9 +104,9 @@ func InitTestDB() {
 		&OrderCard{},
 		&UserRentCard{},
 		&UserConsumeRecord{},
-
+		&UserMemberExpireDelay{},
-
+		&UserShareCardBill{},
-
+		&ShareCardBillGame{},
 	)
 
 	fmt.Println("DB init success")
@@ -561,7 +561,6 @@ func MergingGameCards() {
 
 }
 
-
 func TestGoodsAdd(t *testing.T) {
 	GoodsAdd()
 }
@@ -877,7 +876,7 @@ func TestOrderCancelId(t *testing.T) {
 //		OutTradeNo:  outTradeNo,
 //		OutRefundNo: orderSn,
 //		NotifyUrl:   "",
-//		Amount: wxpay.OrderRefundAmount{
+//		Amount: wxpay.OrderRefundAmount{a
 //			Refund:   order.PayPrice,
 //			Total:    order.PayPrice,
 //			Currency: "CNY",
@@ -895,3 +894,43 @@ func TestOrderCancelId(t *testing.T) {
 //	}
 //}
 
+func TestGameCardGoodsStockInspection(t *testing.T) {
+	GameCardGoodsStockInspection()
+}
+
+func GameCardGoodsStockInspection() {
+	InitDBProd()
+
+	var gameCardGoodses []GameCardGoods
+	err := NewGameCardGoodsQuerySet(DBProd).StoreIdEq(16).All(&gameCardGoodses)
+	if err != nil {
+		logger.Error("err:", err)
+	}
+
+	rentMap := make(map[uint32]uint32, 0)
+	holdMap := make(map[uint32]uint32, 0)
+	for _, gameCard := range gameCardGoodses {
+		if gameCard.Status == 1 {
+			//rentMap[uint32(gameCard.StoreId)] += 1
+			rentMap[uint32(gameCard.GameCardId)] += 1
+		}
+		if gameCard.Status == 3 {
+			holdMap[uint32(gameCard.GameCardId)] += 1
+		}
+	}
+	var gameCardGoodsStocks []GameCardGoodsStock
+	err = NewGameCardGoodsStockQuerySet(DBProd).StoreIdEq(16).All(&gameCardGoodsStocks)
+	if err != nil {
+		logger.Error("err:", err)
+	}
+	for _, stock := range gameCardGoodsStocks {
+		rent := rentMap[uint32(stock.GameCardId)]
+		hold := holdMap[uint32(stock.GameCardId)]
+		//fmt.Println("StoreId:", stock.StoreId, "rent:", rent, stock.RentStock, "hold:", hold, stock.UserHoldStock)
+
+		if rent != stock.RentStock || hold != stock.UserHoldStock {
+			fmt.Println("StoreId:", stock.StoreId, "rent:", rent, stock.RentStock, "hold:", hold, stock.UserHoldStock, stock.GameCardId)
+		}
+	}
+
+}

model/order.go

@@ -151,7 +151,7 @@ func OrderCardListSetGameInfo(list []OrderCard) []OrderCard {
 		order, ok2 := orderMap[list[i].OrderId]
 		fmt.Printf("gameCard1:%#v \n", gameCard)
 		if ok1 && ok2 {
-			if order.CardStatus == 2|| order.CardStatus == 3 {
+			if order.CardStatus == 2 || order.CardStatus == 3 {
 				order.CardStatus = 4
 			}
 			fmt.Printf("gameCard2:%#v \n", gameCard)
@@ -491,7 +491,7 @@ func IsUserHaveUnreturnedOrder(uid uint32) (bool, error) {
 	fmt.Println("uid", uid)
 
 	//sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM `order` WHERE uid = %d AND pay_status IN (1,2) AND card_status IN (1,2,3) ;", uid)
-	sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM order_card WHERE uid = %d AND pay_status IN (1,2) AND card_status IN (1,2,3) ;", uid)
+	sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM order_card WHERE uid = %d AND pay_status IN (2) AND card_status IN (1,2,3) ;", uid)
 	//count, err := NewOrderQuerySet(DB).UidEq(uint64(uid)).PayStatusEq(PayStatusPaid).CardStatusIn(1, 2, 3).Count()
 	//if err != nil {
 	//	logger.Error("err:", err)

model/share_card.go

@@ -0,0 +1,148 @@
+package model
+
+import (
+	"github.com/codinl/go-logger"
+	"time"
+)
+
+//go:generate goqueryset -in share_card.go
+// gen:qs
+type UserShareCardBill struct {
+	Model
+	Uid              uint32    `json:"uid" gorm:"index"`
+	BillSn           string    `json:"bill_sn" gorm:"index"`
+	State            string    `json:"state" gorm:"index"`
+	SendCardType     uint32    `json:"send_card_type"`        // 1-送卡 2-邮寄
+	StoreId          uint32    `json:"store_id" gorm:"index"` // 门店id
+	ExpressCompany   string    `json:"express_company"`       // 物流公司
+	ExpressCompanyNo string    `json:"express_company_no"`    // 物流公司编号
+	ExpressNo        string    `json:"express_no"`            // 物流单号
+	SendCardTime     time.Time `json:"send_card_time"`        // 递送卡时间
+	StockTime        time.Time `json:"stock_time"`            // 入库时间
+	RetrieveTime     time.Time `json:"retrieve_time"`         // 收回卡时间 申请收回
+	StockRemovalTime time.Time `json:"stock_removal_time"`    // 出库时间
+	Store            Store     `json:"store" gorm:"-"`        // 门店
+
+	BillGames []ShareCardBillGame `json:"bill_games" gorm:"-"`
+}
+
+// gen:qs
+type ShareCardBillGame struct {
+	Model
+	UserShareCardBillId uint32   `json:"user_share_card_bill_id" gorm:"index"`
+	Uid                 uint32   `json:"uid" gorm:"index"`
+	GameCardId          uint32   `json:"game_card_id" gorm:"index"`
+	BillSn              string   `json:"bill_sn" gorm:"index"`
+	Count               uint32   `json:"count"`
+	State               string   `json:"state" gorm:"index"`
+	GameCard            GameCard `json:"game_card" gorm:"-"` //
+}
+
+const (
+	ShareCardBillStateInCheck    = "in_check"     // 待审核
+	ShareCardBillStateInSendCard = "in_send_card" // 待递送卡
+	ShareCardBillStateCompleted  = "completed"    // 完成
+	ShareCardBillStateCancel     = "cancel"       // 取消
+	ShareCardBillStateAuditLose  = "check_lose"   // 审核失败
+)
+
+const (
+	ShareCardStateInCheck    = "in_check"     // 待审核
+	ShareCardStateInSendCard = "in_send_card" // 待递送卡
+	ShareCardStateSharing    = "sharing"      // 共享中
+	ShareCardStateAuditLose  = "check_lose"   // 审核失败
+	ShareCardStateCancel     = "cancel"       // 取消
+)
+
+// gen:qs
+type UserShareCard struct {
+	Model
+	Uid                 uint32 `json:"uid" gorm:"index"`
+	SerialNumber        string `json:"serial_number" gorm:"index"` // 编号
+	BillSn              string `json:"bill_sn" gorm:"index"`
+	GameCardId          uint32 `json:"game_card_id" gorm:"index"`
+	State               string `json:"state" gorm:"index"`
+	GameCardGoodsId     uint32 `json:"game_card_goods_id" gorm:"index"`
+	UserShareCardBillId uint32 `json:"user_share_card_bill_id"  gorm:"index"`
+	ShareCardBillGameId uint32 `json:"share_card_bill_game_id"  gorm:"index"`
+}
+
+//type UserShareCardBillInfo struct {
+//	GameCardId uint32 `json:"game_card_id"`
+//	Count      uint32 `json:"count"`
+//}
+
+func GetUserShareCardBillList(uid uint32, page, pageSize int) ([]UserShareCardBill, int, error) {
+	page = page - 1
+	if page < 0 {
+		page = 0
+	}
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	var shareCardBills []UserShareCardBill
+	qs := NewUserShareCardBillQuerySet(DB).UidEq(uid)
+
+	count, err := qs.Count()
+	if err != nil {
+		logger.Error("user share card bill count err:", err)
+		return shareCardBills, 0, err
+	}
+	totalPage := count/pageSize + 1
+	err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCardBills)
+	if err != nil && err != RecordNotFound {
+		logger.Error("user share card bill err:", err)
+		return shareCardBills, 0, err
+	}
+	if len(shareCardBills) == 0 {
+		return shareCardBills, 0, nil
+	}
+	shareCardBills = UserShareCardBillListSetGame(shareCardBills)
+	return shareCardBills, totalPage, nil
+}
+
+func UserShareCardBillListSetGame(list []UserShareCardBill) []UserShareCardBill {
+	billIds := make([]uint32, 0, len(list))
+	for i, _ := range list {
+		billIds = append(billIds, list[i].ID)
+	}
+	if len(billIds) == 0 {
+		return list
+	}
+	billMap := make(map[uint32][]ShareCardBillGame, 0)
+	var games []ShareCardBillGame
+	err := NewShareCardBillGameQuerySet(DB).UserShareCardBillIdIn(billIds...).All(&games)
+	if err != nil && err != RecordNotFound {
+		logger.Error("share card bill  err:", err)
+		return list
+	}
+	gameIds := make([]uint32, 0, len(games))
+	for i, _ := range games {
+		gameIds = append(gameIds, games[i].GameCardId)
+	}
+	cardMap, err := GameCardMap(gameIds)
+	for i, _ := range games {
+		v, ok := cardMap[games[i].GameCardId]
+		if ok {
+			games[i].GameCard = v
+		}
+	}
+
+	for i, _ := range games {
+		billMap[games[i].UserShareCardBillId] = append(billMap[games[i].UserShareCardBillId], games[i])
+	}
+
+	if err != nil {
+		logger.Error("game card map  err:", err)
+		return list
+	}
+
+	for i, _ := range list {
+		v, ok := billMap[list[i].ID]
+		if ok {
+			list[i].BillGames = v
+		}
+	}
+
+	return list
+}

model/user.go

@@ -39,7 +39,7 @@ type User struct {
 	InBlack        bool      `json:"in_black"`                  // 是否在黑名单
 	StoreType      uint8     `json:"store_type"`                // 1-订单门店
 	Version        uint32    `json:"-"`
-	UserVm *UserVm `json:"user_vm" gorm:"-"` //
+	UserVm         *UserVm   `json:"user_vm" gorm:"-"` //
 }
 
 func (o *User) TableName() string {
@@ -59,7 +59,10 @@ const (
 	MemberLevelBlackGold = 5 // 黑金会员
 )
 
-const DateTimeFormat = "2006-01-02"
+const (
+	DateTimeFormat = "2006-01-02"
+	TimeFormat     = "2006-01-02 15:04:05"
+)
 
 // gen:qs
 type UserInvite struct {
@@ -82,6 +85,9 @@ const (
 	DepositRefundStatusRefunded    = 3 // 已退款
 	DepositRefundStatusRefused     = 4 // 已拒绝
 )
+const (
+	MemberExpireDelayDailyFee = 200
+)
 
 // gen:qs
 type DepositRefundRecord struct {
@@ -128,6 +134,18 @@ type UserRentCard struct {
 	Status         uint32 `json:"status"`           // 状态
 }
 
+// gen:qs
+type UserMemberExpireDelay struct {
+	Model
+
+	Uid          uint32    `json:"uid" gorm:"column:uid;index"`
+	MemberExpire time.Time `json:"member_expire"` // 会员到期时间
+	DelayAmount  uint32    `json:"delay_amount"`
+	ExpireDays   uint32    `json:"expire_days"`
+	DailyFee     uint32    `json:"daily_fee"`
+	IsPay        uint32    `json:"is_pay"`
+}
+
 func GetUserByUid(uid uint32) *User {
 	user := new(User)
 	if err := NewUserQuerySet(DB).UidEq(uid).One(user); err != nil {
@@ -186,7 +204,7 @@ type UserOpenMemberRecord struct {
 	Uid          uint32    `json:"uid"`
 	OpenNo       string    `json:"open_no" gorm:"index"`
 	OrderId      uint32    `json:"order_id"`
-	OrderType    uint32    `json:"order_type"` // 1-物流支付 2-取消物流租卡
+	OrderType    uint32    `json:"order_type"` // 1-物流支付 2-取消物流租卡 3-滞纳金
 	MemberLevel  uint32    `json:"member_level"`
 	MemberExpire time.Time `json:"member_expire"` // 会员到期时间
 }
@@ -390,6 +408,21 @@ func GetOrderSn() string {
 	return orderSn
 }
 
+func GetShareCardBillSn() string {
+	var billSn string
+	for {
+		billSn = utils.GetSerialNo32HEXString()
+		count, err := NewUserShareCardBillQuerySet(DB).BillSnEq(billSn).Count()
+		if err != nil {
+			logger.Error("err:", err)
+		}
+		if count == 0 {
+			break
+		}
+	}
+	return billSn
+}
+
 func (m *User) Edit() {
 	err := DB.Save(m).Error
 	if err != nil {
@@ -551,5 +584,68 @@ func CreateUserRentCardByMemberLevel(uid, memberLevel, cardMax uint32) {
 	if err != nil {
 		logger.Error("update err:", err)
 	}
-
+}
+
+func MemberExpireDelaying(uid uint32) (map[string]interface{}, error) {
+	ret := make(map[string]interface{}, 0)
+	ret["is_surrender"] = 0
+	ret["expire_days"] = 0
+	ret["daily_fee"] = MemberExpireDelayDailyFee
+	ret["delay_amount"] = 0
+	var user User
+	err := NewUserQuerySet(DB).UidEq(uid).One(&user)
+	if err != nil {
+		logger.Error("user err:", err)
+		return ret, err
+	}
+	var userMemberExpireDelay UserMemberExpireDelay
+	err = NewUserMemberExpireDelayQuerySet(DB).UidEq(uid).MemberExpireEq(user.MemberExpire).One(&userMemberExpireDelay)
+	if err != nil && err != RecordNotFound {
+		logger.Error("user member expire delay err:", err)
+		return ret, err
+	}
+	if err == nil {
+		if userMemberExpireDelay.IsPay != 1 {
+			ret["is_surrender"] = 1
+			ret["expire_days"] = userMemberExpireDelay.ExpireDays
+			ret["daily_fee"] = userMemberExpireDelay.DailyFee
+			ret["delay_amount"] = userMemberExpireDelay.DelayAmount
+		}
+		return ret, nil
+	}
+	var orderCard OrderCard
+	err = NewOrderCardQuerySet(DB).UidEq(uid).CardStatusIn([]uint32{1, 2, 3, 4}...).OrderDescByOrderId().One(&orderCard)
+	if err != nil {
+		logger.Error("order card err:", err)
+		return ret, err
+	}
+	deadline := orderCard.RevertTime
+	if orderCard.CardStatus != 4 {
+		deadline = time.Now()
+	}
+	if user.MemberLevel == 3 {
+		deadline = time.Unix(1647925200, 0)
+	}
+
+	if user.MemberExpire.AddDate(0, 0, 1).Before(deadline) {
+		days := (deadline.Unix() - user.MemberExpire.Unix()) / 24 / 3600
+		if user.MemberLevel != 3 || (user.MemberLevel == 3 && days > 7) {
+			ret["is_surrender"] = 1
+			ret["expire_days"] = days
+			ret["delay_amount"] = days * MemberExpireDelayDailyFee
+			delay := &UserMemberExpireDelay{
+				Uid:          uid,
+				MemberExpire: user.MemberExpire,
+				DelayAmount:  uint32(days) * MemberExpireDelayDailyFee,
+				ExpireDays:   uint32(days),
+				DailyFee:     MemberExpireDelayDailyFee,
+				IsPay:        0,
+			}
+			err := delay.Create(DB)
+			if err != nil {
+				logger.Error("delay create err:", err)
+			}
+		}
+	}
+	return ret, nil
 }

router/router_app.go

@@ -80,6 +80,8 @@ func ConfigAppRouter(r gin.IRouter) {
 		user.POST("pay_deposit", controller.PayDeposit)                            // 支付押金
 		user.POST("refund_deposit", controller.RefundDeposit)                      // 退押金
 		user.POST("refund_deposit_record", controller.UserDepositRefundRecordList) // 押金记录
+		user.POST("expire_delay", controller.UserMemberExpireDelayingInfo)         // 滞纳金详情
+		user.POST("expire_delay_pay", controller.UserMemberExpireDelayingPay)      // 滞纳金支付
 
 		user.POST("member_config", controller.MemberConfigList) // 开通会员配置
 
@@ -128,12 +130,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)                            // TODO
+		order.Use(auth.UserAccessAuth)                                    // TODO
-		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) // 订单确认收货
@@ -182,5 +184,13 @@ func ConfigAppRouter(r gin.IRouter) {
 		shoppingCart.POST("del", controller.ShoppingCartDel)   //
 
 	}
+	shareCard := api.Group("share_card")
+	{
+		shareCard.Use(auth.UserAccessAuth)
+		shareCard.POST("bill/list", controller.UserShareCardBillList)  // 详情
+		shareCard.POST("bill/add", controller.UserShareCardBillCreate) //
+		//shoppingCart.POST("del", controller.ShoppingCartDel)   //
+
+	}
 
 }