mh_server/model/model_test.go

package model

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

	//"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{},
		// 商城
		//&Goods{},
		//&GoodsCat{},
		//&GoodsAttribute{},
		//&GoodsAttributeCombo{},
		//&Spec{},
		//&SpecValue{},
		//&GoodsOrder{},
		//&OperationLog{},
		//&DeliverTask{},
		//&DeliverTaskSub{},
		// 优惠券
		//&GameCard{},
		//&ActivityMemberRenewal{},
		//&Activity{},
		//&UserCoupon{},
		//&Coupon{},
		//&UserOpenMemberRecord{},
		//&HomeCarousel{},
		//&UserRenewalLog{},
		// 续费会员
		//&User{},
		//&UserOpenMemberRecord{},
		//&CooperativeMemberDeduct{},
		//&CooperativeAssistantMemberDeduct{},
		//&UserMemberRecord{},
		//&CooperativeDeductSettle{},
		//&CooperativeMemberPromotionStore{},
		//&CooperativeMemberPromotionDay{},
		//&InviteMemberReport{},
		//&MemberStatisticDaily{},
		//&CooperativeMemberPromotion{},
		//&GameCard{},
		//&CooperativeMemberPromotionStoreDay{},
		//
		//&UserInvite{},
		//&UserInviteRecord{},
		//&CooperativeMemberPromotionStore{},

		&RecycleCardOrder{},
		&RedeemCode{},
		&PublicRecord{},
	)

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

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

