mh_server/model/share_card.go

package model

import (
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"mh-server/lib/utils"
	"strings"
	"time"
)

//go:generate goqueryset -in share_card.go
// gen:qs
type UserShareCardBill struct {
	Model
	Uid              uint32              `json:"uid" gorm:"index"`
	BillSn           string              `json:"bill_sn" gorm:"index"`
	State            string              `json:"state" gorm:"index"`
	SendCardType     uint32              `json:"send_card_type"`        // 1-送卡 2-邮寄
	StoreId          uint32              `json:"store_id" gorm:"index"` // 门店id
	ExpressCompany   string              `json:"express_company"`       // 物流公司
	ExpressCompanyNo string              `json:"express_company_no"`    // 物流公司编号
	ExpressNo        string              `json:"express_no"`            // 物流单号
	SendCardTime     time.Time           `json:"send_card_time"`        // 递送卡时间
	StockTime        time.Time           `json:"stock_time"`            // 入库时间
	RetrieveTime     time.Time           `json:"retrieve_time"`         // 收回卡时间 申请收回
	StockRemovalTime time.Time           `json:"stock_removal_time"`    // 出库时间
	Store            Store               `json:"store" gorm:"-"`        // 门店
	Remark           string              `json:"remark"`
	BillGames        []ShareCardBillGame `json:"bill_games" gorm:"-"`
}

// gen:qs
type ShareCardBillGame struct {
	Model
	UserShareCardBillId uint32          `json:"user_share_card_bill_id" gorm:"index"`
	Uid                 uint32          `json:"uid" gorm:"index"`
	GameCardId          uint32          `json:"game_card_id" gorm:"index"`
	BillSn              string          `json:"bill_sn" gorm:"index"`
	Count               uint32          `json:"count"`
	State               string          `json:"state" gorm:"index"`
	GameCard            GameCard        `json:"game_card" gorm:"-"` //
	ShareCards          []UserShareCard `json:"share_cards" gorm:"-"`
}

const (
	ShareCardBillStateInCheck       = "in_check"       // 待审核
	ShareCardBillStateInSendCard    = "in_send_card"   // 待递送卡
	ShareCardBillStateSentCard      = "sent_card"      // 已递送卡
	ShareCardBillStateCompleted     = "completed"      // 完成
	ShareCardBillStateCancel        = "cancel"         // 取消
	ShareCardBillStateAuditLose     = "check_lose"     // 审核失败
	ShareCardBillStateReceivingCard = "receiving_card" // 收回中
	ShareCardBillStateReceivedCard  = "received_card"  // 已收回
)

const (
	ShareCardStateInCheck    = "in_check"     // 待审核
	ShareCardStateInSendCard = "in_send_card" // 待递送卡
	ShareCardStateSentCard   = "sent_card"    // 已递送卡
	ShareCardStateSharing    = "sharing"      // 共享中
	ShareCardStateAuditLose  = "check_lose"   // 审核失败
	ShareCardStateCancel     = "cancel"       // 取消
	ShareCardStateRetrieve   = "retrieve"     // 收回
)

const (
	CardProfitVm = 21
)

// gen:qs
type UserShareCard struct {
	Model
	//Uid                     uint32   `json:"uid" gorm:"index"`
	//SerialNumber            string   `json:"serial_number" gorm:"index"` // 编号
	//BillSn                  string   `json:"bill_sn" gorm:"index"`
	//GameCardId              uint32   `json:"game_card_id" gorm:"index"`
	//State                   string   `json:"state" gorm:"index"`
	//GameCardGoodsId         uint32   `json:"game_card_goods_id" gorm:"index"`
	//UserShareCardBillId     uint32   `json:"user_share_card_bill_id"  gorm:"index"`
	//ShareCardBillGameId     uint32   `json:"share_card_bill_game_id"  gorm:"index"`
	//StoreId                 uint32   `json:"store_id" gorm:"index"`                     // 门店id
	//ProfitState             uint32   `json:"profit_state"`                              // 1-未生效 2-生效
	//TotalVm                 uint32   `json:"total_vm"`                                  // 累计积分
	//RetrieveSerialNumber    string   `json:"retrieve_serial_number"  gorm:"index"`      // 收卡编号
	//RetrieveGameCardGoodsId uint32   `json:"retrieve_game_card_goods_id"  gorm:"index"` // 收回卡id

	Uid             uint32 `json:"uid" gorm:"index"`
	GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
	SerialNumber    string `json:"serial_number" gorm:"index"` // 编号
	GameCardId      uint32 `json:"game_card_id" gorm:"index"`

	AllotSerialNumber   string `json:"allot_serial_number" gorm:"index"` // 库存共享卡编号 分配收回卡 绑定新卡编号
	AllotCardGoodsId    uint32 `json:"allot_card_goods_id" gorm:"index"` // 库存共享卡id
	UserShareCardBillId uint32 `json:"user_share_card_bill_id"  gorm:"index"`
	BillSn              string `json:"bill_sn" gorm:"index"`

	State string `json:"state" gorm:"index"`

	ShareCardBillGameId     uint32 `json:"share_card_bill_game_id"  gorm:"index"`
	StoreId                 uint32 `json:"store_id" gorm:"index"`                     // 门店id
	ProfitState             uint32 `json:"profit_state"`                              // 1-未生效 2-生效
	TotalVm                 uint32 `json:"total_vm"`                                  // 累计积分
	RetrieveSerialNumber    string `json:"retrieve_serial_number"  gorm:"index"`      // 收卡编号
	RetrieveGameCardGoodsId uint32 `json:"retrieve_game_card_goods_id"  gorm:"index"` // 收回卡id

	GameCard GameCard `json:"game_card" gorm:"-"`
}

