自动预约挂号脚本

这是一个用Python编写的预约和监控程序

main.py 全代码如下

# -*- coding: utf-8 -*-
import time
from schema import AddRegArgs, DeptSchForDocArgs, DocSchArgs, NumberSourceArgs
from api import Api


def appointment():
    """
    预约程序入口 用来测试是否能够正常预约
    :return:
    """
    api = Api()
    hospitals = api.get_hospital()
    print("请选择院区，输入院区前方序号")
    for index, hospital in enumerate(hospitals):
        print("{}):{}".format(index, hospital["aliasName"]))
    hospital_index = int(input("请输入院区序号："))
    hospital = hospitals[hospital_index]
    deptlist = api.get_deptlist(hospital["hosId"])
    print("请选择科室类别，输入科室类别前方序号")
    for index, deptclass in enumerate(deptlist):
        print("{}):{}".format(index, deptclass["deptName"]))
    deptclass_index = int(input("请输入科室类别序号："))
    deptclass = deptlist[deptclass_index]
    print("请选择科室，输入科室前方序号")
    for index, dept in enumerate(deptclass["deptList"]):
        print("{}):{}".format(index, dept["deptName"]))
    dept_index = int(input("请输入科室序号："))
    dept = deptclass["deptList"][dept_index]
    all_args = {**dept, **hospital}
    args = DeptSchForDocArgs(**all_args)
    doc_list = api.get_dept_sch_for_doc(args)
    print("请选择医生，输入医生前方序号")
    for index, doc in enumerate(doc_list):
        print("{}):{}".format(index, doc["docName"]))
    doc_index = int(input("请输入医生序号："))
    doc = doc_list[doc_index]
    all_args = {**doc, **dept, **hospital}
    args = DocSchArgs(**all_args)
    doc_schDate = api.get_doc_sch(args)
    # 筛选出可预约的时间
    doc_schDate = [
        x
        for x in doc_schDate
        if sum(
            [int(y["numRemain"]) > 0 and y["schState"] == "0" for y in x["schDateList"]]
        )
        > 0
    ]
    if len(doc_schDate) == 0:
        print("没有可预约的时间")
        return
    print("请选择日期，输入日期前方序号")
    for index, schDate in enumerate(doc_schDate):
        print("{}):{}".format(index, schDate["schDate"]))
    schDate_index = int(input("请输入日期序号："))
    schDate = doc_schDate[schDate_index]
    print("请选择时段,输入时段前方序号")
    for index, sch in enumerate(schDate["schDateList"]):
        print("{}):{}".format(index, sch["ampmName"]))
    sch_index = int(input("请输入时段序号:"))
    sch = schDate["schDateList"][sch_index]
    all_args = {**sch, **doc, **dept, **hospital}
    args = NumberSourceArgs(**all_args)
    appointment_time_list = api.get_number_source(args)
    print("请选择预约时间，输入预约时间前方序号")
    for index, timeDesc in enumerate(appointment_time_list):
        print("{}):{}".format(index, timeDesc["timeDesc"]))
    time_index = int(input("请输入预约时间序号："))
    appointment_time = appointment_time_list[time_index]
    pat_card_list = api.get_pat_card_list()
    print("请选择就诊卡，输入就诊卡前方序号")
    for index, pat_card in enumerate(pat_card_list):
        print("{}):{}".format(index, pat_card["name"]))
    pat_card_index = int(input("请输入就诊卡序号："))
    pat_card = pat_card_list[pat_card_index]
    all_args = {**sch, **doc, **dept, **hospital, **appointment_time, **pat_card}
    args = AddRegArgs(**all_args)
    response = api.add_reg(args)
    print(response)


