mh_server/model/user.go

package model

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/jinzhu/gorm"
	"github.com/rs/zerolog/log"
	"mh-server/lib/utils"
	"mh-server/lib/wxpay"
	"sort"
	"strings"
	"sync"
	"time"
)

// gen:qs
//
//go:generate goqueryset -in user.go
type User struct {
	Model

	Uid                   uint32      `json:"uid" gorm:"column:uid;unique_index"`
	MemberLevel           uint32      `json:"member_level"`                         // 当前会员等级:10-普通用户 1-普通会员 2-黄金会员 4-白金会员 5-黑金会员
	MemberGenre           uint32      `json:"member_genre"`                         // 会员类型
	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"`                           // 微信openid
	AppOpenID             string      `json:"app_open_id"`                          //
	WxUnionID             string      `json:"wx_union_id"`                          // 微信uniodid
	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"`                  // 店员名称
	OpenMemberLevel       uint32      `json:"open_member_level"`                    // 开通会员级别：2-黄金会员 4-白金会员 5-黑金会员
	FirstRetailOrder      time.Time   `json:"first_retail_order"`                   //
	Version               uint32      `json:"-"`                                    //
	UserVm                *UserVm     `json:"user_vm" gorm:"-"`                     //
	InviteTime            time.Time   `json:"invite_time"`                          //
	DepositType           uint32      `json:"deposit_type"`                         // 押金类型: 3-未充值
	StoreList             []StoreInfo `gorm:"-" json:"store_list"`                  // 有效门店列表
	RoleId                uint32      `json:"role_id" gorm:"-"`                     // 角色id
	//RenewalTime           time.Time `json:"renewal_time"`
	//RenewalMemberLevel    uint32    `json:"renewal_member_level"`
	//MemberLevelString string    `json:"member_level_string" gorm:"-"` // 会员类型
}

type AuthLoginReq struct {
	Code          string `json:"code" binding:"required"` // 小程序code码
	InviteUid     uint32 `json:"invite_uid"`              // 邀请人用户ID
	EncryptedData string `json:"encrypted_data" binding:"required"`
	Iv            string `json:"iv" binding:"required"`
	//RawData       string `json:"raw_data" binding:"required"`
	//Signature     string `json:"signature" binding:"required"`
	//Tel       string `json:"tel"`                     // 手机号
	//WxName    string `json:"wx_name"`                 // 昵称
	//WxAvatar  string `json:"wx_avatar"`               // 头像
}

type AuthLoginResp struct {
	AccessToken     string    `json:"access_token"`
	AccessExpire    int64     `json:"access_expire"`
	RefreshToken    string    `json:"refresh_token"`
	RefreshExpire   int64     `json:"refresh_expire"`
	Uid             uint32    `json:"uid"`
	AccessCreatedAt time.Time `json:"access_created_at"`
}

func (o *User) TableName() string {
	return "user"
}

const (
	MemberGenreYear     = 200 // 短期会员：黄金年费会员
	MemberGenreQuarter  = 201 // 短期会员：黄金季度会员
	MemberGenreHalfYear = 202 // 短期会员：黄金半年会员
)

const (
	MemberLevelConsumer  = 10 // 普通用户:有开过零售单，留了手机号，但是小程序端未登陆过的，仍然是普通用户
	MemberLevelUser      = 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"`             // 用户类型 1-普通用户 邀请用户类型
	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"`            // 门店类型  1-自有 2-合作商
	Action             uint32    `json:"action"`                // 1-未激活 2-激活邀请 表示：该会员是开通还是续费
	SpendType          uint32    `json:"spend_type"`            // 1-未开通 2-开通会员 3-续费 4-升级 5-店员推广续费
	MemberLevel        uint32    `json:"member_level"`          // 会员等级
	MemberGenre        uint32    `json:"member_genre"`          // 会员类型
	UserInviteRecordId uint32    `json:"user_invite_record_id"` // 邀请记录
	FirstInvite        uint32    `json:"first_invite"`          // 首次邀请标志：1 首次邀请 0 非首次
	Scan               uint32    `json:"scan"`                  // 扫码
	InviteForm         uint32    `json:"invite_form"`           // 邀请方式: 1-店员邀请码续费
	RenewHide          uint32    `json:"renew_hide"`            // 自动续费 1-自动 0-干预
	//InviteTime         time.Time `json:"invite_time"`           // 邀请时间
	ToUser *User `json:"to_user" gorm:"-"`

	//ToUser             *UserLess `json:"to_user" gorm:"-"`      //
}

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 (
	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"           // 购买商品
	FundTypeBuyGoodsCancel    = "buy_goods_cancel"    // 购买商品取消订单
	FundTypeBuyGoodsRefund    = "buy_goods_refund"    // 购买商品退货
	FundTypeRecycleCard       = "recycle_card"        // 回收卡带
	FundTypePostagePackageFee = "postage_package_fee" // 购买运费包
)

