def render_preview_table(request):
"""
Will return the in-progress table of the final fusion, the TF, without activated rule modules.
Will also provide metadata for further frontend display options.
"""
success = False
ignore_duplicates = False
table = {"out_headers": None, "out_rows": None}
ff_name = ""
valid_user = token_checker.token_is_valid(request)
if valid_user:
table = get_preview_table(valid_user)
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
ff_name = ff.name
if len(table["out_rows"]) > 0:
success = True
ignore_duplicates = ff.ignore_duplicates
return HttpResponse(json.dumps(
{
"success": success,
"ff_name": ff_name,
"ignore_duplicates": ignore_duplicates,
"headers": table["out_headers"],
"rows": table["out_rows"]
}))
def i_render_ff(request):
"""
Will provide inclusion data of the export UI for the frontend.
"""
valid_user = token_checker.token_is_valid(request)
if valid_user:
return dashboard_includer.get_as_json("final_fusion/_export.html")
def i_render_new_project(request):
"""
Will return content to render the landing page UI of a project (where you can create notes).
"""
valid_user = token_checker.token_is_valid(request)
if valid_user:
return dashboard_includer.get_as_json("project/_new_project.html")
def render_project_details(request):
"""
Will render project details for display at the landing page UI.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user:
try:
project = Project.objects.get(pk=valid_user.last_opened_project_id, archived=False)
c_date = project.creation_date.strftime('%d.%m.%Y')
days_past = datetime.utcnow().replace(tzinfo=utc) - project.creation_date.replace(tzinfo=utc)
return HttpResponse(json.dumps(
{
"success": True,
"creation_date": str(c_date),
"shared": project.shared,
"days_past": days_past.days,
}))
except ObjectDoesNotExist:
pass
return HttpResponse(json.dumps(
{
"success": success,
}))
def i_render_user_projects(request):
"""
Will provide content for project UI inclusion. Will count added TQs and rule modules to pass
them for display.
"""
valid_user = token_checker.token_is_valid(request)
dic = {}
if valid_user:
projects = list(Project.objects.filter(user_profile=valid_user, archived=False).order_by("pk"))
projects.extend(Project.objects.filter(shared=True, archived=False).order_by("pk"))
project_list = []
for p in projects:
ff = FinalFusion.objects.get(project=p)
rm_count = len(RuleModule.objects.filter(final_fusion=ff, archived=False))
rm_count += len(ScriptModule.objects.filter(final_fusion=ff, archived=False))
project_list.append({
"id": p.pk,
"name": p.name,
"tq_len": len(TQFile.objects.filter(project=p, archived=False)),
"rm_len": rm_count,
"date": "Erstellt am %s" % p.creation_date.strftime('%d.%m.%Y'),
})
dic["projects"] = project_list
return dashboard_includer.get_as_json("project/_user_projects.html", template_context=dic)
def do_select_all(request):
"""
Will automatically select all columns of the TQ (request['tq_id']) to the current TF of the project.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "tq_id" in request.GET and ArgsChecker.is_number(
request.GET["tq_id"]):
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
tq = TQFile.objects.get(pk=request.GET["tq_id"],
project=proj,
archived=False)
for dic in json.loads(tq.content_json):
for col in dic.keys():
if len(
FinalFusionColumn.objects.filter(
source_tq=tq,
archived=False,
source_column_name=col)) == 0:
FinalFusionColumn.objects.create(final_fusion=ff,
source_tq=tq,
source_column_name=col,
display_column_name=col,
rows_json=json.dumps(
tq.get_column(col)))
break
success = True
return HttpResponse(json.dumps({"success": success}))
def i_render_settings(request):
"""
i_render_settings
"""
valid_user = token_checker.token_is_valid(request)
if valid_user:
return dashboard_includer.get_as_json("user_profile/_settings.html",
different_js="_user_settings.js")
def i_render_import(request):
"""
Will render the import page for TQs by inclusion.
"""
valid_user = token_checker.token_is_valid(request)
if valid_user:
dic = {"csrf_token": get_csrf_token(request)}
return dashboard_includer.get_as_json("tq_file/_import.html",
template_context=dic)
def do_logout(request):
"""
do_logout
"""
valid_user = token_checker.token_is_valid(request)
if valid_user:
response = HttpResponse(json.dumps({"success": True}))
response.set_cookie("token", None)
return response
else:
return HttpResponse(json.dumps({"success": False}))
def do_create_col_rm(request):
"""
Will create a column rule module from the web request.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and col_rule_condition_check(request):
rm = request_to_col_rm(request)
rm.save()
if rm:
success = True
return HttpResponse(json.dumps({"success": success}))
def do_rename(request):
"""
Will rename the currently opened project.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "name" in request.GET and not ArgsChecker.str_is_malicious(request.GET["name"]):
project = Project.objects.get(pk=valid_user.last_opened_project_id)
project.name = request.GET["name"]
project.save()
success = True
return HttpResponse(json.dumps({"success": success}))
def render_filtered(request):
"""
Will render rule modules which contain 'filter_name' in their names. Used for rm-search.
"""
success = False
items = []
valid_user = token_checker.token_is_valid(request)
if valid_user and "filter" in request.GET and not ArgsChecker.str_is_malicious(request.GET["filter"]):
success = True
filter_name = request.GET["filter"].strip()
types_display = {
"col": "COL",
"row": "ROW",
"script": "SCR"
}
projects = Project.objects.filter(user_profile=valid_user, archived=False)
for p in projects:
ff = FinalFusion.objects.get(project=p)
rule_modules = RuleModule.objects.filter(final_fusion=ff, archived=False)
script_modules = ScriptModule.objects.filter(final_fusion=ff, archived=False)
for rm in rule_modules:
if filter_name.lower() in rm.name.lower():
items.append({
"project_name": p.name,
"id": rm.pk,
"name": rm.name,
"type": rm.rule_type,
"type_display": types_display[rm.rule_type]
})
for sm in script_modules:
if filter_name in sm.name:
items.append({
"project_name": p.name,
"id": sm.pk,
"name": sm.name,
"type": "script",
"type_display": types_display["script"]
})
return HttpResponse(json.dumps({
"success": success,
"items": json.dumps(items)
}))
def do_rename(request):
"""
Will rename a TF according to the submitted info. The name will be applied for the EF, too.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "name" in request.GET and not ArgsChecker.str_is_malicious(request.GET["name"]):
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
ff.name = request.GET["name"]
ff.save()
success = True
return HttpResponse(json.dumps({"success": success}))
def render_all(request):
"""
Will return a dictionary containing all notes of a project.
"""
valid_user = token_checker.token_is_valid(request)
items = []
if valid_user:
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
notes = ProjectNote.objects.filter(project=proj, archived=False)
for n in notes:
items.append({"id": n.pk, "name": n.name, "content": n.content})
return HttpResponse(json.dumps({
"items": items,
}))
def i_render_single_tq(request):
"""
Will render a single TQ with its metadata by inclusion.
"""
valid_user = token_checker.token_is_valid(request)
if valid_user and "id" in request.GET and ArgsChecker.is_number(
request.GET["id"]):
tq = TQFile.objects.get(pk=request.GET["id"], archived=False)
dic = {
"id": tq.pk,
"name": tq.display_file_name,
"created": tq.creation_date.strftime('%d.%m.%Y')
}
return dashboard_includer.get_as_json("tq_file/_view.html",
template_context=dic)
def do_save_edit_col(request):
"""
Will edit a col-rm by taking the existing one and overriding the new changes.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "id" in request.GET and ArgsChecker.is_number(request.GET["id"]) \
and col_rule_condition_check(request):
rm = request_to_col_rm(request, request.GET["id"])
rm.save()
if rm:
success = True
return HttpResponse(json.dumps({"success": success}))
def do_validate_code(request):
"""
Will check whether the passed code (by request) is valid script code.
Creates a temporary script module and will return the result of its validation method.
"""
valid_user = token_checker.token_is_valid(request)
if valid_user and "code" in request.POST:
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
sm = ScriptModule()
sm.code_content = request.POST["code"]
sm.final_fusion = ff
return HttpResponse(json.dumps(sm.check_validity()))
def do_delete_project(request):
"""
Will delete a project by archiving.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user:
if "id" in request.GET and ArgsChecker.is_number(request.GET["id"]):
try:
project = Project.objects.get(pk=request.GET["id"], user_profile=valid_user)
project.archived = True
project.save()
success = True
except ObjectDoesNotExist:
pass
return HttpResponse(json.dumps({"success": success}))
def do_delete(request):
"""
Will remove a TQ by archiving it.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "id" in request.GET and not ArgsChecker.str_is_malicious(
request.GET["id"]):
tq = TQFile.objects.get(pk=request.GET["id"])
tq.archived = True
tq.save()
success = True
return HttpResponse(json.dumps({"success": success}))
def do_delete_rm(request):
"""
Will delete a rule module by archiving.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "id" in request.GET and ArgsChecker.is_number(request.GET["id"]):
try:
ff = FinalFusion.objects.get(project=Project.objects.get(pk=valid_user.last_opened_project_id))
rm = RuleModule.objects.get(pk=request.GET["id"], final_fusion=ff)
rm.archived = True
rm.save()
success = True
except ObjectDoesNotExist:
pass
return HttpResponse(json.dumps({"success": success}))
def do_rename(request):
"""
Will rename a TQ according to request['name'].
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "name" in request.GET and not ArgsChecker.str_is_malicious(request.GET["name"]) \
and "id" in request.GET and not ArgsChecker.str_is_malicious(request.GET["id"]):
tq = TQFile.objects.get(pk=request.GET["id"])
tq.display_file_name = request.GET["name"]
tq.save()
success = True
return HttpResponse(json.dumps({"success": success}))
def do_select_column(request):
"""
Will add or remove a column of a contextual TQ to the TF of the project.
If this column has been already added to the TF, its respective FFC will be archived and thereby removed.
request["tq_id"]: ID of the TQ, needed to select the columnf rom.
request["col_name"]: Name of the column to select/deselect from the TF.
"""
added = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "tq_id" in request.GET and ArgsChecker.is_number(request.GET["tq_id"]) \
and "col_name" in request.GET and not ArgsChecker.str_is_malicious(request.GET["col_name"]):
tq_id = request.GET["tq_id"]
col_name = request.GET["col_name"]
try:
tq = TQFile.objects.get(pk=tq_id)
col = tq.get_column(col_name)
ef = FinalFusion.objects.get(project=Project.objects.get(
pk=valid_user.last_opened_project_id))
ffc_fetch = FinalFusionColumn.objects.filter(
final_fusion=ef, source_tq=tq, source_column_name=col_name)
if len(ffc_fetch) == 0:
# FFC/Column wasn't found, meaning it hasn't been selected yet = Add to TF by creation.
FinalFusionColumn.objects.create(final_fusion=ef,
source_tq=tq,
source_column_name=col_name,
display_column_name=col_name,
rows_json=json.dumps(col))
added = True
elif len(ffc_fetch) == 1:
# FFC was found, meaning it was already selected = Remove by archiving.
if not ffc_fetch[0].archived:
ffc_fetch[0].archived = True
ffc_fetch[0].save()
added = False
else:
ffc_fetch[0].archived = False
ffc_fetch[0].save()
added = True
except ObjectDoesNotExist:
pass
return HttpResponse(json.dumps({"added": added}))
def render_dashboard(request):
"""
Will render the dashboard (currently just showing a short intro to the app) and will fetch the
user name to enter the user profile page.
"""
dic = {}
valid_user = token_checker.token_is_valid(request)
if valid_user:
if valid_user.last_opened_project_id:
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
dic["ef_name"] = ff.name
dic["username"] = valid_user.user.email
return render(request, "dashboard/dashboard.html", dic)
else:
return HttpResponseRedirect(reverse("login"))
def do_count_duplicates(request):
"""
Will return the duplicate count of the TF. See model for more info.
"""
count = 0
valid_user = token_checker.token_is_valid(request)
if valid_user:
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
try:
ff = FinalFusion.objects.get(project=proj)
count = ff.count_duplicates(valid_user)
except ObjectDoesNotExist:
pass
return HttpResponse(json.dumps({"count": count}))
def do_append_cols(request):
"""
Will append two columns of a TF into a new, dynamic one: A-Column + B-Column = AB-Column by appending
B-Rows under A-Rows. If input instructs, the source A- and B-Columns will be removed from the TF
after appending.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "a_id" in request.GET and ArgsChecker.is_number(request.GET["a_id"]) \
and "b_id" in request.GET and ArgsChecker.is_number(request.GET["b_id"]) and \
"remove_cols" in request.GET and not ArgsChecker.str_is_malicious(request.GET["remove_cols"]):
try:
a_col = FinalFusionColumn.objects.get(pk=request.GET["a_id"])
b_col = FinalFusionColumn.objects.get(pk=request.GET["b_id"])
appended_rows = json.loads(a_col.rows_json)
for r in json.loads(b_col.rows_json):
appended_rows.append(r)
FinalFusionColumn.objects.create(
final_fusion=a_col.final_fusion,
source_column_name="%s~ + %s~" % (a_col.display_column_name[:2], b_col.display_column_name[:2]),
display_column_name="%s~ + %s~" % (a_col.display_column_name[:2], b_col.display_column_name[:2]),
rows_json=json.dumps(appended_rows),
rm_dependency=None,
manually_removable=True
)
if request.GET["remove_cols"] == "true":
a_col.archived = True
a_col.save()
b_col.archived = True
b_col.save()
success = True
except ObjectDoesNotExist as oe:
pass
return HttpResponse(json.dumps({
"success": success,
}))
def do_unionize_columns(request):
"""
Will append columns similar to method 'do_append_cols()'. First it will get all FFCs of the TF and then
group all those with the same column-name into seperate lists (mapped by a dictionary). Then, it will
append the rows of each list into new, dynamic FFCs, which will carry the same name which united the
column names from the beginning of the process.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user:
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
ffc_group = {}
ffcs = FinalFusionColumn.objects.filter(final_fusion=ff, archived=False).order_by("pk")
for ffc in ffcs:
if ffc.display_column_name not in ffc_group:
ffc_group[ffc.display_column_name] = [ffc]
else:
ffc_group[ffc.display_column_name].append(ffc)
for k in ffc_group.keys():
appended_rows = []
for ffc in ffc_group[k]:
for row in json.loads(ffc.source_tq.content_json):
appended_rows.append(row[k])
ffc.archived = True
ffc.save()
FinalFusionColumn.objects.create(
final_fusion=ff,
source_tq=None,
source_column_name=k,
display_column_name=k,
rows_json=json.dumps(appended_rows),
manually_removable=True
)
success = True
return HttpResponse(json.dumps({
"success": success,
}))
def do_get_col_vars(request):
"""
Will return the shortened column vars for scripting modules to the UI. See FinalFusion-Model for more details.
"""
success = False
cv = {}
valid_user = token_checker.token_is_valid(request)
if valid_user:
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
cv = ff.get_col_vars()
success = True
return HttpResponse(json.dumps({
"success": success,
"cv": cv
}))
def render_all_rm(request):
"""
Will return a JSON-Object containing all rule modules of the currently opened project/TF.
"""
success = False
ret = []
valid_user = token_checker.token_is_valid(request)
if valid_user:
success = True
proj = Project.objects.get(pk=valid_user.last_opened_project_id)
ff = FinalFusion.objects.get(project=proj)
rule_modules = RuleModule.objects.filter(final_fusion=ff, archived=False).order_by("pk")
script_modules = ScriptModule.objects.filter(final_fusion=ff, archived=False).order_by("pk")
types_display = {
"col": "COL",
"row": "ROW",
"script": "SCR"
}
for rm in rule_modules:
ret.append({
"id": rm.pk,
"name": rm.name,
"type": rm.rule_type,
"type_display": types_display[rm.rule_type],
"is_valid": rm.is_valid()
})
for sm in script_modules:
ret.append({
"id": sm.pk,
"name": sm.name,
"type": "script",
"type_display": types_display["script"],
"is_valid": sm.check_validity()["valid"]
})
return HttpResponse(json.dumps({
"success": success,
"items": json.dumps(ret)
}))
def do_edit(request):
"""
Will edit a rule module by overriding the differences.
"""
sucess = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "code" in request.POST and "id" in request.POST and ArgsChecker.is_number(
request.POST["id"]):
try:
sm = ScriptModule.objects.get(pk=request.POST["id"],
archived=False)
sm.code_content = request.POST["code"]
sm.save()
except ObjectDoesNotExist:
pass
sucess = True
return HttpResponse(json.dumps({"success": sucess}))
def do_save_edit_row(request):
"""
Will edit a row-rm by taking the existing one and overriding the new changes.
"""
success = False
valid_user = token_checker.token_is_valid(request)
if valid_user and "id" in request.GET and ArgsChecker.is_number(request.GET["id"]) \
and "when_data" in request.GET and "then_data" in request.GET:
try:
when_data = json.loads(request.GET["when_data"])
then_data = json.loads(request.GET["then_data"])
rm = data_to_row_rm(when_data, then_data, request.GET["id"])
if rm:
success = True
except TypeError as te:
print("do_create_row_rm: TypeError")
return HttpResponse(json.dumps({"success": success}))
