go_dreamfactory/modules/pack/cache_comp.go

package pack

import (
	"fmt"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/mgo"
	"go_dreamfactory/lego/sys/redis"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"reflect"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

///背包缓存数据管理组件
type Cache_Comp struct {
	modules.MComp_CacheComp
	module *Pack
}

//组件初始化接口
func (this *Cache_Comp) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	this.ModuleCompBase.Init(service, module, comp, options)
	this.module = module.(*Pack)
	return
}

///查询用户背包数据
func (this *Cache_Comp) Pack_QueryUserPack(uId string) (itmes []*pb.DB_UserItemData, err error) {
	var (
		lists []interface{}
		temp  map[string]interface{}
	)
	itmes = make([]*pb.DB_UserItemData, len(lists))
	if lists, err = this.Redis.HGetAll(fmt.Sprintf(Redis_PackCache, uId), reflect.TypeOf(&pb.DB_UserItemData{})); err == nil {
		for i, v := range lists {
			itmes[i] = v.(*pb.DB_UserItemData)
		}
		return
	} else if err == redis.RedisNil {
		if itmes, err = this.module.db_comp.Pack_QueryUserPack(uId); err == nil {
			temp = make(map[string]interface{})
			for _, v := range itmes {
				temp[v.GridId] = v
			}
			this.Redis.HMSet(fmt.Sprintf(Redis_PackCache, uId), temp)
		} else if err == mgo.MongodbNil {
			err = nil
		}
	}
	return
}

///查询用户指定格子的物品数据
func (this *Cache_Comp) Pack_QueryUserPackByGridId(uId string, grid string) (itme *pb.DB_UserItemData, err error) {
	var (
		itmes []*pb.DB_UserItemData
		temp  map[string]interface{}
	)
	itme = &pb.DB_UserItemData{}
	if err = this.Redis.HGet(fmt.Sprintf(Redis_PackCache, uId), grid, itme); err == nil {
		return
	} else if err == redis.RedisNil {
		if itmes, err = this.module.db_comp.Pack_QueryUserPack(uId); err == nil {
			temp = make(map[string]interface{})
			for _, v := range itmes {
				temp[v.GridId] = v
			}
			this.Redis.HMSet(fmt.Sprintf(Redis_PackCache, uId), temp)
			for _, v := range itmes {
				if v.GridId == grid {
					itme = v
					return
				}
			}
			err = fmt.Errorf("no found uid:%s grid:%s", uId, grid)
		} else if err == mgo.MongodbNil {
			err = nil
		}
	}
	return
}

//更新用户的背包信息
func (this *Cache_Comp) Pack_UpdateUserPack(uId string, itmes ...*pb.DB_UserItemData) (err error) {
	temp := make(map[string]interface{})
	for _, v := range itmes {
		temp[v.GridId] = v
	}
	if err = this.Redis.HMSet(fmt.Sprintf(Redis_PackCache, uId), temp); err != nil {
		this.module.db_comp.Pack_UpdateGridToUserPack(uId, itmes...)
	}

	return
}

//更新用户的背包信息
func (this *Cache_Comp) Pack_DeleteUserPack(uId string, gridIds ...string) (err error) {
	if err = this.Redis.HDel(fmt.Sprintf(Redis_PackCache, uId), gridIds...); err != nil {
		err = this.module.db_comp.Pack_DeleteGridToUserPack(uId, gridIds...)
	}
	return
}

//查询用户背包物品数量
func (this *Cache_Comp) Pack_QueryUserPackItemAmount(uId string, itemid int32) (amount uint32) {
	var (
		itmes []*pb.DB_UserItemData
		err   error
	)
	if itmes, err = this.Pack_QueryUserPack(uId); err != nil {
		return
	}
	for _, v := range itmes {
		if !v.IsEmpty && v.ItemId == itemid {
			amount += v.Amount
		}
	}
	return
}

///添加或则减少物品到用户背包
func (this *Cache_Comp) Pack_AddItemToUserPack(uId string, itemId int32, addnum int32) (err error) {
	var (
		itmes   []*pb.DB_UserItemData
		modifys []*pb.DB_UserItemData
		leftnum int64
	)
	if addnum == 0 {
		return
	}
	if itmes, err = this.Pack_QueryUserPack(uId); err != nil {
		return
	}
	modifys, leftnum = this.pack_addItemToUserPack(itmes, itemId, addnum)
	if leftnum < 0 {
		err = ItemNotEnoughError
		return
	} else if leftnum > 0 {
		err = PackGridNumUpper
		return
	}
	this.Pack_UpdateUserPack(uId, modifys...)
	return
}

