#RobotDB (Web <SQLIte>) Insert + XLS export (XLSName, SheetName, FlagExportHeader)

Sources/pyOpenRPA/Tools/RobotDB/HowToUse

@@ -0,0 +1,33 @@
+https://www.tutorialspoint.com/online_jquery_editor.php
+
+
+<title>Try jQuery Online</title>
+<script src="//ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
+<script>
+$(document).ready(function() {
+   $("em").addClass("selected");
+   $("#myid").addClass("highlight");
+   $.ajax({
+  type: "POST",
+  url: "http://localhost:81/",
+  data: '{"data":1}',
+  success: null,
+  dataType: "html"
+});
+
+
+SQLInsert
+
+data: [{"TableName":"",RowDict:{"Key1":Value1, "Key2":Value2}}]
+
+$(document).ready(function() {
+   $("em").addClass("selected");
+   $("#myid").addClass("highlight");
+   $.ajax({
+  type: "POST",
+  url: "http://localhost:81/",
+  data: '[{"TableName":"Test", "RowDict":{"Name":"Name1","Description":"DescTest", "Money":100, "Date":"01.01.2020"}}]',
+  success: null,
+  dataType: "html"
+});
+});

Sources/pyOpenRPA/Tools/RobotDB/RobotDB.py

@@ -0,0 +1,41 @@
+import subprocess
+import json
+import datetime
+import time
+import codecs
+import os
+import signal
+import sys #Get input argument
+import pdb
+from . import Server
+import logging
+import copy
+#from .Settings import Settings
+import importlib
+from importlib import util
+
+#Единый глобальный словарь (За основу взять из Settings.py)
+global mGlobalDict
+#Call Settings function from argv[1] file
+################################################
+lSubmoduleFunctionName = "Settings"
+lFileFullPath = sys.argv[1]
+lModuleName = (lFileFullPath.split("\\")[-1])[0:-3]
+lTechSpecification = importlib.util.spec_from_file_location(lModuleName, lFileFullPath)
+lTechModuleFromSpec = importlib.util.module_from_spec(lTechSpecification)
+lTechSpecificationModuleLoader = lTechSpecification.loader.exec_module(lTechModuleFromSpec)
+mGlobalDict = None
+if lSubmoduleFunctionName in dir(lTechModuleFromSpec):
+    # Run SettingUpdate function in submodule
+    mGlobalDict = getattr(lTechModuleFromSpec, lSubmoduleFunctionName)()
+#################################################
+#mGlobalDict = Settings.Settings(sys.argv[1])
+Server.mGlobalDict = mGlobalDict
+
+#Инициализация настроечных параметров
+lDaemonActivityLogDict={} #Словарь отработанных активностей, ключ - кортеж (<activityType>, <datetime>, <processPath || processName>, <processArgs>)
+lDaemonStartDateTime=datetime.datetime.now()
+
+#Инициализация сервера
+lThreadServer = Server.RobotDaemonServer("ServerThread", mGlobalDict)
+lThreadServer.start()

Sources/pyOpenRPA/Tools/RobotDB/Server.py

@@ -0,0 +1,395 @@
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from socketserver import ThreadingMixIn
+import threading
+import json
+from threading import Thread
+import importlib
+import pdb
+import base64
+import uuid
+import datetime
+import os #for path operations
+from http import cookies
+global mGlobalDict
+from . import ServerSettings
+#Authenticate function ()
+# return dict
+# {
+#   "Domain": "", #Empty if Auth is not success
+#   "User": "" #Empty if Auth is not success
+# }
+def AuthenticateVerify(inRequest):
+    lResult={"Domain": "", "User": ""}
+    ######################################
+    #Way 1 - try to find AuthToken
+    lCookies = cookies.SimpleCookie(inRequest.headers.get("Cookie", ""))
+    inRequest.OpenRPA = {}
+    inRequest.OpenRPA["AuthToken"] = None
+    #pdb.set_trace()
+    if "AuthToken" in lCookies:
+        lCookieAuthToken = lCookies.get("AuthToken", "").value
+        if lCookieAuthToken:
+            #Find AuthToken in GlobalDict
+            if lCookieAuthToken in mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("AuthTokensDict", {}):
+                #Auth Token Has Been Founded
+                lResult["Domain"] = mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lCookieAuthToken]["Domain"]
+                lResult["User"] = mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lCookieAuthToken]["User"]
+                #Set auth token
+                inRequest.OpenRPA["AuthToken"] = lCookieAuthToken
+                #Exit earlier
+                return lResult
+    ######################################
+    #Way 2 - try to logon
+    lHeaderAuthorization = inRequest.headers.get("Authorization", "").split(" ")
+    if len(lHeaderAuthorization) == 2:
+        llHeaderAuthorizationDecodedUserPasswordList = base64.b64decode(lHeaderAuthorization[1]).decode("utf-8").split(
+            ":")
+        lUser = llHeaderAuthorizationDecodedUserPasswordList[0]
+        lPassword = llHeaderAuthorizationDecodedUserPasswordList[1]
+        lDomain = ""
+        if "\\" in lUser:
+            lDomain = lUser.split("\\")[0]
+            lUser = lUser.split("\\")[1]
+        #Try to logon - use processor
+        lLogonResult = Processor.Activity(
+            {
+                "Type": "WindowsLogon",
+                "Domain": lDomain,
+                "User": lUser,
+                "Password": lPassword
+            }
+        )
+        #Check result
+        if lLogonResult["Result"]:
+            lResult["Domain"] = lLogonResult["Domain"]
+            lResult["User"] = lLogonResult["User"]
+            #Create token
+            lAuthToken=str(uuid.uuid1())
+            mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lAuthToken] = {}
+            mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["Domain"] = lResult["Domain"]
+            mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["User"] = lResult["User"]
+            mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["FlagDoNotExpire"] = False
+            mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["TokenDatetime"] = datetime.datetime.now()
+            #Set-cookie
+            inRequest.OpenRPA["AuthToken"] = lAuthToken
+            inRequest.OpenRPASetCookie = {}
+            #New engine of server
+            inRequest.OpenRPAResponseDict["SetCookies"]["AuthToken"] = lAuthToken
+            #inRequest.OpenRPAResponse["Set-Cookie"]=[]lResult["Set-Cookie"] = lAuthToken
+            #pdb.set_trace()
+            #inRequest.send_header("Set-Cookie:", f"AuthToken={lAuthToken}")
+    ######################################
+    return lResult
+def AuthenticateBlock(inRequest):
+    # Send response status code
+    inRequest.send_response(401)
+    # Send headers
+    inRequest.send_header('Content-type', 'text/html')
+    inRequest.send_header('WWW-Authenticate', 'Basic')  # Always ask login pass
+    inRequest.end_headers()
+    # Write content as utf-8 data
+    inRequest.wfile.write(bytes("", "utf8"))
+#Check access before execute the action
+#return bool True - go execute, False - dont execute
+def UserAccessCheckBefore(inMethod, inRequest):
+    # Help def - Get access flag from dict
+    #pdb.set_trace()
+    def HelpGetFlag(inAccessRuleItem, inRequest, inGlobalDict, inAuthenticateDict):
+        if "FlagAccess" in inAccessRuleItem:
+            return inAccessRuleItem["FlagAccess"]
+        elif "FlagAccessDefRequestGlobalAuthenticate" in inAccessRuleItem:
+            return inAccessRuleItem["FlagAccessDefRequestGlobalAuthenticate"](inRequest, inGlobalDict,
+                                                                              inAuthenticateDict)
+    ##########################################
+    inMethod=inMethod.upper()
+    #Prepare result false
+    lResult = False
+    lAuthToken = inRequest.OpenRPA["AuthToken"]
+    #go next if user is identified
+    lUserDict = None
+    if lAuthToken:
+        lUserDict = mGlobalDict["Server"]["AccessUsers"]["AuthTokensDict"][lAuthToken]
+    #pdb.set_trace()
+    ########################################
+    ########################################
+    #Check general before rule (without User domain)
+    #Check rules
+    for lAccessRuleItem in mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("RuleMethodMatchURLBeforeList", []):
+        #Go next execution if flag is false
+        if not lResult:
+            #Check if Method is identical
+            if lAccessRuleItem["Method"].upper() == inMethod:
+                #check Match type variant: BeginWith
+                if lAccessRuleItem["MatchType"].upper() == "BEGINWITH":
+                    lURLPath = inRequest.path
+                    lURLPath = lURLPath.upper()
+                    if lURLPath.startswith(lAccessRuleItem["URL"].upper()):
+                        lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+                # check Match type variant: Contains
+                elif lAccessRuleItem["MatchType"].upper() == "CONTAINS":
+                    lURLPath = inRequest.path
+                    lURLPath = lURLPath.upper()
+                    if lURLPath.contains(lAccessRuleItem["URL"].upper()):
+                        lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+                # check Match type variant: Equal
+                elif lAccessRuleItem["MatchType"].upper() == "EQUAL":
+                    if lAccessRuleItem["URL"].upper() == inRequest.path.upper():
+                        lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+                # check Match type variant: EqualCase
+                elif lAccessRuleItem["MatchType"].upper() == "EQUALCASE":
+                    if lAccessRuleItem["URL"] == inRequest.path:
+                        lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+    #########################################
+    #########################################
+    #Do check if lResult is false
+    if not lResult:
+        #Check access by User Domain
+        #Check rules to find first appicable
+        #Check rules
+        for lAccessRuleItem in mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("RuleDomainUserDict", {}).get((lUserDict["Domain"].upper(), lUserDict["User"].upper()), {}).get("MethodMatchURLBeforeList", []):
+            #Go next execution if flag is false
+            if not lResult:
+                #Check if Method is identical
+                if lAccessRuleItem["Method"].upper() == inMethod:
+                    #check Match type variant: BeginWith
+                    if lAccessRuleItem["MatchType"].upper() == "BEGINWITH":
+                        lURLPath = inRequest.path
+                        lURLPath = lURLPath.upper()
+                        if lURLPath.startswith(lAccessRuleItem["URL"].upper()):
+                            lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+                    #check Match type variant: Contains
+                    elif lAccessRuleItem["MatchType"].upper() == "CONTAINS":
+                        lURLPath = inRequest.path
+                        lURLPath = lURLPath.upper()
+                        if lURLPath.contains(lAccessRuleItem["URL"].upper()):
+                            lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+                    # check Match type variant: Equal
+                    elif lAccessRuleItem["MatchType"].upper() == "EQUAL":
+                        if lAccessRuleItem["URL"].upper() == inRequest.path.upper():
+                            lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+                    # check Match type variant: EqualCase
+                    elif lAccessRuleItem["MatchType"].upper() == "EQUALCASE":
+                        if lAccessRuleItem["URL"] == inRequest.path:
+                            lResult = HelpGetFlag(lAccessRuleItem, inRequest, mGlobalDict, lUserDict)
+    #####################################
+    #####################################
+    #Return lResult
+    return lResult
+# HTTPRequestHandler class
+class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
+    #Tech def
+    #return {"headers":[],"body":"","statuscode":111}
+    def URLItemCheckDo(self, inURLItem, inMethod):
+        ###############################
+        #Tech sub def - do item
+        ################################
+        def URLItemDo(inURLItem,inRequest,inGlobalDict):
+            inResponseDict = inRequest.OpenRPAResponseDict
+            #Set status code 200
+            inResponseDict["StatusCode"] = 200
+            #Content-type
+            if "ResponseContentType" in inURLItem:
+                inResponseDict["Headers"]["Content-type"] = inURLItem["ResponseContentType"]
+            #If file path is set
+            if "ResponseFilePath" in inURLItem:
+                lFileObject = open(inURLItem["ResponseFilePath"], "rb")
+                # Write content as utf-8 data
+                inResponseDict["Body"] = lFileObject.read()
+                # Закрыть файловый объект
+                lFileObject.close()
+            #If function is set
+            if "ResponseDefRequestGlobal" in inURLItem:
+                inURLItem["ResponseDefRequestGlobal"](inRequest, inGlobalDict)
+            if "ResponseFolderPath" in inURLItem:
+                lRequestPath = inRequest.path
+                lFilePathSecondPart = lRequestPath.replace(inURLItem["URL"],"")
+                lFilePath = os.path.join(inURLItem["ResponseFolderPath"],lFilePathSecondPart)
+                #print(f"File full path {lFilePath}")
+                #Check if file exist
+                if os.path.exists(lFilePath) and os.path.isfile(lFilePath):
+                    lFileObject = open(lFilePath, "rb")
+                    # Write content as utf-8 data
+                    inResponseDict["Body"] = lFileObject.read()
+                    inResponseDict["ContentType"]= "application/octet-stream"
+                    # Закрыть файловый объект
+                    lFileObject.close()
+        ##############################################
+        if inURLItem["Method"].upper() == inMethod.upper():
+            # check Match type variant: BeginWith
+            if inURLItem["MatchType"].upper() == "BEGINWITH":
+                lURLPath = self.path
+                lURLPath = lURLPath.upper()
+                if lURLPath.startswith(inURLItem["URL"].upper()):
+                    URLItemDo(inURLItem, self, mGlobalDict)
+                    return True
+            # check Match type variant: Contains
+            elif inURLItem["MatchType"].upper() == "CONTAINS":
+                lURLPath = self.path
+                lURLPath = lURLPath.upper()
+                if lURLPath.contains(inURLItem["URL"].upper()):
+                    URLItemDo(inURLItem, self, mGlobalDict)
+                    return True
+            # check Match type variant: Equal
+            elif inURLItem["MatchType"].upper() == "EQUAL":
+                if inURLItem["URL"].upper() == self.path.upper():
+                    URLItemDo(inURLItem, self, mGlobalDict)
+                    return True
+            # check Match type variant: EqualCase
+            elif inURLItem["MatchType"].upper() == "EQUALCASE":
+                if inURLItem["URL"] == self.path:
+                    URLItemDo(inURLItem, self, mGlobalDict)
+                    return True
+        return False
+    #ResponseContentTypeFile
+    def SendResponseContentTypeFile(self, inContentType, inFilePath):
+        # Send response status code
+        self.send_response(200)
+        # Send headers
+        self.send_header('Content-type', inContentType)
+        #Check if var exist
+        if hasattr(self, "OpenRPASetCookie"):
+            self.send_header("Set-Cookie", f"AuthToken={self.OpenRPA['AuthToken']}")
+        self.end_headers()
+        lFileObject = open(inFilePath, "rb") 
+        # Write content as utf-8 data
+        self.wfile.write(lFileObject.read())
+        #Закрыть файловый объект
+        lFileObject.close()
+    # ResponseContentTypeFile
+    def ResponseDictSend(self):
+        inResponseDict = self.OpenRPAResponseDict
+        # Send response status code
+        self.send_response(inResponseDict["StatusCode"])
+        # Send headers
+        for lItemKey, lItemValue in inResponseDict["Headers"].items():
+            self.send_header(lItemKey, lItemValue)
+        # Send headers: Set-Cookie
+        for lItemKey, lItemValue in inResponseDict["SetCookies"].items():
+            self.send_header("Set-Cookie", f"{lItemKey}={lItemValue}")
+        #Close headers section in response
+        self.end_headers()
+        # Write content as utf-8 data
+        self.wfile.write(inResponseDict["Body"])
+    def do_GET(self):
+        # Prepare result dict
+        lResponseDict = {"Headers": {}, "SetCookies": {}, "Body": b"", "StatusCode": None}
+        self.OpenRPAResponseDict = lResponseDict
+        #####################################
+        #Do authentication
+        #Check if authentication is turned on
+        #####################################
+        lFlagAccessUserBlock=False
+        lAuthenticateDict = {"Domain": "", "User": ""}
+        if mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("FlagCredentialsAsk", False):
+            lAuthenticateDict = AuthenticateVerify(self)
+            if not lAuthenticateDict["User"]:
+                lFlagAccessUserBlock=True
+        # Logging
+        mGlobalDict["Logger"].info(f"HTTP request /. Domain: {lAuthenticateDict['Domain']}, User: {lAuthenticateDict['User']}")
+        if lFlagAccessUserBlock:
+            AuthenticateBlock(self)
+        #####################################
+        else:
+            #Check the user access (if flag)
+            ####################################
+            lFlagUserAccess = True
+            #If need user authentication
+            if mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("FlagCredentialsAsk", False):
+                lFlagUserAccess = UserAccessCheckBefore("GET", self)
+            ######################################
+            if lFlagUserAccess:
+                lOrchestratorFolder = "\\".join(__file__.split("\\")[:-1])
+                ############################
+                #New server engine (url from global dict (URLList))
+                ############################
+                for lURLItem in mGlobalDict["Server"]["URLList"]:
+                    #Check if all condition are applied
+                    lFlagURLIsApplied=False
+                    lFlagURLIsApplied=self.URLItemCheckDo(lURLItem, "GET")
+                    if lFlagURLIsApplied:
+                        self.ResponseDictSend()
+                        return
+            else:
+                #Set access denied code
+                # Send response status code
+                self.send_response(403)
+                # Send headers
+                self.end_headers()
+    # POST
+    def do_POST(self):
+        # Prepare result dict
+        #pdb.set_trace()
+        lResponseDict = {"Headers": {}, "SetCookies":{}, "Body": b"", "StatusCode": None}
+        self.OpenRPAResponseDict = lResponseDict
+        #####################################
+        #Do authentication
+        #Check if authentication is turned on
+        #####################################
+        lFlagAccessUserBlock=False
+        lAuthenticateDict = {"Domain": "", "User": ""}
+        if mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("FlagCredentialsAsk", False):
+            lAuthenticateDict = AuthenticateVerify(self)
+            if not lAuthenticateDict["User"]:
+                lFlagAccessUserBlock=True
+        if lFlagAccessUserBlock:
+            AuthenticateBlock(self)
+        #####################################
+        else:
+            #Check the user access (if flag)
+            ####################################
+            lFlagUserAccess = True
+            #If need user authentication
+            if mGlobalDict.get("Server", {}).get("AccessUsers", {}).get("FlagCredentialsAsk", False):
+                lFlagUserAccess = UserAccessCheckBefore("POST", self)
+            ######################################
+            if lFlagUserAccess:
+                lOrchestratorFolder = "\\".join(__file__.split("\\")[:-1])
+                ############################
+                #New server engine (url from global dict (URLList))
+                ############################
+                for lURLItem in mGlobalDict["Server"]["URLList"]:
+                    #Check if all condition are applied
+                    lFlagURLIsApplied=False
+                    lFlagURLIsApplied=self.URLItemCheckDo(lURLItem, "POST")
+                    if lFlagURLIsApplied:
+                        self.ResponseDictSend()
+                        return
+                return
+            else:
+                #Set access denied code
+                # Send response status code
+                self.send_response(403)
+                # Send headers
+                self.end_headers()
+                return
+    #Logging
+    #!Turn it on to stop print in console
+    #def log_message(self, format, *args):
+    #    return
+class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
+    """Handle requests in a separate thread."""
+    def finish_request(self, request, client_address):
+        request.settimeout(30)
+        # "super" can not be used because BaseServer is not created from object
+        HTTPServer.finish_request(self, request, client_address)
+#inGlobalDict
+# "JSONConfigurationDict":<JSON>
+class RobotDaemonServer(Thread):
+    def __init__(self,name,inGlobalDict):
+        Thread.__init__(self)
+        self.name = name
+        # Update the global dict
+        ServerSettings.SettingsUpdate(mGlobalDict)
+    def run(self):
+        inServerAddress="";
+        inPort = mGlobalDict["Server"]["ListenPort"];
+        # Server settings
+        # Choose port 8080, for port 80, which is normally used for a http server, you need root access
+        server_address = (inServerAddress, inPort)
+        #httpd = HTTPServer(server_address, testHTTPServer_RequestHandler)
+        # Logging
+        mGlobalDict["Logger"].info(f"Server init. Listen URL: {inServerAddress}, Listen port: {inPort}")
+        #httpd.serve_forever()
+        httpd = ThreadedHTTPServer(server_address, testHTTPServer_RequestHandler)
+        #print('Starting server, use <Ctrl-C> to stop')
+        httpd.serve_forever()