// gen:qs
type ShareCardGameVm struct {
	Model
	GameCardId     uint32 `json:"game_card_id" gorm:"index"`
	HoldCardCount  uint32 `json:"hold_card_count"`  //
	StockCardCount uint32 `json:"stock_card_count"` //
	TotalCardCount uint32 `json:"total_card_count"`
	CardProfit     uint32 `json:"card_profit"`
	Vm             uint32 `json:"vm"`         // 发放积分
	ProvideVm      uint32 `json:"provide_vm"` // 发放积分
	ProvideDate    string `json:"provide_date" gorm:"index"`
	//share_card_game_vm
}

// 用户卡积分记录
// gen:qs
type UserShareCardVm struct {
	Model
	ShareCardGameVmId   uint32 `json:"share_card_game_vm_id" gorm:"index"`
	Uid                 uint32 `json:"uid" gorm:"index"`
	SerialNumber        string `json:"serial_number" gorm:"index"` // 编号
	BillSn              string `json:"bill_sn" gorm:"index"`
	GameCardId          uint32 `json:"game_card_id" gorm:"index"`
	GameCardGoodsId     uint32 `json:"game_card_goods_id" gorm:"index"`
	UserShareCardBillId uint32 `json:"user_share_card_bill_id"  gorm:"index"`
	CardProfit          uint32 `json:"card_profit"`
	Vm                  uint32 `json:"vm"` // 发放积分
	ProvideDate         string `json:"provide_date"`
}

// 用户积分记录
// gen:qs
type ShareCardDateVm struct {
	Model
	Uid         uint32 `json:"uid" gorm:"index"`
	Vm          uint32 `json:"vm"`                        // 发放积分
	TotalVm     uint32 `json:"total_vm"`                  // 用户累计获取积分
	ProvideDate string `json:"provide_date" gorm:"index"` // 收益日期
}

// 总积分记录
// gen:qs
type ShareCardVmRecord struct {
	Model
	TotalVm     uint32 `json:"total_vm"`
	ProvideVm   uint32 `json:"provide_vm"`                // 总发放积分
	ProvideDate string `json:"provide_date" gorm:"index"` // 发放收益时间
	//share_card_vm_record
}

//type UserShareCardBillInfo struct {
//	GameCardId uint32 `json:"game_card_id"`
//	Count      uint32 `json:"count"`
//}

// 用户收回卡
// gen:qs
type ShareCardRetrieve struct {
	Model
	Uid                    uint32                  `json:"uid" gorm:"index"`
	State                  string                  `json:"state" gorm:"index"`              // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
	RetrieveCardType       uint32                  `json:"retrieve_card_type" gorm:"index"` // 1-送卡门店 2-邮寄
	StoreId                uint32                  `json:"store_id" gorm:"index"`           // 门店id
	ExpressCompany         string                  `json:"express_company"`                 // 物流公司
	ExpressCompanyNo       string                  `json:"express_company_no"`              // 物流公司编号
	ExpressNo              string                  `json:"express_no"`                      // 物流单号
	StockRemovalTime       time.Time               `json:"stock_removal_time"`              // 出库时间
	StockTime              time.Time               `json:"stock_time"`                      // 入库时间
	PayState               uint32                  `json:"pay_state"`                       // 1-未支付 2-已支付
	PayAmount              uint32                  `json:"pay_amount"`                      // 支付金额
	Remark                 string                  `json:"remark"`
	OrderSn                string                  `json:"order_sn" gorm:"index"`         // 订单编号
	AddressId              uint32                  `json:"address_id" gorm:"index"`       // 收货地址
	RefundOrderSn          string                  `json:"refund_order_sn"  gorm:"index"` // 订单编号退费
	PickupCode             string                  `json:"pickup_code"`                   // 取货码
	ReceiptTime            time.Time               `json:"receipt_time"`                  // 签收时间
	Store                  Store                   `json:"store" gorm:"-"`
	UserAddress            UserAddress             `json:"user_address" gorm:"-"`
	ShareCardRetrieveCards []ShareCardRetrieveCard `json:"share_card_retrieve_cards" gorm:"-"`
	//TotalVm  uint32   `json:"total_vm"` // 累计积分
	//ShareCardBillGameId uint32    `json:"share_card_bill_game_id"  gorm:"index"`
	//GameCardGoodsId     uint32    `json:"game_card_goods_id" gorm:"index"`
	//UserShareCardBillId uint32    `json:"user_share_card_bill_id"  gorm:"index"`
	//BillSn              string    `json:"bill_sn" gorm:"index"`
	//GameCardId          uint32    `json:"game_card_id" gorm:"index"`
	//SerialNumber        string    `json:"serial_number" gorm:"index"` // 编号
	//GameCard         GameCard  `json:"game_card" gorm:"-"`
}

const (
	RetrieveStateInCheck      = "in_check"      // 待审核
	RetrieveStateCheckLose    = "check_lose"    // 审核失败
	RetrieveStateOutStock     = "out_stock"     // 暂无库存
	RetrieveStateInSendCard   = "in_send_card"  // 待发卡
	RetrieveStateInPickCard   = "in_pick_card"  // 待取卡
	RetrieveStateSentCard     = "sent_card"     // 已发卡
	RetrieveStateReceivedCard = "received_card" // 已收卡
	RetrieveStateCancel       = "cancel"        // 取消
)