// 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:"-"`
}

// gen:qs
// ShopperPromotionCode 店员优惠码
type ShopperPromotionCode struct {
	Model

	Uid     uint32 `json:"uid" gorm:"column:uid;index"`
	State   uint32 `json:"state"` // 1-停用 2-使用
	Code    string `json:"code"  gorm:"index"`
	StoreId uint32 `json:"store_id"` // 门店id
	// shopper_promotion_code
}

func GetUserByUid(uid uint32) *User {
	user := new(User)
	if err := NewUserQuerySet(DB).UidEq(uid).One(user); err != nil {
		logger.Error(err, uid)
		return user
	}
	return user
}

const StoreDateTimeFormat = "2006.01.02"

// GetUserEffectiveStore 获取店员当前的有效门店（邀请客户时使用）
func GetUserEffectiveStore(uid uint32) (*StoreInfo, error) {
	if uid == 0 {
		return &StoreInfo{}, nil
	}

	user := new(SysUser)
	if err := NewSysUserQuerySet(DB).UidEq(uid).One(user); err != nil {
		logger.Error("Error:", err, "UID:", uid)
		return &StoreInfo{}, err
	}

	var userStores []StoreInfo
	if user.RoleId == 1 { // 系统管理员
		var stores []Store
		err := NewStoreQuerySet(DB).CooperativeBusinessIdEq(user.CooperativeBusinessId).All(&stores)
		if err != nil {
			return &StoreInfo{}, err
		}

		for _, item := range stores {
			tempStore := StoreInfo{
				StoreID:    uint64(item.ID),
				StoreName:  item.Name,
				ExpireTime: "2099.12.30",
			}
			userStores = append(userStores, tempStore)
		}
	} else { // 普通用户
		// 解析门店数据
		if err := json.Unmarshal([]byte(user.StoreData), &userStores); err != nil {
			return &StoreInfo{}, err
		}

		if len(userStores) == 0 {
			return &StoreInfo{}, errors.New("no stores found")
		}
	}

	// 当前时间
	now := time.Now()

	// 过滤掉过期的门店
	validStores := make([]StoreInfo, 0)
	for _, store := range userStores {
		expireTime, err := time.Parse(StoreDateTimeFormat, store.ExpireTime)
		if err != nil {
			logger.Error("Error parsing time:", err, "ExpireTime:", store.ExpireTime)
			continue
		}

		// 包含当天有效时间
		expireTime = expireTime.Add(24*time.Hour - time.Second)
		if expireTime.After(now) {
			validStores = append(validStores, store)
		}
	}

	if len(validStores) == 0 {
		return &StoreInfo{}, nil
	}

	// 按有效时间和 store_id 排序
	sort.Slice(validStores, func(i, j int) bool {
		timeI, _ := time.Parse(StoreDateTimeFormat, validStores[i].ExpireTime)
		timeJ, _ := time.Parse(StoreDateTimeFormat, validStores[j].ExpireTime)

		if timeI.Equal(timeJ) {
			return validStores[i].StoreID < validStores[j].StoreID
		}
		return timeI.Before(timeJ)
	})

	return &validStores[0], nil
}

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)
	}
	if !user.MemberExpire.IsZero() {
		fields = append(fields, UserDBSchema.MemberExpire)
	}
	if user.Deposit != 0 {
		fields = append(fields, UserDBSchema.Deposit)
	}
	if user.WxOpenID != "" {
		fields = append(fields, UserDBSchema.WxOpenID)
	}
	if user.WxUnionID != "" {
		fields = append(fields, UserDBSchema.WxUnionID)
	}
	if !user.LastLoginAt.IsZero() {
		fields = append(fields, UserDBSchema.LastLoginAt)
	}
	if !user.CreatedAt.IsZero() {
		fields = append(fields, UserDBSchema.CreatedAt)
	}

	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-购买商品取消订单 8-购买商品订单退货 9-升级会员 10-开通 续费 11-运费包

