636 lines
16 KiB
Go
636 lines
16 KiB
Go
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"
|
|
)
|
|
|
|
func UserRedeemCodeList(c *gin.Context) {
|
|
req := &struct {
|
|
Status string `json:"status"`
|
|
}{}
|
|
if c.ShouldBindJSON(req) != nil {
|
|
logger.Errorf("para err")
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
|
|
codeList, err := model.UserRedeemCodeList(uc.Uid, req.Status)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
RespOK(c, codeList)
|
|
}
|
|
|
|
func UserConvertRedeemCode(c *gin.Context) {
|
|
req := &struct {
|
|
SerialCode string `json:"serial_code"`
|
|
}{}
|
|
if c.ShouldBindJSON(req) != nil {
|
|
logger.Errorf("para err")
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
err := model.UserRedeemCodeConvert(uc.Uid, req.SerialCode)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
RespOK(c, nil)
|
|
}
|
|
|
|
func UserMemberRenewalState(c *gin.Context) {
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
user := model.GetUserByUid(uc.Uid)
|
|
if !user.IsMember() {
|
|
RespOK(c, map[string]interface{}{
|
|
"is_pop": true,
|
|
"is_member_renewal": false,
|
|
})
|
|
return
|
|
}
|
|
var activityMemberRenewal model.ActivityMemberRenewal
|
|
//err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).StateEq(1).
|
|
// One(&activityMemberRenewal)
|
|
err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).OrderDescByID().
|
|
Limit(1).One(&activityMemberRenewal)
|
|
if err != nil && err != model.RecordNotFound {
|
|
logger.Error("activity member renewal err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
isPop := true
|
|
|
|
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)) {
|
|
activityMemberRenewal = model.ActivityMemberRenewal{
|
|
ActivityId: 1,
|
|
Uid: uc.Uid,
|
|
State: 1,
|
|
StartTime: utils.Now(),
|
|
IsPop: true,
|
|
MemberLevel: user.MemberLevel,
|
|
MemberSerial: uint32(user.MemberExpire.Unix()),
|
|
}
|
|
|
|
err = model.DB.Create(&activityMemberRenewal).Error
|
|
if err != nil {
|
|
logger.Error("create activity member renewal err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
go func() {
|
|
renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, model.UserRenewalLogActionPop)
|
|
userLog := &model.UserRenewalLog{
|
|
Uid: uc.Uid,
|
|
Action: model.UserRenewalLogActionPop,
|
|
MemberExpire: user.MemberExpire,
|
|
Type: 0,
|
|
RenewalNum: renewalLog.RenewalNum + 1,
|
|
Serial: uint32(user.MemberExpire.Unix()),
|
|
}
|
|
_ = userLog.Add()
|
|
}()
|
|
|
|
isPop = false
|
|
}
|
|
}
|
|
if activityMemberRenewal.StartTime.AddDate(0, 0,
|
|
model.GetActivityRenewalConfig().ActivityContinuity).Before(utils.Now()) {
|
|
activityMemberRenewal.State = 3
|
|
_, err = model.NewActivityMemberRenewalQuerySet(model.DB).IDEq(activityMemberRenewal.ID).GetUpdater().
|
|
SetState(3).UpdateNum()
|
|
if err != nil {
|
|
logger.Error("update num err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
}
|
|
isMemberRenewal := false
|
|
if activityMemberRenewal.State == 1 {
|
|
isMemberRenewal = true
|
|
}
|
|
ret := make(map[string]interface{}, 0)
|
|
ret["is_pop"] = isPop
|
|
ret["is_member_renewal"] = isMemberRenewal
|
|
|
|
RespOK(c, ret)
|
|
return
|
|
}
|
|
|
|
func UserMemberRenewalInfo(c *gin.Context) {
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
//uc := auth.UserClaims{Uid: 5640286}
|
|
var renewal model.ActivityMemberRenewal
|
|
err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).
|
|
StateEq(1).One(&renewal)
|
|
if err != nil && err != model.RecordNotFound {
|
|
logger.Error("renewal err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
if err == model.RecordNotFound {
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
var coupons []model.Coupon
|
|
err = model.NewCouponQuerySet(model.DB).ActivityIdEq(renewal.ActivityId).All(&coupons)
|
|
if err != nil {
|
|
logger.Error("coupons err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
var userCoupons []model.UserCoupon
|
|
//err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(renewal.ActivityId).
|
|
// StateEq(1).All(&userCoupons)
|
|
now := time.Now()
|
|
err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(renewal.ActivityId).
|
|
ActiveStartLte(now).ActiveEndGte(now).All(&userCoupons)
|
|
if err != nil {
|
|
logger.Error("userCoupons err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
user := model.GetUserByUid(uc.Uid)
|
|
exist, err := model.QueryRecordExist(
|
|
fmt.Sprintf("SELECT * FROM user_renewal_log WHERE uid = %d AND action=2 AND serial=%d",
|
|
uc.Uid, user.MemberExpire.Unix()))
|
|
if err != nil {
|
|
logger.Error("user log exist err:", err)
|
|
}
|
|
if err == nil && !exist {
|
|
go func() {
|
|
renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, model.UserRenewalLogActionEnterActivity)
|
|
userLog := &model.UserRenewalLog{
|
|
Uid: uc.Uid,
|
|
Action: model.UserRenewalLogActionEnterActivity,
|
|
MemberExpire: user.MemberExpire,
|
|
Type: 0,
|
|
RenewalNum: renewalLog.RenewalNum + 1,
|
|
Serial: uint32(user.MemberExpire.Unix()),
|
|
}
|
|
_ = userLog.Add()
|
|
}()
|
|
}
|
|
userCouponMap := make(map[uint32]*model.UserCoupon, 0)
|
|
for i, _ := range userCoupons {
|
|
userCouponMap[userCoupons[i].CouponId] = &userCoupons[i]
|
|
}
|
|
|
|
for i, _ := range coupons {
|
|
_, ok := userCouponMap[coupons[i].ID]
|
|
if ok {
|
|
coupons[i].IsDraw = true
|
|
}
|
|
}
|
|
down := int64(model.GetActivityRenewalConfig().ActivityContinuity)*24*3600 - (utils.Now().Unix() - renewal.StartTime.Unix())
|
|
ret := map[string]interface{}{
|
|
"coupon_list": coupons,
|
|
"renewal": renewal,
|
|
"time_down": down,
|
|
}
|
|
RespOK(c, ret)
|
|
return
|
|
}
|
|
|
|
func UserMemberRenewalCouponDraw(c *gin.Context) {
|
|
req := &struct {
|
|
CouponIds []uint32 `json:"coupon_ids" binding:"required"`
|
|
}{}
|
|
if c.ShouldBindJSON(req) != nil {
|
|
logger.Errorf("para err")
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
if len(req.CouponIds) == 0 {
|
|
logger.Errorf("para err")
|
|
RespOK(c, nil)
|
|
return
|
|
}
|
|
user := model.GetUserByUid(uc.Uid)
|
|
var activityMemberRenewal model.ActivityMemberRenewal
|
|
err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().
|
|
Limit(1).One(&activityMemberRenewal)
|
|
if err != nil {
|
|
logger.Error("activity member renewal err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
if !user.IsMember() ||
|
|
activityMemberRenewal.State == 3 {
|
|
logger.Error("user coupon err")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
var userCoupons []model.UserCoupon
|
|
err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityTypeEq(1).
|
|
StateEq(1).All(&userCoupons)
|
|
if err != nil {
|
|
logger.Error("coupons err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
userCouponMap := make(map[uint32]int, 0)
|
|
for i, _ := range userCoupons {
|
|
userCouponMap[userCoupons[i].CouponId] = i
|
|
}
|
|
var coupons []model.Coupon
|
|
err = model.NewCouponQuerySet(model.DB).IDIn(req.CouponIds...).All(&coupons)
|
|
if err != nil {
|
|
logger.Error("coupons err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
for i, _ := range coupons {
|
|
_, ok := userCouponMap[coupons[i].ID]
|
|
if ok {
|
|
continue
|
|
}
|
|
|
|
go func() {
|
|
action := 0
|
|
if coupons[i].MemberLevel == 2 {
|
|
action = model.UserRenewalLogActionPickGold
|
|
} else if coupons[i].MemberLevel == 4 {
|
|
action = model.UserRenewalLogActionPickPlatinum
|
|
} else if coupons[i].MemberLevel == 5 {
|
|
action = model.UserRenewalLogActionPickBlackGold
|
|
}
|
|
renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
|
|
userLog := &model.UserRenewalLog{
|
|
Uid: uc.Uid,
|
|
Action: uint32(action),
|
|
MemberExpire: user.MemberExpire,
|
|
Type: 0,
|
|
RenewalNum: renewalLog.RenewalNum + 1,
|
|
Serial: uint32(user.MemberExpire.Unix()),
|
|
}
|
|
_ = userLog.Add()
|
|
}()
|
|
|
|
userCoupon := &model.UserCoupon{
|
|
Uid: uc.Uid,
|
|
CouponId: coupons[i].ID,
|
|
CouponType: coupons[i].CouponType,
|
|
ActivityType: coupons[i].ActivityType,
|
|
ActivityId: coupons[i].ActivityId,
|
|
Value: coupons[i].Value,
|
|
State: 1,
|
|
ActiveStart: time.Now(),
|
|
ActiveEnd: time.Now().AddDate(0, 0, model.GetActivityRenewalConfig().CouponValidity),
|
|
MemberLevel: coupons[i].MemberLevel,
|
|
}
|
|
|
|
err = model.DB.Create(userCoupon).Error
|
|
if err != nil {
|
|
logger.Error("user coupon err:", err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
RespOK(c, nil)
|
|
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, Attach: wxpay.WxPayPostagePackage}.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
|
|
//}
|
|
webPay, err := wxpay.HmJsPayUnifiedOrder(orderSn, info.PostagePackageFee, user.WxOpenID, configInfo.NotifyUrl)
|
|
if err != nil {
|
|
logger.Error(errors.New("WebPay 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
|
|
}
|
|
user := model.GetUserByUid(uc.Uid)
|
|
if user == nil {
|
|
logger.Error("user err")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
for i, _ := range coupons {
|
|
if !user.IsMember() && coupons[i].ActivityType == 1 {
|
|
coupons[i].Availability = 1
|
|
} else {
|
|
coupons[i].Availability = 2
|
|
}
|
|
}
|
|
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"`
|
|
PageSize int `json:"page_size"`
|
|
State uint32 `json:"state"` // 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 {
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
|
|
user := model.GetUserByUid(uc.Uid)
|
|
if user == nil {
|
|
logger.Error("user err:")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
page := req.PageIdx - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if req.PageSize == 0 {
|
|
req.PageSize = 10
|
|
}
|
|
|
|
qs := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid)
|
|
if req.State != 0 {
|
|
qs = qs.StateEq(req.State)
|
|
}
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("count err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
totalPage := count/req.PageSize + 1
|
|
var coupons []model.UserCoupon
|
|
err = qs.OrderDescByID().Offset(page * req.PageSize).Limit(req.PageSize).All(&coupons)
|
|
if err != nil && err != model.RecordNotFound {
|
|
logger.Error("coupons err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
ids := make([]uint32, 0)
|
|
for i, _ := range coupons {
|
|
if coupons[i].ActiveEnd.Before(time.Now()) && coupons[i].State != 3 {
|
|
ids = append(ids, coupons[i].ID)
|
|
coupons[i].State = 3
|
|
}
|
|
}
|
|
|
|
list := make([]model.UserCoupon, 0, len(coupons))
|
|
for i, _ := range coupons {
|
|
if user.OpenMemberTime.IsZero() && coupons[i].ActivityType == 1 {
|
|
continue
|
|
}
|
|
if user.MemberGenre == 201 || user.MemberGenre == 202 {
|
|
coupons[i].Availability = 1
|
|
}
|
|
var shopperPromotionCode model.ShopperPromotionCode
|
|
err = model.NewShopperPromotionCodeQuerySet(model.DB).CodeEq(coupons[i].RedeemCode).One(&shopperPromotionCode)
|
|
if err != nil {
|
|
logger.Error(err)
|
|
}
|
|
coupons[i].StoreId = shopperPromotionCode.StoreId
|
|
|
|
var couponInfo model.Coupon
|
|
err = model.NewCouponQuerySet(model.DB).IDEq(coupons[i].CouponId).One(&couponInfo)
|
|
if err != nil {
|
|
logger.Error("coupons err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
coupons[i].Coupon = &couponInfo
|
|
|
|
list = append(list, coupons[i])
|
|
}
|
|
|
|
if len(ids) > 0 {
|
|
err = model.NewUserCouponQuerySet(model.DB).IDIn(ids...).GetUpdater().SetState(3).Update()
|
|
if err != nil {
|
|
logger.Error("update user coupon err:", err)
|
|
}
|
|
}
|
|
ret := map[string]interface{}{
|
|
"list": list,
|
|
"total_page": totalPage,
|
|
"page_idx": req.PageIdx,
|
|
}
|
|
RespOK(c, ret)
|
|
return
|
|
}
|