狗东 自动登录实现

重点在轨迹模拟

# !/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: JHC000abc@gmail.com
@file: login.py
@time: 2024/3/7 19:06
@desc:

"""
import json
import os
import numpy as np
import base64
from lxml import etree
import ddddocr
import requests
import time
from datetime import datetime
import random
import traceback

from DrissionPage import WebPage, ChromiumOptions, SessionOptions

from DrissionPage.common import Actions
from sdk.utils.util_img import MarkProcess


class DrissionPageDemo(object):
    """

    """

    def __init__(self):
        """

        """
        self.tree = None
        self.img = MarkProcess()

    def get_page(self, ua=None, incognito=False, time_out=60, headless=False, cookies=None):
        """

        :param ua:
        :param incognito:
        :return:
        """
        self.page = None
        co = ChromiumOptions()
        so = SessionOptions()
        # co.set_argument('--window-size', '800,600')
        co.auto_port(True)
        co.headless(headless)
        co.ignore_certificate_errors(True)
        co.mute(True)
        co.set_timeouts(page_load=time_out)

        self.page = WebPage()

        return self.page

    def get_normal_date(self, format='%Y-%m-%d %H:%M:%S'):
        """
        获取当前时间戳对应的标准时间
        :param format:
        :return:
        """
        return time.strftime(format, time.localtime())

    def get_diff_times(self):
        """

        :return:
        """
        time_stand = "2024-02-06 16:00:00"
        # 将时间字符串转换为datetime对象
        time_obj1 = datetime.strptime(time_stand, '%Y-%m-%d %H:%M:%S')
        time_now = self.get_normal_date()
        time_obj2 = datetime.strptime(time_now, '%Y-%m-%d %H:%M:%S')

        # 计算时间差并转换为毫秒
        delta = (time_obj1 - time_obj2).total_seconds() * 1000
        print(delta)
        return delta


    def read_img(self, file):
        """

        :param file:
        :return:
        """
        with open(file, 'rb') as f:
            target_bytes = f.read()
        return target_bytes

    def get_opt(self):
        """

        :return:
        """
        det = ddddocr.DdddOcr(det=False, ocr=False, show_ad=False)
        main_bytes = self.read_img("main.jpg")
        move_bytes = self.read_img("move.jpg")
        res = det.slide_match(move_bytes, main_bytes, simple_target=True)
        return res

    def _init_tree(self):
        """
        初始化xpath
        :return:
        """

        page_source = self.page.html
        tree = etree.HTML(page_source)
        self.tree = tree
        return self.tree

    def get_sloor_imgs(self):
        """

        :return:
        """
        main_pic = self.tree.xpath(
            '//div[@class="JDJRV-bigimg"]/img/@src')[0]
        move_pic = self.tree.xpath(
            '//div[@class="JDJRV-smallimg"]/img/@src')[0]

        with open("./main.jpg", "wb")as fp:
            fp.write(base64.b64decode(main_pic.split(",")[-1]))
        with open("./move.jpg", "wb")as fp:
            fp.write(base64.b64decode(move_pic.split(",")[-1]))

    def get_tracks(self, distance, seconds):
        """
        可以根据滑块的偏移，需要的时间（相对时间，并不是准确时间），以及要采用的缓动函数生成拖动轨迹。

        :param distance: 位移距离
        :param seconds: 时间秒
        :par
        am ease_func: 调用的缓慢函数
        :return:
        """

        def ease_in_out_bounce(x):
            return (1 - ease_out_bounce(1 - 2 * x)) / 2 if x < 0.5 else (1 + ease_out_bounce(2 * x - 1)) / 2

        def ease_out_quad(x):
            return 1 - (1 - x) * (1 - x)

        def ease_out_quart(x):
            return 1 - pow(1 - x, 4)

        def ease_out_expo(x):
            if x == 1:
                return 1
            else:
                return 1 - pow(2, -10 * x)

        def ease_out_bounce(x):
            n1 = 7.5625
            d1 = 2.75
            if x < 1 / d1:
                return n1 * x * x
            elif x < 2 / d1:
                x -= 1.5 / d1
                return n1 * x * x + 0.75
            elif x < 2.5 / d1:
                x -= 2.25 / d1
                return n1 * x * x + 0.9375
            else:
                x -= 2.625 / d1
                return n1 * x * x + 0.984375

        tracks = [0]
        offsets = [0]
        for t in np.arange(0.0, seconds, 0.1):
            offset = round(ease_out_expo(t / seconds) * distance)
            tracks.append(offset - offsets[-1])
            offsets.append(offset)
        return offsets, tracks

    def process(self):
        """

        :return:
        """
        self.get_page()
        self.page.get("https://passport.jd.com/uc/login?ltype=logout")
        self.page.run_js_loaded('document.getElementById("loginname").value = "18845876416";')
        self.page.run_js_loaded('document.getElementById("nloginpwd").value = "Fbb33879";')
        self.page.wait(1)
        self.page.run_js_loaded('document.getElementById("loginsubmit").click();')
        self.page.wait(1)

        ac = Actions(self.page)
        login_flag = False
        retry = 3
        while not login_flag and retry > 0:
            self._init_tree()
            try:
                self.get_sloor_imgs()
            except BaseException:
                pass
            else:
                opt = self.get_opt()
                print("opt", opt)

                distance = int(opt["target"][0] * 2 / 3) + 1
                move_list = self.get_tracks(distance, 5)
                move_list = [i for i in move_list[0] if i != 0]
                # print("distance",distance)
                # print(move_list[0])

                ac.hold('x://div[@class="JDJRV-slide-inner JDJRV-slide-btn"]')
                now_x = ac.curr_x
                now_y = ac.curr_y
                for ind, val in enumerate(move_list, 1):

                    ac.move_to((val + int(now_x), int(now_y)), duration=0.001)

                ac.wait(1)
                ac.release()
                if self.page.wait.url_change("https://www.jd.com/", timeout=3):
                    login_flag = True
                    cookie = ""
                    for name, value in self.page.cookies(as_dict=True, all_info=True).items():
                        cookie += f"{name}={value};"
                    print(cookie)
            finally:
                retry -= 1

        return login_flag

    def main(self):
        retry = 3
        flag = False
        while not flag and retry > 0:
            flag = self.process()
            print("flag", flag)
            retry -= 1
            if flag:
                return flag
            else:
                print("未登陆成功")
        print("刷新三次未登陆成功")
        return flag


if __name__ == '__main__':
    dp = DrissionPageDemo()
    dp.main()