|
|
# inRequest.OpenRPA = {}
|
|
|
# inRequest.OpenRPA["AuthToken"] = None
|
|
|
# inRequest.OpenRPA["Domain"] = None
|
|
|
# inRequest.OpenRPA["User"] = None
|
|
|
|
|
|
# lResponseDict = {"Headers": {}, "SetCookies": {}, "Body": b"", "StatusCode": None}
|
|
|
# self.OpenRPAResponseDict = lResponseDict
|
|
|
|
|
|
#from http.client import HTTPException
|
|
|
from email import header
|
|
|
from http.server import BaseHTTPRequestHandler, HTTPServer
|
|
|
from socketserver import ThreadingMixIn
|
|
|
import threading
|
|
|
import json
|
|
|
from threading import Thread
|
|
|
import inspect
|
|
|
|
|
|
from requests import request
|
|
|
|
|
|
from pyOpenRPA.Tools import CrossOS
|
|
|
from . import Processor # Add new processor
|
|
|
from . import ProcessorOld # Support old processor - deprecated defs only for backward compatibility
|
|
|
import urllib.parse # decode URL in string
|
|
|
import importlib
|
|
|
import pdb
|
|
|
import base64
|
|
|
import uuid
|
|
|
import datetime
|
|
|
import os #for path operations
|
|
|
from http import cookies
|
|
|
gSettingsDict = {}
|
|
|
from . import ServerSettings
|
|
|
from . import __Orchestrator__
|
|
|
import copy
|
|
|
import mimetypes
|
|
|
mimetypes.add_type("font/woff2",".woff2")
|
|
|
mimetypes.add_type("text/javascript",".js")
|
|
|
|
|
|
|
|
|
|
|
|
from typing import Union
|
|
|
# объявление import
|
|
|
from fastapi import FastAPI, Form, Request, HTTPException, Depends, Header, Response, Body
|
|
|
from fastapi.responses import PlainTextResponse, HTMLResponse, FileResponse
|
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
from fastapi.templating import Jinja2Templates
|
|
|
|
|
|
from pydantic import BaseModel
|
|
|
import uvicorn
|
|
|
|
|
|
|
|
|
import io
|
|
|
from starlette.responses import StreamingResponse
|
|
|
|
|
|
|
|
|
gCacheDict = {}
|
|
|
|
|
|
|
|
|
# Tool to merge complex dictionaries
|
|
|
def __ComplexDictMerge2to1__(in1Dict, in2Dict):
|
|
|
lPathList=None
|
|
|
if lPathList is None: lPathList = []
|
|
|
for lKeyStr in in2Dict:
|
|
|
if lKeyStr in in1Dict:
|
|
|
if isinstance(in1Dict[lKeyStr], dict) and isinstance(in2Dict[lKeyStr], dict):
|
|
|
__ComplexDictMerge2to1__(in1Dict[lKeyStr], in2Dict[lKeyStr])
|
|
|
elif in1Dict[lKeyStr] == in2Dict[lKeyStr]:
|
|
|
pass # same leaf value
|
|
|
else:
|
|
|
raise Exception('Conflict at %s' % '.'.join(lPathList + [str(lKeyStr)]))
|
|
|
else:
|
|
|
in1Dict[lKeyStr] = in2Dict[lKeyStr]
|
|
|
return in1Dict
|
|
|
|
|
|
# Tool to merge complex dictionaries - no exceptions, just overwrite dict 2 in dict 1
|
|
|
def __ComplexDictMerge2to1Overwrite__(in1Dict, in2Dict):
|
|
|
"""
|
|
|
Merge in2Dict in in1Dict. In conflict override and get value from dict 2
|
|
|
|
|
|
:param in1Dict: Source dict. Save the link (structure)
|
|
|
:param in2Dict: New data dict
|
|
|
:return: Merged dict 1
|
|
|
"""
|
|
|
lPathList=None
|
|
|
if lPathList is None: lPathList = []
|
|
|
for lKeyStr in in2Dict:
|
|
|
if lKeyStr in in1Dict:
|
|
|
if isinstance(in1Dict[lKeyStr], dict) and isinstance(in2Dict[lKeyStr], dict):
|
|
|
__ComplexDictMerge2to1Overwrite__(in1Dict[lKeyStr], in2Dict[lKeyStr])
|
|
|
else:
|
|
|
in1Dict[lKeyStr] = in2Dict[lKeyStr]
|
|
|
else:
|
|
|
in1Dict[lKeyStr] = in2Dict[lKeyStr]
|
|
|
return in1Dict
|
|
|
|
|
|
|
|
|
def AuthenticateBlock(inRequest):
|
|
|
raise HTTPException(status_code=401, detail="here is the details", headers={'Content-type':'text/html', 'WWW-Authenticate':'Basic'})
|
|
|
|
|
|
#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()
|
|
|
gSettingsDict = __Orchestrator__.GSettingsGet()
|
|
|
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
|
|
|
#print(f"lAuthToken: {lAuthToken}")
|
|
|
if lAuthToken:
|
|
|
lUserDict = gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lAuthToken]
|
|
|
#print(f"lUserDict: {lUserDict}")
|
|
|
#pdb.set_trace()
|
|
|
########################################
|
|
|
########################################
|
|
|
#Check general before rule (without User domain)
|
|
|
#Check rules
|
|
|
inRuleMatchURLList = gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("RuleMethodMatchURLBeforeList", [])
|
|
|
for lAccessRuleItem in inRuleMatchURLList:
|
|
|
#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, gSettingsDict, 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, gSettingsDict, lUserDict)
|
|
|
# check Match type variant: Equal
|
|
|
elif lAccessRuleItem["MatchType"].upper() == "EQUAL":
|
|
|
if lAccessRuleItem["URL"].upper() == inRequest.path.upper():
|
|
|
lResult = HelpGetFlag(lAccessRuleItem, inRequest, gSettingsDict, lUserDict)
|
|
|
# check Match type variant: EqualCase
|
|
|
elif lAccessRuleItem["MatchType"].upper() == "EQUALCASE":
|
|
|
if lAccessRuleItem["URL"] == inRequest.path:
|
|
|
lResult = HelpGetFlag(lAccessRuleItem, inRequest, gSettingsDict, lUserDict)
|
|
|
#########################################
|
|
|
#########################################
|
|
|
#Do check if lResult is false
|
|
|
if not lResult:
|
|
|
#Check access by User Domain
|
|
|
#Check rules to find first appicable
|
|
|
#Check rules
|
|
|
lMethodMatchURLList = gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("RuleDomainUserDict", {}).get((lUserDict["Domain"].upper(), lUserDict["User"].upper()), {}).get("MethodMatchURLBeforeList", [])
|
|
|
if len(lMethodMatchURLList) > 0:
|
|
|
for lAccessRuleItem in lMethodMatchURLList:
|
|
|
#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, gSettingsDict, 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, gSettingsDict, lUserDict)
|
|
|
# check Match type variant: Equal
|
|
|
elif lAccessRuleItem["MatchType"].upper() == "EQUAL":
|
|
|
if lAccessRuleItem["URL"].upper() == inRequest.path.upper():
|
|
|
lResult = HelpGetFlag(lAccessRuleItem, inRequest, gSettingsDict, lUserDict)
|
|
|
# check Match type variant: EqualCase
|
|
|
elif lAccessRuleItem["MatchType"].upper() == "EQUALCASE":
|
|
|
if lAccessRuleItem["URL"] == inRequest.path:
|
|
|
lResult = HelpGetFlag(lAccessRuleItem, inRequest, gSettingsDict, lUserDict)
|
|
|
else:
|
|
|
return True
|
|
|
#####################################
|
|
|
#####################################
|
|
|
#Return lResult
|
|
|
return lResult
|
|
|
|
|
|
class HTTPRequestOld():
|
|
|
mRequest:Request = None
|
|
|
mResponse:Response = None
|
|
|
OpenRPA: dict = {}
|
|
|
headers={}
|
|
|
|
|
|
def __init__(self,inRequest,inResponse,inAuthDict):
|
|
|
self.mRequest = inRequest
|
|
|
self.mResponse = inResponse
|
|
|
if inAuthDict is None:
|
|
|
self.OpenRPA = {}
|
|
|
self.OpenRPA["IsSuperToken"] = False
|
|
|
self.OpenRPA["AuthToken"] = None
|
|
|
self.OpenRPA["Domain"] = None
|
|
|
self.OpenRPA["User"] = None
|
|
|
else: self.OpenRPA = inAuthDict
|
|
|
self.headers=inRequest.headers
|
|
|
|
|
|
# Def to check User Role access grants
|
|
|
def UACClientCheck(self, inRoleKeyList): # Alias
|
|
|
return self.UserRoleAccessAsk(inRoleKeyList=inRoleKeyList)
|
|
|
def UserRoleAccessAsk(self, inRoleKeyList):
|
|
|
lResult = True # Init flag
|
|
|
lRoleHierarchyDict = self.UserRoleHierarchyGet() # get the Hierarchy
|
|
|
# Try to get value from key list
|
|
|
lKeyValue = lRoleHierarchyDict # Init the base
|
|
|
for lItem in inRoleKeyList:
|
|
|
if type(lKeyValue) is dict:
|
|
|
if lItem in lKeyValue: # Has key
|
|
|
lKeyValue = lKeyValue[lItem] # Get the value and go to the next loop iteration
|
|
|
else: # Else branch - true or false
|
|
|
if len(lKeyValue)>0: # False - if Dict has some elements
|
|
|
lResult = False # Set the False Flag
|
|
|
else:
|
|
|
lResult = True # Set the True flag
|
|
|
break # Stop the loop
|
|
|
else: # Has element with no detalization - return True
|
|
|
lResult = True # Set the flag
|
|
|
break # Close the loop
|
|
|
return lResult # Return the result
|
|
|
|
|
|
# Def to get hierarchy of the current user roles
|
|
|
# if return {} - all is available
|
|
|
def UserRoleHierarchyGet(self):
|
|
|
#global gSettingsDict
|
|
|
lDomainUpperStr = self.OpenRPA["Domain"].upper()
|
|
|
lUserUpperStr = self.OpenRPA["User"].upper()
|
|
|
return gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("RuleDomainUserDict", {}).get((lDomainUpperStr, lUserUpperStr), {}).get("RoleHierarchyAllowedDict", {})
|
|
|
|
|
|
#Tech def
|
|
|
#return {"headers":[],"body":"","statuscode":111}
|
|
|
def URLItemCheckDo(self, inURLItem, inMethod, inOnlyFlagUACBool = False):
|
|
|
gSettingsDict = __Orchestrator__.GSettingsGet()
|
|
|
###############################
|
|
|
#Tech sub def - do item
|
|
|
################################
|
|
|
def URLItemDo(inURLItem,inRequest,inGlobalDict):
|
|
|
global gCacheDict
|
|
|
inResponseDict = inRequest.OpenRPAResponseDict
|
|
|
inResponseDict["Headers"]["Content-type"]= None
|
|
|
#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:
|
|
|
# Check cache
|
|
|
if inURLItem.get("UseCacheBool",False) == True:
|
|
|
if inURLItem["ResponseFilePath"] in gCacheDict:
|
|
|
# Write content as utf-8 data
|
|
|
inResponseDict["Body"] = gCacheDict[inURLItem["ResponseFilePath"]]
|
|
|
else:
|
|
|
if os.path.exists(inURLItem["ResponseFilePath"]) and os.path.isfile(inURLItem["ResponseFilePath"]):
|
|
|
lFileObject = open(CrossOS.PathStr(inURLItem["ResponseFilePath"]), "rb")
|
|
|
# Write content as utf-8 data
|
|
|
gCacheDict[inURLItem["ResponseFilePath"]] = lFileObject.read()
|
|
|
inResponseDict["Body"] = gCacheDict[inURLItem["ResponseFilePath"]]
|
|
|
# Закрыть файловый объект
|
|
|
lFileObject.close()
|
|
|
else: inResponseDict["Headers"]["Content-type"]= "application/x-empty"; inResponseDict["StatusCode"] = 204 # NOCONTENT
|
|
|
else:
|
|
|
if os.path.exists(inURLItem["ResponseFilePath"]) and os.path.isfile(inURLItem["ResponseFilePath"]):
|
|
|
lFileObject = open(CrossOS.PathStr(inURLItem["ResponseFilePath"]), "rb")
|
|
|
# Write content as utf-8 data
|
|
|
inResponseDict["Body"] = lFileObject.read()
|
|
|
# Закрыть файловый объект
|
|
|
lFileObject.close()
|
|
|
else: inResponseDict["Headers"]["Content-type"]= "application/x-empty"; inResponseDict["StatusCode"] = 204 # NOCONTENT
|
|
|
# detect MIME type if none
|
|
|
if inResponseDict["Headers"]["Content-type"] is None:
|
|
|
inResponseDict["Headers"]["Content-type"]= mimetypes.guess_type(inURLItem["ResponseFilePath"])[0]
|
|
|
#If function is set
|
|
|
if "ResponseDefRequestGlobal" in inURLItem:
|
|
|
lDef = inURLItem["ResponseDefRequestGlobal"]
|
|
|
lDefSignature = inspect.signature(lDef)
|
|
|
if len(lDefSignature.parameters) == 2:
|
|
|
inURLItem["ResponseDefRequestGlobal"](inRequest, inGlobalDict)
|
|
|
elif len(lDefSignature.parameters) == 1:
|
|
|
inURLItem["ResponseDefRequestGlobal"](inRequest)
|
|
|
else:
|
|
|
inURLItem["ResponseDefRequestGlobal"]()
|
|
|
if "ResponseFolderPath" in inURLItem:
|
|
|
#lRequestPath = inRequest.path
|
|
|
lRequestPath = urllib.parse.unquote(inRequest.path)
|
|
|
if inURLItem["URL"][-1]!="/": inURLItem["URL"]+= "/" # Fix for settings
|
|
|
lFilePathSecondPart = lRequestPath.replace(inURLItem["URL"],"")
|
|
|
lFilePathSecondPart = lFilePathSecondPart.split("?")[0]
|
|
|
lFilePath = CrossOS.PathStr(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):
|
|
|
# Check cache
|
|
|
if inURLItem.get("UseCacheBool",False) == True:
|
|
|
if lFilePath in gCacheDict:
|
|
|
# Write content as utf-8 data
|
|
|
inResponseDict["Body"] = gCacheDict[lFilePath]
|
|
|
else:
|
|
|
lFileObject = open(lFilePath, "rb")
|
|
|
# Write content as utf-8 data
|
|
|
gCacheDict[lFilePath] = lFileObject.read()
|
|
|
inResponseDict["Body"] = gCacheDict[lFilePath]
|
|
|
# Закрыть файловый объект
|
|
|
lFileObject.close()
|
|
|
else:
|
|
|
lFileObject = open(lFilePath, "rb")
|
|
|
# Write content as utf-8 data
|
|
|
inResponseDict["Body"] = lFileObject.read()
|
|
|
# Закрыть файловый объект
|
|
|
lFileObject.close()
|
|
|
# detect MIME type if none
|
|
|
if inResponseDict["Headers"]["Content-type"] is None:
|
|
|
inResponseDict["Headers"]["Content-type"]= mimetypes.guess_type(lFilePath)[0]
|
|
|
else:
|
|
|
inResponseDict["Headers"]["Content-type"]= "application/x-empty"; inResponseDict["StatusCode"] = 204 # NOCONTENT
|
|
|
# If No content-type
|
|
|
if inResponseDict["Headers"]["Content-type"] is None:
|
|
|
inResponseDict["Headers"]["Content-type"]= "application/octet-stream"
|
|
|
##############################################
|
|
|
# UAC Check
|
|
|
if inOnlyFlagUACBool == True and inURLItem.get("UACBool",None) in [None, True]:
|
|
|
return False
|
|
|
if inURLItem["Method"].upper() == inMethod.upper():
|
|
|
# check Match type variant: BeginWith
|
|
|
if inURLItem["MatchType"].upper() == "BEGINWITH":
|
|
|
lURLPath = urllib.parse.unquote(self.path)
|
|
|
lURLPath = lURLPath.upper()
|
|
|
if lURLPath.startswith(inURLItem["URL"].upper()):
|
|
|
URLItemDo(inURLItem, self, gSettingsDict)
|
|
|
return True
|
|
|
# check Match type variant: Contains
|
|
|
elif inURLItem["MatchType"].upper() == "CONTAINS":
|
|
|
lURLPath = urllib.parse.unquote(self.path)
|
|
|
lURLPath = lURLPath.upper()
|
|
|
if lURLPath.contains(inURLItem["URL"].upper()):
|
|
|
URLItemDo(inURLItem, self, gSettingsDict)
|
|
|
return True
|
|
|
# check Match type variant: Equal
|
|
|
elif inURLItem["MatchType"].upper() == "EQUAL":
|
|
|
if inURLItem["URL"].upper() == urllib.parse.unquote(self.path).upper():
|
|
|
URLItemDo(inURLItem, self, gSettingsDict)
|
|
|
return True
|
|
|
# check Match type variant: EqualNoParam
|
|
|
elif inURLItem["MatchType"].upper() == "EQUALNOPARAM":
|
|
|
if inURLItem["URL"].upper() == urllib.parse.unquote(self.path).upper().split("?")[0]:
|
|
|
URLItemDo(inURLItem, self, gSettingsDict)
|
|
|
return True
|
|
|
# check Match type variant: EqualCase
|
|
|
elif inURLItem["MatchType"].upper() == "EQUALCASE":
|
|
|
if inURLItem["URL"] == urllib.parse.unquote(self.path):
|
|
|
URLItemDo(inURLItem, self, gSettingsDict)
|
|
|
return True
|
|
|
return False
|
|
|
#ResponseContentTypeFile
|
|
|
def SendResponseContentTypeFile(self, inContentType, inFilePath):
|
|
|
inResponseDict = self.OpenRPAResponseDict
|
|
|
self.mResponse.status_code = 200
|
|
|
# Send headers
|
|
|
self.mResponse.headers["Content-type"]=inContentType
|
|
|
#Check if var exist
|
|
|
if hasattr(self, "OpenRPASetCookie"):
|
|
|
self.mResponse.set_cookie(key='AuthToken',value=self.OpenRPA['AuthToken'])
|
|
|
lFileObject = open(inFilePath, "rb")
|
|
|
# Write content as utf-8 data
|
|
|
lFileBytes = lFileObject.read()
|
|
|
#Закрыть файловый объект
|
|
|
lFileObject.close()
|
|
|
return lFileBytes
|
|
|
# ResponseContentTypeFile
|
|
|
def ResponseDictSend(self):
|
|
|
inResponseDict = self.OpenRPAResponseDict
|
|
|
self.mResponse.status_code = inResponseDict["StatusCode"]
|
|
|
# Send headers
|
|
|
for lItemKey, lItemValue in inResponseDict["Headers"].items():
|
|
|
self.mResponse.headers[lItemKey]=lItemValue
|
|
|
# Send headers: Set-Cookie
|
|
|
for lItemKey, lItemValue in inResponseDict["SetCookies"].items():
|
|
|
self.mResponse.set_cookie(key=lItemKey,value=lItemValue)
|
|
|
self.send_header("Set-Cookie", f"{lItemKey}={lItemValue}")
|
|
|
return inResponseDict["Body"]
|
|
|
|
|
|
def do_GET(self, inBodyStr):
|
|
|
try:
|
|
|
gSettingsDict = __Orchestrator__.GSettingsGet()
|
|
|
try:
|
|
|
self.OpenRPA["DefUserRoleAccessAsk"]=self.UserRoleAccessAsk # Alias for def
|
|
|
self.OpenRPA["DefUserRoleHierarchyGet"]=self.UserRoleHierarchyGet # Alias for def
|
|
|
except Exception as e:
|
|
|
pass
|
|
|
# Prepare result dict
|
|
|
lResponseDict = {"Headers": {}, "SetCookies": {}, "Body": b"", "StatusCode": None, "BodyIsText":True}
|
|
|
self.OpenRPAResponseDict = lResponseDict
|
|
|
#Check the user access (if flag, UAC)
|
|
|
####################################
|
|
|
lFlagUserAccess = True
|
|
|
#If need user authentication
|
|
|
if gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("FlagCredentialsAsk", False):
|
|
|
if self.OpenRPA["AuthToken"] != None:
|
|
|
lFlagUserAccess = UserAccessCheckBefore("GET", self)
|
|
|
######################################
|
|
|
if lFlagUserAccess:
|
|
|
if CrossOS.IS_WINDOWS_BOOL: lOrchestratorFolder = "\\".join(__file__.split("\\")[:-1])
|
|
|
if CrossOS.IS_LINUX_BOOL: lOrchestratorFolder = "/".join(__file__.split("/")[:-1])
|
|
|
############################
|
|
|
#New server engine (url from global dict (URLList))
|
|
|
############################
|
|
|
for lURLItem in gSettingsDict["ServerDict"]["URLList"]:
|
|
|
#Check if all condition are applied
|
|
|
lFlagURLIsApplied=False
|
|
|
lFlagURLIsApplied=self.URLItemCheckDo(lURLItem, "GET")
|
|
|
if lFlagURLIsApplied:
|
|
|
return self.ResponseDictSend()
|
|
|
#Monitor
|
|
|
if self.path == '/Monitor/JSONDaemonListGet':
|
|
|
lResponseDict = {"Headers": {'Content-type':'application/json'}, "SetCookies": {}, "Body": bytes(json.dumps(gSettingsDict), "utf8"), "StatusCode": 200}
|
|
|
return self.ResponseDictSend()
|
|
|
#Filemanager function
|
|
|
if self.path.lower().startswith('/filemanager/'):
|
|
|
lFileURL=self.path[13:]
|
|
|
# check if file in FileURL - File Path Mapping Dict
|
|
|
if lFileURL.lower() in gSettingsDict["FileManager"]["FileURLFilePathDict"]:
|
|
|
return self.SendResponseContentTypeFile('application/octet-stream', gSettingsDict["FileManager"]["FileURLFilePathDict"][lFileURL])
|
|
|
else:
|
|
|
raise HTTPException(status_code=403, detail="here is the details", headers={})
|
|
|
except Exception as e:
|
|
|
lL = gSettingsDict["Logger"]
|
|
|
if lL: lL.exception(f"Сервер (do_GET): Неопознанная ошибка сети - см. текст ошибки. Сервер продолжает работу")
|
|
|
# POST
|
|
|
def do_POST(self, inBodyStr):
|
|
|
try:
|
|
|
gSettingsDict = __Orchestrator__.GSettingsGet()
|
|
|
lL = gSettingsDict["Logger"]
|
|
|
try:
|
|
|
self.OpenRPA["DefUserRoleAccessAsk"]=self.UserRoleAccessAsk # Alias for def
|
|
|
self.OpenRPA["DefUserRoleHierarchyGet"]=self.UserRoleHierarchyGet # Alias for def
|
|
|
except Exception as e:
|
|
|
pass
|
|
|
# Prepare result dict
|
|
|
#pdb.set_trace()
|
|
|
lResponseDict = {"Headers": {}, "SetCookies": {}, "Body": b"", "StatusCode": None, "BodyIsText":True}
|
|
|
self.OpenRPAResponseDict = lResponseDict
|
|
|
#Check the user access (if flag)
|
|
|
####################################
|
|
|
lFlagUserAccess = True
|
|
|
#If need user authentication
|
|
|
if gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("FlagCredentialsAsk", False):
|
|
|
if self.OpenRPA["AuthToken"] != None:
|
|
|
lFlagUserAccess = UserAccessCheckBefore("POST", self)
|
|
|
######################################
|
|
|
if lFlagUserAccess:
|
|
|
lOrchestratorFolder = "\\".join(__file__.split("\\")[:-1])
|
|
|
############################
|
|
|
#New server engine (url from global dict (URLList))
|
|
|
############################
|
|
|
for lURLItem in gSettingsDict["ServerDict"]["URLList"]:
|
|
|
#Check if all condition are applied
|
|
|
lFlagURLIsApplied=False
|
|
|
lFlagURLIsApplied=self.URLItemCheckDo(lURLItem, "POST")
|
|
|
if lFlagURLIsApplied:
|
|
|
return self.ResponseDictSend()
|
|
|
#Централизованная функция получения запросов/отправки
|
|
|
if self.path == '/Utils/Processor':
|
|
|
#Превращение массива байт в объект
|
|
|
lInputObject=json.loads(inBodyStr)
|
|
|
# Logging info about processor activity if not SuperToken ()
|
|
|
if not self.mOpenRPA['IsSuperToken']:
|
|
|
lActivityTypeListStr = ""
|
|
|
try:
|
|
|
if type(lInputObject) is list:
|
|
|
for lActivityItem in lInputObject:
|
|
|
lActivityTypeListStr+=f"{lActivityItem['Type']}; "
|
|
|
else:
|
|
|
lActivityTypeListStr += f"{lInputObject['Type']}"
|
|
|
except Exception as e:
|
|
|
lActivityTypeListStr = "Обнаружена ошибка при чтении Activity Type"
|
|
|
if lL: lL.info(f"Сервер:: !ВНИМАНИЕ! /Utils/Processor через некоторое время перестанет поддерживаться. Используйте /pyOpenRPA/Processor или /pyOpenRPA/ActivityListExecute. Активность поступила от пользователя. Домен: {self.OpenRPA['Domain']}, Логин: {self.OpenRPA['User']}, Тип активности: {lActivityTypeListStr}")
|
|
|
lResponseDict = {"Headers": {'Content-type':'application/json'}, "SetCookies": {}, "Body": bytes(json.dumps(ProcessorOld.ActivityListOrDict(lInputObject)), "utf8"), "StatusCode": 200}
|
|
|
return self.ResponseDictSend()
|
|
|
else:
|
|
|
raise HTTPException(status_code=403, detail="here is the details", headers={})
|
|
|
except Exception as e:
|
|
|
lL = gSettingsDict["Logger"]
|
|
|
if lL: lL.exception(f"Сервер, обратная совместимость (do_POST): Неопознанная ошибка сети - см. текст ошибки. Сервер продолжает работу")
|
|
|
|
|
|
|
|
|
|
|
|
from pyOpenRPA import __version__
|
|
|
|
|
|
# ИНИЦИАЛИЗАЦИЯ FASTAPI!
|
|
|
app = FastAPI(
|
|
|
title = "pyOpenRPA (ORPA) Orchestrator",
|
|
|
description = "Сервер оркестратора pyOpenRPA Orchestrator",
|
|
|
version = __version__,
|
|
|
openapi_url="/orpa/fastapi/openapi.json",
|
|
|
docs_url = "/orpa/fastapi/docs",
|
|
|
redoc_url = "/orpa/fastapi/redoc",
|
|
|
swagger_ui_oauth2_redirect_url = "/orpa/fastapi/docs/oauth2-redirect",
|
|
|
)
|
|
|
|
|
|
def IdentifyAuthorize(inRequest:Request, inResponse:Response,
|
|
|
inCookiesStr: Union[str, None] = Header(default=None,alias="Cookie"),
|
|
|
inAuthorizationStr: Union[str, None] = Header(default="",alias="Authorization")):
|
|
|
lResult={"Domain": "", "User": ""}
|
|
|
#print("IdentifyAuthorize")
|
|
|
######################################
|
|
|
#Way 1 - try to find AuthToken
|
|
|
lCookies = cookies.SimpleCookie(inCookiesStr) # inRequest.headers.get("Cookie", "")
|
|
|
global gSettingsDict
|
|
|
lHeaderAuthorization = inAuthorizationStr.split(" ")
|
|
|
if "AuthToken" in lCookies:
|
|
|
lCookieAuthToken = lCookies.get("AuthToken", "").value
|
|
|
if lCookieAuthToken:
|
|
|
#Find AuthToken in GlobalDict
|
|
|
if lCookieAuthToken in gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("AuthTokensDict", {}):
|
|
|
#Auth Token Has Been Founded
|
|
|
lResult["Domain"] = gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lCookieAuthToken]["Domain"]
|
|
|
lResult["User"] = gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lCookieAuthToken]["User"]
|
|
|
#Set auth token
|
|
|
mOpenRPA={}
|
|
|
mOpenRPA["AuthToken"] = lCookieAuthToken
|
|
|
mOpenRPA["Domain"] = lResult["Domain"]
|
|
|
mOpenRPA["User"] = lResult["User"]
|
|
|
mOpenRPA["IsSuperToken"] = gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("AuthTokensDict", {}).get(mOpenRPA["AuthToken"], {}).get("FlagDoNotExpire", False)
|
|
|
return mOpenRPA
|
|
|
######################################
|
|
|
#Way 2 - try to logon
|
|
|
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]
|
|
|
lLogonBool = __Orchestrator__.OSCredentialsVerify(inUserStr=lUser, inPasswordStr=lPassword, inDomainStr=lDomain)
|
|
|
#Check result
|
|
|
if lLogonBool:
|
|
|
lResult["Domain"] = lDomain
|
|
|
lResult["User"] = lUser
|
|
|
#Create token
|
|
|
lAuthToken=str(uuid.uuid1())
|
|
|
gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lAuthToken] = {}
|
|
|
gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["Domain"] = lResult["Domain"]
|
|
|
gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["User"] = lResult["User"]
|
|
|
gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["FlagDoNotExpire"] = False
|
|
|
gSettingsDict["ServerDict"]["AccessUsers"]["AuthTokensDict"][lAuthToken]["TokenDatetime"] = datetime.datetime.now()
|
|
|
#Set-cookie
|
|
|
inResponse.set_cookie(key="AuthToken",value=lAuthToken)
|
|
|
mOpenRPA={}
|
|
|
mOpenRPA["AuthToken"] = lAuthToken
|
|
|
mOpenRPA["Domain"] = lResult["Domain"]
|
|
|
mOpenRPA["User"] = lResult["User"]
|
|
|
mOpenRPA["IsSuperToken"] = gSettingsDict.get("ServerDict", {}).get("AccessUsers", {}).get("AuthTokensDict", {}).get(mOpenRPA["AuthToken"], {}).get("FlagDoNotExpire", False)
|
|
|
return mOpenRPA
|
|
|
#inRequest.OpenRPASetCookie = {}
|
|
|
#New engine of server
|
|
|
#inRequest.OpenRPAResponseDict["SetCookies"]["AuthToken"] = lAuthToken
|
|
|
else:
|
|
|
raise HTTPException(status_code=401, detail="here is the details", headers={})
|
|
|
######################################
|
|
|
else:
|
|
|
raise HTTPException(status_code=401, detail="here is the details", headers={'Content-type':'text/html', 'WWW-Authenticate':'Basic'})
|
|
|
|
|
|
lRouteList =[]
|
|
|
for lItem in app.router.routes:
|
|
|
lRouteList.append(lItem)
|
|
|
app.router.routes=[]
|
|
|
for lItem in lRouteList:
|
|
|
app.add_api_route(
|
|
|
path=lItem.path,
|
|
|
endpoint=lItem.endpoint,
|
|
|
methods=["GET"],
|
|
|
dependencies=[Depends(IdentifyAuthorize)],
|
|
|
tags=["FastAPI"]
|
|
|
)
|
|
|
|
|
|
def BackwardCompatibility(inRequest:Request, inResponse:Response, inBodyStr:str = Body(""), inAuthDict = None):
|
|
|
lHTTPRequest = HTTPRequestOld(inRequest=inRequest, inResponse=inResponse, inAuthDict=inAuthDict)
|
|
|
lHTTPRequest.path = inRequest.url.path
|
|
|
lHTTPRequest.body = inBodyStr
|
|
|
lHTTPRequest.client_address = [inRequest.client.host]
|
|
|
threading.current_thread().request = lHTTPRequest
|
|
|
lResult = lHTTPRequest.do_GET(inBodyStr=inBodyStr)
|
|
|
if lResult is None:
|
|
|
lResult = lHTTPRequest.do_POST(inBodyStr=inBodyStr)
|
|
|
if lHTTPRequest.OpenRPAResponseDict["Headers"]["Content-type"] != None:
|
|
|
return StreamingResponse(io.BytesIO(lResult), media_type=lHTTPRequest.OpenRPAResponseDict["Headers"]["Content-type"])
|
|
|
|
|
|
#WRAPPERS!
|
|
|
def BackwardCompatibityWrapperAuth(inRequest:Request, inResponse:Response, inBodyStr:str = Body(""),
|
|
|
inAuthDict:dict=Depends(IdentifyAuthorize)): # Old from v1.3.1 (updated to FastAPI)
|
|
|
return BackwardCompatibility(inRequest = inRequest, inResponse = inResponse, inBodyStr = inBodyStr, inAuthDict=inAuthDict)
|
|
|
def BackwardCompatibityWrapperNoAuth(inRequest:Request, inResponse:Response, inBodyStr:str = Body("")): # Old from v1.3.1 (updated to FastAPI)
|
|
|
return BackwardCompatibility(inRequest = inRequest, inResponse = inResponse, inBodyStr = inBodyStr, inAuthDict=None)
|
|
|
def BackwardCompatibityBeginWrapperAuth(inBeginTokenStr, inRequest:Request, inResponse:Response, inBodyStr:str = Body(""),
|
|
|
inAuthDict:dict=Depends(IdentifyAuthorize)): # Old from v1.3.1 (updated to FastAPI)
|
|
|
return BackwardCompatibility(inRequest = inRequest, inResponse = inResponse, inBodyStr = inBodyStr, inAuthDict=inAuthDict)
|
|
|
def BackwardCompatibityBeginWrapperNoAuth(inBeginTokenStr, inRequest:Request, inResponse:Response, inBodyStr:str = Body("")): # Old from v1.3.1 (updated to FastAPI)
|
|
|
return BackwardCompatibility(inRequest = inRequest, inResponse = inResponse, inBodyStr = inBodyStr, inAuthDict=None)
|
|
|
|
|
|
# Get thread list /orpa/threads
|
|
|
@app.get(path="/orpa/threads",response_class=PlainTextResponse)
|
|
|
def Threads(inRequest:Request):
|
|
|
#import pdb
|
|
|
#pdb.set_trace()
|
|
|
lThreadStr = ""
|
|
|
for thread in threading.enumerate():
|
|
|
lThreadStr+=f"ПОТОК: {thread.name}\n"
|
|
|
#print(thread.name)
|
|
|
return lThreadStr
|
|
|
|
|
|
def InitFastAPI():
|
|
|
global gSettingsDict
|
|
|
global app
|
|
|
ServerSettings.SettingsUpdate(gSettingsDict)
|
|
|
lL = gSettingsDict.get("Logger",None)
|
|
|
gSettingsDict["ServerDict"]["ServerThread"] = app
|
|
|
|
|
|
for lConnectItemDict in gSettingsDict["ServerDict"]["URLList"]:
|
|
|
if "ResponseFolderPath" in lConnectItemDict:
|
|
|
app.mount(lConnectItemDict["URL"],
|
|
|
StaticFiles(directory=CrossOS.PathStr(lConnectItemDict["ResponseFolderPath"])),
|
|
|
name=lConnectItemDict["URL"].replace('/',"_"))
|
|
|
else:
|
|
|
if lConnectItemDict.get("MatchType") in ["EqualCase", "Equal","EqualNoParam"]:
|
|
|
if lConnectItemDict.get("UACBool",True):
|
|
|
app.add_api_route(
|
|
|
path=lConnectItemDict["URL"],
|
|
|
endpoint=BackwardCompatibityWrapperAuth,
|
|
|
response_class=PlainTextResponse,
|
|
|
methods=[lConnectItemDict["Method"]],
|
|
|
tags=["BackwardCompatibility"]
|
|
|
)
|
|
|
else:
|
|
|
app.add_api_route(
|
|
|
path=lConnectItemDict["URL"],
|
|
|
endpoint=BackwardCompatibityWrapperNoAuth,
|
|
|
response_class=PlainTextResponse,
|
|
|
methods=[lConnectItemDict["Method"]],
|
|
|
tags=["BackwardCompatibility"]
|
|
|
)
|
|
|
elif lConnectItemDict.get("MatchType") in ["BeginWith", "Contains"]:
|
|
|
lURLStr = lConnectItemDict["URL"]
|
|
|
if lURLStr[-1]!="/": lURLStr+="/"
|
|
|
lURLStr+="{inBeginTokenStr}"
|
|
|
if lConnectItemDict.get("UACBool",True):
|
|
|
app.add_api_route(
|
|
|
path=lURLStr,
|
|
|
endpoint=BackwardCompatibityBeginWrapperAuth,
|
|
|
response_class=PlainTextResponse,
|
|
|
methods=[lConnectItemDict["Method"]],
|
|
|
tags=["BackwardCompatibility"]
|
|
|
)
|
|
|
else:
|
|
|
app.add_api_route(
|
|
|
path=lURLStr,
|
|
|
endpoint=BackwardCompatibityBeginWrapperNoAuth,
|
|
|
response_class=PlainTextResponse,
|
|
|
methods=[lConnectItemDict["Method"]],
|
|
|
tags=["BackwardCompatibility"]
|
|
|
)
|
|
|
|
|
|
uvicorn.run('pyOpenRPA.Orchestrator.Server:app', host='0.0.0.0', port=1024)
|
|
|
|
|
|
|
|
|
#if lL: lL.info(f"Сервер инициализирован успешно (с поддержкой SSL):: Наименование: {self.name}, Слушает URL: {lAddressStr}, Слушает порт: {lPortInt}, Путь к файлу сертификата (.pem): {lCertFilePathStr}")
|
|
|
#if lL: lL.info(f"Сервер инициализирован успешно (без поддержки SSL):: Наименование: {self.name}, Слушает URL: {lAddressStr}, Слушает порт: {lPortInt}")
|
|
|
|
|
|
|
