|
|
#Import parent folder to import current / other packages
|
|
|
from pyOpenRPA.Robot import UIDesktop #Lib to access RDP window
|
|
|
from . import ConnectorExceptions # Exceptions classes
|
|
|
import os #os for process run
|
|
|
import uuid #temp id for Template.rdp
|
|
|
import tempfile #Temporary location
|
|
|
import subprocess
|
|
|
from . import Clipboard # Clipboard functions get/set
|
|
|
import keyboard # Keyboard functions
|
|
|
import time
|
|
|
import random # random integers
|
|
|
from win32api import GetSystemMetrics # Get Screen rect
|
|
|
import pyautogui # for hotkey operations
|
|
|
# System variables for recovery scenario
|
|
|
gRecoveryWindowRDPRetryCountInt = 3 # Retry iteration count is RDP window is not responsible
|
|
|
gRecoveryWindowRDPRetryIntervalSecInt = 3 # Retry interval for reconnect
|
|
|
|
|
|
gRecoveryWindowRUNRetryCountInt = 3 # Retry iteration count is RUN window is not responsible
|
|
|
gRecoveryWindowRUNRetryIntervalSecInt = 3 # Retry interval for retry
|
|
|
|
|
|
gRecoveryCMDResponsibleRetryCountInt = 3 # Retry iteration count is CMD is not responsible
|
|
|
gRecoveryCMDResponsibleRetryIntervalSecInt = 3 # Retry interval for retry
|
|
|
|
|
|
gKeyboardHotkeyDelaySecFloat = 0.6 # Const for delay - important for work with RDP!!!!
|
|
|
|
|
|
#Connect to RDP session
|
|
|
"""
|
|
|
{
|
|
|
"Host": "", #Host address
|
|
|
"Port": "", #RDP Port
|
|
|
"Login": "", # Login
|
|
|
"Password": "", #Password
|
|
|
"Screen": {
|
|
|
"Resolution":"FullScreen", #"640x480" or "1680x1050" or "FullScreen". If Resolution not exists set full screen
|
|
|
"FlagUseAllMonitors": False, # True or False
|
|
|
"DepthBit":"" #"32" or "24" or "16" or "15"
|
|
|
}
|
|
|
}
|
|
|
"""
|
|
|
def Session(inRDPSessionConfiguration, inScreenSize550x350Bool = False):
|
|
|
#RDPConnector.SessionConnect(mConfiguration)
|
|
|
#RDPConnector.LoginPassSet("111.222.222.111","ww","dd")
|
|
|
(lRDPFile, lSessionHex) = SessionConfigurationCreate(inRDPSessionConfiguration)
|
|
|
#Set session hex in globalDict
|
|
|
inRDPSessionConfiguration["SessionHex"] = lSessionHex
|
|
|
#Set login/password
|
|
|
SessionLoginPasswordSet(inRDPSessionConfiguration["Host"],inRDPSessionConfiguration["Login"],inRDPSessionConfiguration["Password"])
|
|
|
#Start session
|
|
|
SessionRDPStart(lRDPFile, inScreenSize550x350Bool= inScreenSize550x350Bool)
|
|
|
#Remove temp file
|
|
|
time.sleep(4) #Delete file after some delay - one way to delete and run the RDP before because RDP is not read file in one moment
|
|
|
os.remove(lRDPFile) # delete the temp rdp
|
|
|
# Set the result
|
|
|
return inRDPSessionConfiguration
|
|
|
#Add login/ password to the windows credentials to run RDP
|
|
|
def SessionLoginPasswordSet(inHost, inLogin, inPassword):
|
|
|
#Clear old login/password if it exists
|
|
|
#os.system(f"cmdkey /delete:TERMSRV/{inHost}") #Dont need to delete because new user password will clear the previous creds
|
|
|
#Set login password for host
|
|
|
os.system(f'cmdkey /generic:TERMSRV/{inHost} /user:{inLogin} /pass:"{inPassword}"')
|
|
|
return None
|
|
|
#Create current .rdp file with settings
|
|
|
#Return (full path to file, session hex)
|
|
|
def SessionConfigurationCreate(inConfiguration):
|
|
|
#RobotRDPActive folder path
|
|
|
lFileFullPath=__file__
|
|
|
lFileFullPath = lFileFullPath.replace("/","\\")
|
|
|
lRobotRDPActiveFolderPath = "\\".join(lFileFullPath.split("\\")[:-1])
|
|
|
#Full path to Template.rdp file
|
|
|
lRDPTemplateFileFullPath = os.path.join(lRobotRDPActiveFolderPath, "Template.rdp")
|
|
|
#Open template file (.rdp encoding is USC-2 LE BOM = UTF-16 LE) http://qaru.site/questions/7156020/python-writing-a-ucs-2-little-endian-utf-16-le-file-with-bom
|
|
|
lRDPTemplateFileContent = open(lRDPTemplateFileFullPath, "r", encoding="utf-16-le").read()
|
|
|
#Prepare host:port
|
|
|
lHostPort=inConfiguration['Host']
|
|
|
if 'Port' in inConfiguration:
|
|
|
if inConfiguration['Port']:
|
|
|
lHostPort=f"{lHostPort}:{inConfiguration['Port']}"
|
|
|
# Generate parameter for .rdp "drivestoredirect:s:C:\;"
|
|
|
lDriveStoreDirectStr = ""
|
|
|
for lItem in inConfiguration['SharedDriveList']:
|
|
|
lDriveStoreDirectStr+=f"{lItem.upper()}:\\;" # Attention - all drives must be only in upper case!!!
|
|
|
#Replace {Width}, {Height}, {BitDepth}, {HostPort}, {Login}
|
|
|
lRDPTemplateFileContent = lRDPTemplateFileContent.replace("{Width}", str(inConfiguration.get('Screen',{}).get("Width",1680)))
|
|
|
lRDPTemplateFileContent = lRDPTemplateFileContent.replace("{Height}", str(inConfiguration.get('Screen',{}).get("Height",1050)))
|
|
|
lRDPTemplateFileContent = lRDPTemplateFileContent.replace("{BitDepth}", inConfiguration.get('Screen',{}).get("DepthBit","32"))
|
|
|
lRDPTemplateFileContent = lRDPTemplateFileContent.replace("{HostPort}", lHostPort)
|
|
|
lRDPTemplateFileContent = lRDPTemplateFileContent.replace("{Login}", inConfiguration['Login'])
|
|
|
lRDPTemplateFileContent = lRDPTemplateFileContent.replace("{SharedDriveList}", lDriveStoreDirectStr)
|
|
|
#Save template to temp file
|
|
|
lRDPCurrentFileFullPath = os.path.join(tempfile.gettempdir(), f"{uuid.uuid4().hex}.rdp")
|
|
|
open(lRDPCurrentFileFullPath, "w", encoding="utf-16-le").write(lRDPTemplateFileContent)
|
|
|
#Return .rdp full path
|
|
|
return (lRDPCurrentFileFullPath, (lRDPCurrentFileFullPath.split("\\")[-1])[0:-4])
|
|
|
#RDPSessionStart
|
|
|
def SessionRDPStart(inRDPFilePath, inScreenSize550x350Bool = False):
|
|
|
#Disable certificate warning
|
|
|
lCMDString = 'reg add "HKEY_CURRENT_USER\\Software\\Microsoft\\Terminal Server Client" /v "AuthenticationLevelOverride" /t "REG_DWORD" /d 0 /f'
|
|
|
os.system(lCMDString)
|
|
|
#run rdp session
|
|
|
lItemArgs = [inRDPFilePath]
|
|
|
subprocess.Popen(lItemArgs, shell=True)
|
|
|
#Wait for UAC unknown publisher exists
|
|
|
lRDPFileName = (inRDPFilePath.split("\\")[-1])[0:-4]
|
|
|
lWaitResult = UIDesktop.UIOSelectorsSecs_WaitAppear_List(
|
|
|
[
|
|
|
[{"title": "Подключение к удаленному рабочему столу", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "Боль&ше не выводить запрос о подключениях к этому компьютеру", "friendly_class_name": "CheckBox"}],
|
|
|
[{"title": "Remote Desktop Connection", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "D&on't ask me again for connections to this computer",
|
|
|
"friendly_class_name": "CheckBox"}],
|
|
|
[{"title_re": f"{lRDPFileName}.*",
|
|
|
"class_name": "TscShellContainerClass", "backend": "win32"},{"depth_start":3, "depth_end": 3, "class_name":"UIMainClass"}]
|
|
|
],
|
|
|
30
|
|
|
)
|
|
|
#Enable certificate warning
|
|
|
lCMDString = 'reg add "HKEY_CURRENT_USER\\Software\\Microsoft\\Terminal Server Client" /v "AuthenticationLevelOverride" /t "REG_DWORD" /d 2 /f'
|
|
|
os.system(lCMDString)
|
|
|
#Click if 0 is appear (RUS)
|
|
|
if 0 in lWaitResult:
|
|
|
#Check the box do not retry
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title": "Подключение к удаленному рабочему столу", "backend": "win32"},
|
|
|
{"title": "Боль&ше не выводить запрос о подключениях к этому компьютеру", "friendly_class_name": "CheckBox"}]).check()
|
|
|
#Go to connection
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title": "Подключение к удаленному рабочему столу", "backend": "win32"},
|
|
|
{"title":"Подкл&ючить", "class_name":"Button"}]).click()
|
|
|
lWaitResult = UIDesktop.UIOSelectorsSecs_WaitAppear_List(
|
|
|
[
|
|
|
[{"title_re": f"{lRDPFileName}.*",
|
|
|
"class_name": "TscShellContainerClass", "backend": "win32"}]
|
|
|
],
|
|
|
30
|
|
|
)
|
|
|
# Click if 1 is appear (ENG)
|
|
|
if 1 in lWaitResult:
|
|
|
# Check the box do not retry
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title": "Remote Desktop Connection", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "D&on't ask me again for connections to this computer",
|
|
|
"friendly_class_name": "CheckBox"}]).check()
|
|
|
# Go to connection
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title": "Remote Desktop Connection", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "Co&nnect", "class_name": "Button"}]).click()
|
|
|
lWaitResult = UIDesktop.UIOSelectorsSecs_WaitAppear_List(
|
|
|
[
|
|
|
[{"title_re": f"{lRDPFileName}.*",
|
|
|
"class_name": "TscShellContainerClass", "backend": "win32"}]
|
|
|
],
|
|
|
30
|
|
|
)
|
|
|
# Raise exception if RDP is not active
|
|
|
if len(lWaitResult) == 0:
|
|
|
raise ConnectorExceptions.SessionWindowNotExistError("Error when initialize the RDP session - No RDP windows has appreared!")
|
|
|
time.sleep(3) # Wait for init
|
|
|
if inScreenSize550x350Bool: SessionScreenSize_X_Y_W_H(inSessionHex = lRDPFileName, inXInt = 10, inYInt = 10, inWInt = 550, inHInt = 350) #Prepare little window
|
|
|
return None
|
|
|
|
|
|
#Set fullscreen for app
|
|
|
def SessionScreenFull(inSessionHex, inLogger = None, inRDPConfigurationItem = None):
|
|
|
########################################
|
|
|
lWindowRDPRetryIterator = 0 # Retry iterator if RDP window is not active
|
|
|
lRDPConfigurationItem = inRDPConfigurationItem # Get the RDP configuration item
|
|
|
lL = inLogger # Get the logger instance
|
|
|
lRDPWindow = None # Init the variable
|
|
|
while lWindowRDPRetryIterator<gRecoveryWindowRDPRetryCountInt: # Loop iteration to connect to RDP
|
|
|
try: # Try to get RDP window
|
|
|
lRDPWindow = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHex}.*", "backend": "win32"}])
|
|
|
lWindowRDPRetryIterator = gRecoveryWindowRDPRetryCountInt # Set last iterator to turn off the loop
|
|
|
# RDP window has been detected - go to set focus and maximize
|
|
|
lRDPWindow.set_focus()
|
|
|
lRDPWindow.maximize()
|
|
|
if not SessionIsFullScreen(inSessionHex):
|
|
|
lRDPWindow.type_keys("^%{BREAK}")
|
|
|
time.sleep(0.5)
|
|
|
except Exception as e: # RDP window is not exist - try to reconnect
|
|
|
if lL: lL.warning(f"RDP::SessionScreenFull: RDP window is not exist - try sleep {gRecoveryWindowRDPRetryIntervalSecInt}[s.] and then to reconnect. SessionHex: {inSessionHex}. Current retry iterator is {lWindowRDPRetryIterator}")
|
|
|
if lRDPConfigurationItem:
|
|
|
time.sleep(gRecoveryWindowRDPRetryIntervalSecInt) # Before try to reconnect sleep
|
|
|
# Try to reconnect the RDP
|
|
|
SessionClose(inSessionHexStr=inSessionHex) # Close the
|
|
|
Session(lRDPConfigurationItem) # Create RDP session
|
|
|
inSessionHex = lRDPConfigurationItem["SessionHex"] # Get new session hex after reconnect
|
|
|
SystemRDPWarningClickOk() # Click all warning messages
|
|
|
lWindowRDPRetryIterator = lWindowRDPRetryIterator + 1 # increase the iterator
|
|
|
if lWindowRDPRetryIterator >= gRecoveryWindowRDPRetryCountInt: # Raise the error if retry count is over
|
|
|
if lL: lL.warning(f"RDP::SessionScreenFull: Retry count is over. Raise the error. SessionHex: {inSessionHex}.") # Log the info
|
|
|
raise ConnectorExceptions.SessionWindowNotExistError() # raise the error
|
|
|
else:
|
|
|
if lL: lL.warning(f"RDP::SessionScreenFull: Has no RDP configuration item - don't reconnect. Raise the error. SessionHex: {inSessionHex}") # Log the info
|
|
|
raise ConnectorExceptions.SessionWindowNotExistError() # raise the error
|
|
|
return None
|
|
|
|
|
|
# Set the screen size
|
|
|
def SessionScreenSize_X_Y_W_H(inSessionHex, inXInt, inYInt, inWInt, inHInt):
|
|
|
lDoBool = True
|
|
|
while lDoBool:
|
|
|
#Prepare little window
|
|
|
try:
|
|
|
lRDPWindow = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHex}.*", "backend": "win32"}])
|
|
|
except Exception as e:
|
|
|
return None
|
|
|
try:
|
|
|
lRDPWindow.set_focus()
|
|
|
if SessionIsFullScreen(inSessionHex):
|
|
|
lRDPWindow.type_keys("^%{BREAK}")
|
|
|
time.sleep(0.5)
|
|
|
lRDPWindow.restore()
|
|
|
time.sleep(0.5)
|
|
|
lRDPWindow.move_window(inXInt,inYInt,inWInt,inHInt)
|
|
|
except Exception as e:
|
|
|
time.sleep(1)
|
|
|
else:
|
|
|
lDoBool = False
|
|
|
return None
|
|
|
|
|
|
# Set Little window of the session
|
|
|
def SessionScreen100x550(inSessionHex):
|
|
|
SessionScreenSize_X_Y_W_H(inSessionHex = inSessionHex, inXInt = 10, inYInt = 10, inWInt = 550, inHInt = 100)
|
|
|
return None
|
|
|
# Session - close window
|
|
|
def SessionClose(inSessionHexStr):
|
|
|
#Close window
|
|
|
try:
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHexStr}.*", "backend": "win32"}]).close()
|
|
|
except Exception as e:
|
|
|
pass
|
|
|
#Type command in CMD
|
|
|
# inSessionHex - SessionHex to catch window
|
|
|
# inModeStr "LISTEN", "CROSSCHECK", "RUN"
|
|
|
# "LISTEN" - Get result of the cmd command in result TODO get home script
|
|
|
# "CROSSCHECK" - Check if the command was successufully sent TODO get home script
|
|
|
# "RUN" - Run without crosscheck and get clipboard
|
|
|
# return {
|
|
|
# "OutStr": <> # Result string
|
|
|
# "IsResponsibleBool": True|False # Flag is RDP is responsible - works only when inModeStr = CROSSCHECK
|
|
|
# }
|
|
|
# example Connector.SessionCMDRun("4d1e48f3ff6c45cc810ea25d8adbeb50","start notepad", "RUN")
|
|
|
def SessionCMDRun(inSessionHex,inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboardTimeoutSec = 5, inLogger=None, inRDPConfigurationItem=None):
|
|
|
lL = inLogger # Init the logger
|
|
|
# Init the result dict
|
|
|
lResult = {"OutStr": None,"IsResponsibleBool":True}
|
|
|
SessionScreenFull(inSessionHex, inLogger=lL, inRDPConfigurationItem=inRDPConfigurationItem) # Enter full screen mode with recovery scenario
|
|
|
time.sleep(2)
|
|
|
# Run CMD operations
|
|
|
lResult = SystemCMDRun(inSessionHexStr = inRDPConfigurationItem["SessionHex"], inCMDCommandStr = inCMDCommandStr, inModeStr = inModeStr, inClipboardTimeoutSec = inClipboardTimeoutSec, inLogger=lL)
|
|
|
# Exit fullscreen mode
|
|
|
SessionScreenSize_X_Y_W_H(inSessionHex=inSessionHex, inXInt=10, inYInt=10, inWInt=550,
|
|
|
inHInt=350) # Prepare little window
|
|
|
return lResult
|
|
|
# Check if session is in Full screen mode
|
|
|
# Return True - is in fullscreen
|
|
|
# example print(Connector.SessionIsFullScreen(""))
|
|
|
def SessionIsFullScreen(inSessionHexStr):
|
|
|
#Default resul
|
|
|
lResult = False
|
|
|
lWeight = GetSystemMetrics(0)
|
|
|
lHeight = GetSystemMetrics(1)
|
|
|
#Get window screen
|
|
|
try:
|
|
|
lRectangle = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHexStr}.*", "backend": "win32"}]).rectangle()
|
|
|
except Exception as e:
|
|
|
return lResult
|
|
|
# Get Height/Weight
|
|
|
lSessionWeight = lRectangle.right - lRectangle.left
|
|
|
lSessionHeight = lRectangle.bottom - lRectangle.top
|
|
|
#Case fullscreen
|
|
|
if lSessionHeight == lHeight and lSessionWeight == lWeight:
|
|
|
lResult = True
|
|
|
return lResult
|
|
|
|
|
|
# Check if session is in minimized screen mode
|
|
|
# Return True - is in minimized
|
|
|
# example print(Connector.SessionIsFullScreen(""))
|
|
|
def SessionIsMinimizedScreen(inSessionHexStr):
|
|
|
#Default result
|
|
|
lResult = False
|
|
|
#Get window screen
|
|
|
try:
|
|
|
lResult = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHexStr}.*", "backend": "win32"}]).is_minimized()
|
|
|
except Exception as e:
|
|
|
pass
|
|
|
return lResult
|
|
|
# Check if RDP session is responsible (check with random combination in cmd)
|
|
|
# Attention - function will be work fine if RDP will be in full screen mode!!! (see def SessionScreenFull)
|
|
|
# Return True - is responsible; False - is not responsible
|
|
|
#Type command in CMD
|
|
|
# inFlagDoCrossCheck: True - Do check that CMD is executed (the text response will not be available)
|
|
|
# inModeStr "LISTEN", "CROSSCHECK", "RUN"
|
|
|
# "LISTEN" - Get result of the cmd command in result TODO get home script
|
|
|
# "CROSSCHECK" - Check if the command was successufully sent TODO get home script
|
|
|
# "RUN" - Run without crosscheck and get clipboard
|
|
|
# inClipboardTimeoutSec # Second for wait when clipboard will changed
|
|
|
# return {
|
|
|
# "OutStr": <> # Result string
|
|
|
# "IsResponsibleBool": True|False # Flag is RDP is responsible - works only when inModeStr = CROSSCHECK
|
|
|
# }
|
|
|
# example Connector.SessionCMDRun("4d1e48f3ff6c45cc810ea25d8adbeb50","start notepad", "RUN")
|
|
|
def SystemCMDRun(inSessionHexStr, inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboardTimeoutSec = 5, inLogger = None):
|
|
|
lRDPWindow = None # Init the UI object
|
|
|
try:
|
|
|
lRDPWindow = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHexStr}.*", "backend": "win32"}])
|
|
|
except Exception as e:
|
|
|
raise ConnectorExceptions.SessionWindowNotExistError() # Raise error of gui window
|
|
|
lL = inLogger # Alias for logger
|
|
|
lResult = {"OutStr": None,"IsResponsibleBool":True} # Init the result dict
|
|
|
lClipboardTextOld = str(random.randrange(999,9999999)) # Set random text to clipboard (for check purposes that clipboard text has been changed)
|
|
|
Clipboard.TextSet(lClipboardTextOld)
|
|
|
lCrosscheckKeyStr = str(random.randrange(999,9999999))
|
|
|
lRecoveryCMDResponsibleRetryIteratorInt = 0 # Init the retry iterator
|
|
|
lCommandIsTooBigBool = False
|
|
|
lCMDPostFixStr = "" # Case default "RUN"
|
|
|
while lRecoveryCMDResponsibleRetryIteratorInt<gRecoveryCMDResponsibleRetryCountInt: # loop for retry
|
|
|
# # # # # # # # # # # # # OPEN WINDOW RUN # # # # # # # # # # # # # # #
|
|
|
lRecoveryWindowRUNRetryIteratorInt = 0 # Init the retry iterator
|
|
|
while lRecoveryWindowRUNRetryIteratorInt<gRecoveryWindowRUNRetryCountInt: # loop for retry
|
|
|
if inModeStr == "CROSSCHECK":
|
|
|
#lCMDPostFixStr = f"& (echo {lCrosscheckKeyStr} | clip)"
|
|
|
lCMDPostFixStr = f"| (echo {lCrosscheckKeyStr} | clip)" # Bugfix async set clipboard data
|
|
|
elif inModeStr == "LISTEN":
|
|
|
lCMDPostFixStr = f"| clip"
|
|
|
Clipboard.TextSet("") # Clear the clipboard
|
|
|
KeyboardHotkey("win","r") # win+r
|
|
|
time.sleep(gKeyboardHotkeyDelaySecFloat)
|
|
|
KeyboardHotkey("ctrl","a") # Select all
|
|
|
KeyboardHotkey("ctrl","a") # Select all Bugfix - need double ctrl A because some OS reset selestion when ctrl A in RUN window
|
|
|
#time.sleep(gKeyboardHotkeyDelaySecFloat)
|
|
|
keyboard.send("backspace") # Delete selected all
|
|
|
time.sleep(gKeyboardHotkeyDelaySecFloat) # Wait for RUN window will appear ctrl+a+backspace is async - so we need some timeout...
|
|
|
lInputStr = f"cmd /c ({inCMDCommandStr}) {lCMDPostFixStr}" # Generate the output string for RUN window
|
|
|
if len(lInputStr) <= 259:
|
|
|
keyboard.write(lInputStr, delay=0.05) # Write new text
|
|
|
else:
|
|
|
if lL: lL.warning(
|
|
|
f"RDP.SystemCMDRun: ATTENTION! Your command is too big for the RUN window (len is {len(lInputStr)}). Orchestrator will send this command to the new cmd window. ")
|
|
|
lInputStr = "cmd"
|
|
|
lCommandIsTooBigBool = True
|
|
|
keyboard.write(lInputStr, delay=0.05) # Write cmd
|
|
|
time.sleep(gKeyboardHotkeyDelaySecFloat)
|
|
|
# Check if autocomplete
|
|
|
# # # # # # #
|
|
|
KeyboardHotkey("ctrl", "c") # Copy data
|
|
|
# Check the clipboard
|
|
|
lClipboardStr = Clipboard.TextGet() # Get text from clipboard
|
|
|
time.sleep(gKeyboardHotkeyDelaySecFloat)
|
|
|
#lL.debug(f"Clipboard text when check autocomplete:'{lClipboardStr}'")
|
|
|
if lClipboardStr != "": # Send backspace if
|
|
|
time.sleep(gKeyboardHotkeyDelaySecFloat)
|
|
|
keyboard.send("backspace") # Delete selected all
|
|
|
# # # # # # # #
|
|
|
KeyboardHotkey("ctrl","a") # Select all
|
|
|
KeyboardHotkey("ctrl","c") # Copy data
|
|
|
# Check the clipboard
|
|
|
lClipboardWaitTimeStartSec = time.time()
|
|
|
lClipboardStr = Clipboard.TextGet() # Get text from clipboard
|
|
|
while lClipboardStr != lInputStr and (time.time() - lClipboardWaitTimeStartSec) <= inClipboardTimeoutSec:
|
|
|
lClipboardStr = Clipboard.TextGet() # Get text from clipboard
|
|
|
time.sleep(0.5) # wait some time for the next operation
|
|
|
if lClipboardStr == lInputStr: # Cross check the clipboard data and input string
|
|
|
lRecoveryWindowRUNRetryIteratorInt = gRecoveryWindowRUNRetryCountInt # Set final count to block the loop
|
|
|
else: # Failed - wait and retry
|
|
|
if lL: lL.warning(f"RDP::SystemCMDRun: RUN window (win+r) doesn't appear. Wait for {gRecoveryWindowRUNRetryIntervalSecInt}[s.] and retry. Current retry iterator is {lRecoveryWindowRUNRetryIteratorInt}. CMD Str: {lInputStr}") # Log the error
|
|
|
lRecoveryWindowRUNRetryIteratorInt = lRecoveryWindowRUNRetryIteratorInt + 1 # Increment the iterator
|
|
|
if lRecoveryWindowRUNRetryIteratorInt == gRecoveryWindowRUNRetryCountInt:
|
|
|
if lL: lL.warning(f"RDP::SystemCMDRun: RUN window (win+r) retry count is over. Raise the error. CMD Str: {lInputStr}") # Log the error
|
|
|
raise ConnectorExceptions.RUNExistError() # Raise the error
|
|
|
time.sleep(gRecoveryWindowRUNRetryIntervalSecInt) # wait for some seconds before new iteration
|
|
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
|
# # # # # # # # # # # # # RUN CMD # # # # # # # # # # # # # # #
|
|
|
if inModeStr == "LISTEN": # if mode == LISTEN - set random number in clipboard
|
|
|
Clipboard.TextSet(lClipboardTextOld) #
|
|
|
time.sleep(0.5) # wait some time for the next operation
|
|
|
keyboard.press_and_release('enter') # Execute CMD
|
|
|
time.sleep(1)
|
|
|
if lCommandIsTooBigBool == True:
|
|
|
# Case when string is tool big - call cmd and then type text into
|
|
|
#keyboard.write("cmd") # Open cmd
|
|
|
#time.sleep(1)
|
|
|
#keyboard.press_and_release('enter') # Execute CMD
|
|
|
keyboard.write(f"(({inCMDCommandStr}) {lCMDPostFixStr}) && exit", delay=0.05) # send command
|
|
|
time.sleep(1)
|
|
|
keyboard.press_and_release('enter') # Execute command
|
|
|
if inModeStr == "CROSSCHECK" or inModeStr == "LISTEN": # Get OutStr (Case CROSSCHECK and LISTEN)
|
|
|
lClipboardWaitTimeStartSec = time.time()
|
|
|
lResult["OutStr"] = Clipboard.TextGet() # Get text from clipboard
|
|
|
while lResult["OutStr"].startswith(lClipboardTextOld) and (time.time() - lClipboardWaitTimeStartSec) <= inClipboardTimeoutSec:
|
|
|
lResult["OutStr"] = Clipboard.TextGet() # Get text from clipboard
|
|
|
time.sleep(0.5) # wait some time for the next operation
|
|
|
if lResult["OutStr"] == lClipboardTextOld: # If value hasn't been changed - retry send
|
|
|
lRecoveryCMDResponsibleRetryIteratorInt = lRecoveryCMDResponsibleRetryIteratorInt + 1 # increment the iterator
|
|
|
if lL: lL.warning(f"RDP::SystemCMDRun: CMD command doesn't been executed (no changes in clipboard data). Wait for {gRecoveryCMDResponsibleRetryIntervalSecInt}[s.] and retry from start window RUN. Current retry iterator is {lRecoveryCMDResponsibleRetryIteratorInt}. CMD Str: {lInputStr}, Clipboard data: {lResult['OutStr']}") # Log the error
|
|
|
if lRecoveryCMDResponsibleRetryIteratorInt >= gRecoveryCMDResponsibleRetryCountInt: # raise the error if retry count is exceeded
|
|
|
if lL: lL.warning(f"RDP::SystemCMDRun: CMD command retry count is over. Raise the error.") # Log the error
|
|
|
raise ConnectorExceptions.CMDResponsibleError() # Raise the error
|
|
|
time.sleep(gRecoveryCMDResponsibleRetryIntervalSecInt) # wait for some seconds before new iteration
|
|
|
else: # Data was recieved - do crosscheck
|
|
|
if inModeStr == "CROSSCHECK":
|
|
|
if lResult["OutStr"] == f"{lCrosscheckKeyStr} \r\n\x00\x00\x00\x00\x00": # it is ok - do futher check
|
|
|
lResult["IsResponsibleBool"] = True
|
|
|
lRecoveryCMDResponsibleRetryIteratorInt = gRecoveryCMDResponsibleRetryCountInt # turn off the iterator
|
|
|
else:
|
|
|
lResult["IsResponsibleBool"] = False
|
|
|
lRecoveryCMDResponsibleRetryIteratorInt = lRecoveryCMDResponsibleRetryIteratorInt + 1 # increment the iterator
|
|
|
if lL: lL.warning(f"RDP::SystemCMDRun: CMD command doesn't been executed (wrong clipboard data). Wait for {gRecoveryCMDResponsibleRetryIntervalSecInt}[s.] and retry from start window RUN. Current retry iterator is {lRecoveryCMDResponsibleRetryIteratorInt}. CMD Str: {lInputStr}, Clipboard data: {lResult['OutStr']}") # Log the error
|
|
|
if lRecoveryCMDResponsibleRetryIteratorInt >= gRecoveryCMDResponsibleRetryCountInt: # raise the error if retry count is exceeded
|
|
|
if lL: lL.warning(f"RDP::SystemCMDRun: CMD command retry count is over. Raise the error.") # Log the error
|
|
|
raise ConnectorExceptions.CMDResponsibleError() # Raise the error
|
|
|
time.sleep(gRecoveryCMDResponsibleRetryIntervalSecInt) # wait for some seconds before new iteration
|
|
|
else: # clipboard data has been changed but mode is not crosscheck - return success from function
|
|
|
lRecoveryCMDResponsibleRetryIteratorInt = gRecoveryCMDResponsibleRetryCountInt # turn off the iterator
|
|
|
else: # Success - no cross validation is aaplicable
|
|
|
lRecoveryCMDResponsibleRetryIteratorInt = gRecoveryCMDResponsibleRetryCountInt # turn off the iterator
|
|
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
|
return lResult # return the result
|
|
|
# Check if current RDP is responsible
|
|
|
def SystemRDPIsResponsible(inSessionHexStr):
|
|
|
return SystemCMDRun(inSessionHexStr = inSessionHexStr, inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK")["IsResponsibleBool"]
|
|
|
# Click OK on error messages
|
|
|
def SystemRDPWarningClickOk():
|
|
|
# Try to click OK Error window in RUS version
|
|
|
while UIDesktop.UIOSelector_Exist_Bool([{"title": "Подключение к удаленному рабочему столу", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "ОК", "class_name": "Button"}]):
|
|
|
try:
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title": "Подключение к удаленному рабочему столу", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "ОК", "class_name": "Button"}]).click()
|
|
|
except Exception as e:
|
|
|
pass
|
|
|
# Try to click OK Error window in ENG version
|
|
|
while UIDesktop.UIOSelector_Exist_Bool([{"title": "Remote Desktop Connection", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "OK", "class_name": "Button"}]):
|
|
|
try:
|
|
|
UIDesktop.UIOSelector_Get_UIO([{"title": "Remote Desktop Connection", "class_name": "#32770", "backend": "win32"},
|
|
|
{"title": "OK", "class_name": "Button"}]).click()
|
|
|
except Exception as e:
|
|
|
pass
|
|
|
# Bugfix with RDP work
|
|
|
def KeyboardHotkey(inModifierKeyStr,inKeyStr, inDelaySecFloat=gKeyboardHotkeyDelaySecFloat):
|
|
|
keyboard.press(inModifierKeyStr)
|
|
|
time.sleep(inDelaySecFloat)
|
|
|
keyboard.send(inKeyStr)
|
|
|
time.sleep(inDelaySecFloat)
|
|
|
keyboard.release(inModifierKeyStr)
|
|
|
time.sleep(inDelaySecFloat) |
