package model

import (
	"crypto/sha512"
	"encoding/json"
	"fmt"
	"mh-server/lib/auth"
	"mh-server/lib/utils"

	//"github.com/andreburgaud/crypt2go/ecb"
	//"github.com/andreburgaud/crypt2go/padding"
	"github.com/codinl/go-logger"
	"github.com/jinzhu/gorm"
	"github.com/xuri/excelize/v2"
	"math/rand"
	"strings"
	"testing"
	"time"
)

func TestGameList(t *testing.T) {
	InitTestDB()
	var game GameCard
	err := NewGameCardQuerySet(DBDev).IDEq(1).One(&game)
	if err != nil {
		logger.Error("err:", err)
		return
	}
	logger.Infof("game %#v", game)
	fmt.Printf("game %#v", game)
	gameName := game.Name
	for i := 50; i < 200; i++ {
		randNum := getRandNum()
		numUnix := getRandNumUnix()

		num := fmt.Sprintf("0%d", i+1)
		game.Name = num + gameName
		game.NewProducts = 2
		game.Price = uint32(randNum)
		game.OrderCount = uint32(randNum + numUnix)
		game.ID = 0
		DBDev.Create(&game)
	}
}

func getRandNum() int {
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(1000)
}

func getRandNumUnix() int {
	rand.Seed(time.Now().Unix())
	return rand.Intn(1000)
}

var DBDev *gorm.DB

// 测试服务器
func InitTestDB() {
	var err error

	dialect := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
		"mh_dev", "m5h4parZsXjbeiFh", "39.108.188.218", "3306", "mh_dev")

	db, err := gorm.Open("mysql", dialect)
	if err != nil {
		logger.Infof("Open DB error [%s] with dialect[%s]", err.Error(), dialect)
		panic(err)
	}

	if db.DB().Ping() != nil {
		fmt.Printf("Ping DB fail: %#v", db.Error)
		panic(err)
	}
	db.SingularTable(true)

	db.AutoMigrate(

		//&GameCard{},
		//&FundRecord{},
		//&User{},
		//&UserAttendance{},
		//&UserAttendanceRecord{},

		// 合作商
		&Store{},
		&GameCard{},
		&GameCardGoods{},
		&GameCardGoodsStock{},
		&User{},
		&Order{},
		&OrderCard{},

		&OperationLog{},
		&CooperativeBusiness{},
		&CooperativeMemberDeduct{},
		&CooperativeAssistantMemberDeduct{},

		&CooperativeMemberPromotion{},
		&CooperativeMemberPromotionStore{},
		&CooperativeMemberPromotionDay{},
		&CooperativeMemberPromotionStoreDay{},
		&InviteMemberReport{},
		&CooperativeDeductSettle{},
		&XcxRole{},
	)

	fmt.Println("DB init success")
	DBDev = db
	logger.Info("ok")
}

func TestInitTestDBModel(t *testing.T) {
	InitTestDB()
}

func TestMemberExprireTime(t *testing.T) {
	InitTestDB()
}

var DBProd *gorm.DB

func InitDBProd() {
	var err error
	dialect := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
		"mh_pro", "fLeytnBFCRB553ab", "39.108.188.218", "3306",
		"mh_pro")

	DBProd, err = gorm.Open("mysql", dialect)
	if err != nil {
		fmt.Println("Connect Database Error, error = ", err)
		panic(err)
	}
	DBProd.DB().SetMaxOpenConns(1000)
	DBProd.DB().SetMaxIdleConns(500)
	DBProd.DB().SetConnMaxLifetime(time.Second * 10)
	//DBProd.LogMode(true)
	DBProd.LogMode(false)
	DBProd.SingularTable(true)
	DBProd.AutoMigrate(
		//&RedeemCode{},
		//&UserRedeemCode{},
		//&GameCardGoods{},
		//
		//&UserShareCardBill{},
		//&ShareCardBillGame{},
		//&UserShareCard{},
		//&ShareCardVmRecord{},
		//&UserShareCardVm{},
		//&ShareCardDateVm{},
		//&ShareCardGameVm{},
		//&ShareCardRetrieve{},
		//&ShareCardRetrieveCard{},
		//&GameCardLabel{},
		//&CardIssueFeedback{},

		//&GameCard{},
		//&FundRecord{},
		//&User{},

		//&GameCard{},
		//&FundRecord{},
		//&User{},
		//&UserAttendance{},
		//&UserAttendanceRecord{},

	)

	if err := DBProd.DB().Ping(); err != nil {
		fmt.Println("Ping Database Fail, error = ", err)
		panic(err)
	}
	fmt.Println("DB init success")
}

func TestInitProdDBModel(t *testing.T) {
	InitDBProd()
}