///添加或则减少多个物品到用户背包
func (this *Cache_Comp) Pack_AddItemsToUserPack(uId string, items map[int32]int32) (err error) {
	var (
		itmes       []*pb.DB_UserItemData
		modifys     []*pb.DB_UserItemData
		tempmodifys []*pb.DB_UserItemData
		leftnum     int64
		iskeep      bool
	)
	if itmes, err = this.Pack_QueryUserPack(uId); err != nil {
		return
	}
	for k, v := range items {
		tempmodifys, leftnum = this.pack_addItemToUserPack(itmes, k, v)
		if leftnum < 0 {
			err = ItemNotEnoughError
			return
		} else if leftnum > 0 {
			err = PackGridNumUpper
			return
		}
		for _, v1 := range tempmodifys {
			iskeep = false
			for _, v2 := range modifys {
				if v1.GridId == v2.GridId {
					iskeep = true
				}
			}
			if !iskeep {
				modifys = append(modifys, v1)
			}
		}
	}

	this.Pack_UpdateUserPack(uId, modifys...)
	return
}

///修改指定格子的物品数量
func (this *Cache_Comp) Pack_AddItemToUserPackByGrid(uId string, gridid string, itemId int32, addnum int32) (err error) {
	var (
		itme   *pb.DB_UserItemData
		grid   *pb.DB_UserItemData
		num    int64
		amount int64
	)
	if addnum == 0 {
		return
	}
	if itme, err = this.Pack_QueryUserPackByGridId(uId, gridid); err != nil {
		return
	}
	amount = int64(itme.Amount)
	if grid.IsEmpty {
		amount = 0
	} else if grid.ItemId != itemId {
		err = fmt.Errorf("target grid itemid:%d no is %d ", grid.ItemId, itemId)
	}
	num = amount + int64(addnum)
	if num < 0 {
		err = ItemNotEnoughError
	} else {
		if num > GridCapMaxNum {
			err = GirdAmountUpper
			return
		} else {
			itme.Amount = uint32(num)
			this.Pack_UpdateUserPack(uId, itme)
		}
	}
	return
}

///添加移除物品到用户背包
func (this *Cache_Comp) pack_addItemToUserPack(items []*pb.DB_UserItemData, itemId int32, addnum int32) (modifys []*pb.DB_UserItemData, leftnum int64) {
	var (
		num   int64
		isNew bool
	)
	if addnum == 0 {
		return
	}
	isNew = true
	leftnum = int64(addnum)
	modifys = make([]*pb.DB_UserItemData, 0)
	for _, v := range items {
		if !v.IsEmpty && v.ItemId == itemId {
			isNew = false
			num = int64(v.Amount) + int64(leftnum)
			if num < 0 {
				leftnum += int64(v.Amount)
				v.Amount = 0
				v.IsEmpty = true
				modifys = append(modifys, v)
			} else if num > 0 && num < int64(v.Amount) {
				leftnum = 0
				v.Amount = uint32(num)
				modifys = append(modifys, v)
				break
			} else if num > 0 && num > int64(v.Amount) {
				if num <= GridCapMaxNum {
					leftnum = 0
					v.Amount = uint32(num)
					modifys = append(modifys, v)
					break
				} else {
					if v.Amount < GridCapMaxNum {
						leftnum = int64(num - GridCapMaxNum)
						v.Amount = uint32(GridCapMaxNum)
						modifys = append(modifys, v)
					}
				}
			} else if num == 0 {
				leftnum = 0
				v.Amount = 0
				v.IsEmpty = true
				modifys = append(modifys, v)
			}
		}
	}
	if leftnum < 0 { //背包物品不够
		return
	}
	if leftnum > 0 { //还没有放完 寻找空的格子填充
		for _, v := range items {
			if v.IsEmpty {
				if leftnum <= GridCapMaxNum {
					v.IsEmpty = false
					v.ItemId = itemId
					v.Amount = uint32(leftnum)
					leftnum = 0
					modifys = append(modifys, v)
					break
				} else {
					leftnum -= GridCapMaxNum
					v.IsEmpty = false
					v.ItemId = itemId
					v.Amount = uint32(GridCapMaxNum)
					modifys = append(modifys, v)
				}
			}
		}
		index := int32(len(items))
		for leftnum > 0 { //需要补充格子
			if leftnum <= GridCapMaxNum {
				grid := &pb.DB_UserItemData{
					GridId:    primitive.NewObjectID().Hex(),
					IsEmpty:   false,
					ItemId:    itemId,
					Amount:    uint32(leftnum),
					IsNewItem: isNew,
				}
				items = append(items, grid)
				modifys = append(modifys, grid)
				leftnum = 0
				break
			} else {
				leftnum -= GridCapMaxNum
				grid := &pb.DB_UserItemData{
					GridId:    primitive.NewObjectID().Hex(),
					IsEmpty:   false,
					ItemId:    itemId,
					Amount:    uint32(GridCapMaxNum),
					IsNewItem: isNew,
				}
				items = append(items, grid)
				modifys = append(modifys, grid)
				index++
			}
			if index > GridMaxNUm { //格子已达上限
				break
			}
		}
	}
	return
}