// 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"`
	MemberGenre   uint32    `json:"member_genre"`
	MemberExpire  time.Time `json:"member_expire"`               // 会员到期时间
	UserCouponId  uint32    `json:"user_coupon_id" gorm:"index"` // 优惠券id
	State         uint32    `json:"state"`                       // 1-未处理 2-已处理
	DeductionDays uint32    `json:"deduction_days"`
	DeductionFee  uint32    `json:"deduction_fee"`

	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"
	LogCorrelationRecycleCardOrderId = "recycle_card_order_id"
)
const (
	OperationTypeRentCardRevert              = "rent_card_revert"
	OperationTypeRentCardDeliver             = "rent_card_deliver"
	OperationTypeGameCardGoodsInStock        = "game_card_goods_in_stock"        // 入库
	OperationTypeRecycleCardOrderImageUpdate = "recycle_card_order_image_update" // 回收卡上传图片
)

// 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"`                               // 备注
}

// 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")
	}
	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"`            // 黄金数量
	GoldCountHalf    uint32 `json:"gold_count_half"`       // 半年黄金数量
	GoldCountQuarter uint32 `json:"gold_count_quarter"`    // 季度黄金数量
	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"`                                       // 黑金会员提成
	RenewalGoldCount                  uint32 `json:"renewal_gold_count"`                                      // 续费年度黄金会员数量（自动）
	RenewalGoldCountHalf              uint32 `json:"renewal_gold_count_half"`                                 // 续费半年黄金会员数量（自动）
	RenewalGoldCountQuarter           uint32 `json:"renewal_gold_count_quarter"`                              // 续费季度黄金会员数量（自动）
	RenewalPlatinumCount              uint32 `json:"renewal_platinum_count"`                                  // 续费白金会员数量（自动）
	RenewalBlackGoldCount             uint32 `json:"renewal_black_gold_count"`                                // 续费黑金会员数量（自动）
	UpgradeGoldToPlatinumCount        uint32 `json:"upgrade_gold_to_platinum_count" gorm:"default:0"`         // 升级：黄金->白金数量（自动）
	UpgradeGoldToBlackCount           uint32 `json:"upgrade_gold_to_black_count" gorm:"default:0"`            // 升级：黄金->黑金数量（自动）
	UpgradePlatinumToBlackCount       uint32 `json:"upgrade_platinum_to_black_count" gorm:"default:0"`        // 升级：白金->黑金数量（自动）
	InviteRenewalGoldCount            uint32 `json:"invite_renewal_gold_count"`                               // 续费黄金会员数量（干预）
	InviteRenewalPlatinumCount        uint32 `json:"invite_renewal_platinum_count"`                           // 续费白金会员数量（干预）
	InviteRenewalBlackGoldCount       uint32 `json:"invite_renewal_black_gold_count"`                         // 续费黑金会员数量（干预）
	InviteUpgradeGoldToPlatinumCount  uint32 `json:"invite_upgrade_gold_to_platinum_count" gorm:"default:0"`  // 升级：黄金->白金数量（干预）
	InviteUpgradeGoldToBlackCount     uint32 `json:"invite_upgrade_gold_to_black_count" gorm:"default:0"`     // 升级：黄金->黑金数量（干预）
	InviteUpgradePlatinumToBlackCount uint32 `json:"invite_upgrade_platinum_to_black_count" gorm:"default:0"` // 升级：白金->黑金数量（干预）

	// 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.HmRefundTransaction(orderRefund)
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	//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"`         // 当前用户ID
	MemberType int    `json:"member_type"` // 会员类型：0-全部 1-普通用户 2-会员
	SpendType  uint32 `json:"spend_type"`  // 操作类型：2-开通会员 3-续费 4-升级
	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"`
	List  []UserInvite `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([]UserInvite, 0),
	}
	page := m.Page - 1
	if page < 0 {
		page = 0
	}

	if m.PageSize == 0 {
		m.PageSize = 10
	}

	qs := NewUserInviteQuerySet(DB).FromUidEq(m.Uid).ActionEq(2) // action=2，激活邀请
	if m.MemberType != 0 {
		qs = qs.MemberTypeEq(uint32(m.MemberType))
		if m.MemberType == 2 { // 查询会员数据
			user := GetUserByUid(m.Uid)
			//qs = qs.FirstInviteNe(1).SpendTypeEq(2)
			//qs = qs.SpendTypeEq(2)
			//qs = qs.SpendTypeNotIn([]uint32{3, 4}...)
			if user.CooperativeBusinessId == 1 { // 合作商为迪为
				if m.SpendType != 0 {
					qs = qs.SpendTypeEq(m.SpendType)
					if m.SpendType == 3 { // 如果是3-续费，则查询是否为店员推广续费，即：invite_form = 1
						qs = qs.InviteFormEq(1)
					}
				} else { // 如果没有指定spend_type，则默认查询2-开通会员，3-续费
					qs = qs.SpendTypeIn([]uint32{2, 3}...)
				}
			} else { // 如果不是迪为合作商，则查询非3-续费，4-升级的数据
				qs = qs.SpendTypeNotIn([]uint32{3, 4}...)
			}
		}
	}
	if m.MemberType == 0 && m.SpendType != 0 { // 被邀请用户为0-未注册用户，操作类型不为0
		qs = qs.SpendTypeEq(m.SpendType)
		if m.SpendType == 3 { // 如果是3-续费，则查询是否为店员推广续费，即：invite_form = 1
			qs = qs.InviteFormEq(1)
		}
	}
	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 { // 如果被邀请用户是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.OrderDescByCreatedAt().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]
		if invites[i].MemberStatus != 1 {
			invites[i].CreatedAt = invites[i].MemberOpenTime
		}
	}
	if len(uids) == 0 {
		return resp, nil
	}
	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]
	}
	for i, _ := range invites {
		user, ok1 := userMap[uids[i]]
		if ok1 {
			invites[i].ToUser = &user
		}
	}
	//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 = invites

	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, user.MemberGenre)
			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 && err != RecordNotFound {
		logger.Error("order card err:", err)
		return ret, err
	}

	if err == RecordNotFound {
		var order Order
		err = NewOrderQuerySet(DB).UidEq(uint64(uid)).CardStatusIn([]uint8{1, 2, 3, 4}...).OrderDescByID().Limit(1).One(&order)
		if err != nil && err != RecordNotFound {
			logger.Error("order card err:", err)
			return ret, err
		}
		orderCard.RevertTime = order.RevertTime
		orderCard.CardStatus = uint32(order.CardStatus)
	}
	deadline := orderCard.RevertTime
	if orderCard.CardStatus > 0 && 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"`
}