func TestHotSearch_TableName(t *testing.T) {
	InitTestDB()

	list := []string{"马里奥赛车8豪华版", "任天堂明星大乱斗 特别版", "超级马力欧 奥德赛", "塞尔达传说：旷野之息",
		"宝可梦：剑 / 盾", "精灵宝可梦 Let's Go! 皮卡丘/Let's Go! 伊布", "喷射战士2", "超级马力欧派对",
		"新超级马里奥兄弟U", "路易基鬼屋3", "超级马力欧创作家2", "塞尔达传说:织梦岛", "集合了！动物森友会",
		"1-2 Switch", "马里奥网球Aces", "马里奥+疯兔：王国之战", "火焰之纹章：风花雪月", "星之卡比：新星同盟",
		"大金刚国度：热带寒流"}
	for i, s := range list {
		hotSearch := &HotSearch{
			Keyword: s,
			Sort:    uint32(len(list) - i),
		}
		err := hotSearch.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}
}

func TestGetHomeCarouselList(t *testing.T) {
	InitTestDB()
	//imgs := []string{"1-2011060021334X.jpg", "1-2011060021425N.jpg", "1-201106002150294.jpg", "1-201106002159522.jpg"}
	imgs := []string{"http://39.108.188.218:8000/img/1-2011060021334X.jpg", "http://39.108.188.218:8000/img/1-2011060021425N.jpg", "http://39.108.188.218:8000/img/1-201106002150294.jpg", "http://39.108.188.218:8000/img/1-201106002159522.jpg"}
	for i, img := range imgs {
		homeCarousel := &HomeCarousel{
			Name:   "banner" + fmt.Sprintf("%d", len(imgs)-i),
			Img:    img,
			Sort:   uint32(len(imgs) - i),
			IsShow: 1,
			Detail: "",
			Link:   "",
		}
		err := homeCarousel.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}
}

func TestGameCardType_Create(t *testing.T) {
	InitTestDB()
	types := []string{"角色扮演", "射击游戏", "动作游戏", "冒险游戏", "赛车游戏", "策略游戏", "即时战略", "养成游戏", "桌面棋牌", "休闲益智", "体育运动", "模拟经营", "音乐游戏", "格斗游戏", "动作角色", "第一人称射击", "第三人称射击"}
	for i, s := range types {
		cardType := GameCardType{
			Name: s,
			Sort: uint32(i + 100),
		}
		err := cardType.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}

}

func TestStore_TableName(t *testing.T) {
	InitTestDB()

	for i := 0; i < 10; i++ {
		idx := fmt.Sprintf("%d", i+1)
		store := Store{
			Name:      "门店" + idx,
			Img:       "http://39.108.188.218:8000/img/1599445323_430355.jpg",
			Tel:       "021-54473036",
			Province:  "广东省",
			City:      "深圳市",
			District:  "南山区",
			Address:   "高新园",
			Longitude: 0,
			Latitude:  0,
		}
		err := store.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}

}

func TestPess(t *testing.T) {
	InitTestDB()
	comp := []string{"圆通速递", "韵达快递", "中通快递", "顺丰速运", "申通快递", "百世快递", "邮政快递包裹", "京东物流", "EMS", "极兔速递", "EMS包裹"}
	compCode := []string{"yuantong", "yunda", "zhongtong", "shunfeng", "shentong", "huitongkuaidi", "youzhengguonei", "jd", "ems", "jtexpress", "emsbg"}
	for i, _ := range comp {
		company := &ExpressCompany{
			CompanyName: comp[i],
			CompanyCode: compCode[i],
		}
		err := company.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}
}

func TestGoodsStock(t *testing.T) {
	InitTestDB()
	cards := make([]GameCard, 0)
	err := NewGameCardQuerySet(DBDev).All(&cards)
	if err != nil {
		logger.Error("err:", err)
	}
	stores := make([]Store, 0)
	err = NewStoreQuerySet(DBDev).IsOnlineEq(1).All(&stores)
	if err != nil {
		logger.Error("err:", err)
	}

	for _, store := range stores {
		for _, card := range cards {
			stock := &GameCardGoodsStock{
				StoreId:    uint64(store.ID),
				GameCardId: uint64(card.ID),
				StoreStock: 1000,
				RentStock:  10,
			}
			err := stock.Create(DBDev)
			if err != nil {
				logger.Error("err:", err)
			}
		}
	}
}

