update code

models/ban_user.py

@@ -60,6 +60,20 @@ class BanUser(db.Model):
             await cls.unban(user_qq)
             return False
 
+    @classmethod
+    async def is_super_ban(cls, user_qq: int) -> bool:
+        """
+        说明：
+            判断用户是否被ban
+        参数：
+            :param user_qq: qq号
+        """
+        user = await cls.query.where((cls.user_qq == user_qq)).gino.first()
+        if not user:
+            return False
+        if user.ban_level == 10:
+            return True
+
     @classmethod
     async def ban(cls, user_qq: int, ban_level: int, duration: int) -> bool:
         """

models/bilibili_sub.py

@@ -0,0 +1,249 @@
+from services.log import logger
+from services.db_context import db
+from datetime import datetime
+from typing import Optional, List
+
+
+class BilibiliSub(db.Model):
+    __tablename__ = "bilibili_sub"
+
+    id = db.Column(db.Integer(), primary_key=True)
+    sub_id = db.Column(db.Integer(), nullable=False)
+    sub_type = db.Column(db.String(), nullable=False)
+    # 订阅用户
+    sub_users = db.Column(db.String(), nullable=False)
+    # 直播
+    live_short_id = db.Column(db.Integer())
+    live_status = db.Column(db.Integer)
+    # 主播/UP
+    uid = db.Column(db.BigInteger())
+    uname = db.Column(db.String())
+    latest_video_created = db.Column(db.BigInteger())  # 视频上传时间
+    dynamic_upload_time = db.Column(db.BigInteger(), default=0)  # 动态发布时间
+    # 番剧
+    season_name = db.Column(db.String())
+    season_id = db.Column(db.Integer())
+    season_current_episode = db.Column(db.String())
+    season_update_time = db.Column(db.DateTime())
+
+    _idx1 = db.Index("bilibili_sub_idx1", "sub_id", "sub_type", unique=True)
+
+    @classmethod
+    async def add_bilibili_sub(
+        cls,
+        sub_id: int,
+        sub_type: str,
+        sub_user: str,
+        *,
+        live_short_id: Optional[int] = None,
+        live_status: Optional[int] = None,
+        dynamic_upload_time: Optional[int] = None,
+        uid: Optional[int] = None,
+        uname: Optional[str] = None,
+        latest_video_created: Optional[int] = None,
+        season_name: Optional[str] = None,
+        season_id: Optional[int] = None,
+        season_current_episode: Optional[str] = None,
+        season_update_time: Optional[datetime] = None,
+    ) -> bool:
+        """
+        说明：
+            添加订阅
+        参数：
+            :param sub_id: 订阅名称，房间号，番剧号等
+            :param sub_type: 订阅类型
+            :param sub_user: 订阅此条目的用户
+            :param live_short_id: 直接短 id
+            :param live_status: 主播开播状态
+            :param dynamic_upload_time: 主播/UP最新动态时间
+            :param uid: 主播/UP uid
+            :param uname: 用户名称
+            :param latest_video_created: 最新视频上传时间
+            :param season_name: 番剧名称
+            :param season_id: 番剧 season_id
+            :param season_current_episode: 番剧最新集数
+            :param season_update_time: 番剧更新时间
+        """
+        try:
+            async with db.transaction():
+                query = (
+                    await cls.query.where(cls.sub_id == sub_id)
+                    .with_for_update()
+                    .gino.first()
+                )
+                sub_user = sub_user if sub_user[-1] == "," else f"{sub_user},"
+                if query:
+                    if sub_user not in query.sub_users:
+                        sub_users = query.sub_users + sub_user
+                        await query.update(sub_users=sub_users).apply()
+                else:
+                    sub = await cls.create(
+                        sub_id=sub_id, sub_type=sub_type, sub_users=sub_user
+                    )
+                    await sub.update(
+                        live_short_id=live_short_id
+                        if live_short_id
+                        else sub.live_short_id,
+                        live_status=live_status if live_status else sub.live_status,
+                        dynamic_upload_time=dynamic_upload_time
+                        if dynamic_upload_time
+                        else sub.dynamic_upload_time,
+                        uid=uid if uid else sub.uid,
+                        uname=uname if uname else sub.uname,
+                        latest_video_created=latest_video_created
+                        if latest_video_created
+                        else sub.latest_video_created,
+                        season_update_time=season_update_time
+                        if season_update_time
+                        else sub.season_update_time,
+                        season_current_episode=season_current_episode
+                        if season_current_episode
+                        else sub.season_current_episode,
+                        season_id=season_id if season_id else sub.season_id,
+                        season_name=season_name if season_name else sub.season_name,
+                    ).apply()
+                return True
+        except Exception as e:
+            logger.info(f"bilibili_sub 添加订阅错误 {type(e)}: {e}")
+        return False
+
+    @classmethod
+    async def delete_bilibili_sub(cls, sub_id: int, sub_user: str) -> bool:
+        """
+        说明：
+            删除订阅
+        参数：
+            :param sub_id: 订阅名称
+            :param sub_user: 删除此条目的用户
+        """
+        try:
+            async with db.transaction():
+                query = (
+                    await cls.query.where(
+                        (cls.sub_id == sub_id) & (cls.sub_users.contains(sub_user))
+                    )
+                    .with_for_update()
+                    .gino.first()
+                )
+                if not query:
+                    return False
+                await query.update(
+                    sub_users=query.sub_users.replace(f"{sub_user},", "")
+                ).apply()
+                if not query.sub_users.strip():
+                    await query.delete()
+                return True
+        except Exception as e:
+            logger.info(f"bilibili_sub 删除订阅错误 {type(e)}: {e}")
+        return False
+
+    @classmethod
+    async def get_sub(cls, sub_id: int) -> Optional["BilibiliSub"]:
+        """
+        说明：
+            获取订阅对象
+        参数：
+            :param sub_id: 订阅 id
+        """
+        return await cls.query.where(cls.sub_id == sub_id).gino.first()
+
+    @classmethod
+    async def get_sub_data(cls, id_: str) -> List["BilibiliSub"]:
+        """
+        获取 id_ 订阅的所有内容
+        :param id_: id
+        """
+        query = cls.query.where(cls.sub_users.contains(id_))
+        return await query.gino.all()
+
+    @classmethod
+    async def update_sub_info(
+        cls,
+        sub_id: int,
+        *,
+        live_short_id: Optional[int] = None,
+        live_status: Optional[int] = None,
+        dynamic_upload_time: Optional[int] = None,
+        uid: Optional[int] = None,
+        uname: Optional[str] = None,
+        latest_video_created: Optional[int] = None,
+        season_name: Optional[str] = None,
+        season_id: Optional[int] = None,
+        season_current_episode: Optional[str] = None,
+        season_update_time: Optional[datetime] = None,
+    ) -> bool:
+        """
+        说明：
+            更新订阅信息
+        参数：
+            :param sub_id: 订阅名称，房间号，番剧号等
+            :param live_short_id: 直接短 id
+            :param live_status: 主播开播状态
+            :param dynamic_upload_time: 主播/UP最新动态时间
+            :param uid: 主播/UP uid
+            :param uname: 用户名称
+            :param latest_video_created: 最新视频上传时间
+            :param season_name: 番剧名称
+            :param season_id: 番剧 season_id
+            :param season_current_episode: 番剧最新集数
+            :param season_update_time: 番剧更新时间
+        """
+        try:
+            async with db.transaction():
+                sub = (
+                    await cls.query.where(cls.sub_id == sub_id)
+                    .with_for_update()
+                    .gino.first()
+                )
+                if sub:
+                    await sub.update(
+                        live_short_id=live_short_id
+                        if live_short_id is not None
+                        else sub.live_short_id,
+                        live_status=live_status
+                        if live_status is not None
+                        else sub.live_status,
+                        dynamic_upload_time=dynamic_upload_time
+                        if dynamic_upload_time is not None
+                        else sub.dynamic_upload_time,
+                        uid=uid if uid is not None else sub.uid,
+                        uname=uname if uname is not None else sub.uname,
+                        latest_video_created=latest_video_created
+                        if latest_video_created is not None
+                        else sub.latest_video_created,
+                        season_update_time=season_update_time
+                        if season_update_time is not None
+                        else sub.season_update_time,
+                        season_current_episode=season_current_episode
+                        if season_current_episode is not None
+                        else sub.season_current_episode,
+                        season_id=season_id if season_id is not None else sub.season_id,
+                        season_name=season_name
+                        if season_name is not None
+                        else sub.season_name,
+                    ).apply()
+                    return True
+        except Exception as e:
+            logger.info(f"bilibili_sub 更新订阅错误 {type(e)}: {e}")
+        return False
+
+    @classmethod
+    async def get_all_sub_data(
+        cls,
+    ) -> "List[BilibiliSub], List[BilibiliSub], List[BilibiliSub]":
+        """
+        说明：
+            分类获取所有数据
+        """
+        live_data = []
+        up_data = []
+        season_data = []
+        query = await cls.query.gino.all()
+        for x in query:
+            if x.sub_type == "live":
+                live_data.append(x)
+            if x.sub_type == "up":
+                up_data.append(x)
+            if x.sub_type == "season":
+                season_data.append(x)
+        return live_data, up_data, season_data

models/group_member_info.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 
 from services.db_context import db
-from typing import List
+from typing import List, Optional
 
 
 class GroupInfoUser(db.Model):
@@ -13,6 +13,7 @@ class GroupInfoUser(db.Model):
     belonging_group = db.Column(db.BigInteger(), nullable=False)
     user_join_time = db.Column(db.DateTime(), nullable=False)
     nickname = db.Column(db.Unicode())
+    uid = db.Column(db.BigInteger())
 
     _idx1 = db.Index("info_group_users_idx1", "user_qq", "belonging_group", unique=True)
 
@@ -141,3 +142,33 @@ class GroupInfoUser(db.Model):
             if user.nickname:
                 return user.nickname
         return ""
+
+    @classmethod
+    async def get_group_member_uid(cls, user_qq: int, belonging_group: int) -> Optional[str]:
+        query = cls.query.where(
+            (cls.user_qq == user_qq) & (cls.belonging_group == belonging_group)
+        )
+        user = await query.gino.first()
+        _max_uid = cls.query.where((cls.user_qq == 114514) & (cls.belonging_group == 114514)).with_for_update()
+        _max_uid_user = await _max_uid.gino.first()
+        _max_uid = _max_uid_user.uid
+        if not user or not user.uid:
+            all_user = await cls.query.where(cls.user_qq == user_qq).gino.all()
+            for x in all_user:
+                if x.uid:
+                    return x.uid
+            else:
+                if not user:
+                    await GroupInfoUser.add_member_info(user_qq, belonging_group, '', datetime.min)
+                    user = await cls.query.where(
+                        (cls.user_qq == user_qq) & (cls.belonging_group == belonging_group)
+                    ).gino.first()
+                await user.update(
+                    uid=_max_uid + 1,
+                ).apply()
+                await _max_uid_user.update(
+                    uid=_max_uid + 1,
+                ).apply()
+
+        return user.uid if user and user.uid else None
+

models/omega_pixiv_illusts.py

@@ -0,0 +1,138 @@
+from typing import Optional, List
+from datetime import datetime
+from services.db_context import db
+
+
+class OmegaPixivIllusts(db.Model):
+    __tablename__ = "omega_pixiv_illusts"
+    id = db.Column(db.Integer(), primary_key=True)
+    pid = db.Column(db.BigInteger(), nullable=False)
+    uid = db.Column(db.BigInteger(), nullable=False)
+    title = db.Column(db.String(), nullable=False)
+    uname = db.Column(db.String(), nullable=False)
+    nsfw_tag = db.Column(db.Integer(), nullable=False)
+    width = db.Column(db.Integer(), nullable=False)
+    height = db.Column(db.Integer(), nullable=False)
+    tags = db.Column(db.String(), nullable=False)
+    url = db.Column(db.String(), nullable=False)
+    created_at = db.Column(db.DateTime(timezone=True))
+    updated_at = db.Column(db.DateTime(timezone=True))
+
+    _idx1 = db.Index("omega_pixiv_illusts_idx1", "pid", "url", unique=True)
+
+    @classmethod
+    async def add_image_data(
+            cls,
+            pid: int,
+            title: str,
+            width: int,
+            height: int,
+            url: str,
+            uid: int,
+            uname: str,
+            nsfw_tag: int,
+            tags: str,
+            created_at: datetime,
+            updated_at: datetime,
+    ):
+        """
+        说明：
+            添加图片信息
+        参数：
+            :param pid: pid
+            :param title: 标题
+            :param width: 宽度
+            :param height: 长度
+            :param url: url链接
+            :param uid: 作者uid
+            :param uname: 作者名称
+            :param nsfw_tag: nsfw标签, 0=safe, 1=setu. 2=r18
+            :param tags: 相关tag
+            :param created_at: 创建日期
+            :param updated_at: 更新日期
+        """
+        if not await cls.check_exists(pid):
+            await cls.create(
+                pid=pid,
+                title=title,
+                width=width,
+                height=height,
+                url=url,
+                uid=uid,
+                uname=uname,
+                nsfw_tag=nsfw_tag,
+                tags=tags,
+            )
+            return True
+        return False
+
+    @classmethod
+    async def query_images(
+            cls,
+            keywords: Optional[List[str]] = None,
+            uid: Optional[int] = None,
+            pid: Optional[int] = None,
+            nsfw_tag: Optional[int] = 0,
+            num: int = 100
+    ) -> List[Optional["OmegaPixivIllusts"]]:
+        """
+        说明：
+            查找符合条件的图片
+        参数：
+            :param keywords: 关键词
+            :param uid: 画师uid
+            :param pid: 图片pid
+            :param nsfw_tag: nsfw标签, 0=safe, 1=setu. 2=r18
+            :param num: 获取图片数量
+        """
+        if nsfw_tag is not None:
+            query = cls.query.where(cls.nsfw_tag == nsfw_tag)
+        else:
+            query = cls.query
+        if keywords:
+            for keyword in keywords:
+                query = query.where(cls.tags.contains(keyword))
+        elif uid:
+            query = query.where(cls.uid == uid)
+        elif pid:
+            query = query.where(cls.uid == pid)
+        query = query.order_by(db.func.random()).limit(num)
+        return await query.gino.all()
+
+    @classmethod
+    async def check_exists(cls, pid: int) -> bool:
+        """
+        说明：
+            检测pid是否已存在
+        参数：
+            :param pid: 图片PID
+        """
+        query = await cls.query.where(cls.pid == pid).gino.all()
+        return bool(query)
+
+    @classmethod
+    async def get_keyword_num(cls, tags: List[str] = None) -> "int, int, int":
+        """
+        说明：
+            获取相关关键词(keyword, tag)在图库中的数量
+        参数：
+            :param tags: 关键词/Tag
+        """
+        query = cls.query
+        if tags:
+            for tag in tags:
+                query = query.where(cls.tags.contains(tag))
+        count = len(await query.where(cls.nsfw_tag == 0).gino.all())
+        setu_count = len(await query.where(cls.nsfw_tag == 1).gino.all())
+        r18_count = len(await query.where(cls.nsfw_tag == 2).gino.all())
+        return count, setu_count, r18_count
+
+    @classmethod
+    async def get_all_pid(cls) -> List[int]:
+        """
+        说明：
+            获取所有图片PID
+        """
+        data = await cls.query.gino.all()
+        return [x.pid for x in data]
+

models/pixiv.py

@@ -1,6 +1,5 @@
 from typing import Optional, List
 from services.db_context import db
-import asyncio
 
 
 class Pixiv(db.Model):
@@ -24,18 +23,19 @@ class Pixiv(db.Model):
 
     @classmethod
     async def add_image_data(
-            cls,
-            pid: int,
-            title: str,
-            width: int,
-            height: int,
-            view: int,
-            bookmarks: int,
-            img_url: str,
-            img_p: str,
-            uid: int,
-            author: str,
-            tags: str,
+        cls,
+        pid: int,
+        title: str,
+        width: int,
+        height: int,
+        view: int,
+        bookmarks: int,
+        img_url: str,
+        img_p: str,
+        uid: int,
+        author: str,
+        tags: str,
+        nws
     ):
         """
         说明：