type InviteMemberReportListResp struct {
	CurPage   int                  `json:"cur_page"`
	TotalPage int                  `json:"total_page"`
	Count     int                  `json:"count"` // 总记录数
	List      []InviteMemberReport `json:"list"`
}

func (m *InviteMemberReportListReq) List() ([]InviteMemberReport, int, 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, 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, count, 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, count, 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,
	//		}
	//	}
	//}
}

// gen:qs
type MemberStatisticDaily struct {
	Model

	MemberLevel  uint32    `json:"member_level"`
	Date         string    `json:"date"`
	DateTime     time.Time `json:"date_time"`
	Increase     uint32    `json:"increase"`
	Expire       uint32    `json:"expire"`
	Net          uint32    `json:"net"`
	Accumulative uint32    `json:"accumulative"`
}

// StorePromotion 记录促销情况
func StorePromotion(inviteUid, uid uint32, inviteUser, user *User) error {
	//inviteUid := uint32(0)
	//uid := uint32(0)
	if inviteUser == nil {
		inviteUser = GetUserByUid(inviteUid)
	}
	if user == nil {
		user = GetUserByUid(uid)
	}

	if user == nil || inviteUser == nil {
		logger.Error("user inviteUser is nil")
		return errors.New("user inviteUser is nil")
	}

	// 目前在领取优惠券的时候做了邀请记录，这里不再重复记录
	//if inviteUser.UserType == 2 && user.Uid != 0 { // 是店员邀请并且用户id不为空
	//	nowTime := time.Now()
	//	effectiveStoreInfo, err := GetUserEffectiveStore(inviteUid)
	//	if err != nil {
	//		return err
	//	}
	//
	//	exist, err := QueryRecordExist(
	//		fmt.Sprintf("SELECT * FROM user_invite_record WHERE to_uid = %d AND from_uid = %d ",
	//			user.Uid, inviteUid))
	//	if err != nil {
	//		logger.Error("query err:", err)
	//		return err
	//	}
	//	if !exist {
	//		firstInviteRecord := &UserInviteRecord{
	//			ToUid:       user.Uid,
	//			FromUid:     inviteUid,
	//			StoreId:     effectiveStoreInfo.StoreID,
	//			Action:      2, // 激活邀请
	//			SpendType:   1, // 未开通
	//			MemberLevel: 0, // 未开通会员
	//			First:       1, // 首次邀请
	//			Scan:        1,
	//			ActionTime:  nowTime,
	//		}
	//		err = DB.Create(firstInviteRecord).Error
	//		if err != nil {
	//			logger.Error("create user invite record err:", err)
	//		}
	//	}
	//	// 扫码记录
	//	inviteRecord := &UserInviteRecord{
	//		ToUid:       user.Uid,
	//		FromUid:     inviteUid,
	//		StoreId:     effectiveStoreInfo.StoreID,
	//		Action:      1, // 未激活
	//		SpendType:   1, // 未开通
	//		MemberLevel: 0,
	//		First:       0,
	//		Scan:        1,
	//		ActionTime:  nowTime,
	//	}
	//	err = DB.Create(inviteRecord).Error
	//	if err != nil {
	//		logger.Error("create user invite record err:", err)
	//	}
	//	// UserInvite 邀请主要
	//	var inviteNew UserInvite
	//	inviteErr := NewUserInviteQuerySet(DB).ToUidEq(user.Uid).FromUidEq(inviteUid).ActionEq(1).
	//		SpendTypeEq(1).One(&inviteNew)
	//	if inviteErr != nil && inviteErr != RecordNotFound {
	//		// 是否存在未开通
	//		logger.Error("user invite err:", err)
	//	}
	//	//fmt.Println("inviteErr:", inviteErr)
	//	//fmt.Printf("inviteNew:%#v \n", inviteNew)
	//	if inviteErr == RecordNotFound {
	//		memberLevel := user.MemberLevel
	//		if memberLevel == 0 {
	//			memberLevel = MemberLevelUser
	//		}
	//		invite := &UserInvite{
	//			FromUid:            inviteUid,                  // 邀请人用户id
	//			UserType:           inviteUser.UserType,        // 邀请人用户类型
	//			StoreId:            effectiveStoreInfo.StoreID, // 邀请人门店id
	//			MemberOpenTime:     nowTime,                    // 开通会员时间
	//			MemberType:         memberLevel,                // 被邀请用户类型
	//			MemberStatus:       1,                          // 被邀请用户会员状态 1-未开通
	//			ToUid:              user.Uid,                   // 被邀请用户id
	//			Action:             1,                          // 未激活
	//			SpendType:          1,                          // 未开通
	//			UserInviteRecordId: inviteRecord.ID,            // 邀请记录id
	//			FirstInvite:        0,                          // TODO 首次邀请id
	//			Scan:               1,                          // 扫码次数
	//			InviteForm:         1,                          // 1-店员邀请码续费
	//		}
	//		fmt.Println("创建邀请:", invite)
	//		if err := invite.Create(DB); err != nil {
	//			logger.Error(err)
	//			return err
	//		}
	//	}
	//
	//	if inviteErr == nil {
	//		err = NewUserInviteQuerySet(DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(nowTime).
	//			SetUserInviteRecordId(inviteRecord.ID).SetInviteForm(1).Update()
	//		if err != nil {
	//			logger.Error("from uid update user invite err:", err, inviteUid)
	//		}
	//	}
	//}

	return nil
}