Sources/pyOpenRPA/Tools/RobotDB/ServerSettings.py

@@ -0,0 +1,77 @@
+import json
+#Insert in DB
+def SQLInsert(inRequest,inGlobalDict):
+    inResponseDict = inRequest.OpenRPAResponseDict
+    # Create result JSON
+    lResultJSON = {"FlagSQLInsert": False}
+    #Read the body
+    #ReadRequest
+    lInputJSON={}
+    if inRequest.headers.get('Content-Length') is not None:
+        lInputByteArrayLength = int(inRequest.headers.get('Content-Length'))
+        lInputByteArray=inRequest.rfile.read(lInputByteArrayLength)
+        print(lInputByteArray.decode('utf8'))
+        #Превращение массива байт в объект
+        lInputJSON=json.loads(lInputByteArray.decode('utf8'))
+    ########################################
+    print(lInputJSON)
+    import sqlite3
+    conn = sqlite3.connect(inGlobalDict["SQLite"]["DBPath"])
+    c = conn.cursor()
+    # Loop for rows
+    for lRowItem in lInputJSON:
+        my_dict = lRowItem["RowDict"]
+        # Insert a row of data
+        columns = ', '.join(my_dict.keys())
+        placeholders = ':'+', :'.join(my_dict.keys())
+        query = f'INSERT INTO {lRowItem["TableName"]} (%s) VALUES (%s)' % (columns, placeholders)
+        c.execute(query, my_dict)
+    # Save (commit) the changes
+    conn.commit()
+    # We can also close the connection if we are done with it.
+    # Just be sure any changes have been committed or they will be lost.
+    conn.close()
+    ########################################
+    # Send message back to client
+    message = json.dumps(lResultJSON)
+    # Write content as utf-8 data
+    inResponseDict["Body"] = bytes(message, "utf8")
+
+def GetScreenshot(inRequest,inGlobalDict):
+    # Get Screenshot
+    def SaveScreenshot(inFilePath):
+        # grab fullscreen
+        # Save the entire virtual screen as a PNG
+        lScreenshot = getScreenAsImage()
+        lScreenshot.save('screenshot.png', format='png')
+        # lScreenshot = ScreenshotSecondScreen.grab_screen()
+        # save image file
+        # lScreenshot.save('screenshot.png')
+    # Сохранить файл на диск
+    SaveScreenshot("Screenshot.png")
+    lFileObject = open("Screenshot.png", "rb")
+    # Write content as utf-8 data
+    inRequest.OpenRPAResponseDict["Body"] = lFileObject.read()
+    # Закрыть файловый объект
+    lFileObject.close()
+def SettingsUpdate(inGlobalConfiguration):
+    import os
+    import pyOpenRPA.Orchestrator
+    lOrchestratorFolder = "\\".join(pyOpenRPA.Orchestrator.__file__.split("\\")[:-1])
+    lURLList = \
+        [ #List of available URLs with the orchestrator server
+            #{
+            #    "Method":"GET|POST",
+            #    "URL": "/index", #URL of the request
+            #    "MatchType": "", #"BeginWith|Contains|Equal|EqualCase",
+            #    "ResponseFilePath": "", #Absolute or relative path
+            #    "ResponseFolderPath": "", #Absolute or relative path
+            #    "ResponseContentType": "", #HTTP Content-type
+            #    "ResponseDefRequestGlobal": None #Function with str result
+            #}
+            #Orchestrator basic dependencies
+            {"Method":"POST", "URL": "/", "MatchType": "EqualCase", "ResponseDefRequestGlobal": SQLInsert, "ResponseContentType": "text/html"},
+            {"Method":"GET", "URL": "/3rdParty/Semantic-UI-CSS-master/semantic.min.css", "MatchType": "EqualCase", "ResponseFilePath": os.path.join(lOrchestratorFolder, "..\\Resources\\Web\\Semantic-UI-CSS-master\\semantic.min.css"), "ResponseContentType": "text/css"}
+        ]
+    inGlobalConfiguration["Server"]["URLList"]=inGlobalConfiguration["Server"]["URLList"]+lURLList
+    return inGlobalConfiguration