// gen:qs
type ShareCardRetrieveCard struct {
	//ShareCardRetrieveId     uint32   `json:"share_card_retrieve_id" gorm:"index"`
	//UserShareCardId         uint32   `json:"user_share_card_id" gorm:"index"` // 用户共享卡收回
	//Uid                     uint32   `json:"uid" gorm:"index"`
	//SerialNumber            string   `json:"serial_number" gorm:"index"` // 编号
	//State                   string   `json:"state" gorm:"index"`         // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
	//BillSn                  string   `json:"bill_sn" gorm:"index"`
	//GameCardId              uint32   `json:"game_card_id" gorm:"index"`
	//RetrieveCardType        uint32   `json:"retrieve_card_type" gorm:"index"` // 1-送卡 2-邮寄
	//GameCardGoodsId         uint32   `json:"game_card_goods_id" gorm:"index"`
	//UserShareCardBillId     uint32   `json:"user_share_card_bill_id"  gorm:"index"`
	//StoreId                 uint32   `json:"store_id" gorm:"index"` // 门店id
	//Remark                  string   `json:"remark"`
	//RetrieveSerialNumber    string   `json:"retrieve_serial_number"  gorm:"index"`      // 收卡编号
	//RetrieveGameCardGoodsId uint32   `json:"retrieve_game_card_goods_id"  gorm:"index"` // 收回卡id

	Model
	ShareCardRetrieveId uint32 `json:"share_card_retrieve_id" gorm:"index"` // 收回卡单id
	UserShareCardId     uint32 `json:"user_share_card_id" gorm:"index"`     // 用户共享卡id
	Uid                 uint32 `json:"uid" gorm:"index"`
	State               string `json:"state" gorm:"index"`          // -暂无库存 -待发卡 -待取卡 -已发卡 -已收卡 -已取消
	TransportType       uint32 `json:"transport_type" gorm:"index"` // 1-送卡到门店 2-邮寄
	SerialNumber        string `json:"serial_number" gorm:"index"`  // 编号
	GameCardGoodsId     uint32 `json:"game_card_goods_id" gorm:"index"`
	GameCardId          uint32 `json:"game_card_id" gorm:"index"`

	StoreId             uint32 `json:"store_id" gorm:"index"` // 共享卡门店id
	UserShareCardBillId uint32 `json:"user_share_card_bill_id"  gorm:"index"`
	BillSn              string `json:"bill_sn" gorm:"index"`

	RetrieveSerialNumber    string `json:"retrieve_serial_number"  gorm:"index"`      // 收卡编号
	RetrieveGameCardGoodsId uint32 `json:"retrieve_game_card_goods_id"  gorm:"index"` // 收回卡id
	Remark                  string `json:"remark"`

	OriginalCardType     string    `json:"retrieve_card_type" gorm:"index"` // -公共卡 -用户共享  回收前的卡类型 原卡类型
	AllotUserShareCardId uint32    `json:"allot_user_share_card_id"`        // 分配用户共享卡id
	ReceiptTime          time.Time `json:"receipt_time"`                    // 签收时间
	PayState             uint32    `json:"pay_state"`                       // 1-未支付 2-已支付

	GameCard          GameCard          `json:"game_card" gorm:"-"`
	Store             Store             `json:"store" gorm:"-"`
	ShareCardRetrieve ShareCardRetrieve `json:"share_card_retrieve" gorm:"-"`

	//TotalVm  uint32   `json:"total_vm"` // 累计积分
	//ShareCardBillGameId uint32    `json:"share_card_bill_game_id"  gorm:"index"`
	// share_card_retrieve_card
}

const (
	CardIssueStateFollowing = "following"  // 处理中
	CardIssueStateFollowed  = "followed"   // 已处理
	CardIssueStateInDeliver = "in_deliver" // 发货中
	CardIssueStateCompleted = "completed"  // 已完成
	CardIssueStateCanceled  = "canceled"   // 已取消
)
const (
	ObtainTypeRetrieveCard = "retrieve_card" // 收回卡
	ObtainTypeRentCard     = "rent_card"     // 租卡
)

