fix:多级会员

controller/game_card.go

@@ -252,7 +252,7 @@ func PushWXPayNotice(c *gin.Context) {
 	if notify.Attach == wxpay.WxPayRentCard {
 		logger.Info("租借游戏卡 支付成功:")
 		var order model.Order
-		err := model.NewOrderQuerySet(model.DB).OrderSnEq(notify.OutTradeNo).PayStatusEq(PayStatusUnPay).One(&order)
+		err := model.NewOrderQuerySet(model.DB).OrderSnEq(notify.OutTradeNo).PayStatusEq(PayStatusUnPay).CardStatusNe(OrderCardStatusCancel).One(&order)
 		if err != nil {
 			logger.Error("err:", err)
 			return
@@ -331,7 +331,7 @@ func PushWXPayNotice(c *gin.Context) {
 			logger.Error("err:", err)
 			return
 		}
-
+		go model.ShoppingCartCreateOrderByOrder(order)
 		//count, err := model.NewOrderQuerySet(model.DB).UidEq(order.Uid).IDEq(order.ID).Count()
 		//if err != nil {
 		//	logger.Error("err:", err)
@@ -443,6 +443,8 @@ func PushWXPayNotice(c *gin.Context) {
 				}
 			}
 
+			model.CreateUserRentCardByMemberLevel(record.Uid,record.MemberLevel,memberConfig.CardMax)
+
 		}
 
 		fmt.Println("notify.TotalFee:", notify.TotalFee)
@@ -522,6 +524,7 @@ func PushWXPayNotice(c *gin.Context) {
 			return
 		}
 
+		model.CreateUserRentCardByMemberLevel(record.Uid,record.MemberLevel,memberConfig.CardMax)
 	}
 
 	logger.Debug("微信推动支付通知")

controller/order.go

@@ -381,6 +381,8 @@ func RentCardOrderCreate(c *gin.Context) {
 			"web_pay":  "",
 			"order_id": order.ID,
 		}
+
+		go model.ShoppingCartCreateOrder(uc.Uid, req.GameCardList)
 		RespOK(c, ret)
 		return
 	}

controller/store.go