func GetMemberGenreFromLevel(level uint32) uint32 {
	switch level {
	case 4: //白金
		return 400
	case 5: //黑金
		return 500
	}
	return 0
}

//// todo
//var userCoupon model.UserCoupon
//err := model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).One(&userCoupon)
//if err != nil {
//logger.Error("user coupon err:", err)
//}
//	// UserInviteRecord
//	// user_invite
//	if userCoupon.PromotionalSales == 0 {
//		logger.Error("promotional sales  is null")
//	} else {
//		inviteCouponUser := model.GetUserByUid(userCoupon.PromotionalSales)
//		if inviteCouponUser != nil {
//			userCouponInvite := &model.UserInvite{
//				FromUid:            userCoupon.PromotionalSales,
//				UserType:           inviteCouponUser.UserType, // user.UserType
//				StoreId:            inviteCouponUser.StoreId,
//				MemberOpenTime:     newTime,
//				MemberType:         2,
//				MemberStatus:       2,
//				ToUid:              user.Uid,
//				StoreType:          inviteCouponUser.StoreType,
//				Action:             1,
//				SpendType:          spendType,
//				MemberLevel:        record.MemberLevel,
//				UserInviteRecordId: 0,
//				FirstInvite:        1,
//			}
//
//			err = userCouponInvite.Create(model.DB)
//			if err != nil {
//				logger.Error("create user coupon invite err:", err)
//			}
//		}
//	}