func TestGoodsCard(t *testing.T) {
	InitTestDB()
	cards := make([]GameCard, 0)
	err := NewGameCardQuerySet(DBDev).All(&cards)
	if err != nil {
		logger.Error("err:", err)
	}
	stores := make([]Store, 0)
	err = NewStoreQuerySet(DBDev).IsOnlineEq(1).All(&stores)
	if err != nil {
		logger.Error("err:", err)
	}

	for _, store := range stores {
		for _, card := range cards {
			stock := &GameCardGoodsStock{
				StoreId:    uint64(store.ID),
				GameCardId: uint64(card.ID),
				StoreStock: 1000,
				RentStock:  10,
			}
			err := stock.Create(DBDev)
			if err != nil {
				logger.Error("err:", err)
			}
		}
	}
}

func TestOrderList(t *testing.T) {
	InitTestDB()
	count, err := NewOrderQuerySet(DBDev.Debug()).UidEq(uint64(55191926)).PayStatusEq(PayStatusPaid).CardStatusIn([]uint8{1, 2, 3}...).Count()
	if err != nil {
		logger.Error("err:", err)

	}

	fmt.Println("count:", count)
}

func TestGenShareCode(t *testing.T) {

}

// 用户绑定门店
func TestUserBundleFirstOrderStore(t *testing.T) {
	UserBundleFirstOrderStore()
}

func UserBundleFirstOrderStore() {
	InitDBProd()
	var users []User
	//err := NewUserQuerySet(DBProd).StoreIdEq(0).MemberLevelGte(2).OrderAscByID().All(&users)
	err := NewUserQuerySet(DBProd).StoreTypeEq(1).OrderAscByID().All(&users)
	if err != nil {
		fmt.Println("users err:", err)
		return
	}

	for i, _ := range users {
		//var order Order
		//err := NewOrderQuerySet(DBProd).UidEq(uint64(users[i].Uid)).PayStatusEq(PayStatusPaid).
		//	CardStatusEq(OrderCardStatusCompleted).OrderAscByCreatedAt().Limit(1).One(&order)
		//if err != nil {
		//	fmt.Println("store_id err:", err)
		//	//return
		//}

		//if i > 3{
		//	return
		//}
		if users[i].Uid == 0 {
			continue
		}
		//sql := fmt.Sprintf("UPDATE `user` SET store_id =%d,store_type=1 WHERE uid = %d;", order.StoreId, users[i].Uid)
		//fmt.Println("sql:", sql)
		//err = DBProd.Exec(sql).Error
		//if err != nil {
		//	fmt.Println("store_id err:", err)
		//	return
		//}
		userInvite := &UserInvite{
			FromUid:        0,
			UserType:       0,
			StoreId:        users[i].StoreId,
			MemberOpenTime: users[i].MemberExpire.AddDate(-1, 0, 0),
			MemberType:     2,
			MemberStatus:   2,
			ToUid:          users[i].Uid,
			StoreType:      1,
		}

		err = DBProd.Create(userInvite).Error
		if err != nil {
			fmt.Println("create err:", err)
		}
	}
}

func TestMemberCode(t *testing.T) {

	for i := 0; i < 100; i++ {
		MemberCode()
	}

}

func MemberCode() {
	//sha256.New()
	//ft := time.Now().Format("20060102150405")
	st := fmt.Sprintf("%d", time.Now().UnixNano())
	str := "test-hash" + st
	hasher := sha512.New()

	hasher.Write([]byte(str))

	r := hasher.Sum(nil)

	//fmt.Printf("%x \n",r)

	hs := fmt.Sprintf("%x", r)

	upper := strings.ToUpper(hs)

	fmt.Println("upper:", upper)

}

func TestLeng(t *testing.T) {
	fmt.Println("len:", len("22AB0776591642F13101"))

	// B61E1104C989D4E2F453EB6253A06A3721094DDF76FF468EB679CEA046403D3F7B963A8FBED0CB70C1EB9B17BB684DAFB700F966676D
}

// 生成会员兑换码
func TestRedeemCodeCreate(t *testing.T) {
	RedeemCodeCreate()
}

func RedeemCodeCreate() {
	//InitTestDB()
	InitDBProd()

	for i := 0; i < 7; i++ {
		redeem := NewRedeemCode()

		fmt.Println("redeemCode:", redeem)

		secretCode := RedeemSecretCode(redeem)

		fmt.Println("secretCode:", secretCode)
		if !IsRedeemCodeExist(redeem) {
			redeemCode := &RedeemCode{
				SerialCode:     redeem,
				CodeType:       CodeTypeMemberGoldMember,
				Status:         RedeemCodeStatusStock,
				CodeSecret:     secretCode,
				EffectiveTime:  time.Now(),
				ExpirationTime: time.Now().AddDate(1, 0, 0),
			}
			//err := DBDev.Create(redeemCode).Error
			err := DBProd.Create(redeemCode).Error
			if err != nil {
				fmt.Println("err:", err)

			}
		}

	}

}