@@ -65,7 +65,7 @@ class Pixiv(db.Model):
                 img_p=img_p,
                 uid=uid,
                 author=author,
-                is_r18=True if 'R-18' in tags else False,
+                is_r18=True if "R-18" in tags else False,
                 tags=tags,
             )
             return True
@@ -97,44 +97,45 @@ class Pixiv(db.Model):
         说明：
             获取所有PID
         """
-        pid = []
-        query = await cls.query.gino.all()
-        for image in query:
-            if image.pid not in pid:
-                pid.append(image.pid)
-        return pid
+        query = await cls.query.select("pid").gino.first()
+        pid = [x[0] for x in query]
+        return list(set(pid))
 
     # 0：非r18  1：r18  2：混合
     @classmethod
     async def query_images(
         cls,
-        keyword: Optional[List[str]] = None,
+        keywords: Optional[List[str]] = None,
         uid: Optional[int] = None,
         pid: Optional[int] = None,
-        r18: int = 0,
+        r18: Optional[int] = 0,
+        num: int = 100
     ) -> List[Optional["Pixiv"]]:
         """
         说明：
             查找符合条件的图片
         参数：
-            :param keyword: 关键词
+            :param keywords: 关键词
             :param uid: 画师uid
             :param pid: 图片pid
             :param r18: 是否r18，0：非r18  1：r18  2：混合
