robots-auto-action/toutiao/self_sign.py

"""
app: 头条极速版:
desc:完整签到
"""
import base64
import time

import yaml

from func.action_func import del_key_vague
from scene.oprator.atom_data import single_click_by_text, single_click_by_control, click_pic, stop_app, start_app
from task.task_job import callback_task
from tools import loggerKit, redis_client

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']

"""
头条极速版

开宝箱刷视频
"""


def self_sign(task_id, 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 null"
            }

            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": "指令被用户终止"
            }

            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) and perform_action_result == "success":
            action1_id = int(round(time.time() * 1000))
            """
            发送第1条指令
            首页点击任务
            """

            action1_dict = single_click_by_control(action1_id, target_app="com.ss.android.article.lite",
                                                   target_version="9.7.0.0",
                                                   package_name="com.ss.android.article.lite",
                                                   control_id="com.ss.android.article.lite:id/kp", timeout=30)

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

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

            return action1_dict

        step1 = redis_client.get(f"{device_id}_{perform_action_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) and perform_action_result == "success":
            loggerKit.info("设备:{0}, action1_id_mem:{1}", device_id, int(last_action_id))

            action2_id = int(round(time.time() * 1000))
            """
            发送第2条指令
            点击开宝箱
            """
            with open("pic/boxes.png", "rb") as image_file:
                encoded_string = base64.b64encode(image_file.read())
            action2_dict = click_pic(action2_id, target_app="com.ss.android.article.lite", target_version="9.7.0.0",
                                     package_name="com.ss.android.article.lite", pic_base64=encoded_string)

            redis_client.set(device_id + "operate", action2_id)
            redis_client.set(f"{device_id}_{action2_id}_step2", "1")
            redis_client.delete(f"{device_id}_{action2_id}_step1")

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

            return action2_dict

        step2 = redis_client.get(f"{device_id}_{perform_action_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) and perform_action_result == "success":
            loggerKit.info("设备:{0}, action2_id_mem:{1}", device_id, int(last_action_id))

            action3_id = int(round(time.time() * 1000))
            """
            发送第3条指令
            看视频再领金币
            """
            with open("pic/video.png", "rb") as image_file:
                encoded_string = base64.b64encode(image_file.read())
            action3_dict = click_pic(action3_id, target_app="com.ss.android.article.lite", target_version="9.7.0.0",
                                     package_name="com.ss.android.article.lite", pic_base64=encoded_string)

            redis_client.set(device_id + "operate", action3_id)
            redis_client.set(f"{device_id}_{action3_id}_step3", "1")
            redis_client.delete(f"{device_id}_{action3_id}_step2")

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

            return action3_dict

        while True:
            action3_id_mem = redis_client.get(device_id + "operate")
            step3 = redis_client.get(f"{device_id}_{perform_action_id}_step3")
            if step3 is not None and int(step3) == 1 and action3_id_mem is not None and int(perform_action_id) == int(
                    action3_id_mem) and perform_action_result == "success":
                loggerKit.info("设备:{0}, action3_id_mem:{1}", device_id, int(action3_id_mem))

                action4_id = int(round(time.time() * 1000))
                """
                发送第4条指令
                点击领取成功
                """
                with open("pic/draw.png", "rb") as image_file:
                    encoded_string = base64.b64encode(image_file.read())
                action4_dict = click_pic(action4_id, target_app="com.ss.android.article.lite", target_version="9.7.0.0",
                                         package_name="com.ss.android.article.lite", pic_base64=encoded_string)

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

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

                return action4_dict

            """
            出现逛街最多则跳出循环
            """
            with open("pic/video.png", "rb") as image_file:
                encoded_string = base64.b64encode(image_file.read())
            if encoded_string is not None:
                break
            else:
                action4_id_mem = redis_client.get(device_id + "operate")
                step4 = redis_client.get(f"{device_id}_{perform_action_id}_step4")
                if step4 is not None and int(step4) == 1 and action4_id_mem is not None and int(
                        perform_action_id) == int(
                    action4_id_mem) and perform_action_result == "success":
                    loggerKit.info("设备:{0}, action4_id_mem:{1}", device_id, int(action4_id_mem))

                    action5_id = int(round(time.time() * 1000))
                    """
                    发送第5条指令
                    看视频再领金币
                    """
                    with open("pic/video.png", "rb") as image_file:
                        encoded_string = base64.b64encode(image_file.read())

                    action5_dict = click_pic(action5_id, target_app="com.ss.android.article.lite",
                                             target_version="9.7.0.0",
                                             package_name="com.ss.android.article.lite", pic_base64=encoded_string)

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

                    loggerKit.info("设备:{0}, action3_id:{1}", device_id, action5_id)
                    return action5_dict

                """
                开始看视频
                """
                time.sleep(38)

        """
        停止app
        """
        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) and perform_action_result == "success":
            loggerKit.info("设备:{0}, action10_id_mem:{1}", device_id, int(last_action_id))

            action6_id = int(round(time.time() * 1000))
            """
            停止指令
            停止app
            """
            action6_dict = stop_app(action6_id, target_app="com.ss.android.article.lite",
                                    target_version="9.7.0.0",
                                    package_name="com.ss.android.article.lite")

            redis_client.delete(f"{device_id}_step4")
            del_key_vague(device_id)
            loggerKit.info("设备:{0}, action6_dict:{1}", device_id, action6_dict)

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

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

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

        action0_dict = start_app(action0_id, target_app="com.ss.android.article.lite",
                                 target_version="9.7.0.0",
                                 package_name="com.ss.android.article.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