def addControllerListTo(apiInstance, controllerList):
for controller in controllerList:
OpenApiManager.addControllerDocumentation(controller, apiInstance)
mainUrl = f'{apiInstance.baseUrl}{controller.url}'
urlList = [mainUrl]
infoList = [f'Controller: {mainUrl}']
controllerMethodList = ReflectionHelper.getAttributePointerList(
controller)
for controllerMethod in controllerMethodList:
if ReflectionHelper.hasAttributeOrMethod(
controllerMethod,
FlaskManager.KW_URL) and ObjectHelper.isNotEmpty(
controllerMethod.url):
controllerUrl = f'{mainUrl}{controllerMethod.url}'
if controllerUrl not in urlList:
urlList.append(controllerUrl)
infoList.append(
f'{c.TAB}{ReflectionHelper.getName(controllerMethod)}: {controllerUrl}'
)
# subUrlList = controllerMethod.url.split(c.SLASH)
# concatenatedSubUrl = c.NOTHING
# for subUrl in subUrlList :
# if subUrl :
# concatenatedSubUrl += f'{c.SLASH}{subUrl}'
# if c.LESSER == subUrl[0] and c.BIGGER == subUrl[-1] :
# newUrl = f'{apiInstance.baseUrl}{controller.url}{concatenatedSubUrl}'
# if not newUrl in urlList :
# urlList.append(newUrl)
OpenApiManager.addEndPointDocumentation(
controllerUrl, controllerMethod, controller, apiInstance)
log.debug(
addControllerListTo,
f'{controller.url} -> {StringHelper.prettyPython(infoList)}')
apiInstance.add_resource(controller, *urlList)
def getCurrentUser(userClass=None, apiInstance=None):
currentUsert = get_current_user()
if ObjectHelper.isNotNone(currentUsert):
return currentUsert
else:
rawJwt = getJwtBody()
identity = getIdentity(rawJwt=rawJwt)
context = getContext(rawJwt=rawJwt)
data = getData(rawJwt=rawJwt)
if ObjectHelper.isNone(userClass):
return {
JwtConstant.KW_IDENTITY: identity,
JwtConstant.KW_CONTEXT: context,
JwtConstant.KW_DATA: data
}
else:
currentUsert = userClass()
currentUsert._contextInfo = {
JwtConstant.KW_IDENTITY: identity,
JwtConstant.KW_CONTEXT: context
}
for attributeName in data:
if ReflectionHelper.hasAttributeOrMethod(
currentUsert, attributeName):
ReflectionHelper.setAttributeOrMethod(
currentUsert, attributeName, data.get(attributeName))
return currentUsert
def getCurrentSession(sessionClass=None, apiInstance=None):
apiInstance = retrieveApiInstance(apiInstance=apiInstance)
rawJwt = getJwtBody(apiInstance=apiInstance)
identity = getIdentity(rawJwt=rawJwt, apiInstance=apiInstance)
context = getContext(rawJwt=rawJwt, apiInstance=apiInstance)
data = getData(rawJwt=rawJwt, apiInstance=apiInstance)
if ObjectHelper.isNone(sessionClass):
return {
JwtConstant.KW_IDENTITY: identity,
JwtConstant.KW_CONTEXT: context,
JwtConstant.KW_DATA: data
}
else:
currentSession = sessionClass()
currentSession._contextInfo = {
JwtConstant.KW_IDENTITY: identity,
JwtConstant.KW_CONTEXT: context
}
for attributeName in data:
if ReflectionHelper.hasAttributeOrMethod(currentSession,
attributeName):
ReflectionHelper.setAttributeOrMethod(currentSession,
attributeName,
data.get(attributeName))
return currentSession
def innerMethodWrapper(resourceInstanceMethod, *args, **kwargs):
def myPrint(resourceInstance, abcd):
url = 2
if ObjectHelper.isNotNone(abcd):
url = resourceInstance.url + clientMethodUrl + abcd
return url
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstance = args[0]
completeResponse = 1
httpClientEvent = getHttpClientEvent(resourceInstanceMethod, *args,
**kwargs)
try:
return myPrint(resourceInstance, *httpClientEvent.args,
**httpClientEvent.kwargs)
except Exception as exception:
print(exception)
completeResponse = 3
return completeResponse
return completeResponse
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceInstanceMethod)
innerResourceInstanceMethod.url = clientMethodUrl
return innerResourceInstanceMethod
def wrapper(function, *args, **kwargs):
log.wrapper(
wrapper,
f'Wrapping {function} function with (*{args} args and **{kwargs} kwargs)'
)
def wrapedFunction(*args, **kwargs):
try:
functionReturn = function(*args, **kwargs)
except Exception as exception:
if isinstance(exception, GlobalException):
raise exception
logMessage = str(exception) if StringHelper.isNotBlank(
str(exception)) else LOG_MESSAGE_NOT_PRESENT
functionName = ReflectionHelper.getName(
function, typeName=c.TYPE_FUNCTION)
log.wrapper(
EncapsulateItWithGlobalException,
f'''Failed to execute "{functionName}(args={args}, kwargs={kwargs})" {c.TYPE_FUNCTION} call''',
exception)
raise GlobalException(
message=message,
logMessage=logMessage,
logResource=ReflectionHelper.getParentClass(function),
logResourceMethod=function,
status=HttpStatus.map(
encapsulateItWithGlobalExceptionStatus).enumValue)
return functionReturn
ReflectionHelper.overrideSignatures(wrapedFunction, function)
return wrapedFunction
def Wrapper(OuterClass, *args, **kwargs):
log.wrapper(HttpClient,f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
url = clientUrl
headers = clientHeaders
timeout = clientTimeout
logRequest = clientLogRequest
logResponse = clientLogResponse
def __init__(self,*args, **kwargs):
log.wrapper(OuterClass,f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
apiInstance = FlaskManager.getApi()
OuterClass.__init__(self,*args, **kwargs)
self.globals = apiInstance.globals
def options(self, *args, **kwargs):
raise HttpClientEvent(HttpDomain.Verb.OPTIONS, *args, **kwargs)
def get(self, *args, **kwargs):
raise HttpClientEvent(HttpDomain.Verb.GET, *args, **kwargs)
def post(self, *args, **kwargs):
raise HttpClientEvent(HttpDomain.Verb.POST, *args, **kwargs)
def put(self, *args, **kwargs):
raise HttpClientEvent(HttpDomain.Verb.PUT, *args, **kwargs)
def patch(self, *args, **kwargs):
raise HttpClientEvent(HttpDomain.Verb.PATCH, *args, **kwargs)
def delete(self, *args, **kwargs):
raise HttpClientEvent(HttpDomain.Verb.DELETE, *args, **kwargs)
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def addResourceAttibutes(apiInstance):
ReflectionHelper.setAttributeOrMethod(apiInstance,
FlaskManager.KW_RESOURCE,
FlaskResource())
for resourceName in FlaskManager.KW_RESOURCE_LIST:
ReflectionHelper.setAttributeOrMethod(
apiInstance.resource,
f'{resourceName[0].lower()}{resourceName[1:]}', FlaskResource())
def __eq__(self, other) :
if ObjectHelper.isNone(other) :
return self is None
isEqual = True
for value, name in ReflectionHelper.getAttributeDataList(other) :
attributeIsEqual = ReflectionHelper.getAttributeOrMethod(self, name) == ReflectionHelper.getAttributeOrMethod(other, name)
isEqual = isEqual == attributeIsEqual and True == attributeIsEqual
return isEqual
def jwtRefreshRequired(function, *args, **kwargs):
def innerFunction(*args, **kwargs):
###- arguments=args[0] --> python weardnes in it's full glory
retrieveApiInstance(
arguments=args[0]).sessionManager.validateRefreshSession()
functionReturn = function(*args, **kwargs)
return functionReturn
ReflectionHelper.overrideSignatures(innerFunction, function)
return innerFunction
def getClassRole(instanceClass) :
if DTO_SUFIX == ReflectionHelper.getName(instanceClass)[-len(DTO_SUFIX):] :
sufixList = [str(DTO_CLASS_ROLE)]
concatenatedSufix = str(DTO_SUFIX)
for mesoSufix in MESO_SUFIX_LIST :
if mesoSufix == ReflectionHelper.getName(instanceClass)[-(len(mesoSufix)+len(concatenatedSufix)):-len(concatenatedSufix)] :
concatenatedSufix += mesoSufix
sufixList = [mesoSufix.upper()] + sufixList
return c.UNDERSCORE.join(sufixList)
return MODEL_CLASS_ROLE
def Wrapper(OuterClass, *args, **kwargs):
log.debug(Client,f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
url = controllerUrl
def __init__(self,*args,**kwargs):
log.debug(OuterClass,f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
apiInstance = FlaskManager.getApi()
OuterClass.__init__(self,*args,**kwargs)
self.globals = apiInstance.globals
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def innerMethodWrapper(resourceInstanceMethod,*args,**kwargs) :
log.debug(ValidatorMethod,f'''wrapping {resourceInstanceMethod.__name__}''')
def innerResourceInstanceMethod(*args,**kwargs) :
resourceInstance = args[0]
try :
FlaskManager.validateArgs(args,requestClass,innerResourceInstanceMethod)
methodReturn = resourceInstanceMethod(*args,**kwargs)
except Exception as exception :
FlaskManager.raiseGlobalException(exception, resourceInstance, resourceInstanceMethod)
return methodReturn
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod, resourceInstanceMethod)
return innerResourceInstanceMethod
def Wrapper(OuterClass, *args, **kwargs):
log.wrapper(Repository,f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
model = repositoryModel
def __init__(self,*args,**kwargs):
log.wrapper(OuterClass,f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
OuterClass.__init__(self,*args,**kwargs)
apiInstance = FlaskManager.getApi()
self.repository = apiInstance.repository
self.globals = apiInstance.globals
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def Wrapper(OuterClass, *args, **kwargs):
log.debug(Validator,f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
def __init__(self,*args,**kwargs):
log.debug(OuterClass,f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
OuterClass.__init__(self,*args,**kwargs)
apiInstance = FlaskManager.getApi()
self.service = apiInstance.resource.service
self.validator = apiInstance.resource.validator
self.helper = apiInstance.resource.helper
self.converter = apiInstance.resource.converter
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def Wrapper(OuterClass, *args, **kwargs):
log.debug(SimpleClient, f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
def __init__(self, *args, **kwargs):
log.debug(
OuterClass,
f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
OuterClass.__init__(self, *args, **kwargs)
self.globals = getApi().globals
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def Wrapper(OuterClass, *args, **kwargs):
class InnerClass(OuterClass):
url = clientUrl
def __init__(self, *args, **kwargs):
OuterClass.__init__(self, *args, **kwargs)
def myPrint(self, *args, **kwargs):
raise HttpClientEvent(*args, key=4, **kwargs)
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
print(InnerClass)
return InnerClass
def innerMethodWrapper(resourceInstanceMethod,*args,**kwargs) :
log.debug(ClientMethod,f'''wrapping {resourceInstanceMethod.__name__}''')
def innerResourceInstanceMethod(*args,**kwargs) :
resourceInstance = args[0]
completeResponse = None
if logRequest :
log.prettyJson(
resourceInstanceMethod,
'bodyRequest',
json.loads(Serializer.jsonifyIt(args[1:])),
condition = logRequest,
logLevel = log.DEBUG
)
try :
FlaskManager.validateKwargs(
kwargs,
resourceInstance,
innerResourceInstanceMethod,
requestHeaderClass = requestHeaderClass,
requestParamClass = requestParamClass
)
FlaskManager.validateArgs(args, requestClass, innerResourceInstanceMethod)
completeResponse = resourceInstanceMethod(*args,**kwargs)
FlaskManager.validateResponseClass(responseClass, completeResponse)
except Exception as exception :
log.warning(innerResourceInstanceMethod, 'Not posssible to complete request', exception=exception)
raise exception
controllerResponse = completeResponse[0] if ObjectHelper.isNotNone(completeResponse[0]) else {'message' : completeResponse[1].enumName}
if logResponse :
log.prettyJson(
resourceInstanceMethod,
'bodyResponse',
json.loads(Serializer.jsonifyIt(controllerResponse)),
condition = logResponse,
logLevel = log.DEBUG
)
return completeResponse[0]
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod, resourceInstanceMethod)
innerResourceInstanceMethod.url = controllerMethodUrl
innerResourceInstanceMethod.requestHeaderClass = controllerMethodRequestHeaderClass
innerResourceInstanceMethod.requestParamClass = controllerMethodRequestParamClass
innerResourceInstanceMethod.requestClass = controllerMethodRequestClass
innerResourceInstanceMethod.responseClass = controllerMethodResponseClass
innerResourceInstanceMethod.roleRequired = controllerMethodRoleRequired
innerResourceInstanceMethod.produces = controllerMethodProduces
innerResourceInstanceMethod.consumes = controllerMethodConsumes
innerResourceInstanceMethod.logRequest = controllerMethodLogRequest
innerResourceInstanceMethod.logResponse = controllerMethodLogResponse
return innerResourceInstanceMethod
def Wrapper(OuterClass, *args, **kwargs):
log.debug(Scheduler, f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
def __init__(self, *args, **kwargs):
log.debug(
OuterClass,
f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
apiInstance = FlaskManager.getApi()
OuterClass.__init__(self, *args, **kwargs)
self.globals = apiInstance.globals
self.service = apiInstance.resource.service
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def innerMethodWrapper(resourceInstanceMethod, *innerMethodArgs,
**innerMethodKwargs):
log.debug(SchedulerMethod,
f'''wrapping {resourceInstanceMethod.__name__}''')
apiInstance = FlaskManager.getApi()
methodClassName = ReflectionHelper.getMethodClassName(
resourceInstanceMethod)
methodName = ReflectionHelper.getName(resourceInstanceMethod)
methodKwargs['id'] = methodKwargs.get(
'id', f'{methodClassName}{c.DOT}{methodName}')
instancesUpTo = methodKwargs.pop('instancesUpTo', 1)
weekDays = methodKwargs.pop('weekDays', None)
if ObjectHelper.isNotEmpty(
methodArgs
) and SchedulerType.CRON == methodArgs[0] and ObjectHelper.isNotNone(
weekDays) and StringHelper.isNotBlank(weekDays):
methodKwargs['day_of_week'] = weekDays
if ObjectHelper.isNotNone(instancesUpTo):
methodKwargs['max_instances'] = instancesUpTo
shedulerArgs = [*methodArgs]
shedulerKwargs = {**methodKwargs}
@apiInstance.scheduler.task(*shedulerArgs, **shedulerKwargs)
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstanceName = methodClassName[:-len(
FlaskManager.KW_SCHEDULER_RESOURCE)]
resourceInstanceName = f'{resourceInstanceName[0].lower()}{resourceInstanceName[1:]}'
args = FlaskManager.getArgumentInFrontOfArgs(
args,
ReflectionHelper.getAttributeOrMethod(
apiInstance.resource.scheduler, resourceInstanceName))
resourceInstance = args[0]
methodReturn = None
try:
FlaskManager.validateArgs(args, requestClass,
innerResourceInstanceMethod)
methodReturn = resourceInstanceMethod(*args, **kwargs)
except Exception as exception:
FlaskManager.raiseGlobalException(exception, resourceInstance,
resourceInstanceMethod)
log.log(innerResourceInstanceMethod,
f'Not possible to run {shedulerId} properly',
exception=exception)
return methodReturn
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceInstanceMethod)
return innerResourceInstanceMethod
def bindResource(apiInstance, resourceInstance):
validateFlaskApi(apiInstance)
validateResourceInstance(resourceInstance)
setResource(
ReflectionHelper.getAttributeOrMethod(
apiInstance.resource,
getResourceType(resourceInstance).lower()), resourceInstance)
def getNullableChildDtoClass(attributeName, dtoClass, verb, url,
documentation):
log.log(
getNullableChildDtoClass,
f'attributeName: {attributeName}, dtoClass: {dtoClass}, verb: {verb}, url: {url}'
)
childDtoClass = Serializer.getTargetClassFromFatherClassAndChildMethodName(
dtoClass, attributeName)
log.log(getNullableChildDtoClass, f'childDtoClass: {childDtoClass}')
if childDtoClass:
if ReflectionHelper.getName(type(type)) == ReflectionHelper.getName(
type(childDtoClass)):
addDtoToUrlVerb(verb, url, childDtoClass, documentation)
else:
addDtoToUrlVerb(verb, url, type(childDtoClass), documentation)
return childDtoClass
def addEndPointDocumentation(endPointUrl, controllerMethod, controller,
apiInstance):
try:
url = getUrl(endPointUrl, apiInstance.baseUrl)
addUrlIfNeeded(url, apiInstance.documentation)
verb = ReflectionHelper.getName(controllerMethod, muteLogs=True)
if verb in [KW_GET, KW_POST, KW_PUT, KW_DELETE, KW_PATCH]:
addVerb(verb, url, apiInstance.documentation)
addTagToUrlVerb(verb, url, controller.tag,
apiInstance.documentation)
addConsumesAndProducesToUrlVerb(verb, url,
controllerMethod.consumes,
controllerMethod.produces,
apiInstance.documentation)
addSession(verb, url, controllerMethod.contextRequired,
apiInstance.documentation, apiInstance.globals)
addApiKey(verb, url, controllerMethod.apiKeyRequired,
apiInstance.documentation, apiInstance.globals)
addSecurity(verb, url, controllerMethod.roleRequired,
apiInstance.documentation, apiInstance.globals)
addHeadersListToUrlVerb(verb, url, endPointUrl,
controllerMethod.requestHeaderClass,
apiInstance.documentation)
addUrlParamListToUrlVerb(verb, url, endPointUrl,
apiInstance.documentation)
addQueryParamListToUrlVerb(verb, url, endPointUrl,
controllerMethod.requestParamClass,
apiInstance.documentation)
addRequestToUrlVerb(verb, url, controllerMethod.requestClass,
apiInstance.documentation)
addResponseToUrlVerb(verb, url, controllerMethod.responseClass,
apiInstance.documentation)
except Exception as exception:
log.failure(addEndPointDocumentation,
'Not possible to add end point documentation', exception)
def Wrapper(OuterClass, *args, **kwargs):
log.wrapper(Service,f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
def __init__(self,*args,**kwargs):
log.wrapper(OuterClass,f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
apiInstance = FlaskManager.getApi()
OuterClass.__init__(self,*args,**kwargs)
self.service = apiInstance.resource.service
self.client = apiInstance.resource.client
self.repository = apiInstance.resource.repository
self.validator = apiInstance.resource.validator
self.mapper = apiInstance.resource.mapper
self.helper = apiInstance.resource.helper
self.converter = apiInstance.resource.converter
self.globals = apiInstance.globals
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def encapsulateItWithGlobalException_noParameters_unknownException():
#arrange
@EncapsulateItWithGlobalException()
def internalFuncionDoesNotThrowsException():
return SUCCESS
@EncapsulateItWithGlobalException()
def internalFuncionDoesThrowsException():
raise RAISED_EXCEPTION
# #act
externalSuccess = externalFuncionDoesNotThrowsException()
internalSuccess = internalFuncionDoesNotThrowsException()
externalFailure = TestHelper.getRaisedException(
externalFuncionDoesThrowsException)
internalFailure = TestHelper.getRaisedException(
internalFuncionDoesThrowsException)
# print(externalFailure.logResource)
# print(externalFailure.logResourceMethod)
# print(internalFailure.logResource)
# print(internalFailure.logResourceMethod)
#assert
assert SUCCESS == externalSuccess
assert SUCCESS == internalSuccess
assert not RAISED_EXCEPTION == externalFailure, f'not {RAISED_EXCEPTION} == {externalFailure}: {not RAISED_EXCEPTION == externalFailure}'
assert not RAISED_EXCEPTION == internalFailure, f'not {RAISED_EXCEPTION} == {internalFailure}: {not RAISED_EXCEPTION == internalFailure}'
assert not RAISED_EXCEPTION == externalFailure, f'not {RAISED_EXCEPTION} == {externalFailure}: {not RAISED_EXCEPTION == externalFailure}'
assert not RAISED_EXCEPTION == internalFailure, f'not {RAISED_EXCEPTION} == {internalFailure}: {not RAISED_EXCEPTION == internalFailure}'
assert GlobalException == ReflectionHelper.getClass(externalFailure)
assert GlobalException == ReflectionHelper.getClass(internalFailure)
assert ExceptionHandler.DEFAULT_MESSAGE == externalFailure.message, f'{ExceptionHandler.DEFAULT_LOG_MESSAGE} == {externalFailure.message}: {ExceptionHandler.DEFAULT_LOG_MESSAGE == externalFailure.message}'
assert ExceptionHandler.DEFAULT_MESSAGE == internalFailure.message
assert HttpStatus.INTERNAL_SERVER_ERROR == externalFailure.status
assert HttpStatus.INTERNAL_SERVER_ERROR == internalFailure.status
assert FAILURE == externalFailure.logMessage
assert FAILURE == internalFailure.logMessage
assert ExceptionHandler.DEFAULT_LOG_RESOURCE == externalFailure.logResource, f'{ExceptionHandler.DEFAULT_LOG_RESOURCE} == {externalFailure.logResource}: {ExceptionHandler.DEFAULT_LOG_RESOURCE == externalFailure.logResource}'
assert externalFuncionDoesThrowsException.__name__ == externalFailure.logResourceMethod.__name__, f'{externalFuncionDoesThrowsException} == {externalFailure.logResourceMethod}: {externalFuncionDoesThrowsException == externalFailure.logResourceMethod}'
assert ExceptionHandler.DEFAULT_LOG_RESOURCE == internalFailure.logResource, f'{ExceptionHandler.DEFAULT_LOG_RESOURCE} == {internalFailure.logResource}: {ExceptionHandler.DEFAULT_LOG_RESOURCE == internalFailure.logResource}'
assert type(internalFuncionDoesThrowsException) == type(
internalFailure.logResourceMethod)
def innerMethodWrapper(resourceInstanceMethod, *args, **kwargs):
log.wrapper(HelperMethod,
f'''wrapping {resourceInstanceMethod.__name__}''')
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstance = args[0]
try:
FlaskManager.validateArgs(args, requestClass,
innerResourceInstanceMethod)
args = FlaskManager.getArgsWithResponseClassInstanceAppended(
args, responseClass)
methodReturn = resourceInstanceMethod(*args, **kwargs)
except Exception as exception:
FlaskManager.raiseAndPersistGlobalException(
exception, resourceInstance, resourceInstanceMethod)
return methodReturn
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceInstanceMethod)
return innerResourceInstanceMethod
def Wrapper(OuterClass, *args, **kwargs):
log.wrapper(Client, f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
url = clientUrl
headers = clientHeaders
timeout = clientTimeout
logRequest = clientLogRequest
logResponse = clientLogResponse
def __init__(self, *args, **kwargs):
log.wrapper(
OuterClass,
f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
apiInstance = FlaskManager.getApi()
OuterClass.__init__(self, *args, **kwargs)
self.globals = apiInstance.globals
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def innerMethodWrapper(resourceInstanceMethod, *args, **kwargs):
log.wrapper(ClientMethod,
f'''wrapping {resourceInstanceMethod.__name__}''')
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstance = args[0]
completeResponse = None
try:
FlaskManager.validateArgs(args, requestClass,
resourceInstanceMethod)
completeResponse = resourceInstanceMethod(*args, **kwargs)
###- This simple client cannot handle headers or anything this much elegant
if ObjectHelper.isTuple(
completeResponse) and 0 < len(completeResponse):
completeResponse = completeResponse[0]
except Exception as exception:
log.log(innerResourceInstanceMethod,
'Failure at client method execution',
exception=exception,
muteStackTrace=True)
raise exception
return completeResponse
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceInstanceMethod)
innerResourceInstanceMethod.url = clientMethodUrl
innerResourceInstanceMethod.headers = clientMethodHeaders
innerResourceInstanceMethod.requestHeaderClass = clientMethodRequestHeaderClass
innerResourceInstanceMethod.requestParamClass = clientMethodRequestParamClass
innerResourceInstanceMethod.requestClass = clientMethodRequestClass
innerResourceInstanceMethod.responseClass = clientMethodResponseClass
innerResourceInstanceMethod.returnOnlyBody = clientMethodReturnOnlyBody
innerResourceInstanceMethod.timeout = clientMethodTimeout
innerResourceInstanceMethod.propagateAuthorization = clientMethodPropagateAuthorization
innerResourceInstanceMethod.propagateApiKey = clientMethodPropagateApiKey
innerResourceInstanceMethod.propagateSession = clientMethodPropagateSession
innerResourceInstanceMethod.produces = clientMethodProduces
innerResourceInstanceMethod.consumes = clientMethodConsumes
innerResourceInstanceMethod.logRequest = clientMethodLogRequest
innerResourceInstanceMethod.logResponse = clientMethodLogResponse
return innerResourceInstanceMethod
def getObjectAsDictionary(instance, fieldsToExpand=[EXPAND_ALL_FIELDS], visitedIdInstances=None) :
# print(instance)
if ObjectHelper.isNone(visitedIdInstances) :
visitedIdInstances = []
if ObjectHelper.isNativeClassInstance(instance) or ObjectHelper.isNone(instance) :
return instance
if EnumAnnotation.isEnumItem(instance) :
return instance.enumValue
if isDatetimeRelated(instance) :
return str(instance)
# print(f'{instance} not in {visitedIdInstances}: {instance not in visitedIdInstances}')
isVisitedInstance = id(instance) in visitedIdInstances
innerVisitedIdInstances = [*visitedIdInstances.copy()]
if ObjectHelper.isDictionary(instance) and not isVisitedInstance :
for key,value in instance.items() :
instance[key] = getObjectAsDictionary(value, visitedIdInstances=innerVisitedIdInstances)
return instance
elif isSerializerCollection(instance) :
objectValueList = []
for innerObject in instance :
innerAttributeValue = getObjectAsDictionary(innerObject, visitedIdInstances=innerVisitedIdInstances)
if ObjectHelper.isNotNone(innerAttributeValue) :
objectValueList.append(innerAttributeValue)
return objectValueList
elif not isVisitedInstance :
jsonInstance = {}
try :
# print(id(instance))
innerVisitedIdInstances.append(id(instance))
atributeNameList = ReflectionHelper.getAttributeNameList(instance.__class__)
for attributeName in atributeNameList :
attributeValue = getattr(instance, attributeName)
if ReflectionHelper.isNotMethodInstance(attributeValue):
jsonInstance[attributeName] = getObjectAsDictionary(attributeValue, visitedIdInstances=innerVisitedIdInstances)
else :
jsonInstance[attributeName] = None
except Exception as exception :
log.warning(getObjectAsDictionary, f'Not possible to get attribute name list from {ReflectionHelper.getName(ReflectionHelper.getClass(instance, muteLogs=True), muteLogs=True)}', exception=exception)
if ObjectHelper.isNotEmpty(jsonInstance) :
return jsonInstance
return str(instance)
def Wrapper(OuterClass, *args, **kwargs):
log.debug(Controller, f'''wrapping {OuterClass.__name__}''', None)
class InnerClass(OuterClass, flask_restful.Resource):
url = controllerUrl
tag = controllerTag
description = controllerDescription
def __init__(self, *args, **kwargs):
log.debug(
OuterClass,
f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})',
None)
apiInstance = getApi()
OuterClass.__init__(self)
flask_restful.Resource.__init__(self, *args, **kwargs)
self.service = apiInstance.resource.service
self.globals = apiInstance.globals
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
def Wrapper(OuterClass, *args, **kwargs):
log.wrapper(Scheduler, f'''wrapping {OuterClass.__name__}''')
class InnerClass(OuterClass):
def __init__(self, *args, **kwargs):
log.wrapper(
OuterClass,
f'in {InnerClass.__name__}.__init__(*{args},**{kwargs})')
apiInstance = FlaskManager.getApi()
OuterClass.__init__(self, *args, **kwargs)
self.globals = apiInstance.globals
self.service = apiInstance.resource.service
self.enabled = self.globals.getApiSetting(
ConfigurationKeyConstant.API_SCHEDULER_ENABLE)
self.disabled = disable
self.muteLogs = muteLogs or ConverterStatic.getValueOrDefault(
self.globals.getApiSetting(
ConfigurationKeyConstant.API_SCHEDULER_MUTE_LOGS),
DEFAUTL_MUTE_LOGS)
ReflectionHelper.overrideSignatures(InnerClass, OuterClass)
return InnerClass