type MemberType int

const (
	Unknown                         MemberType = iota
	FirstInvite                                // 1-首次邀请
	OpenAnnualGold                             // 2-开通年费黄金
	OpenQuarterGold                            // 3-开通季度黄金
	OpenHalfYearGold                           // 4-开通半年黄金
	OpenAnnualPlatinum                         // 5-开通年费白金
	OpenAnnualBlack                            // 6-开通年费黑金
	RenewAnnualGoldIntervene                   // 7-续费年费黄金（干预）
	RenewAnnualPlatinumIntervene               // 8-续费年费白金（干预）
	RenewAnnualBlackIntervene                  // 9-续费年费黑金（干预）
	RenewAnnualGoldAuto                        // 10-续费年费黄金（自动）
	RenewQuarterGoldAuto                       // 11-续费季度黄金（自动）
	RenewHalfYearGoldAuto                      // 12-续费半年黄金（自动）
	RenewAnnualPlatinumAuto                    // 13-续费年费白金（自动）
	RenewAnnualBlackAuto                       // 14-续费年费黑金（自动）
	UpgradeGoldToPlatinumIntervene             // 15-黄金→白金（干预）
	UpgradeGoldToBlackIntervene                // 16-黄金→黑金（干预）
	UpgradePlatinumToBlackIntervene            // 17-白金→黑金（干预）
	UpgradeGoldToPlatinumAuto                  // 18-黄金→白金（自动）
	UpgradeGoldToBlackAuto                     // 19-黄金→黑金（自动）
	UpgradePlatinumToBlackAuto                 // 20-白金→黑金（自动）
)

type NewUserInviteRecordReq struct {
	PageNum         int       `json:"pageIndex"`
	PageSize        int       `json:"pageSize"`
	FromUid         uint32    `json:"from_uid"`          // 邀请人ID
	ToUid           uint32    `json:"to_uid"`            // 用户ID
	RecordType      []uint32  `json:"record_type"`       // 记录类型 1-首次邀请，2-开通年费黄金，3-开通季度黄金，4-开通半年黄金， 5-开通年费白金，6-开通年费黑金，7-续费年费黄金（干预），8-续费年费白金（干预），9-续费年费黑金（干预），10-续费年费黄金（自动）， 11-续费季度黄金（自动），12-续费半年黄金（自动），13-续费年费白金（自动），14-续费年费黑金（自动），15-黄金→白金（干预）， 16-黄金→黑金（干预），17-白金→黑金（干预），18-黄金→白金（自动），19-黄金→黑金（自动），20-白金→黑金（自动）
	RecordStartTime time.Time `json:"record_start_time"` // 记录时间-开始时间
	RecordEndTime   time.Time `json:"record_end_time"`   // 记录时间-结束时间
}

type UserInviteRecordListResp struct {
	Count     int                        `json:"count"`     // 总记录数
	PageIndex int                        `json:"pageIndex"` // 页码
	List      []UserInviteRecordListData `json:"list"`
}

type UserInviteRecordListData struct {
	InviteUid   uint32    `json:"invite_uid"`   // 邀请人ID
	UserUid     uint32    `json:"user_uid"`     // 用户ID
	RecordType  uint32    `json:"record_type"`  // 记录类型
	RecordTime  time.Time `json:"record_time"`  // 记录时间
	MemberLevel uint32    `json:"member_level"` // 会员等级：1-普通 2-黄金 4-白金 5-黑金
}

func UpdateUserInviteRecordRenewHide() error {
	err := NewUserInviteRecordQuerySet(DB).SpendTypeEq(3).ScanEq(0).RenewHideNe(1).
		GetUpdater().SetRenewHide(1).Update()
	if err != nil {
		logger.Errorf("update renew_hide err:", err)
		return err
	}

	return nil
}

