async def main():
start_time = time.time()
lock_key = "EXE_RECORD_RAFFLE"
if not await redis_cache.set_if_not_exists(
lock_key, value=1, timeout=60 * 3):
logging.info("RECORD_RAFFLE Another proc is Running. Now exit.")
await redis_cache.close()
return
await objects.connect()
x_node_redis = await gen_x_node_redis()
try:
await sync_guard(x_node_redis)
await sync_raffle(x_node_redis)
await sync_anchor(x_node_redis)
except Exception as e:
logging.error(f"{e}\n{traceback.format_exc()}")
# tears down.
await x_node_redis.close()
await objects.close()
await redis_cache.delete(lock_key)
await redis_cache.set(key="LT_RAFFLE_DB_UPDATE_TIME", value=time.time())
await redis_cache.close()
logging.info(f"RECORD_RAFFLE done! cost: {time.time() - start_time:.3f}.")
async def run(self):
hbe = None
small_hb_task = None
hbx_index = 1
while True:
is_living = await self.get_live_room_status(self.room_id)
if not is_living:
hbe = None
self.room_id = await self.find_living_room()
if small_hb_task:
small_hb_task.cancel()
small_hb_task = None
if self.room_id is None:
await asyncio.sleep(60 * 5)
continue
user: LTUser = await queries.get_lt_user_by_uid(self.user_id)
if not user:
logging.error(f"User {self.user_id} 认证过期，需要重新登录！")
break
api = BiliPrivateApi(req_user=user)
if hbe is None:
hbe = await api.storm_heart_e(self.room_id)
small_hb_task = asyncio.create_task(self.heartbeat_small(api))
await asyncio.sleep(hbe.heartbeat_interval)
continue
response = await api.storm_heart_x(hbx_index, hbe, self.room_id)
logging.info(f"storm_heart_x: {response}")
hbx_index += 1
if hbx_index > 7:
break
await asyncio.sleep(hbe.heartbeat_interval)
if small_hb_task is not None:
small_hb_task.cancel()
async def post_heartbeat(index, total, lt_user_obj):
cookie = lt_user_obj.cookie
r, data = await BiliApi.post_heartbeat_5m(cookie)
if not r:
logging.error(f"post_heartbeat_5m failed! msg: {data}")
return
r, data = await BiliApi.post_heartbeat_last_timest(cookie)
if not r:
logging.error(f"post_heartbeat_last_timest failed! msg: {data}")
return
if lt_user_obj.access_token:
r, data = await BiliApi.post_heartbeat_app(cookie=cookie, access_token=lt_user_obj.access_token)
if not r:
logging.error(f"post_heartbeat_app failed! msg: {data}")
await record_heart_beat(user_id=lt_user_obj.user_id)
logging.info(f"({index + 1}/{total}) Post heartbeat for {lt_user_obj} done.")
async def post_heartbeat(index, total, lt_user_obj):
cookie = lt_user_obj.cookie
r, data = await BiliApi.post_heartbeat_5m(cookie)
if not r:
logging.error(f"post_heartbeat_5m failed! msg: {data}")
return
r, data = await BiliApi.post_heartbeat_last_timest(cookie)
if not r:
logging.error(f"post_heartbeat_last_timest failed! msg: {data}")
return
r, data = await BiliApi.post_heartbeat_app(
cookie=cookie, access_token=lt_user_obj.access_token)
if not r:
logging.error(f"post_heartbeat_app failed! msg: {data}")
return
logging.info(
f"({index + 1}/{total}) Post heartbeat for {lt_user_obj.name}(uid: {lt_user_obj.DedeUserID}) done."
)
async def sync_anchor(redis):
raffles = await RedisAnchor.get_all(redis=redis)
for raffle in raffles:
raffle_id = raffle["id"]
room_id = raffle["room_id"]
prize_gift_name = raffle["award_name"]
prize_count = raffle["award_num"]
gift_name = "天选时刻"
gift_type = "ANCHOR"
users = await objects.execute(
BiliUser.select().where(BiliUser.real_room_id == room_id))
if users:
sender = users[0]
sender_name = sender.name
else:
flag, info = await BiliApi.get_live_room_info_by_room_id(
room_id=room_id)
if not flag:
logging.error(
f"ANCHOR_LOT_AWARD Cannot get live room info of {room_id}, reason: {info}."
)
continue
sender_uid = info["uid"]
flag, info = await BiliApi.get_user_info(uid=sender_uid)
if not flag:
logging.error(
f"ANCHOR_LOT_AWARD Cannot get get_user_info. uid: {sender_uid}, reason: {info}."
)
continue
sender_name = info["name"]
sender_face = info["face"]
sender = await BiliUser.get_or_update(uid=sender_uid,
name=sender_name,
face=sender_face)
logging.info(
f"ANCHOR_LOT_AWARD Sender info get from biliapi. {sender_name}({sender_uid})"
)
for i, user in enumerate(raffle["award_users"]):
inner_raffle_id = raffle_id * 10000 + i
winner_name = user["uname"]
winner_uid = user["uid"]
winner_face = user["face"]
winner = await BiliUser.get_or_update(uid=winner_uid,
name=winner_name,
face=winner_face)
r = await objects.create(Raffle,
id=inner_raffle_id,
room_id=room_id,
gift_name=gift_name,
gift_type=gift_type,
sender_obj_id=sender.id,
sender_name=sender_name,
winner_obj_id=winner.id,
winner_name=winner_name,
prize_gift_name=prize_gift_name,
prize_count=prize_count,
created_time=datetime.datetime.now() -
datetime.timedelta(seconds=600),
expire_time=datetime.datetime.now())
logging.info(f"Saved: Anchor:{raffle_id} {r.id}")
# notice
await notice_qq(
room_id=room_id,
winner_uid=winner_uid,
winner_name=winner_name,
prize_gift_name=prize_gift_name,
sender_name=sender_name,
)
await RedisAnchor.delete(raffle_id, redis=redis)