def monitor():
    """
    监控程序入口 用来实际的抢挂号，每10S检测一次指定日期的指定医生的挂号情况
    :return:
    """
    api = Api()
    hospitals = api.get_hospital()
    print("请选择院区，输入院区前方序号")
    for index, hospital in enumerate(hospitals):
        print("{}):{}".format(index, hospital["aliasName"]))
    hospital_index = int(input("请输入院区序号："))
    hospital = hospitals[hospital_index]
    deptlist = api.get_deptlist(hospital["hosId"])
    print("请选择科室类别，输入科室类别前方序号")
    for index, deptclass in enumerate(deptlist):
        print("{}):{}".format(index, deptclass["deptName"]))
    deptclass_index = int(input("请输入科室类别序号："))
    deptclass = deptlist[deptclass_index]
    print("请选择科室，输入科室前方序号")
    for index, dept in enumerate(deptclass["deptList"]):
        print("{}):{}".format(index, dept["deptName"]))
    dept_index = int(input("请输入科室序号："))
    dept = deptclass["deptList"][dept_index]
    all_args = {**dept, **hospital}
    args = DeptSchForDocArgs(**all_args)
    doc_list = api.get_dept_sch_for_doc(args)
    print("请选择医生，输入医生前方序号")
    for index, doc in enumerate(doc_list):
        print("{}):{}".format(index, doc["docName"]))
    doc_index = int(input("请输入医生序号："))
    doc = doc_list[doc_index]
    all_args = {**doc, **dept, **hospital}
    args = DocSchArgs(**all_args)
    doc_schDate = api.get_doc_sch(args)
    print("请选择日期，输入日期前方序号")
    for index, schDate in enumerate(doc_schDate):
        print("{}):{}".format(index, schDate["schDate"]))
    schDate_index = int(input("请输入日期序号："))
    schDate = doc_schDate[schDate_index]
    while True:
        try:
            doc_schDate = api.get_doc_sch(args)
            # 筛选出可预约的时间
            doc_schDate = [
                x
                for x in doc_schDate
                if sum(
                    [
                        int(y["numRemain"]) > 0
                        and y["schState"] == "0"
                        and y["schDate"] == schDate
                        for y in x["schDateList"]
                    ]
                )
                > 0
            ]
            if len(doc_schDate) == 0:
                print("没有可预约的时间,等待10S后再次检测")
                time.sleep(10)
                continue

            for sch_index, sch in enumerate(schDate["schDateList"]):
                all_args = {**sch, **doc, **dept, **hospital}
                args = NumberSourceArgs(**all_args)
                appointment_time_list = api.get_number_source(args)
                for appointment_time_index, appointment_time in enumerate(
                    appointment_time_list
                ):
                    print("目标医师当前存在可预约时间，程序将尝试自动预约。如未收到预约成功消息，请前往预约界面手动预约。")
                    pat_card_list = api.get_pat_card_list()
                    pat_card = pat_card_list[0]
                    all_args = {
                        **sch,
                        **doc,
                        **dept,
                        **hospital,
                        **appointment_time,
                        **pat_card,
                    }
                    args = AddRegArgs(**all_args)
                    response = api.add_reg(args)
                    if response["code"] == "0":
                        print("预约成功！请在10分钟内前往订单页面付款并停止程序运行！若未及时停止程序运行，程序将在10分钟后自动重新预约！")
                        time.sleep(600)
                    else:
                        print("预约失败！请前往预约界面手动预约！")
                        time.sleep(600)
            print("等待10S后重新预约")
            time.sleep(10)
        except KeyboardInterrupt:
            print("程序已停止")
            break
        except Exception as e:
            print("程序异常，程序将在10S后重新预约")
            time.sleep(10)
            continue


if __name__ == "__main__":
    monitor()

说明

这段代码是一个用Python编写的预约和监控程序，主要用于通过API进行医院挂号预约。以下是代码的逐行翻译和解释：

代码功能简介

这个脚本定义了两个主要的功能：

1. appointment()：允许用户通过命令行界面选择医院、科室、医生和时间，进行手动预约。

2. monitor()：持续监控特定医生的可预约情况，并尝试自动预约。

appointment()函数

– 初始化API连接。

– 从API获取医院列表，并让用户选择一个医院。

– 根据所选医院获取科室列表，并让用户选择一个科室类别。

– 在选定的科室类别中选择具体的科室。

– 获取医生的时间表，并让用户选择一个医生。

– 显示医生可预约的日期，并让用户选择。

