def __before__(self, action, **params):
"""
Here we see, what action is to be called and check the authorization
"""
log.debug("[__before__::%r] %r" % (action, params))
try:
audit.initialize()
c.audit["success"] = False
c.audit["client"] = get_client()
if action != "check_t":
check_session()
return response
except webob.exc.HTTPUnauthorized as acc:
## the exception, when an abort() is called if forwarded
log.exception("[__before__::%r] webob.exception %r" % (action, acc))
Session.rollback()
Session.close()
raise acc
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context="before")
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
'''
Here we see, what action is to be called and check the authorization
'''
log.debug("[__before__::%r] %r" % (action, params))
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
if action != "check_t":
check_session(request)
request_context['Audit'] = audit
return response
except webob.exc.HTTPUnauthorized as acc:
## the exception, when an abort() is called if forwarded
log.exception("[__before__::%r] webob.exception %r" % (action, acc))
Session.rollback()
Session.close()
raise acc
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
"""
"""
try:
log.debug('[__before__::%r] %r', action, params)
audit.initialize()
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
self.request_context['Audit'] = audit
return request
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
finally:
log.debug('[__before__::%r] done', action)
def __before__(self, action, **params):
"""
"""
try:
log.debug('[__before__::%r] %r', action, params)
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
request_context['Audit'] = audit
checkAuthorisation(scope='monitoring', method=action)
return request
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
finally:
log.debug('[__before__::%r] done', action)
def __before__(self, action, **params):
"""
"""
try:
log.debug('[__before__::%r] %r', action, params)
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
request_context['Audit'] = audit
checkAuthorisation(scope='monitoring', method=action)
return request
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
finally:
log.debug('[__before__::%r] done', action)
def __before__(self, action, **params):
"""
"""
try:
log.debug("[__before__::%r] %r" % (action, params))
# Session handling
check_session(request)
checkToolsAuthorisation(action, params)
c.audit = request_context['audit']
return request
except PolicyException as exx:
log.exception("policy failed %r" % exx)
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
log.debug("[__before__::%r] %r" % (action, params))
try:
audit.initialize()
c.audit['success'] = False
c.audit['client'] = get_client(request)
c.version = get_version()
c.licenseinfo = get_copyright_info()
c.polDefs = getPolicyDefinitions()
# Session handling for the functions, that show data:
# Also exclude custom-style.css, since the CSRF check
# will always fail and return a HTTP 401 anyway.
# A HTTP 404 makes more sense.
if request.path.lower() in [
'/manage/', '/manage', '/manage/logout',
'/manage/audittrail', '/manage/policies',
'/manage/tokenview', '/manage/userview', '/manage/help',
'/manage/custom-style.css'
]:
pass
else:
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
'''
Here we see, what action is to be called and check the authorization
'''
log.debug("[__before__::%r] %r" % (action, params))
try:
audit.initialize()
c.audit['success'] = False
c.audit['client'] = get_client()
if action != "check_t":
check_session()
return response
except webob.exc.HTTPUnauthorized as acc:
## the exception, when an abort() is called if forwarded
log.error("[__before__::%r] webob.exception %r" % (action, acc))
log.error("[__before__] %s" % traceback.format_exc())
Session.rollback()
Session.close()
raise acc
except Exception as exx:
log.error("[__before__::%r] exception %r" % (action, exx))
log.error("[__before__] %s" % traceback.format_exc())
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
"""
"""
try:
log.debug('[__before__::%r] %r', action, params)
audit.initialize()
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
self.request_context['Audit'] = audit
return request
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
finally:
log.debug('[__before__::%r] done', action)
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context['action']
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
c.version = get_version()
c.version_ref = base64.encodebytes(c.version.encode())[:6]
c.licenseinfo = get_copyright_info()
c.polDefs = getPolicyDefinitions()
c.display_provider = boolean(
request_context['Config'].get('display_provider', True))
# -------------------------------------------------------------- --
# check for support of setting admin password
c.admin_can_change_password = False
if ('linotpadmin.user' in config and
'linotpadmin.password' in config):
c.admin_can_change_password = True
# -------------------------------------------------------------- --
# Session handling for the functions, that show data:
# Also exclude custom-style.css, since the CSRF check
# will always fail and return a HTTP 401 anyway.
# A HTTP 404 makes more sense.
if request.path.lower() in ['/manage/', '/manage',
'/manage/logout',
'/manage/audittrail',
'/manage/policies',
'/manage/tokenview',
'/manage/userview',
'/manage/help',
'/manage/custom-style.css']:
pass
else:
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context['action']
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
audit = config.get('audit')
request_context['Audit'] = audit
checkAuthorisation(scope='monitoring', method=action)
return
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
def __before__(self, action, **params):
"""
"""
try:
log.debug("[__before__::%r] %r" % (action, params))
# Session handling
check_session(request)
checkToolsAuthorisation(action, params)
c.audit = request_context['audit']
return request
except PolicyException as exx:
log.exception("policy failed %r" % exx)
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context['action']
try:
# Session handling
check_session(request)
checkToolsAuthorisation(action, params)
c.audit = request_context['audit']
return
except PolicyException as exx:
log.exception("policy failed %r" % exx)
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, action, **params):
'''
Here we see, what action is to be called and check the authorization
'''
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
if action != "check_t":
check_session(request)
request_context['Audit'] = audit
return response
except webob.exc.HTTPUnauthorized as acc:
# the exception, when an abort() is called if forwarded
log.exception("[__before__::%r] webob.exception %r"
% (action, acc))
Session.rollback()
Session.close()
raise acc
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context["action"]
try:
g.audit["success"] = False
g.audit["client"] = get_client(request)
# Session handling
check_session(request)
audit = config.get("audit")
request_context["Audit"] = audit
checkAuthorisation(scope="monitoring", method=action)
return
except Exception as exception:
log.error(exception)
db.session.rollback()
return sendError(response, exception, context="before")
def __before__(self, action):
try:
c.audit = request_context['audit']
c.audit['client'] = get_client(request)
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r", action, exx)
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, action):
try:
c.audit = request_context['audit']
c.audit['client'] = get_client(request)
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r", action, exx)
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, action, **params):
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
c.version = get_version()
c.version_ref = base64.encodestring(c.version)[:6]
c.licenseinfo = get_copyright_info()
c.polDefs = getPolicyDefinitions()
c.display_provider = boolean(
request_context['Config'].get('display_provider', True))
# -------------------------------------------------------------- --
# check for support of setting admin password
c.admin_can_change_password = False
if ('linotpadmin.user' in config and
'linotpadmin.password' in config):
c.admin_can_change_password = True
# -------------------------------------------------------------- --
# Session handling for the functions, that show data:
# Also exclude custom-style.css, since the CSRF check
# will always fail and return a HTTP 401 anyway.
# A HTTP 404 makes more sense.
if request.path.lower() in ['/manage/', '/manage',
'/manage/logout',
'/manage/audittrail',
'/manage/policies',
'/manage/tokenview',
'/manage/userview',
'/manage/help',
'/manage/custom-style.css']:
pass
else:
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action):
log.debug("[__before__]")
try:
audit.initialize()
c.audit['client'] = get_client(request)
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
log.debug("[__before__]")
try:
audit.initialize()
c.audit['client'] = get_client()
check_session()
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action):
log.debug("[__before__]")
try:
c.audit = self.request_context['audit']
c.audit['client'] = get_client(request)
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
log.debug("[__before__]")
try:
audit.initialize()
c.audit['client'] = get_client()
check_session()
except Exception as exx:
log.error("[__before__::%r] exception %r" % (action, exx))
log.error("[__before__] %s" % traceback.format_exc())
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
log.debug("[__before__::%r] %r" % (action, params))
try:
c.audit = request_context['audit']
c.audit['client'] = get_client(request)
check_session(request)
request_context['Audit'] = audit
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
log.debug("[__before__]")
try:
audit.initialize()
c.audit["client"] = get_client()
check_session()
except Exception as exx:
log.error("[__before__::%r] exception %r" % (action, exx))
log.error("[__before__] %s" % traceback.format_exc())
Session.rollback()
Session.close()
return sendError(response, exx, context="before")
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context["action"]
try:
g.audit["client"] = get_client(request)
check_session(request)
except Exception as exx:
log.error("[__before__::%r] exception %r", action, exx)
db.session.rollback()
return sendError(response, exx, context="before")
def __before__(self, **params):
'''
'''
action = request_context['action']
try:
g.audit['success'] = False
g.audit['client'] = get_client(request)
# Session handling
if action not in ['getsession', 'dropsession']:
check_session(request, scope='helpdesk')
except Exception as exx:
log.exception("[__before__::%r] exception", action)
db.session.rollback()
return sendError(None, exx, context='before')
def __before__(self, action, **params):
log.debug("[__before__::%r] %r" % (action, params))
try:
audit.initialize()
c.audit["success"] = False
c.audit["client"] = get_client()
c.version = get_version()
c.licenseinfo = get_copyright_info()
c.polDefs = getPolicyDefinitions()
# Session handling for the functions, that show data:
# Also exclude custom-style.css, since the CSRF check
# will always fail and return a HTTP 401 anyway.
# A HTTP 404 makes more sense.
if request.path.lower() in [
"/manage/",
"/manage",
"/manage/logout",
"/manage/audittrail",
"/manage/policies",
"/manage/tokenview",
"/manage/userview",
"/manage/help",
"/manage/custom-style.css",
]:
pass
else:
check_session()
except Exception as exx:
log.error("[__before__::%r] exception %r" % (action, exx))
log.error("[__before__] %s" % traceback.format_exc())
Session.rollback()
Session.close()
return sendError(response, exx, context="before")
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, **params):
"""
__before__ is called before every action
Here we see, what action is to be called and check the authorization
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context['action']
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
if action != "check_t":
check_session(request)
audit = config.get('audit')
request_context['Audit'] = audit
return
except flap.HTTPUnauthorized as acc:
# the exception, when an abort() is called if forwarded
log.exception("[__before__::%r] webob.exception %r" %
(action, acc))
Session.rollback()
Session.close()
raise acc
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, action, **params):
"""
"""
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
request_context['Audit'] = audit
checkAuthorisation(scope='reporting.access', method=action)
return request
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context['action']
try:
c.audit = request_context['audit']
c.audit['client'] = get_client(request)
check_session(request)
audit = config.get('audit')
request_context['Audit'] = audit
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, action, **params):
"""
"""
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
# Session handling
check_session(request)
request_context['Audit'] = audit
checkAuthorisation(scope='reporting.access', method=action)
return request
except Exception as exception:
log.exception(exception)
Session.rollback()
Session.close()
return sendError(response, exception, context='before')
def __before__(self, action, **params):
log.debug("[__before__::%r] %r" % (action, params))
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
c.version = get_version()
c.licenseinfo = get_copyright_info()
c.polDefs = getPolicyDefinitions()
# Session handling for the functions, that show data:
# Also exclude custom-style.css, since the CSRF check
# will always fail and return a HTTP 401 anyway.
# A HTTP 404 makes more sense.
if request.path.lower() in ['/manage/', '/manage',
'/manage/logout',
'/manage/audittrail',
'/manage/policies',
'/manage/tokenview',
'/manage/userview',
'/manage/help',
'/manage/custom-style.css']:
pass
else:
check_session(request)
except Exception as exx:
log.exception("[__before__::%r] exception %r" % (action, exx))
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
finally:
log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params):
'''
'''
try:
c.audit = request_context['audit']
c.audit['success'] = False
c.audit['client'] = get_client(request)
request_context['Audit'] = audit
# Session handling
if action not in ['getsession', 'dropsession']:
check_session(request, scope='helpdesk')
return request
except Exception as exx:
log.exception("[__before__::%r] exception", action)
Session.rollback()
Session.close()
return sendError(response, exx, context='before')
def __before__(self, **params):
"""
__before__ is called before every action
:param params: list of named arguments
:return: -nothing- or in case of an error a Response
created by sendError with the context info 'before'
"""
action = request_context["action"]
try:
g.audit["success"] = False
g.audit["client"] = get_client(request)
c.version = get_version()
c.version_ref = base64.encodebytes(c.version.encode())[:6]
c.licenseinfo = get_copyright_info()
c.polDefs = get_policy_definitions()
c.display_provider = boolean(
request_context["Config"].get("display_provider", True)
)
# -------------------------------------------------------------- --
# check for support of setting admin password
c.admin_can_change_password = False
if (
"linotpadmin.user" in config
and "linotpadmin.password" in config
):
c.admin_can_change_password = True
# -------------------------------------------------------------- --
# Session handling for the functions, that show data:
# Also exclude custom-style.css, since the CSRF check
# will always fail and return a HTTP 401 anyway.
# A HTTP 404 makes more sense.
if request.path.lower() in [
"/manage/",
"/manage",
"/manage/login",
"/manage/audittrail",
"/manage/policies",
"/manage/tokenview",
"/manage/userview",
"/manage/help",
"/manage/custom-style.css",
]:
pass
else:
check_session(request)
except Exception as exx:
log.error("[__before__::%r] exception %r", action, exx)
db.session.rollback()
return sendError(response, exx, context="before")
finally:
log.debug("[__before__::%r] done", action)
