很楠不爱3

这个屌丝很懒，什么也没留下！

热门标签

LAN RPA SAP自动化工具

作者：很楠不爱3 | 2024-05-31 08:08:55

踩

lan rpa

简介

SAP GUI 前台操作一次，即可完成SAP自动化批处理制作，支持alv录制
支持部分录制，即不需要录制完整事务码，可以在当前窗口执行部分重复操作
无需开发、配置、传输请求，如果操作熟练，就可以做到无需测试
录制完成后自动生成excel模板，保存好模板未来可以在任何sap环境继续使用
适用于SAP快捷登录、日常操作的简化、一次性数据的批处理、自动化测试

环境准备

下载LAN RPA

https://download.csdn.net/download/cylcylcylcylwo/88986702https://download.csdn.net/download/cylcylcylcylwo/88986702

执行LAN_RPA.exe文件

配置SAP账号密码

点击连接-编辑，会打开一个excel

填入描述（必须和sap gui里填写的描述一致，区分大小写），客户端，用户名，语言，密码

保存excel，点击连接-重读，读取配置的sap连接

配置SAP服务器参数

TCODE RZ11，输入 sapgui/user_scripting 设置值为TRUE，这个参数是启动SAP服务器gui script的意思。服务器重启后会失效，可以RZ10改，RZ10改完服务器重启不会失效。

配置SAP GUI通知

gui-选项

把脚本通知的勾去掉，这个配置的作用是执行脚本时不会发出gui 通知

上手

窗口管理

选择配置好的SAP连接，点击打开，即可快速打开连接，快速切换用户和语言

选中打开的会话，右键

双击：跳转到窗口，如果双击窗口没跳出来，再双击一次就可以了

新会话：打开新的窗口

关闭其他：关闭其他窗口

关闭全部：关闭全部窗口

开始录制（以下demo都存在网盘的模板文件夹，有些是录屏示例，有些已经在生产使用了，可直接执行）

选中一个会话，点击开始录制，跳转到sap窗口，在窗口输入事务码开始操作，操作结束之后点击结束录制即可完成制作。

注意工具只会根据输入的值生成模板，输入框的默认值如果要作为模板可输入字段，需要手工输入一下。

demo1 批量修改物料描述

选择一个系统，点击打开按钮，打开一个连接

打开后选中一个会话，点击开始录制，此时会自动跳转到SAP窗口。（如果选中的会话不是初始的tcode，可以点初始化按钮，还原到开始菜单）

输入 mm02 ，回车

输入物料号（注意mm02进来可能默认有物料号，此时需要重新输入，不能直接默认不输入物料直接回车进去），回车

选中视图，回车

修改描述，点击保存

操作完毕后点结束录制

此时会弹出一个文件保存框，输入文件名

保存后会自动打开一个excel模板文件

插入一行，填写描述（此步骤可选）

在字段页签，添加多行数据，其中doc_num表示条目数，如果有行项目，也通过doc_num把抬头和行项目关联

在表1 页签，添加多行数据（这里的表1是根据选择视图的弹出框自动生成的，作用是进来选中视图。如果视图位置不固定，可以在mm02保存默认视图，这次每次直接回车，不用再选视图）

保存excel，选中一个会话，点击执行按钮

此时会跳转到SAP窗口开始执行，执行完毕会自动打开excel，查看返回消息

demo2 批量下载alv报表

打开或者选择一个会话，点击开始录制

输入tcode，输入选择条件，执行

右键下载

输入文件名称（注意必须输入，默认带出来的删掉输一次），点击生成（或如果文件已存在就点击替换）

点结束录制

保存模板

填一下选择条件，和导出的文件名称

保存后点击执行

查看返回消息

demo3 CA01创建工艺路线

录制好的模板放在网盘的 demo 文件夹了，注意录制工序的时候录一行就好了

demo4 BP维护branch code

demo5 migo 批量创建物料凭证

demo6 批量冲销物料凭证

点击开始录制，输入se37

点击功能模块-执行-测试序列

输入

BAPI_GOODSMVT_CANCEL

BAPI_TRANSACTION_COMMIT

点击执行

输入物料凭证和年度，点击执行

点击返回

再点执行

点击结束录制，在弹出的excel填写数据

在字段页签填写需要冲销的物料凭证

在表1 页签按doc_num复制数据

保存excel，点击执行

demo7 SM30 带输入条件批量维护

正常录制，没什么特别的，模板在demo文件夹中

demo8 CS01创建BOM

demo9 va32 重新派生

录制的时候双击第一行行项目，在明细界面操作完之后，点击返回，然后点保存

在字段页签填入计划协议号

在表1 页签填入行，用doc_num和和计划协议对应，要处理几行就复制几行

对于科目分配页签位置不固定的解决方法：分场景录两个模板分别跑对应的数据，数据不分开用不同模板跑两次都可以，程序遇到找不到屏幕的情况会自动跳过不会卡住的

demo10 se38创建程序

以安装ZLAN_ACC为例，直接执行demo文件夹中的 se38安装zlan_acc.xlsx 即可

自动执行到这个界面，敲一下回车就完成安装了

如果要自己录制，也正常从se38进去录制即可

demo11 su01增加角色与参数文件

关于alv录制，和表一样只录入一行即可，有两种做法，推荐第二种

1.点击插入行按钮，在excel的sheet“表”中填入多行，会重复执行插入行和填写alv单元格的操作，如果此操作导致alv错位，建议每次插入一行，保存好了再进来插入一行

2.在空白行输入，如果有多行数据，每次执行会在下一行输入。

如果进来alv已有多行数据，需要翻页才能到空白行，可以在录制前选中alv一列筛选为空的数据，然后保存用户的缺省布局，这样每次进来从第一行开始都是alv可输入的空白行了

demo12 co01 创建生产订单

demo13 spro配置ewm Map Document Types from ERP System to EWM

此模板是每次进入spro配置一条，可以优化成：用一个窗口先打开spro，展开节点到指定位置，只录制添加新条目和返回，执行的时候也从已经展开节点的窗口执行，提升效率

demo14 FS00创建科目

详细解释

配置

点击配置-编辑

会打开配置文件

[general]
theme = yeti 主题
delay = 0 执行延时，如1则会等待1秒再执行下一步。
template_no_ask = False 录制结束时会根据填写的模板路径直接保存模板，不会弹出文件选择框
bar_total = False 是否在进度条显示总条目数和当前已完成的条目数
refresh_interval = 1000 会话自动刷新间隔。如果打开的窗口太多1秒可能刷新不完，在前台会看到卡顿，此时需要调大刷新间隔
log = False 是否输出日志，如果为True，则执行完之后会把日志输出到excel上

[path]
vbs = C:\Users\10042832\AppData\Roaming\SAP\SAP GUI\Scripts\SCRIPT6.VBS vbs文件位置
template = C:/Users/DELL/Desktop/temp/ca01.xlsx 模板位置

录制原理