– 显示所选日期的具体时间段，并让用户选择。

– 获取可用的预约时间，让用户选择具体的时间点。

– 获取用户的就诊卡信息，并让用户选择一张就诊卡。

– 提交预约请求，并显示响应结果。

monitor()函数

– 类似于`appointment()`，但主要用于自动监控和预约。

– 在用户选择医生和日期后，程序每10秒检查一次可预约时间。

– 如果发现有可预约的时间，程序会尝试预约，并在成功后等待10分钟（防止重复预约），然后继续监控。

主程序入口

– 当脚本作为主程序运行时，它会启动`monitor()`函数，开始监控预约情况。

使用示例

这个脚本通过命令行交互，用户需要根据提示输入选择的序号来选择医院、科室、医生和时间。这适合需要频繁检查和预约医院挂号的场景，如抢购热门医生的挂号名额。

实现细节

– 脚本依赖于外部定义的`Api`类及其方法（如`get_hospital()`, `get_deptlist()`, `get_dept_sch_for_doc()`, `get_doc_sch()`, `get_number_source()`, `add_reg()`, `get_pat_card_list()`），这些方法需要与后端API正确交互。

– 使用了Python的字典展开语法`**`来传递参数。

– 使用了异常处理来管理运行时错误，并允许用户通过`Ctrl+C`中断程序。

如何启动运行：

将所有文件放在同一目录下， 启动运行main.py即可。

schema.py 文件内容如下

# -*- coding: utf-8 -*-
from pydantic import BaseModel
from typing import Union


class HospitalArgs(BaseModel):
    sysCode: Union[str, int] = "1001035"


class DeptListArgs(BaseModel):
    clinicalType: str = 1
    hosId: int
    sysCode: Union[str, int] = "1001035"


class DeptSchForDocArgs(BaseModel):
    clinicalType: str = 1
    deptCode: str = None
    deptId: str = deptCode
    specialtyId: str = None
    deptName: str
    visitingArea: str
    hosId: int
    recommendation: str = ""
    type: str = "order"
    source: int = 22
    sysCode: Union[str, int] = "1001035"

    def update(self):
        self.deptId = self.deptCode


class DocSchArgs(BaseModel):
    deptId: str
    deptName: str
    docId: str
    docName: str
    docTitle: str
    docPhoto: str
    hosId: int
    hosName: str
    type: str = "order"
    visitingArea: str = ""
    clinicalType: str = 1
    source: int = 22
    sysCode: Union[str, int] = "1001035"


class NumberSourceArgs(BaseModel):
    sysCode: Union[str, int] = "1001035"
    ampm: str
    categor: str
    docId: str
    deptId: str
    hosId: Union[str, int]
    schDate: str
    schId: str


class AddRegArgs(BaseModel):
    # key不一致参数
    disNo: str = None
    schDate: str = None
    patienId: str = None

    # 必须参数
    clinicalType: str = 1
    visitingArea: str = ""
    ampm: str
    appointmentNumber: str = disNo
    categor: str
    categorName: str
    deptId: str
    deptName: str
    docId: str
    docName: str
    endTime: str = ""
    extend: str = ""
    fee: str
    hosId: Union[str, int]
    hosName: str
    isFlexible: str = ""
    numId: str = ""
    patientId: str = patienId
    resDate: str = schDate
    schId: str
    source: int = 22
    startTime: str = ""
    sysCode: Union[str, int] = "1001035"
    thirdUserId: str = ""
    timeDesc: str
    timePoint: str = ""
    schQukCategor: str

    def update(self):
        self.appointmentNumber = self.disNo
        self.resDate = self.schDate
        self.patientId = self.patienId

说明

这段代码是一个Python模块，使用了`pydantic`库来定义几个数据模型（schemas），这些模型用于校验和管理数据的结构，主要用于医院预约系统的API调用。下面是对每个类的功能和属性的简要说明：

1. `HospitalArgs` 类

– 功能：定义获取医院数据时可能需要的参数。

– 属性：

  – `sysCode`：系统代码，可能是一个字符串或整数，预设为”1001035″。

2. `DeptListArgs` 类

