785 lines
26 KiB
Python
785 lines
26 KiB
Python
"""虎牙活动积分相关 JCE 结构。"""
|
|
|
|
from .taf_protocol import TafInputStream, TafOutputStream, TafStruct, TafType
|
|
|
|
|
|
class ActivityUserId(TafStruct):
|
|
"""活动组件使用的用户标识。"""
|
|
|
|
def __init__(self):
|
|
self.lUid: int = 0
|
|
self.sGuid: str = ""
|
|
self.sToken: str = ""
|
|
self.sHuYaUA: str = "webh5&0.0.1&websocket&&diypc_52775"
|
|
self.sCookie: str = ""
|
|
self.iTokenType: int = 0
|
|
self.sDeviceInfo: str = ""
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int64(0, self.lUid)
|
|
os.write_string(1, self.sGuid)
|
|
os.write_string(2, self.sToken)
|
|
os.write_string(3, self.sHuYaUA)
|
|
os.write_string(4, self.sCookie)
|
|
os.write_int32(5, self.iTokenType)
|
|
os.write_string(6, self.sDeviceInfo)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.lUid = ins.read_int64(0, default=self.lUid)
|
|
self.sGuid = ins.read_string(1, default=self.sGuid)
|
|
self.sToken = ins.read_string(2, default=self.sToken)
|
|
self.sHuYaUA = ins.read_string(3, default=self.sHuYaUA)
|
|
self.sCookie = ins.read_string(4, default=self.sCookie)
|
|
self.iTokenType = ins.read_int32(5, default=self.iTokenType)
|
|
self.sDeviceInfo = ins.read_string(6, default=self.sDeviceInfo)
|
|
|
|
|
|
class GetUserScoreReq(TafStruct):
|
|
"""webActUI.getUserScore 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.sid: int = 0
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.sid)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.sid = ins.read_int32(1, default=self.sid)
|
|
|
|
|
|
class GetUserScoreResp(TafStruct):
|
|
"""webActUI.getUserScore 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.gainScore: int = 0
|
|
self.usedScore: int = 0
|
|
self.newGainScore: int = 0
|
|
self.newUsedScore: int = 0
|
|
self.score: int = 0
|
|
self.isOpenExchangeTip: int = 0
|
|
|
|
@property
|
|
def available_score(self) -> int:
|
|
"""按现网页组件逻辑计算可用积分。"""
|
|
if self.newGainScore or self.newUsedScore:
|
|
return max(0, int(self.newGainScore) - int(self.newUsedScore))
|
|
return int(self.score)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.status = ins.read_int32(0, default=self.status)
|
|
self.msg = ins.read_string(1, default=self.msg)
|
|
self.gainScore = ins.read_int32(2, default=self.gainScore)
|
|
self.usedScore = ins.read_int32(3, default=self.usedScore)
|
|
self.newGainScore = ins.read_int64(4, default=self.newGainScore)
|
|
self.newUsedScore = ins.read_int64(5, default=self.newUsedScore)
|
|
self.score = ins.read_int64(6, default=self.score)
|
|
self.isOpenExchangeTip = ins.read_int32(7, default=self.isOpenExchangeTip)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.status)
|
|
os.write_string(1, self.msg)
|
|
os.write_int32(2, self.gainScore)
|
|
os.write_int32(3, self.usedScore)
|
|
os.write_int64(4, self.newGainScore)
|
|
os.write_int64(5, self.newUsedScore)
|
|
os.write_int64(6, self.score)
|
|
os.write_int32(7, self.isOpenExchangeTip)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"gain_score": self.gainScore,
|
|
"used_score": self.usedScore,
|
|
"new_gain_score": self.newGainScore,
|
|
"new_used_score": self.newUsedScore,
|
|
"score": self.score,
|
|
"available_score": self.available_score,
|
|
"is_open_exchange_tip": self.isOpenExchangeTip,
|
|
}
|
|
|
|
|
|
class GetActPrizeListReq(TafStruct):
|
|
"""webActUI.getActPrizeList 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.sid: int = 0
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.sid)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.sid = ins.read_int32(1, default=self.sid)
|
|
|
|
|
|
class ActPrizeItem(TafStruct):
|
|
"""活动商品项，字段位置来自 getActPrizeList 实测响应。"""
|
|
|
|
def __init__(self):
|
|
self.prizeId: int = 0
|
|
self.prizeType: int = 0
|
|
self.name: str = ""
|
|
self.score: int = 0
|
|
self.icon: str = ""
|
|
self.stock: int = 0
|
|
self.remainText: str = ""
|
|
self.price: int = 0
|
|
self.categoryId: str = ""
|
|
self.totalRemain: int = 0
|
|
self.rawOrder: int = 0
|
|
self.startTime: int = 0
|
|
self.endTime: int = 0
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.prizeId = ins.read_int64(0, default=self.prizeId)
|
|
self.prizeType = ins.read_int32(1, default=self.prizeType)
|
|
self.name = ins.read_string(2, default=self.name)
|
|
self.score = ins.read_int64(3, default=self.score)
|
|
ins.read_int32(4, default=0)
|
|
self.icon = ins.read_string(5, default=self.icon)
|
|
self.stock = ins.read_int64(10, default=self.stock)
|
|
self.remainText = ins.read_string(12, default=self.remainText)
|
|
self.price = ins.read_int64(13, default=self.price)
|
|
self.categoryId = ins.read_string(14, default=self.categoryId)
|
|
self.totalRemain = ins.read_int64(17, default=self.totalRemain)
|
|
self.rawOrder = ins.read_int64(22, default=self.rawOrder)
|
|
self.startTime = ins.read_int64(25, default=self.startTime)
|
|
self.endTime = ins.read_int64(26, default=self.endTime)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int64(0, self.prizeId)
|
|
os.write_int32(1, self.prizeType)
|
|
os.write_string(2, self.name)
|
|
os.write_int64(3, self.score)
|
|
os.write_string(5, self.icon)
|
|
os.write_int64(10, self.stock)
|
|
os.write_string(12, self.remainText)
|
|
os.write_int64(13, self.price)
|
|
os.write_string(14, self.categoryId)
|
|
os.write_int64(17, self.totalRemain)
|
|
os.write_int64(22, self.rawOrder)
|
|
os.write_int64(25, self.startTime)
|
|
os.write_int64(26, self.endTime)
|
|
|
|
@staticmethod
|
|
def read_list_item(ins: TafInputStream, _tag: int):
|
|
item = ActPrizeItem()
|
|
item.read_from(ins)
|
|
while True:
|
|
_end_tag, dtype = ins.read_head()
|
|
if dtype == TafType.STRUCT_END:
|
|
break
|
|
ins.skip_field(dtype)
|
|
return item
|
|
|
|
@staticmethod
|
|
def _remain_percent_text(value: str) -> str:
|
|
text = str(value or "").strip()
|
|
if not text or text.endswith("%"):
|
|
return text
|
|
try:
|
|
float(text)
|
|
except ValueError:
|
|
return text
|
|
return f"{text}%"
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"product_id": str(self.prizeId),
|
|
"name": self.name,
|
|
"price": self.price,
|
|
"remain_text": self._remain_percent_text(self.remainText),
|
|
"remain_percent": self.remainText,
|
|
"stock": self.stock,
|
|
"score": self.score,
|
|
"icon": self.icon,
|
|
"prize_type": self.prizeType,
|
|
"category_id": self.categoryId,
|
|
"total_remain": self.totalRemain,
|
|
"raw_order": self.rawOrder,
|
|
"start_time": self.startTime,
|
|
"end_time": self.endTime,
|
|
}
|
|
|
|
|
|
class ActPrizeTag(TafStruct):
|
|
"""活动商品分类。"""
|
|
|
|
def __init__(self):
|
|
self.tagId: int = 0
|
|
self.name: str = ""
|
|
self.sort: int = 0
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.tagId = ins.read_int64(0, default=self.tagId)
|
|
self.name = ins.read_string(1, default=self.name)
|
|
self.sort = ins.read_int32(2, default=self.sort)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int64(0, self.tagId)
|
|
os.write_string(1, self.name)
|
|
os.write_int32(2, self.sort)
|
|
|
|
@staticmethod
|
|
def read_list_item(ins: TafInputStream, _tag: int):
|
|
item = ActPrizeTag()
|
|
item.read_from(ins)
|
|
while True:
|
|
_end_tag, dtype = ins.read_head()
|
|
if dtype == TafType.STRUCT_END:
|
|
break
|
|
ins.skip_field(dtype)
|
|
return item
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"category_id": str(self.tagId),
|
|
"category_name": self.name,
|
|
"sort": self.sort,
|
|
}
|
|
|
|
|
|
class GetActPrizeListResp(TafStruct):
|
|
"""webActUI.getActPrizeList 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.prizes: list[ActPrizeItem] = []
|
|
self.tags: list[ActPrizeTag] = []
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.status = ins.read_int32(0, default=self.status)
|
|
self.msg = ins.read_string(1, default=self.msg)
|
|
self.prizes = ins.read_list(2, item_reader=ActPrizeItem.read_list_item)
|
|
self.tags = ins.read_list(4, item_reader=ActPrizeTag.read_list_item)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.status)
|
|
os.write_string(1, self.msg)
|
|
os.write_list(2, self.prizes)
|
|
os.write_list(4, self.tags)
|
|
|
|
def to_dict(self) -> dict:
|
|
tag_info = {
|
|
str(item.tagId): {"name": item.name, "sort": index, "raw_sort": item.sort}
|
|
for index, item in enumerate(self.tags)
|
|
}
|
|
goods = []
|
|
for item in self.prizes:
|
|
data = item.to_dict()
|
|
category = tag_info.get(data["category_id"], {})
|
|
data["category_name"] = category.get("name", "")
|
|
data["category_sort"] = category.get("sort", 0)
|
|
goods.append(data)
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"goods_count": len(self.prizes),
|
|
"categories": [item.to_dict() for item in self.tags],
|
|
"goods": goods,
|
|
}
|
|
|
|
|
|
class GameAccount(TafStruct):
|
|
"""游戏账号信息。"""
|
|
|
|
def __init__(self):
|
|
self.openId: str = ""
|
|
self.appId: str = ""
|
|
self.type: str = ""
|
|
self.faceUrl: str = ""
|
|
self.nick: str = ""
|
|
self.accessToken: str = ""
|
|
self.extendInfo: str = ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.openId = ins.read_string(0, default=self.openId)
|
|
self.appId = ins.read_string(1, default=self.appId)
|
|
self.type = ins.read_string(2, default=self.type)
|
|
self.faceUrl = ins.read_string(3, default=self.faceUrl)
|
|
self.nick = ins.read_string(4, default=self.nick)
|
|
self.accessToken = ins.read_string(5, default=self.accessToken)
|
|
self.extendInfo = ins.read_string(6, default=self.extendInfo)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_string(0, self.openId)
|
|
os.write_string(1, self.appId)
|
|
os.write_string(2, self.type)
|
|
os.write_string(3, self.faceUrl)
|
|
os.write_string(4, self.nick)
|
|
os.write_string(5, self.accessToken)
|
|
os.write_string(6, self.extendInfo)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"app_id": self.appId,
|
|
"type": self.type,
|
|
"face_url": self.faceUrl,
|
|
"nick": self.nick,
|
|
"extend_info": self.extendInfo,
|
|
"has_open_id": bool(self.openId),
|
|
"has_access_token": bool(self.accessToken),
|
|
}
|
|
|
|
|
|
class GameRole(TafStruct):
|
|
"""游戏角色信息。"""
|
|
|
|
def __init__(self):
|
|
self.roleId: str = ""
|
|
self.roleName: str = ""
|
|
self.areaName: str = ""
|
|
self.platName: str = ""
|
|
self.partitionName: str = ""
|
|
self.gameSerial: str = ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.roleId = ins.read_string(0, default=self.roleId)
|
|
self.roleName = ins.read_string(1, default=self.roleName)
|
|
self.areaName = ins.read_string(2, default=self.areaName)
|
|
self.platName = ins.read_string(3, default=self.platName)
|
|
self.partitionName = ins.read_string(4, default=self.partitionName)
|
|
self.gameSerial = ins.read_string(5, default=self.gameSerial)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_string(0, self.roleId)
|
|
os.write_string(1, self.roleName)
|
|
os.write_string(2, self.areaName)
|
|
os.write_string(3, self.platName)
|
|
os.write_string(4, self.partitionName)
|
|
os.write_string(5, self.gameSerial)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"role_id": self.roleId,
|
|
"role_name": self.roleName,
|
|
"area_name": self.areaName,
|
|
"plat_name": self.platName,
|
|
"partition_name": self.partitionName,
|
|
"game_serial": self.gameSerial,
|
|
}
|
|
|
|
|
|
class GameAccountData(TafStruct):
|
|
"""绑定账号状态。"""
|
|
|
|
def __init__(self):
|
|
self.isBindAcount: int = 0
|
|
self.isBindRole: int = 0
|
|
self.isNeedActCheck: int = 0
|
|
self.gameAccount = GameAccount()
|
|
self.gameRole = GameRole()
|
|
self.changBindTime: int = 0
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.isBindAcount = ins.read_int32(0, default=self.isBindAcount)
|
|
self.isBindRole = ins.read_int32(1, default=self.isBindRole)
|
|
self.isNeedActCheck = ins.read_int32(2, default=self.isNeedActCheck)
|
|
self.gameAccount = ins.read_struct(3, GameAccount) or self.gameAccount
|
|
self.gameRole = ins.read_struct(4, GameRole) or self.gameRole
|
|
self.changBindTime = ins.read_int32(5, default=self.changBindTime)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.isBindAcount)
|
|
os.write_int32(1, self.isBindRole)
|
|
os.write_int32(2, self.isNeedActCheck)
|
|
os.write_struct(3, self.gameAccount)
|
|
os.write_struct(4, self.gameRole)
|
|
os.write_int32(5, self.changBindTime)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"is_bind_account": self.isBindAcount,
|
|
"is_bind_role": self.isBindRole,
|
|
"is_need_act_check": self.isNeedActCheck,
|
|
"game_account": self.gameAccount.to_dict(),
|
|
"game_role": self.gameRole.to_dict(),
|
|
"change_bind_time": self.changBindTime,
|
|
}
|
|
|
|
|
|
class CheckUserBindGameAccountReq(TafStruct):
|
|
"""webActUI.checkUserBindGameAccount 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.gid: int = 0
|
|
self.outerActId: str = ""
|
|
self.isInnerBind: int = 0
|
|
self.scene: str = ""
|
|
self.bActId: int = 0
|
|
self.isUseOuterActId: int = 0
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.gid)
|
|
os.write_string(2, self.outerActId)
|
|
os.write_int32(3, self.isInnerBind)
|
|
os.write_string(4, self.scene)
|
|
os.write_int32(5, self.bActId)
|
|
os.write_int32(6, self.isUseOuterActId)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.gid = ins.read_int32(1, default=self.gid)
|
|
self.outerActId = ins.read_string(2, default=self.outerActId)
|
|
self.isInnerBind = ins.read_int32(3, default=self.isInnerBind)
|
|
self.scene = ins.read_string(4, default=self.scene)
|
|
self.bActId = ins.read_int32(5, default=self.bActId)
|
|
self.isUseOuterActId = ins.read_int32(6, default=self.isUseOuterActId)
|
|
|
|
|
|
class CheckUserBindGameAccountResp(TafStruct):
|
|
"""webActUI.checkUserBindGameAccount 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.accountData = GameAccountData()
|
|
self.gameName: str = ""
|
|
self.gameAuthScene: str = ""
|
|
self.changeBindDay: int = 0
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.status = ins.read_int32(0, default=self.status)
|
|
self.msg = ins.read_string(1, default=self.msg)
|
|
self.accountData = ins.read_struct(2, GameAccountData) or self.accountData
|
|
self.gameName = ins.read_string(3, default=self.gameName)
|
|
self.gameAuthScene = ins.read_string(4, default=self.gameAuthScene)
|
|
self.changeBindDay = ins.read_int32(5, default=self.changeBindDay)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.status)
|
|
os.write_string(1, self.msg)
|
|
os.write_struct(2, self.accountData)
|
|
os.write_string(3, self.gameName)
|
|
os.write_string(4, self.gameAuthScene)
|
|
os.write_int32(5, self.changeBindDay)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"account_data": self.accountData.to_dict(),
|
|
"game_name": self.gameName,
|
|
"game_auth_scene": self.gameAuthScene,
|
|
"change_bind_day": self.changeBindDay,
|
|
}
|
|
|
|
|
|
class ConfirmBindActAccountReq(TafStruct):
|
|
"""webActUI.confirmBindActAccount 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.gid: int = 0
|
|
self.outerActId: str = ""
|
|
self.bActId: int = 0
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.gid)
|
|
os.write_string(2, self.outerActId)
|
|
os.write_int32(3, self.bActId)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.gid = ins.read_int32(1, default=self.gid)
|
|
self.outerActId = ins.read_string(2, default=self.outerActId)
|
|
self.bActId = ins.read_int32(3, default=self.bActId)
|
|
|
|
|
|
class ConfirmBindActAccountResp(TafStruct):
|
|
"""webActUI.confirmBindActAccount 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.status = ins.read_int32(0, default=self.status)
|
|
self.msg = ins.read_string(1, default=self.msg)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.status)
|
|
os.write_string(1, self.msg)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
}
|
|
|
|
|
|
class GetLiveLinkParamReq(TafStruct):
|
|
"""webActUI.getLiveLinkParam 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.gid: int = 0
|
|
self.outerActId: int = 0
|
|
self.gameAuthScene: str = ""
|
|
self.v: str = ""
|
|
self.bActId: int = 0
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.gid)
|
|
os.write_int32(2, self.outerActId)
|
|
os.write_string(3, self.gameAuthScene)
|
|
os.write_string(4, self.v)
|
|
os.write_int32(5, self.bActId)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.gid = ins.read_int32(1, default=self.gid)
|
|
self.outerActId = ins.read_int32(2, default=self.outerActId)
|
|
self.gameAuthScene = ins.read_string(3, default=self.gameAuthScene)
|
|
self.v = ins.read_string(4, default=self.v)
|
|
self.bActId = ins.read_int32(5, default=self.bActId)
|
|
|
|
|
|
class GetLiveLinkParamResp(TafStruct):
|
|
"""webActUI.getLiveLinkParam 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.livelinkParam: dict[str, str] = {}
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.status = ins.read_int32(0, default=self.status)
|
|
self.msg = ins.read_string(1, default=self.msg)
|
|
self.livelinkParam = ins.read_map(2)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.status)
|
|
os.write_string(1, self.msg)
|
|
os.write_map(2, self.livelinkParam)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"livelink_param": dict(self.livelinkParam),
|
|
}
|
|
|
|
def to_log_dict(self) -> dict:
|
|
data = dict(self.livelinkParam)
|
|
if data.get("code"):
|
|
data["code"] = f"<redacted len={len(data['code'])}>"
|
|
if data.get("sig"):
|
|
data["sig"] = f"<redacted len={len(data['sig'])}>"
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"livelink_param": data,
|
|
}
|
|
|
|
|
|
class GetUserProfileBatchReq(TafStruct):
|
|
"""huyauserui.getUserProfileBatch 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.uidList: list[int] = []
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_list(1, self.uidList)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.uidList = ins.read_list(1)
|
|
|
|
|
|
class HuyaUserProfile(TafStruct):
|
|
"""虎牙用户资料，仅读取绑定链接需要的字段。"""
|
|
|
|
def __init__(self):
|
|
self.uid: int = 0
|
|
self.nick: str = ""
|
|
self.avatar: str = ""
|
|
self.passport: str = ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
while True:
|
|
tag, dtype = ins.peek_head()
|
|
if dtype == TafType.STRUCT_END:
|
|
break
|
|
ins.read_head()
|
|
if tag == 0:
|
|
self.uid = ins._read_int_value(dtype)
|
|
elif tag == 1:
|
|
self.nick = self._read_string_value(ins, dtype)
|
|
elif tag == 2:
|
|
self.avatar = self._read_string_value(ins, dtype)
|
|
elif tag == 17:
|
|
self.passport = self._read_string_value(ins, dtype)
|
|
else:
|
|
ins.skip_field(dtype)
|
|
|
|
@staticmethod
|
|
def _read_string_value(ins: TafInputStream, dtype: int) -> str:
|
|
if dtype == TafType.STRING1:
|
|
length = int.from_bytes(ins.buf.read(1), "big")
|
|
elif dtype == TafType.STRING4:
|
|
length = int.from_bytes(ins.buf.read(4), "big")
|
|
else:
|
|
ins.skip_field(dtype)
|
|
return ""
|
|
return ins.buf.read(length).decode("utf-8", errors="replace")
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int64(0, self.uid)
|
|
os.write_string(1, self.nick)
|
|
os.write_string(2, self.avatar)
|
|
os.write_string(17, self.passport)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"uid": self.uid,
|
|
"nick": self.nick,
|
|
"avatar": self.avatar,
|
|
"passport": self.passport,
|
|
}
|
|
|
|
|
|
class GetUserProfileBatchResp(TafStruct):
|
|
"""huyauserui.getUserProfileBatch 响应。"""
|
|
|
|
def __init__(self):
|
|
self.profiles: list[HuyaUserProfile] = []
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
found = ins._find_tag(0, False)
|
|
if not found:
|
|
return
|
|
if found[1] != TafType.LIST:
|
|
ins.skip_field(found[1])
|
|
return
|
|
count = ins._read_int_len()
|
|
profiles = []
|
|
for _ in range(count):
|
|
_, dtype = ins.read_head()
|
|
if dtype != TafType.STRUCT_BEGIN:
|
|
ins.skip_field(dtype)
|
|
continue
|
|
item_profile = None
|
|
while True:
|
|
tag, field_type = ins.peek_head()
|
|
if field_type == TafType.STRUCT_END:
|
|
ins.read_head()
|
|
break
|
|
if tag == 0 and field_type == TafType.STRUCT_BEGIN:
|
|
item_profile = ins.read_struct(0, HuyaUserProfile)
|
|
else:
|
|
ins.read_head()
|
|
ins.skip_field(field_type)
|
|
if item_profile is not None:
|
|
profiles.append(item_profile)
|
|
self.profiles = profiles
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_list(0, self.profiles)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {"profiles": [profile.to_dict() for profile in self.profiles]}
|
|
|
|
|
|
def _self_check():
|
|
rsp = GetUserScoreResp()
|
|
rsp.status = 200
|
|
rsp.msg = "请求成功"
|
|
rsp.gainScore = 300
|
|
rsp.usedScore = 120
|
|
rsp.newGainScore = 300
|
|
rsp.newUsedScore = 120
|
|
rsp.score = 180
|
|
|
|
os = TafOutputStream()
|
|
os.write_struct(0, rsp)
|
|
ins = TafInputStream(os.get_bytes())
|
|
_, dtype = ins.read_head()
|
|
assert dtype == TafType.STRUCT_BEGIN
|
|
|
|
parsed = GetUserScoreResp()
|
|
parsed.read_from(ins)
|
|
assert parsed.status == 200
|
|
assert parsed.available_score == 180
|
|
|
|
prize_rsp = GetActPrizeListResp()
|
|
prize = ActPrizeItem()
|
|
prize.prizeId = 12885
|
|
prize.name = "赤蝎幽灵大礼包"
|
|
prize.price = 3600
|
|
prize.remainText = "39"
|
|
prize.categoryId = "85"
|
|
tag = ActPrizeTag()
|
|
tag.tagId = 85
|
|
tag.name = "限量返场"
|
|
tag.sort = 2
|
|
prize_rsp.status = 200
|
|
prize_rsp.msg = "请求成功"
|
|
prize_rsp.prizes = [prize]
|
|
prize_rsp.tags = [tag]
|
|
os = TafOutputStream()
|
|
os.write_struct(0, prize_rsp)
|
|
ins = TafInputStream(os.get_bytes())
|
|
_, dtype = ins.read_head()
|
|
assert dtype == TafType.STRUCT_BEGIN
|
|
parsed_prize = GetActPrizeListResp()
|
|
parsed_prize.read_from(ins)
|
|
assert parsed_prize.status == 200
|
|
assert parsed_prize.prizes[0].name == "赤蝎幽灵大礼包"
|
|
assert parsed_prize.prizes[0].price == 3600
|
|
parsed_prize_data = parsed_prize.to_dict()
|
|
assert parsed_prize_data["goods"][0]["category_name"] == "限量返场"
|
|
assert parsed_prize_data["goods"][0]["remain_text"] == "39%"
|
|
|
|
link_rsp = GetLiveLinkParamResp()
|
|
link_rsp.status = 200
|
|
link_rsp.livelinkParam = {
|
|
"actId": "17096",
|
|
"gameIdList": "cjm",
|
|
"livePlatId": "huya",
|
|
"code": "abc",
|
|
"sig": "def",
|
|
"t": "1783159287",
|
|
}
|
|
os = TafOutputStream()
|
|
os.write_struct(0, link_rsp)
|
|
ins = TafInputStream(os.get_bytes())
|
|
_, dtype = ins.read_head()
|
|
assert dtype == TafType.STRUCT_BEGIN
|
|
parsed_link = GetLiveLinkParamResp()
|
|
parsed_link.read_from(ins)
|
|
assert parsed_link.status == 200
|
|
assert parsed_link.livelinkParam["actId"] == "17096"
|
|
|
|
confirm_rsp = ConfirmBindActAccountResp()
|
|
confirm_rsp.status = 200
|
|
confirm_rsp.msg = "请求成功"
|
|
os = TafOutputStream()
|
|
os.write_struct(0, confirm_rsp)
|
|
ins = TafInputStream(os.get_bytes())
|
|
_, dtype = ins.read_head()
|
|
assert dtype == TafType.STRUCT_BEGIN
|
|
parsed_confirm = ConfirmBindActAccountResp()
|
|
parsed_confirm.read_from(ins)
|
|
assert parsed_confirm.status == 200
|
|
assert parsed_confirm.msg == "请求成功"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
_self_check()
|