func TestMemberExpireTime(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(
		&RecycleCardOrder{},
		&RedeemCode{},
		&PublicRecord{},
	)

	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 TestActivity_Create(t *testing.T) {
	InitTestDB()
	DB = DBDev
	//activity := Activity{
	//	Name:         "会员续费优惠券",
	//	ActivityType: 1,
	//	State:        2,
	//	StartTime:    utils.Now(),
	//	EndTime:      utils.Now().AddDate(1, 0, 0),
	//}

	//&UserCoupon{
	//	Uid:          0,
	//	CouponId:     0,
	//	CouponType:   "",
	//	ActivityType: 0,
	//	Value:        0,
	//	State:        0,
	//	ActiveStart:  time.Time{},
	//	ActiveEnd:    time.Time{},
	//},

	coupon := Coupon{
		Name:         "150抵扣券",
		Describe:     "续费黑金会员减150",
		CouponType:   "deduction",
		ActivityType: 1,
		ActivityId:   1,
		Value:        15000,
		OutCount:     0,
		UsedCount:    0,
		ActiveStart:  utils.Now(),
		ActiveEnd:    utils.Now().AddDate(1, 0, 0),
	}

	err := DB.Create(&coupon).Error
	if err != nil {
		logger.Error("coupon 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("MC30")

		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 TestDeductionCoupon5Create(t *testing.T) {
	RedeemCodeDeductionCoupon5Create()
}

func RedeemCodeDeductionCoupon5Create() {
	InitTestDB()
	//InitDBProd()

	for i := 0; i < 9950; i++ {
		redeem := NewRedeemCode("DC5")

		fmt.Println("redeemCode:", redeem)

		secretCode := RedeemSecretCode(redeem)

		fmt.Println("secretCode:", secretCode)
		if !IsRedeemCodeExist(redeem) { // 数据库 TODO
			redeemCode := &RedeemCode{
				SerialCode:     redeem,
				CodeType:       CodeTypeDeductionCoupon5,
				Status:         RedeemCodeStatusStock,
				StoreId:        0,
				CodeSecret:     secretCode,
				EffectiveTime:  time.Now(),
				ExpirationTime: time.Now().AddDate(1, 0, 0),
				CouponId:       4,
			}
			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(prefix string) 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 prefix + 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)
}

func TestUpdateCooperativeBusiness(t *testing.T) {
	//InitTestDB()
	//DB = DBDev
	InitDBProd()
	DB = DBProd

	//var list []GameCardGoods
	//err := DB.Table("game_card").Find(&list).Error
	//if err != nil {
	//	fmt.Println("err:", err)
	//}
	//storeMap := GetAllStoreMap()
	chendu := []uint32{15, 17, 20, 21}
	chongqin := []uint32{12, 16}
	diwei := []uint32{13, 14, 18, 19, 23, 24, 25}
	DB.Table("user").Where("store_id in (?)", chendu).Updates(map[string]interface{}{
		"cooperative_business_id": 2,
		"cooperative_name":        "成都合作商",
	})
	DB.Table("user").Where("store_id in (?)", chongqin).Updates(map[string]interface{}{
		"cooperative_business_id": 3,
		"cooperative_name":        "重庆合作商",
	})
	DB.Table("user").Where("store_id in (?)", diwei).Updates(map[string]interface{}{
		"cooperative_business_id": 1,
		"cooperative_name":        "迪为合作商",
	})

}

func TestUpdateCooperativeMemberDeduct(t *testing.T) {
	InitDBProd()
	DB = DBProd
	var stores []Store
	err := DB.Table("store").Find(&stores).Error
	if err != nil {
		logger.Error("err:", err)
	}

	for i, _ := range stores {
		deduct := &CooperativeAssistantMemberDeduct{
			CooperativeBusinessId: stores[i].CooperativeBusinessId,
			StoreId:               stores[i].ID,
			GoldDeduct:            4000,
			PlatinumDeduct:        8000,
			BlackGoldDeduct:       15000,
		}
		fmt.Println("deduct:", deduct.CooperativeBusinessId)
		fmt.Println("deduct:", deduct.StoreId)
		err = DB.Create(deduct).Error
		if err != nil {
			logger.Error("err:", err)
		}
	}

}

func TestUpdateUid(t *testing.T) {
	InitDBProd()
	DB = DBProd

	//uid := 52260289
	//newUid := 12345678

	//InitTestDB()
	//DB = DBDev
	uid := 55191927
	newUid := 55191926

	//err := DB.Table("").Where("uid=?", uid).Update("uid", 12345678).Error
	//if err != nil {
	//	fmt.Println("err:", err)
	//}

	err := DB.Table("user_consume_record").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_member_expire_delay").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("invite_member_report").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("order").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("order_card").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_attendance").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_invite").Where("from_uid=?", uid).Update("from_uid", newUid).Error
	err = DB.Table("user_invite").Where("to_uid=?", uid).Update("to_uid", newUid).Error
	err = DB.Table("article_collect").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("card_issue_feedback").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("operation_log").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_share_card").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_share_card_bill").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("share_card_retrieve").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("share_card_bill_game").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("share_card_retrieve_card").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_attendance_record").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("deposit_refund_record").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("goods_order").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("collection").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_rent_card").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_vm").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("fund_record").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_address").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_share_card_vm").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("share_card_date_vm").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_vm_record").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("history_browsing").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("search_history").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("shopping_cart").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_refresh_token").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_redeem_code").Where("uid=?", uid).Update("uid", newUid).Error
	err = DB.Table("user_open_member_record").Where("uid=?", uid).Update("uid", newUid).Error
	if err != nil {
		fmt.Println("err:", err)
	}

}