Sources/pyOpenRPA/Tools/RobotDB/__init__.py

@@ -0,0 +1,7 @@
+r"""
+
+The OpenRPA package (from UnicodeLabs)
+
+"""
+__all__ = []
+__author__ = 'Ivan Maslov <ivan.maslov@unicodelabs.ru>'

Sources/pyOpenRPA/Tools/RobotDB/__main__.py

@@ -0,0 +1,4 @@
+import sys
+lFolderPath = "\\".join(__file__.split("\\")[:-3])
+sys.path.insert(0, lFolderPath)
+from pyOpenRPA.Tools.RobotDB import RobotDB

Utils/RobotDB/AccessUser_ND.py

@@ -0,0 +1,27 @@
+def SettingsUpdate(inDict):
+    ##################################################
+    #""/"ND" MethodMatchURLList
+    l__ND_RuleMethodMatchURLBeforeList={
+        ("","ND"): {
+            "MethodMatchURLBeforeList": [
+                {
+                    "Method":"GET",
+                    "MatchType":"Beginwith",
+                    "URL":"/",
+                    #"FlagAccessDefRequestGlobalAuthenticate": TestDef
+                    "FlagAccess": True
+                },
+                {
+                    "Method":"POST",
+                    "MatchType":"Beginwith",
+                    "URL":"/",
+                    #"FlagAccessDefRequestGlobalAuthenticate": TestDef
+                    "FlagAccess": True
+                }
+            ]
+        }
+    }
+    #Append to global list
+    inDict["Server"]["AccessUsers"]["RuleDomainUserDict"].update(l__ND_RuleMethodMatchURLBeforeList)
+    #Return current dict
+    return inDict

