def get_urllist_report_graph_data_(request,
urllist_ids,
report_type: str = "web") -> JsonResponse:
return JsonResponse(get_urllist_timeline_graph(get_account(request),
urllist_ids, report_type),
encoder=JSEncoder,
safe=False)
def remove_tag_(request):
data = get_json_body(request)
remove_tag(account=get_account(request),
urllist_id=data.get('urllist_id', []),
url_ids=data.get('url_ids', []),
tag=data.get('tag', ""))
return JsonResponse(operation_response(success=True), safe=False)
def delete_url_from_urllist_(request):
account = get_account(request)
request = get_json_body(request)
items_deleted, item_details = delete_url_from_urllist(
account, request.get('list_id'), request.get('url_id'))
return JsonResponse({
'items_deleted': items_deleted,
'success': items_deleted
})
def get_accounts(request) -> HttpResponse:
myaccount = get_account(request)
scans = AccountInternetNLScan.objects.all().filter(
account=myaccount.id).count()
lists = UrlList.objects.all().filter(account=myaccount.id).count()
users = list(User.objects.all().filter(
dashboarduser__account=myaccount.id).values_list('username',
flat=True))
current_account = {
'id':
myaccount.id,
'name':
myaccount.name,
'scans':
scans,
'lists':
lists,
'users':
users,
'label':
f"{myaccount.id}: {myaccount.name} (Lists: {lists}, Scans: {scans}, Users: {len(users)})"
}
accounts = Account.objects.all().values_list('id', 'name').order_by('id')
account_data = []
# add some metadata to the accounts, so it's more clear where you are switching to:
for account in accounts:
scans = AccountInternetNLScan.objects.all().filter(
account=account[0]).count()
lists = UrlList.objects.all().filter(account=account[0]).count()
users = list(User.objects.all().filter(
dashboarduser__account=account[0]).values_list('username',
flat=True))
account_information = {
'id':
account[0],
'name':
account[1],
'scans':
scans,
'lists':
lists,
'users':
users,
'label':
f"{account[0]}: {account[1]} (Lists: {lists}, Scans: {scans}, Users: {len(users)})"
}
account_data.append(account_information)
return JsonResponse({
'current_account': current_account,
'accounts': account_data
})
def save_ad_hoc_tagged_report_(request, report_id: int):
data = get_json_body(request)
tags = data.get('tags', [])
try:
at_when: Optional[datetime] = datetime.fromisoformat(
f"{data.get('custom_date')} {data.get('custom_time')}")
except ValueError:
at_when = None
return JsonResponse(
save_ad_hoc_tagged_report(get_account(request), report_id, tags,
at_when))
def get_ad_hoc_tagged_report_(request, report_id: int):
data = get_json_body(request)
tags = data.get('tags', [])
try:
at_when: Optional[datetime] = datetime.fromisoformat(
f"{data.get('custom_date')} {data.get('custom_time')}")
except ValueError:
at_when = None
return HttpResponse( # pylint: disable=http-response-with-content-type-json
ad_hoc_tagged_report(get_account(request), report_id, tags, at_when),
content_type="application/json")
def get_accounts(request) -> HttpResponse:
account = get_account(request)
accounts = Account.objects.all().values_list('id', 'name')
account_data = []
# add some metadata to the accounts, so it's more clear where you are switching to:
for account in accounts:
account_information = {'id': account[0], 'name': account[1]}
account_information['scans'] = AccountInternetNLScan.objects.all().filter(
account=account_information['id']).count()
account_information['lists'] = UrlList.objects.all().filter(account=account_information['id']).count()
account_information['users'] = list(User.objects.all().filter(
dashboarduser__account=account_information['id']).values_list('username', flat=True))
account_data.append(account_information)
return JsonResponse({'current_account': account, 'accounts': account_data})
def powertools(request) -> HttpResponse:
# only for the true superusers :)
if not request.user.is_staff and request.user.is_active and request.user.is_superuser:
return report.dashboard(request)
# account switching.=
if request.POST.get('change_account', None):
dashboard_user = DashboardUser.objects.all().filter(
user=request.user).first()
# very new users don't have the dashboarduser fields filled in, and are thus not connected to an account.
if not dashboard_user:
dashboard_user = DashboardUser(
**{
'account': Account.objects.all().first(),
'user': request.user
})
dashboard_user.account = Account.objects.get(
id=request.POST.get('change_account'))
dashboard_user.save()
selected_account_id: int = 0
account = get_account(request)
if account:
selected_account_id = account.pk
# end account switching
# Fast account creation. Of the most basic kind.
state, add_account_and_user_form = default_form_logic(
InstantAccountAddForm, request)
response = render(
request,
'internet_nl_dashboard/templates/internet_nl_dashboard/powertools.html',
{
'add_account_and_user_form': add_account_and_user_form,
'add_account_and_user_form_state': state,
'menu_item_powertools': "current",
'selected_account': selected_account_id,
'accounts': list(Account.objects.all().values('id', 'name')),
})
return inject_default_language_cookie(request, response)
def tags_in_urllist_(request, urllist_id):
return JsonResponse(tags_in_urllist(account=get_account(request),
urllist_id=urllist_id),
safe=False)
def get_previous_report_(request, urllist_id, at_when):
return JsonResponse(get_previous_report(get_account(request), urllist_id, at_when), encoder=JSEncoder, safe=False)
def get_report_(request, report_id) -> HttpResponse:
return HttpResponse(get_report(get_account(request), report_id), content_type="application/json")
def get_report_(request, report_id) -> JsonResponse:
return JsonResponse(get_report(get_account(request), report_id), encoder=JSEncoder, safe=False)
def cancel_scan_(request):
account = get_account(request)
request = get_json_body(request)
response = cancel_scan(account, request.get('id'))
return JsonResponse(response)
def get_scan_status_of_list_(request, urllist_id: int) -> JsonResponse:
return JsonResponse(get_scan_status_of_list(account=get_account(request),
list_id=urllist_id),
encoder=JSEncoder)
def running_scans(request) -> JsonResponse:
account = get_account(request)
# list of dicts: In order to allow non-dict objects to be serialized set the safe parameter to False.
return JsonResponse(get_scan_monitor_data(account), encoder=JSEncoder, safe=False)
def alter_url_in_urllist_(request):
return JsonResponse(
alter_url_in_urllist(get_account(request), get_json_body(request)))
def add_urls_to_urllist(request):
return JsonResponse(
save_urllist_content(get_account(request), get_json_body(request)))
def save_report_settings_(request) -> JsonResponse:
return JsonResponse(save_report_settings(get_account(request), get_json_body(request)))
def scan_now_(request):
return JsonResponse(scan_now(get_account(request), get_json_body(request)))
def get_report_settings_(request) -> JsonResponse:
return JsonResponse(get_report_settings(get_account(request)))
def get_urllist_report_graph_data_(request, urllist_id) -> JsonResponse:
return JsonResponse(get_urllist_report_graph_data(get_account(request), urllist_id), encoder=JSEncoder, safe=False)
def get_lists(request) -> JsonResponse:
return JsonResponse(
get_urllists_from_account(account=get_account(request)),
encoder=JSEncoder,
safe=False)
def get_report_differences_compared_to_current_list_(request, report_id):
return JsonResponse(get_report_differences_compared_to_current_list(get_account(request), report_id),
encoder=JSEncoder, safe=True)
def get_urllist_content_(request, urllist_id: int) -> JsonResponse:
return JsonResponse(get_urllist_content(account=get_account(request),
urllist_id=urllist_id),
encoder=JSEncoder)
def get_recent_reports_(request) -> JsonResponse:
return JsonResponse(get_recent_reports(get_account(request)), encoder=JSEncoder, safe=False)
def save_list_content(request, urllist_name: str,
urls: List[str]) -> JsonResponse:
return JsonResponse(save_urllist_content_by_name(get_account(request),
urllist_name, urls),
encoder=JSEncoder)
def update_list_settings_(request):
return JsonResponse(
update_list_settings(get_account(request), get_json_body(request)))
def delete_list_(request):
return JsonResponse(
delete_list(get_account(request), get_json_body(request)))
def subdomain_discovery_scan_status_(request, urllist_id) -> JsonResponse:
return JsonResponse(scan_status(get_account(request), urllist_id),
encoder=JSEncoder,
safe=False)
def get_report_(request, report_id) -> HttpResponse:
# Explicitly NOT use jsonresponse as this loads the json data into an encoder which is extremely slow on large files
return HttpResponse( # pylint: disable=http-response-with-content-type-json
get_report(get_account(request), report_id),
content_type="application/json")