@@ -10,7 +10,8 @@ import (
 
 func StoreList(c *gin.Context) {
 	req := struct {
-		GameCardId uint64 `json:"game_card_id"`
+		//GameCardId uint64 `json:"game_card_id"`
+		GameCardList  []model.CardInfo `json:"game_card_list"`
 	}{}
 	if err := c.ShouldBindJSON(&req); err != nil {
 		logger.Error(err)
@@ -18,7 +19,7 @@ func StoreList(c *gin.Context) {
 		return
 	}
 
-	stores, err := model.GetStoreList(req.GameCardId)
+	stores, err := model.GetStoreList(req.GameCardList)
 	if err != nil {
 		logger.Error("err:", err)
 		RespJson(c, status.InternalServerError, nil)

model/model_test.go

@@ -131,7 +131,8 @@ func InitDBProd() {
 	DBProd.DB().SetMaxOpenConns(1000)
 	DBProd.DB().SetMaxIdleConns(500)
 	DBProd.DB().SetConnMaxLifetime(time.Second * 10)
-	DBProd.LogMode(true)
+	//DBProd.LogMode(true)
+	DBProd.LogMode(false)
 	DBProd.SingularTable(true)
 	DBProd.AutoMigrate(
 		&RedeemCode{},
@@ -310,6 +311,7 @@ func TestGenShareCode(t *testing.T) {
 
 }
 
+// 用户绑定门店
 func TestUserBundleFirstOrderStore(t *testing.T) {
 	UserBundleFirstOrderStore()
 }
@@ -552,7 +554,190 @@ func MergingGameCards() {
 
 }
 
-func UpdateUserName()  {
+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 {
+		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)
+		}
+	}
+}

model/order.go

@@ -36,7 +36,8 @@ type Order struct {
 	Uid                    uint64    `json:"uid" gorm:"index"`
 	GameCardId             uint64    `json:"game_card_id" gorm:"index"`                                 // 游戏id
 	GameCardGoodsId        uint64    `json:"game_card_goods_id" gorm:"index"`                           // 游戏卡id
-	StoreId                uint64    `json:"store_id"`                                                  // 门店id
+	GameCardSerialNumber   string    `json:"game_card_serial_number" gorm:"index"`                      // 游戏卡编号
+	StoreId                uint64    `json:"store_id" gorm:"index"`                                     // 门店id
 	UserAddressId          uint64    `json:"user_address_id"`                                           // 地址id
 	DeliveryType           uint8     `json:"delivery_type"`                                             // 取货类型 1-门店自取 2-快递
 	Count                  uint32    `json:"count"`                                                     // 数量
@@ -150,6 +151,9 @@ func OrderCardListSetGameInfo(list []OrderCard) []OrderCard {
 		order, ok2 := orderMap[list[i].OrderId]
 		fmt.Printf("gameCard1:%#v \n", gameCard)
 		if ok1 && ok2 {
+			if order.CardStatus == 2|| order.CardStatus == 3 {
+				order.CardStatus = 4
+			}
 			fmt.Printf("gameCard2:%#v \n", gameCard)
 			list[i].GameName = gameCard.Name
 			list[i].GameCoverImg = gameCard.CoverImg
@@ -234,6 +238,7 @@ func (m *OrderListReq) GetOrderCardList() ([]OrderCard, uint32, error) {
 		return orderCards, 0, err
 	}
 	totalPage = uint32(count/m.PageSize + 1)
+	fmt.Println("orderCards:", orderCards)
 
 	orderCards = OrderCardListSetGameInfo(orderCards)
 
@@ -386,7 +391,7 @@ func (m *Order) RevertCancel() (bool, error) {
 	//order.RevertExpressCompanyNo = m.RevertExpressCompanyNo
 	//order.RevertExpressNo = m.RevertExpressNo
 	_, err = NewOrderCardQuerySet(DB).IDEq(m.OrderCardId).GetUpdater().
-	//_, err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).GetUpdater().
+		//_, err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).GetUpdater().
 		SetCardStatus(OrderCardStatusPlaying).
 		//SetRevertTime(time.Time{}).
 		SetRevertStoreId(0).

model/store.go

@@ -31,7 +31,7 @@ type GameCardStock struct {
 	Stock uint32 `json:"stock"`
 }
 
-func GetStoreList(gameId uint64) ([]GameCardStock, error) {
+func GetStoreList(cardInfos []CardInfo) ([]GameCardStock, error) {
 	var eg errgroup.Group
 	stores := make([]Store, 0)
 	stocks := make([]GameCardGoodsStock, 0)
@@ -48,7 +48,7 @@ func GetStoreList(gameId uint64) ([]GameCardStock, error) {
 		return nil
 	})
 
-	if gameId == 0 {
+	if len(cardInfos) == 0 {
 		stores = * <-storesCh
 		fmt.Println("stores:", stores)
 		for i, _ := range stores {
@@ -61,8 +61,15 @@ func GetStoreList(gameId uint64) ([]GameCardStock, error) {
 		return list, nil
 	}
 
+	gameIds := make([]uint64, 0)
+	cardInfoMap := make(map[uint64]uint32, 0)
+	for i, _ := range cardInfos {
+		gameIds = append(gameIds, uint64(cardInfos[i].GameCardId))
+		cardInfoMap[uint64(cardInfos[i].GameCardId)] = cardInfos[i].Count
+	}
 	eg.Go(func() error {
-		err := NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(gameId).RentStockGt(0).All(&stocks)
+		//err := NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(gameId).RentStockGt(0).All(&stocks)
+		err := NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameIds...).RentStockGt(0).All(&stocks)
 		if err != nil {
 			logger.Errorf("err:%+v", err)
 			return err
@@ -75,20 +82,47 @@ func GetStoreList(gameId uint64) ([]GameCardStock, error) {
 		logger.Errorf("err:%+v", err)
 		return list, err
 	}
-	stockMap := make(map[uint64]uint32)
+	//stockMap := make(map[uint64]uint32)
+	//for i, _ := range stocks {
+	//	count, ok := cardInfoMap[uint64(stocks[i].GameCardId)]
+	//	if ok &&  count <= stocks[i].RentStock {
+	//		stockMap[stocks[i].StoreId] = stocks[i].RentStock
+	//	}
+	//}
+
+	storeStockMap := make(map[uint64]map[uint64]uint32, 0)
 	for i, _ := range stocks {
-		stockMap[stocks[i].StoreId] = stocks[i].RentStock
+		//count, ok := cardInfoMap[uint64(stocks[i].GameCardId)]
+		//if ok &&  count <= stocks[i].RentStock {
+		//	stockMap[stocks[i].StoreId] = stocks[i].RentStock
+		//}
+		stockMap, ok := storeStockMap[stocks[i].StoreId]
+		if !ok {
+			stockMap = make(map[uint64]uint32, 0)
+		}
+		stockMap[stocks[i].GameCardId] = stocks[i].RentStock
+		storeStockMap[stocks[i].StoreId] = stockMap
 	}
+
 	for i, _ := range stores {
-		rentStock, ok := stockMap[uint64(stores[i].ID)]
+		stockMap, ok := storeStockMap[uint64(stores[i].ID)]
-		if ok {
+		if ok && IsStoreStockEnough(cardInfos, stockMap) {
 			cardStock := GameCardStock{
 				Store: stores[i],
-				Stock: rentStock,
+				Stock: 0,
 			}
 			list = append(list, cardStock)
 		}
+
+		//if ok {
+		//	cardStock := GameCardStock{
+		//		Store: stores[i],
+		//		Stock: rentStock,
+		//	}
+		//	list = append(list, cardStock)
+		//}
 	}
+	fmt.Println("list:", list)
 	return list, nil
 }
 
@@ -118,3 +152,14 @@ type CannibalizeGameCardGoods struct {
 	GameCardId             uint32 `json:"game_card_id"`               // 游戏卡id
 	SerialNumber           string `json:"serial_number" gorm:"index"` // 编号
 }
+
+func IsStoreStockEnough(cardInfos []CardInfo, gameStockMap map[uint64]uint32) bool {
+	//haveStock =
+	for i, _ := range cardInfos {
+		stock, ok := gameStockMap[uint64(cardInfos[i].GameCardId)]
+		if !ok || stock < cardInfos[i].Count {
+			return false
+		}
+	}
+	return true
+}

model/user.go

@@ -443,7 +443,7 @@ func GetUserMutex(mutexKey string) *sync.Mutex {
 
 var AuthLoginMutex = sync.Mutex{}
 
-func OrderCardUserRentCard(uid uint32, count uint32, memberConfig *MemberConfig,gdb *gorm.DB) error {
+func OrderCardUserRentCard(uid uint32, count uint32, memberConfig *MemberConfig, gdb *gorm.DB) error {
 	//UserRentCard{}
 	if gdb == nil {
 		gdb = DB
@@ -490,3 +490,65 @@ func OrderCardUserRentCard(uid uint32, count uint32, memberConfig *MemberConfig,
 	}
 	return nil
 }
+
+func ShoppingCartCreateOrder(uid uint32, cards []CardInfo) {
+	cardIds := make([]uint64, 0, len(cards))
+	for i, _ := range cards {
+		cardIds = append(cardIds, uint64(cards[i].GameCardId))
+	}
+	err := NewShoppingCartQuerySet(DB).UidEq(uint64(uid)).GameCardIdIn(cardIds...).Delete()
+	if err != nil {
+		logger.Error("err:", err)
+	}
+	return
+}
+
+func ShoppingCartCreateOrderByOrder(order Order) {
+	var orderCards []OrderCard
+	err := NewOrderCardQuerySet(DB).OrderIdEq(order.ID).All(&orderCards)
+	if err != nil {
+		logger.Error("err:", err.Error())
+	}
+	cardIds := make([]uint64, 0, len(orderCards))
+	for i, _ := range orderCards {
+		cardIds = append(cardIds, uint64(orderCards[i].GameCardId))
+	}
+	err = NewShoppingCartQuerySet(DB).UidEq(uint64(order.Uid)).GameCardIdIn(cardIds...).Delete()
+	if err != nil {
+		logger.Error("err:", err)
+	}
+	return
+}
+
+func CreateUserRentCardByMemberLevel(uid, memberLevel, cardMax uint32) {
+	var userRentCard UserRentCard
+	err := NewUserRentCardQuerySet(DB).UidEq(uid).One(&userRentCard)
+	if err != nil && err != RecordNotFound {
+		logger.Error("UserRentCard err:", err)
+		return
+	}
+
+	if err == RecordNotFound {
+		userRentCard = UserRentCard{
+			Uid:            uid,
+			MemberLevel:    memberLevel,
+			LevelRentCount: cardMax,
+			HaveRentCount:  0,
+			CanRentCount:   cardMax,
+			Status:         0,
+		}
+		err := DB.Create(&userRentCard).Error
+		if err != nil {
+			logger.Error("UserRentCard create err:", err)
+		}
+		return
+	}
+	_, err = NewUserRentCardQuerySet(DB).IDEq(userRentCard.ID).GetUpdater().
+		SetMemberLevel(memberLevel).
+		SetCanRentCount(cardMax - userRentCard.HaveRentCount).
+		SetLevelRentCount(cardMax).UpdateNum()
+	if err != nil {
+		logger.Error("update err:", err)
+	}
+
+}