1233 lines
41 KiB
Python
1233 lines
41 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 = ""
|
|
self.sQIMEI: 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)
|
|
os.write_string(7, self.sQIMEI)
|
|
|
|
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)
|
|
self.sQIMEI = ins.read_string(7, default=self.sQIMEI)
|
|
|
|
|
|
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 GetUserPrizeRecordsReq(TafStruct):
|
|
"""webActUI.getUserPrizeRecords 请求。"""
|
|
|
|
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 ScoreExchangePrizeReq(TafStruct):
|
|
"""webActUI.scoreExchangePrize 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.sid: int = 0
|
|
self.pid: int = 0
|
|
self.ip: str = ""
|
|
self.clientEnv: dict = {}
|
|
self.source: str = ""
|
|
self.isRole: int = 1
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.sid)
|
|
os.write_int32(2, self.pid)
|
|
os.write_string(3, self.ip)
|
|
os.write_map(4, self.clientEnv)
|
|
os.write_string(5, self.source)
|
|
os.write_int32(6, self.isRole)
|
|
|
|
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)
|
|
self.pid = ins.read_int32(2, default=self.pid)
|
|
self.ip = ins.read_string(3, default=self.ip)
|
|
self.clientEnv = ins.read_map(4)
|
|
self.source = ins.read_string(5, default=self.source)
|
|
self.isRole = ins.read_int32(6, default=self.isRole)
|
|
|
|
|
|
class ExchangeInfo(TafStruct):
|
|
"""积分兑换结果信息。"""
|
|
|
|
def __init__(self):
|
|
self.pid: int = 0
|
|
self.exchangeScore: int = 0
|
|
self.desc: str = ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.pid = ins.read_int32(1, default=self.pid)
|
|
self.exchangeScore = ins.read_int64(2, default=self.exchangeScore)
|
|
self.desc = ins.read_string(3, default=self.desc)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(1, self.pid)
|
|
os.write_int64(2, self.exchangeScore)
|
|
os.write_string(3, self.desc)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"pid": self.pid,
|
|
"exchange_score": self.exchangeScore,
|
|
"desc": self.desc,
|
|
}
|
|
|
|
|
|
class ExchangeActPreCondition(TafStruct):
|
|
"""兑换前置条件提示。"""
|
|
|
|
def __init__(self):
|
|
self.conditionType: int = 0
|
|
self.conditionParams: dict = {}
|
|
self.tip: str = ""
|
|
self.jumpUrl: str = ""
|
|
self.buttonDesc: str = ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.conditionType = ins.read_int32(0, default=self.conditionType)
|
|
self.conditionParams = ins.read_map(1)
|
|
self.tip = ins.read_string(2, default=self.tip)
|
|
self.jumpUrl = ins.read_string(3, default=self.jumpUrl)
|
|
self.buttonDesc = ins.read_string(4, default=self.buttonDesc)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.conditionType)
|
|
os.write_map(1, self.conditionParams)
|
|
os.write_string(2, self.tip)
|
|
os.write_string(3, self.jumpUrl)
|
|
os.write_string(4, self.buttonDesc)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"condition_type": self.conditionType,
|
|
"condition_params": dict(self.conditionParams),
|
|
"tip": self.tip,
|
|
"jump_url": self.jumpUrl,
|
|
"button_desc": self.buttonDesc,
|
|
}
|
|
|
|
|
|
class ScoreExchangePrizeResp(TafStruct):
|
|
"""webActUI.scoreExchangePrize 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.orderId: str = ""
|
|
self.exchangeInfo = ExchangeInfo()
|
|
self.actPreCondition = ExchangeActPreCondition()
|
|
|
|
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.orderId = ins.read_string(3, default=self.orderId)
|
|
self.exchangeInfo = ins.read_struct(4, ExchangeInfo) or self.exchangeInfo
|
|
self.actPreCondition = (
|
|
ins.read_struct(5, ExchangeActPreCondition) or self.actPreCondition
|
|
)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_int32(0, self.status)
|
|
os.write_string(1, self.msg)
|
|
os.write_string(3, self.orderId)
|
|
os.write_struct(4, self.exchangeInfo)
|
|
os.write_struct(5, self.actPreCondition)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"order_id": self.orderId,
|
|
"exchange_info": self.exchangeInfo.to_dict(),
|
|
"act_pre_condition": self.actPreCondition.to_dict(),
|
|
}
|
|
|
|
|
|
class UserPrizeRecordItem(TafStruct):
|
|
"""用户兑换记录项，字段来自 getUserPrizeRecords 实测响应。"""
|
|
|
|
def __init__(self):
|
|
self.recordId: int = 0
|
|
self.prizeName: str = ""
|
|
self.score: int = 0
|
|
self.exchangeTime: int = 0
|
|
self.prizeStatus: int = 0
|
|
self.prizeType: int = 0
|
|
self.orderId: str = ""
|
|
self.icon: str = ""
|
|
self.prizeId: int = 0
|
|
self.prizeItemId: int = 0
|
|
self.ext: dict = {}
|
|
self.exchangeDate: int = 0
|
|
|
|
@staticmethod
|
|
def _status_label(status: int) -> str:
|
|
if status == 0:
|
|
return "未发放"
|
|
if status == 1:
|
|
return "已发放"
|
|
return f"状态{status}"
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.recordId = ins.read_int64(0, default=self.recordId)
|
|
self.prizeName = ins.read_string(1, default=self.prizeName)
|
|
self.score = ins.read_int64(2, default=self.score)
|
|
self.exchangeTime = ins.read_int64(3, default=self.exchangeTime)
|
|
self.prizeStatus = ins.read_int32(4, default=self.prizeStatus)
|
|
self.prizeType = ins.read_int32(10, default=self.prizeType)
|
|
self.orderId = ins.read_string(12, default=self.orderId)
|
|
self.icon = ins.read_string(14, default=self.icon)
|
|
self.prizeId = ins.read_int64(16, default=self.prizeId)
|
|
self.prizeItemId = ins.read_int64(19, default=self.prizeItemId)
|
|
self.ext = ins.read_map(20)
|
|
self.exchangeDate = ins.read_int64(21, default=self.exchangeDate)
|
|
while True:
|
|
pos = ins.buf.tell()
|
|
_tag, dtype = ins.read_head()
|
|
if dtype == TafType.STRUCT_END:
|
|
ins.buf.seek(pos)
|
|
return
|
|
ins.skip_field(dtype)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
pass
|
|
|
|
@staticmethod
|
|
def read_list_item(ins: TafInputStream, _tag: int):
|
|
item = UserPrizeRecordItem()
|
|
item.read_from(ins)
|
|
_end_tag, dtype = ins.read_head()
|
|
if dtype != TafType.STRUCT_END:
|
|
raise ValueError(f"期望兑换记录 STRUCT_END，实际 0x{dtype:02x}")
|
|
return item
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"record_id": self.recordId,
|
|
"prize_name": self.prizeName,
|
|
"score": self.score,
|
|
"exchange_time": self.exchangeTime,
|
|
"exchange_date": self.exchangeDate,
|
|
"prize_status": self.prizeStatus,
|
|
"status_label": self._status_label(self.prizeStatus),
|
|
"order_id": self.orderId,
|
|
"icon": self.icon,
|
|
"prize_id": self.prizeId,
|
|
"prize_type": self.prizeType,
|
|
"prize_item_id": self.prizeItemId,
|
|
"ext": dict(self.ext),
|
|
}
|
|
|
|
|
|
class GetUserPrizeRecordsResp(TafStruct):
|
|
"""webActUI.getUserPrizeRecords 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.records: list[UserPrizeRecordItem] = []
|
|
|
|
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.records = ins.read_list(2, item_reader=UserPrizeRecordItem.read_list_item)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
pass
|
|
|
|
def to_dict(self) -> dict:
|
|
records = [item.to_dict() for item in self.records]
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"record_count": len(records),
|
|
"records": records,
|
|
}
|
|
|
|
|
|
class GetActTaskDetailReq(TafStruct):
|
|
"""webActUI.getActTaskDetail 请求。"""
|
|
|
|
def __init__(self):
|
|
self.userId = ActivityUserId()
|
|
self.actId: int = 0
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
os.write_struct(0, self.userId)
|
|
os.write_int32(1, self.actId)
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.userId = ins.read_struct(0, ActivityUserId) or self.userId
|
|
self.actId = ins.read_int32(1, default=self.actId)
|
|
|
|
|
|
class ActTaskPrizeInfo(TafStruct):
|
|
"""活动任务奖励项，刷新充值商品时只取展示需要字段。"""
|
|
|
|
def __init__(self):
|
|
self.actId: int = 0
|
|
self.taskId: int = 0
|
|
self.prizeId: int = 0
|
|
self.name: str = ""
|
|
self.count: int = 0
|
|
self.percentText: str = ""
|
|
self.extra: dict = {}
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.actId = ins.read_int64(0, default=self.actId)
|
|
self.taskId = ins.read_int64(1, default=self.taskId)
|
|
self.prizeId = ins.read_int64(2, default=self.prizeId)
|
|
self.name = ins.read_string(3, default=self.name)
|
|
self.count = ins.read_int64(4, default=self.count)
|
|
self.percentText = ins.read_string(9, default=self.percentText)
|
|
self.extra = ins.read_map(12)
|
|
while True:
|
|
pos = ins.buf.tell()
|
|
_tag, dtype = ins.read_head()
|
|
if dtype == TafType.STRUCT_END:
|
|
ins.buf.seek(pos)
|
|
return
|
|
ins.skip_field(dtype)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
pass
|
|
|
|
@staticmethod
|
|
def read_list_item(ins: TafInputStream, _tag: int):
|
|
item = ActTaskPrizeInfo()
|
|
item.read_from(ins)
|
|
_end_tag, dtype = ins.read_head()
|
|
if dtype != TafType.STRUCT_END:
|
|
raise ValueError(f"期望任务奖励 STRUCT_END，实际 0x{dtype:02x}")
|
|
return item
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"act_id": self.actId,
|
|
"task_id": self.taskId,
|
|
"prize_id": self.prizeId,
|
|
"name": self.name,
|
|
"count": self.count,
|
|
"percent_text": self.percentText,
|
|
"extra": dict(self.extra),
|
|
}
|
|
|
|
|
|
class ActTaskDetailItem(TafStruct):
|
|
"""活动任务项，字段位置来自 getActTaskDetail 实测响应。"""
|
|
|
|
def __init__(self):
|
|
self.actId: int = 0
|
|
self.taskId: int = 0
|
|
self.name: str = ""
|
|
self.taskStatus: int = 0
|
|
self.taskType: int = 0
|
|
self.limitType: int = 0
|
|
self.taskParams: str = ""
|
|
self.targetValue: str = ""
|
|
self.icon: str = ""
|
|
self.description: str = ""
|
|
self.prizes: list[ActTaskPrizeInfo] = []
|
|
self.taskUrl: str = ""
|
|
self.startTime: str = ""
|
|
self.endTime: str = ""
|
|
|
|
@staticmethod
|
|
def _extract_spu_id(text: str) -> str:
|
|
import urllib.parse
|
|
|
|
raw = str(text or "")
|
|
if not raw:
|
|
return ""
|
|
query = raw
|
|
if "?" in raw:
|
|
query = raw.split("?", 1)[1]
|
|
if "#" in query and "?" in query.split("#", 1)[1]:
|
|
query = query.split("#", 1)[1].split("?", 1)[1]
|
|
params = urllib.parse.parse_qs(query, keep_blank_values=True)
|
|
for key in ("spuId", "spu_id"):
|
|
value = params.get(key)
|
|
if value and value[0]:
|
|
return value[0]
|
|
for part in raw.replace("#", "&").split("&"):
|
|
if part.startswith("spuId="):
|
|
return urllib.parse.unquote(part.split("=", 1)[1])
|
|
return ""
|
|
|
|
def read_from(self, ins: TafInputStream):
|
|
self.actId = ins.read_int64(0, default=self.actId)
|
|
self.taskId = ins.read_int64(1, default=self.taskId)
|
|
self.name = ins.read_string(2, default=self.name)
|
|
self.taskStatus = ins.read_int32(3, default=self.taskStatus)
|
|
self.taskType = ins.read_int32(4, default=self.taskType)
|
|
self.limitType = ins.read_int32(5, default=self.limitType)
|
|
self.taskParams = ins.read_string(6, default=self.taskParams)
|
|
self.targetValue = ins.read_string(7, default=self.targetValue)
|
|
self.icon = ins.read_string(8, default=self.icon)
|
|
self.description = ins.read_string(9, default=self.description)
|
|
self.prizes = ins.read_list(11, item_reader=ActTaskPrizeInfo.read_list_item)
|
|
self.taskUrl = ins.read_string(12, default=self.taskUrl)
|
|
self.startTime = ins.read_string(25, default=self.startTime)
|
|
self.endTime = ins.read_string(26, default=self.endTime)
|
|
while True:
|
|
pos = ins.buf.tell()
|
|
_tag, dtype = ins.read_head()
|
|
if dtype == TafType.STRUCT_END:
|
|
ins.buf.seek(pos)
|
|
return
|
|
ins.skip_field(dtype)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
pass
|
|
|
|
@staticmethod
|
|
def read_list_item(ins: TafInputStream, _tag: int):
|
|
item = ActTaskDetailItem()
|
|
item.read_from(ins)
|
|
_end_tag, dtype = ins.read_head()
|
|
if dtype != TafType.STRUCT_END:
|
|
raise ValueError(f"期望任务 STRUCT_END，实际 0x{dtype:02x}")
|
|
return item
|
|
|
|
@property
|
|
def spu_id(self) -> str:
|
|
return self._extract_spu_id(self.taskUrl) or self._extract_spu_id(
|
|
self.taskParams
|
|
)
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"act_id": self.actId,
|
|
"task_id": self.taskId,
|
|
"name": self.name,
|
|
"task_status": self.taskStatus,
|
|
"task_type": self.taskType,
|
|
"limit_type": self.limitType,
|
|
"task_params": self.taskParams,
|
|
"target_value": self.targetValue,
|
|
"icon": self.icon,
|
|
"description": self.description,
|
|
"task_url": self.taskUrl,
|
|
"spu_id": self.spu_id,
|
|
"start_time": self.startTime,
|
|
"end_time": self.endTime,
|
|
"prizes": [item.to_dict() for item in self.prizes],
|
|
}
|
|
|
|
|
|
class GetActTaskDetailResp(TafStruct):
|
|
"""webActUI.getActTaskDetail 响应。"""
|
|
|
|
def __init__(self):
|
|
self.status: int = 0
|
|
self.msg: str = ""
|
|
self.tasks: list[ActTaskDetailItem] = []
|
|
|
|
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.tasks = ins.read_list(2, item_reader=ActTaskDetailItem.read_list_item)
|
|
|
|
def write_to(self, os: TafOutputStream):
|
|
pass
|
|
|
|
def to_dict(self) -> dict:
|
|
tasks = [item.to_dict() for item in self.tasks]
|
|
return {
|
|
"status": self.status,
|
|
"msg": self.msg,
|
|
"task_count": len(tasks),
|
|
"tasks": tasks,
|
|
}
|
|
|
|
|
|
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 = ""
|
|
self.extendInfo: 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)
|
|
self.extendInfo = ins.read_string(6, default=self.extendInfo)
|
|
|
|
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)
|
|
os.write_string(6, self.extendInfo)
|
|
|
|
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,
|
|
"extend_info": self.extendInfo,
|
|
}
|
|
|
|
|
|
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()
|