func IsRedeemCodeExist(code string) bool {
	var isExist uint32
	sql := fmt.Sprintf("SELECT EXISTS (SELECT * FROM redeem_code WHERE serial_code = '%s') AS code_exsit;", code)
	//err := DBDev.Raw(sql).Row().Scan(&isExist)
	err := DBProd.Raw(sql).Row().Scan(&isExist)
	if err != nil {
		fmt.Println("err:", err)
		return true
	}
	return isExist == 1
}

func NewRedeemCode() string {
	semen := fmt.Sprintf("MemberCard30%d", time.Now().UnixNano())
	shaer := sha512.New()
	shaer.Write([]byte(semen))
	r := shaer.Sum(nil)
	hs := fmt.Sprintf("%x", r)
	hs = strings.ToUpper(hs)

	return "MC30" + hs[:19]
}

func TestInitConfig(t *testing.T) {
	InitConfig()
}

func InitConfig() {
	//InitTestDB()
	InitDBProd()

	payConfig := &PayConfig{
		MemberFee:  29900,
		DepositFee: 30000,
		NotifyUrl:  "https://switch.deovo.com:8001/api/v1/wxpay/notice",
	}
	bytes, err := json.Marshal(payConfig)
	if err != nil {
		fmt.Println("err:", err)
	}

	configInfo := &Config{
		Name:  "pay_config",
		Value: string(bytes),
	}

	err = DBProd.Create(configInfo).Error
	if err != nil {
		fmt.Println("err:", err)
	}
}

func TestMergingGameCards(t *testing.T) {
	MergingGameCards()
}

func MergingGameCards() {

	//UPDATE history_browsing SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE collection SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE game_card_goods SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE `order` SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE shopping_cart SET game_card_id=782  WHERE game_card_id = 870;

	fromGameId := uint64(870)
	toGameId := uint64(782)
	InitDBProd()
	var fromGameCardStock []GameCardGoodsStock
	err := NewGameCardGoodsStockQuerySet(DBProd).GameCardIdEq(fromGameId).All(&fromGameCardStock)
	if err != nil {
		logger.Error("err:", err)
		return
	}

	var toGameCardStock []GameCardGoodsStock
	err = NewGameCardGoodsStockQuerySet(DBProd).GameCardIdEq(toGameId).All(&toGameCardStock)
	if err != nil {
		logger.Error("err:", err)
		return
	}

	toGameMap := make(map[uint64]GameCardGoodsStock, 0)
	for i, _ := range toGameCardStock {
		toGameMap[toGameCardStock[i].StoreId] = toGameCardStock[i]
	}

	for _, v := range fromGameCardStock {

		//fmt.Println("fromGameCardStock:", fromGameCardStock[i].StoreId)
		//fmt.Println("fromGameCardStock:", fromGameCardStock[i].StoreStock)
		//fmt.Println("fromGameCardStock:", v.RentStock)

		cardGoodsStock, ok := toGameMap[v.StoreId]

		if ok {
			//	cardGoodsStock.StoreStock += v.StoreStock
			//	cardGoodsStock.RentStock += v.RentStock
			//	cardGoodsStock.UserHoldStock += v.UserHoldStock
			//	cardGoodsStock.OrderCount += v.OrderCount
			//	cardGoodsStock.TotalStock += v.TotalStock
			//	err := DBProd.Save(&cardGoodsStock).Error
			//	if err != nil {
			//		logger.Error("err:", err)
			//	}
			fmt.Println("cardGoodsStock:", cardGoodsStock)
		} else {
			fmt.Println("cardGoodsStock:", v.StoreId)
			v.ID = 0
			v.GameCardId = 782
			err := DBProd.Create(&v).Error
			if err != nil {
				logger.Error("create err:", err)
			}
		}
	}

}

func TestGoodsAdd(t *testing.T) {
	GoodsAdd()
}

func GoodsAdd() {
	InitTestDB()
	for i := 0; i < 5; i++ {
		goods := Goods{
			GoodsId:       1 + uint32(i) + 1,
			SerialNo:      "sdhfjskdhjk" + fmt.Sprintf("%d", i+1),
			CatId:         1,
			Name:          "宝可梦剑" + fmt.Sprintf("%d", i+1),
			Title:         "宝可梦剑",
			MainImage:     "https://minghui-oss.oss-cn-shenzhen.aliyuncs.com/eceec8e0-da21-11eb-8936-197fd3ba503d.jpg",
			Images:        "https://minghui-oss.oss-cn-shenzhen.aliyuncs.com/eceec8e0-da21-11eb-8936-197fd3ba503d.jpg",
			Stock:         10,
			Detail:        "宝可梦剑 详情" + fmt.Sprintf("%d", i+1),
			SoldCount:     0,
			SaleStatus:    1,
			PriceVm:       10 + uint32(i),
			PriceRm:       29900,
			PriceOriginal: 29900,
			DeliveryFee:   1000,
			VersionId:     0,
		}

		err := DBDev.Create(&goods).Error
		if err != nil {
			fmt.Println("err:", err)
		}
	}

}