+            :param num: 查找图片的数量
         """
         if r18 == 0:
-            query = await cls.query.where(cls.is_r18 == False).gino.all()
+            query = cls.query.where(cls.is_r18 == False)
         elif r18 == 1:
-            query = await cls.query.where(cls.is_r18 == True).gino.all()
+            query = cls.query.where(cls.is_r18 == True)
         else:
-            query = await cls.query.gino.all()
-        if keyword:
-            query = [x for x in query if set(x.tags.split(',')) > set(keyword)]
+            query = cls.query
+        if keywords:
+            for keyword in keywords:
+                query = query.where(cls.tags.contains(keyword))
         elif uid:
-            query = [x for x in query if x.uid == uid]
+            query = query.where(cls.uid == uid)
         elif pid:
-            query = [x for x in query if x.pid == pid]
-        return query
+            query = query.where(cls.uid == pid)
+        query = query.order_by(db.func.random()).limit(num)
+        return await query.gino.all()
 
     @classmethod
     async def check_exists(cls, pid: int, img_p: str) -> bool:
@@ -151,41 +152,18 @@ class Pixiv(db.Model):
         return bool(query)
 
     @classmethod
-    async def get_keyword_num(cls, keyword: List[str]) -> "int, int":
+    async def get_keyword_num(cls, tags: List[str] = None) -> "int, int":
         """
         说明：
             获取相关关键词(keyword, tag)在图库中的数量
         参数：