func (m *NewUserInviteRecordReq) NewList() (*UserInviteRecordListResp, error) {
	var records []UserInviteRecord

	err := UpdateUserInviteRecordRenewHide()
	if err != nil {
		logger.Errorf("err:", err)
		return nil, err
	}

	page := m.PageNum - 1
	pageSize := m.PageSize

	if page < 0 {
		page = 0
	}
	if pageSize == 0 {
		pageSize = 10
	}
	qs := NewUserInviteRecordQuerySet(DB).ActionEq(2)

	if m.FromUid != 0 {
		qs = qs.FromUidEq(m.FromUid)
	}
	if m.ToUid != 0 {
		qs = qs.ToUidEq(m.ToUid)
	}
	//if m.RecordType != 0 {
	//	switch m.RecordType {
	//	case 1: // 首次邀请
	//		qs = qs.FirstEq(1).SpendTypeEq(1)
	//	case 2: // 开通年费黄金
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(2)
	//	case 3: // 开通季度黄金
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(2).MemberGenreEq(201)
	//	case 4: // 开通半年黄金
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(2).MemberGenreEq(202)
	//	case 5: // 开通年费白金
	//		qs = qs.MemberLevelEq(4).SpendTypeEq(2)
	//	case 6: // 开通年费黑金
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(2)
	//
	//	case 7: // 续费年费黄金（干预）
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(3).RenewHideEq(0)
	//	case 8: // 续费年费白金（干预）
	//		qs = qs.MemberLevelEq(4).SpendTypeEq(3).RenewHideEq(0)
	//	case 9: // 续费年费黑金（干预）
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(3).RenewHideEq(0)
	//
	//	case 10: // 续费年费黄金（自动）
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(3).RenewHideEq(1)
	//	case 11: // 续费季度黄金（自动）
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(3).RenewHideEq(1).
	//			MemberGenreEq(201)
	//	case 12: // 续费半年黄金（自动）
	//		qs = qs.MemberLevelEq(2).SpendTypeEq(3).RenewHideEq(1).
	//			MemberGenreEq(202)
	//	case 13: // 续费年费白金（自动）
	//		qs = qs.MemberLevelEq(4).SpendTypeEq(3).RenewHideEq(1)
	//	case 14: // 续费年费黑金（自动）
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(3).RenewHideEq(1)
	//
	//	case 15: //黄金→白金（干预）
	//		qs = qs.MemberLevelEq(4).SpendTypeEq(4).RenewHideEq(0)
	//	case 16: //黄金→黑金（干预）
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(4).RenewHideEq(0).
	//			MemberGenreIn(200, 201, 202)
	//	case 17: //白金→黑金（干预）
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(4).RenewHideEq(0).
	//			MemberGenreNotIn(200, 201, 202)
	//
	//	case 18: //黄金→白金（自动）
	//		qs = qs.MemberLevelEq(4).SpendTypeEq(4).RenewHideEq(1)
	//	case 19: //黄金→黑金（自动）
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(4).RenewHideEq(1).
	//			MemberGenreIn(200, 201, 202)
	//	case 20: //白金→黑金（自动）
	//		qs = qs.MemberLevelEq(5).SpendTypeEq(4).RenewHideEq(1).
	//			MemberGenreNotIn(200, 201, 202)
	//	}
	//}
	if len(m.RecordType) != 0 {
		var recordTypeConditions []string
		for _, t := range m.RecordType {
			switch t {
			case 1:
				recordTypeConditions = append(recordTypeConditions, "(first=1 AND spend_type=1)")
			case 2:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=2)")
			case 3:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=2 AND user_invite_record.member_genre=201)")
			case 4:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=2 AND user_invite_record.member_genre=202)")
			case 5:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=4 AND spend_type=2)")
			case 6:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=2)")

			case 7:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=3 AND renew_hide=0)")
			case 8:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=4 AND spend_type=3 AND renew_hide=0)")
			case 9:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=3 AND renew_hide=0)")

			case 10:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=3 AND renew_hide=1)")
			case 11:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=3 AND renew_hide=1 AND user_invite_record.member_genre=201)")
			case 12:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=2 AND spend_type=3 AND renew_hide=1 AND user_invite_record.member_genre=202)")
			case 13:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=4 AND spend_type=3 AND renew_hide=1)")
			case 14:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=3 AND renew_hide=1)")

			case 15:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=4 AND spend_type=4 AND renew_hide=0)")
			case 16:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=4 AND renew_hide=0 AND user_invite_record.member_genre in (200,201,202))")
			case 17:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=4 AND renew_hide=0 AND user_invite_record.member_genre not in (200,201,202))")

			case 18:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=4 AND spend_type=4 AND renew_hide=1)")
			case 19:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=4 AND renew_hide=1 AND user_invite_record.member_genre in (200,201,202))")
			case 20:
				recordTypeConditions = append(recordTypeConditions, "(user_invite_record.member_level=5 AND spend_type=4 AND renew_hide=1 AND user_invite_record.member_genre not in (200,201,202))")
			}
		}

		// 拼接多选条件
		if len(recordTypeConditions) > 0 {
			recordTypeQuery := strings.Join(recordTypeConditions, " OR ")
			qs = qs.Where(recordTypeQuery)
		}
	}

	if !m.RecordStartTime.IsZero() {
		qs = qs.ActionTimeGte(m.RecordStartTime)
	}
	if !m.RecordEndTime.IsZero() {
		qs = qs.ActionTimeLte(m.RecordStartTime)
	}

	err = qs.Select("user_invite_record.*").OrderDescByActionTime().Offset(page * pageSize).
		Limit(pageSize).All(&records)
	if err != nil && err != RecordNotFound {
		logger.Errorf("err:", err)
		return nil, err
	}

	var count int
	count, err = qs.Count()
	if err != nil {
		logger.Errorf("err:", err)
		return nil, err
	}

	resp := new(UserInviteRecordListResp)
	var listData []UserInviteRecordListData

	for _, item := range records {
		data := UserInviteRecordListData{
			InviteUid:   item.FromUid,
			UserUid:     item.ToUid,
			RecordType:  uint32(CalculateMemberType(item.SpendType, item.RenewHide, item.MemberGenre, item.MemberLevel)),
			RecordTime:  item.ActionTime,
			MemberLevel: item.MemberLevel,
		}
		listData = append(listData, data)
	}
	resp.List = listData
	resp.PageIndex = m.PageNum
	resp.Count = count

	return resp, nil
}

