1011 lines
30 KiB
Go
1011 lines
30 KiB
Go
package model
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/codinl/go-logger"
|
|
"github.com/jinzhu/gorm"
|
|
"github.com/rs/zerolog/log"
|
|
"mh-server/lib/utils"
|
|
"mh-server/lib/wxpay"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
//go:generate goqueryset -in user.go
|
|
// gen:qs
|
|
type User struct {
|
|
Model
|
|
|
|
Uid uint32 `json:"uid" gorm:"column:uid;unique_index"`
|
|
MemberLevel uint32 `json:"member_level"` // 会员等级 1-用户 2-会员
|
|
MemberExpire time.Time `json:"member_expire"` // 会员到期时间
|
|
OpenMemberTime time.Time `json:"open_member_time"` // 开通会员
|
|
Bond uint32 `json:"bond"` // 保证金
|
|
WxName string `json:"wx_name"` // 昵称
|
|
WxAvatar string `json:"wx_avatar"` // 头像
|
|
WxOpenID string `json:"wx_open_id"`
|
|
AppOpenID string `json:"app_open_id"`
|
|
WxUnionID string `json:"wx_union_id"`
|
|
Tel string `json:"tel"` // 电话
|
|
Gender uint8 `json:"gender"` // 性别
|
|
City string `json:"city"` // 城市
|
|
Province string `json:"province"` // 省
|
|
Country string `json:"country"` // 市
|
|
Deposit uint32 `json:"deposit"` // 押金
|
|
UserType uint32 `json:"user_type"` // 用户类型: 1-普通用户 2-店员
|
|
XcxRoleId uint32 `json:"xcx_role_id"` // 角色id
|
|
OpenMemberChannel string `json:"open_member_channel" ` // 开通会员渠道: -门店推广 -用户邀请 -兑换码
|
|
StoreId uint64 `json:"store_id"` // 门店id
|
|
InviteCodeUrl string `json:"invite_code_url"` // 分享二维码
|
|
LastLoginAt time.Time `json:"last_login_at"` // 最近登录时间
|
|
IP string `json:"-" gorm:"type:varchar(60)"` // ip
|
|
InBlack bool `json:"in_black"` // 是否在黑名单
|
|
StoreType uint32 `json:"store_type"` // 1-订单门店
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
ShopAssistantName string `json:"shop_assistant_name"` // 店员名称
|
|
Version uint32 `json:"-"`
|
|
UserVm *UserVm `json:"user_vm" gorm:"-"` //
|
|
//RoleId uint32 `json:"role_id"` // 角色id
|
|
}
|
|
|
|
func (o *User) TableName() string {
|
|
return "user"
|
|
}
|
|
|
|
const (
|
|
MemberTypeConsumer = 1 // 普通用户
|
|
MemberTypeMember = 2 // 黄金会员
|
|
)
|
|
|
|
const (
|
|
MemberLevelConsumer = 1 // 普通用户
|
|
MemberLevelGold = 2 // 黄金会员
|
|
MemberLevelPeriod = 3 // 短期会员
|
|
MemberLevelPlatinum = 4 // 白金会员
|
|
MemberLevelBlackGold = 5 // 黑金会员
|
|
)
|
|
|
|
const (
|
|
DateTimeFormat = "2006-01-02"
|
|
TimeFormat = "2006-01-02 15:04:05"
|
|
)
|
|
const (
|
|
OpenMemberChannelStorePromotion = "store_promotion" // 门店推荐
|
|
OpenMemberChannelUserInvite = "user_invite"
|
|
OpenMemberChannelRedeemCode = "redeem_code"
|
|
)
|
|
|
|
// gen:qs
|
|
type UserInvite struct {
|
|
Model
|
|
|
|
FromUid uint32 `json:"from_uid"` // 邀请用户id
|
|
UserType uint32 `json:"user_type"` // 用户类型
|
|
StoreId uint64 `json:"store_id"` // 门店id
|
|
MemberOpenTime time.Time `json:"member_open_time"` // 开通会员
|
|
MemberType uint32 `json:"member_type"` // 被邀请用户 1-普通用户 2-会员
|
|
MemberStatus uint8 `json:"member_status"` // 被邀请用户 1-未开通 2-已开通 3-已取消会员
|
|
ToUid uint32 `json:"to_uid"` // 被邀请用户
|
|
StoreType uint32 `json:"store_type"` // 门店类型
|
|
MemberLevel uint32 `json:"member_level"` // 会员等级
|
|
ToUser *UserLess `json:"to_user"` //
|
|
}
|
|
|
|
type UserLess struct {
|
|
Uid uint32 `json:"uid"`
|
|
MemberOpenTime time.Time `json:"member_open_time"` // 开通会员
|
|
MemberLevel uint32 `json:"member_level"` // 会员等级
|
|
}
|
|
|
|
const (
|
|
DepositRefundStatusUnconfirmed = 1 // 待确认
|
|
DepositRefundStatusConfirmed = 2 // 已确认
|
|
DepositRefundStatusRefunded = 3 // 已退款
|
|
DepositRefundStatusRefused = 4 // 已拒绝
|
|
)
|
|
const (
|
|
MemberExpireDelayDailyFee = 200
|
|
)
|
|
|
|
// gen:qs
|
|
type DepositRefundRecord struct {
|
|
Model
|
|
|
|
Uid uint32 `json:"uid"`
|
|
Status uint32 `json:"status"` // 1 // 待确认 2 // 已确认 3 // 已退款 4 // 已拒绝
|
|
Amount uint32 `json:"amount"`
|
|
Operator uint32 `json:"operator"`
|
|
ConfirmTime time.Time `json:"confirm_time"`
|
|
User User `json:"user" gorm:"-"`
|
|
}
|
|
|
|
const (
|
|
//FundTypeMemberGold = "member_gold" // 黄金会员
|
|
//FundTypeMemberPlatinum = "member_platinum" // 白金会员
|
|
//FundTypeMemberBlackGold = "member_black_gold" // 黑金会员
|
|
//FundTypeMemberGoldDeposit = "member_gold_deposit" // 黄金会员押金
|
|
//FundTypeMemberPlatinumDeposit = "member_platinum_deposit" // 白金会员押金
|
|
//FundTypeMemberBlackGoldDeposit = "member_black_gold_platinum" // 黑金会员押金
|
|
|
|
FundTypeMemberFee = "member_fee" // 会员费
|
|
FundTypeMemberDeposit = "member_deposit" // 押金
|
|
FundTypeExpressFee = "express_fee" // 邮费
|
|
FundTypeUpgradeMember = "upgrade_member" // 升级会员
|
|
FundTypeMemberExpireDelay = "member_expire_delay" // 滞纳金
|
|
FundTypeDepositRefund = "deposit_refund" // 退押金
|
|
FundTypeExpressFeeRefund = "express_fee_refund" // 退邮费
|
|
FundTypeBuyGoods = "buy_goods" // 购买商品
|
|
|
|
)
|
|
|
|
// gen:qs
|
|
type FundRecord struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
FundType string `json:"fund_type" gorm:"index"` // -member_gold -member_platinum -member_black_gold
|
|
Amount int64 `json:"amount"`
|
|
TransactionId string `json:"transaction_id" gorm:"index"` // 支付单号
|
|
OutTradeNo string `json:"out_trade_no" gorm:"index"`
|
|
RefundId string `json:"refund_id" gorm:"index"`
|
|
PaymentNo string `json:"payment_no" gorm:"index"` // 付款单号
|
|
Status uint32 `json:"status"` // 1-待支付 2-已支付 3-已退款
|
|
Remark string `json:"remark"` // 备注
|
|
}
|
|
|
|
// gen:qs
|
|
type UserRentCard struct {
|
|
Model
|
|
Uid uint32 `json:"uid"`
|
|
MemberLevel uint32 `json:"member_level"` // 会员等级 1-用户 2-会员
|
|
LevelRentCount uint32 `json:"level_rent_count"` // 等级借卡数量
|
|
HaveRentCount uint32 `json:"have_rent_count"` // 已借卡数量
|
|
CanRentCount uint32 `json:"can_rent_count"` // 可借卡数量
|
|
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"` // 1-已支付
|
|
}
|
|
|
|
// gen:qs
|
|
type XcxRole struct {
|
|
Model
|
|
RoleId uint32 `json:"role_id" gorm:"unique_index,not null"`
|
|
RoleName string `json:"role_name" gorm:"size:255;"` // 角色名称
|
|
RoleKey string `json:"role_key" gorm:"size:255;"` // 角色代码
|
|
RoleSort int `json:"role_sort" gorm:""` // 角色排序
|
|
Status string `json:"status" gorm:"size:255;"` // 状态:1-停用 2-正常
|
|
Flag string `json:"flag" gorm:"size:255;"` //
|
|
CreateBy string `json:"create_by" gorm:"size:255;"` //
|
|
UpdateBy string `json:"update_by" gorm:"size:255;"` //
|
|
Remark string `json:"remark" gorm:"size:255;"` // 备注
|
|
|
|
Params string `json:"params" gorm:"-"`
|
|
MenuIds []int `json:"menuIds" gorm:"-"`
|
|
DeptIds []int `json:"deptIds" gorm:"-"`
|
|
}
|
|
|
|
func GetUserByUid(uid uint32) *User {
|
|
user := new(User)
|
|
if err := NewUserQuerySet(DB).UidEq(uid).One(user); err != nil {
|
|
logger.Error(err, uid)
|
|
return nil
|
|
}
|
|
return user
|
|
}
|
|
|
|
func GetUserRentCard(uid uint32) *UserRentCard {
|
|
userRent := new(UserRentCard)
|
|
if err := NewUserRentCardQuerySet(DB).UidEq(uid).One(userRent); err != nil {
|
|
logger.Error(err, uid)
|
|
return nil
|
|
}
|
|
return userRent
|
|
}
|
|
|
|
func UserUpdate(user *User) error {
|
|
if user.Uid == 0 {
|
|
return errors.New("uid is null")
|
|
}
|
|
fields := make([]UserDBSchemaField, 0)
|
|
if user.WxName != "" {
|
|
fields = append(fields, UserDBSchema.WxName)
|
|
}
|
|
if user.WxAvatar != "" {
|
|
fields = append(fields, UserDBSchema.WxAvatar)
|
|
}
|
|
if user.Tel != "" {
|
|
fields = append(fields, UserDBSchema.Tel)
|
|
}
|
|
if user.MemberLevel != 0 {
|
|
fields = append(fields, UserDBSchema.MemberLevel)
|
|
fields = append(fields, UserDBSchema.MemberExpire)
|
|
}
|
|
if user.Deposit != 0 {
|
|
fields = append(fields, UserDBSchema.Deposit)
|
|
}
|
|
|
|
if len(fields) > 0 {
|
|
err := user.Update(DB.Where(&User{Uid: user.Uid}), fields...)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单
|
|
|
|
// gen:qs
|
|
type UserOpenMemberRecord struct {
|
|
Model
|
|
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
OpenNo string `json:"open_no" gorm:"index"`
|
|
OrderId uint32 `json:"order_id" gorm:"index"`
|
|
OrderType uint32 `json:"order_type"`
|
|
MemberLevel uint32 `json:"member_level"`
|
|
MemberExpire time.Time `json:"member_expire"` // 会员到期时间
|
|
|
|
Order *Order `json:"order" gorm:"-"`
|
|
ShareCardRetrieve *ShareCardRetrieve `json:"share_card_retrieve" gorm:"-"`
|
|
GoodsOrder *GoodsOrder `json:"goods_order" gorm:"-"`
|
|
//Attach string `json:"attach"`
|
|
}
|
|
|
|
func (o *UserOpenMemberRecord) TableName() string {
|
|
return "user_open_member_record"
|
|
}
|
|
|
|
func (m UserOpenMemberRecord) Insert() error {
|
|
err := m.Create(DB)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
LogCorrelationOrderId = "order_id"
|
|
LogCorrelationOrderCard = "order_card_id"
|
|
)
|
|
const (
|
|
OperationTypeRentCardRevert = "rent_card_revert"
|
|
OperationTypeRentCardDeliver = "rent_card_deliver"
|
|
OperationTypeGameCardGoodsInStock = "game_card_goods_in_stock" // 入库
|
|
)
|
|
|
|
// gen:qs
|
|
type OperationLog struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"` // 店员id
|
|
SysUid uint32 `json:"sys_uid" gorm:"index"`
|
|
Description string `json:"description"` // 描述
|
|
OperationType string `json:"operation_type" gorm:"index"` // 操作类型
|
|
CorrelationId uint32 `json:"correlation_id" gorm:"index"` // 关联id
|
|
CorrelationName string `json:"correlation_name" gorm:"index"` // 关联name
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
StoreName string `json:"store_name"` // 门店名称
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
SerialNumber string `json:"serial_number" gorm:"index"` // 卡编号
|
|
Detail string `json:"detail"` // 详情
|
|
Remark string `json:"remark"` // 备注
|
|
}
|
|
|
|
func (m *UserOpenMemberRecord) OrderRefund(outTradeNo string) error {
|
|
if m.Order == nil {
|
|
return errors.New("order is nil")
|
|
}
|
|
if m.OpenNo == "" {
|
|
m.OpenNo = GetOrderSn()
|
|
}
|
|
m.Uid = uint32(m.Order.Uid)
|
|
m.OrderId = m.Order.ID
|
|
|
|
err := m.Refund(outTradeNo, m.Order.PayPrice)
|
|
if err != nil {
|
|
logger.Error("refund err:", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *UserOpenMemberRecord) MallGoodsOrderRefund(outTradeNo string) error {
|
|
if m.GoodsOrder == nil {
|
|
return errors.New("goods order is nil")
|
|
}
|
|
if m.OpenNo == "" {
|
|
m.OpenNo = GetOrderSn()
|
|
}
|
|
m.Uid = uint32(m.GoodsOrder.Uid)
|
|
m.OrderId = m.GoodsOrder.ID
|
|
|
|
err := m.Refund(outTradeNo, m.GoodsOrder.Rm)
|
|
if err != nil {
|
|
logger.Error("refund err:", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// gen:qs
|
|
type InviteMemberReport struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"` // 店员uid
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
GoldCount uint32 `json:"gold_count"` // 黄金数量
|
|
PlatinumCount uint32 `json:"platinum_count"` // 白金数量
|
|
BlackGoldCount uint32 `json:"black_gold_count"` // 黑金数量
|
|
//ReportTime string `json:"report_time" gorm:"index"` // 业绩时间
|
|
Date string `json:"date" gorm:"index"` // 业绩时间
|
|
DeductAmount uint32 `json:"deduct_amount"` // 店员提成
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
GoldDeduct uint32 `json:"gold_deduct"` // 黄金会员提成
|
|
PlatinumDeduct uint32 `json:"platinum_deduct"` // 白金会员提成
|
|
BlackGoldDeduct uint32 `json:"black_gold_deduct"` // 黑金会员提成
|
|
// invite_member_report
|
|
User *User `json:"user" gorm:"-"`
|
|
}
|
|
|
|
func (m *UserOpenMemberRecord) Refund(outTradeNo string, amount uint32) error {
|
|
configInfo, err := PayConfigInfo()
|
|
if err != nil {
|
|
logger.Error("config info err:", err)
|
|
return err
|
|
}
|
|
//configInfo.NotifyUrl = "https://dev.switch.deovo.com:8004/api/v1/wxpay_refund/notice"
|
|
err = m.Insert()
|
|
if err != nil {
|
|
logger.Error("insert user open member record err:", err)
|
|
return err
|
|
}
|
|
|
|
orderRefund := wxpay.OrderRefund{
|
|
OutTradeNo: outTradeNo,
|
|
OutRefundNo: m.OpenNo,
|
|
NotifyUrl: configInfo.RefundNotifyUrl,
|
|
Amount: wxpay.OrderRefundAmount{
|
|
Refund: amount,
|
|
Total: amount,
|
|
Currency: "CNY",
|
|
},
|
|
}
|
|
err = wxpay.TransactionOrderRefund(orderRefund)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
|
|
//FundRecord{
|
|
// Uid: m.Uid,
|
|
// FundType: FundTypeExpressFeeRefund,
|
|
// Amount: int64(m.Order.PayPrice) * (-1),
|
|
// TransactionId: "",
|
|
// OutTradeNo: "",
|
|
// Status: 0,
|
|
// Remark: "",
|
|
//}
|
|
return nil
|
|
}
|
|
|
|
//func (m *UserOpenMemberRecord) ShareCardRetrieveRefund(outTradeNo string) error {
|
|
// //if m.ShareCardRetrieve == nil {
|
|
// // return errors.New("order is nil")
|
|
// //}
|
|
// //if m.OpenNo == "" {
|
|
// // m.OpenNo = GetShareCardRetrieveOrderSn()
|
|
// //}
|
|
// //m.Uid = uint32(m.Order.Uid)
|
|
// //m.OrderId = m.ShareCardRetrieve.ID
|
|
// //configInfo, err := PayConfigInfo()
|
|
// //if err != nil {
|
|
// // logger.Error("config info err:", err)
|
|
// // return err
|
|
// //}
|
|
// //
|
|
// //err = m.Insert()
|
|
// //if err != nil {
|
|
// // logger.Error("insert user open member record err:", err)
|
|
// // return err
|
|
// //}
|
|
// //
|
|
// //orderRefund := wxpay.OrderRefund{
|
|
// // OutTradeNo: outTradeNo,
|
|
// // OutRefundNo: m.OpenNo,
|
|
// // NotifyUrl: configInfo.NotifyUrl,
|
|
// // Amount: wxpay.OrderRefundAmount{
|
|
// // Refund: m.ShareCardRetrieve.PayAmount,
|
|
// // Total: m.ShareCardRetrieve.PayAmount,
|
|
// // Currency: "CNY",
|
|
// // },
|
|
// //}
|
|
// //err = wxpay.TransactionOrderRefund(orderRefund)
|
|
// //if err != nil {
|
|
// // logger.Error("err:", err)
|
|
// // return err
|
|
// //}
|
|
// return nil
|
|
//}
|
|
|
|
func (m *UserOpenMemberRecord) GetByOpenNo() error {
|
|
err := NewUserOpenMemberRecordQuerySet(DB).OpenNoEq(m.OpenNo).One(m)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// gen:qs
|
|
type CommonProblem struct {
|
|
Model
|
|
|
|
Question string `json:"question"`
|
|
Answer string `json:"answer" gorm:"type:text"`
|
|
Sort uint32 `json:"sort" gorm:"index"`
|
|
}
|
|
|
|
type GroupSendMessageTemplate struct {
|
|
Model
|
|
|
|
Title string `json:"title" `
|
|
Message string `json:"message"`
|
|
UserType uint32 `json:"user_type" gorm:"index,column:user_type"` // 1-所有用户 2-会员 3-非会员 4-指定用户
|
|
SendTime time.Time `json:"send_time"`
|
|
Tels string `json:"tels"`
|
|
Status uint32 `json:"status"` // 1-待发送 2-已发送
|
|
}
|
|
|
|
func (*CommonProblem) TableName() string {
|
|
return "common_problem"
|
|
}
|
|
|
|
func (*CommonProblem) List() ([]CommonProblem, error) {
|
|
commons := make([]CommonProblem, 0)
|
|
err := NewCommonProblemQuerySet(DB).OrderDescBySort().All(&commons)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return commons, err
|
|
}
|
|
return commons, err
|
|
}
|
|
|
|
func (m *User) AppletQRCodeUpdate() error {
|
|
num, err := NewUserQuerySet(DB).UidEq(m.Uid).GetUpdater().SetInviteCodeUrl(m.InviteCodeUrl).UpdateNum()
|
|
if err != nil || num != 1 {
|
|
logger.Error("AppletQRCodeUpdate err")
|
|
return errors.New("AppletQRCodeUpdate err")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type UserInviteListReq struct {
|
|
Page int `json:"page"`
|
|
PageSize int `json:"page_size"`
|
|
Uid uint32 `json:"uid"`
|
|
MemberType int `json:"member_type"` // 0-全部 1-普通用户 2-会员
|
|
StartTime string `json:"start_time"` // 开始时间
|
|
EndTime string `json:"end_time"` // 结束时间
|
|
}
|
|
|
|
type UserInviteListResp struct {
|
|
Page int `json:"page"`
|
|
TotalPage int `json:"total_page"`
|
|
List []UserInviteList `json:"list"`
|
|
Count int `json:"count"`
|
|
}
|
|
|
|
type UserInviteList struct {
|
|
User User `json:"user"`
|
|
UserInvite UserInvite `json:"user_invite"`
|
|
}
|
|
|
|
func (m *UserInviteListReq) InviteUserList() (*UserInviteListResp, error) {
|
|
list := make([]User, 0)
|
|
resp := &UserInviteListResp{
|
|
Page: m.Page,
|
|
List: make([]UserInviteList, 0),
|
|
}
|
|
page := m.Page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
|
|
qs := NewUserInviteQuerySet(DB).FromUidEq(m.Uid)
|
|
if m.MemberType != 0 {
|
|
qs = qs.MemberTypeEq(uint32(m.MemberType))
|
|
}
|
|
if m.StartTime != "" {
|
|
parse, err := time.Parse(DateTimeFormat, m.StartTime)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return resp, err
|
|
}
|
|
if m.MemberType == 2 {
|
|
qs = qs.MemberOpenTimeGte(parse)
|
|
} else {
|
|
qs = qs.CreatedAtGte(parse)
|
|
}
|
|
}
|
|
if m.EndTime != "" {
|
|
parse, err := time.Parse(DateTimeFormat, m.EndTime)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return resp, err
|
|
}
|
|
if m.MemberType == 2 {
|
|
qs = qs.MemberOpenTimeLte(parse.AddDate(0, 0, 1))
|
|
} else {
|
|
qs = qs.CreatedAtLte(parse.AddDate(0, 0, 1))
|
|
}
|
|
}
|
|
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
resp.TotalPage = count/m.PageSize + 1
|
|
resp.Count = count
|
|
|
|
var invites []UserInvite
|
|
//err = qs.Offset(page * m.PageSize).Limit(m.PageSize).OrderDescByID().All(&invites)
|
|
err = qs.Offset(page * m.PageSize).Limit(m.PageSize).OrderDescByMemberOpenTime().All(&invites)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
if len(invites) == 0 {
|
|
return resp, nil
|
|
}
|
|
uids := make([]uint32, 0)
|
|
inviteMap := make(map[uint32]UserInvite, 0)
|
|
for i, _ := range invites {
|
|
uids = append(uids, invites[i].ToUid)
|
|
inviteMap[invites[i].ToUid] = invites[i]
|
|
}
|
|
err = NewUserQuerySet(DB).UidIn(uids...).All(&list)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
|
|
userMap := make(map[uint32]User, 0)
|
|
for i, _ := range list {
|
|
userMap[list[i].Uid] = list[i]
|
|
}
|
|
//users := make([]User, 0)
|
|
users := make([]UserInviteList, 0)
|
|
for i, _ := range uids {
|
|
user, ok1 := userMap[uids[i]]
|
|
invite, ok2 := inviteMap[uids[i]]
|
|
if !ok1 || !ok2 {
|
|
continue
|
|
}
|
|
userInvite := UserInviteList{
|
|
User: user,
|
|
UserInvite: invite,
|
|
}
|
|
|
|
users = append(users, userInvite)
|
|
}
|
|
resp.List = users
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
func GetOrderSn() string {
|
|
var orderSn string
|
|
for {
|
|
//orderSn = utils.GetSerialNo32HEXString()
|
|
orderSn = utils.GenSerialNo()
|
|
count, err := NewUserOpenMemberRecordQuerySet(DB).OpenNoEq(orderSn).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
if count == 0 {
|
|
break
|
|
}
|
|
}
|
|
return orderSn
|
|
}
|
|
|
|
func GetShareCardBillSn() string {
|
|
var billSn string
|
|
for {
|
|
//billSn = utils.GetSerialNo32HEXString()
|
|
billSn = utils.GenSerialNo()
|
|
count, err := NewUserShareCardBillQuerySet(DB).BillSnEq(billSn).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
if count == 0 {
|
|
break
|
|
}
|
|
}
|
|
return billSn
|
|
}
|
|
|
|
func GetShareCardRetrieveOrderSn() string {
|
|
var orderSn string
|
|
for {
|
|
//orderSn = utils.GetSerialNo32HEXString()
|
|
orderSn = utils.GenSerialNo()
|
|
count, err := NewShareCardRetrieveQuerySet(DB).OrderSnEq(orderSn).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
if count == 0 {
|
|
break
|
|
}
|
|
}
|
|
return orderSn
|
|
}
|
|
|
|
func (m *User) Edit() {
|
|
err := DB.Save(m).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func GetWxPayExpressFeeRefundRecord(orderId uint32) (string, error) {
|
|
var openMemberRecord UserOpenMemberRecord
|
|
//err := NewUserOpenMemberRecordQuerySet(DB).OrderIdEq(orderId).OrderTypeEq(1).
|
|
//OrderDescByID().Limit(1).One(&openMemberRecord)
|
|
err := NewUserOpenMemberRecordQuerySet(DB).OrderIdEq(orderId).OrderDescByID().
|
|
Limit(1).One(&openMemberRecord)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return "", err
|
|
}
|
|
return openMemberRecord.OpenNo, nil
|
|
}
|
|
|
|
func GetDepositRefundRecordList(uid uint32) ([]DepositRefundRecord, error) {
|
|
var deposits []DepositRefundRecord
|
|
err := NewDepositRefundRecordQuerySet(DB).UidEq(uid).OrderDescByID().All(&deposits)
|
|
if err != nil {
|
|
logger.Error("deposit refund record err:", err)
|
|
return deposits, err
|
|
}
|
|
return deposits, nil
|
|
}
|
|
|
|
var userMutexMap map[string]*sync.Mutex
|
|
|
|
func GetUserMutexMap() map[string]*sync.Mutex {
|
|
if userMutexMap == nil {
|
|
userMutexMap = make(map[string]*sync.Mutex, 0)
|
|
}
|
|
return userMutexMap
|
|
}
|
|
|
|
func GetUserMutex(mutexKey string) *sync.Mutex {
|
|
mutexMap := GetUserMutexMap()
|
|
if v, ok := mutexMap[mutexKey]; ok {
|
|
return v
|
|
} else {
|
|
mutexMap[mutexKey] = new(sync.Mutex)
|
|
return mutexMap[mutexKey]
|
|
}
|
|
}
|
|
|
|
//func AuthLoginMutex(uid uint32) *sync.Mutex {
|
|
// return GetUserMutex(fmt.Sprintf("AuthLogin:%d", uid))
|
|
//}
|
|
|
|
var AuthLoginMutex = sync.Mutex{}
|
|
|
|
func OrderCardUserRentCard(uid uint32, count uint32, memberConfig *MemberConfig, gdb *gorm.DB) error {
|
|
//UserRentCard{}
|
|
if gdb == nil {
|
|
gdb = DB
|
|
}
|
|
var userRentCard UserRentCard
|
|
err := NewUserRentCardQuerySet(DB).UidEq(uid).One(&userRentCard)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
if err == RecordNotFound {
|
|
user := GetUserByUid(uid)
|
|
if user == nil {
|
|
logger.Error("user nil")
|
|
return errors.New("user nil")
|
|
}
|
|
if memberConfig == nil {
|
|
memberConfig, err = GetMemberConfig(user.MemberLevel)
|
|
if err != nil {
|
|
logger.Error("GetMemberConfig err:", err)
|
|
return err
|
|
}
|
|
}
|
|
rentCard := &UserRentCard{
|
|
Uid: uid,
|
|
MemberLevel: user.MemberLevel,
|
|
LevelRentCount: memberConfig.CardMax,
|
|
HaveRentCount: uint32(count),
|
|
CanRentCount: uint32(memberConfig.CardMax - count),
|
|
Status: 0,
|
|
}
|
|
err := gdb.Create(rentCard).Error
|
|
if err != nil {
|
|
logger.Error("err", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
sql := fmt.Sprintf("UPDATE user_rent_card SET have_rent_count=have_rent_count+%d ,can_rent_count=can_rent_count-%d WHERE uid = %d", count, count, uid)
|
|
err = gdb.Exec(sql).Error
|
|
if err != nil {
|
|
logger.Error("err", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ShoppingCartCreateOrder(uid uint32, cards []CardInfo) {
|
|
cardIds := make([]uint64, 0, len(cards))
|
|
for i, _ := range cards {
|
|
cardIds = append(cardIds, uint64(cards[i].GameCardId))
|
|
}
|
|
err := NewShoppingCartQuerySet(DB).UidEq(uint64(uid)).GameCardIdIn(cardIds...).Delete()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func ShoppingCartCreateOrderByOrder(order Order) {
|
|
var orderCards []OrderCard
|
|
err := NewOrderCardQuerySet(DB).OrderIdEq(order.ID).All(&orderCards)
|
|
if err != nil {
|
|
logger.Error("err:", err.Error())
|
|
}
|
|
cardIds := make([]uint64, 0, len(orderCards))
|
|
for i, _ := range orderCards {
|
|
cardIds = append(cardIds, uint64(orderCards[i].GameCardId))
|
|
}
|
|
err = NewShoppingCartQuerySet(DB).UidEq(uint64(order.Uid)).GameCardIdIn(cardIds...).Delete()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func CreateUserRentCardByMemberLevel(uid, memberLevel, cardMax uint32) {
|
|
var userRentCard UserRentCard
|
|
err := NewUserRentCardQuerySet(DB).UidEq(uid).One(&userRentCard)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("UserRentCard err:", err)
|
|
return
|
|
}
|
|
|
|
if err == RecordNotFound {
|
|
userRentCard = UserRentCard{
|
|
Uid: uid,
|
|
MemberLevel: memberLevel,
|
|
LevelRentCount: cardMax,
|
|
HaveRentCount: 0,
|
|
CanRentCount: cardMax,
|
|
Status: 0,
|
|
}
|
|
err := DB.Create(&userRentCard).Error
|
|
if err != nil {
|
|
logger.Error("UserRentCard create err:", err)
|
|
}
|
|
return
|
|
}
|
|
_, err = NewUserRentCardQuerySet(DB).IDEq(userRentCard.ID).GetUpdater().
|
|
SetMemberLevel(memberLevel).
|
|
SetCanRentCount(cardMax - userRentCard.HaveRentCount).
|
|
SetLevelRentCount(cardMax).UpdateNum()
|
|
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
|
|
}
|
|
|
|
func (m *OperationLog) AddLog() {
|
|
defer func() {
|
|
if err := recover(); err != nil {
|
|
fmt.Println("recover err:", err)
|
|
}
|
|
}()
|
|
go func() {
|
|
err := DB.Create(m).Error
|
|
if err != nil {
|
|
logger.Error("create operation log err:")
|
|
}
|
|
}()
|
|
}
|
|
|
|
type InviteMemberReportListReq struct {
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
Uid uint32 `json:"uid"`
|
|
}
|
|
|
|
func (m *InviteMemberReportListReq) List() ([]InviteMemberReport, int, error) {
|
|
var memberReport []InviteMemberReport
|
|
qs := NewInviteMemberReportQuerySet(DB).UidEq(m.Uid)
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return memberReport, 0, err
|
|
}
|
|
page := m.PageNum - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
totalPage := count/m.PageSize + 1
|
|
|
|
err = qs.Offset(page * m.PageSize).Limit(m.PageSize).OrderDescByID().All(&memberReport)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return memberReport, totalPage, err
|
|
}
|
|
|
|
assistant := GetUserByUid(m.Uid)
|
|
cooperative := new(CooperativeBusiness)
|
|
cooperative.ID = assistant.CooperativeBusinessId
|
|
cooperative.SetAssistantMemberDeductConfig(uint32(assistant.StoreId))
|
|
fmt.Println("CooperativeBusinessId:", assistant.CooperativeBusinessId, assistant.StoreId)
|
|
fmt.Println("CooperativeAssistantMemberDeduct:", cooperative.CooperativeAssistantMemberDeduct)
|
|
if len(memberReport) > 0 {
|
|
memberReport[len(memberReport)-1].GoldDeduct = cooperative.CooperativeAssistantMemberDeduct.GoldDeduct
|
|
memberReport[len(memberReport)-1].PlatinumDeduct = cooperative.CooperativeAssistantMemberDeduct.PlatinumDeduct
|
|
memberReport[len(memberReport)-1].BlackGoldDeduct = cooperative.CooperativeAssistantMemberDeduct.BlackGoldDeduct
|
|
|
|
report := memberReport[len(memberReport)-1]
|
|
fmt.Println("report:", report)
|
|
memberReport[len(memberReport)-1].DeductAmount += report.GoldCount * report.GoldDeduct
|
|
memberReport[len(memberReport)-1].DeductAmount += report.PlatinumCount * report.PlatinumDeduct
|
|
memberReport[len(memberReport)-1].DeductAmount += report.BlackGoldCount * report.BlackGoldDeduct
|
|
}
|
|
|
|
return memberReport, totalPage, nil
|
|
}
|
|
|
|
func GetUserMap(ids []uint32) (map[uint32]*User, error) {
|
|
userMap := make(map[uint32]*User, 0)
|
|
if len(ids) == 0 {
|
|
return userMap, nil
|
|
}
|
|
var users []User
|
|
err := NewUserQuerySet(DB).UidIn(ids...).All(&users)
|
|
if err != nil {
|
|
logger.Error("user err:", err)
|
|
return userMap, err
|
|
}
|
|
for i, _ := range users {
|
|
userMap[users[i].Uid] = &users[i]
|
|
}
|
|
return userMap, nil
|
|
}
|
|
|
|
func (u *User) SetVm() error {
|
|
var userVm UserVm
|
|
err := NewUserVmQuerySet(DB).UidEq(u.Uid).One(&userVm)
|
|
if err != nil {
|
|
log.Error().Msgf("UserVm err:%#v", err)
|
|
return err
|
|
}
|
|
u.UserVm = &userVm
|
|
return nil
|
|
}
|
|
|
|
func UserInviteListSetToUser(list []UserInvite) {
|
|
ids := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
ids = append(ids, list[i].ToUid)
|
|
}
|
|
|
|
userMap, err := GetUserMap(ids)
|
|
if err != nil {
|
|
logger.Error("user map err:", err)
|
|
return
|
|
}
|
|
|
|
for i, _ := range list {
|
|
v, ok := userMap[list[i].ToUid]
|
|
if ok {
|
|
|
|
list[i].ToUser = &UserLess{
|
|
Uid: v.Uid,
|
|
MemberOpenTime: v.OpenMemberTime,
|
|
MemberLevel: v.MemberLevel,
|
|
}
|
|
}
|
|
}
|
|
}
|