-            :param keyword: 关键词/Tag
+            :param tags: 关键词/Tag
         """
-        query = await cls.query.gino.all()
-        i = int(len(query) / 200)
-        mod = len(query) % 200
-        tasks = []
-        start = 0
-        end = 200
-        count = 0
-        r18_count = 0
-        for _ in range(i):
-            tasks.append(asyncio.ensure_future(split_query_list(query[start: end], keyword)))
-            start += 200
-            end += 200
-        if mod:
-            tasks.append(asyncio.ensure_future(split_query_list(query[end:], keyword)))
-        result = await asyncio.gather(*tasks)
-        for x, j in result:
-            count += x
-            r18_count += j
-        # query = [x for x in query if set(x.tags.split(',')) > set(keyword)]
-        # r18_count = len([x for x in query if x.is_r18])
+        query = cls.query
+        if tags:
+            for tag in tags:
+                query = cls.query.where(cls.tags.contains(tag))
+        count = len(await query.where(cls.is_r18 == False).gino.all())
+        r18_count = len(await query.where(cls.is_r18 == True).gino.all())
         return count, r18_count
 
-
-async def split_query_list(query: List['Pixiv'], keyword: List[str]) -> 'int, int':
-    return await asyncio.get_event_loop().run_in_executor(None, _split_query_list, query, keyword)
-
-
-def _split_query_list(query: List['Pixiv'], keyword: List[str]) -> 'int, int':
-    query = [x for x in query if set(x.tags.split(',')) > set(keyword)]
-    r18_count = len([x for x in query if x.is_r18])
-    return len(query) - r18_count, r18_count

models/russian_user.py

@@ -12,6 +12,10 @@ class RussianUser(db.Model):
     fail_count = db.Column(db.Integer(), default=0)
     make_money = db.Column(db.Integer(), default=0)
     lose_money = db.Column(db.Integer(), default=0)
+    winning_streak = db.Column(db.Integer(), default=0)
+    losing_streak = db.Column(db.Integer(), default=0)
+    max_winning_streak = db.Column(db.Integer(), default=0)
+    max_losing_streak = db.Column(db.Integer(), default=0)
 
     _idx1 = db.Index("russian_group_users_idx1", "user_qq", "group_id", unique=True)
 
@@ -52,12 +56,28 @@ class RussianUser(db.Model):
             if not user:
                 user = await cls.create(user_qq=user_qq, group_id=group_id)
             if itype == "win":
+                _max = (
+                    user.max_winning_streak
+                    if user.max_winning_streak > user.winning_streak + 1
+                    else user.winning_streak + 1
+                )
                 await user.update(
                     win_count=user.win_count + 1,
+                    winning_streak=user.winning_streak + 1,
+                    losing_streak=0,
+                    max_winning_streak=_max
                 ).apply()
             elif itype == "lose":
+                _max = (
+                    user.max_losing_streak
+                    if user.max_losing_streak > user.losing_streak + 1
+                    else user.losing_streak + 1
+                )
                 await user.update(
                     fail_count=user.fail_count + 1,
+                    losing_streak=user.losing_streak + 1,
+                    winning_streak=0,
+                    max_losing_streak=_max,
                 ).apply()
             return True
         except Exception:

models/setu.py

@@ -72,17 +72,19 @@ class Setu(db.Model):
                 (cls.local_id == local_id) & (cls.is_r18 == flag)
             ).gino.first()
         if r18 == 0:
-            query = await cls.query.where(cls.is_r18 == False).gino.all()
+            query = cls.query.where(cls.is_r18 == False)
         elif r18 == 1:
-            query = await cls.query.where(cls.is_r18 == True).gino.all()
+            query = cls.query.where(cls.is_r18 == True)
         else:
-            query = await cls.query.gino.all()
+            query = cls.query
         if tags:
-            query = [x for x in query if set(x.tags.split(",")) > set(tags)]
-        return query
+            for tag in tags:
+                query = query.where(cls.tags.contains(tag) | cls.title.contains(tag) | cls.author.contains(tag))
+        query = query.order_by(db.func.random()).limit(50)
+        return await query.gino.all()
 
     @classmethod
-    async def get_image_count(cls, r18: int = 0):
+    async def get_image_count(cls, r18: int = 0) -> int:
         """
         说明：
             查询图片数量

models/sign_group_user.py

@@ -41,7 +41,17 @@ class SignGroupUser(db.Model):
         )
 
     @classmethod
-    async def get_all_impression(cls, belonging_group: int) -> "list, list":
+    async def sign(cls, user: "SignGroupUser", impression: float, checkin_time_last: datetime):
+        await user.update(
+            checkin_count=user.checkin_count + 1,
+            checkin_time_last=checkin_time_last,
+            impression=user.impression + impression,
+            add_probability=0,
+            specify_probability=0,
+        ).apply()
+
+    @classmethod
+    async def get_all_impression(cls, belonging_group: int) -> "list, list, list":
         """
         说明：
             获取该群所有用户 id 及对应 好感度