def crud_subscription(case_name, action):
if action == 'edit':
form = forms.EditSubscriptionForm(request.form)
if form.validate():
success = case_subscription.edit_subscription(
case_name, form.ancestry.data, form.events.data)
if success:
return json.dumps(case_subscription.subscriptions_as_json())
else:
return json.dumps(
{"status": "Error occurred while editing subscription"})
else:
return json.dumps({
"status":
"Error: Case name {0} was not found".format(case_name)
})
elif action == 'add':
form = forms.AddSubscriptionForm(request.form)
if form.validate():
case_subscription.add_subscription(case_name, form.ancestry.data,
form.events.data)
return json.dumps(case_subscription.subscriptions_as_json())
elif action == 'delete':
form = forms.DeleteSubscriptionForm(request.form)
if form.validate():
case_subscription.remove_subscription_node(case_name,
form.ancestry.data)
return json.dumps(case_subscription.subscriptions_as_json())
def update_subscription(case_name):
if request.form:
f = forms.EditSubscriptionForm(request.form)
data = {"ancestry": f.ancestry.data, "events": f.events.data}
else:
data = request.get_json()
if data:
if 'ancestry' in data and 'events' in data:
data['ancestry'] = convert_ancestry(data['ancestry'])
if len(data['ancestry']) == 1 and data['events']:
data['events'] = convert_scheduler_events(data['events'])
success = case_subscription.edit_subscription(
case_name, data['ancestry'], data['events'])
running_context.CaseSubscription.update(case_name)
running_context.db.session.commit()
if success:
return json.dumps(case_subscription.subscriptions_as_json())
else:
return json.dumps(
{"status": "Error occurred while editing subscription"})
else:
return json.dumps({"status": "Error: malformed JSON"})
else:
return json.dumps({"status": "Error: no JSON in request"})
def __func():
form = forms.ImportCaseForm(request.form)
filename = form.filename.data if form.filename.data else core.config.paths.default_case_export_path
if os.path.isfile(filename):
try:
with open(filename, 'r') as cases_file:
cases_file = cases_file.read()
cases_file = cases_file.replace('\n', '')
cases = json.loads(cases_file)
case_subscription.add_cases(cases)
for case in cases.keys():
running_context.db.session.add(
running_context.CaseSubscription(name=case))
running_context.CaseSubscription.update(case)
running_context.db.session.commit()
return {
"cases": case_subscription.subscriptions_as_json()
}, SUCCESS
except (OSError, IOError) as e:
current_app.logger.error(
'Error importing cases from file {0}: {1}'.format(
filename, format_exception_message(e)))
return {"error": "Error reading file."}, IO_ERROR
except ValueError as e:
current_app.logger.error(
'Error importing cases from file {0}: Invalid JSON {1}'.
format(filename, format_exception_message(e)))
return {"error": "Invalid JSON file."}, INVALID_INPUT_ERROR
else:
current_app.logger.debug(
'Cases successfully imported from {0}'.format(filename))
return {"error": "File does not exist."}, IO_ERROR
def import_cases():
form = forms.ImportCaseForm(request.form)
filename = form.filename.data if form.filename.data else core.config.paths.default_case_export_path
if os.path.isfile(filename):
try:
with open(filename, 'r') as cases_file:
cases_file = cases_file.read()
cases_file = cases_file.replace('\n', '')
cases = json.loads(cases_file)
case_subscription.add_cases(cases)
for case in cases.keys():
running_context.db.session.add(
running_context.CaseSubscription(name=case))
running_context.CaseSubscription.update(case)
running_context.db.session.commit()
return json.dumps({
"status":
"success",
"cases":
case_subscription.subscriptions_as_json()
})
except (OSError, IOError):
return json.dumps({"status": "error reading file"})
except ValueError:
return json.dumps({"status": "file contains invalid JSON"})
else:
return json.dumps({"status": "error: file does not exist"})
def delete_case(case_name):
delete_cases([case_name])
case = running_context.CaseSubscription.query.filter_by(
name=case_name).first()
if case:
running_context.db.session.delete(case)
running_context.db.session.commit()
return json.dumps(case_subscription.subscriptions_as_json())
def export_cases():
form = forms.ExportCaseForm(request.form)
filename = form.filename.data if form.filename.data else core.config.paths.default_case_export_path
try:
with open(filename, 'w') as cases_file:
cases_file.write(
json.dumps(case_subscription.subscriptions_as_json()))
return json.dumps({"status": "success"})
except (OSError, IOError):
return json.dumps({"status": "error writing to file"})
def __func():
converted_ancestry = convert_ancestry(ancestry['ancestry'])
result = case_subscription.remove_subscription_node(case, converted_ancestry)
if result:
running_context.CaseSubscription.update(case)
running_context.db.session.commit()
current_app.logger.debug('Deleted subscription {0}'.format(converted_ancestry))
return case_subscription.subscriptions_as_json()
else:
return {'error': 'Case or element does not exist.'}, OBJECT_DNE_ERROR
def __func():
delete_cases([case])
case_obj = running_context.CaseSubscription.query.filter_by(name=case).first()
if case_obj:
running_context.db.session.delete(case_obj)
running_context.db.session.commit()
current_app.logger.debug('Case deleted {0}'.format(case))
return case_subscription.subscriptions_as_json(), SUCCESS
else:
current_app.logger.error('Cannot delete case {0}. Case does not exist.'.format(case))
return {"error": "Case does not exist."}, OBJECT_DNE_ERROR
def __func():
form = forms.ExportCaseForm(request.form)
filename = form.filename.data if form.filename.data else core.config.paths.default_case_export_path
try:
with open(filename, 'w') as cases_file:
cases_file.write(json.dumps(case_subscription.subscriptions_as_json()))
current_app.logger.debug('Cases successfully exported to {0}'.format(filename))
return SUCCESS
except (OSError, IOError) as e:
current_app.logger.error('Error exporting cases to {0}: {1}'.format(filename, e))
return {"error": "Could not write to file."}, IO_ERROR
def __func():
case_obj = CaseSubscriptions()
add_cases({"{0}".format(str(case)): case_obj})
case_obj = running_context.CaseSubscription.query.filter_by(name=case).first()
if case_obj is None:
running_context.db.session.add(running_context.CaseSubscription(name=case))
running_context.db.session.commit()
current_app.logger.debug('Case added: {0}'.format(case))
return case_subscription.subscriptions_as_json(), OBJECT_CREATED
else:
current_app.logger.warning('Cannot create case {0}. Case already exists.'.format(case))
return {"error": "Case already exists."}, OBJECT_EXISTS_ERROR
def delete_subscription(case_name):
if request.get_json():
data = request.get_json()
if 'ancestry' in data:
case_subscription.remove_subscription_node(
case_name, convert_ancestry(data['ancestry']))
running_context.CaseSubscription.update(case_name)
running_context.db.session.commit()
return json.dumps(case_subscription.subscriptions_as_json())
else:
return json.dumps({"status": "Error: malformed JSON"})
else:
return json.dumps({"status": "Error: no JSON in request"})
def __func(element):
ancestry = convert_ancestry(element['ancestry'])
if len(ancestry) == 1 and element['events']:
element['events'] = convert_scheduler_events(element['events'])
success = case_subscription.edit_subscription(case, ancestry, element['events'])
running_context.CaseSubscription.update(case)
running_context.db.session.commit()
if success:
current_app.logger.info('Edited subscription {0} to {1}'.format(ancestry, element['events']))
return case_subscription.subscriptions_as_json(), SUCCESS
else:
current_app.logger.error('Error occurred while editing subscription '
'{0} to {1}'.format(ancestry, element['events']))
return {"error": "Case or element does not exist."}, OBJECT_DNE_ERROR
def __func():
events = element['events']
if len(element['ancestry']) == 1 and events:
events = convert_scheduler_events(events)
converted_ancestry = convert_ancestry(element['ancestry'])
result = case_subscription.add_subscription(case, converted_ancestry, events)
if result:
running_context.CaseSubscription.update(case)
running_context.db.session.commit()
current_app.logger.debug('Subscription added for {0} to {1}'.format(converted_ancestry, events))
return case_subscription.subscriptions_as_json(), OBJECT_CREATED
else:
current_app.logger.error("Cannot create subscription for case {0}. Case does not exist".format(case))
return {"error": "Case does not exist."}, OBJECT_DNE_ERROR
def add_subscription(case_name):
if request.get_json():
data = request.get_json()
if 'ancestry' in data:
events = data['events'] if 'events' in data else []
if len(data['ancestry']) == 1 and events:
events = convert_scheduler_events(events)
case_subscription.add_subscription(
case_name, convert_ancestry(data['ancestry']), events)
running_context.CaseSubscription.update(case_name)
running_context.db.session.commit()
return json.dumps(case_subscription.subscriptions_as_json())
else:
return json.dumps({"status": "Error: malformed JSON"})
else:
return json.dumps({"status": "Error: no JSON in request"})
def test_sync_to_subscriptions(self):
case1, _ = construct_case1()
case2, _ = construct_case2()
case3, _ = construct_case2()
case4, _ = construct_case1()
cases = {'case1': case1, 'case2': case2}
set_subscriptions(cases)
case_db_entry_1 = CaseSubscription('case3', subscription=json.dumps(case3.as_json()))
case_db_entry_2 = CaseSubscription('case4', subscription=json.dumps(case4.as_json()))
server.running_context.db.session.add(case_db_entry_1)
server.running_context.db.session.add(case_db_entry_2)
server.running_context.db.session.commit()
CaseSubscription.sync_to_subscriptions()
result_subscriptions = subscriptions_as_json()
self.assertIn('case3', result_subscriptions)
self.assertIn('case4', result_subscriptions)
self.assertNotIn('case1', result_subscriptions)
self.assertNotIn('case2', result_subscriptions)
self.assertDictEqual(result_subscriptions['case3'], case3.as_json())
self.assertDictEqual(result_subscriptions['case4'], case4.as_json())
def edit_global_subscription(case_name):
form = forms.EditGlobalSubscriptionForm(request.form)
if form.validate():
global_sub = case_subscription.GlobalSubscriptions(
controller=form.controller.data,
workflow=form.workflow.data,
step=form.step.data,
next_step=form.next_step.data,
flag=form.flag.data,
filter=form.filter.data)
success = case_subscription.edit_global_subscription(
case_name, global_sub)
if success:
return json.dumps(case_subscription.subscriptions_as_json())
else:
return json.dumps({
"status":
"Error: Case name {0} was not found".format(case_name)
})
else:
return json.dumps({"status": "Error: form invalid"})
return json.dumps({"status": "error writing to file"})
@cases_page.route('/<string:case_name>', methods=['PUT'])
@auth_token_required
@roles_accepted(*running_context.user_roles['/cases'])
def add_case(case_name):
case = CaseSubscriptions()
add_cases({"{0}".format(str(case_name)): case})
case = running_context.CaseSubscription.query.filter_by(
name=case_name).first()
if not case:
running_context.db.session.add(
running_context.CaseSubscription(name=case_name))
running_context.db.session.commit()
return json.dumps(case_subscription.subscriptions_as_json())
@cases_page.route('/<string:case_name>', methods=['GET'])
@auth_token_required
@roles_accepted(*running_context.user_roles['/cases'])
def read_case(case_name):
case = case_database.case_db.session.query(case_database.Case) \
.filter(case_database.Case.name == case_name).first()
if case:
return json.dumps({'case': case.as_json()})
else:
return json.dumps({'status': 'Case with given name does not exist'})
@cases_page.route('/<string:case_name>', methods=['POST'])
def display_subscriptions():
return json.dumps(case_subscription.subscriptions_as_json())
def __func():
return case_subscription.subscriptions_as_json(), SUCCESS
def crud_case(case_name, action):
if action == 'add':
case = CaseSubscriptions()
add_cases({"{0}".format(str(case_name)): case})
return json.dumps(case_subscription.subscriptions_as_json())