– 功能：定义获取科室列表数据时需要的参数。

– 属性：

  – `clinicalType`：临床类型，预设为1。

  – `hosId`：医院ID，为整数。

  – `sysCode`：系统代码，同`HospitalArgs`。

3. `DeptSchForDocArgs` 类

– 功能：定义获取特定科室下医生的排班信息时需要的参数。

– 属性：

  – `clinicalType`：临床类型，预设为1。

  – `deptCode`：科室代码。

  – `deptId`：科室ID，初始与`deptCode`相同。

  – `specialtyId`：专业ID。

  – `deptName`：科室名称。

  – `visitingArea`：访问区域。

  – `hosId`：医院ID。

  – `recommendation`：推荐字段，预设为空字符串。

  – `type`：类型，预设为”order”。

  – `source`：来源，预设为22。

  – `sysCode`：系统代码。

  – `update()`：方法用于更新`deptId`。

4. `DocSchArgs` 类

– 功能：定义获取特定医生的详细排班信息时需要的参数。

– 属性：

  – 包含医生ID、姓名、职称、照片、所属医院ID和名称等。

  – 其他与`DeptSchForDocArgs`类似的字段如`clinicalType`, `type`, `source`等。

5. `NumberSourceArgs` 类

– 功能：定义获取某一具体时间段可预约号源信息时需要的参数。

– 属性：

  – `sysCode`：系统代码。

  – 其他相关预约详情如时间段（`ampm`）、分类（`categor`）、医生ID、科室ID、医院ID等。

6. `AddRegArgs` 类

– 功能：定义添加预约信息时需要的参数。

– 属性：

  – 包含预约具体的编号、分类、时间描述、患者ID等。

  – 其他预约细节如费用、是否灵活排班、开始时间和结束时间等。

  – `update()`：方法用于更新与预约编号、日期和患者ID相关的属性。

7.如何启动运行：

将所有文件放在同一目录下， 启动运行main.py即可。

api.py 文件内容如下

# -*- coding: utf-8 -*-

from hashlib import md5
import requests
import json
from Crypto.Cipher import DES
from Crypto.Util.Padding import pad
import time
import base64
from typing import Union
from ddddocr import DdddOcr
from configparser import ConfigParser
from schema import AddRegArgs, DeptSchForDocArgs, DocSchArgs, NumberSourceArgs

ocr = DdddOcr()

config = ConfigParser()
config.read("conf.ini", encoding="utf-8")


# 异常处理装饰器
def exception_handler(func):
    def wrapper(*args, **kwargs):
        for _ in range(3):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                print(f"函数{func.__name__}出现异常,异常关键词为：", e, "程序将在5S后重试")
                time.sleep(5)
        raise Exception("程序异常，重试运行后仍无法成功")

    return wrapper