func UpdateUserName() {
	InitDBProd()

}

func TestMemberUserList(t *testing.T) {
	MemberUserList()
}

func MemberUserList() {
	InitDBProd()
	var users []User
	err := NewUserQuerySet(DBProd).MemberLevelEq(2).OrderAscByID().All(&users)
	//err := NewUserQuerySet(DBProd).MemberLevelNe(2).OrderAscByID().All(&users)
	//err := NewUserQuerySet(DBProd).StoreTypeEq(1).OrderAscByID().All(&users)
	if err != nil {
		fmt.Println("users err:", err)
		return
	}
	endTime, _ := time.Parse("2006-01-02", "2022-02-13")
	startTime, _ := time.Parse("2006-01-02", "2021-07-30")

	for _, user := range users {
		count, err := NewUserInviteQuerySet(DBProd).ToUidEq(user.Uid).MemberTypeEq(2).MemberOpenTimeGt(startTime).MemberOpenTimeLt(endTime).Count()
		//count, err := NewUserInviteQuerySet(DBProd).ToUidEq(user.Uid).MemberTypeEq(2).MemberOpenTimeGt(startTime).MemberOpenTimeLt(endTime).Count()
		if err != nil {
			fmt.Println("err:", err)
		}
		if count == 0 {
			fmt.Println("user :", user.Uid)
		}
	}

}

func TestOpenMemberTimeUserList(t *testing.T) {
	OpenMemberTimeUserList()
}

func OpenMemberTimeUserList() {
	InitDBProd()
	var users []User
	err := NewUserQuerySet(DBProd).MemberLevelEq(2).All(&users)
	if err != nil {
		fmt.Println("err:", err)
	}
	userMap := make(map[uint32]User, 0)
	for i, _ := range users {
		userMap[users[i].Uid] = users[i]
	}

	var userInvites []UserInvite
	err = NewUserInviteQuerySet(DBProd).MemberTypeEq(2).All(&userInvites)
	if err != nil {
		fmt.Println("err:", err)
	}

	for i, _ := range userInvites {
		user, ok := userMap[userInvites[i].ToUid]
		if ok {
			if user.OpenMemberTime.IsZero() {
				fmt.Println("", user.OpenMemberTime, user.Uid, user.MemberLevel)
				fmt.Println("", userInvites[i].MemberOpenTime, userInvites[i].MemberType, userInvites[i].ToUid)

			}
		}

	}

}

func TestSyncUserRentCard(t *testing.T) {
	SyncUserRentCard()
}

func SyncUserRentCard() {
	InitDBProd()
	var users []User
	err := NewUserQuerySet(DBProd).MemberLevelIn(2, 3).All(&users)
	if err != nil {
		logger.Error("err:", err)
	}

	for _, user := range users {
		var orderCards []OrderCard
		qs := NewOrderCardQuerySet(DBProd).UidEq(user.Uid).CardStatusIn(1, 2, 3).PayStatusEq(2)
		qs.All(&orderCards)
		count, err := qs.Count()
		if err != nil {
			fmt.Println("err:", err)
		}
		if count > 1 {
			//if orderCards[0].CardStatus > 1 &&orderCards[1].CardStatus >1{
			//	continue
			//}
			fmt.Println("订单 count: uid:", count, user.Uid, orderCards[0].CardStatus, orderCards[1].CardStatus)
		}
	}
	//for _, user := range users {
	//	fmt.Println("user:", user.MemberLevel, user.MemberExpire, user.OpenMemberTime)
	//	userRentCard := &UserRentCard{
	//		Uid:            user.Uid,
	//		MemberLevel:    user.MemberLevel,
	//		LevelRentCount: 1,
	//		HaveRentCount:  0,
	//		CanRentCount:   1,
	//		Status:         0,
	//	}
	//	err = DBProd.Create(userRentCard).Error
	//	if err != nil {
	//		logger.Error("err:", err)
	//	}
	//}
}

func TestSyncUserOpenMemberTime(t *testing.T) {
	SyncUserOpenMemberTime()
}