// gen:qs
type CardIssueFeedback struct {
	Model
	Uid             uint32 `json:"uid" gorm:"index"` // 反馈用户
	GameCardId      uint32 `json:"game_card_id" gorm:"index"`
	SerialNumber    string `json:"serial_number" gorm:"index"` // 编号
	GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
	StoreId         uint32 `json:"store_id" gorm:"index"`     // 门店id
	RelevanceId     uint32 `json:"relevance_id" gorm:"index"` // 关联id
	ObtainType      string `json:"obtain_type"`               // 卡类型: -收回卡 -租卡
	State           string `json:"state" gorm:"index"`        // 状态:
	Problem         string `json:"problem"`                   // 问题
	Remark          string `json:"remark"`

	ExpressCompany          string    `json:"express_company"`                         // 物流公司
	ExpressCompanyNo        string    `json:"express_company_no"`                      // 物流公司编号
	ExpressNo               string    `json:"express_no" gorm:"index"`                 // 物流单号
	IsNormalFunction        uint32    `json:"is_normal_function"`                      // 功能是否正常:1-是 2-否
	IsPackingIntact         uint32    `json:"is_packing_intact"`                       // 包装是否完整:1-是 2-否
	IsCardBreakage          uint32    `json:"is_card_breakage"`                        // 卡带是否破损:1-是 2-否
	DeliverExpressCompany   string    `json:"deliver_express_company"`                 // 发货物流公司
	DeliverExpressCompanyNo string    `json:"deliver_express_company_no"`              // 发货物流公司编号
	DeliverExpressNo        string    `json:"deliver_express_no" gorm:"index"`         // 发货物流单号
	ReissueSerialNumber     string    `json:"reissue_serial_number" gorm:"index"`      // 补发货编码
	ReissueGameCardGoodsId  uint32    `json:"reissue_game_card_goods_id" gorm:"index"` // 补发货卡id
	DeliverTime             time.Time `json:"deliver_time"`                            // 发货时间
	CheckTime               time.Time `json:"check_time"`                              // 检测时间
	CheckSysUid             string    `json:"check_sys_uid" gorm:"index"`              // 检测店员账号用户id
	ReceiptTime             time.Time `json:"receipt_time"`                            // 签收时间
	//CheckShopAssistant     string    `json:"check_shop_assistant" gorm:"index"`       // 检测店员账号
	TransportType uint32 `json:"transport_type" gorm:"index"` // 1-送卡到门店 2-邮寄
	UserAddressId uint32 `json:"user_address_id" gorm:"index"`

	UserInfo          *User              `json:"user_info" gorm:"-"`
	GameCard          *GameCard          `json:"game_card" gorm:"-"`
	Store             *Store             `json:"store" gorm:"-"`
	ShareCardRetrieve *ShareCardRetrieve `json:"share_card_retrieve" gorm:"-"`
	Order             *Order             `json:"order" gorm:"-"`
	UserAddress       *UserAddress       `json:"user_address" gorm:"-"`
	// card_issue_feedback
}

func GetUserShareCardBillList(uid uint32, page, pageSize int, state string) ([]UserShareCardBill, int, error) {
	page = page - 1
	if page < 0 {
		page = 0
	}
	if pageSize == 0 {
		pageSize = 10
	}
	var shareCardBills []UserShareCardBill
	qs := NewUserShareCardBillQuerySet(DB).UidEq(uid)
	if state != "" {
		qs = qs.StateEq(state)
	}
	count, err := qs.Count()
	if err != nil {
		logger.Error("user share card bill count err:", err)
		return shareCardBills, 0, err
	}
	totalPage := count/pageSize + 1
	err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCardBills)
	if err != nil && err != RecordNotFound {
		logger.Error("user share card bill err:", err)
		return shareCardBills, 0, err
	}
	if len(shareCardBills) == 0 {
		return shareCardBills, 0, nil
	}
	shareCardBills = UserShareCardBillListSetGame(shareCardBills)
	return shareCardBills, totalPage, nil
}

func GetUserShareCardBill(uid uint32, billId uint32) (UserShareCardBill, error) {
	var shareCardBill UserShareCardBill
	err := NewUserShareCardBillQuerySet(DB).IDEq(billId).One(&shareCardBill)
	if err != nil {
		logger.Error("user share card bill err:", err)
		return shareCardBill, err
	}

	var store Store
	err = NewStoreQuerySet(DB).IDEq(shareCardBill.StoreId).One(&store)
	if err != nil {
		logger.Error("store err:", err)
		return shareCardBill, err
	}
	shareCardBill.Store = store
	list := []UserShareCardBill{shareCardBill}
	list = UserShareCardBillListSetGame(list)
	if len(list) == 0 {
		return shareCardBill, nil
	}
	err = list[0].SetShareCard()
	if err != nil {
		logger.Error("set share card err:", err)
		return shareCardBill, err
	}
	return list[0], nil
}

func UserShareCardBillListSetGame(list []UserShareCardBill) []UserShareCardBill {
	billIds := make([]uint32, 0, len(list))
	for i, _ := range list {
		billIds = append(billIds, list[i].ID)
	}
	if len(billIds) == 0 {
		return list
	}
	billMap := make(map[uint32][]ShareCardBillGame, 0)
	var games []ShareCardBillGame
	err := NewShareCardBillGameQuerySet(DB).UserShareCardBillIdIn(billIds...).All(&games)
	if err != nil && err != RecordNotFound {
		logger.Error("share card bill  err:", err)
		return list
	}
	gameIds := make([]uint32, 0, len(games))
	for i, _ := range games {
		gameIds = append(gameIds, games[i].GameCardId)
	}
	cardMap, err := GameCardMap(gameIds)
	for i, _ := range games {
		v, ok := cardMap[games[i].GameCardId]
		if ok {
			games[i].GameCard = v
		}
	}

	for i, _ := range games {
		billMap[games[i].UserShareCardBillId] = append(billMap[games[i].UserShareCardBillId], games[i])
	}

	if err != nil {
		logger.Error("game card map  err:", err)
		return list
	}

	for i, _ := range list {
		v, ok := billMap[list[i].ID]
		if ok {
			list[i].BillGames = v
		}
	}

	return list
}

