LongArticleAlgServer/routes/AccountArticleRank.py

"""
@author: luojunhui
"""
import json
import time

from uuid import uuid4

from applications.aliyunLog import AliyunArticleLog
from applications.functions import ArticleRank
from applications.functions import title_sim_v2_by_list
from applications.functions import get_article_title_url_list


def has_same(title, account_nickname, index_list=[1, 2]):
    """
    判断是否存储
    :param title:
    :param account_nickname:
    :param index_list: 历史已发布的文章需要屏蔽的位置
    :return:
    """
    account_title_list = get_article_title_url_list(
        account_nickname,
        index_list=index_list
    )
    sim_res = title_sim_v2_by_list(title, account_title_list)
    if sim_res:
        return True
    return False


class AccountArticleRank(object):
    """
    文章排序
    """

    def __init__(self, params, mysql_client):
        """
        :param params: 请求参数
        :param mysql_client: 数据库链接池
        """
        self.publishArticleList = None
        self.publishNum = None
        self.strategy = None
        self.ghId = None
        self.accountName = None
        self.accountId = None
        self.params = params
        self.mysql_client = mysql_client
        self.filter_list = []
        self.request_id = "alg-{}-{}".format(uuid4(), int(time.time()))
        self.logger = AliyunArticleLog(request_id=self.request_id, alg="ArticleRank")

    async def check_params(self):
        """
        校验参数
        :return:
        """
        try:
            self.accountId = self.params["accountId"]
            self.accountName = self.params["accountName"]
            self.ghId = self.params["ghId"]
            self.strategy = self.params["strategy"]
            self.publishNum = self.params["publishNum"]
            self.publishArticleList = [i for i in self.params["publishArticleList"] if not has_same(i['title'], self.accountName)]
            self.history_list = [i for i in self.params["publishArticleList"] if has_same(i['title'], self.accountName)]
            self.logger.log(
                code="1001",
                msg="参数校验成功",
                data=self.params
            )
            return None
        except Exception as e:
            response = {
                "msg": "params error",
                "info": "params check failed, params : {} is not correct".format(e),
                "code": 0,
            }
            self.logger.log(
                code="1002",
                msg="参数校验失败--{}".format(e),
                data=self.params
            )
            return response

    async def basic_rank(self):
        # 第一步把所有文章标题分为3组
        article_list1_ori = [i for i in self.publishArticleList if "【1】" in i['producePlanName']]
        article_list2_ori = [i for i in self.publishArticleList if "【2】" in i['producePlanName']]
        article_list3_ori = [i for i in self.publishArticleList if not i in article_list1_ori and not i in article_list2_ori]

        # 全局去重，保留优先级由  L1 --> L2 --> L3
        hash_map = {}

        article_list1 = []
        for i in article_list1_ori:
            title = i['title']
            if hash_map.get(title):
                continue
            else:
                article_list1.append(i)
                hash_map[title] = 1

        article_list2 = []
        for i in article_list2_ori:
            title = i['title']
            if hash_map.get(title):
                continue
            else:
                article_list2.append(i)
                hash_map[title] = 2

        article_list3 = []
        for i in article_list3_ori:
            title = i['title']
            if hash_map.get(title):
                continue
            else:
                article_list3.append(i)
                hash_map[title] = 1

        # 第二步对article_list1， article_list3按照得分排序, 对article_list2按照播放量排序
        if article_list1:
            rank1 = ArticleRank().rank(
                account_list=[self.accountName],
                text_list=[i['title'] for i in article_list1]
            )
            score_list1 = rank1[self.accountName]['score_list']
            ranked_1 = []
            for index, value in enumerate(score_list1):
                obj = article_list1[index]
                obj['score'] = value + 1000
                ranked_1.append(obj)
            ranked_1 = sorted(ranked_1, key=lambda x:x['score'], reverse=True)
        else:
            ranked_1 = []
        # rank2
        if article_list2:
            for item in article_list2:
                item['score'] = 100
            ranked_2 = sorted(article_list2, key=lambda x:x['crawlerViewCount'], reverse=True)
        else:
            ranked_2 = []

        # rank3
        if article_list3:
            rank3 = ArticleRank().rank(
                account_list=[self.accountName],
                text_list=[i['title'] for i in article_list3]
            )
            score_list3 = rank3[self.accountName]['score_list']
            ranked_3 = []
            for index, value in enumerate(score_list3):
                obj = article_list3[index]
                obj['score'] = value
                ranked_3.append(obj)
            ranked_3 = sorted(ranked_3, key=lambda x:x['score'], reverse=True)
        else:
            ranked_3 = []
        self.logger.log(
            code="1004",
            msg="去重排序完成",
            data={
                "rank1": ranked_1,
                "rank2": ranked_2,
                "rank3": ranked_3
            }
        )
        return ranked_1, ranked_2, ranked_3

    async def rank_v1(self):
        """
        Rank Version 1
        :return:
        """
        try:
            ranked_1, ranked_2, ranked_3 = await self.basic_rank()
            try:
                L = []
                if ranked_1:
                    L.append(ranked_1[0])
                    if ranked_2:
                        L.append(ranked_2[0])
                else:
                    if ranked_2:
                        if len(ranked_2) > 1:
                            for i in ranked_2[:2]:
                                L.append(i)
                        else:
                            L.append(ranked_2[0])
                for item in ranked_3:
                    L.append(item)

                result = {
                    "accountId": self.accountId,
                    "accountName": self.accountName,
                    "ghId": self.ghId,
                    "strategy": self.strategy,
                    "publishNum": self.publishNum,
                    "rank_list": L[:self.publishNum],
                    "filter_list": self.filter_list
                }
                self.logger.log(
                    code=1006,
                    msg="rank successfully",
                    data=result
                )
                response = {"status": "Rank Success", "data": result, "code": 1}
            except Exception as e:
                result = {
                    "accountId": self.accountId,
                    "accountName": self.accountName,
                    "ghId": self.ghId,
                    "strategy": self.strategy,
                    "publishNum": self.publishNum,
                    "rank_list": self.publishArticleList[: self.publishNum],
                    "filter_list": self.filter_list
                }
                self.logger.log(
                    code=1007,
                    msg="rank failed because of {}".format(e),
                    data=result
                )
                response = {"status": "Rank Fail", "data": result, "code": 1}
            return response
        except:
            result = {"code": 2, "info": "account is not exist"}
            return result

    async def rank_v2(self):
        """
        Rank Version 2
        :return:
        """
        return await self.rank_v1()

    async def rank_v3(self):
        """
        Rank Version 3
        :return:
        """
        return await self.rank_v1()

    async def rank_v4(self):
        """
        Rank Version 4
        :return:
        """
        return await self.rank_v1()

    async def rank_v5(self):
        """
        Rank Version 5
        :return:
        """
        return await self.rank_v1()

    async def choose_strategy(self):
        """
        选择排序策略
        :return:
        """
        match self.strategy:
            case "ArticleRankV1":
                self.logger.log(
                    code="1003",
                    msg="命中排序策略1"
                )
                return await self.rank_v1()
            case "ArticleRankV2":
                self.logger.log(
                    code="1003",
                    msg="命中排序策略2"
                )
                return await self.rank_v2()
            case "ArticleRankV3":
                self.logger.log(
                    code="1003",
                    msg="命中排序策略3"
                )
                return await self.rank_v3()
            case "ArticleRankV4":
                self.logger.log(
                    code="1003",
                    msg="命中排序策略4"
                )
                return await self.rank_v4()
            case "ArticleRankV5":
                self.logger.log(
                    code="1003",
                    msg="命中排序策略5"
                )
                return await self.rank_v5()

    async def deal(self):
        """
        Deal Function
        :return:
        """
        error_params = await self.check_params()
        if error_params:
            return error_params
        else:
            for i in self.history_list:
                i['filterReason'] = "历史已发布文章"
                self.filter_list.append(i)
            return await self.choose_strategy()