class Api:
    def __init__(self):
        """
        初始化
        """
        print("初始化")
        # 读取配置
        self.sys_code = config.get("江苏省中医院", "sysCode")
        self.desKey = config.get("江苏省中医院", "desKey")
        self.phsId = config.get("江苏省中医院", "phsId")
        self.host = config.get("江苏省中医院", "host")
        self.token = config.get("江苏省中医院", "token", fallback=None)
        username = config.get("江苏省中医院", "username", fallback=None)
        password = config.get("江苏省中医院", "password", fallback=None)
        assert (self.token is not None) or (
            username is not None and password is not None
        ), "初始化，用户名/账号密码必传入其一"

        if not self.token:
            access_token = self.login(username, password)
            self.token = self.get_he_ren_token(access_token)
            config.set("江苏省中医院", "token", self.token)
            with open("conf.ini", "w", encoding="utf-8") as f:
                config.write(f)
        print("获取token成功")

    def encrypt(
        self,
        key: str = None,
        plaintext: str = None,
    ) -> str:
        """
        Encrypts a plaintext string using DES
        :param key:
        :param plaintext:
        :return:
        """
        if key is None:
            key = self.desKey
        if plaintext is None:
            plaintext = "1001035_" + str(int(time.time() * 1000))
        key = key.encode()
        plaintext = plaintext.encode()
        plaintext = pad(plaintext, DES.block_size)
        cipher = DES.new(key, DES.MODE_ECB)
        ciphertext = cipher.encrypt(plaintext)
        return base64.encodebytes(ciphertext).decode("utf-8").strip()

    @exception_handler
    def get_hospital(self) -> dict:
        """
          获取医区信息
        :return:院区信息
        """
        url = f"{self.host}/phs-base/getHospital"
        payload = json.dumps({"args": {"sysCode": self.sys_code}, "token": self.token})
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["result"]

    @exception_handler
    def get_deptlist(self, hos_id: Union[str, int]) -> dict:
        """
        获取科室列表
        :param hos_id:医院id
        :return: 科室列表
        """
        url = f"{self.host}/phs-reg/reg/getDeptList"
        payload = json.dumps(
            {
                "args": {
                    "clinicalType": "1",
                    "hosId": hos_id,
                    "sysCode": self.sys_code,
                },
                "token": self.token,
            }
        )
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["result"]["dataList"]

    @exception_handler
    def get_dept_sch_for_doc(self, args: DeptSchForDocArgs) -> dict:
        """
        获取医生信息
        :param args: 请求参数
        :return:
        """
        args.update()
        payload = {
            "args": {
                **args.dict(),
            },
            "token": self.token,
        }
        payload = json.dumps(payload)
        url = f"{self.host}/phs-reg/reg/getDeptSchForDoc"
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["result"]["schDocResultList"]

    @exception_handler
    def get_doc_sch(self, arg: DocSchArgs):
        """
        获取医生排班信息
        :param arg: 请求参数
        :return:
        """
        url = f"{self.host}/phs-reg/reg/getDocSch"

        payload = {"args": {**arg.dict()}, "token": self.token}
        payload = json.dumps(payload)
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["result"]["dataList"]

    @exception_handler
    def get_pat_card_list(self) -> list:
        """
        获取就诊卡，即挂号人信息
        :param args:请求参数
        :return:
        """
        payload = {
            "args": {
                "sysCode": self.sys_code,
            },
            "token": self.token,
        }
        payload = json.dumps(payload)
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        url = f"{self.host}/phs-base/relevantPatient/getPatCardList"
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["result"]

    @exception_handler
    def add_reg(self, args: AddRegArgs) -> dict:
        """
        提交订单
        :param args: 请求参数
        :return:
        """
        args.update()
        payload = json.dumps(
            {
                "args": {
                    **args.dict(),
                },
                "token": self.token,
            }
        )
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        url = f"{self.host}/phs-reg/reg/addReg"
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        print(response.text)
        return response.json()

    @exception_handler
    def get_verification_code(self) -> [str, str]:
        """
        获取验证码
        :return: srt:verifyCode,uniqueId
        """
        url = "http://wechat.jshtcm.com/cas-wechat/*.jsonRequest"
        payload = [{}]
        payload = json.dumps(payload)
        headers = {
            "Content-Type": "application/json",
            "X-Service-Id": "cas-wechat.smsService",
            "X-Service-Method": "getVerifyCodeInfo",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if response.status_code != 200:
            raise Exception("获取验证码失败")
        body = json.loads(response.json()["body"])
        verifyCode = body["verifyCode"]
        uniqueId = body["uniqueId"]
        verifyCode = base64.b64decode(verifyCode)
        verifyCode = ocr.classification(verifyCode)
        return verifyCode, uniqueId

    @exception_handler
    def login(self, username: Union[str, int], password: str) -> str:
        """
        登录
        :param username: 用户名/手机号
        :param password: 密码
        :return:accessToken
        """
        if type(username) == int:
            username = str(username)
        url = "http://wechat.jshtcm.com/cas-wechat/logon/login"
        verifyCode, uniqueId = self.get_verification_code()

        payload = json.dumps(
            {
                "tenantId": "hcn.jsszyy",
                "pwd": md5(password.encode()).hexdigest(),
                "forAccessToken": True,
                "rid": "patient",
                "verifyCode": verifyCode,
                "uniqueId": uniqueId,
                "loginName": username,
            }
        )
        headers = {
            "Content-Type": "application/json",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if response.json().get("code") != 200:
            raise Exception(
                response.json().get("msg") or "登录失败"
            )
        return response.json()["properties"]["accessToken"]

    @exception_handler
    def get_he_ren_token(self, x_access_token: str) -> str:
        """
        获取患者端token
        :param x_access_token:登陆后的token
        :return:token
        """
        url = "http://wechat.jshtcm.com/cas-wechat/*.jsonRequest"
        payload = json.dumps([{"openId": ""}])
        headers = {
            "X-Service-Method": "getHeRenToken",
            "X-Access-Token": x_access_token,
            "X-Service-Id": "cas-wechat.heRenService",
            "Content-Type": "application/json",
        }
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["body"]

    @exception_handler
    def get_number_source(self, args: NumberSourceArgs) -> dict:
        """
        获取预约时间
        :param args:
        :return:
        """
        payload = {
            "args": {
                **args.dict(),
            },
            "token": self.token,
        }
        payload = json.dumps(payload)
        headers = {
            "phsSign": self.encrypt(),
            "phsId": self.phsId,
            "Content-Type": "application/json",
        }
        url = f"{self.host}/phs-reg/reg/getNumberSource"
        response = requests.request("POST", url, headers=headers, data=payload)
        if (
            str(response.json().get("code")) != "200"
            and str(response.json().get("code")) != "0"
        ):
            print(response.json().get("message") or response.json().get("msg"))
        return response.json()["result"]


if __name__ == "__main__":
    api = Api()
    print(api.get_hospital())

说明

这个 Python 脚本定义了一个名为 Api 的类，该类封装了与医院系统的 API 交互功能，包括登录、获取医院信息、获取科室列表、获取医生排班信息、获取预约时间段等。这里对代码进行了逐行翻译和解释：

导入依赖和初始化对象

– 使用了 `pydantic` 模块来定义数据模型，`requests` 用于发送 HTTP 请求，`Crypto` 用于数据加密，`ddddocr` 用于验证码识别，`configparser` 用于配置文件管理。

– 实例化了验证码识别对象 `ocr` 和配置解析对象 `config`。

异常处理装饰器 `exception_handler`

– 定义了一个装饰器用于捕获和处理函数运行中的异常，如果函数运行失败，则在 5 秒后重试，最多重试 3 次。

Api 类的定义

– `__init__` 方法初始化 API 类，从配置文件读取必要的配置项，如系统代码、加密密钥等，并尝试登录获取 token。

– `encrypt` 方法使用 DES 加密算法加密文本。

API 交互方法

– `get_hospital`：获取医院信息。

– `get_deptlist`：根据医院 ID 获取科室列表。

– `get_dept_sch_for_doc`：获取指定科室的医生排班信息。

– `get_doc_sch`：获取指定医生的详细排班信息。

– `get_pat_card_list`：获取患者的就诊卡列表，用于挂号。

– `add_reg`：提交预约挂号请求。

– `get_verification_code`：获取验证码信息，用于登录验证。

– `login`：用户登录，需要处理验证码。

– `get_he_ren_token`：获取登录后的患者端 token，用于后续的 API 请求。

– `get_number_source`：获取指定条件下的可预约时间段。

主函数

– 实例化 Api类并调用 get_hospital方法打印医院信息。

注意点

– 此代码依赖于外部的配置文件 (conf.ini) 和网络 API。在运行之前，需要确保所有的配置都已正确设置，并且相关的网络 API 可用。

– 使用了 DES 加密和 Base64 编码来处理某些敏感信息。

– 采用了重试机制来处理网络请求中可能遇到的临时错误。

conf.ini 全文代码如下

[江XX中医院]
host = https://www.XXX.com.cn/
deskey = wewerwe
phsid = 4546554654
syscode = 15666666645
username = 账号
password = 密码
token = token

注意：项目配置文件，需要修改的配置是username,password,token。如果直接使用token则无需username,password，其他配置基本不需要改动。

如何启动运行：

将所有文件放在同一目录下， 启动运行main.py即可。