robots-auto-action/douyin/douyin_train_home_comment.py

import random
import time

from func.action_func import del_key_vague
from task.task_job import callback_task
from tools import loggerKit, redis_client
from scene.oprator.atom_data import start_app, stop_app, continual_swipe_screen, single_click_by_control, swipe_screen, \
    get_text_by_control

import yaml

with open('config.yaml', 'r') as file:
    config = yaml.load(file, Loader=yaml.FullLoader)

extern_domain = config['bmp-cp']['extern_domain']

# 任务执行回调url
task_callback_url = extern_domain + config['bmp-cp']['task_callback_url']


# 抖音养号首页帖子评论（浏览30-50帖子 随机时长 对其评论进行观看）
# version 29.5.0
def douyin_spider(task_id, keyword, data):
    loggerKit.info('请求信息:{0}'.format(data))

    device_id = data.get("deviceID")
    perform_action_id = data.get("performActionId")
    result = data.get("result")

    if result is not None:
        """
        非首个指令
        """
        perform_action_result = result.get("performActionResult")
        if perform_action_result is None:
            return_dict = {
                "data": "",
                "code": -2,
                "message": "fail, performActionResult is null"
            }

            # 回调任务中心

            del_key_vague(device_id)

            callback_task(500, '指令执行失败', task_id, device_id, 0, None)

            return return_dict

        if perform_action_result == "failure":
            # 回调任务中心
            return_dict = {
                "data": "",
                "code": -2,
                "message": "fail, performActionResult is not success"
            }

            del_key_vague(device_id)

            callback_task(500, '任务执行失败', task_id, device_id, 0, None)

            return return_dict

        if perform_action_result == "stop":
            # 回调任务中心
            return_dict = {
                "data": "",
                "code": -2,
                "message": "fail, performActionResult is not success"
            }

            del_key_vague(device_id)

            callback_task(500, '指令被用户终止', task_id, device_id, 0, None)

            return return_dict

        # 每次操作完成后会将对应的操作唯一id存储到redis，并且返回给手机端 手机端下次带着上个操作id来执行下一个操作
        last_action_id = redis_client.get(device_id + "operate")
        step0 = redis_client.get(f"{device_id}_step0")
        if step0 is not None and int(step0) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            action1_id = int(round(time.time() * 1000))
            """
            发送第1条指令
            滑动15-20个视频 
            """

            swipe_count = random.randint(5, 10)

            action1_dict = continual_swipe_screen(action1_id,
                                                  package_name="com.ss.android.ugc.aweme.lite",
                                                  continuous_time_interval='3,10',
                                                  continuous_count=swipe_count)

            redis_client.set(device_id + "operate", action1_id)
            redis_client.set(f"{device_id}_step1", "1")
            redis_client.delete(f"{device_id}_step0")

            loggerKit.info("任务:{0}, action1_id,滑动15-20个视频", task_id)

            return action1_dict

        step1 = redis_client.get(f"{device_id}_step1")

        # 获取评论数量
        if step1 is not None and int(step1) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action1_id_mem:{1}", device_id, int(last_action_id))

            action2_id = int(round(time.time() * 1000))
            """
            发送第2条指令
            获取评论数量
            """

            action2_dict = get_text_by_control(action2_id, target_app="douyin", target_version="28.8.0",
                                               package_name="com.ss.android.ugc.aweme.lite",
                                               max_page='1',
                                               control_id="com.ss.android.ugc.aweme.lite:id/bez", timeout=5,
                                               item_index=0)
            redis_client.set(device_id + "operate", action2_id)
            redis_client.set(f"{device_id}_step2", "1")
            redis_client.delete(f"{device_id}_step1")

            loggerKit.info("任务:{0}, action2_id,获取评论数量", task_id)

            return action2_dict

        step2 = redis_client.get(f"{device_id}_step2")

        # 判断是否有评论数
        if step2 is not None and int(step2) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action1_id_mem:{1}", device_id, int(last_action_id))

            action3_id = int(round(time.time() * 1000))
            """
            发送第3条指令
            判断是否有评论数量
            """
            result_text = result.get("performActionText")
            if result_text is None or result_text == '':
                # 没有获取到评论数量，可能是在直播间页面。跳过此次点开评论操作
                # 向下滑动一次，再重新获取评论
                action2_dict = swipe_screen(action3_id,
                                            package_name="com.ss.android.ugc.aweme.lite",
                                            sleep_time=3)
                redis_client.set(device_id + "operate", action3_id)
                redis_client.delete(f"{device_id}_step2")
                redis_client.set(f"{device_id}_step1", "1")

                loggerKit.info("任务:{0}, action3_id,评论信息为:{1},不可点击再次滑动", task_id, result_text)

                return action2_dict

            elif result_text == '评论':
                # 没有对应的评论次数，仅有评论文案 证明该帖子无评论。跳过此次点开评论操作
                # 向下滑动一次，再重新获取评论
                action2_dict = swipe_screen(action3_id,
                                            package_name="com.ss.android.ugc.aweme.lite",
                                            sleep_time=3)
                redis_client.set(device_id + "operate", action3_id)
                redis_client.delete(f"{device_id}_step2")
                redis_client.set(f"{device_id}_step1", "1")

                loggerKit.info("任务:{0}, action3_id,评论信息为:{1},不可点击再次滑动", task_id, result_text)

                return action2_dict

            else:
                # 有对应评论，需要点击进去进行滑动
                action3_dict = single_click_by_control(action3_id, target_app="douyin", target_version="28.8.0",
                                                       package_name="com.ss.android.ugc.aweme.lite",
                                                       control_id="com.ss.android.ugc.aweme.lite:id/comment_container",
                                                       timeout=5)
                redis_client.set(device_id + "operate", action3_id)
                redis_client.set(f"{device_id}_step3", "1")
                redis_client.delete(f"{device_id}_step2")

                loggerKit.info("任务:{0}, action3_id,评论信息为:{1},点击评论框", task_id, result_text)

                return action3_dict

        # 进行滑动
        step3 = redis_client.get(f"{device_id}_step3")
        if step3 is not None and int(step3) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action3_id_mem:{1}", device_id, int(last_action_id))

            action4_id = int(round(time.time() * 1000))
            """
            发送第4条指令
            进行滑动
            """
            action4_dict = swipe_screen(action4_id,
                                        package_name="com.ss.android.ugc.aweme.lite",
                                        sleep_time=8)

            redis_client.set(device_id + "operate", action4_id)
            redis_client.set(f"{device_id}_step4", "1")
            redis_client.delete(f"{device_id}_step3")

            loggerKit.info("任务:{0}, action4_id,向上滑动一次", task_id)

            return action4_dict

        # 关闭评论框
        step4 = redis_client.get(f"{device_id}_step4")
        if step4 is not None and int(step4) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action4_id_mem:{1}", device_id, int(last_action_id))

            action5_id = int(round(time.time() * 1000))
            """
            发送第4条指令
            关闭评论框
            """

            action5_dict = single_click_by_control(action5_id, target_app="douyin", target_version="28.8.0",
                                                   package_name="com.ss.android.ugc.aweme.lite",
                                                   control_id="com.ss.android.ugc.aweme.lite:id/back_btn",
                                                   control_ids="com.ss.android.ugc.aweme.lite:id/back_btn,"
                                                               "com.ss.android.ugc.aweme.lite:id/back",
                                                   timeout=5)

            redis_client.set(device_id + "operate", action5_id)
            redis_client.set(f"{device_id}_step5", "1")
            redis_client.delete(f"{device_id}_step4")

            loggerKit.info("任务:{0}, action5_id,关闭评论", task_id)

            return action5_dict

        step5 = redis_client.get(f"{device_id}_step5")
        if step5 is not None and int(step5) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            action6_id = int(round(time.time() * 1000))
            """
            发送第6条指令
            滑动10-15个视频 
            """
            if perform_action_result == "invalid operation":
                # 回调任务中心
                return_dict = {
                    "data": "",
                    "code": -2,
                    "message": "fail, performActionResult is not success"
                }

                del_key_vague(device_id)

                callback_task(500, '任务执行失败,无法正常关闭评论框', task_id, device_id, 0, None)

                return return_dict

            swipe_count = random.randint(5, 10)

            action6_dict = continual_swipe_screen(action6_id,
                                                  package_name="com.ss.android.ugc.aweme.lite",
                                                  continuous_time_interval='3,10',
                                                  continuous_count=swipe_count)

            redis_client.set(device_id + "operate", action6_id)
            redis_client.set(f"{device_id}_step6", "1")
            redis_client.delete(f"{device_id}_step5")

            loggerKit.info("任务:{0}, action6_id,继续下滑10-15个视频", task_id)

            return action6_dict

        step6 = redis_client.get(f"{device_id}_step6")

        # 获取评论数量
        if step6 is not None and int(step6) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action6_id_mem:{1}", device_id, int(last_action_id))

            action7_id = int(round(time.time() * 1000))
            """
            发送第7条指令
            获取评论数量
            """

            action7_dict = get_text_by_control(action7_id, target_app="douyin", target_version="28.8.0",
                                               package_name="com.ss.android.ugc.aweme.lite",
                                               max_page='1',
                                               control_id="com.ss.android.ugc.aweme.lite:id/bez", timeout=5,
                                               item_index=0)
            redis_client.set(device_id + "operate", action7_id)
            redis_client.set(f"{device_id}_step7", "1")
            redis_client.delete(f"{device_id}_step6")

            loggerKit.info("任务:{0}, action7_id,获取评论数量", task_id)

            return action7_dict

        step7 = redis_client.get(f"{device_id}_step7")

        # 判断是否有评论数
        if step7 is not None and int(step7) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action1_id_mem:{1}", device_id, int(last_action_id))

            action8_id = int(round(time.time() * 1000))
            """
            发送第3条指令
            判断是否有评论数量
            """
            result_text = result.get("performActionText")
            if result_text is None or result_text == '':
                # 没有获取到评论数量，可能是在直播间页面。跳过此次点开评论操作
                # 向下滑动一次，再重新获取评论
                action8_dict = swipe_screen(action8_id,
                                            package_name="com.ss.android.ugc.aweme.lite",
                                            sleep_time=3)
                redis_client.set(device_id + "operate", action8_id)
                redis_client.delete(f"{device_id}_step7")
                redis_client.set(f"{device_id}_step6", "1")

                loggerKit.info("任务:{0}, action8_id,获取评论数量为:{1},继续向下滑动", task_id, result_text)

                return action8_dict

            elif result_text == '评论':
                # 没有对应的评论次数，仅有评论文案 证明该帖子无评论。跳过此次点开评论操作
                # 向下滑动一次，再重新获取评论
                action8_dict = swipe_screen(action8_id,
                                            package_name="com.ss.android.ugc.aweme.lite",
                                            sleep_time=3)
                redis_client.set(device_id + "operate", action8_id)
                redis_client.delete(f"{device_id}_step7")
                redis_client.set(f"{device_id}_step6", "1")

                loggerKit.info("任务:{0}, action8_id,获取评论数量为:{1},继续向下滑动", task_id, result_text)

                return action8_dict

            else:
                # 有对应评论，需要点击进去进行滑动
                action8_dict = single_click_by_control(action8_id, target_app="douyin", target_version="28.8.0",
                                                       package_name="com.ss.android.ugc.aweme.lite",
                                                       control_id="com.ss.android.ugc.aweme.lite:id/comment_container",
                                                       timeout=5)
                redis_client.set(device_id + "operate", action8_id)
                redis_client.set(f"{device_id}_step8", "1")
                redis_client.delete(f"{device_id}_step7")

                loggerKit.info("任务:{0}, action8_id,获取评论数量为:{1},点开评论", task_id, result_text)

                return action8_dict

        # 进行滑动
        step8 = redis_client.get(f"{device_id}_step8")
        if step8 is not None and int(step8) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action8_id_mem:{1}", device_id, int(last_action_id))

            action9_id = int(round(time.time() * 1000))
            """
            发送第9条指令
            进行滑动
            """
            action9_dict = swipe_screen(action9_id,
                                        package_name="com.ss.android.ugc.aweme.lite",
                                        sleep_time=8)

            redis_client.set(device_id + "operate", action9_id)
            redis_client.set(f"{device_id}_step9", "1")
            redis_client.delete(f"{device_id}_step8")

            loggerKit.info("任务:{0}, action9_id,滑动评论", task_id)

            return action9_dict

        # 关闭评论框
        step9 = redis_client.get(f"{device_id}_step9")
        if step9 is not None and int(step9) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action9_id_mem:{1}", device_id, int(last_action_id))

            if perform_action_result == "invalid operation":
                # 回调任务中心
                return_dict = {
                    "data": "",
                    "code": -2,
                    "message": "fail, performActionResult is not success"
                }

                del_key_vague(device_id)

                callback_task(500, '任务执行失败,无法正常关闭评论框', task_id, device_id, 0, None)

                return return_dict

            action10_id = int(round(time.time() * 1000))
            """
            发送第10条指令
            关闭评论框
            """
            action10_dict = single_click_by_control(action10_id, target_app="douyin", target_version="28.8.0",
                                                    package_name="com.ss.android.ugc.aweme.lite",
                                                    control_id="com.ss.android.ugc.aweme.lite:id/back_btn",
                                                    control_ids="com.ss.android.ugc.aweme.lite:id/back_btn,"
                                                                "com.ss.android.ugc.aweme.lite:id/back",
                                                    timeout=5)

            redis_client.set(device_id + "operate", action10_id)
            redis_client.set(f"{device_id}_step10", "1")
            redis_client.delete(f"{device_id}_step9")

            loggerKit.info("任务:{0}, action10_id,关闭评论", task_id)

            return action10_dict

        step10 = redis_client.get(f"{device_id}_step10")
        if step10 is not None and int(step10) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            action11_id = int(round(time.time() * 1000))
            """
            发送第11条指令
            滑动10-15个视频 
            """

            swipe_count = random.randint(5, 10)

            action11_dict = continual_swipe_screen(action11_id,
                                                   package_name="com.ss.android.ugc.aweme.lite",
                                                   continuous_time_interval='3,10',
                                                   continuous_count=swipe_count)

            redis_client.set(device_id + "operate", action11_id)
            redis_client.set(f"{device_id}_step11", "1")
            redis_client.delete(f"{device_id}_step10")

            loggerKit.info("任务:{0}, action11_id,继续滑动10-15", task_id)

            return action11_dict

        # 停止
        step11 = redis_client.get(f"{device_id}_step11")
        if step11 is not None and int(step11) == 1 and last_action_id is not None and int(perform_action_id) == int(
                last_action_id):
            loggerKit.info("设备:{0}, action11_id_mem:{1}", device_id, int(last_action_id))

            action12_id = int(round(time.time() * 1000))
            """
            发送第12条指令
            关闭
            """
            action12_dict = stop_app(action12_id, target_app="douyin", target_version="28.8.0",
                                     package_name="com.ss.android.ugc.aweme.lite", timeout=5)

            # redis_client.set(device_id + "operate", action12_id)
            # redis_client.set(f"{device_id}_step12", "1")
            # redis_client.delete(f"{device_id}_step11")

            loggerKit.info("任务:{0}, action12_id,停止app", task_id)

            del_key_vague(device_id)

            # 回调任务中心修改任务状态
            callback_task(None, None, task_id, device_id, 1, None)

            return action12_dict

    else:

        action0_id = int(round(time.time() * 1000))

        """
        启动指令
        启动app
        """

        action0_dict = start_app(action0_id, target_app="douyin", target_version="29.5.0",
                                 package_name="com.ss.android.ugc.aweme.lite")

        redis_client.set(device_id + "operate", action0_id)
        redis_client.set(f"{device_id}_step0", "1")
        redis_client.delete(f"{device_id}_step9")

        loggerKit.info("设备:{0}, action0_id:{1}", device_id, action0_id)

        return action0_dict

# 批量模糊删除缓存
# def del_key_vague(device_id):
#     # 批量模糊删除keys
#     keys = redis_client.match_pattern_prefix(device_id)
#     if len(keys) > 0:
#         # 需要判断是否有匹配的值, 没有的话会报错
#         for key in keys:
#             redis_client.delete(key)
#         loggerKit.info(f"clear {device_id} keys success...")
#     else:
#         loggerKit.info(f"{device_id} keys none ...")