func GetUserShareCardGameList(uid uint32, page, pageSize int, label string) ([]GameCard, int, error) {
	page = page - 1
	if page < 0 {
		page = 0
	}
	if pageSize == 0 {
		pageSize = 10
	}
	var games []GameCard
	//qs := NewGameCardQuerySet(DB)
	sql := fmt.Sprintf("SELECT * FROM game_card WHERE 1 ")
	if label != "" {
		var gameLabels []GameCardLabel
		labelSql := "SELECT * FROM game_card_label WHERE  game_label LIKE '%" + label + "%';"
		err := DB.Raw(labelSql).Scan(&gameLabels).Error
		if err != nil {
			logger.Error("game card label err:", err)
			return games, 0, err
		}

		if len(gameLabels) > 0 {
			idString := make([]string, 0, len(gameLabels))
			for i, _ := range gameLabels {
				//idString += fmt.Sprintf("%d", gameLabels[i].GameCardId)
				idString = append(idString, fmt.Sprintf("%d", gameLabels[i].GameCardId))
			}
			sql += " AND (`name` LIKE '%" + label + "%' " + fmt.Sprintf(" OR id IN (%s))",
				strings.Join(idString, ","))
		} else {
			sql += " AND `name` LIKE '%" + label + "%' "
		}
		//qs = qs.StateEq(state)
	}

	type GameCount struct {
		Count int `json:"count"`
	}
	var count GameCount
	countSql := strings.Replace(sql, "SELECT *", "SELECT COUNT(*) AS count ", -1)
	//countSql := strings.Replace(sql, "SELECT *", "SELECT COUNT(*)  ", -1)
	fmt.Println("countSql:", countSql)
	err := DB.Raw(countSql).Scan(&count).Error
	//count, err := qs.Count()
	if err != nil {
		logger.Error("user share card bill count err:", err)
		return games, 0, err
	}
	totalPage := count.Count/pageSize + 1
	sql += fmt.Sprintf("ORDER BY id DESC LIMIT %d OFFSET %d ;", pageSize, page*pageSize)
	err = DB.Raw(sql).Scan(&games).Error
	//err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&games)
	fmt.Println("sql:", sql)
	if err != nil && err != RecordNotFound {
		logger.Error("user share card bill err:", err)
		return games, 0, err
	}
	if len(games) == 0 {
		return games, 0, nil
	}
	games = ShareCardGameListSetGameVm(games)
	//shareCardBills = UserShareCardBillListSetGame(shareCardBills)
	return games, totalPage, nil
}

func ShareCardGameListSetGameVm(list []GameCard) []GameCard {
	if len(list) == 0 {
		return list
	}
	gameIds := make([]uint32, 0, len(list))
	for i, _ := range list {
		gameIds = append(gameIds, list[i].ID)
	}
	vmMap := GetShareCardGameVmMap(gameIds)
	for i, _ := range list {
		v, ok := vmMap[list[i].ID]
		if ok {
			list[i].EstimateVm = v.Vm
		}
		if list[i].EstimateVm == 0 {
			list[i].EstimateVm = CardProfitVm
		}
	}
	return list
}

func GetShareCardGameVmMap(ids []uint32) map[uint32]ShareCardGameVm {
	shareCardGameVmMap := make(map[uint32]ShareCardGameVm, 0)
	if len(ids) == 0 {
		return shareCardGameVmMap
	}
	dateFormat := utils.ZeroDateFormat(-1)
	var shareGameVm []ShareCardGameVm
	err := NewShareCardGameVmQuerySet(DB).IDIn(ids...).ProvideDateEq(dateFormat).All(&shareGameVm)
	if err != nil && err != RecordNotFound {
		logger.Error("share card game vm err:", err)
		return shareCardGameVmMap
	}
	for i, _ := range shareGameVm {
		shareCardGameVmMap[shareGameVm[i].GameCardId] = shareGameVm[i]
	}

	return shareCardGameVmMap
}

func (m *UserShareCardBill) SetShareCard() error {
	var userShareCards []UserShareCard
	err := NewUserShareCardQuerySet(DB).UserShareCardBillIdEq(m.ID).All(&userShareCards)
	if err != nil {
		logger.Error("user share card err:", err)
		return err
	}
	shareCardMap := make(map[uint32][]UserShareCard, 0)
	for i, _ := range userShareCards {
		shareCardMap[userShareCards[i].GameCardId] = append(shareCardMap[userShareCards[i].GameCardId], userShareCards[i])
	}
	if len(m.BillGames) == 0 {
		logger.Error("bill games is nil")
		return nil
	}
	for i, _ := range m.BillGames {
		v, ok := shareCardMap[m.BillGames[i].GameCardId]
		if ok {
			m.BillGames[i].ShareCards = v
		}
	}

	return nil
}

func GetUserShareCardMyCardList(uid uint32, page, pageSize int, state string) ([]UserShareCard, int, int, error) {
	page = page - 1
	if page < 0 {
		page = 0
	}
	if pageSize == 0 {
		pageSize = 10
	}
	states := []string{state}
	if state == "" {
		states = []string{ShareCardStateInCheck, ShareCardStateSharing, ShareCardStateRetrieve}
	}

	var shareCards []UserShareCard
	shareCardCount, err := NewUserShareCardQuerySet(DB).UidEq(uid).StateEq(ShareCardStateSharing).Count()
	if err != nil {
		logger.Error("user share card  count err:", err)
		return shareCards, 0, shareCardCount, err
	}

	qs := NewUserShareCardQuerySet(DB).UidEq(uid).StateIn(states...)

	count, err := qs.Count()
	if err != nil {
		logger.Error("user share card bill count err:", err)
		return shareCards, 0, shareCardCount, err
	}
	totalPage := count/pageSize + 1
	err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCards)
	if err != nil && err != RecordNotFound {
		logger.Error("user share card bill err:", err)
		return shareCards, 0, shareCardCount, err
	}
	if len(shareCards) == 0 {
		return shareCards, 0, shareCardCount, nil
	}
	shareCards = UserShareCardListSetGame(shareCards)
	return shareCards, totalPage, shareCardCount, nil
}