func SyncUserOpenMemberTime() {
	InitDBProd()
	var userInvites []UserInvite
	err := NewUserInviteQuerySet(DBProd).MemberTypeEq(2).All(&userInvites)
	if err != nil {
		logger.Error("err:", err)
	}
	count := 0
	for _, userInvite := range userInvites {
		fmt.Println("user:", userInvite.MemberLevel, userInvite.MemberOpenTime)
		//err = NewUserInviteQuerySet(DBProd).IDEq(userInvite.ID).GetUpdater().SetMemberLevel(2).Update()
		//if err != nil {
		//	logger.Error("err:", err)
		//}

		err = NewUserQuerySet(DBProd).UidEq(userInvite.ToUid).GetUpdater().
			SetOpenMemberTime(userInvite.MemberOpenTime).Update()
		if err != nil {
			logger.Error("err:", err)
		}
		count++
	}

	fmt.Println("count:", count)
}

func TestSyncUserOrder(t *testing.T) {
	SyncUserOrder()
}

func SyncUserOrder() {
	InitDBProd()
	var orders []Order
	sql := fmt.Sprintf("SELECT * FROM `order` WHERE pay_status = 2 AND card_status IN (1,2,3);")
	err := DBProd.Raw(sql).Scan(&orders).Error
	//err := NewOrderQuerySet(DBProd).PayStatusEq(2).CardStatusIn([]uint8{1, 2, 3}...).All(&orders)
	if err != nil {
		logger.Error("err:", err)
		return
	}
	fmt.Println("orders:", len(orders))
	//for _, order := range orders {
	//	//fmt.Println("order:", order.PayStatus, order.GameCardGoodsId)
	//	//var gameCardGoods GameCardGoods
	//	//err = NewGameCardGoodsQuerySet(DBProd).IDEq(uint32(order.GameCardGoodsId)).One(&gameCardGoods)
	//	//if err != nil {
	//	//	logger.Error("err:", err)
	//	//	//continue
	//	//}
	//	//orderCard := OrderCard{
	//	//	OrderId:                order.ID,
	//	//	Uid:                    uint32(order.Uid),
	//	//	GameCardId:             uint32(order.GameCardId),
	//	//	GameCardGoodsId:        uint32(order.GameCardGoodsId),
	//	//	StoreId:                uint32(order.StoreId),
	//	//	CardStatus:             uint32(order.CardStatus),
	//	//	DeliveryTime:           order.DeliveryTime,
	//	//	ReceiptTime:            order.ReceiptTime,
	//	//	DeliveryType:           order.DeliveryType,
	//	//	SerialNumber:           order.GameCardSerialNumber,
	//	//	PayStatus:              order.PayStatus,
	//	//	RevertStoreId:          order.RevertStoreId,
	//	//	RevertTime:             order.RevertTime,
	//	//	RevertExpressCompany:   order.RevertExpressCompany,
	//	//	RevertExpressCompanyNo: order.RevertExpressCompanyNo,
	//	//	RevertExpressNo:        order.RevertExpressNo,
	//	//	RevertExpressDuration:  order.RevertExpressDuration,
	//	//
	//	//	//Postage:                order.Postage,
	//	//	//ExpressCompany:         order.ExpressCompany,
	//	//	//ExpressCompanyNo:       order.ExpressCompanyNo,
	//	//	//ExpressNo:              order.ExpressNo,
	//	//	//GamePrice:              0,
	//	//	//GameCoverImg:           "",
	//	//	//Order:                  nil,
	//	//}
	//	//fmt.Println("order:", order.ID, order.PayStatus, order.CardStatus, order.Uid, order.GameCardId)
	//	//err = DBProd.Create(&orderCard).Error
	//	//if err != nil {
	//	//	logger.Error("err:", err)
	//	//}
	//}
}

func TestSyncUserRent(t *testing.T) {
	SyncUserRent()
}

func SyncUserRent() {
	InitDBProd()
	var users []User
	err := NewUserQuerySet(DBProd).MemberLevelIn(2, 3).All(&users)
	if err != nil {
		logger.Error("err:", err)
	}
	//Order{}
	for _, user := range users {
		if user.Uid == 34021861 || user.Uid == 81309358 {
			continue
		}
		count, err := NewUserRentCardQuerySet(DBProd).UidEq(user.Uid).CanRentCountEq(1).HaveRentCountEq(0).Count()
		if err != nil {
			fmt.Println("err:", err)
		}
		if count > 0 {
			orderCount, err := NewOrderCardQuerySet(DBProd).UidEq(user.Uid).CardStatusIn(1, 2, 3).PayStatusEq(2).Count()
			if err != nil {
				fmt.Println("err:", err)
			}
			if orderCount == 0 {
				continue
			}
			fmt.Println("订单 count: uid:", orderCount, user.Uid)

			//_, err = NewUserRentCardQuerySet(DBProd).UidEq(user.Uid).GetUpdater().SetCanRentCount(0).
			//	SetHaveRentCount(1).UpdateNum()
			//if err != nil {
			//	fmt.Println("err:", err)
			//}
		}
	}
}

