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

feat:运费包

Browse Source
This commit is contained in:
li 2022-09-29 15:49:16 +08:00
parent 443cda8e04
commit c4d5ac06d8
16 changed files with 2787 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cmd/server.go
View File

@ -7,7 +7,6 @@ import (
"github.com/spf13/cobra"
"mh-server/config"
"mh-server/lib/auth"
//"mh-server/lib/sms"
"mh-server/lib/utils"
"mh-server/model"
"mh-server/router"
@ -18,7 +17,7 @@ func runServer() {
gin.SetMode(gin.DebugMode)
router.ConfigAppRouter(server)
//OrderCancelId()
err := server.Run(fmt.Sprintf(":%d", config.AppConfig.ServerPort))
if err != nil {
logger.Error(err)

189
controller/activity.go
View File

@ -1,12 +1,14 @@
package controller
import (
"errors"
"fmt"
"github.com/codinl/go-logger"
"github.com/gin-gonic/gin"
"mh-server/lib/auth"
"mh-server/lib/status"
"mh-server/lib/utils"
"mh-server/lib/wxpay"
"mh-server/model"
"time"
)
@ -81,7 +83,8 @@ func UserMemberRenewalState(c *gin.Context) {
if err == model.RecordNotFound || uint32(user.MemberExpire.Unix()) != activityMemberRenewal.MemberSerial {
//if user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0)) &&
// user.MemberExpire.After(utils.Now()) {
if user.MemberExpire.Before(utils.Now().AddDate(0, 0, model.GetActivityRenewalConfig().PopTrap)) {
if user.MemberExpire.Before(utils.Now().AddDate(0, 0,
model.GetActivityRenewalConfig().PopTrap)) {
activityMemberRenewal = model.ActivityMemberRenewal{
ActivityId: 1,
Uid: uc.Uid,
@ -114,7 +117,8 @@ func UserMemberRenewalState(c *gin.Context) {
isPop = false
}
}
if activityMemberRenewal.StartTime.AddDate(0, 0, model.GetActivityRenewalConfig().ActivityContinuity).Before(utils.Now()) {
if activityMemberRenewal.StartTime.AddDate(0, 0,
model.GetActivityRenewalConfig().ActivityContinuity).Before(utils.Now()) {
activityMemberRenewal.State = 3
_, err = model.NewActivityMemberRenewalQuerySet(model.DB).IDEq(activityMemberRenewal.ID).GetUpdater().
SetState(3).UpdateNum()
@ -322,6 +326,187 @@ func UserMemberRenewalCouponDraw(c *gin.Context) {
return
}
func PostagePackageBuy(c *gin.Context) {
//req := struct {
//}{}
//if err := c.ShouldBindJSON(&req); err != nil {
// logger.Error(err)
// RespJson(c, status.BadRequest, nil)
// return
//}
uc := auth.GetCurrentUser(c)
if uc == nil {
RespJson(c, status.Unauthorized, nil)
return
}
//uc = new(auth.UserClaims)
//uc.Uid = 14531402
user := model.GetUserByUid(uc.Uid)
if user == nil {
logger.Error("user is nil")
RespJson(c, status.InternalServerError, nil)
return
}
if !user.IsMember() || user.MemberExpire.Before(time.Now()) {
logger.Error("user not member")
RespJson(c, status.NotMember, nil)
return
}
info, err := model.PostagePackageFeeConfigInfo()
if err != nil {
logger.Error("postage package fee err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
orderSn := model.GetOrderSn()
err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, MemberLevel: user.MemberLevel,
OrderType: 11, UserCouponId: 0}.Insert()
if err != nil {
logger.Error(errors.New("web pay err"))
RespJson(c, status.InternalServerError, nil)
return
}
configInfo, err := model.PayConfigInfo()
if err != nil {
logger.Error(err)
RespJson(c, status.InternalServerError, nil)
return
}
webPay, err := wxpay.WebPay(orderSn, info.PostagePackageFee, user.WxOpenID, "N", wxpay.WxPayPostagePackage, configInfo.NotifyUrl)
if err != nil {
logger.Error(errors.New("web pay err"))
RespJson(c, status.InternalServerError, nil)
return
}
go func() {
action, err := model.IsFirstUserAction(uc.Uid, 2)
if err != nil {
logger.Error("user action exist err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
first := uint32(0)
if !action {
first = 1
}
log := &model.UserActionLog{
Uid: uc.Uid,
ActionType: 2,
First: first,
}
err = model.DB.Create(log).Error
if err != nil {
logger.Error("create user action log err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
}()
tips := fmt.Sprintf("支付成功，会员已延长%d天", model.GetPostagePackageMemberDuration(user.MemberLevel))
ret := map[string]interface{}{
"web_pay": webPay,
"tip": tips,
}
RespOK(c, ret)
return
}
func UserCouponList(c *gin.Context) {
req := struct {
PageIdx int `json:"page_idx"`
PageSize int `json:"page_size"`
ActivityType uint32 `json:"activity_type"` // 活动类型 1-会员续费 2-关注公众号 3-运费包
}{}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(err)
RespJson(c, status.BadRequest, nil)
return
}
uc := auth.GetCurrentUser(c)
if uc == nil {
logger.Error("uc is nil")
RespJson(c, status.Unauthorized, nil)
return
}
//uc = &auth.UserClaims{Uid: 87564738}
page := req.PageIdx - 1
if page < 0 {
page = 0
}
if req.PageSize == 0 {
req.PageSize = 10
}
qs := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).StateEq(1)
if req.ActivityType != 0 {
qs = qs.ActivityTypeEq(3)
}
count, err := qs.Count()
if err != nil {
logger.Error("count err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
totalPage := count/req.PageSize + 1
var coupons []model.UserCoupon
err = qs.OrderAscByID().Offset(page * req.PageSize).Limit(req.PageSize).All(&coupons)
if err != nil && err != model.RecordNotFound {
logger.Error(err)
RespJson(c, status.InternalServerError, nil)
return
}
ret := map[string]interface{}{
"list": coupons,
"total_page": totalPage,
"page_idx": req.PageIdx,
}
RespOK(c, ret)
return
}
func PostagePackageInfo(c *gin.Context) {
//req := struct {
//}{}
//if err := c.ShouldBindJSON(&req); err != nil {
// logger.Error(err)
// RespJson(c, status.BadRequest, nil)
// return
//}
uc := auth.GetCurrentUser(c)
if uc == nil {
logger.Error("uc is nil")
RespJson(c, status.Unauthorized, nil)
return
}
action, err := model.IsFirstUserAction(uc.Uid, 1)
if err != nil {
logger.Error("user action exist err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
first := uint32(0)
if !action {
first = 1
}
log := model.UserActionLog{
Uid: uc.Uid,
ActionType: 1,
First: first,
}
err = model.DB.Create(log).Error
if err != nil {
logger.Error("create user action log err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
RespOK(c, nil)
return
}
func MemberRenewalUserCouponList(c *gin.Context) {
req := struct {
PageIdx int `json:"page_idx"`

168
controller/game_card.go
View File

@ -344,13 +344,31 @@ func PushWXPayNotice(c *gin.Context) {
if err != nil {
begin.Rollback()
logger.Error("err:", err)
// 库存不足取消订单
orderSn := model.GetOrderSn()
memberRecord := &model.UserOpenMemberRecord{OpenNo: orderSn, OrderType: 2, Order: &order}
err = memberRecord.OrderRefund(notifyInfo.OutTradeNo)
if err != nil {
logger.Error("err:", err)
return
if order.PostageType == 1 {
// 库存不足取消订单
orderSn := model.GetOrderSn()
memberRecord := &model.UserOpenMemberRecord{OpenNo: orderSn, OrderType: 2, Order: &order}
err = memberRecord.OrderRefund(notifyInfo.OutTradeNo)
if err != nil {
logger.Error("err:", err)
return
}
}
// TODO
if order.PostageType == 2 {
var userCoupon model.UserCoupon
err = model.NewUserCouponQuerySet(model.DB).ActivityTypeEq(3).UidEq(uint32(order.Uid)).
StateEq(2).OrderAscByID().Limit(1).One(&userCoupon)
if err != nil && err != model.RecordNotFound {
logger.Error("user coupon err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
err = model.NewUserCouponQuerySet(model.DB).IDEq(userCoupon.ID).GetUpdater().SetState(1).Update()
if err != nil {
logger.Error("user coupon err:", err)
}
}
//err = model.UserOpenMemberRecord{Uid: uint32(order.Uid), OpenNo: orderSn, OrderId: order.ID, OrderType: 2}.Insert()
@ -409,7 +427,9 @@ func PushWXPayNotice(c *gin.Context) {
fundRecord.FundType = model.FundTypeExpressFee
fundRecord.Remark = "借卡邮费"
} else if notifyInfo.Attach == wxpay.WxPayMember {
}
if notifyInfo.Attach == wxpay.WxPayMember {
logger.Info("开通会员 支付成功:")
logger.Info("用户uid:", notifyInfo.OutTradeNo)
@ -643,7 +663,9 @@ func PushWXPayNotice(c *gin.Context) {
fmt.Println("notify.TotalFee:", notifyInfo.TotalFee)
fmt.Println("notify.OutTradeNo:", notifyInfo.OutTradeNo)
} else if notifyInfo.Attach == wxpay.WxPayDeposit {
}
if notifyInfo.Attach == wxpay.WxPayDeposit {
record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
err := record.GetByOpenNo()
if err != nil {
@ -694,7 +716,9 @@ func PushWXPayNotice(c *gin.Context) {
logger.Error("update user open member record state:err", err)
}
//}
} else if notifyInfo.Attach == wxpay.WxPayBuyGoods {
}
if notifyInfo.Attach == wxpay.WxPayBuyGoods {
_, err = model.NewGoodsOrderQuerySet(model.DB).SerialNoEq(notifyInfo.OutTradeNo).GetUpdater().
SetPayTime(time.Now()).
SetPayStatus(model.PayStatusOK).
@ -732,7 +756,9 @@ func PushWXPayNotice(c *gin.Context) {
fundRecord.Uid = uint32(goodsOrder.Uid)
fundRecord.FundType = model.FundTypeBuyGoods
fundRecord.Remark = "商城购买"
} else if notifyInfo.Attach == wxpay.WxPayUpgradeMember {
}
if notifyInfo.Attach == wxpay.WxPayUpgradeMember {
record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
err := record.GetByOpenNo()
if err != nil {
@ -828,7 +854,9 @@ func PushWXPayNotice(c *gin.Context) {
fundRecord.Uid = uint32(record.Uid)
fundRecord.FundType = model.FundTypeUpgradeMember
fundRecord.Remark = "升级会员"
} else if notifyInfo.Attach == wxpay.WxPayMemberExpireDelay {
}
if notifyInfo.Attach == wxpay.WxPayMemberExpireDelay {
record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
err := record.GetByOpenNo()
if err != nil {
@ -847,8 +875,8 @@ func PushWXPayNotice(c *gin.Context) {
return
}
_, err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(record.Uid).MemberExpireEq(user.MemberExpire).GetUpdater().
SetIsPay(1).UpdateNum()
_, err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(record.Uid).MemberExpireEq(user.MemberExpire).
GetUpdater().SetIsPay(1).UpdateNum()
if err != nil {
logger.Error("err:", err)
return
@ -860,7 +888,9 @@ func PushWXPayNotice(c *gin.Context) {
fundRecord.Uid = uint32(record.Uid)
fundRecord.FundType = model.FundTypeMemberExpireDelay
fundRecord.Remark = "会员过期滞纳金"
} else if notifyInfo.Attach == wxpay.WxPayShareCardRetrieve {
}
if notifyInfo.Attach == wxpay.WxPayShareCardRetrieve {
record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
err := record.GetByOpenNo()
if err != nil {
@ -916,6 +946,114 @@ func PushWXPayNotice(c *gin.Context) {
fundRecord.Remark = "共享卡收回卡快递费"
}
if notifyInfo.Attach == wxpay.WxPayPostagePackage {
record := &model.UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
err := record.GetByOpenNo()
if err != nil {
logger.Error("err:", err)
}
if record.State == 2 {
ret.ReturnCode = "SUCCESS"
RespBodyXML(c, ret)
return
}
var activity model.Activity
err = model.NewActivityQuerySet(model.DB).IDEq(3).One(&activity)
if err != nil {
logger.Error("coupon err:", err)
return
}
var coupon model.Coupon
err = model.NewCouponQuerySet(model.DB).ActivityTypeEq(activity.ActivityType).One(&coupon)
if err != nil {
logger.Error("coupon err:", err)
ret.ReturnCode = "Error"
RespBodyXML(c, ret)
return
}
defer func() {
if err := recover(); err != nil {
logger.Error("err:", err)
}
}()
//info, err := model.PostagePackageFeeConfigInfo()
//if err != nil {
// logger.Error("postage package fee config err")
// ret.ReturnCode = "Error"
// RespBodyXML(c, ret)
// return
//}
//originalMemberConfig, err := model.GetMemberConfig(record.MemberLevel)
//if err != nil {
// logger.Error("err:", err)
// ret.ReturnCode = "Error"
// RespBodyXML(c, ret)
// return
//}
//days := (info.PostagePackageFee * 365) / originalMemberConfig.MemberFee
user := model.GetUserByUid(record.Uid)
days := model.GetPostagePackageMemberDuration(user.MemberLevel)
durationRecord := &model.UserMemberDurationRecord{
Uid: record.Uid,
Duration: days,
EventType: 1,
MemberLevel: record.MemberLevel,
}
nowTime := time.Now()
go func() {
begin := model.DB.Begin()
for i := 0; i < 10; i++ {
userCoupon := &model.UserCoupon{
Uid: record.Uid,
CouponId: coupon.ID,
CouponType: coupon.CouponType,
ActivityType: activity.ActivityType,
ActivityId: activity.ID,
Value: coupon.Value,
State: 1,
ActiveStart: nowTime,
ActiveEnd: nowTime.AddDate(10, 0, 0),
MemberLevel: record.MemberLevel,
}
err = begin.Create(userCoupon).Error
if err != nil {
begin.Rollback()
logger.Error("user coupon err:", err)
return
}
}
memberExpire := user.MemberExpire.AddDate(0, 0, int(days))
err := model.NewUserQuerySet(begin).UidEq(record.Uid).GetUpdater().SetMemberExpire(memberExpire).Update()
if err != nil {
begin.Rollback()
logger.Error("update member expire err:", err)
return
}
err = begin.Create(durationRecord).Error
if err != nil {
logger.Error("create duration record err:", err)
return
}
err = begin.Commit().Error
if err != nil {
begin.Rollback()
logger.Error("commit err:", err)
return
}
}()
fundRecord.Uid = uint32(record.Uid)
fundRecord.FundType = model.FundTypePostagePackageFee
fundRecord.Remark = "购买运费包"
}
fundRecord.Amount = int64(notifyInfo.TotalFee)
fundRecord.TransactionId = notifyInfo.TransactionId
fundRecord.OutTradeNo = notifyInfo.OutTradeNo

136
controller/order.go
View File

@ -160,10 +160,6 @@ var orderCreateLocker sync.Mutex
// 创建订单
func RentCardOrderCreate(c *gin.Context) {
//type Goods struct {
// Price uint32 `json:"price"`
//}
req := struct {
GameCardList []model.CardInfo `json:"game_card_list"`
StoreId uint32 `json:"store_id"`
@ -171,6 +167,7 @@ func RentCardOrderCreate(c *gin.Context) {
Price uint32 `json:"price"`
DeliveryType uint8 `json:"delivery_type"` // 取货方式
ExpressFee uint32 `json:"express_fee"`
UserCouponId uint32 `json:"user_coupon_id"`
}{}
bodyString, err := ioutil.ReadAll(c.Request.Body)
@ -191,24 +188,16 @@ func RentCardOrderCreate(c *gin.Context) {
RespJson(c, status.InternalServerError, nil)
return
}
//if err := c.ShouldBindJSON(&req);err != nil {
// logger.Error(err)
// RespJson(c,status.BadRequest,nil)
// return
//}
fmt.Println("商品下单 req:", req)
//uc := &struct {
// Uid uint32 `json:"uid"`
//}{}
uc := auth.GetCurrentUser(c)
if uc == nil {
logger.Error("uc is nil")
RespJson(c, status.BadRequest, nil)
return
}
//uc.Uid = 62389201
user := model.GetUserByUid(uc.Uid)
if user == nil {
logger.Error(errors.New("GetUserByUid err"))
@ -228,8 +217,7 @@ func RentCardOrderCreate(c *gin.Context) {
RespJson(c, status.InternalServerError, nil)
return
}
//fmt.Println("Deposit:", user.Deposit)
//fmt.Println("MemberDeposit:", memberConfig.MemberDeposit)
if user.Deposit != memberConfig.MemberDeposit {
logger.Error(errors.New("user deposit 0"))
RespJson(c, status.OrderUnpaidDeposit, nil)
@ -240,16 +228,15 @@ func RentCardOrderCreate(c *gin.Context) {
for _, v := range req.GameCardList {
cardCount += v.Count
}
//fmt.Println("cardCount:", cardCount)
rentCard := model.GetUserRentCard(uc.Uid)
if rentCard == nil {
//logger.Error(errors.New("GetUserByUid err"))
//RespJson(c, status.InternalServerError, nil)
//return
//fmt.Println("CardMax", memberConfig.CardMax)
rentCard = &model.UserRentCard{LevelRentCount: memberConfig.CardMax, CanRentCount: memberConfig.CardMax}
}
//fmt.Println("rentCard", rentCard.CanRentCount)
if uc.Uid == 15304136 || uc.Uid == 45935373 {
rentCard.CanRentCount -= 1
}
@ -317,6 +304,21 @@ func RentCardOrderCreate(c *gin.Context) {
Postage: req.ExpressFee,
CooperativeBusinessId: store.CooperativeBusinessId,
CooperativeName: store.CooperativeName,
PostageType: 1,
}
var userCoupon model.UserCoupon
//err = model.NewUserCouponQuerySet(model.DB).ActivityTypeEq(3).UidEq(uc.Uid).StateEq(1).
// OrderAscByID().Limit(1).One(&userCoupon)
err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&userCoupon)
if err != nil && err != model.RecordNotFound {
logger.Error("user coupon err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if err == nil && userCoupon.Uid == uc.Uid &&
userCoupon.State == 1 && userCoupon.ActivityType == 3 {
req.Price = 0
order.PostageType = 2
}
// 以支付成功作为订单下单成功的依据，不是订单创建 已修改
@ -396,6 +398,15 @@ func RentCardOrderCreate(c *gin.Context) {
RespJson(c, status.InternalServerError, nil)
return
}
if userCoupon.ID != 0 {
err = model.NewUserCouponQuerySet(tx).IDEq(userCoupon.ID).GetUpdater().SetState(2).Update()
if err != nil {
tx.Rollback()
logger.Error("update user coupon state err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
}
err = tx.Commit().Error
if err != nil {
tx.Rollback()
@ -463,7 +474,7 @@ func RentCardOrderCreate(c *gin.Context) {
}
//orderId := fmt.Sprintf("%d", order.ID)
////orderId = "100000"
//orderId = "100000"
//fmt.Println("orderId", orderId)
//fmt.Println("Price", req.Price)
//fmt.Println("WxOpenID", user.WxOpenID)
@ -669,6 +680,7 @@ func OrderAmount(c *gin.Context) {
StoreId uint32 `json:"store_id" binding:"required"`
UserAddressId uint32 `json:"user_address_id" binding:"required"`
Price uint32 `json:"price" `
UserCouponId uint32 `json:"user_coupon_id"`
}{}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error("ShouldBindJSON err:", err)
@ -676,6 +688,13 @@ func OrderAmount(c *gin.Context) {
return
}
uc := auth.GetCurrentUser(c)
if uc == nil {
logger.Error("uc is nil")
RespJson(c, status.Unauthorized, nil)
return
}
var (
eg errgroup.Group
userAddress = &model.UserAddress{}
@ -706,16 +725,47 @@ func OrderAmount(c *gin.Context) {
RespJson(c, status.InternalServerError, nil)
return
}
//model.UserCoupon{}
expressFee := model.ExpressFeeProvince
//if userAddress.Province != "广东省" {
if userAddress.Province != store.Province {
expressFee = model.ExpressFeeOutsideProvince
}
hasPostagePackage := 0
if req.UserCouponId != 0 {
var userCoupon model.UserCoupon
err := model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&userCoupon)
if err != nil {
logger.Error("user coupon err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if userCoupon.State == 1 && userCoupon.ActivityType == 3 && userCoupon.Uid == uc.Uid {
expressFee = 0
}
} else {
exist, err := model.QueryRecordExist(fmt.Sprintf("SELECT * FROM user_coupon WHERE uid=%d AND activity_type=3 AND state=1", uc.Uid))
if err != nil {
logger.Error("user coupon err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if !exist {
err := model.DB.Exec("UPDATE statistic SET count=count+1 WHERE event_type=1").Error
if err != nil {
logger.Error("update statistic err:", err)
}
hasPostagePackage = 1
}
}
hasPostagePackage = 1
ret := map[string]interface{}{
"total_amount": req.Price + uint32(expressFee),
"express_fee": expressFee,
"total_amount": req.Price + uint32(expressFee),
"express_fee": expressFee,
"has_postage_package": hasPostagePackage,
}
RespOK(c, ret)
return
@ -911,21 +961,37 @@ func OrderCancel(c *gin.Context) {
order = orderInfo
fmt.Println("order:", order)
if isRecede {
outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(order.ID)
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
//m.OpenNo = model.GetOrderSn()
memberRecord := &model.UserOpenMemberRecord{OpenNo: model.GetOrderSn(), OrderType: 2, Order: &order}
err = memberRecord.OrderRefund(outTradeNo)
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
if order.PostageType == 1 {
outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(order.ID)
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
//m.OpenNo = model.GetOrderSn()
memberRecord := &model.UserOpenMemberRecord{OpenNo: model.GetOrderSn(), OrderType: 2, Order: &order}
err = memberRecord.OrderRefund(outTradeNo)
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
}
if order.PostageType == 2 {
var userCoupon model.UserCoupon
err = model.NewUserCouponQuerySet(model.DB).ActivityTypeEq(3).UidEq(uint32(order.Uid)).StateEq(2).
OrderAscByID().Limit(1).One(&userCoupon)
if err != nil && err != model.RecordNotFound {
logger.Error("user coupon err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
err = model.NewUserCouponQuerySet(model.DB).IDEq(userCoupon.ID).GetUpdater().SetState(1).Update()
if err != nil {
logger.Error("user coupon err:", err)
}
}
//orderSn := model.GetOrderSn()
//err = model.UserOpenMemberRecord{Uid: uint32(order.Uid), OpenNo: orderSn, OrderId: order.ID, OrderType: 2}.Insert()
//if err != nil {

1
lib/wxpay/wx_pay.go
View File

@ -43,6 +43,7 @@ const (
WxPayUpgradeMember = "upgrade_member" // 多级会员
WxPayMemberExpireDelay = "member_expire_delay" // 会员过期滞纳金
WxPayShareCardRetrieve = "share_card_retrieve" // 收回卡
WxPayPostagePackage = "postage_package" // 运费包
//WxPayExchangeGoods = "exchange_goods" // 兑换商品
//NotifyUrl = "https://switch.deovo.com:8001/api/v1/wxpay/notice" // 数据库配置 生产

25
model/analyse.go
View File

@ -1,18 +1,18 @@
package model
import (
"fmt"
"github.com/codinl/go-logger"
"time"
)
//go:generate goqueryset -in analyse.go
// gen:qs
type Statistic struct {
Model
Count uint32 `json:"count"` // 计数
Type uint32 `json:"type" gorm:"index"` // 类型:1-
Count uint32 `json:"count" gorm:"default:0"` // 计数
EventType uint32 `json:"event_type" gorm:"index"` // 类型:1-运费包曝光次数
}
const (
@ -50,7 +50,8 @@ func (l *UserRenewalLog) Add() error {
func GetActionUserRenewalLog(uid, action uint32) (UserRenewalLog, error) {
var userRenewalLog UserRenewalLog
err := NewUserRenewalLogQuerySet(DB).UidEq(uid).ActionEq(action).OrderDescByID().Limit(1).One(&userRenewalLog)
err := NewUserRenewalLogQuerySet(DB).UidEq(uid).ActionEq(action).OrderDescByID().
Limit(1).One(&userRenewalLog)
if err != nil && err != RecordNotFound {
logger.Error("user renewal log err:", err)
return userRenewalLog, err
@ -115,3 +116,17 @@ func (m *UserMemberRecord) Add() {
}
}()
}
// gen:qs
type UserActionLog struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
ActionType uint32 `json:"action_type"` // 1-运费包_领券送时长专题页 2-运费包_购买运费包
First uint32 `json:"first"` // 1-首次
// user_action_log
}
func IsFirstUserAction(uid, actionType uint32) (bool, error) {
return QueryRecordExist(fmt.Sprintf("SELECT * FROM user_action_log WHERE uid=%d AND action_type=%d", uid, actionType))
}

1402
model/autogenerated_analyse.go
View File

File diff suppressed because it is too large Load Diff

750
model/autogenerated_user.go
View File

@ -8394,6 +8394,756 @@ func NewUserInviteUpdater(db *gorm.DB) UserInviteUpdater {
// ===== END of UserInvite modifiers
// ===== BEGIN of query set UserMemberDurationRecordQuerySet
// UserMemberDurationRecordQuerySet is an queryset type for UserMemberDurationRecord
type UserMemberDurationRecordQuerySet struct {
db *gorm.DB
}
// NewUserMemberDurationRecordQuerySet constructs new UserMemberDurationRecordQuerySet
func NewUserMemberDurationRecordQuerySet(db *gorm.DB) UserMemberDurationRecordQuerySet {
return UserMemberDurationRecordQuerySet{
db: db.Model(&UserMemberDurationRecord{}),
}
}
func (qs UserMemberDurationRecordQuerySet) w(db *gorm.DB) UserMemberDurationRecordQuerySet {
return NewUserMemberDurationRecordQuerySet(db)
}
func (qs UserMemberDurationRecordQuerySet) Select(fields ...UserMemberDurationRecordDBSchemaField) UserMemberDurationRecordQuerySet {
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 *UserMemberDurationRecord) Create(db *gorm.DB) error {
return db.Create(o).Error
}
// Delete is an autogenerated method
// nolint: dupl
func (o *UserMemberDurationRecord) Delete(db *gorm.DB) error {
return db.Delete(o).Error
}
// All is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) All(ret *[]UserMemberDurationRecord) error {
return qs.db.Find(ret).Error
}
// Count is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) Count() (int, error) {
var count int
err := qs.db.Count(&count).Error
return count, err
}
// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) CreatedAtEq(createdAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("created_at = ?", createdAt))
}
// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) CreatedAtGt(createdAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("created_at > ?", createdAt))
}
// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) CreatedAtGte(createdAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("created_at >= ?", createdAt))
}
// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) CreatedAtLt(createdAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("created_at < ?", createdAt))
}
// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) CreatedAtLte(createdAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("created_at <= ?", createdAt))
}
// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) CreatedAtNe(createdAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("created_at != ?", createdAt))
}
// Delete is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) Delete() error {
return qs.db.Delete(UserMemberDurationRecord{}).Error
}
// DeleteNum is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeleteNum() (int64, error) {
db := qs.db.Delete(UserMemberDurationRecord{})
return db.RowsAffected, db.Error
}
// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeleteNumUnscoped() (int64, error) {
db := qs.db.Unscoped().Delete(UserMemberDurationRecord{})
return db.RowsAffected, db.Error
}
// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtEq(deletedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}
// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtGt(deletedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}
// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtGte(deletedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}
// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtIsNotNull() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}
// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtIsNull() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at IS NULL"))
}
// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtLt(deletedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}
// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtLte(deletedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}
// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DeletedAtNe(deletedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}
// DurationEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationEq(duration uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("duration = ?", duration))
}
// DurationGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationGt(duration uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("duration > ?", duration))
}
// DurationGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationGte(duration uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("duration >= ?", duration))
}
// DurationIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationIn(duration ...uint32) UserMemberDurationRecordQuerySet {
if len(duration) == 0 {
qs.db.AddError(errors.New("must at least pass one duration in DurationIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("duration IN (?)", duration))
}
// DurationLt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationLt(duration uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("duration < ?", duration))
}
// DurationLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationLte(duration uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("duration <= ?", duration))
}
// DurationNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationNe(duration uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("duration != ?", duration))
}
// DurationNotIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) DurationNotIn(duration ...uint32) UserMemberDurationRecordQuerySet {
if len(duration) == 0 {
qs.db.AddError(errors.New("must at least pass one duration in DurationNotIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("duration NOT IN (?)", duration))
}
// EventTypeEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeEq(eventType uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("event_type = ?", eventType))
}
// EventTypeGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeGt(eventType uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("event_type > ?", eventType))
}
// EventTypeGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeGte(eventType uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("event_type >= ?", eventType))
}
// EventTypeIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeIn(eventType ...uint32) UserMemberDurationRecordQuerySet {
if len(eventType) == 0 {
qs.db.AddError(errors.New("must at least pass one eventType in EventTypeIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("event_type IN (?)", eventType))
}
// EventTypeLt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeLt(eventType uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("event_type < ?", eventType))
}
// EventTypeLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeLte(eventType uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("event_type <= ?", eventType))
}
// EventTypeNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeNe(eventType uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("event_type != ?", eventType))
}
// EventTypeNotIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) EventTypeNotIn(eventType ...uint32) UserMemberDurationRecordQuerySet {
if len(eventType) == 0 {
qs.db.AddError(errors.New("must at least pass one eventType in EventTypeNotIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("event_type NOT IN (?)", eventType))
}
// GetDB is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) GetDB() *gorm.DB {
return qs.db
}
// GetUpdater is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) GetUpdater() UserMemberDurationRecordUpdater {
return NewUserMemberDurationRecordUpdater(qs.db)
}
// IDEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDEq(ID uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("id = ?", ID))
}
// IDGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDGt(ID uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("id > ?", ID))
}
// IDGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDGte(ID uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("id >= ?", ID))
}
// IDIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDIn(ID ...uint32) UserMemberDurationRecordQuerySet {
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 UserMemberDurationRecordQuerySet) IDLt(ID uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("id < ?", ID))
}
// IDLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDLte(ID uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("id <= ?", ID))
}
// IDNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDNe(ID uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("id != ?", ID))
}
// IDNotIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) IDNotIn(ID ...uint32) UserMemberDurationRecordQuerySet {
if len(ID) == 0 {
qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("id NOT IN (?)", ID))
}
// Limit is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) Limit(limit int) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Limit(limit))
}
// MemberLevelEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelEq(memberLevel uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("member_level = ?", memberLevel))
}
// MemberLevelGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelGt(memberLevel uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("member_level > ?", memberLevel))
}
// MemberLevelGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelGte(memberLevel uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("member_level >= ?", memberLevel))
}
// MemberLevelIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelIn(memberLevel ...uint32) UserMemberDurationRecordQuerySet {
if len(memberLevel) == 0 {
qs.db.AddError(errors.New("must at least pass one memberLevel in MemberLevelIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("member_level IN (?)", memberLevel))
}
// MemberLevelLt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelLt(memberLevel uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("member_level < ?", memberLevel))
}
// MemberLevelLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelLte(memberLevel uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("member_level <= ?", memberLevel))
}
// MemberLevelNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelNe(memberLevel uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("member_level != ?", memberLevel))
}
// MemberLevelNotIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) MemberLevelNotIn(memberLevel ...uint32) UserMemberDurationRecordQuerySet {
if len(memberLevel) == 0 {
qs.db.AddError(errors.New("must at least pass one memberLevel in MemberLevelNotIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("member_level NOT IN (?)", memberLevel))
}
// Offset is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) Offset(offset int) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Offset(offset))
}
// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs UserMemberDurationRecordQuerySet) One(ret *UserMemberDurationRecord) error {
return qs.db.First(ret).Error
}
// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByCreatedAt() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("created_at ASC"))
}
// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByDeletedAt() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("deleted_at ASC"))
}
// OrderAscByDuration is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByDuration() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("duration ASC"))
}
// OrderAscByEventType is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByEventType() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("event_type ASC"))
}
// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByID() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("id ASC"))
}
// OrderAscByMemberLevel is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByMemberLevel() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("member_level ASC"))
}
// OrderAscByUid is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByUid() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("uid ASC"))
}
// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderAscByUpdatedAt() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("updated_at ASC"))
}
// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByCreatedAt() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("created_at DESC"))
}
// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByDeletedAt() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("deleted_at DESC"))
}
// OrderDescByDuration is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByDuration() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("duration DESC"))
}
// OrderDescByEventType is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByEventType() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("event_type DESC"))
}
// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByID() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("id DESC"))
}
// OrderDescByMemberLevel is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByMemberLevel() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("member_level DESC"))
}
// OrderDescByUid is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByUid() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("uid DESC"))
}
// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) OrderDescByUpdatedAt() UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Order("updated_at DESC"))
}
// UidEq is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidEq(uid uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("uid = ?", uid))
}
// UidGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidGt(uid uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("uid > ?", uid))
}
// UidGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidGte(uid uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("uid >= ?", uid))
}
// UidIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidIn(uid ...uint32) UserMemberDurationRecordQuerySet {
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 UserMemberDurationRecordQuerySet) UidLt(uid uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("uid < ?", uid))
}
// UidLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidLte(uid uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("uid <= ?", uid))
}
// UidNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidNe(uid uint32) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("uid != ?", uid))
}
// UidNotIn is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UidNotIn(uid ...uint32) UserMemberDurationRecordQuerySet {
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 UserMemberDurationRecordQuerySet) UpdatedAtEq(updatedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}
// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UpdatedAtGt(updatedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}
// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UpdatedAtGte(updatedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}
// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UpdatedAtLt(updatedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}
// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UpdatedAtLte(updatedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}
// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs UserMemberDurationRecordQuerySet) UpdatedAtNe(updatedAt time.Time) UserMemberDurationRecordQuerySet {
return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}
// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetCreatedAt(createdAt time.Time) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.CreatedAt)] = createdAt
return u
}
// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetDeletedAt(deletedAt *time.Time) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.DeletedAt)] = deletedAt
return u
}
// SetDuration is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetDuration(duration uint32) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.Duration)] = duration
return u
}
// SetEventType is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetEventType(eventType uint32) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.EventType)] = eventType
return u
}
// SetID is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetID(ID uint32) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.ID)] = ID
return u
}
// SetMemberLevel is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetMemberLevel(memberLevel uint32) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.MemberLevel)] = memberLevel
return u
}
// SetUid is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetUid(uid uint32) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.Uid)] = uid
return u
}
// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) SetUpdatedAt(updatedAt time.Time) UserMemberDurationRecordUpdater {
u.fields[string(UserMemberDurationRecordDBSchema.UpdatedAt)] = updatedAt
return u
}
// Update is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) Update() error {
return u.db.Updates(u.fields).Error
}
// UpdateNum is an autogenerated method
// nolint: dupl
func (u UserMemberDurationRecordUpdater) UpdateNum() (int64, error) {
db := u.db.Updates(u.fields)
return db.RowsAffected, db.Error
}
// ===== END of query set UserMemberDurationRecordQuerySet
// ===== BEGIN of UserMemberDurationRecord modifiers
// UserMemberDurationRecordDBSchemaField describes database schema field. It requires for method 'Update'
type UserMemberDurationRecordDBSchemaField string
// String method returns string representation of field.
// nolint: dupl
func (f UserMemberDurationRecordDBSchemaField) String() string {
return string(f)
}
// UserMemberDurationRecordDBSchema stores db field names of UserMemberDurationRecord
var UserMemberDurationRecordDBSchema = struct {
ID UserMemberDurationRecordDBSchemaField
CreatedAt UserMemberDurationRecordDBSchemaField
UpdatedAt UserMemberDurationRecordDBSchemaField
DeletedAt UserMemberDurationRecordDBSchemaField
Uid UserMemberDurationRecordDBSchemaField
Duration UserMemberDurationRecordDBSchemaField
EventType UserMemberDurationRecordDBSchemaField
MemberLevel UserMemberDurationRecordDBSchemaField
}{
ID: UserMemberDurationRecordDBSchemaField("id"),
CreatedAt: UserMemberDurationRecordDBSchemaField("created_at"),
UpdatedAt: UserMemberDurationRecordDBSchemaField("updated_at"),
DeletedAt: UserMemberDurationRecordDBSchemaField("deleted_at"),
Uid: UserMemberDurationRecordDBSchemaField("uid"),
Duration: UserMemberDurationRecordDBSchemaField("duration"),
EventType: UserMemberDurationRecordDBSchemaField("event_type"),
MemberLevel: UserMemberDurationRecordDBSchemaField("member_level"),
}
// Update updates UserMemberDurationRecord fields by primary key
// nolint: dupl
func (o *UserMemberDurationRecord) Update(db *gorm.DB, fields ...UserMemberDurationRecordDBSchemaField) error {
dbNameToFieldName := map[string]interface{}{
"id": o.ID,
"created_at": o.CreatedAt,
"updated_at": o.UpdatedAt,
"deleted_at": o.DeletedAt,
"uid": o.Uid,
"duration": o.Duration,
"event_type": o.EventType,
"member_level": o.MemberLevel,
}
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 UserMemberDurationRecord %v fields %v: %s",
o, fields, err)
}
return nil
}
// UserMemberDurationRecordUpdater is an UserMemberDurationRecord updates manager
type UserMemberDurationRecordUpdater struct {
fields map[string]interface{}
db *gorm.DB
}
// NewUserMemberDurationRecordUpdater creates new UserMemberDurationRecord updater
// nolint: dupl
func NewUserMemberDurationRecordUpdater(db *gorm.DB) UserMemberDurationRecordUpdater {
return UserMemberDurationRecordUpdater{
fields: map[string]interface{}{},
db: db.Model(&UserMemberDurationRecord{}),
}
}
// ===== END of UserMemberDurationRecord modifiers
// ===== BEGIN of query set UserMemberExpireDelayQuerySet
// UserMemberExpireDelayQuerySet is an queryset type for UserMemberExpireDelay

