def get(p):
id = tools.get('id')
# delete
es.delete(p['host'], 'core_data', 'datasource', id)
es.flush(p['host'], 'core_data')
return tools.redirect(request.referrer)
def get(p):
# get list of roles
query = "site_id:{}".format(p['site']['id'])
option = "size=10000&sort=name:asc"
p['role_list'] = es.list(p['host'], 'core_nav', 'role', query, option)
# selected role
role_id = p['nav'][-1]
p['role'] = es.get(p['host'], 'core_nav', 'role', role_id)
if not p['role']:
p['role'] = p['role_list'][0]
# get permission
permission_id = "{}_{}".format(p['role']['id'], p['navigation']['id'])
p['permission'] = es.get(p['host'], 'core_nav', 'permission', permission_id)
if request.method == "POST":
doc = { "operations": [x for x in tools.get('operations', []) if x] }
if not p['permission']:
# create permission
es.create(p['host'], 'core_nav', 'permission', permission_id, doc)
else:
# edit permission
es.update(p['host'], 'core_nav', 'permission', permission_id, doc)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
return render_template("post/permission/default.html", p=p)
def set_conf(host, index, name, value):
config = {
'name': name,
'value': value
}
es.update(host, index, "config", name, config)
es.flush(host, index)
def get(p):
# load navigation
navigation_id = p['nav'][-1]
navigation = es.get(p['host'], 'core_nav', 'navigation', navigation_id)
if not navigation:
return tools.alert(
'not valid navigation id - {}'.format(navigation_id))
if not tools.get('site_id'): return tools.alert("site id missing")
if not tools.get('module_id'): return tools.alert("module id missing")
# edit role
doc = {
'site_id': tools.get('site_id'),
'parent_id': tools.get('parent_id'),
'module_id': tools.get('module_id'),
'order_key': int(tools.get('order_key')),
'is_displayed': tools.get('is_displayed'),
'name': tools.get('name'),
'display_name': tools.get('display_name'),
'url': tools.get('url'),
'new_window': tools.get('new_window'),
'description': tools.get('description')
}
es.update(p['host'], 'core_nav', 'navigation', navigation_id, doc)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
host = p['c']['host']; index = p['c']['index'];
# init workflow
wf = tools.get("wf", 'comment_edit')
p['workflow'] = workflow.init(wf, host, index)
# load comment
post_id = p['nav'][-1]
p['post'] = es.get(host, index, 'post', post_id)
if not p['post']:
return tools.alert('not valid post id - {}'.format(post_id))
# comment_id
comment_id = tools.get("id")
p['comment'] = next((x for x in p['post']['comment'] if x['id'] == comment_id), None)
if not p['comment']:
return tools.alert('not valid comment_id - {}'.format(comment_id))
# field map
fields = es.list(host, index, 'field')
p['field_map'] = {}
for field in fields:
p['field_map'][field['name']] = field['id']
# update comment
p['comment']['updated'] = es.now()
p['comment']['updated_by'] = p['login']
p['comment']['comment'] = tools.get("comment")
es.update(host, index, 'post', post_id, p['post'])
es.flush(host, index)
return tools.redirect(request.referrer)
def trigger_scheduled_tasks():
# today
dayofmonth = datetime.today().day
dayofweek = datetime.today().weekday()
hour = datetime.today().hour
minute = datetime.today().minute
# get list of tasks that should run under this host
query = """
(dayofmonth:{} OR dayofmonth:None) AND
(dayofweek:{} OR dayofweek:None) AND
(hour:{} OR hour:None) AND
(minute:{} OR minute:None)
""".format(dayofmonth, dayofweek, hour, minute)
ret = es.list(HOST, 'core_task', 'schedule', query)
for schedule in ret:
# check if instance exists
query = """
task_id:{} AND
created:[now-1m TO now+1m]
""".format(schedule['task_id'])
instance = es.list(HOST, 'core_task', 'instance', query)
if len(instance) > 0:
continue # task already triggered
# create instance
es.create(
HOST, 'core_task', 'instance', '', {
"task_id": schedule['task_id'],
"status": "WAITING",
"login": "******",
"created": es.now()
})
es.flush(HOST, 'core_task')
def get(p):
host = p['c']['host']
index = p['c']['index']
# load comment
post_id = p['nav'][-1]
p['post'] = es.get(host, index, 'post', post_id)
if not p['post']:
return tools.alert('not valid post id - {}'.format(post_id))
# comment_id
comment_id = tools.get("id")
p['comment'] = next(
(x for x in p['post']['comment'] if x['id'] == comment_id), {})
if not p['comment']:
return tools.alert('not valid comment_id - {}'.format(comment_id))
# init workflow
wf = tools.get('wf', 'comment_delete')
p['workflow'] = workflow.init(wf, host, index)
# remove comment
p['post']['comment'].remove(p['comment'])
es.update(host, index, 'post', post_id, p['post'])
es.flush(host, index)
return tools.redirect(request.referrer)
def get(p):
host = p['c']['host']
index = p['c']['index']
# load notification
notification_id = p['nav'][-1]
p['notification'] = es.get(host, index, 'notification', notification_id)
if not p['notification']:
return tools.alert(
'not valid notification id - {}'.format(notification_id))
# save notification
if request.method == "POST":
doc = {
'header': tools.get('header'),
'message': tools.get('message'),
'recipients': tools.get('recipients'),
'condition': tools.get('condition'),
'workflow': tools.get('workflow')
}
es.update(host, index, 'notification', notification_id, doc)
es.flush(host, index)
return tools.redirect("{}/notification/edit/{}".format(
p['url'], notification_id))
return render_template("post/notification/edit.html", p=p)
def get(p):
host = p['c']['host'] ; index = p['c']['index'] ;
# get list of mappings
mapping = es.mapping(host, index, 'post')
properties = mapping[index]['mappings']['post']['properties']
# get all field list
p['field_list'] = []
for prop in properties.keys():
field = es.get(host, index, 'field', prop)
if not field:
# create field
field = {
"type": properties[prop].get('type'),
"name": prop,
"order_key": '10000'
}
es.create(host, index, 'field', prop, field)
es.flush(host, index)
field['id'] = prop
# add to field list
p['field_list'].append(field)
# sort by order key
p['field_list'] = sorted(p['field_list'],
key=lambda field: int(field['order_key'] if field['order_key'] else 10000))
return render_template("post/field/default.html", p=p)
def log(self, status, message):
es.create(self.host, 'core_task', 'log', '', {
"instance_id": self.instance['id'],
"action": self.action['name'],
"status": status,
"message": message,
"created": es.now()
})
es.flush(self.host, 'core_task')
def get(p):
# load schedule
schedule_id = p['nav'][-1]
schedule = es.get(p['host'], 'core_task', 'schedule', schedule_id)
if not schedule:
return tools.alert('schedule not found - {}'.format(schedule_id))
es.delete(p['host'], 'core_task', 'schedule', schedule_id)
es.flush(p['host'], 'core_task')
return tools.redirect(request.referrer)
def get(p):
es.create(p['host'], 'core_task', 'task', '', {
'navigation_id': p['navigation']['id'],
'name': tools.get('name'),
'runat': tools.get('runat', 'anywhere'),
'description': tools.get('description')
})
es.flush(p['host'], 'core_task')
return tools.redirect(request.referrer)
def get(p):
# load task
task_id = p['nav'][-1]
p['task'] = es.get(p['host'], 'core_task', 'task', task_id)
if not p['task']:
return tools.alert('task not found - {}'.format(task_id))
es.delete(p['host'], 'core_task', 'task', task_id)
es.flush(p['host'], 'core_task')
return tools.redirect(request.referrer)
def get(p):
# load rule
rev_proxy_id = p['nav'][-1]
rev_proxy = es.get(p['host'], 'core_proxy', 'rev_proxy', rev_proxy_id)
if not rev_proxy:
return tools.alert('not valid rev_proxy id - {}'.format(rev_proxy_id))
# delete
es.delete(p['host'], 'core_proxy', 'rev_proxy', rev_proxy_id)
es.flush(p['host'], 'core_proxy')
return tools.redirect(request.referrer)
def get(p):
# load role
role_id = p['nav'][-1]
p['role'] = es.get(p['host'], 'core_nav', 'role', role_id)
if not p['role']:
return tools.alert('not valid role id - {}'.format(role_id))
# delete
es.delete(p['host'], 'core_nav', 'role', role_id)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
# url shall exist
if not tools.get('url'): return tools.alert("url is missing")
# create new reverse proxy rule
doc = {
'url': tools.get('url')
}
es.create(p['host'], 'core_proxy', 'public', '', doc)
es.flush(p['host'], 'core_proxy')
return tools.redirect(request.referrer)
def get(p):
# Load Action
action_id = p['nav'][-1]
p['action'] = es.get(p['host'], 'core_task', 'action', action_id)
if not p['action']:
return tools.alert('not valid action id - {}'.format(action_id))
# delete
es.delete(p['host'], 'core_task', 'action', p['action']['id'])
es.flush(p['host'], 'core_task')
return tools.redirect(request.referrer)
def get(p):
# create new site
site = {
'order_key': tools.get('order_key'),
'name': tools.get('name'),
'display_name': tools.get('display_name'),
'description': tools.get('description')
}
es.create(p['host'], 'core_nav', 'site', '', site)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
# create new login module
doc = {
"type": tools.get('type'),
"name": tools.get('name'),
"description": tools.get('description'),
"priority": tools.get('priority'),
"configuration": tools.get('configuration')
}
es.create(p['host'], 'core_nav', 'login_module', '', doc)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
# load public url
public_id = p['nav'][-1]
public = es.get(p['host'], 'core_proxy', 'public', public_id)
if not public:
return tools.alert('not valid public url id - {}'.format(public_id))
# edit role
doc = {'url': tools.get('url')}
es.update(p['host'], 'core_proxy', 'public', public_id, doc)
es.flush(p['host'], 'core_proxy')
return tools.redirect(request.referrer)
def get(p):
# load login module
login_module_id = p['nav'][-1]
login_module = es.get(p['host'], 'core_nav', 'login_module',
login_module_id)
if not login_module:
return tools.alert(
'not valid login module id - {}'.format(login_module_id))
# deletelogin module
es.delete(p['host'], 'core_nav', 'login_module', login_module_id)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
host = p['c']['host']
index = p['c']['index']
# load workflow
workflow_id = p['nav'][-1]
p['workflow'] = es.get(host, index, 'workflow', workflow_id)
if not p['workflow']:
return tools.alert('not valid workflow id - {}'.format(workflow_id))
# delete
es.delete(host, index, 'workflow', workflow_id)
es.flush(host, index)
return tools.redirect(request.referrer)
def get(p):
host = p['c']['host']
index = p['c']['index']
# load notification
notification_id = p['nav'][-1]
p['notification'] = es.get(host, index, 'notification', notification_id)
if not p['notification']:
return tools.alert(
'not valid notification id - {}'.format(notification_id))
# delete notification
es.delete(host, index, 'notification', notification_id)
es.flush(host, index)
return tools.redirect(request.referrer)
def get(p):
# name shall exist
if not tools.get('inc_url'): return tools.alert("incoming url is missing")
if not tools.get('out_url'): return tools.alert("outgoing url is missing")
# create new reverse proxy rule
doc = {
'inc_url': tools.get('inc_url'),
'out_url': tools.get('out_url'),
'auth_method': tools.get('auth_method'),
'header': tools.get('header')
}
es.create(p['host'], 'core_proxy', 'rev_proxy', '', doc)
es.flush(p['host'], 'core_proxy')
return tools.redirect(request.referrer)
def get(p):
# check if site_id is passed
p['site_id'] = tools.get('site_id')
if not p['site_id']: return tools.alert('site id is missing')
if request.method == "POST":
# save custom navigation
p['site'] = {'navigation': tools.get('navigation')}
es.update(p['host'], 'core_nav', 'site', p['site_id'], p['site'])
es.flush(p['host'], 'core_nav')
# load site
p['site'] = es.get(p['host'], 'core_nav', 'site', p['site_id'])
if not p['site']: return tools.alert('site id is not valid')
return render_template("admin/customize/default.html", p=p)
def get(p):
site_id = p['nav'][-1]
# root site can't be deleted
if site_id == "0":
return tools.alert("Root site can't be deleted")
# check if site id is valid
site = es.get(p['host'], 'core_nav', 'site', site_id)
if not site:
return tools.alert("not valid site id: {}".format(site_id))
es.delete(p['host'], 'core_nav', 'site', site_id)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
if not tools.get('name'): return tools.alert('name is missing')
# save to configuration
es.create(
p['host'], 'core_data', 'datasource', '', {
'navigation_id': p['navigation']['id'],
'type': tools.get('type'),
'name': tools.get('name'),
'description': tools.get('description'),
'connection': tools.get('connection'),
'query': tools.get('query')
})
es.flush(p['host'], 'core_data')
return tools.redirect(request.referrer)
def get(p):
# load role
role_id = p['nav'][-1]
p['role'] = es.get(p['host'], 'core_nav', 'role', role_id)
if not p['role']:
return tools.alert('not valid role id - {}'.format(role_id))
# edit role
doc = {}
if tools.get('users'): doc['users'] = tools.get('users')
if tools.get('name'): doc['name'] = tools.get('name')
if tools.get('description'): doc['description'] = tools.get('description')
es.update(p['host'], 'core_nav', 'role', role_id, doc)
es.flush(p['host'], 'core_nav')
return tools.redirect(request.referrer)
def get(p):
host = p['c']['host']
index = p['c']['index']
doc = {
"name": tools.get("name"),
"description": tools.get("description"),
"status": tools.get("status"),
"condition": tools.get("condition"),
"validation": tools.get('validation'),
"postaction": tools.get('postaction'),
"screen": tools.get('screen')
}
es.create(host, index, 'workflow', '', doc)
es.flush(host, index)
return tools.redirect(request.referrer)
def post(p, host, index):
# save field
doc = {
"is_filter": tools.get("is_filter"),
"filter_field": tools.get("filter_field"),
"handler": tools.get("handler"),
"name": tools.get("name"),
"visible": tools.get("visible"),
"order_key": int(tools.get("order_key")),
"list_tpl": tools.get("list_tpl"),
"view_tpl": tools.get("view_tpl"),
"edit_tpl": tools.get("edit_tpl")
}
es.update(host, index, 'field', p['field']['id'], doc)
es.flush(host, index)
return tools.redirect(request.referrer)