func TestOrderCancelId(t *testing.T) {
	//OrderCancelId()
}

//func OrderCancelId() {
//	ids := []uint32{8288, 8265}
//	for _, id := range ids {
//		//OrderCancel(id)
//		controller.OrderCancelBy(id)
//	}
//
//}

//func OrderCancel(id uint32) {
//	//InitDBProd()
//	//DB = DBProd
//	var order Order
//	err := NewOrderQuerySet(DB).IDEq(id).One(&order)
//	if err != nil {
//		fmt.Println("err:", err)
//	}
//
//	outTradeNo, err := GetWxPayExpressFeeRefundRecord(order.ID)
//	if err != nil {
//		logger.Error("err:", err)
//		return
//	}
//
//	orderSn := GetOrderSn()
//	err = UserOpenMemberRecord{Uid: uint32(order.Uid), OpenNo: orderSn, OrderId: order.ID, OrderType: 2}.Insert()
//	if err != nil {
//		logger.Error(errors.New("WebPay err"))
//		return
//	}
//
//	orderRefund := wxpay.OrderRefund{
//		OutTradeNo:  outTradeNo,
//		OutRefundNo: orderSn,
//		NotifyUrl:   "",
//		Amount: wxpay.OrderRefundAmount{a
//			Refund:   order.PayPrice,
//			Total:    order.PayPrice,
//			Currency: "CNY",
//		},
//	}
//	bytes, _ := json.Marshal(order)
//	fmt.Println("订单取消:", string(bytes))
//	orderRefundJson, _ := json.Marshal(&orderRefund)
//	fmt.Println("订单取消 orderRefundJson:", string(orderRefundJson))
//	//err = wxpay.WxPayOrderRefund(orderRefund)
//	err = wxpay.TransactionOrderRefund(orderRefund)
//	if err != nil {
//		logger.Error("err:", err)
//		return
//	}
//}

func TestGameCardGoodsStockInspection(t *testing.T) {
	GameCardGoodsStockInspection()
}

func GameCardGoodsStockInspection() {
	InitDBProd()

	var gameCardGoodses []GameCardGoods
	err := NewGameCardGoodsQuerySet(DBProd).StoreIdEq(16).All(&gameCardGoodses)
	if err != nil {
		logger.Error("err:", err)
	}

	rentMap := make(map[uint32]uint32, 0)
	holdMap := make(map[uint32]uint32, 0)
	for _, gameCard := range gameCardGoodses {
		if gameCard.Status == 1 {
			//rentMap[uint32(gameCard.StoreId)] += 1
			rentMap[uint32(gameCard.GameCardId)] += 1
		}
		if gameCard.Status == 3 {
			holdMap[uint32(gameCard.GameCardId)] += 1
		}
	}
	var gameCardGoodsStocks []GameCardGoodsStock
	err = NewGameCardGoodsStockQuerySet(DBProd).StoreIdEq(16).All(&gameCardGoodsStocks)
	if err != nil {
		logger.Error("err:", err)
	}
	for _, stock := range gameCardGoodsStocks {
		rent := rentMap[uint32(stock.GameCardId)]
		hold := holdMap[uint32(stock.GameCardId)]
		//fmt.Println("StoreId:", stock.StoreId, "rent:", rent, stock.RentStock, "hold:", hold, stock.UserHoldStock)

		if rent != stock.RentStock || hold != stock.UserHoldStock {
			fmt.Println("StoreId:", stock.StoreId, "rent:", rent, stock.RentStock, "hold:", hold, stock.UserHoldStock, stock.GameCardId)
		}
	}

}

func TestTimeZeroData(t *testing.T) {
	InitTestDB()

	//NewShareCardRetrieveCardQuerySet(DB).IDEq(189).GetUpdater().SetStoreId()

}

func TestWxPayDecode(t *testing.T) {
	config := AttendanceVmConfig{
		VmDay1: 2,
		VmDay2: 4,
		VmDay3: 6,
		VmDay4: 8,
		VmDay5: 10,
		VmDay6: 12,
		VmDay7: 14,
	}

	marshal, _ := json.Marshal(&config)

	fmt.Println("config:", string(marshal))
}

func TestAtt(t *testing.T) {
	InitTestDB()
	DB = DBDev

	UserAttendanceDays()
}

