ORPA-pyOpenRPA/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/RobotRDPActive.py

from pyOpenRPA.Robot import UIDesktop
import os
import time # Time wait operations
from . import ConnectorExceptions # Exceptions classes
from . import Connector
from . import Processor # Module for process some functions on thr RDP
# Main function
# inThreadControlDict = {"ThreadExecuteBool":True}
def RobotRDPActive(inGSettings, inThreadControlDict):
    # inGSettings = {
    # ... "RobotRDPActive": {} ...
    # }
    lL = inGSettings["Logger"] #Logger alias
    Processor.gSettings = inGSettings  # Set gSettings in processor module
    mGSettingsRDPActiveDict = inGSettings["RobotRDPActive"] # Get configuration from global dict settings
    # Global error handler
    try:
        ######## Init the RDP List
        lNewRDPList = {}
        for lRDPSessionKeyStrItem in mGSettingsRDPActiveDict["RDPList"]:
            lConfigurationItem = mGSettingsRDPActiveDict["RDPList"][lRDPSessionKeyStrItem]
            lAddToNewRDPDict = True
            if "SessionHex" not in lConfigurationItem: lAddToNewRDPDict = False # 2020.08.03 fix: Init the Session hex field. If no SessionHex - trash in structure - remove
            if lConfigurationItem["SessionHex"] is None or lConfigurationItem["SessionHex"] == "": # Minor fix - need for restore existed RDP sessions
                lConfigurationItem["SessionIsWindowExistBool"] = False  # Flag that session is not started
                lConfigurationItem["SessionIsWindowResponsibleBool"] = False  # Flag that session is not started
                lConfigurationItem["SessionHex"] = " 77777sdfsdf77777dsfdfsf77777777"  # Flag that session is not started
            if lAddToNewRDPDict:
                lNewRDPList[lRDPSessionKeyStrItem] = lConfigurationItem
        mGSettingsRDPActiveDict["RDPList"] = lNewRDPList # Update the structure
        ##########
        # Run monitor - main loop
        # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
        inGlobalDict = mGSettingsRDPActiveDict # Compatibility
        inListUpdateTimeout = 1 # Compatibility
        lFlagWhile = True
        lResponsibilityCheckLastSec = time.time()  # Get current time for check interval
        while lFlagWhile:
            try:
                if inThreadControlDict["ThreadExecuteBool"] == True:
                    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                    # Check RDP window is OK - reconnect if connection was lost
                    lUIOSelectorList = []
                    lRDPConfigurationDictList = []
                    # Prepare selectors list for check
                    for lRDPSessionKeyStrItem in inGlobalDict["RDPList"]:
                        lItem = inGlobalDict["RDPList"][lRDPSessionKeyStrItem]
                        lRDPConfigurationDictList.append(lItem) # Add RDP Configuration in list
                        lUIOSelectorList.append([{"title_re": f"{lItem['SessionHex']}.*", "backend": "win32"}])
                    # Run wait command
                    lRDPDissappearList = UIDesktop.UIOSelectorsSecs_WaitDisappear_List(lUIOSelectorList, inListUpdateTimeout)
                    for lItem in lRDPDissappearList: # Reconnect if connection was lost
                        lRDPConfigurationDict = lRDPConfigurationDictList[lItem] # Get RDP Configuration list
                        lRDPConfigurationDict["SessionIsWindowExistBool"] = False  # Set flag that session is disconnected
                        # Check if RDP window is not ignored
                        if not lRDPConfigurationDict["SessionIsIgnoredBool"]:
                            try:
                                Connector.Session(lRDPConfigurationDict, inScreenSize550x350Bool = True)
                                lRDPConfigurationDict["SessionIsWindowExistBool"] = True  # Flag that session is started
                                if lL: lL.info(f"SessionHex: {str(lRDPConfigurationDict['SessionHex'])}:: Session has been initialized!")  #Logging
                            # catch ConnectorExceptions.SessionWindowNotExistError
                            except ConnectorExceptions.SessionWindowNotExistError as e:
                                lRDPConfigurationDict["SessionIsWindowExistBool"] = False  # Set flag that session is disconnected
                                if lL: lL.warning(f"SessionHex: {str(lRDPConfigurationDict['SessionHex'])}:: Session is not exist!")  #Logging
                            # general exceptions
                            except Exception as e:
                                if lL: lL.exception(f"!!! ATTENTION !!! Unrecognized error")  #Logging
                                pass
                    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                    Connector.SystemRDPWarningClickOk() # Click all warning messages
                    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                    # Check if RDP session is full screen (if is not ignored)
                    if inGlobalDict["FullScreenRDPSessionKeyStr"] is not None:
                        lRDPSessionKeyStr = inGlobalDict["FullScreenRDPSessionKeyStr"] # Get the RDPSessionKeyStr
                        if lRDPSessionKeyStr in inGlobalDict["RDPList"]: # Session Key is in dict
                            lRDPConfigurationDict = inGlobalDict["RDPList"][lRDPSessionKeyStr]
                            #if not lRDPConfigurationDict["SessionIsIgnoredBool"]: # Session is not ignored
                            # Check if full screen
                            lIsFullScreenBool = Connector.SessionIsFullScreen(inSessionHexStr=lRDPConfigurationDict["SessionHex"])
                            if not lIsFullScreenBool: # If not the full screen
                                # Check all RDP window and minimize it
                                for lRDPSessionKeyStrItem in inGlobalDict["RDPList"]:
                                    lRDPConfigurationDictItem = inGlobalDict["RDPList"][lRDPSessionKeyStrItem]
                                    if Connector.SessionIsFullScreen(inSessionHexStr=lRDPConfigurationDictItem["SessionHex"]):
                                        if inThreadControlDict["ThreadExecuteBool"] == True: # TEST FEATURE BEFORE ONE THREAD INTEGRATION
                                            Connector.SessionScreenSize_X_Y_W_H(inSessionHex=lRDPConfigurationDictItem["SessionHex"], inXInt=10, inYInt=10,
                                                                      inWInt=550,
                                                                      inHInt=350)  # Prepare little window
                                # Set full screen for new window
                                if inThreadControlDict["ThreadExecuteBool"] == True: # TEST FEATURE BEFORE ONE THREAD INTEGRATION
                                    Connector.SessionScreenFull(inSessionHex=lRDPConfigurationDict["SessionHex"], inLogger= inGSettings["Logger"], inRDPConfigurationItem=inGlobalDict["RDPList"][lRDPSessionKeyStrItem])
                    else:
                        # Check all RDP window and minimize it
                        for lRDPSessionKeyStrItem in inGlobalDict["RDPList"]:
                            lRDPConfigurationDictItem = inGlobalDict["RDPList"][lRDPSessionKeyStrItem]
                            if Connector.SessionIsFullScreen(inSessionHexStr=lRDPConfigurationDictItem["SessionHex"]) or Connector.SessionIsMinimizedScreen(inSessionHexStr=lRDPConfigurationDictItem["SessionHex"]): # If window is minimized - restore # if window in full screen - resize
                                if inThreadControlDict["ThreadExecuteBool"] == True:  # TEST FEATURE BEFORE ONE THREAD INTEGRATION
                                    Connector.SessionScreenSize_X_Y_W_H(inSessionHex=lRDPConfigurationDictItem["SessionHex"],
                                                                    inXInt=10, inYInt=10,
                                                                    inWInt=550,
                                                                    inHInt=350)  # Prepare little window
                    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
                    # Iterate the activity list in robot RDP active
                    lActivityListNew = []
                    lActivityListOld = inGlobalDict["ActivityList"]
                    inGlobalDict["ActivityList"] = []
                    for lActivityItem in lActivityListOld:
                        lSubmoduleFunctionName = lActivityItem["DefNameStr"]
                        if lSubmoduleFunctionName in dir(Processor):
                            lActivityItemResult = None # init the variable
                            try: # try to run function from Processor.py
                                lActivityItemResult = getattr(Processor, lSubmoduleFunctionName)(
                                    *lActivityItem["ArgList"], **lActivityItem["ArgDict"])
                            except Exception as e:
                                if lL: lL.exception(f"RDP::main: Exception when run def in processor.py - activity will be ignored. Activity item: {lActivityItem}")  #Logging
                                lActivityItemResult = True # True - clear from repeat list
                            lActivityItemResultType = type(lActivityItemResult)
                            # Check if Result is bool
                            if lActivityItemResultType is bool:
                                if not lActivityItemResult:
                                    # Activity is not done - add to list (retry in future)
                                    lActivityListNew.append(lActivityItem)
                    inGlobalDict["ActivityList"] = lActivityListNew  # Override the value
                    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
            except RuntimeError as e:
                # case noGUI error passed - do nothing
                if lL: lL.warning(f"Host session has lost the GUI")  #Logging
            finally:
                # Wait for the next iteration
                time.sleep(0.7)
        # Scheduler.Scheduler(mGSettingsRDPActiveDict["Scheduler"])  # Init & Run Scheduler TODO remake in processor list
        # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
        #Monitor.Monitor(mGSettingsRDPActiveDict, 1)
    except Exception as e:
        if lL: lL.exception(f"!!! ATTENTION !!! Global error handler - look at code")  #Logging