// CalculateMemberType   匹配记录类型
func CalculateMemberType(spendType, renewHide, memberGenre, memberLevel uint32) MemberType {
	switch {
	case spendType == 1:
		return FirstInvite
	case spendType == 2:
		switch memberLevel {
		case 2:
			return OpenAnnualGold
		case 4:
			return OpenAnnualPlatinum
		case 5:
			return OpenAnnualBlack
		}
	case spendType == 3 && renewHide == 0:
		switch memberLevel {
		case 2:
			return RenewAnnualGoldIntervene
		case 4:
			return RenewAnnualPlatinumIntervene
		case 5:
			return RenewAnnualBlackIntervene
		}
	case spendType == 3 && renewHide == 1:
		switch memberLevel {
		case 2:
			return RenewAnnualGoldAuto
		case 4:
			return RenewAnnualPlatinumAuto
		case 5:
			return RenewAnnualBlackAuto
		}
	case spendType == 4 && renewHide == 0:
		switch memberLevel {
		case 4:
			return UpgradeGoldToPlatinumIntervene
		case 5:
			if memberGenre == 200 || memberGenre == 201 || memberGenre == 202 {
				return UpgradeGoldToBlackIntervene
			}
			return UpgradePlatinumToBlackIntervene
		}
	case spendType == 4 && renewHide == 1:
		switch memberLevel {
		case 4:
			return UpgradeGoldToPlatinumAuto
		case 5:
			if memberGenre == 200 {
				return UpgradeGoldToBlackAuto
			}
			return UpgradePlatinumToBlackAuto
		}
	case spendType == 2 && memberLevel == 2 && memberGenre == 201:
		return OpenQuarterGold
	case spendType == 2 && memberLevel == 2 && memberGenre == 202:
		return OpenHalfYearGold
	case spendType == 3 && renewHide == 1 && memberLevel == 2 && memberGenre == 201:
		return RenewQuarterGoldAuto
	case spendType == 3 && renewHide == 1 && memberLevel == 2 && memberGenre == 202:
		return RenewHalfYearGoldAuto
	}
	return Unknown
}