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}))