根据输入的字段，生成对应excel的列。所以如果要录入字段有默认值，要做一次输入操作，不能直接回车跳过屏幕了
录制多行的表时只需要录制一行，如果要进入行明细界面操作，就双击录制的那一行，在明细界面操作完了之后点击返回按钮，不要直接保存，以返回判断双击操作结束了。
字段和表通过doc_num关联，表录制的时候录一行，如果要操作多行，在表页签复制doc_num为多行，即可按顺序操作表
录制的时候不要通过F4搜索帮助选择值，直接填入值，不要有无效操作，这样执行效率最高
录制过程如果想中断，点结束录制，然后在弹出的文件选择框点取消就可以了。点开始录制开始一次新的录制，点结束录制结束一次录制，如果点了结束录制没有保存模板文件，可以继续点结束录制重复生成模板，不需要重复录制
尽量录复杂的场景，把可能弹出的屏幕都录到，如果屏幕多录了执行的时候找不到屏幕会自动跳过，不会卡住
如果多次操作同一笔单据，有可能保存好了sap的锁还没释放，再进入会报错被自己锁定，可以修改操作等待时间，delay = 1，则每次操作都等1秒，放在后台慢慢执行吧

版本

v1.0

初始版本，后续考虑要不要录windows窗口和网页，以及多窗口的并发。有需求可以交流一下

v1.1

兼容了事务码录入了/n 的场景
增加了对abap编辑器的支持，直接粘贴代码吧，手敲代码的换行还没处理
增加了终止功能，可以在执行过程中中断了
修复了连接超时断开，会话没有刷新的问题

v1.2

网盘中只更新了exe文件，用exe文件覆盖之前下载的文件夹中的exe

修复读值漏了前导零的bug
增加了对alv的支持：参考demo11 su01增加角色与参数文件
1.编辑alv单元格
2.插入行

V1.3

增加对spro tree操作的支持(DEMO13)
忽略窗口最大化的操作（maximize），可以后台执行，不会因为SAP窗口最大化而在前台弹出

v1.4

修复了SAP下拉框没有匹配到excel值的bug（demo fsp0）
修复了SAP单选框没有匹配到excel值的bug（demo fs00）

v1.5

增加alv场景时，把table control换行逻辑改到了，修复table不能自动写到第二行的bug

v1.7

处理了录制结束没点返回，也没点保存的表操作场景。如只在sm30界面操作数据，不从tcode进去，也没有保存

代码


import datetime
import sys
import configparser
# from math import ceil
import webbrowser
 
import openpyxl
import pyperclip
from openpyxl.utils import get_column_letter
import xlsxwriter
import json
import numpy as np
import re
import time
from operator import methodcaller
 
# import eventlet
import subprocess
import os
import tkinter as tk
from tkinter import ttk, font, messagebox, filedialog
from tkinter import *
 
import pandas as pd
import ttkbootstrap
from ttkbootstrap.constants import *
from ttkbootstrap import Style
import pythoncom
# import pypiwin32
import win32com
from win32com import client
from win32com.client import Dispatch
 