Utils/RobotDB/AccessUser_SuperToken.py

@@ -0,0 +1,35 @@
+import datetime
+def SettingsUpdate(inDict):
+    ##################################################
+    #""/"SuperToken" MethodMatchURLList
+    l__SuperToken_RuleMethodMatchURLBeforeList={
+        ("","SUPERTOKEN"): { #!!!!!only in upper case!!!!
+            "MethodMatchURLBeforeList": [
+                {
+                    "Method":"GET",
+                    "MatchType":"Beginwith",
+                    "URL":"/",
+                    #"FlagAccessDefRequestGlobalAuthenticate": TestDef
+                    "FlagAccess": True
+                },
+                {
+                    "Method":"POST",
+                    "MatchType":"Beginwith",
+                    "URL":"/",
+                    #"FlagAccessDefRequestGlobalAuthenticate": TestDef
+                    "FlagAccess": True
+                }
+            ]
+        }
+    }
+    #Append to global list
+    inDict["Server"]["AccessUsers"]["RuleDomainUserDict"].update(l__SuperToken_RuleMethodMatchURLBeforeList)
+    #"<AuthToken>":{"User":"", "Domain":"", "TokenDatetime":<Datetime>}
+    #!!!!!!!!!!!!!!!!!!!!!!!
+    #Attention: default supertoken is 1992-04-03-0643-ru-b4ff-openrpa52zzz - please change it when you will customize OpenRPA in your company
+    #!!!!!!!!!!!!!!!!!!!!!!!
+    inDict["Server"]["AccessUsers"]["AuthTokensDict"].update(
+        {"1992-04-03-0643-ru-b4ff-openrpa52zzz":{"User":"SuperToken", "Domain":"", "TokenDatetime":  datetime.datetime.now(), "FlagDoNotExpire":True}}
+    )
+    #Return current dict
+    return inDict