func UserShareCardListSetGame(list []UserShareCard) []UserShareCard {
	gameIds := make([]uint32, 0, len(list))
	for i, _ := range list {
		gameIds = append(gameIds, list[i].GameCardId)
	}
	cardMap, err := GameCardMap(gameIds)
	if err != nil {
		logger.Error("game card map err:", err)
		return list
	}
	for i, _ := range list {
		v, ok := cardMap[list[i].GameCardId]
		if ok {
			list[i].GameCard = v
		}
	}

	return list
}

func GetUserShareCardVmList(uid uint32, page, pageSize int, goodsId uint32) ([]UserShareCardVm, int, error) {
	page = page - 1
	if page < 0 {
		page = 0
	}
	if pageSize == 0 {
		pageSize = 10
	}

	var shareCardVms []UserShareCardVm
	qs := NewUserShareCardVmQuerySet(DB).UidEq(uid).GameCardGoodsIdEq(goodsId)

	count, err := qs.Count()
	if err != nil {
		logger.Error("user share card bill count err:", err)
		return shareCardVms, 0, err
	}
	totalPage := count/pageSize + 1
	err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCardVms)
	if err != nil && err != RecordNotFound {
		logger.Error("user share card bill err:", err)
		return shareCardVms, 0, err
	}
	//if len(shareCardVms) == 0 {
	//	return shareCardVms, 0, nil
	//}
	//shareCards = UserShareCardListSetGame(shareCards)
	return shareCardVms, totalPage, nil
}

func GetUserShareCardDateVmInfo(uid uint32) (ShareCardDateVm, error) {
	var cardDateVm ShareCardDateVm
	//err := NewShareCardDateVmQuerySet(DB).UidEq(uid).ProvideDateEq(utils.ZeroDateFormat(-1)).One(&cardDateVm)
	err := NewShareCardDateVmQuerySet(DB).UidEq(uid).OrderDescByID().Limit(1).One(&cardDateVm)
	if err != nil && err != RecordNotFound {
		logger.Error("share card date vm err:", err)
	}
	//count := len(cardDateVms)
	//var cardDateVm ShareCardDateVm
	//if count == 2 {
	//	cardDateVm = cardDateVms[1]
	//	cardDateVm.TotalVm += cardDateVms[0].Vm
	//} else if count == 1 {
	//	cardDateVm = cardDateVms[0]
	//} else {
	//
	//}
	return cardDateVm, nil
}

type ShareCardRetrieveCreateReq struct {
	SerialNumbers    []string `json:"serial_numbers"`
	StoreId          uint32   `json:"store_id"`           // 门店id
	RetrieveCardType uint32   `json:"retrieve_card_type"` // 1-门店 2-邮寄   修改
	AddressId        uint32   `json:"address_id"`         // 收货地址
	Amount           uint32   `json:"amount"`             // 金额
	Uid              uint32   `json:"uid"`
}

func (m *ShareCardRetrieveCreateReq) RetrieveCreate() (*ShareCardRetrieve, error) {
	var userShareCards []UserShareCard
	err := NewUserShareCardQuerySet(DB).SerialNumberIn(m.SerialNumbers...).All(&userShareCards)
	if err != nil {
		logger.Error("user share card err:", err)
		return nil, err
	}
	//gameIds := make([]uint64, 0)
	//for i, _ := range user{
	//	gameIds = append(gameIds, uint64(userShareCards[i].GameCardId))
	//}
	//// TODO  共享卡半年收回 测试上线修改
	for i, _ := range userShareCards {
		if userShareCards[i].CreatedAt.AddDate(0, 6, 0).After(time.Now()) {
			logger.Error("user share before 6 month")
			return nil, errors.New("before_6_month")
		}
	}
	//var gameCardGoodsStocks []GameCardGoodsStock
	//err = NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(m.StoreId)).GameCardIdIn(gameIds...).All(&gameCardGoodsStocks)
	//if err != nil {
	//	logger.Error("game card goods stock err:", err)
	//	return err
	//}
	//var gameGoods []GameCardGoods
	//err = NewGameCardGoodsQuerySet(DB).GameCardIdIn(gameIds...).StatusEq(1).OrderAscByID().All(&gameGoods)
	//if err != nil && err != RecordNotFound {
	//	logger.Error("game card goods err:", err)
	//	return err
	//}
	payState := uint32(1)
	if m.RetrieveCardType == 1 {
		payState = 2
	}
	begin := DB.Begin()
	retrieve := &ShareCardRetrieve{
		Uid:              m.Uid,
		RetrieveCardType: m.RetrieveCardType,
		StoreId:          m.StoreId,
		State:            RetrieveStateInCheck,
		OrderSn:          GetShareCardRetrieveOrderSn(),
		PayState:         payState,
		AddressId:        m.AddressId,
		PayAmount:        m.Amount,
		PickupCode:       GetShareCardRetrievePickupCode(),
	}
	err = begin.Create(&retrieve).Error
	if err != nil {
		begin.Rollback()
		logger.Error("create share card retrieve err:", err)
		return retrieve, err
	}
	for i, _ := range userShareCards {
		card := &ShareCardRetrieveCard{
			ShareCardRetrieveId: retrieve.ID,
			UserShareCardId:     userShareCards[i].ID,
			Uid:                 m.Uid,
			SerialNumber:        userShareCards[i].SerialNumber,
			State:               RetrieveStateInCheck,
			BillSn:              userShareCards[i].BillSn,
			GameCardId:          userShareCards[i].GameCardId,
			TransportType:       m.RetrieveCardType,
			//RetrieveCardType:    m.RetrieveCardType,
			GameCardGoodsId:     userShareCards[i].GameCardGoodsId,
			UserShareCardBillId: userShareCards[i].ShareCardBillGameId,
			StoreId:             m.StoreId,
		}
		err = begin.Create(&card).Error
		if err != nil {
			begin.Rollback()
			logger.Error("create share card retrieve card err:", err)
			return retrieve, err
		}
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		return retrieve, err
	}
	return retrieve, nil
}

