def post_fork():
global session
create_logger(__name__).info("logging in as system")
session = Session()
create_logger(__name__).info(
f"logged in as system with sessionid: {session.session_id}")
def __init__(self):
user = AppInfo.system_credentials()
self.session_id = AppInfo.login(user['username'], user['password'])
if self.session_id == None:
create_logger(__name__).info(
"username / password wrong or user is disaled")
context = AppInfo.create_context(self.session_id)
context.get_session_values()['timer_interval'] = 0
context.get_session_values()['timer_unit'] = 'm'
AppInfo.save_context(context)
def render_status_template(context, http_status, err_desc):
www_root=AppInfo.get_current_config("ui","wwwroot",exception=True)
path=f"templates/error/{http_status}.htm"
default_template="templates/error/default.htm"
template=None
log.create_logger(__name__).info(f"{FileSystemTools.format_path(www_root)}{path}")
if os.path.isfile(f"{FileSystemTools.format_path(www_root)}{path}"):
template=JinjaTemplate.create_file_template(context, path).render({"error": http_status, "description": err_desc})
elif os.path.isfile(f"{FileSystemTools.format_path(www_root)}{default_template}"):
template=JinjaTemplate.create_file_template(context, default_template).render({"error": http_status, "description": err_desc})
else:
template=JinjaTemplate.create_string_template(context,
"""<div>Statuscode_:{{ error }}</div><div>Description:{{ description }}</div>"""
).render({"error": http_status, "description": err_desc})
return template
def post(self):
username = ""
password = ""
next = HTTPRequest.redirect(request)
if 'username' in request.headers:
username = request.headers.get("username")
password = request.headers.get("password")
elif 'username' in request.form:
username = request.form.get("username")
password = request.form.get("password")
elif 'restapi_username' in request.form:
username = request.form.get("restapi_username")
password = request.form.get("restapi_password")
log.create_logger(__name__).info(f"{username} {password}")
session_id = AppInfo.login(username, password)
log.create_logger(__name__).info(f"{request.accept_mimetypes}")
if session_id == None:
if next == None:
abort(400, 'wrong username or password')
else:
return redirect(
f"/ui/login?redirect={next}&msg=Wrong username or password",
code=302)
else:
session['session_id'] = session_id
g.context = AppInfo.create_context(session_id)
if next == None:
response = make_response({
"session_id": session_id,
"status": "logged_on"
})
response.headers['content-type'] = 'text/json'
return response
else:
return redirect(next, code=302)
def every_minute(signum):
context = AppInfo.create_context(session.session_id)
interval = int(context.get_session_values()['timer_interval']) + 1
context.get_session_values()['timer_interval'] = interval
unit = context.get_session_values()['timer_unit']
create_logger(__name__).info(f"Interval: {interval}")
AppInfo.save_context(context, close_context=False)
#every minute
execute_plugin(context, "$timer_every_minute", {})
# every ten minutes
if interval % 10 == 0:
execute_plugin(context, "$timer_every_ten_minutes", {})
# every hour
if interval % 60 == 0:
execute_plugin(context, "$timer_every_hour", {})
AppInfo.save_context(context)
def __init__(self, fetch_xml, context):
self._logger=log.create_logger(__name__)
self._fetch_xml=fetch_xml
self._context=context
self._sql_type=""
self._sql_where=""
self._sql_table=""
self._sql_table_alias=""
self._sql_table_join=""
self._sql_select="*"
self._sql_comment=""
self._sql_order=""
self._sql_group_by=""
self._sql_paramaters_order=[]
self._json_fields={} # for insert and update
self._tables=[]
self._sql_parameters_where=[]
self._table_aliases={}
self._columns_desc=[]
self.parse()
import decimal
from flask import Flask, request, abort, g, session
from flask import Blueprint
from flask_restplus import Resource, Api, reqparse
from flaskext.mysql import MySQL
from datetime import date, datetime, time, timedelta
from core.appinfo import AppInfo
from services.fetchxml import build_fetchxml_by_alias
from services.database import DatabaseServices
from core.fetchxmlparser import FetchXmlParser
from core.jsontools import json_serial
from core.exceptions import RestApiNotAllowed
from core import log
logger = log.create_logger(__name__)
def create_parser():
parser = reqparse.RequestParser()
return parser
class EntityListFilter(Resource):
api = AppInfo.get_api()
@api.doc(parser=create_parser())
def post(self):
try:
parser = create_parser().parse_args()
context = g.context
def async_action(arguments):
context = AppInfo.create_context(session.session_id)
create_logger(__name__).info("spool")
AppInfo.save_context(context)
def execute_plugin(context, publisher, params):
create_logger(__name__).info(publisher)
plugin = Plugin(context, publisher, 'execute')
plugin.execute('after', {'input': params, 'output': {}})
import json
import pymysql.cursors
from flask import Flask, Blueprint
from flask_restplus import Resource, Api, reqparse
from flaskext.mysql import MySQL
from pymysql.cursors import DictCursor
import uuid
from core.context import Context
from config import CONFIG
from core.log import create_logger
from core.exceptions import ConfigNotValid
logger=create_logger(__name__)
class CustomFlask(Flask):
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
if rule=='/' and endpoint.endswith('root'):
logger.info(f"Rule {rule} for endpoint {endpoint} not accepted!")
return
logger.info(f"Add rule {rule} for endpoint {endpoint}")
return super(CustomFlask, self).add_url_rule(rule, endpoint, view_func, **options)
class AppInfo:
_app=None
_api=None
_content_api=None
_ui_api=None