func UserAttendanceDays() {
	uc := &auth.UserClaims{Uid: 31871993}
	list := make([]AttendanceInfo, 0, 7)
	todayZero := utils.TodayZeroDateFormat()
	configInfo, err := AttendanceVmConfigInfo()
	if err != nil {
		logger.Error("attendance vm config info err:", err)
		//RespJson(c, status.InternalServerError, nil)
		return
	}

	var attendanceRecord UserAttendanceRecord
	err = NewUserAttendanceRecordQuerySet(DB).UidEq(uc.Uid).AttendanceDateEq(todayZero).One(&attendanceRecord)
	if err != nil && err != RecordNotFound {
		logger.Error("user attendance record err:")
		//RespJson(c, status.InternalServerError, nil)
		return
	}

	if err == RecordNotFound {
		for i := 0; i < 7; i++ {
			info := AttendanceInfo{
				IndexDay: uint32(i) + 1,
				Date:     utils.TodayZeroAddDaysDateFormat((-1) * (7 - i)),
				State:    1,
				Vm:       configInfo.Vm(uint32(i) + 1),
			}
			list = append(list, info)
		}
		ret := map[string]interface{}{
			"list":          list,
			"is_attendance": 1,
		}
		retJson, _ := json.Marshal(&ret)
		fmt.Println("ret:", string(retJson))
		//RespOK(c, ret)
		return
	}

	var userAttendance UserAttendance
	err = NewUserAttendanceQuerySet(DB).UidEq(uc.Uid).One(&userAttendance)
	if err != nil && err != RecordNotFound {
		logger.Error("user attendance record err:")
		//RespJson(c, status.InternalServerError, nil)
		return
	}

	attendanceDays := int(userAttendance.ConsecutiveDays % 7)
	if attendanceDays == 0 {
		attendanceDays = 7
	}
	days := attendanceDays
	fmt.Println("--------attendanceDays:", attendanceDays)
	for i := 0; i < 7; i++ {
		state := uint32(1)
		if attendanceDays > 0 {
			state = 2
		}
		fmt.Println("attendanceDays:", attendanceDays)
		info := AttendanceInfo{
			IndexDay: uint32(i) + 1,
			//Date:     utils.TodayZeroAddDaysDateFormat((-1) * (7 - i)),
			Date:  utils.TodayZeroAddDaysDateFormat(i + 1 - days),
			State: state,
			Vm:    configInfo.Vm(uint32(i) + 1),
		}

		list = append(list, info)
		attendanceDays--
	}

	isAttendance := 1
	if attendanceRecord.AttendanceDate == todayZero {
		isAttendance = 2
	}
	ret := map[string]interface{}{
		"list":          list,
		"is_attendance": isAttendance,
	}

	retJson, _ := json.Marshal(&ret)
	fmt.Println("ret:", string(retJson))
}

func TestAddCooperativeBusiness(t *testing.T) {
	InitTestDB()
	//business := &CooperativeBusiness{
	//	Name:    "迪为",
	//	AddTime: time.Now(),
	//}
	//err := DBDev.Create(business).Error
	//if err != nil {
	//	logger.Error("err:")
	//}
	deduct := &CooperativeMemberDeduct{
		CooperativeBusinessId: 1,
		GoldDeduct:            5000,
		PlatinumDeduct:        8000,
		BlackGoldDeduct:       1500,
	}
	err := DBDev.Create(deduct).Error
	if err != nil {
		logger.Error("err:")
	}
}

func CreateEx() {
	file := excelize.NewFile()
	sheet := "Sheet1"
	index := file.NewSheet(sheet)

	file.SetCellStr(sheet, "A1", "这个表格")

	file.SetActiveSheet(index)

	err := file.SaveAs("boo.xlsx")
	if err != nil {
		logger.Error("err:", err)
	}

}

func TestAddMemberPromotion(t *testing.T) {
	AddMemberPromotion()
}

func AddMemberPromotion() {
	InitTestDB()
	sql := fmt.Sprintf("UPDATE cooperative_member_promotion SET gold_count=gold_count+1 WHERE date=%s AND cooperative_business_id=%d", "2022-04", 1)
	err := DBDev.Exec(sql).Error
	if err != nil {
		logger.Error("err:", err)
	}

}

func TestXcxRoleAdd(t *testing.T) {
	InitTestDB()
	role := &XcxRole{
		RoleName: "店长",
		RoleKey:  "shop_manager",
		RoleSort: 2,
		Status:   "normal",
		Flag:     "",
		CreateBy: "",
		UpdateBy: "",
		Remark:   "",
	}
	err := DBDev.Create(role).Error
	if err != nil {
		logger.Error("err:")
	}
	// assistant
	//shop_manager  长
}

func TestExportGoodsStock(t *testing.T) {
	InitTestDB()
	DB = DBDev
	stock := ExportGoodsStock(13)
	fmt.Println("stock:", stock)

}

func TestAddCooperativeMemberPromotion(t *testing.T) {
	InitTestDB()
	DB = DBDev
	AddCooperativeMemberPromotion(4, 20, 68608411, 2)
}