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

fix:会员共享卡

Browse Source
This commit is contained in:
li 2022-03-26 11:25:15 +08:00
parent 5307a67bb4
commit 60d0bcb8b0
13 changed files with 4902 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
controller/game_card.go
View File

@ -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("微信推动支付通知")

71
controller/mall.go
View File

@ -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()

124
controller/user.go
View File

@ -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()
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
resp, err := model.MemberExpireDelaying(uc.Uid)
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会员 升级
// 订单 会员导数据
// 退押金记录
// 订单 会员导数据
// 退押金记录

108
controller/user_share_card.go Normal file
View File

@ -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
}

11
lib/wxpay/wx_pay.go
View File

@ -34,11 +34,12 @@ const (
//wxPayNotifyUrl = "api/v1/wxpay/notice"
wxPayNotifyUrl = "/api/v1/wxpay/notice"
WxPayMember = "member_pay" // 会员
WxPayRentCard = "rent_card_pay" // 租卡
WxPayDeposit = "deposit_pay" // 押金
WxPayExchangeGoods = "exchange_goods" // 兑换商品
WxPayUpgradeMember = "upgrade_member" // 多级会员
WxPayMember = "member_pay" // 会员
WxPayRentCard = "rent_card_pay" // 租卡
WxPayDeposit = "deposit_pay" // 押金
WxPayExchangeGoods = "exchange_goods" // 兑换商品
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 测试

3397
model/autogenerated_share_card.go Normal file
View File

File diff suppressed because it is too large Load Diff

886
model/autogenerated_user.go
View File

@ -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

6
model/game_card.go
View File

@ -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 {

49
model/model_test.go
View File

@ -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)
}
}
}

4
model/order.go
View File

@ -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)

148
model/share_card.go Normal file
View File

@ -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
}

104
model/user.go
View File

@ -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
}

22
router/router_app.go
View File

@ -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.POST("create", controller.RentCardOrderCreate) // 创建租卡
order.POST("pay", controller.OrderPay) // 租卡订单支付
order.POST("list", controller.RentCardOrderList) // 租卡订单列表
order.POST("revert", controller.OrderRevert) // 租卡订单归还
order.POST("revert/cancel", controller.OrderRevertCancel) // 取消归还
order.Use(auth.UserAccessAuth) // TODO
order.POST("create", controller.RentCardOrderCreate) // 创建租卡
order.POST("pay", controller.OrderPay) // 租卡订单支付
order.POST("list", controller.RentCardOrderList) // 租卡订单列表
order.POST("revert", controller.OrderRevert) // 租卡订单归还
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) //
}
}