//func GetUserCardBySerialNumber(serialNumber string, list []GameCardGoods) (*GameCardGoods, bool) {
//	for i, _ := range list {
//		if list[i].SerialNumber == serialNumber {
//			return &list[i], true
//		}
//	}
//	return nil, false
//}

//func SetUserCardSerialNumber(storeId uint32, list []UserShareCard) ([]UserShareCard, error) {
//	for i, _ := range list {
//		var goods GameCardGoods
//		err := NewGameCardGoodsQuerySet(DB).StoreIdEq(uint64(storeId)).SerialNumberEq(list[i].SerialNumber).
//			StatusEq(1).One(&goods)
//		if err != nil && err != RecordNotFound {
//			logger.Error("game card goods err:", err)
//			return list, err
//		}
//		if goods.ID == list[i].GameCardGoodsId {
//			list[i].SerialNumber = goods.SerialNumber
//			list[i].GameCardGoodsIdRetrieve = goods.ID
//		}
//	}
//	return list, nil
//}
//
//func SetRandomCardSerialNumber(storeId uint32, list []UserShareCard) ([]UserShareCard, error) {
//	for i, _ := range list {
//		var goods GameCardGoods
//		err := NewGameCardGoodsQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdEq(uint64(list[i].GameCardId)).
//			StatusEq(1).OrderAscByID().Limit(1).One(&goods)
//		if err != nil && err != RecordNotFound {
//			logger.Error("game card goods err:", err)
//			return list, err
//		}
//		list[i].SerialNumber = goods.SerialNumber
//		list[i].GameCardGoodsIdRetrieve = goods.ID
//	}
//	return list, nil
//}

type ShareCardRetrieveListReq struct {
	Uid      uint32 `json:"uid"`
	State    string `json:"state"`
	Page     int    `json:"cur_page"`
	PageSize int    `json:"page_size"`
}

func (m *ShareCardRetrieveListReq) List() ([]ShareCardRetrieve, int, error) {
	var retrieveCards []ShareCardRetrieve
	qs := NewShareCardRetrieveQuerySet(DB).UidEq(m.Uid).PayStateEq(2)
	if m.State != "" {
		qs = qs.StateEq(m.State)
	}
	page := m.Page - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}

	count, err := qs.Count()
	if err != nil {
		logger.Error("user share card bill count err:", err)
		return retrieveCards, 0, err
	}
	totalPage := count/m.PageSize + 1
	err = qs.OrderDescByID().Offset(page * m.PageSize).Limit(m.PageSize).All(&retrieveCards)
	if err != nil && err != RecordNotFound {
		logger.Error("user share card bill err:", err)
		return retrieveCards, 0, err
	}
	if len(retrieveCards) == 0 {
		return retrieveCards, totalPage, nil
	}
	retrieveCards = ShareCardRetrieveListSetGames(retrieveCards)
	return retrieveCards, totalPage, nil
}

func ShareCardRetrieveListSetGames(list []ShareCardRetrieve) []ShareCardRetrieve {
	gameIds := make([]uint32, 0, len(list))
	retrieveIds := make([]uint32, 0, len(list))
	for i, _ := range list {
		//gameIds = append(gameIds, list[i].GameCardId)
		retrieveIds = append(retrieveIds, list[i].ID)
	}
	if len(retrieveIds) == 0 {
		return list
	}
	var cards []ShareCardRetrieveCard
	err := NewShareCardRetrieveCardQuerySet(DB).ShareCardRetrieveIdIn(retrieveIds...).All(&cards)
	if err != nil {
		logger.Error("share card retrieve card err:", err)
		return list
	}
	for i, _ := range cards {
		gameIds = append(gameIds, cards[i].GameCardId)
	}
	if len(gameIds) == 0 {
		logger.Error("game ids err:", err)
		return list
	}
	gameMap, err := GameCardMap(gameIds)
	if err != nil {
		logger.Error("game card map err:", err)
		return list
	}
	for i, _ := range cards {
		v, ok := gameMap[cards[i].GameCardId]
		if ok {
			cards[i].GameCard = v
		}
	}

	cardsMap := make(map[uint32][]ShareCardRetrieveCard, 0)
	for i, _ := range cards {
		cardsMap[cards[i].ShareCardRetrieveId] = append(
			cardsMap[cards[i].ShareCardRetrieveId], cards[i])
	}

	//retrieveMap, err := GetShareCardRetrieveMap(retrieveIds)
	//if err != nil {
	//	logger.Error("get share card retrieve map err:", err)
	//	return list
	//}
	for i, _ := range list {
		v, ok1 := cardsMap[list[i].ID]
		if ok1 {
			list[i].ShareCardRetrieveCards = v
		}
		//retrieve, ok2 := retrieveMap[list[i].ShareCardRetrieveId]
		//if ok2 {
		//	list[i].ShareCardRetrieve = retrieve
		//}
	}

	return list
}