Utils/RobotDB/SettingsExample.py

@@ -0,0 +1,107 @@
+import psutil
+import datetime
+import logging
+import os
+
+#RobotDB settings
+def Settings():
+    import os
+    import pyOpenRPA.Orchestrator
+    lOrchestratorFolder = "\\".join(pyOpenRPA.Orchestrator.__file__.split("\\")[:-1])
+    mDict = {
+        "SQLite":{
+            "DBPath":os.path.join("\\".join(__file__.split("\\")[:-1]),"DB.db")
+        },
+        "Server": {
+            "ListenPort_": "Порт, по которому можно подключиться к демону",
+            "ListenPort": 81,
+            "ListenURLList": [
+                {
+                    "Description": "Local machine test",
+                    "URL_": "Сетевое расположение сервера демона",
+                    "URL": "http://127.0.0.1:81"
+                }
+            ],
+            "AccessUsers": { #Default - all URL is blocked
+                "FlagCredentialsAsk": True, #Turn on Authentication
+                "RuleDomainUserDict": {
+                    #("DOMAIN", "USER"): { !!!!!only in upper case!!!!
+                    #    "MethodMatchURLBeforeList": [
+                    #       {
+                    #           "Method":"GET|POST",
+                    #           "MatchType":"BeginWith|Contains|Equal|EqualCase",
+                    #           "URL":"",
+                    #           "FlagAccessDefRequestGlobalAuthenticate": None, #Return bool
+                    #           "FlagAccess": True       
+                    #        }
+                    #    ]
+                    #}
+                },
+                "RuleMethodMatchURLBeforeList": [ #General MethodMatchURL list (no domain/user)
+                    #       {
+                    #           "Method":"GET|POST",
+                    #           "MatchType":"BeginWith|Contains|Equal|EqualCase",
+                    #           "URL":"",
+                    #           "FlagAccessDefRequestGlobalAuthenticate": None, #Return bool
+                    #           "FlagAccess": True       
+                    #        }
+                ],
+                "AuthTokensDict": {
+                    #"<AuthToken>":{"User":"", "Domain":"", "TokenDatetime":<Datetime>, "FlagDoNotExpire":True}
+                }
+            },
+            "URLList":[ #List of available URLs with the orchestrator server
+                #{
+                #    "Method":"GET|POST",
+                #    "URL": "/index", #URL of the request
+                #    "MatchType": "", #"BeginWith|Contains|Equal|EqualCase",
+                #    "ResponseFilePath": "", #Absolute or relative path
+                #    "ResponseFolderPath": "", #Absolute or relative path
+                #    "ResponseContentType": "", #HTTP Content-type
+                #    "ResponseDefRequestGlobal": None #Function with str result
+                #}
+                ]
+        },
+        "Logger": logging.getLogger("RobotDB"),
+        "Storage": {} #Orchestrator storage - not used
+    }
+    #Создать файл логирования
+    # add filemode="w" to overwrite
+    if not os.path.exists("Reports"):
+        os.makedirs("Reports")
+    ##########################
+    #Подготовка логгера Robot
+    #########################
+    mRobotLogger=mDict["Logger"]
+    mRobotLogger.setLevel(logging.INFO)
+    # create the logging file handler
+    mRobotLoggerFH = logging.FileHandler("Reports\ReportRobotDB_"+datetime.datetime.now().strftime("%Y_%m_%d")+".log")
+    mRobotLoggerFormatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    mRobotLoggerFH.setFormatter(mRobotLoggerFormatter)
+    # add handler to logger object
+    mRobotLogger.addHandler(mRobotLoggerFH)
+    ############################################
+    ###################################
+    #Init .py files from Settings folder
+    ####################################
+    #Get file list from Settings folder
+    import os
+    import pdb
+    #lFunction to call in subfiles
+    lSubmoduleFunctionName = "SettingsUpdate"
+    #lSettingsPath = os.path.join(inSettingsFolderPath, "Settings")
+    lSettingsPath = "\\".join(__file__.split("\\")[:-1])
+    #lSettingsPath = os.path.join(os.getcwd(), "Settings")
+    #Lambda function to get files .py from settings folder except Settings.py
+    lFileList = [f for f in os.listdir(lSettingsPath) if os.path.isfile(os.path.join(lSettingsPath, f)) and f.split(".")[-1] == "py" and os.path.join(lSettingsPath, f) != __file__]
+    import importlib.util
+    for lModuleFilePathItem in lFileList:
+        lModuleName = lModuleFilePathItem[0:-3]
+        lFileFullPath = os.path.join(lSettingsPath, lModuleFilePathItem)
+        lTechSpecification = importlib.util.spec_from_file_location(lModuleName, lFileFullPath)
+        lTechModuleFromSpec = importlib.util.module_from_spec(lTechSpecification)
+        lTechSpecificationModuleLoader = lTechSpecification.loader.exec_module(lTechModuleFromSpec)
+        if lSubmoduleFunctionName in dir(lTechModuleFromSpec):
+            #Run SettingUpdate function in submodule
+            getattr(lTechModuleFromSpec, lSubmoduleFunctionName)(mDict)
+    return mDict

Utils/RobotDB/pyOpenRPA.Tools.RobotDB_x64.cmd

@@ -0,0 +1,4 @@
+cd %~dp0..\..\Sources
+copy /Y ..\Resources\WPy64-3720\python-3.7.2.amd64\python.exe ..\Resources\WPy64-3720\python-3.7.2.amd64\OpenRPA_RobotDB.exe
+..\Resources\WPy64-3720\python-3.7.2.amd64\OpenRPA_RobotDB.exe -m pyOpenRPA.Tools.RobotDB "..\Utils\RobotDB\SettingsExample.py"
+pause >nul