2795 lines
76 KiB
Go
2795 lines
76 KiB
Go
package model
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto"
|
|
cryrand "crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/sha1"
|
|
"crypto/sha512"
|
|
"crypto/x509"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"encoding/pem"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math/rand"
|
|
"mh-server/lib/auth"
|
|
"mh-server/lib/utils"
|
|
"mh-server/lib/wxpay"
|
|
"mh-server/lib/xianmai"
|
|
"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{},
|
|
|
|
&Order{},
|
|
&OrderCard{},
|
|
&UserMemberDurationRecord{},
|
|
&Statistic{},
|
|
&UserActionLog{},
|
|
&UserCoupon{},
|
|
&ShopperPromotionCode{},
|
|
&UserOpenMemberRecord{},
|
|
&UserInvite{},
|
|
&UserInviteRecord{},
|
|
&User{},
|
|
&UserRedeemCode{},
|
|
)
|
|
|
|
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{},
|
|
|
|
//&Order{},
|
|
//&OrderCard{},
|
|
//&UserMemberDurationRecord{},
|
|
//&Statistic{},
|
|
//&UserActionLog{},
|
|
|
|
&ShopperPromotionCode{},
|
|
&UserCoupon{},
|
|
&UserOpenMemberRecord{},
|
|
&UserInvite{},
|
|
&UserInviteRecord{},
|
|
&User{},
|
|
&UserRedeemCode{},
|
|
)
|
|
|
|
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) {
|
|
InitDBProd()
|
|
ids := []uint32{12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26}
|
|
for i, _ := range ids {
|
|
GameCardGoodsStockInspection(ids[i])
|
|
}
|
|
|
|
}
|
|
|
|
func GameCardGoodsStockInspection(id uint32) {
|
|
var gameCardGoodses []GameCardGoods
|
|
err := NewGameCardGoodsQuerySet(DBProd).StoreIdEq(uint64(id)).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 || gameCard.Status == 2 {
|
|
holdMap[uint32(gameCard.GameCardId)] += 1
|
|
}
|
|
}
|
|
var gameCardGoodsStocks []GameCardGoodsStock
|
|
err = NewGameCardGoodsStockQuerySet(DBProd).StoreIdEq(uint64(id)).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}
|
|
uc := &auth.UserClaims{}
|
|
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, 200)
|
|
}
|
|
|
|
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)
|
|
}
|
|
//f.Name()
|
|
//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)
|
|
//}
|
|
|
|
}
|
|
|
|
func TestReader(t *testing.T) {
|
|
buffer := bytes.Buffer{}
|
|
buffer.ReadByte()
|
|
l1 := []uint32{1, 2, 3}
|
|
l2 := make([]uint32, 10)
|
|
l3 := make([]uint32, 1)
|
|
l4 := make([]uint32, 0)
|
|
copy(l2, l1)
|
|
copy(l3, l1)
|
|
copy(l4, l1)
|
|
fmt.Println("l2:", l2)
|
|
fmt.Println("l3:", l3)
|
|
fmt.Println("l4:", l4)
|
|
}
|
|
|
|
func TestRandSecret(t *testing.T) {
|
|
RandSecret("seed")
|
|
}
|
|
|
|
func RandSecret(seed string) {
|
|
key := fmt.Sprintf("%s%d", seed, time.Now().UnixNano())
|
|
hash := sha512.New()
|
|
hash.Write([]byte(key))
|
|
encodeToString := hex.EncodeToString(hash.Sum(nil))
|
|
fmt.Println("encode:", encodeToString[:10])
|
|
|
|
//return strconv.ParseUint(encodeToString[:5], 16, 32)
|
|
}
|
|
|
|
func TestGameCassetteList(t *testing.T) {
|
|
list, count, err := xianmai.GameCassetteList("", 0, 10000)
|
|
if err != nil {
|
|
fmt.Println("err:", err)
|
|
}
|
|
fmt.Println("count:", count)
|
|
|
|
for i, _ := range list {
|
|
fmt.Println("", list[i].GoodsName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestDays(t *testing.T) {
|
|
d1, _ := time.Parse(DateTimeFormat, "2022-12-27")
|
|
d2, _ := time.Parse(DateTimeFormat, "2022-09-28")
|
|
fmt.Println("天数:", (d2.Unix()-d1.Unix())/24/3600)
|
|
}
|
|
|
|
func TestCreateAccessToken(t *testing.T) {
|
|
//token, err := auth.CreateAccessToken(34075903)
|
|
token, err := auth.CreateToken(34075903, "oOqYrhCNQRvVNAaEo4h4osoW", 259200)
|
|
if err != nil {
|
|
fmt.Println("err:", err)
|
|
}
|
|
fmt.Println("token:", token)
|
|
}
|
|
|
|
func TestPushWXPayNotice(t *testing.T) {
|
|
InitDBProd()
|
|
DB = DBProd
|
|
PushWXPayNoticeInfo()
|
|
}
|
|
|
|
func PushWXPayNoticeInfo() {
|
|
fmt.Println("微信推送支付通知")
|
|
//body, err := ioutil.ReadAll(c.Request.Body)
|
|
//if err != nil {
|
|
// logger.Error(err)
|
|
//}
|
|
|
|
//logger.Error("xml Request.Body1:", string(body))
|
|
var notifyInfo wxpay.WechatNotifyInfo
|
|
notifyInfo.OutTradeNo = "82EE941414"
|
|
notifyInfo.Attach = wxpay.WxPayPostagePackage
|
|
//if err := c.ShouldBindXML(¬ify); err != nil {
|
|
// logger.Error(err)
|
|
// RespBodyXML(c, map[string]string{
|
|
// "return_code": "FAIL",
|
|
// })
|
|
// return
|
|
//}
|
|
|
|
//err = xml.Unmarshal(body, ¬ifyInfo)
|
|
//if err != nil {
|
|
// logger.Error(err)
|
|
//}
|
|
//ret := WXPayNoticeResp{
|
|
// ReturnCode: "FAIL",
|
|
//}
|
|
//correctSign, err := PayCallBackHandle(notifyInfo, config.AppConfig.WxMchSecret)
|
|
//if err != nil {
|
|
// logger.Error("PushWXPayNotice sign create fail")
|
|
// return
|
|
//}
|
|
//if notifyInfo.Sign != correctSign {
|
|
// logger.Error("PushWXPayNotice sign verification fail")
|
|
// return
|
|
//}
|
|
fundRecord := new(FundRecord)
|
|
|
|
if notifyInfo.Attach == wxpay.WxPayPostagePackage {
|
|
record := &UserOpenMemberRecord{OpenNo: notifyInfo.OutTradeNo}
|
|
err := record.GetByOpenNo()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
if record.State == 2 {
|
|
//ret.ReturnCode = "SUCCESS"
|
|
logger.Error("State err")
|
|
return
|
|
}
|
|
var activity Activity
|
|
err = NewActivityQuerySet(DB).IDEq(3).One(&activity)
|
|
if err != nil {
|
|
logger.Error("coupon err:", err)
|
|
return
|
|
}
|
|
var coupon Coupon
|
|
err = NewCouponQuerySet(DB).ActivityTypeEq(activity.ActivityType).One(&coupon)
|
|
if err != nil {
|
|
logger.Error("coupon err:", err)
|
|
return
|
|
}
|
|
|
|
defer func() {
|
|
if err := recover(); err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
}()
|
|
|
|
//days := (info.PostagePackageFee * 365) / originalMemberConfig.MemberFee
|
|
user := GetUserByUid(record.Uid)
|
|
days := GetPostagePackageMemberDuration(user.MemberLevel)
|
|
durationRecord := &UserMemberDurationRecord{
|
|
Uid: record.Uid,
|
|
Duration: days,
|
|
EventType: 1,
|
|
MemberLevel: record.MemberLevel,
|
|
}
|
|
nowTime := time.Now()
|
|
|
|
//go func() {
|
|
begin := DB.Begin()
|
|
for i := 0; i < 10; i++ {
|
|
userCoupon := &UserCoupon{
|
|
Uid: record.Uid,
|
|
CouponId: coupon.ID,
|
|
CouponType: coupon.CouponType,
|
|
ActivityType: activity.ActivityType,
|
|
ActivityId: activity.ID,
|
|
Value: coupon.Value,
|
|
State: 1,
|
|
ActiveStart: nowTime,
|
|
ActiveEnd: nowTime.AddDate(10, 0, 0),
|
|
MemberLevel: record.MemberLevel,
|
|
}
|
|
err = begin.Create(userCoupon).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("user coupon err:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
memberExpire := user.MemberExpire.AddDate(0, 0, int(days))
|
|
err = NewUserQuerySet(begin).UidEq(record.Uid).GetUpdater().SetMemberExpire(memberExpire).Update()
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("update member expire err:", err)
|
|
return
|
|
}
|
|
|
|
err = begin.Create(durationRecord).Error
|
|
if err != nil {
|
|
logger.Error("create duration record err:", err)
|
|
return
|
|
}
|
|
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("commit err:", err)
|
|
return
|
|
}
|
|
//}()
|
|
|
|
fundRecord.Uid = uint32(record.Uid)
|
|
fundRecord.FundType = FundTypePostagePackageFee
|
|
fundRecord.Remark = "购买运费包"
|
|
}
|
|
|
|
fundRecord.Amount = int64(notifyInfo.TotalFee)
|
|
fundRecord.TransactionId = notifyInfo.TransactionId
|
|
fundRecord.OutTradeNo = notifyInfo.OutTradeNo
|
|
fundRecord.Status = 2
|
|
err := DB.Create(&fundRecord).Error
|
|
if err != nil {
|
|
logger.Error("create fund record err:", err)
|
|
}
|
|
logger.Debug("微信推动支付通知")
|
|
|
|
}
|
|
|
|
func TestUserRedeemCodeConvert(t *testing.T) {
|
|
|
|
UserRedeemCodeConvert(45168343, "MC302F140B2D675674C1F6C")
|
|
}
|
|
|
|
func TestNameScanInvite(t *testing.T) {
|
|
InitTestDB()
|
|
DB = DBDev
|
|
|
|
InviteUid := uint32(63192613)
|
|
Uid := uint32(45321263)
|
|
|
|
inviteUser := GetUserByUid(InviteUid)
|
|
user := GetUserByUid(Uid)
|
|
|
|
nowTime := time.Now()
|
|
if Uid != 0 {
|
|
exist, err := QueryRecordExist(
|
|
fmt.Sprintf("SELECT * FROM user_invite_record WHERE to_uid = %d AND from_uid = %d ",
|
|
Uid, InviteUid))
|
|
if err != nil {
|
|
logger.Error("query err:", err)
|
|
return
|
|
}
|
|
if !exist {
|
|
firstInviteRecord := &UserInviteRecord{
|
|
ToUid: Uid,
|
|
FromUid: InviteUid,
|
|
Action: 2,
|
|
SpendType: 1,
|
|
MemberLevel: 0,
|
|
First: 1,
|
|
Scan: 1,
|
|
ActionTime: nowTime,
|
|
}
|
|
err = DB.Create(firstInviteRecord).Error
|
|
if err != nil {
|
|
logger.Error("create user invite record err:", err)
|
|
}
|
|
}
|
|
|
|
inviteRecord := &UserInviteRecord{
|
|
ToUid: Uid,
|
|
FromUid: InviteUid,
|
|
Action: 1,
|
|
SpendType: 1,
|
|
MemberLevel: 0,
|
|
First: 0,
|
|
Scan: 1,
|
|
ActionTime: nowTime,
|
|
}
|
|
err = DB.Create(inviteRecord).Error
|
|
if err != nil {
|
|
logger.Error("create user invite record err:", err)
|
|
}
|
|
|
|
var inviteNew UserInvite
|
|
inviteErr := NewUserInviteQuerySet(DB).ToUidEq(Uid).FromUidEq(InviteUid).ActionEq(1).
|
|
SpendTypeEq(1).One(&inviteNew)
|
|
if inviteErr != nil && inviteErr != RecordNotFound {
|
|
logger.Error("user invite err:", err)
|
|
}
|
|
fmt.Println("inviteErr:", inviteErr)
|
|
fmt.Printf("inviteNew:%#v \n", inviteNew)
|
|
if inviteErr == RecordNotFound {
|
|
memberLevel := user.MemberLevel
|
|
if memberLevel == 0 {
|
|
memberLevel = MemberLevelUser
|
|
}
|
|
invite := &UserInvite{
|
|
FromUid: InviteUid,
|
|
UserType: inviteUser.UserType,
|
|
StoreId: inviteUser.StoreId,
|
|
MemberOpenTime: time.Now(),
|
|
MemberType: memberLevel,
|
|
MemberStatus: 1,
|
|
ToUid: user.Uid,
|
|
Action: 1,
|
|
SpendType: 1,
|
|
UserInviteRecordId: inviteRecord.ID,
|
|
FirstInvite: 0, // TODO
|
|
Scan: 1,
|
|
}
|
|
fmt.Println("创建邀请:", invite)
|
|
//count, err := model.NewUserInviteQuerySet(model.DB).FromUidEq(req.InviteUid).ToUidEq(user.Uid).Count()
|
|
//if err != nil {
|
|
// logger.Error(err)
|
|
// RespJson(c, status.InternalServerError, nil)
|
|
// return
|
|
//}
|
|
//if count == 0 {
|
|
//}
|
|
if err := invite.Create(DB); err != nil {
|
|
logger.Error(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
if inviteErr == nil {
|
|
//err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().
|
|
// SetFromUid(req.InviteUid).SetStoreId(inviteUser.StoreId).SetUserInviteRecordId(inviteRecord.ID).Update()
|
|
err = NewUserInviteQuerySet(DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(nowTime).
|
|
SetUserInviteRecordId(inviteRecord.ID).Update()
|
|
if err != nil {
|
|
logger.Error("from uid update user invite err:", err, InviteUid)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 模拟扫码邀请用户
|
|
func TestNewUser(t *testing.T) {
|
|
InitTestDB()
|
|
DB = DBDev
|
|
|
|
InviteUid := uint32(45401895)
|
|
Uid := uint32(38986764)
|
|
|
|
user := GetUserByUid(Uid)
|
|
nowTime := time.Now()
|
|
|
|
if InviteUid != 0 {
|
|
inviteRecordFirst := &UserInviteRecord{
|
|
ToUid: Uid,
|
|
FromUid: InviteUid,
|
|
Action: 2,
|
|
SpendType: 1,
|
|
MemberLevel: 0,
|
|
First: 1,
|
|
Scan: 1,
|
|
ActionTime: nowTime,
|
|
}
|
|
err := DB.Create(inviteRecordFirst).Error
|
|
if err != nil {
|
|
logger.Error("create user invite record err:", err)
|
|
}
|
|
|
|
inviteRecord := &UserInviteRecord{
|
|
ToUid: Uid,
|
|
FromUid: InviteUid,
|
|
Action: 1,
|
|
SpendType: 1,
|
|
MemberLevel: 0,
|
|
First: 0,
|
|
Scan: 1,
|
|
ActionTime: nowTime,
|
|
}
|
|
err = DB.Create(inviteRecord).Error
|
|
if err != nil {
|
|
logger.Error("create user invite record err:", err)
|
|
}
|
|
|
|
inviteUser := GetUserByUid(InviteUid)
|
|
user.StoreId = inviteUser.StoreId
|
|
user.UserType = UserTypeConsumer
|
|
user.CooperativeBusinessId = inviteUser.CooperativeBusinessId
|
|
user.CooperativeName = inviteUser.CooperativeName
|
|
|
|
invite := &UserInvite{
|
|
FromUid: InviteUid,
|
|
UserType: inviteUser.UserType,
|
|
StoreId: inviteUser.StoreId,
|
|
MemberType: MemberLevelUser,
|
|
ToUid: user.Uid,
|
|
MemberStatus: 1,
|
|
Action: 1,
|
|
SpendType: 1,
|
|
UserInviteRecordId: inviteRecord.ID,
|
|
Scan: 1,
|
|
}
|
|
|
|
if err := invite.Create(DB); err != nil {
|
|
logger.Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPasKey(t *testing.T) {
|
|
d := `{"hm":10}`
|
|
|
|
p := "/Users/li/mh/mh_server/pack/configs/hm_pay/private_key.pem"
|
|
readFile, err := ioutil.ReadFile(p)
|
|
if err != nil {
|
|
logger.Error("read file err:", err)
|
|
}
|
|
block, _ := pem.Decode(readFile)
|
|
priKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
|
|
if err != nil || priKey == nil {
|
|
logger.Error("parse private err:", err)
|
|
}
|
|
//x509.SHA256WithRSA
|
|
h := sha1.New()
|
|
h.Write([]byte(d))
|
|
sum := h.Sum(nil)
|
|
signPKCS1v15, err := rsa.SignPKCS1v15(cryrand.Reader, priKey.(*rsa.PrivateKey), crypto.SHA1, sum[:])
|
|
if err != nil {
|
|
logger.Error("sign err:", err)
|
|
}
|
|
encodeToString := base64.StdEncoding.EncodeToString(signPKCS1v15)
|
|
|
|
fmt.Println("key:", encodeToString)
|
|
}
|
|
|
|
func TestSha1withRsa(t *testing.T) {
|
|
d := `{"hm":10}`
|
|
|
|
withRsa, err := wxpay.Sha1withRsa(d)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
|
|
fmt.Println("sign:", withRsa)
|
|
|
|
err = wxpay.VerifySha1Rsa(d, withRsa)
|
|
if err != nil {
|
|
logger.Error("verify rsa err:", err)
|
|
}
|
|
|
|
}
|
|
|
|
func TestHmJsPayUnifiedOrder(t *testing.T) {
|
|
order, err := wxpay.HmJsPayUnifiedOrder("84FDC15BCC", 2, "ohuHh4riVVPxwKHrYHsWwZRpxVMk", "https://dev.switch.deovo.com:8004/api/v1/wxpay/notice")
|
|
if err != nil {
|
|
fmt.Println("err:", err)
|
|
}
|
|
|
|
fmt.Println("order:", order)
|
|
}
|
|
|
|
func TestHmRefundTransaction(t *testing.T) {
|
|
refund := wxpay.OrderRefund{
|
|
OutTradeNo: "84FDC15BCE",
|
|
OutRefundNo: "861C878AB8",
|
|
NotifyUrl: "",
|
|
Amount: wxpay.OrderRefundAmount{
|
|
Refund: 15,
|
|
Total: 15,
|
|
Currency: "",
|
|
},
|
|
}
|
|
wxpay.HmRefundTransaction(refund)
|
|
}
|
|
|
|
func TestUnicode(t *testing.T) {
|
|
str := `{"msg":"\u8be5\u5355\u53f7\u6682\u65e0\u7269\u6d41\u8fdb\u5c55\uff0c\u8bf7\u7a0d\u540e\u518d\u8bd5\uff0c\u6216\u68c0\u67e5\u516c\u53f8\u548c\u5355\u53f7\u662f\u5426\u6709\u8bef\u3002","status":"-3","error_code":"13","data":{"info":{"status":"0","msg":"\u8be5\u5355\u53f7\u6682\u65e0\u7269\u6d41\u8fdb\u5c55\uff0c\u8bf7\u7a0d\u540e\u518d\u8bd5\uff0c\u6216\u68c0\u67e5\u516c\u53f8\u548c\u5355\u53f7\u662f\u5426\u6709\u8bef\u3002","_source_com":""},"com":"zhongtong","company":{"url":"http:\/\/www.zto.com\/?from=openv","fullname":"\u4e2d\u901a\u5feb\u9012","shortname":"\u4e2d\u901a","icon":{"id":"29","smallurl":"https:\/\/ss0.baidu.com\/6ONWsjip0QIZ8tyhnq\/it\/u=3682653099,2524883494&fm=58","smallpos":"0,496","middleurl":"https:\/\/ss2.baidu.com\/6ONYsjip0QIZ8tyhnq\/it\/u=1078213688,3146076104&fm=58","middlepos":"0,324","normal":"https:\/\/ss0.baidu.com\/6ONWsjip0QIZ8tyhnq\/it\/u=1022514261,1855787563&fm=58"},"website":{"title":"www.zto.com","url":"http:\/\/www.zto.com"},"tel":"95311","auxiliary":[{"title":"\u7f51\u70b9\u67e5\u8be2","url":"http:\/\/www.zto.com\/GuestService\/SiteQuery"},{"title":"\u7f51\u4e0a\u5bc4\u4ef6","url":"http:\/\/my.zto.com\/order"},{"title":"\u4ef7\u683c\u67e5\u8be2","url":"http:\/\/www.zto.com\/GuestService\/PriceQuery"},{"title":"\u4e2d\u901a\u4f18\u9009","url":"http:\/\/www.ztbest.com"}]},"source":{"logo":"https:\/\/ss2.baidu.com\/6ONYsjip0QIZ8tyhnq\/it\/u=1429564979,1787167512&fm=58","title":"\u6570\u636e\u6765\u81ea\u5feb\u9012100","url":"http:\/\/www.kuaidi100.com\/?from=baidu_ala","name":"\u5feb\u9012100","showName":"\u5feb\u9012100"}}}`
|
|
data := make(map[string]interface{})
|
|
json.Unmarshal([]byte(str), &data)
|
|
newStr, err := json.Marshal(data)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
fmt.Println("===", string(newStr))
|
|
|
|
}
|
|
|
|
func packageAndDefer() int {
|
|
val := 10
|
|
defer func() {
|
|
val += 1
|
|
fmt.Println("11", val)
|
|
}()
|
|
return val
|
|
}
|
|
|
|
func TestModel(t *testing.T) {
|
|
fmt.Println(packageAndDefer())
|
|
m := make(map[uint32]string, 0)
|
|
fmt.Println(m)
|
|
|
|
//// A header for a Go map.
|
|
//type hmap struct {
|
|
// // Note: the format of the hmap is also encoded in cmd/compile/internal/reflectdata/reflect.go.
|
|
// // Make sure this stays in sync with the compiler's definition.
|
|
// count int // # live cells == size of map. Must be first (used by len() builtin)
|
|
// flags uint8
|
|
// B uint8 // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
|
|
// noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
|
|
// hash0 uint32 // hash seed
|
|
// buckets unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
|
|
// oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
|
|
// nevacuate uintptr // progress counter for evacuation (buckets less than this have been evacuated)
|
|
// extra *mapextra // optional fields
|
|
//}
|
|
}
|
|
|
|
type UserPromotion struct {
|
|
Automatic uint32 `json:"automatic"`
|
|
Promotion uint32 `json:"promotion"`
|
|
Shopper uint32 `json:"shopper"`
|
|
Date string `json:"date"`
|
|
}
|
|
|
|
// 店员推广续费会员
|
|
func TestUserAddress_Create(t *testing.T) {
|
|
InitTestDB()
|
|
InitDBProd()
|
|
DB = DBDev
|
|
contentTime, err := time.Parse(DateTimeFormat, "2023-02-01")
|
|
if err != nil {
|
|
logger.Error("err=?", err)
|
|
}
|
|
list := make([]UserPromotion, 0)
|
|
for i := 0; i < 6; i++ {
|
|
startTime := contentTime.AddDate(0, i*(-1), 0)
|
|
endTime := startTime.AddDate(0, -1, 0)
|
|
|
|
shopper, _ := NewUserInviteQuerySet(DB).CreatedAtLte(startTime).CreatedAtGte(endTime).SpendTypeEq(3).InviteFormEq(1).Count()
|
|
var userInvites []UserInvite
|
|
_ = NewUserInviteQuerySet(DB).CreatedAtLte(startTime).CreatedAtGte(endTime).SpendTypeEq(3).All(&userInvites)
|
|
|
|
promotion := &UserPromotion{
|
|
Automatic: 0,
|
|
Promotion: 0,
|
|
Shopper: uint32(shopper),
|
|
Date: endTime.Format("2006-01"),
|
|
}
|
|
|
|
for _, invite := range userInvites {
|
|
if invite.InviteForm == 1 {
|
|
continue
|
|
}
|
|
var fund FundRecord
|
|
err := NewFundRecordQuerySet(DBProd).UidEq(invite.ToUid).FundTypeEq("member_fee").OrderDescByID().Limit(1).One(&fund)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
if fund.Amount == 34900 || fund.Amount == 59900 || fund.Amount == 200 {
|
|
promotion.Promotion += 1
|
|
} else {
|
|
promotion.Automatic += 1
|
|
}
|
|
}
|
|
list = append(list, *promotion)
|
|
//fmt.Println("", promotion.Date, ",", promotion.Promotion, ",", promotion.Automatic, ",", promotion.Shopper)
|
|
}
|
|
|
|
file := excelize.NewFile()
|
|
streamWriter, err := file.NewStreamWriter("Sheet1")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
fileName := time.Now().Format(TimeFormat) + "店员推广续费会员数据" + ".xlsx"
|
|
style1 := &excelize.Style{
|
|
Border: []excelize.Border{{
|
|
Type: "left",
|
|
Color: "#000000",
|
|
Style: 1,
|
|
}},
|
|
Fill: excelize.Fill{
|
|
Type: "pattern",
|
|
Pattern: 1,
|
|
Color: []string{"#000000"},
|
|
},
|
|
}
|
|
styleId, err := file.NewStyle(style1)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
styleId, _ = file.NewStyle(`{"fill":{"type":"pattern","color":["#E0EBF5"],"pattern":1}}`)
|
|
title := []interface{}{"日期", "线上领券续费", "原价续费", "店员推广续费"}
|
|
cell, _ := excelize.CoordinatesToCellName(1, 1)
|
|
if err = streamWriter.SetRow(cell, title); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
fmt.Println("style:", styleId)
|
|
|
|
var row []interface{}
|
|
for rowId := 0; rowId < len(list); rowId++ {
|
|
row = []interface{}{list[rowId].Date, list[rowId].Promotion, list[rowId].Automatic, list[rowId].Shopper}
|
|
cell, _ := excelize.CoordinatesToCellName(1, rowId+2)
|
|
fmt.Println("cell", cell)
|
|
//name, err := excelize.CoordinatesToCellName(1, rowId+2)
|
|
//if err != nil {
|
|
// logger.Error("err:", err)
|
|
//}
|
|
//fmt.Println("ColumnNumberToName-----:", name)
|
|
|
|
if err := streamWriter.SetRow(cell, row); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = file.SetCellStyle("Sheet1", cell, cell, styleId)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
}
|
|
if err := streamWriter.Flush(); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fmt.Println("fileName", fileName)
|
|
//if err := file.SaveAs("/www/server/images/export/" + fileName); err != nil {
|
|
if err := file.SaveAs("./" + fileName); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
}
|
|
|
|
func TestGoodsStockFile(t *testing.T) {
|
|
file := excelize.NewFile()
|
|
//streamWriter, err := file.NewStreamWriter("Sheet1")
|
|
//if err != nil {
|
|
// fmt.Println(err)
|
|
//}
|
|
fileName := time.Now().Format(TimeFormat) + "店员推广续费会员数据" + ".xlsx"
|
|
styleBorder := &excelize.Style{
|
|
Border: []excelize.Border{{
|
|
Type: "left",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}, {
|
|
Type: "top",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}, {
|
|
Type: "right",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}, {
|
|
Type: "bottom",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}},
|
|
}
|
|
styleFill := &excelize.Style{
|
|
Border: []excelize.Border{{
|
|
Type: "left",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}, {
|
|
Type: "top",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}, {
|
|
Type: "right",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}, {
|
|
Type: "bottom",
|
|
Color: "000000",
|
|
Style: 1,
|
|
}},
|
|
Fill: excelize.Fill{
|
|
Type: "pattern",
|
|
Pattern: 1,
|
|
Color: []string{"E0EBF5"},
|
|
},
|
|
}
|
|
styleBorderId, err := file.NewStyle(styleBorder)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
styleFillId, err := file.NewStyle(styleFill)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
title := []interface{}{"日期", "线上领券续费", "原价续费", "店员推广续费"}
|
|
|
|
//if err = streamWriter.SetRow(cell, title); err != nil {
|
|
// fmt.Println(err)
|
|
//}
|
|
for i, _ := range title {
|
|
cell, _ := excelize.CoordinatesToCellName(1+i, 1)
|
|
err = file.SetCellValue("Sheet1", cell, title[i])
|
|
err = file.SetCellStyle("Sheet1", cell, cell, styleFillId)
|
|
//err = file.SetCellStyle("Sheet1", cell, cell, styleBorderId)
|
|
|
|
}
|
|
|
|
fmt.Println("style:", styleBorderId)
|
|
fmt.Println("style:", styleFillId)
|
|
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
fmt.Println("fileName", fileName)
|
|
if err := file.SaveAs("./" + fileName); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
}
|
|
|
|
// 拉新数据
|
|
func TestOrderCardUserRentCard(t *testing.T) {
|
|
InitDBProd()
|
|
DB = DBProd
|
|
var cards []OrderCard
|
|
err := DBProd.Raw("SELECT * FROM order_card WHERE uid IN (41062552,61322858,79502493,5151314,75683046,92301496,84098843) AND card_status IN (2,3,4);").Scan(&cards).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
accountUids := []uint32{41062552, 61322858, 79502493, 5151314, 75683046, 92301496, 84098843}
|
|
userOrderMap := make(map[uint32]OrderCard, 0)
|
|
//storeMap := make(map[uint32]Store, 0)
|
|
storeIds := make([]uint32, 0, len(cards))
|
|
gameIds := make([]uint32, 0, len(cards))
|
|
userIds := make([]uint32, 0, len(cards))
|
|
|
|
for i, _ := range cards {
|
|
if cards[i].CardStatus == 4 {
|
|
var userOrder OrderCard
|
|
//err = NewOrderCardQuerySet(DBProd.Debug()).SerialNumberEq(cards[i].SerialNumber).CreatedAtGt(cards[i].RevertTime).OrderAscByID().Limit(1).One(&userOrder)
|
|
err = NewOrderCardQuerySet(DBProd.Debug()).SerialNumberEq(cards[i].SerialNumber).CreatedAtGt(cards[i].DeliveryTime).OrderAscByID().Limit(1).One(&userOrder)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
userOrderMap[cards[i].ID] = userOrder
|
|
userIds = append(userIds, userOrder.Uid)
|
|
if cards[i].ID == 16395 {
|
|
fmt.Println("userOrder", userOrder)
|
|
}
|
|
}
|
|
|
|
//storeIds = append(storeIds, cards[i].StoreId)
|
|
gameIds = append(gameIds, cards[i].GameCardId)
|
|
}
|
|
accountUserMap, _ := GetUserMap(accountUids)
|
|
for _, user := range accountUserMap {
|
|
storeIds = append(storeIds, uint32(user.StoreId))
|
|
}
|
|
|
|
storeMap, err := GetStoreMap(storeIds)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
gameMap := GetGameCardMap(gameIds)
|
|
userMap, _ := GetUserMap(userIds)
|
|
|
|
file := excelize.NewFile()
|
|
streamWriter, err := file.NewStreamWriter("Sheet1")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fileName := time.Now().Format(TimeFormat) + "锁卡订单数据" + ".xlsx"
|
|
|
|
title := []interface{}{"订单id", "账号uid", "门店id", "门店名称", "游戏id", "游戏名称", "游戏卡编码", "锁卡时间", "订单状态", "还卡时间", "借卡用户uid", "开通会员时间", "是否拉新"}
|
|
cell, _ := excelize.CoordinatesToCellName(1, 1)
|
|
if err = streamWriter.SetRow(cell, title); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
list := cards
|
|
var row []interface{}
|
|
for rowId := 0; rowId < len(list); rowId++ {
|
|
accountUser, _ := accountUserMap[list[rowId].Uid]
|
|
store, _ := storeMap[uint32(accountUser.StoreId)]
|
|
gameCard := gameMap[list[rowId].GameCardId]
|
|
userOrder, _ := userOrderMap[list[rowId].ID]
|
|
userInfo := userMap[userOrder.Uid]
|
|
if userInfo == nil {
|
|
userInfo = &User{}
|
|
}
|
|
if userInfo == nil {
|
|
fmt.Println("---------------userInfo")
|
|
}
|
|
|
|
row = []interface{}{list[rowId].ID, list[rowId].Uid, store.ID, store.Name, list[rowId].GameCardId, gameCard.Name, list[rowId].SerialNumber,
|
|
list[rowId].CreatedAt.Format(TimeFormat), GetOrderStatus(list[rowId].CardStatus), list[rowId].DeliveryTime.Format(TimeFormat),
|
|
userOrder.Uid, GetUserOpenMemberTime(userInfo.OpenMemberTime), IsPullingNew(userInfo.OpenMemberTime, list[rowId].DeliveryTime),
|
|
}
|
|
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("/www/server/images/export/" + fileName); err != nil {
|
|
if err := file.SaveAs("./" + fileName); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func GetGameCardMap(ids []uint32) map[uint32]GameCard {
|
|
gameMap := make(map[uint32]GameCard, 0)
|
|
if len(ids) == 0 {
|
|
return gameMap
|
|
}
|
|
var games []GameCard
|
|
err := NewGameCardQuerySet(DBProd).IDIn(ids...).All(&games)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
for i, _ := range games {
|
|
gameMap[games[i].ID] = games[i]
|
|
}
|
|
return gameMap
|
|
}
|
|
|
|
func GetOrderStatus(status uint32) string {
|
|
switch status {
|
|
case 2:
|
|
return "游玩中"
|
|
case 3:
|
|
return "归还中"
|
|
case 4:
|
|
return "已完成"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func IsPullingNew(open, revert time.Time) string {
|
|
if open.AddDate(0, 1, 0).After(revert) {
|
|
return "是"
|
|
} else {
|
|
return "否"
|
|
}
|
|
}
|
|
|
|
func GetUserOpenMemberTime(open time.Time) string {
|
|
if open.IsZero() {
|
|
return ""
|
|
} else {
|
|
return open.Format(TimeFormat)
|
|
}
|
|
}
|
|
|
|
type OpenMember struct {
|
|
Last int `json:"last"`
|
|
Now int `json:"now"`
|
|
Date string `json:"date"`
|
|
}
|
|
|
|
func TestUserMember(t *testing.T) {
|
|
//InitTestDB()
|
|
InitDBProd()
|
|
DB = DBProd
|
|
contentTime, err := time.Parse(DateTimeFormat, "2023-02-01")
|
|
if err != nil {
|
|
logger.Error("err=?", err)
|
|
}
|
|
list := make([]OpenMember, 0)
|
|
for i := 0; i < 6; i++ {
|
|
startTime := contentTime.AddDate(0, i*(-1), 0)
|
|
endTime := startTime.AddDate(0, -1, 0)
|
|
|
|
countNow, _ := NewUserQuerySet(DBProd).OpenMemberTimeGte(endTime).OpenMemberTimeLte(startTime).MemberLevelIn(2, 4, 5).Count()
|
|
|
|
countLast, _ := NewUserQuerySet(DBProd).OpenMemberTimeGte(endTime.AddDate(-1, 0, 0)).
|
|
OpenMemberTimeLte(startTime.AddDate(-1, 0, 0)).MemberLevelIn(2, 4, 5).Count()
|
|
list = append(list, OpenMember{
|
|
Last: countLast,
|
|
Now: countNow,
|
|
Date: endTime.Format("2006-01"),
|
|
})
|
|
}
|
|
|
|
file := excelize.NewFile()
|
|
streamWriter, err := file.NewStreamWriter("Sheet1")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fileName := time.Now().Format(TimeFormat) + "去年同期会员" + ".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{}{GetMonth(list[rowId].Date), list[rowId].Last, list[rowId].Now}
|
|
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("/www/server/images/export/" + fileName); err != nil {
|
|
if err := file.SaveAs("./" + fileName); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
}
|
|
|
|
func GetMonth(date string) string {
|
|
return date[len(date)-2:] + "月份"
|
|
}
|
|
|
|
// 拉新锁卡数据5
|
|
func TestLachineCardInfo(t *testing.T) {
|
|
InitDBProd()
|
|
DB = DBProd
|
|
LachineCardInfo()
|
|
}
|
|
|
|
// 拉新锁卡数据
|
|
func LachineCardInfo() {
|
|
DB = DBProd
|
|
var cards []OrderCard
|
|
err := DBProd.Raw("SELECT * FROM order_card WHERE uid IN (41062552,61322858,79502493,5151314,75683046,92301496,84098843) AND card_status IN (1,2,3);").Scan(&cards).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
storeIds := make([]uint32, 0, len(cards))
|
|
gameIds := make([]uint32, 0, len(cards))
|
|
accountUids := []uint32{41062552, 61322858, 79502493, 5151314, 75683046, 92301496, 84098843}
|
|
accountUserMap, _ := GetUserMap(accountUids)
|
|
for _, user := range accountUserMap {
|
|
storeIds = append(storeIds, uint32(user.StoreId))
|
|
}
|
|
for i, _ := range cards {
|
|
//storeIds = append(storeIds, cards[i].StoreId)
|
|
gameIds = append(gameIds, cards[i].GameCardId)
|
|
}
|
|
storeMap, err := GetStoreMap(storeIds)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
gameMap := GetGameCardMap(gameIds)
|
|
file := excelize.NewFile()
|
|
streamWriter, err := file.NewStreamWriter("Sheet1")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fileName := time.Now().Format(TimeFormat) + "锁卡数据" + ".xlsx"
|
|
|
|
title := []interface{}{"订单id", "账号uid", "门店id", "门店名称", "游戏id", "游戏名称", "游戏卡编码", "锁卡时间", "订单状态"}
|
|
cell, _ := excelize.CoordinatesToCellName(1, 1)
|
|
if err = streamWriter.SetRow(cell, title); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
list := cards
|
|
var row []interface{}
|
|
for rowId := 0; rowId < len(list); rowId++ {
|
|
accountUser, _ := accountUserMap[list[rowId].Uid]
|
|
store, _ := storeMap[uint32(accountUser.StoreId)]
|
|
//store, _ := storeMap[list[rowId].StoreId]
|
|
gameCard := gameMap[list[rowId].GameCardId]
|
|
|
|
row = []interface{}{list[rowId].ID, list[rowId].Uid, store.ID, store.Name, list[rowId].GameCardId, gameCard.Name, list[rowId].SerialNumber,
|
|
list[rowId].CreatedAt.Format(TimeFormat), GetOrderStatus(list[rowId].CardStatus),
|
|
}
|
|
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("/www/server/images/export/" + fileName); err != nil {
|
|
if err := file.SaveAs("./" + fileName); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func TestNameSunHash(t *testing.T) {
|
|
|
|
}
|
|
|
|
func UserCardStock() {
|
|
// 1.
|
|
|
|
}
|
|
|
|
// 拉新锁卡数据5
|
|
func TestUserMemberInfo(t *testing.T) {
|
|
InitDBProd()
|
|
DB = DBProd
|
|
LachineCardInfo()
|
|
}
|
|
|
|
func TestUserMemberGenreInfo(t *testing.T) {
|
|
InitDBProd()
|
|
DB = DBProd
|
|
UserMemberGenreInfo()
|
|
}
|
|
|
|
// 短期会员数据
|
|
func UserMemberGenreInfo() {
|
|
DB = DBProd
|
|
var cards []User
|
|
err := DBProd.Raw("SELECT id,uid,wx_name,member_genre,store_id,member_expire FROM user WHERE member_level =2 AND member_genre !=0;").Scan(&cards).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
//storeIds := make([]uint32, 0, len(cards))
|
|
//gameIds := make([]uint32, 0, len(cards))
|
|
//accountUids := []uint32{41062552, 61322858, 79502493, 5151314, 75683046, 92301496, 84098843}
|
|
//accountUserMap, _ := GetUserMap(accountUids)
|
|
//for _, user := range accountUserMap {
|
|
// storeIds = append(storeIds, uint32(user.StoreId))
|
|
//}
|
|
//for i, _ := range cards {
|
|
// //storeIds = append(storeIds, cards[i].StoreId)
|
|
// gameIds = append(gameIds, cards[i].GameCardId)
|
|
//}
|
|
//storeMap, err := GetStoreMap(storeIds)
|
|
//if err != nil {
|
|
// logger.Error("err:", err)
|
|
//}
|
|
//gameMap := GetGameCardMap(gameIds)
|
|
file := excelize.NewFile()
|
|
streamWriter, err := file.NewStreamWriter("Sheet1")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fileName := time.Now().Format(TimeFormat) + "短期会员" + ".xlsx"
|
|
|
|
title := []interface{}{"用户uid", "昵称", "开通时间", "到期时间", "会员类型"}
|
|
cell, _ := excelize.CoordinatesToCellName(1, 1)
|
|
if err = streamWriter.SetRow(cell, title); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
list := cards
|
|
var row []interface{}
|
|
for rowId := 0; rowId < len(list); rowId++ {
|
|
//accountUser, _ := accountUserMap[list[rowId].Uid]
|
|
//store, _ := storeMap[uint32(accountUser.StoreId)]
|
|
//store, _ := storeMap[uint32(list[rowId].StoreId)]
|
|
//gameCard := gameMap[list[rowId].GameCardId]
|
|
memberType := "90天"
|
|
memberLength := 90
|
|
if list[rowId].MemberGenre == 202 {
|
|
memberType = "180天"
|
|
memberLength = 180
|
|
}
|
|
open := list[rowId].MemberExpire.AddDate(0, 0, (-1)*memberLength)
|
|
|
|
row = []interface{}{list[rowId].Uid, list[rowId].WxName, open, list[rowId].MemberExpire,
|
|
memberType,
|
|
}
|
|
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("/www/server/images/export/" + fileName); err != nil {
|
|
if err := file.SaveAs("./" + fileName); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func TestEvaluation(t *testing.T) {
|
|
cassetteList, i, err := xianmai.GameCassetteList("", 1, 20)
|
|
if err != nil {
|
|
fmt.Println("err:", err)
|
|
}
|
|
|
|
fmt.Println("cassetteList:", cassetteList)
|
|
fmt.Println("i:", i)
|
|
}
|
|
|
|
func TestGameCardStockCreat(t *testing.T) {
|
|
GameCardStockCreat()
|
|
}
|
|
|
|
func GameCardStockCreat() {
|
|
InitDBProd()
|
|
gameCardId := 800
|
|
storeIds := []uint64{13, 17, 19, 21, 23, 26}
|
|
for i, _ := range storeIds {
|
|
goodsStock := &GameCardGoodsStock{
|
|
StoreId: storeIds[i],
|
|
GameCardId: uint64(gameCardId),
|
|
StoreStock: 0,
|
|
RentStock: 0,
|
|
UserHoldStock: 0,
|
|
OrderCount: 0,
|
|
TotalStock: 0,
|
|
CooperativeBusinessId: 1,
|
|
CooperativeName: "迪为合作商",
|
|
}
|
|
|
|
err := DBProd.Create(goodsStock).Error
|
|
if err != nil {
|
|
fmt.Println("err:", err)
|
|
}
|
|
}
|
|
}
|