func ShareCardRetrieveCardListSetGame(list []ShareCardRetrieveCard) []ShareCardRetrieveCard {
	gameIds := make([]uint32, 0, len(list))
	retrieveIds := make([]uint32, 0, len(list))
	for i, _ := range list {
		gameIds = append(gameIds, list[i].GameCardId)
		retrieveIds = append(retrieveIds, list[i].ShareCardRetrieveId)
	}

	cardMap, err := GameCardMap(gameIds)
	if err != nil {
		logger.Error("game card map err:", err)
		return list
	}

	for i, _ := range list {
		v, ok1 := cardMap[list[i].GameCardId]
		if ok1 {
			list[i].GameCard = v
		}
	}

	return list
}

func GetShareCardRetrieveMap(ids []uint32) (map[uint32]ShareCardRetrieve, error) {
	retrieveMap := make(map[uint32]ShareCardRetrieve, 0)
	if len(ids) == 0 {
		return retrieveMap, nil
	}
	var retrieves []ShareCardRetrieve
	err := NewShareCardRetrieveQuerySet(DB).IDIn(ids...).All(&retrieves)
	if err != nil {
		logger.Error("share card retrieve err:", err)
		return retrieveMap, err
	}
	for i, _ := range retrieves {
		retrieveMap[retrieves[i].ID] = retrieves[i]
	}
	return retrieveMap, nil
}

func GetShareCardRetrieveInfo(retrieveId uint32) (ShareCardRetrieve, error) {
	var retrieve ShareCardRetrieve
	err := NewShareCardRetrieveQuerySet(DB).IDEq(retrieveId).One(&retrieve)
	if err != nil {
		logger.Error("share card retrieve err:", err)
		return retrieve, err
	}
	var cards []ShareCardRetrieveCard
	err = NewShareCardRetrieveCardQuerySet(DB).ShareCardRetrieveIdEq(retrieveId).All(&cards)
	if err != nil {
		logger.Error("share card retrieve card err:", err)
		return retrieve, err
	}

	retrieve.ShareCardRetrieveCards = ShareCardRetrieveCardListSetGame(cards)
	err = retrieve.SetStore()
	if err != nil {
		logger.Error("store err:", err)
		return retrieve, err
	}

	err = retrieve.SetUserAddress()
	if err != nil {
		logger.Error("user address err:", err)
		return retrieve, err
	}

	return retrieve, nil
}

func (m *ShareCardRetrieve) SetStore() error {
	err := NewStoreQuerySet(DB).IDEq(m.StoreId).One(&m.Store)
	if err != nil && err != RecordNotFound {
		logger.Error("set store err:", err)
		return err
	}
	return nil
}
func (m *ShareCardRetrieve) SetUserAddress() error {
	err := NewUserAddressQuerySet(DB).IDEq(m.AddressId).One(&m.UserAddress)
	if err != nil && err != RecordNotFound {
		logger.Error("set store err:", err)
		return err
	}
	return nil
}

func CardIssueFeedbackListSetGame(list []CardIssueFeedback) []CardIssueFeedback {
	ids := make([]uint32, 0, len(list))
	for i, _ := range list {
		ids = append(ids, list[i].GameCardId)
	}
	if len(ids) == 0 {
		return list
	}
	gameMap, err := GameCardMap(ids)
	if err != nil {
		logger.Error("set store err:", err)
		return list
	}

	for i, _ := range list {
		v, ok := gameMap[list[i].GameCardId]
		if ok {
			list[i].GameCard = &v
		}
	}

	return list
}

// 用户收回卡
//// gen:qs
//type ShareCardRetrieve struct {
//	Model
//	Uid              uint32    `json:"uid" gorm:"index"`
//	State            string    `json:"state" gorm:"index"`              // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
//	RetrieveCardType uint32    `json:"retrieve_card_type" gorm:"index"` // 1-送卡 2-邮寄
//	StoreId          uint32    `json:"store_id" gorm:"index"`           // 门店id
//	ExpressCompany   string    `json:"express_company"`                 // 物流公司
//	ExpressCompanyNo string    `json:"express_company_no"`              // 物流公司编号
//	ExpressNo        string    `json:"express_no"`                      // 物流单号
//	StockRemovalTime time.Time `json:"stock_removal_time"`              // 出库时间
//	StockTime        time.Time `json:"stock_time"`                      // 入库时间
//	Remark           string    `json:"remark"`
//
//	Store Store `json:"store" gorm:"-"`
//}
//
//// gen:qs
//type ShareCardRetrieveCard struct {
//	Model
//	ShareCardRetrieveId uint32   `json:"share_card_retrieve_id" gorm:"index"`
//	UserShareCardId     uint32   `json:"user_share_card_id" gorm:"index"` // 用户共享卡收回
//	Uid                 uint32   `json:"uid" gorm:"index"`
//	SerialNumber        string   `json:"serial_number" gorm:"index"` // 编号
//	State               string   `json:"state" gorm:"index"`         // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
//	BillSn              string   `json:"bill_sn" gorm:"index"`
//	GameCardId          uint32   `json:"game_card_id" gorm:"index"`
//	RetrieveCardType    uint32   `json:"retrieve_card_type" gorm:"index"` // 1-送卡 2-邮寄
//	GameCardGoodsId     uint32   `json:"game_card_goods_id" gorm:"index"`
//	UserShareCardBillId uint32   `json:"user_share_card_bill_id"  gorm:"index"`
//	StoreId             uint32   `json:"store_id" gorm:"index"` // 门店id
//	Remark              string   `json:"remark"`
//	GameCard            GameCard `json:"game_card" gorm:"-"`
//	Store               Store    `json:"store" gorm:"-"`
//
//	//TotalVm  uint32   `json:"total_vm"` // 累计积分
//	//ShareCardBillGameId uint32    `json:"share_card_bill_game_id"  gorm:"index"`
//}