47
model/config.go
View File

@ -27,12 +27,13 @@ type PayConfig struct {
}
const (
ConfigNamePay = "pay_config" // 支付配置
ConfigNameMember = "member_config" // 会员配置
ConfigNameMemberVm = "member_vm_config" // 会员积分配置
ConfigNameAttendanceVm = "attendance_vm_config" // 签到积分配置
ConfigActivityRenewal = "activity_renewal_config" // 活动配置
ConfigRecycleCard = "recycle_card_config" // 回收卡配置
ConfigNamePay = "pay_config" // 支付配置
ConfigNameMember = "member_config" // 会员配置
ConfigNameMemberVm = "member_vm_config" // 会员积分配置
ConfigNameAttendanceVm = "attendance_vm_config" // 签到积分配置
ConfigActivityRenewal = "activity_renewal_config" // 活动配置
ConfigRecycleCard = "recycle_card_config" // 回收卡配置
ConfigPostagePackageFee = "postage_package_fee_config" // 运费包费
)
func PayConfigInfo() (*PayConfig, error) {
@ -243,6 +244,40 @@ func RecycleCardConfigInfo() (RecycleCardConfig, error) {
return recycleConfig, nil
}
type PostagePackageFeeConfig struct {
PostagePackageFee uint32 `json:"postage_package_fee"`
}
func PostagePackageFeeConfigInfo() (PostagePackageFeeConfig, error) {
postagePackageFeeConfig := PostagePackageFeeConfig{}
var configAllocation Config
err := NewConfigQuerySet(DB).NameEq(ConfigPostagePackageFee).One(&configAllocation)
if err != nil {
logger.Error("err:", err)
return postagePackageFeeConfig, err
}
err = json.Unmarshal([]byte(configAllocation.Value), &postagePackageFeeConfig)
if err != nil {
logger.Error("err:", err)
return postagePackageFeeConfig, err
}
return postagePackageFeeConfig, nil
}
func GetPostagePackageMemberDuration(level uint32) uint32 {
switch level {
case 2:
return 90
case 4:
return 51
case 5:
return 24
}
return 0
}
//type ConfigInterface interface {
// Encode() string
//}

6
model/coupon.go
View File

@ -25,7 +25,7 @@ type Coupon struct {
Name string `json:"name"`
Describe string `json:"describe" gorm:"type:text;"` // 描述
CouponType string `json:"coupon_type"`
ActivityType uint32 `json:"activity_type"` // 活动类型 1-会员续费 2-关注公众号
ActivityType uint32 `json:"activity_type"` // 活动类型 1-会员续费 2-关注公众号 3-运费包
ActivityId uint32 `json:"activity_id" gorm:"index"`
Value uint32 `json:"value"`
OutCount uint32 `json:"out_count"` // 用户已领取数量
@ -43,7 +43,7 @@ type UserCoupon struct {
Uid uint32 `json:"uid" gorm:"index"`
CouponId uint32 `json:"coupon_id" gorm:"index"`
CouponType string `json:"coupon_type"`
ActivityType uint32 `json:"activity_type"` // 活动类型 1-会员续费
ActivityType uint32 `json:"activity_type"` // 活动类型 1-会员续费 2-关注公众号 3-运费包
ActivityId uint32 `json:"activity_id" gorm:"index"`
Value uint32 `json:"value"`
State uint32 `json:"state"` // 1-未使用 2-已使用 3-已过期
@ -59,7 +59,7 @@ type Activity struct {
Model
Name string `json:"name" gorm:"column:name;comment:'活动名称'"` // 活动名称
ActivityType uint32 `json:"activity_type" gorm:"column:activity_type;comment:'活动类型'"` // 活动类型 1-会员续费 2-关注公众号
ActivityType uint32 `json:"activity_type" gorm:"column:activity_type;comment:'活动类型'"` // 活动类型 1-会员续费 2-关注公众号 3-运费包
State uint32 `json:"state" gorm:"column:state;comment:'状态'"` // 1-未开启 2-进行中 3-已结束
StartTime time.Time `json:"start_time" gorm:"column:start_time;comment:'开始时间'"` // 开始时间
EndTime time.Time `json:"end_time" gorm:"column:end_time;comment:'结束时间'"` // 结束时间 零值永不结束

14
model/game_card.go
View File

@ -560,11 +560,14 @@ func GetGameCardSearch(name string, page, pageSize int, storeId uint32) ([]GameC
cardMap[cards[i].ID] = cards[i]
}
var cardStocks []GameCardGoodsStock
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(cardIds...).RentStockGt(0).All(&cardStocks)
if err != nil {
logger.Error("game card goods stock err:", err)
return cards, totalPage, nil
if len(cardIds) != 0 {
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(cardIds...).RentStockGt(0).All(&cardStocks)
if err != nil {
logger.Error("game card goods stock err:", err)
return cards, totalPage, nil
}
}
list := make([]GameCard, 0, len(cards))
stockMap := make(map[uint64]uint32, 0)
for i, _ := range cardStocks {
@ -1064,7 +1067,7 @@ func (m *GameCardGoodsStockAnalysisReq) GameCardStockListAnalysis() (*GameCardGo
}
//fmt.Println("--gameIds:", gameIds)
sqlStore += fmt.Sprintf(" AND game_card_id IN (%s)", strings.Join(gameIds, ","))
sqlStore += fmt.Sprintf(" AND game_card_id IN (%s) ", strings.Join(gameIds, ","))
}
//var countGame int64
@ -1072,6 +1075,7 @@ func (m *GameCardGoodsStockAnalysisReq) GameCardStockListAnalysis() (*GameCardGo
fmt.Println("sqlCount:", sqlCount)
err := DB.Raw(sqlCount).Scan(&gameCardCount).Error
if err != nil {
logger.Info("sqlCount:", sqlCount)
logger.Error("sqlCount err:", err)
return resp, err
}

82
model/model_test.go
View File

@ -1,11 +1,14 @@
package model
import (
"bytes"
"crypto/sha512"
"encoding/hex"
"encoding/json"
"fmt"
"mh-server/lib/auth"
"mh-server/lib/utils"
"mh-server/lib/xianmai"
"os"
"sort"
"strconv"
@ -91,12 +94,10 @@ func InitTestDB() {
//&User{},
//&Order{},
//&OrderCard{},
//
//&OperationLog{},
//&CooperativeBusiness{},
//&CooperativeMemberDeduct{},
//&CooperativeAssistantMemberDeduct{},
//
//&CooperativeMemberPromotion{},
//&CooperativeMemberPromotionStore{},
//&CooperativeMemberPromotionDay{},
@ -138,14 +139,19 @@ func InitTestDB() {
//&CooperativeMemberPromotion{},
//&GameCard{},
//&CooperativeMemberPromotionStoreDay{},
//
//&UserInvite{},
//&UserInviteRecord{},
//&CooperativeMemberPromotionStore{},
&RecycleCardOrder{},
&RedeemCode{},
&PublicRecord{},
//&RecycleCardOrder{},
//&RedeemCode{},
//&PublicRecord{},
&Order{},
&OrderCard{},
&UserMemberDurationRecord{},
&Statistic{},
&UserActionLog{},
)
fmt.Println("DB init success")
@ -181,9 +187,15 @@ func InitDBProd() {
DBProd.LogMode(false)
DBProd.SingularTable(true)
DBProd.AutoMigrate(
&RecycleCardOrder{},
&RedeemCode{},
&PublicRecord{},
//&RecycleCardOrder{},
//&RedeemCode{},
//&PublicRecord{},
&Order{},
&OrderCard{},
&UserMemberDurationRecord{},
&Statistic{},
&UserActionLog{},
)
if err := DBProd.DB().Ping(); err != nil {
@ -1099,7 +1111,8 @@ func TestAtt(t *testing.T) {
}
func UserAttendanceDays() {
uc := &auth.UserClaims{Uid: 31871993}
//uc := &auth.UserClaims{Uid: 31871993}
uc := &auth.UserClaims{}
list := make([]AttendanceInfo, 0, 7)
todayZero := utils.TodayZeroDateFormat()
configInfo, err := AttendanceVmConfigInfo()
@ -1660,3 +1673,52 @@ func TestExportGameList(t *testing.T) {
}
}
func TestReader(t *testing.T) {
buffer := bytes.Buffer{}
buffer.ReadByte()
l1 := []uint32{1, 2, 3}
l2 := make([]uint32, 10)
l3 := make([]uint32, 1)
l4 := make([]uint32, 0)
copy(l2, l1)
copy(l3, l1)
copy(l4, l1)
fmt.Println("l2:", l2)
fmt.Println("l3:", l3)
fmt.Println("l4:", l4)
}
func TestRandSecret(t *testing.T) {
RandSecret("seed")
}
func RandSecret(seed string) {
key := fmt.Sprintf("%s%d", seed, time.Now().UnixNano())
hash := sha512.New()
hash.Write([]byte(key))
encodeToString := hex.EncodeToString(hash.Sum(nil))
fmt.Println("encode:", encodeToString[:10])
//return strconv.ParseUint(encodeToString[:5], 16, 32)
}
func TestGameCassetteList(t *testing.T) {
list, count, err := xianmai.GameCassetteList("", 0, 10000)
if err != nil {
fmt.Println("err:", err)
}
fmt.Println("count:", count)
for i, _ := range list {
fmt.Println("", list[i].GoodsName)
}
}
func TestDays(t *testing.T) {
d1, _ := time.Parse(DateTimeFormat, "2022-12-27")
d2, _ := time.Parse(DateTimeFormat, "2022-09-28")
fmt.Println("天数:", (d2.Unix()-d1.Unix())/24/3600)
}

2
model/order.go
View File

@ -52,6 +52,7 @@ type Order struct {
OrderSn string `json:"order_sn" gorm:"type:varchar(255);not null;COMMENT:'订单编号'"` // 订单编号
PayPrice uint32 `json:"pay_price"` // 实际付款金额(包含运费)
Postage uint32 `json:"postage"` // 邮费
PostageType uint32 `json:"postage_type"` // 邮费类型:1-法币 2-包邮券
ExpressCompany string `json:"express_company"` // 物流公司
ExpressCompanyNo string `json:"express_company_no"` // 物流公司编号
ExpressNo string `json:"express_no"` // 物流单号
@ -99,6 +100,7 @@ type OrderCard struct {
CooperativeName string `json:"cooperative_name"` // 合作商名称
Postage uint32 `json:"postage" gorm:"-"` // 邮费
PostageType uint32 `json:"postage_type"` // 邮费类型
ExpressCompany string `json:"express_company" gorm:"-"` // 物流公司
ExpressCompanyNo string `json:"express_company_no" gorm:"-"` // 物流公司编号
ExpressNo string `json:"express_no" gorm:"-"` // 物流单号

28
model/store.go
View File

@ -261,3 +261,31 @@ func CannibalizeGameCardGoodsSetInfo(goodses []CannibalizeGameCardGoods) []Canni
//UserOpenMemberRecord{}
return goodses
}
//func GetDeliveryStoreByAddress(addressId uint32) Store {
// // 订单最少的店
// // 没有库存
// // 订单最多的店
// store := Store{}
// var address UserAddress
// err := NewUserAddressQuerySet(DB).IDEq(addressId).One(&address)
// if err != nil {
// logger.Error("user address err:", err)
// return store
// }
//
// var stores []Store
// err = NewStoreQuerySet(DB).ProvinceEq(address.Province).All(&stores)
// if err != nil {
// logger.Error("store err:", err)
// return store
// }
//
// storeIds := make([]uint32, 0, len(stores))
// for i, _ := range stores {
// storeIds = append(storeIds, stores[i].ID)
// }
//
// NewGameCardGoodsStockQuerySet(DB).IDIn(storeIds...)
//
//}

13
model/user.go
View File

@ -147,6 +147,7 @@ const (
FundTypeBuyGoodsCancel = "buy_goods_cancel" // 购买商品取消订单
FundTypeBuyGoodsRefund = "buy_goods_refund" // 购买商品退货
FundTypeRecycleCard = "recycle_card" // 回收卡带
FundTypePostagePackageFee = "postage_package_fee" // 购买运费包
)
// gen:qs
@ -256,7 +257,7 @@ func UserUpdate(user *User) error {
return nil
}
//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单 8-购买商品订单退货 9-升级会员 10-开通 续费
//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单 8-购买商品订单退货 9-升级会员 10-开通 续费 11-运费包
// gen:qs
type UserOpenMemberRecord struct {
@ -322,6 +323,16 @@ type OperationLog struct {
Remark string `json:"remark"` // 备注
}
// gen:qs
type UserMemberDurationRecord struct {
Model
Uid uint32 `json:"uid"`
Duration uint32 `json:"duration"`
EventType uint32 `json:"event_type"` // 类型: 1-购买运费包
MemberLevel uint32 `json:"member_level"` // 会员等级 1-用户 2-会员
}
func (m *UserOpenMemberRecord) OrderRefund(outTradeNo string) error {
if m.Order == nil {
return errors.New("order is nil")

7
router/router_app.go
View File

@ -131,7 +131,7 @@ func ConfigAppRouter(r gin.IRouter) {
// 订单
order := api.Group("order")
{
order.POST("amount", controller.OrderAmount) // 订单金额
order.POST("info", controller.OrderInfo) // 订单详情
order.POST("express", controller.OrderExpress) // 订单物流
order.POST("express_company/list", controller.ExpressCompanyList) // 物流公司列表
@ -145,6 +145,7 @@ func ConfigAppRouter(r gin.IRouter) {
order.POST("revert/cancel", controller.OrderRevertCancel) // 取消归还
//order.POST("express_fee/refund", controller.ExpressFeeRefund) // 物流费退款
order.POST("confirm_receipt", controller.ConfirmReceipt) // 订单确认收货
order.POST("amount", controller.OrderAmount) // 订单金额
}
article := api.Group("article")
@ -170,6 +171,9 @@ func ConfigAppRouter(r gin.IRouter) {
activity.POST("member_renewal/info", controller.UserMemberRenewalInfo)
activity.POST("member_renewal/coupon_draw", controller.UserMemberRenewalCouponDraw)
activity.POST("member_renewal/user_coupon/list", controller.MemberRenewalUserCouponList)
activity.POST("postage_package/buy", controller.PostagePackageBuy)
activity.POST("user_coupon/list", controller.UserCouponList)
activity.POST("postage_package/info", controller.PostagePackageInfo)
}
mall := api.Group("mall")
@ -274,5 +278,4 @@ func ConfigAppRouter(r gin.IRouter) {
recycleConsole.POST("order/check", controller.RecycleCardOrderCheck) // 管理端
recycleConsole.POST("order/list", controller.ConsoleRecycleCardOrderList)
}
}