class lan_rpa:
 
    def __init__(self):
        # 布局
        self.v_excption = 'lan stop'
        self.v_column = 0
        self.v_pady = 3
        self.v_padx = (10, 0)
 
        # 初始化sapgui
        self.__sapgui__start()
 
        # 变量
        self.v_filename_script = 'Script6.vbs'
        self.v_input = {}
        self.v_con_sel = {'desc': '', 'client': '', 'user': '', 'langu': ''}
        self.v_path_connection = 'connection.xlsx'
        self.v_path_config = 'config.ini'
 
        # 读连接
        self.__connection_read(True)
 
        # 读配置
        self.v_config = configparser.ConfigParser()
        self.v_config.read('config.ini')
 
    def __tkinter_main(self):
        root = tk.Tk()
        self.v_root = root
        root.wm_title('LAN RPA v1.2')
        # root.iconphoto(False, tk.PhotoImage(file=self.__resource_path('lan.png')))
        root.iconphoto(False, tk.PhotoImage(file='lan.png'))
        ttkbootstrap.Style().theme_use(self.v_config['general']['theme'])
 
        # 刷新事件
        root.after(self.v_config['general']['refresh_interval'], self.__session_refresh)
 
        # 布局
        frame1 = tk.Frame(root)  # 连接选择
        self.v_frame1 = frame1
        frame2 = tk.Frame(root)  # 会话列表+资源列表
        # paned = tk.PanedWindow(frame2, orient=tk.HORIZONTAL)  # 默认是左右分布的
        # paned.pack(fill=tk.BOTH, expand=1)  # 放到主窗口，上下左右缩放
        # frame_session = tk.Frame(paned)  # 会话列表
        # paned.add(frame_session)
        # frame_explorer = tk.Frame(paned)  # 资源列表
        # paned.add(frame_explorer)
        frame3 = tk.Frame(root)
        frame4 = tk.Frame(root)
        frame1.grid(row=0, column=0)
        frame2.grid(row=1, column=0, sticky='w', padx=self.v_padx, pady=10)
        frame3.grid(row=2, column=0, sticky='w', pady=10)
        frame4.grid(row=3, column=0, sticky='w', pady=10)
 
        # 菜单
        self.__menubar(root)
 
        # 连接选择
        self.__tkinter_frame_con()
        # 会话
        # self.__tkinter_frame_session(frame_session)
        self.__tkinter_frame_session(frame2)
        # # 资源浏览器
        # self.__tkinter_frame_explorer(frame_explorer)
 
        # 收藏列表
        # self.__tkinter_frame_favorite(frame3, root)
        self.__tkinter_frame_record(frame3)
        # 模板文件
        self.__tkinter_frame_file(frame4)
 
        # root.attributes('-topmost', True) #置顶
 
        # 居中显示
        dialog_width = 600
        dialog_height = 400
        # root.geometry('600x450')
        self.__window_geometry(dialog_width, dialog_height, root)
        root.mainloop()
 
    def __window_geometry(self, dialog_width, dialog_height, root):
        screenwidth = root.winfo_screenwidth()
        screenheight = root.winfo_screenheight()
        root.geometry("%dx%d+%d+%d" % (
            dialog_width, dialog_height, (screenwidth - dialog_width) / 2, (screenheight - dialog_height) / 2))
 
    def __tkinter_frame_record(self, frame3):
        # ttk.Button(frame3, text='刷新', command=self.__session_refresh).grid(row=0, column=self.__column_next(0),
        #                                                                    padx=self.v_padx)
        # tk.Button(frame3, text="刷新", command=self.__session_refresh).grid(row=0, column=self.__column_next(0),
        #                                                                   padx=self.v_padx)
        tk.Button(frame3, text="初始化", command=self.__session_init).grid(row=0, column=self.__column_next(0),
                                                                        padx=self.v_padx)
        tk.Button(frame3, text="开始录制", command=self.__record_start).grid(row=0, column=self.__column_next(),
                                                                         padx=self.v_padx)
        tk.Button(frame3, text="结束录制", command=self.__record_end).grid(row=0, column=self.__column_next(),
                                                                       padx=self.v_padx)
        frame_progressbar = tk.Frame(frame3)
        frame_progressbar.grid(row=0, column=self.__column_next(), padx=self.v_padx)
        self.v_progress_bar = ttk.Progressbar(frame_progressbar, length='100', mode="determinate", orient=tk.HORIZONTAL)
        self.v_progress_bar.grid(row=0)
        self.v_progress_count = tk.Label(frame_progressbar, text='')
        if self.v_config['general']['bar_total'] == 'True':
            self.v_progress_count.grid(row=1)
        self.v_progress_remain = tk.Label(frame3, text='')
        self.v_progress_remain.grid(row=0, column=self.__column_next())
 
    def __menubar(self, root):
        menubar = tk.Menu(root)
        menu_connection = tk.Menu(menubar)
        menu_config = tk.Menu(menubar)
        menu_about = tk.Menu(menubar)
 
        menu_connection.add_command(label='编辑', command=self.__connection_edit)
        menu_connection.add_command(label='重读', command=self.__connection_read)
 
        menu_config.add_command(label='主题', command=self.__win_theme)
        menu_config.add_command(label='编辑', command=self.__config_edit)
        menu_config.add_command(label='重读', command=self.__config_read)
 
        menu_about.add_command(label='帮助', command=self.__about_document)
        menu_about.add_command(label='交流', command=self.__about_conmunicate)  # 777363609
 
        menubar.add_cascade(label='连接', menu=menu_connection)
        menubar.add_cascade(label='配置', menu=menu_config)
        menubar.add_cascade(label='关于', menu=menu_about)
        root.config(menu=menubar)
 
    def __tkinter_frame_session(self, frame_session):
        # session info list treeview
        col_text = ('id', 'SID', '客户端', 'TCODE', '用户', '语言')
        col_name = ('id', 'sid', 'client', 'tcode', 'user', 'langu')
        col_width = ('50', '50', '50', '180', '110', '80')
        self.v_column_len = len(col_name)  # 记下tv展示的列，因为SystemSessionId和SessionNumber在后面两列
        xbar = ttk.Scrollbar(frame_session, orient='horizontal')  # 水平滚动条
        ybar = ttk.Scrollbar(frame_session, orient='vertical')  # 垂直滚动条
        xbar.pack(side=BOTTOM, fill=X)
        ybar.pack(side=RIGHT, fill=Y)
        tv = ttk.Treeview(frame_session, column=col_name, yscrollcommand=ybar.set, xscrollcommand=xbar.set,
                          show='headings')  # 隐藏首列
        self.v_tv_session = tv
        for i in range(len(col_text)):
            tv.column(col_name[i], width=col_width[i], anchor='n')
            tv.heading(col_name[i], text=col_text[i])
        ybar['command'] = self.v_tv_session.yview
        xbar['command'] = self.v_tv_session.xview
        tv.pack()
 
        # 数据
        # self.__session_refresh()
        # 右键菜单
        self.v_right_click_menu = tk.Menu(frame_session, tearoff=0)
        self.v_right_click_menu.add_command(label='新会话', command=self.__session_create)
        self.v_right_click_menu.add_command(label='关闭其他', command=self.__session_close_other)
        self.v_right_click_menu.add_command(label='关闭全部', command=self.__session_close_all)
        # self.v_right_click_menu.add_command(label='关闭后面', command=self.__session_close_back)
        # 绑定事件
        tv.bind('<Double-1>', self.__session_JumpForward)  # 双击左键跳转窗口
        tv.bind('<Button-3>', self.__session_right_click)  # 右键菜单
 
    # def __tkinter_connection_config(self):
    #     self.v_tkt_SAPConnectionConfig = tkt_SAPConnectionConfig()
    #     self.v_tkt_SAPConnectionConfig.open()
 
    def main(self):
 
        # self.__sapgui_init()
 
        # session处理
        # close_all()
        # return
 
        # logoin = self.login_init()
 
        self.__tkinter_main()
 
        return
 
    def __session_close_other(self):
        session_info = self.__session_info_selected()
        for connection in self.v_application.Connections:
            for session in connection.Sessions:
                if session.Busy == False:
                    if session.Info.SystemSessionId != session_info.SystemSessionId:
                        session.StartTransaction('ex')
                        break
                    if session.Info.SessionNumber != session_info.SessionNumber:
                        session.findById("wnd[0]").close()
                        continue
        # self.__session_refresh()
 
    def __session_close_all(self):
        for connection in self.v_application.Connections:
            for session in connection.Sessions:
                if session.Busy == False:
                    session.StartTransaction('ex')
                    break
        # self.__session_refresh()
 
    def __handle_connection_create(self):
        self.__connection_create(self.v_input['desc'].get(), self.v_input['client'].get(),
                                 self.v_input['user'].get(),
                                 self.v_input['password'], self.v_input['langu'].get())
 
        # self.__session_refresh()
 
    def __session_create(self):
        session = self.__session_selected()
        session.CreateSession()
 
    def __session_refresh(self):
        session_info_sel = self.__session_info_selected()  # 在刷新tv数据之前先取到选中的行，为了刷新之后重新选中会话
 
        self.v_session_info_list = self.__session_info_list_get()
        i = 1
        data_list = []
        if self.v_session_info_list:
            for session_info in self.v_session_info_list:
                try:
                    data_obj = (str(i), session_info.SystemName, session_info.Client, session_info.Transaction,
                                session_info.User,
                                session_info.Language,
                                session_info.SystemSessionId, session_info.SessionNumber)
                    data_list.append(data_obj)
                    i = i + 1
                except Exception as e:  # 可能窗口关闭，连接断开了
                    continue
 
        self.v_tv_session.delete(*self.v_tv_session.get_children())
        for i in range(len(data_list)):
            self.v_tv_session.insert('', 'end', values=data_list[i])
 
        # 选中会话
        try:
            for child in self.v_tv_session.get_children():
                if session_info_sel.SystemSessionId == self.v_tv_session.item(child)['values'][self.v_column_len] \
                        and session_info_sel.SessionNumber == self.v_tv_session.item(child)['values'][
                    self.v_column_len + 1]:
                    self.v_tv_session.selection_set(child)
                    break
        except Exception as e:
            if self.v_tv_session.get_children():
                self.v_tv_session.selection_set(self.v_tv_session.get_children()[0])  # 默认选中第一个窗口
 
        # 继续刷新
        self.v_root.after(self.v_config['general']['refresh_interval'], self.__session_refresh)
 
    def __on_focus_in(self, event):
        pass
        # self.__session_list_refresh()
 
    def __session_right_click(self, event):
        row_id = self.v_tv_session.identify_row(event.y)
        if row_id:
            self.v_tv_session.selection_set(row_id)
            self.v_right_click_menu.post(event.x_root, event.y_root)
 
    def __session_JumpForward(self, event):
        session = self.__session_selected()
        if session:
            session.findById("wnd[0]").Visualize(True)
            session.findById("wnd[0]").JumpForward()
            return session
 
    def __session_selected(self):
        session_info = self.__session_info_selected()
        try:  # 如果session关闭了，session_info.就会异常
            session = self.__session_get(session_info.SystemSessionId, session_info.SessionNumber)
            return session
        except Exception as e:
            messagebox.showinfo('选择会话', '当前会话繁忙或已关闭：' + str(e))
 
    def __session_info_selected(self):
        item_text = None
        for item in self.v_tv_session.selection():  # 这里values全部转成str!!
            item_text = self.v_tv_session.item(item, "values")
        if item_text:
            for session_info in self.v_session_info_list:
                try:
                    if session_info.SystemSessionId == item_text[self.v_column_len] and str(
                            session_info.SessionNumber) == \
                            item_text[self.v_column_len + 1]:
                        return session_info
                except Exception as e:
                    continue
 
    def __tkinter_frame_con(self):
        # Input控件
        self.v_con_sel['desc'] = tk.StringVar()
        self.v_input['desc'] = ttk.Combobox(self.v_frame1, textvariable=self.v_con_sel['desc'], state='readonly',
                                            width='15')
        self.v_con_sel['client'] = tk.StringVar()
        self.v_input['client'] = ttk.Combobox(self.v_frame1, textvariable=self.v_con_sel['client'],
                                              state='readonly',
                                              width='3')
        self.v_con_sel['user'] = tk.StringVar()
        self.v_input['user'] = ttk.Combobox(self.v_frame1, textvariable=self.v_con_sel['user'], state='readonly',
                                            width='12')
        self.v_con_sel['langu'] = tk.StringVar()
        self.v_input['langu'] = ttk.Combobox(self.v_frame1, textvariable=self.v_con_sel['langu'], state='readonly',
                                             width='5')
 
        # 布局
        tk.Label(self.v_frame1, text='描述').grid(row=0, column=0, padx=self.v_padx)
        self.v_input['desc'].grid(row=0, column=1)
        tk.Label(self.v_frame1, text='客户端').grid(row=0, column=2, padx=self.v_padx)
        self.v_input['client'].grid(row=0, column=3)
        tk.Label(self.v_frame1, text='用户').grid(row=0, column=4, padx=self.v_padx)
        self.v_input['user'].grid(row=0, column=5)
        tk.Label(self.v_frame1, text='语言').grid(row=0, column=6, padx=self.v_padx)
        self.v_input['langu'].grid(row=0, column=7)
 
        # 设置连接值
        self.__con_sel_refresh()
 
        # 绑定事件：下拉框列表值
        self.v_input['desc'].bind("<<ComboboxSelected>>", self.__input_selected_desc)
        self.v_input['client'].bind("<<ComboboxSelected>>", self.__input_selected_client)
        self.v_input['user'].bind("<<ComboboxSelected>>", self.__input_selected_user)
 
        ttk.Button(self.v_frame1, text='打开', command=self.__handle_connection_create).grid(row=0, column=8,
                                                                                           padx=self.v_padx,
                                                                                           pady=10, )
 
    def __con_sel_refresh(self):
        self.v_input['desc']['value'] = list(self.v_con_list.keys())
        self.v_input['desc'].current(0)  # 设置默认值
        self.__input_selected_desc(None)
 
    def __input_selected_desc(self, event):
        self.v_input['client'].delete(0, tk.END)
        self.v_input['client']['value'] = list(self.v_con_list[self.v_con_sel['desc'].get()].keys())
        self.v_input['client'].current(0)  # 设置默认值
        self.__input_selected_client(event)
        self.__input_selected_user(event)
 
    def __input_selected_client(self, event):
        self.v_input['user'].delete(0, tk.END)
        self.v_input['user']['value'] = list(self.v_con_list[self.v_con_sel['desc'].get()]
                                             [self.v_con_sel['client'].get()].keys())
        self.v_input['user'].current(0)  # 设置默认值
        self.__input_selected_user(event)
 
    def __input_selected_user(self, event):
        self.v_input['langu'].delete(0, tk.END)
        self.v_input['langu']['value'] = list(self.v_con_list[self.v_con_sel['desc'].get()]
                                              [self.v_con_sel['client'].get()][self.v_con_sel['user'].get()].keys())
        self.v_input['langu'].current(0)  # 设置默认值
        self.v_input['password'] = \
            self.v_con_list[self.v_con_sel['desc'].get()][self.v_con_sel['client'].get()][
                self.v_con_sel['user'].get()][
                self.v_con_sel['langu'].get()]
 
    def __filedialog_select_vbs(self):
        (filepath, tempfilename) = os.path.split(self.v_config['path']['vbs'])
        selected_file_path = filedialog.askopenfilename(initialdir=filepath,
                                                        filetypes=[('脚本', '*.vbs')])  # 使用askopenfilename函数选择单个文件
        if selected_file_path:
            self.v_config['path']['vbs'] = selected_file_path
            self.__config_write()
            self.v_stringvar_vbs.set(selected_file_path)
 
    def __filedialog_select_template(self):
        (filepath, tempfilename) = os.path.split(self.v_config['path']['template'])
        selected_file_path = filedialog.askopenfilename(initialdir=filepath,
                                                        filetypes=[('模板', '*.xlsx')])  # 使用askopenfilename函数选择单个文件
        if selected_file_path:
            self.v_config['path']['template'] = selected_file_path
            self.__config_write()
            self.v_stringvar_template.set(selected_file_path)
 
    def __tkinter_frame_file(self, frame3):
        v_width_input = 55
 
        self.v_stringvar_vbs = tk.StringVar()
        self.v_stringvar_template = tk.StringVar()
        self.__refresh_file()
        # 布局控件
        # tk.Label(frame3, text="脚本").grid(column=0, row=0, pady=v_pady)
        # tk.Entry(frame3, textvariable=self.v_stringvar_vbs, width=v_width_input).grid(column=1, row=0)
        # tk.Button(frame3, text="选择", command=self.__filedialog_select_vbs).grid(row=0, column=2)
        # tk.Button(frame3, text="解析", command=self.__file_explain).grid(row=0, column=3, padx=self.v_padx)
        tk.Label(frame3, text="模板").grid(column=0, row=1, pady=self.v_pady, padx=self.v_padx)
        tk.Entry(frame3, textvariable=self.v_stringvar_template, width=v_width_input).grid(column=1, row=1)
        tk.Button(frame3, text="选择", command=self.__filedialog_select_template).grid(row=1, column=2)
        tk.Button(frame3, text="打开", command=self.__file_open_template).grid(row=1, column=3, padx=self.v_padx)
        tk.Button(frame3, text="执行", command=self.__button_file_execute).grid(row=1, column=4, padx=self.v_padx)
        # button_exec = tk.Button(frame3, text="执行")
        # button_exec.after(1,self.__button_file_execute)
        # button_exec.grid(row=1, column=4, padx=self.v_padx)
        tk.Button(frame3, text="终止", command=self.__button_stop).grid(row=1, column=5, padx=self.v_padx)
 
    def __refresh_file(self):
        # self.v_stringvar_vbs.set(self.v_config['path']['vbs'])
        self.v_stringvar_template.set(self.v_config['path']['template'])
 
    # def __config_get(self, key):
    #     try:
    #         return self.v_config.loc[self.v_config['key'] == key, 'value'].iloc[0]
    #     except Exception as e:
    #         return ''
 
    def __file_close(self, file):
        xlApp = Dispatch('Excel.Application')
        try:
            xlApp.DisplayAlerts = False  # 设置不显示警告和消息框
        except Exception as e:
            messagebox.showerror('关闭excel', e)
            return
        # xlBook = xlApp.Workbooks.Open(file)
        workbooks_n = xlApp.Workbooks.Count
        # print(f'已打开工作簿的数量为:{workbooks_n}个')
 
        if workbooks_n < 0: return
 
        for i in range(1, workbooks_n + 1):  # 工作簿索引从1开始
            path_ = xlApp.Workbooks(i).Path
            name_ = xlApp.Workbooks(i).Name
            file_ = os.path.join(path_, name_)
            # path = path_ + "\\backup_" + name_
            # print(f'第{i}个excel的文件路径为:{path}')
            if file == "/".join(file_.split("\\")):  # 转义的\\替换回/
                xlApp.Workbooks(i).Close()  # 关闭当前打开的文件,不保存文件
                # xlApp.Workbooks(i).Activate()
                # # xlApp.Workbooks(i).SaveAs(path)
                # xlApp.Workbooks(path).Close()
 
        # xlApp.Quit()  #关闭所有打开的excel文件
        del xlApp
 
    def __file_open_template(self):
        try:
            os.startfile(self.v_stringvar_template.get())
        except Exception as e:
            messagebox.showerror('打开文件', e)
 
    def __file_execute(self):
        self.v_stop = True
        if not self.v_stringvar_template.get():
            messagebox.showerror('文件不能为空')
            return
        self.v_config['path']['template'] = self.v_stringvar_template.get()
        self.__config_write()
 
        # self.v_root.state('icon')  # 最小化
        oper_start = 0
        oper_end = 0
        session = self.__session_JumpForward(None)
        if not session:
            return
        self.__file_close(self.v_stringvar_template.get())  # 先关闭，再回写消息，再打开
        dict = pd.read_excel(self.v_stringvar_template.get(), sheet_name=None,dtype='str') #str防止001.1这样的被当时float
 
        # 循环操作
        tabix = -1
        total = len(dict['字段']['doc_num'])
        start_time = time.time()  # 记录程序开始运行时间
        for doc_num in dict['字段']['doc_num']:
            if not self.v_stop:
                break
            path_t = ''
            log = ''
            tabix = tabix + 1
            self.v_root.update()
            if str(doc_num) == 'nan':
                continue
            table_entry = False
            for i in range(len(dict['操作']['path'])):
                attr, equal, path, value = self.__file_oper_get(dict, i)
                table_entry = self.__table_entry_begin(dict['操作'], i, attr, value,
                                                       table_entry)  # 要传上一个table的Path，因为此时是win0
                table_flag = self.__file_path_check_table(path)
                alv_flag = self.__check_alv(attr)
                if alv_flag:
                    table_flag = True
                if not table_flag and not table_entry:  # 字段：也可能不是字段，比如win0
                    if oper_start != 0:  # 记录了表开始，现在回到了字段，说明表结束了
                        oper_end = i - 1
                    if attr == 'text':  # 避免focus和double click等匹配到了值（或者参考表哪里用 = 判断？）
                        for key in dict['字段']:
                            if key == path + '+' + attr:
                                value = dict['字段'].loc[dict['字段']['doc_num'] == doc_num, key].iloc[
                                    0]  # dict.loc根据行+列返回一个列的series，取series第一个值
                                if re.findall('/okcd', path):
                                    if value[:2] != '/n' and value[:2] != '/N':
                                        value = '/n' + value
                                break
                    elif attr == 'insertText':
                        for key in dict['代码']:
                            if key == value:  # 在 操作 页签的值记录了插入代码的位置
                                value_oper = value
                                if len(dict['代码'][key]) > 1:
                                    value = '\n\r'.join(dict['代码'][key]) + ',' + value_oper
                                else:
                                    value = str(dict['代码'][key][0]) + ',' + value_oper
                                break
                else:  # 表：第一行正常循环，多行后面处理
                    if oper_start == 0:
                        oper_start = i
                    # table = path.split(',')[0]
                    for key in dict:  # 循环每个sheet匹配表字段
                        if re.findall('表', key):
                            for key2 in dict[key]:  # 循环取列名
                                if key2 == path.split(',')[0] + '+' + attr:  # 匹配一次列名就定位到表了
                                    row_doc_tab = len(dict[key].loc[dict[key]['doc_num'] == doc_num, 'doc_num'])
                                    sheet_tbl = key
                                    break
                            else:  # 里面break了则触发外面break跳出第二层循环
                                continue
                            break
 
                # 开始执行
                if oper_start != 0 and oper_end != 0:  # 表：循环完了,开始一次性执行表全部条目
                    pagesize = 0
                    row_current = 0
                    for x in range(row_doc_tab):  # 条目数
                        # 翻页：规定表和表不关联，处理完表1再处理表2，所以在表条目维度翻页就可以
                        attr_t, equal_t, path_t, value_t = self.__file_oper_get(dict, oper_start)
                        if self.__file_path_check_table(path_t):  # 进了表才考虑定位行
                            if 'getAbsoluteRow' in attr_t:  # 选表行
                                row_start = int(attr_t.split('(')[1].strip(')')[0])  # 选中绝对行要不要翻页的？
                                path_tc = path_t
                            else:
                                row_start = int(path_t.split(',')[1].strip(']')[0])  # 开始录制的表行（可能不是从第一行开始的）
                                path_tc = re.findall(r"(.+)/", path_t)[0]
                            if pagesize == 0:
                                pagesize = session.findById(path_tc).verticalScrollbar.pagesize
                            if not row_current:
                                row_current = row_start
 
                            # div_mod = divmod(row_current, pagesize)
                            # if div_mod[0] != 0 and div_mod[1] == 0:  # 翻页：用翻页按钮是因为发现CA01不填第二行无法定位到第二行
                            if row_current == pagesize:  # 翻页
                                log_r = self.__script_exec('sendVKey', '', session.findById("wnd[0]"), '82', "wnd[0]")
                                if log_r:
                                    log = log + log_r
                                row_current = row_start
                        for oper_now in range(oper_start, oper_end + 1):  # range不包含上限
                            attr_t, equal_t, path_t, value_t = self.__file_oper_get(dict, oper_now)
 
                            if self.__file_path_check_table(path_t):
                                if 'getAbsoluteRow' in attr_t:  # 选表行
                                    attr_t = attr_t.split('(')[0] + '(' + str(row_current) + ')' + attr_t.split(')')[
                                        1]  # path_t就是tc的位置不用处理，但是行在attr上
                                elif 'modifyCell' in attr_t or 'insertRows':  #修改alv单元格
                                    pass
                                else:
                                    path_t = path_t.split(',')[0] + ',' + str(row_current) + ']'
                            try:
                                obj_t = session.findById(path_t)
                            except Exception as e:
                                pass
                            for key2 in dict[sheet_tbl]:  # 循环取列名
                                if key2 == path_t.split(',')[0] + '+' + attr_t \
                                        or key2 == path_t + '+' + attr_t:  # 选中行
                                    break
                            if equal_t == 'X':  # 有=号才是可输入字段
                                value_t = dict[sheet_tbl].loc[dict[sheet_tbl]['doc_num'] == doc_num, key2].iloc[
                                    x]  # 取series第x个值
                            elif path_t == 'wnd[0]' or attr_t == 'insertRows':  # 双击/ alv插入行
                                value_t = value_t
                            elif attr_t == 'modifyCell':
                                value_t = [row_current,re.findall(r"\"(.+?)\"", value_t.rsplit(',',2)[1])[0],dict[sheet_tbl].loc[dict[sheet_tbl]['doc_num'] == doc_num, key2].iloc[
                                    x]] #行/列名/值
                            else:
                                value_t = 'nan'
                            log_r = self.__script_exec(attr_t, equal_t, obj_t, value_t, path_t)
                            if log_r:
                                log = log + log_r
                        row_current = row_current + 1
                    oper_start = 0
                    oper_end = 0
 
                if oper_start == 0:  # 非表直接执行
                    try:
                        obj = session.findById(path)  # 到执行的时候才可以取，因为可能前面在执行表
                    except Exception as e:
                        pass
                    log_r = self.__script_exec(attr, equal, obj, value, path)
                    if log_r:
                        log = log + log_r
                # 判断表的双击是否返回或者保存了
                table_entry = self.__table_entry_end(path, attr, value, table_entry)
            # 回写消息
            msg_type = session.findById('wnd[0]/sbar').MessageType
            msg_text = session.findById('wnd[0]/sbar').Text
            dict['字段'].loc[
                tabix, 'msg_type'] = msg_type  # 正确改值方式，否则:SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame
            dict['字段'].loc[tabix, 'msg_text'] = msg_text
            if self.v_config['general']['log'] == 'True':
                dict['字段'].loc[tabix, 'log'] = log
            end_time = time.time()  # 记录程序结束运行时间
            self.v_progress_bar['value'] = (tabix + 1) / total * 100
            self.v_progress_count['text'] = str(tabix + 1) + '/' + str(total)
            self.v_progress_remain['text'] = '剩余时间：' + str(
                datetime.timedelta(
                    seconds=int((end_time - start_time) / (tabix + 1) * (total - (tabix + 1)))))  # int向下取整
        try:  # 只覆盖一个sheet 只有openpyxl有 a mode
            with pd.ExcelWriter(self.v_stringvar_template.get(), mode="a", engine="openpyxl",
                                if_sheet_exists="replace", ) as writer:
                pd.DataFrame(dict['字段']).to_excel(writer, sheet_name="字段", index=False)
                # 按列遍历：单元格改回文本格式
                for x in range(1, writer.sheets['字段'].max_row + 1):  # 先改有文本的单元格，再改列，直接改列不起作用
                    for y in range(0, writer.sheets['字段'].max_column):
                        writer.sheets['字段'][x][y].number_format = '@'
                for i in range(1, writer.sheets['字段'].max_column + 1):
                    writer.sheets['字段'].column_dimensions[get_column_letter(i)].number_format = '@'
        except Exception as e:
            messagebox.showerror('消息回写excel出错', e)
 
        self.__file_open_template()
 
    def __script_exec(self, attr, equal, obj, value, path):  # path可选，用于报错，可以优化成传入path和session
        value = str(value)  # 避免1.0被当做float丢失.0了
        if attr == 'ResizeWorkingPane':
            return
        elif 'getAbsoluteRow' in attr:
            attr_1 = attr.split('(')[0]
            value_1 = attr.split('(')[1].split(')')[0]
            obj = getattr(obj, attr_1)(value_1)  # 动态调用只能分两步：先取table row，再设置为True
            attr = attr.split('.')[1]
 
        time.sleep(int(self.v_config['general']['delay']))
        try:
            # if str(equal) != 'nan':
            if str(equal) == 'X':
                setattr(obj, attr, value)  # 设置属性值
            else:
                if str(value) == 'nan':
                    getattr(obj, attr)()  # 直接调用方法
                else:
                    if obj.type == 'GuiShell':  # 如果是abap编辑器则传入多个参数
                        if attr == 'insertText':  # 代码直接转tuple可能有特殊字符
                            getattr(obj, attr)(value.rsplit(',',2)[0], int(value.rsplit(',',2)[1]),int(value.rsplit(',',2)[2]))
                        elif attr == 'insertRows':
                            getattr(obj, attr)(value)  # 调用方法传参
                        else:
                            value = eval(value)  # 转成tuple
                            getattr(obj, attr)(*value)  # 加* tuple变参数
                    else:
                        getattr(obj, attr)(value)  # 调用方法传参
        except Exception as e:
            return str(e) + str(path) + '：' + str(attr) + '：' + str(value) + '；'
 
    def __file_oper_get(self, df, i):
        path = df['操作']['path'][i]
        attr = df['操作']['attr'][i]
        equal = df['操作']['equal'][i]
        value = df['操作']['value'][i]
        if attr == 'insertText' or attr == 'modifyCell':  # 如果是代码则不去掉引号
            pass
        else:
            value_n = re.findall(r"\"(.+?)\"", str(value))  # 去掉引号
            if value_n:
                value = value_n[0]
        return attr, equal, path, value
 
    def __file_explain(self):
        # v_len_max = 30000 #excel单元格最大字符数 32000
 
        if self.v_config['general']['template_no_ask'] == 'False':  # 是否问模板路径
            self.v_path = self.__filedialog_create_template()
            if self.v_path:
                self.v_stringvar_template.set(self.v_path)
            else:
                return
        operation_list = []
        try:
            with open(self.v_path_script, encoding='UTF-16') as f:  # 代码保存出来就是UTF-16不知道为啥
                for line in f.readlines():  # readlines(),函数把所有的行都读取进来；
                    line = line.strip()  # 删除行后的换行符，img_file 就是每行的内容啦
                    path = re.findall(r"session.findById\(\"(.+?)\"\).", line)  # (" ").
                    if not path:
                        continue
                    attr = re.findall(r"\).(.+?) ", line)  # 测试空格不用转义
                    if not attr:  # 没有值的情况，比如setFocus
                        attr = re.findall('(?<=\).).*$', line)
                    value = re.findall('(?<=\s).*$', line)  # \s空格 取空格右边全部
                    equal = ''
                    if value:
                        # equal = re.search('=', value[0])  # 值中找=号
                        # if equal:
                        if value[0][:1] == '=':  # 如果第一位是等于号（值中可能也有=号）
                            equal = 'X'
                            value = re.findall('(?<=\s).*$', value[0])  # \s空格 取空格右边全部
                    path = self.__array_get_first(path)
                    attr = self.__array_get_first(attr)
                    value = self.__array_get_first(value)
                    operation = (path, attr, equal, value)
                    operation_list.append(operation)
        except Exception as e:
            messagebox.showerror('解析文件', e)
            return
        dict_field = {}
        dict_tables = {}
        dict_code = {}  # 代码
        dict_operation = {'path': {}, 'attr': {}, 'equal': {}, 'value': {}}
 
        # 开始解析操作
        i = -1
        table_entry = False
        df_operation_list = pd.DataFrame(operation_list)
        df_operation_list.columns = ['path', 'attr', 'equal', 'value']
        for oper in operation_list:
            i = i + 1
            path = oper[0]
            attr = oper[1]
            equal = oper[2]
            value = oper[3]
            path_t = ''  # 上一个表的path
            if attr == 'caretPosition' or attr == 'verticalScrollbar.position' or attr == 'currentCellColumn':
                continue
            elif attr == 'insertText':  # 代码：先写 代码 页签，再写操作
                value_code = value.rsplit(",", 2)[0]  # 从右向左按 , 拆两次
                code_list = value_code.split(' + vbCr + "" + vbLf + ')  # 根据换行符号拆开
                for x in range(len(code_list)):
                    code_list[x] = code_list[x][1:len(code_list[x]) - 1]  # 去掉首尾引号
                dict_code[value.rsplit(",", 2)[1] + ',' + value.rsplit(",", 2)[
                    2]] = code_list  # 录制的脚本中文会变成?，需要录完了在excel自己覆盖一下数据
                value = value.rsplit(",", 2)[1] + ',' + value.rsplit(",", 2)[2]  # 如果插入代码，则把位置写到操作页签，把值写入代码页签
            dict_operation['path'][i] = path
            dict_operation['attr'][i] = attr
            dict_operation['equal'][i] = equal
            dict_operation['value'][i] = value
 
            # 判断表的双击是否跳转屏幕了
            # oper_next = operation_list[i + 1]
            table_entry = self.__table_entry_begin(df_operation_list, i, attr, value, table_entry)
 
            table_flag = self.__file_path_check_table(path)
            alv_flag = self.__check_alv(attr)
            if alv_flag: #alv跟表一样处理
                table_flag = True
            if table_flag:  # 如果是跳转的就沿用上一个表名，所以没有第一个表没有填值，只是双击的情况也需要记录表名
                if 'getAbsoluteRow' in attr:  # 选表行
                    table = path
                    tabix = re.findall(r"\((.+?)\)", attr)[0]
                else:  # 表字段
                    if not alv_flag: #table control
                        table = re.findall(r"(.+)/", path)[0]  # 贪婪匹配：从整个字符去掉最后一个匹配
                        tabix = re.findall(r",(.+?)\]", path)[0]
                    else: #alv
                        table = path
                        tabix = value_code = value.rsplit(",", 2)[0]  # 从右向左按 , 拆两次，第一个值为行
 
            if equal == 'X' or attr == 'setFocus' or attr == 'modifyCell':  # setFocus必须要有，有些表没有输入直接双击的，不然匹配不到表
                if alv_flag:
                    value = value.rsplit(',',2)[2]
                quotes = []
                quotes = re.findall(r"\"(.+?)\"", value)  # 值中找引号
                if quotes:
                    value = re.findall(r"\"(.+?)\"", value)[0]
                elif '"' in value:  # 如果引号中间是空，正则也是找不到的
                    value = ''
 
                if table_flag or table_entry:  # 当前为表或者是表双击跳转的屏幕
                    if table_flag and not alv_flag:  # 表上还是要拆分行，只保留列；alv列不写入path了，直接读operation的value取到列
                        path = path.split(',')[0]
                    if not dict_tables.__contains__(table):
                        dict_tables[table] = {}
                    if not dict_tables[table].__contains__(path + '+' + attr):
                        dict_tables[table][path + '+' + attr] = {}
                    dict_tables[table][path + '+' + attr][tabix] = value
                else:  # 字段
                    dict_field[path + '+' + attr] = {0: value}  # 一个path可能有多个属性操作，拼接起来作为字段名
 
                # 判断表的双击是否返回或者保存了
            table_entry = self.__table_entry_end(path, attr, value, table_entry)
 
        dict_field['msg_type'] = {0: ''}
        dict_field['msg_text'] = {0: ''}
        dict_field['log'] = {0: ''}
 
        # 写入excel
        self.__file_close(self.v_stringvar_template.get())  # 先关闭，避免写入的时候占用了
        excel_colum = []
        try:  # with就不用再save了
            with pd.ExcelWriter(self.v_stringvar_template.get(),
                                engine='xlsxwriter') as writer:  # xlsxwriter才能写格式，但是xlsxwriter只能写不能读（所以不能修改）
                df1 = pd.DataFrame(dict_field)
                df1.insert(0, 'doc_num', 1)
                df1.to_excel(writer, sheet_name='字段', index=False)  # 不要第一列的序号
                excel_colum.append(len(df1.keys()))
                i = 0
                for key in dict_tables.keys():
                    i = i + 1
                    dict_table = dict_tables[key]
                    df2 = pd.DataFrame(dict_table)
                    df2.insert(0, 'doc_num', 1)
                    df2.to_excel(writer, sheet_name='表' + str(i), index=False)
                    excel_colum.append(len(dict_table.keys()))
                # df_code = pd.DataFrame(dict_code)
                df_code = pd.DataFrame(pd.DataFrame.from_dict(dict_code, orient='index').values.T,
                                       columns=list(dict_code.keys()))  # dict_code列长度可能不一样需要特殊处理
                df_code.to_excel(writer, sheet_name='代码', na_rep='', index=False)
                excel_colum.append(len(df_code.keys()))
                df3 = pd.DataFrame(dict_operation)
                df3.to_excel(writer, sheet_name='操作', na_rep='', index=False)  # na_rep 缺失数据表示
                excel_colum.append(len(df3.keys()))
 
                # 设置单元格格式为文本
                workbook = writer.book
                format_text = workbook.add_format({'num_format': '@'})
                i = -1
                for sheet_name in writer.sheets:
                    i = i + 1
                    writer.sheets[sheet_name].set_column(0, excel_colum[i] - 1, None, format_text)  # 不设置宽度
        except Exception as e:
            # raise e
            messagebox.showerror('写入excel', str(e))
        else:
            self.__file_open_template()
 
    def __table_entry_end(self, path, attr, value, table_entry):
        if table_entry and ((attr == 'sendVKey' and value == '11') or path == "wnd[0]/tbar[0]/btn[11]"):  # 保存
            messagebox.showerror('请检查操作', '双击表跳转之后要返回，不要直接保存')
            raise self.v_excption
 
        if table_entry and ((attr == 'sendVKey' and value == '3') or path == "wnd[0]/tbar[0]/btn[3]"  # 返回
        ):
            table_entry = False
        return table_entry
 
    def __table_entry_begin(self, operation_list, i, attr, value, table_entry):  # 双击就关联表，否则就算点了button 2进到明细也认为互不关联
        if i == 0:
            return
        oper_path_pre = operation_list['path'][i - 1]
        if operation_list['path'][i] == 'wnd[0]' and (attr == 'sendVKey' and value == '2') and i + 1 < len(
                operation_list):  # 上一个path_t存在表名是表上双击的
            oper_path_next = operation_list['path'][i + 1]
            table_next = oper_path_next.split('/')[0:len(oper_path_next.split('/')) - 1]
            table_pre = oper_path_pre.split('/')[0:len(oper_path_pre.split('/')) - 1]
            if table_next != table_pre:  # 其实这样也不准确，因为跳过去可能直接翻页了，这样取到的也不是屏幕名
                table_entry = True
        return table_entry
 
    def __file_path_check_table(self, path):
        if path.split('/')[len(path.split('/')) - 2][:3] == 'tbl' \
                or path.split('/')[len(path.split('/')) - 1][:3] == 'tbl':  # 如果是表选中行则最后一个不是字段是表名
            return TRUE
        else:
            return False
 
    def __check_alv(self, attr):
        if attr == 'modifyCell' or attr == 'insertRows':
            return TRUE
        else:
            return False
 
    def __array_get_first(self, field):
        if field:
            field = field[0]
        else:
            field = ''
        return field
 
    def __connection_read(self, init=False):
        con = {}
        df = pd.read_excel(self.v_path_connection, sheet_name=None)
        # 连接
        for i in range(len(df['连接']['desc'])):
            desc = str(df['连接']['desc'][i])
            client = str(df['连接']['client'][i])
            user = str(df['连接']['user'][i])
            langu = str(df['连接']['langu'][i])
            password = str(df['连接']['password'][i])
            if not con.__contains__(desc):
                con[desc] = {}
            if not con[desc].__contains__(client):
                con[desc][client] = {}
            if not con[desc][client].__contains__(user):
                con[desc][client][user] = {}
            if not con[desc][client][user].__contains__(langu):
                con[desc][client][user][langu] = password
        self.v_con_list = con
        if not self.v_con_list:
            self.v_con_list = {"未配置": {"300": {"abap01": {"zh": "123456"}}}}
        # with open(self.v_path_connection, 'w') as fp:
        #     json.dump(self.v_con_list, fp)
        if not init:
            self.__con_sel_refresh()
 
    def __config_write(self):
        with open(self.v_path_config, "w+") as f:
            self.v_config.write(f)
 
    def __win_theme(self):
        # root = ttkbootstrap.Window()
        root = tk.Tk()
        root.wm_title('主题')
        # root.iconphoto(False, tk.PhotoImage(file='lan.png'))
        style = ttkbootstrap.Style()
        theme_names = style.theme_names()  # 以列表的形式返回多个主题名
        theme_selection = ttkbootstrap.Frame(root, padding=(10, 10, 10, 0))
        theme_selection.pack(fill=X, expand=YES)
        lbl = ttkbootstrap.Label(theme_selection, text="主题:")
        theme_cbo = ttkbootstrap.Combobox(
            master=theme_selection,
            text=style.theme.name,
            values=theme_names,
        )
        theme_cbo.pack(padx=10, side=RIGHT)
        theme_cbo.current(theme_names.index(style.theme.name))
        lbl.pack(side=RIGHT)
 
        def change_theme(event):
            theme_cbo_value = theme_cbo.get()
            style.theme_use(theme_cbo_value)
            # theme_selected.configure(text=theme_cbo_value)
            theme_cbo.selection_clear()
            self.v_config['general']['theme'] = theme_cbo_value
            self.__config_write()
 
        theme_cbo.bind('<<ComboboxSelected>>', change_theme)
        # theme_selected = ttkbootstrap.Label(
        #     master=theme_selection,
        #     text="litera",
        #     font="-size 24 -weight bold"
        # )
        # theme_selected.pack(side=LEFT)
        self.__window_geometry(200, 50, root)
        root.mainloop()
 
    def __filedialog_create_template(self):
        path = filedialog.asksaveasfilename(filetypes=[('excel文件', ['.xlsx'])],
                                            title='生成模板',
                                            initialfile='template.xlsx'
                                            )
        return path
 
    def __resource_path(self, relative_path):
        if getattr(sys, 'frozen', False):  # 是否Bundle Resource
            base_path = sys._MEIPASS
        else:
            base_path = os.path.abspath(".")
        return os.path.join(base_path, relative_path)
 
    def __session_info_list_get(self):
        out_list = []
        try:  # 有可能超时连接断开，一个连接都没有了
            for connection in self.v_application.Connections:
                for session in connection.Sessions:
                    outdict = {}
                    try:  # 有可能超时断开，刚好执行到session.Info，就出异常了
                        if session.Busy == False:
                            session_info = session.Info
                            outdict = session_info
                            out_list.append((outdict))
                    except Exception as e:
                        pass
        except Exception as e:
            pass
        return out_list
 
 
    def __sapgui__start(self):
        self.v_path_sapgui = "C:\Program Files (x86)\SAP\FrontEnd\SAPgui\saplogon.exe"
        if not self.__sapgui_check_logon():
            if self.v_path_sapgui and os.path.exists(self.v_path_sapgui):
                subprocess.Popen(self.v_path_sapgui)
                time.sleep(7)
                return self.__sapgui_check_logon()
            else:
                raise ValueError('Path to saplogon.exe not found')
 
    def __sapgui_check_logon(self):
        try:
            self.v_application = win32com.client.GetObject('SAPGUI').GetScriptingEngine
        except Exception as e:
            return False
        else:
            return True
 
    def __connection_create(self, desc, client, user, pwd, langu=None, close_conn=False, change_pwd=True):
        try:
            self.v_application.OpenConnection(desc, True)
        except pythoncom.com_error as error:
            hr, msg, exc, arg = error.args
            sap_error = "COM: {0} ({1})".format(msg, hr)
            msg = "Connection '{0}' not found. {1}".format(desc, sap_error)
            # raise RuntimeError(msg)
            messagebox.showerror('打开连接错误', error)
        try:
            sap_session = self.v_application.Children(self.v_application.Children.Count - 1).Children(0)
        except Exception as e:
            messagebox.showerror('获取会话', '检查SAP是否开启了sapgui script（RZ11配置）')
            return
        sap_session.findById("wnd[0]").JumpBackward()
        sap_session.findById('wnd[0]/usr/txtRSYST-BNAME').text = user
        sap_session.findById('wnd[0]/usr/pwdRSYST-BCODE').text = pwd
        sap_session.findById('wnd[0]/usr/txtRSYST-MANDT').text = client
        sap_session.findById('wnd[0]/usr/txtRSYST-LANGU').text = langu
        sap_session.findById('wnd[0]').sendVKey(0)
 
        # msg = sap_session.findById('wnd[0]/sbar')
        # if msg and msg[0] == "E":
        #     sap_session.findById('wnd[0]').sendVKey(15) #shift + f3
        #     raise RuntimeError("Could not log to the SAP server. {0}".format(msg[2]))
 
        # 重复登录
        try:
            sap_session.findById("wnd[1]/usr/radMULTI_LOGON_OPT2")
        except pythoncom.com_error as error:
            pass
        else:
            sap_session.findById("wnd[1]/usr/radMULTI_LOGON_OPT2").select()
            sap_session.findById("wnd[1]/tbar[0]/btn[0]").press()
 
        # copyright弹框
        try:
            sap_session.findById("wnd[1]").sendVKey(0)
        except pythoncom.com_error as error:
            pass
 
        # return_pwd = SAPLogonPwd.is_change_password_window_while_connect(sap_session, change_pwd=change_pwd)
        # SAPNewSession.close_new_windows_while_connect(sap_session)
        return sap_session
 
    def __session_get(self, SystemSessionId, SessionNumber):
        for connection in self.v_application.Connections:
            for session in connection.Sessions:
                if session.Busy == False:
                    if session.Info.SystemSessionId == SystemSessionId and session.Info.SessionNumber == SessionNumber:
                        return session
 
    def __session_init(self):
        session = self.__session_selected()
        session.StartTransaction('')
        # self.__session_refresh()
 
    def __record_start(self):
        session = self.__session_selected()
        self.v_session = session  # 获得session的句柄，这样方法执行完了，session的record可以保持不丢失
        session.Record = False
        session.SaveAsUnicode = True  # 会存UTF-16
        session.RecordFile = self.v_filename_script
        self.v_path_script = session.RecordFile  # 本地变量丢失句柄会清掉/关闭Record会丢掉先记下来
        self.v_config['path']['vbs'] = self.v_path_script
        self.__config_write()
        session.findById("wnd[0]").JumpForward()
        session.Record = True  # 执行这句之后就会创建文件,之后前台操作都是实时写文件的
 
    def __record_end(self):
        session = self.__session_selected()
        if not session:
            return
        if session.RecordFile:
            self.v_path_script = session.RecordFile
        else:
            self.v_path_script = self.v_config['path']['vbs']
        session.Record = False  # 会清空 session.RecordFile
        self.v_session = None  # 释放session，此时gui右下角的脚本状态会立即消失
        self.__file_explain()
 
    # class SAPGUI:
 
    # def __tv_data_set(self,tv, data):
    def __column_next(self, column=None):
        if column != None:
            self.v_column = column
        self.v_column = self.v_column + 1
        return self.v_column
 
    def __connection_edit(self):
        os.startfile(self.v_path_connection)
 
    def __config_edit(self):
        os.startfile('config.ini')
 
    def __config_read(self):
        self.v_config.read('config.ini')
 
    def __button_file_execute(self):
        # self.__file_execute()
        self.v_root.after(1, self.__file_execute)
 
    def __button_stop(self):
        messagebox.showinfo('终止', '收到，当前条目执行完就会停止执行')
        self.v_stop = False
 
    def __about_document(self):
        # webbrowser.open('https://xiaolan.blog.csdn.net/article/details/128494871')
        webbrowser.open('https://blog.csdn.net/cylcylcylcylwo/article/details/128494871')
 
    def __about_conmunicate(self):
        pyperclip.copy('777363609')  # 相当如写入到剪切板
        
 
 
if __name__ == "__main__":
    lan_rpa = lan_rpa()
    lan_rpa.main()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/651278