func TestStringSort(t *testing.T) {
	idx := "1,20,14,7"
	////list := strings.Split(idx, ",")
	////sort.Strings(list)
	////fmt.Println("list:", list)

	stringSort, err := NumStringSort(idx)
	if err != nil {
		fmt.Println("err:", err)
	}

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

func NumStringSort(n string) (string, error) {
	numStrings := strings.Split(n, ",")
	nums := make([]int, 0, len(numStrings))
	for i, _ := range numStrings {
		num, err := strconv.Atoi(numStrings[i])
		if err != nil {
			logger.Error("num err:", err)
			return "", err
		}
		nums = append(nums, num)
	}
	ns := ""
	sort.Ints(nums)
	for i, _ := range nums {
		ns += fmt.Sprintf("%d,", nums[i])
	}

	return ns[:len(ns)-1], nil
}

func TestByte(t *testing.T) {
	s := strings.Split("91 123 34 105 100 34 58 49 53 57 57 44 34 99 114 101 97 116 101 100 65 116 34 58 34 50 48 50 50 45 48 54 45 48 56 84 49 49 58 52 54 58 51 53 43 48 56 58 48 48 34 44 34 117 105 100 34 58 53 54 52 48 50 56 54 44 34 103 97 109 101 95 99 97 114 100 95 105 100 34 58 48 44 34 103 97 109 101 95 99 97 114 100 95 103 111 111 100 115 95 105 100 34 58 48 44 34 103 97 109 101 95 99 97 114 100 95 115 101 114 105 97 108 95 110 117 109 98 101 114 34 58 34 98 50 50 50 49 49 49 34 44 34 115 116 111 114 101 95 105 100 34 58 50 57 44 34 117 115 101 114 95 97 100 100 114 101 115 115 95 105 100 34 58 48 44 34 100 101 108 105 118 101 114 121 95 116 121 112 101 34 58 49 44 34 99 111 117 110 116 34 58 49 44 34 112 105 99 107 117 112 95 99 111 100 101 34 58 34 229 183 178 229 143 150 232 180 167 34 44 34 99 97 114 100 95 115 116 97 116 117 115 34 58 52 44 34 100 101 108 105 118 101 114 121 95 116 105 109 101 34 58 34 50 48 50 50 45 48 54 45 48 56 84 49 49 58 52 55 58 53 56 43 48 56 58 48 48 34 44 34 114 101 99 101 105 112 116 95 116 105 109 101 34 58 34 48 48 48 49 45 48 49 45 48 49 84 48 48 58 48 48 58 48 48 90 34 44 34 112 97 121 95 116 105 109 101 34 58 34 50 48 50 50 45 48 54 45 48 56 84 49 49 58 52 54 58 51 53 43 48 56 58 48 48 34 44 34 112 97 121 95 115 116 97 116 117 115 34 58 50 44 34 111 114 100 101 114 95 115 110 34 58 34 55 56 49 57 50 51 66 54 50 56 34 44 34 112 97 121 95 112 114 105 99 101 34 58 48 44 34 112 111 115 116 97 103 101 34 58 48 44 34 101 120 112 114 101 115 115 95 99 111 109 112 97 110 121 34 58 34 34 44 34 101 120 112 114 101 115 115 95 99 111 109 112 97 110 121 95 110 111 34 58 34 34 44 34 101 120 112 114 101 115 115 95 110 111 34 58 34 34 44 34 101 120 112 114 101 115 115 95 100 117 114 97 116 105 111 110 34 58 48 44 34 114 101 118 101 114 116 95 115 116 111 114 101 95 105 100 34 58 48 44 34 114 101 118 101 114 116 95 116 105 109 101 34 58 34 48 48 48 49 45 48 49 45 48 49 84 48 48 58 48 48 58 48 48 90 34 44 34 114 101 118 101 114 116 95 101 120 112 114 101 115 115 95 99 111 109 112 97 110 121 34 58 34 34 44 34 114 101 118 101 114 116 95 101 120 112 114 101 115 115 95 99 111 109 112 97 110 121 95 110 111 34 58 34 34 44 34 114 101 118 101 114 116 95 101 120 112 114 101 115 115 95 110 111 34 58 34 34 44 34 114 101 118 101 114 116 95 101 120 112 114 101 115 115 95 100 117 114 97 116 105 111 110 34 58 48 44 34 99 111 111 112 101 114 97 116 105 118 101 95 98 117 115 105 110 101 115 115 95 105 100 34 58 49 48 44 34 99 111 111 112 101 114 97 116 105 118 101 95 110 97 109 101 34 58 34 34 44 34 103 97 109 101 95 99 97 114 100 95 115 101 114 105 97 108 95 110 117 109 98 101 114 115 34 58 110 117 108 108 44 34 111 114 100 101 114 95 99 97 114 100 115 34 58 110 117 108 108 125 93", " ")

	b := make([]byte, 0)
	for i, _ := range s {
		by, _ := strconv.Atoi(s[i])
		b = append(b, byte(by))
	}

	fmt.Println("byte:", string(b))
}

func TestSlice(t *testing.T) {
	//var p [100]int
	//var m interface{} = [...]int{99: 0}
	//fmt.Println(p == m)
	//fmt.Println("p:", p)
	//fmt.Println("m:", m)

	user := User{
		Uid:    123123,
		WxName: "hfiue",
	}

	fmt.Printf("user:%#v", user)
	fmt.Println("")
	fmt.Printf("user:%+v", user)
	fmt.Println("")
}

func TestUserUpgradeMemberRecord(t *testing.T) {

	UserUpgradeMemberRecord()
}

// 导出升级会员数据
func UserUpgradeMemberRecord() {
	InitDBProd()
	var users []User
	err := NewUserQuerySet(DBProd).MemberLevelEq(4).All(&users)
	if err != nil {
		fmt.Println("user err:", err)
	}
	uids := ""
	for i, _ := range users {
		t := users[i].OpenMemberTime.AddDate(1, 0, 0).Unix() - users[i].MemberExpire.Unix()

		if (t > 0 && t > 20*3600) || (t < 0 && t < -20*3600) {
			fmt.Println("user:",
				users[i].MemberExpire.Format(utils.TimeFormat),
				users[i].OpenMemberTime.Format(utils.TimeFormat),
				users[i].CreatedAt.Format(utils.TimeFormat))
			uids += fmt.Sprintf("%d,", users[i].Uid)

		}
	}
	fmt.Println("uids:", uids[:len(uids)-1])
}

func TestOrderUpdater_SetUserAddressId(t *testing.T) {
	//var users []User

	InitTestDB()
	DB = DBDev

	var games []GameCard
	err := NewGameCardQuerySet(DBDev).All(&games)
	if err != nil {
		fmt.Println("err:", err)
	}

	for _, game := range games {
		exist, err := QueryRecordExist(fmt.Sprintf("SELECT * FROM game_card_goods_stock WHERE game_card_id = %d", game.ID))
		if err != nil {
			fmt.Println("err:", err)
		}
		if exist {
			continue
		}
		//if game.ID != 812 {
		//	continue
		//}
		goods := &GameCardGoods{
			GameCardId:            uint64(game.ID),
			SerialNumber:          fmt.Sprintf("%d", game.ID) + "01",
			Status:                1,
			StoreId:               32,
			Provider:              "",
			StockTime:             time.Now(),
			CardType:              "common",
			FunctionState:         2,
			ShareProfitType:       1,
			CooperativeBusinessId: 12,
			CooperativeName:       "代理商01",
		}

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

		goodsStock := &GameCardGoodsStock{
			StoreId:               32,
			GameCardId:            uint64(game.ID),
			StoreStock:            1,
			RentStock:             1,
			UserHoldStock:         0,
			OrderCount:            0,
			TotalStock:            1,
			CooperativeBusinessId: 12,
			CooperativeName:       "代理商01",
			Name:                  game.Name,
			CoverImg:              game.CoverImg,
		}
		err = DBDev.Create(goodsStock).Error
		if err != nil {
			fmt.Println("err:", err)
		}
		err = NewGameCardQuerySet(DBDev).IDEq(game.ID).GetUpdater().SetStatus(1).Update()
		if err != nil {
			fmt.Println("err:", err)
		}
	}
}

func TestActivityRenewalConfig(t *testing.T) {
	config := ActivityRenewalConfig{
		CouponValidity:     7,
		ActivityContinuity: 7,
		PopTrap:            30,
	}

	marshal, err := json.Marshal(&config)
	if err != nil {
		logger.Error("err:", err)
	}
	fmt.Println("marshal:", string(marshal))
}

type MemberData struct {
	Date        string `json:"date"`
	MemberCount uint32 `json:"member_count"`
}

func TestMemberExport(t *testing.T) {
	MemberExport()
}

func MemberExport() {
	InitDBProd()
	date, _ := time.Parse(utils.DateFormat, "2022-08-01")
	list := make([]*MemberData, 0, 7)
	for i := 0; i < 7; i++ {
		end := date.AddDate(0, -1*i, 0)
		start := end.AddDate(0, -1, 0)
		fmt.Println("start:", start.Format(utils.DateFormat))
		fmt.Println("end:", end.Format(utils.DateFormat))
		member := new(MemberData)
		member.Date = start.Format("2006-01")
		err := DBProd.Raw(
			"SELECT COUNT(id) AS member_count FROM  `user` WHERE member_level IN (2,4,5) AND cooperative_business_id=1 AND open_member_time>? AND open_member_time<? ", start, end).Scan(member).Error
		if err != nil {
			fmt.Println("member err:", err)
		}
		list = append(list, member)
	}

	file := excelize.NewFile()
	streamWriter, err := file.NewStreamWriter("Sheet1")
	if err != nil {
		fmt.Println(err)
	}

	fileName := time.Now().Format("2006-01-02 15:04:05") + "迪为会员统计" + ".xlsx"

	title := []interface{}{"时间", "累计会员数"}
	cell, _ := excelize.CoordinatesToCellName(1, 1)
	if err = streamWriter.SetRow(cell, title); err != nil {
		fmt.Println(err)
	}
	var row []interface{}
	for rowId := 0; rowId < len(list); rowId++ {
		row = []interface{}{list[rowId].Date, list[rowId].MemberCount}
		cell, _ := excelize.CoordinatesToCellName(1, rowId+2)
		if err := streamWriter.SetRow(cell, row); err != nil {
			fmt.Println(err)
		}
	}
	if err := streamWriter.Flush(); err != nil {
		fmt.Println(err)
	}
	if err := file.SaveAs("./" + fileName); err != nil {
		fmt.Println(err)
	}

}

func TestGetAccessToken(t *testing.T) {
	InitTestDB()
	DB = DBDev
	GetAccessToken()
}

func TestExportGameList(t *testing.T) {
	InitDBProd()
	var games []GameCard
	_ = NewGameCardQuerySet(DBProd).OrderDescByID().All(&games)

	fileName := "游戏列表"
	fileName = time.Now().Format(TimeFormat) + fileName + ".md"
	// /www/server/images/export
	//f, err := os.OpenFile(fmt.Sprintf("./")+fileName, os.O_CREATE|os.O_TRUNC|os.O_APPEND|os.O_RDWR, 0644)
	f, err := os.OpenFile(fmt.Sprintf("./")+fileName, os.O_CREATE|os.O_TRUNC|os.O_APPEND|os.O_RDWR, 0644)
	if err != nil {
		fmt.Println(err)
	}
	defer f.Close()

	//w := csv.NewWriter(f)
	//os.WriteFile()
	//headline := []string{"商品名称", "卡池总数", "在库数量", "玩家持有数量", "锁定数量", "借出总数", "商品编号", "所在门店", "状态"}
	//if err := w.Write(headline); err != nil {
	//}

	for i, goods := range games {
		//if i > 5 {
		//	break
		//}
		fmt.Println("第", i)
		w := fmt.Sprintf("##### %s \n ", goods.Name) +
			fmt.Sprintf(`<img src="%s" `, goods.CoverImg) + `style="zoom:50%;" />` + "\n" +
			"游戏详情:\n" +
			goods.DetailInfo + "\n\n\n"
		f.WriteString(w)
	}

	if err := f.Close(); err != nil {
		//log.Fatal(err)
		logger.Error(" err:", err)
	}

}