574 lines
16 KiB
Python
574 lines
16 KiB
Python
from django.shortcuts import render
|
|
from django.http import HttpResponse,JsonResponse
|
|
from django.contrib.auth import authenticate
|
|
# from django.core import serializer
|
|
from rest_framework import viewsets
|
|
from rest_framework.decorators import api_view, permission_classes
|
|
from rest_framework.views import APIView
|
|
from rest_framework.authentication import SessionAuthentication, BasicAuthentication
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.response import Response
|
|
from rest_framework.authtoken.models import Token
|
|
from rest_framework.permissions import IsAdminUser
|
|
from .serializers import wgSerializer
|
|
from .models import user_model
|
|
from .utils.html_parser import get_logs, get_profiles
|
|
import json
|
|
from .utils.statistics import count_clients, count_traffic, count_connection, count_percentage, count_broken
|
|
from .utils.reqs_handler import req_edit_state, req_edit_user, req_apply_sys, req_ip_recommendation, reg_bulk, req_del_user, req_get_client
|
|
from django.middleware.csrf import get_token
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
|
|
class wgLogin(APIView):
|
|
authentication_classes = [SessionAuthentication, BasicAuthentication]
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def get(self, request, format=None):
|
|
|
|
# serializer = self.get_serializer(data=request.data)
|
|
# serializer.is_valid(raise_exception=True) user = serializer.validated_data['user']
|
|
user = request.GET.get('username')
|
|
password = request.GET.get('password')
|
|
|
|
content = {
|
|
'user': str(request.user), # `django.contrib.auth.User` instance.
|
|
'auth': str(request.auth), # None
|
|
}
|
|
|
|
# user = content['user']
|
|
print(request.META['HTTP_AUTHORIZATION'])
|
|
|
|
print(user)
|
|
print(password)
|
|
|
|
user = authenticate(username=user, password=password)
|
|
|
|
print("****-> ",user.id)
|
|
|
|
token, _ = Token.objects.get_or_create(user=user)
|
|
|
|
response = Response(content)
|
|
|
|
response.set_cookie('Token', token.key)
|
|
|
|
# print(response)
|
|
|
|
return response
|
|
# return response
|
|
|
|
# return Response(content)
|
|
|
|
# Create your views here.
|
|
class wgView(viewsets.ModelViewSet):
|
|
|
|
# queryset = user_model.objects.all()
|
|
queryset = user_model.objects.all()
|
|
serializer_class = wgSerializer
|
|
|
|
# print(">"*100," ",inf_data)
|
|
|
|
def get(self, request):
|
|
return self.inf_connector()
|
|
# iserializer = wgSerializer
|
|
# queryset = user_model.objects.all()
|
|
# serializers_class = wgSerializer
|
|
# serializer = wgSerializer
|
|
# permission_classes = [IsAdminUser]
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
@permission_classes([IsAuthenticated])
|
|
def wgCheckAuth(request):
|
|
|
|
return HttpResponse(json.dumps({"Auth":True}))
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
# @permission_classes([IsAuthenticated])
|
|
def wgViewLogs(request):
|
|
|
|
param = request.GET.get('param', '')
|
|
|
|
data = get_logs()
|
|
# data = json.loads(data)
|
|
|
|
final_data = []
|
|
|
|
|
|
if param == "d2201":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "DTS22_PNUP_01" in str(x["wgName"]):
|
|
print(x)
|
|
x["data_id"]=i
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "d2202":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "DTS22_PNUP_02" in str(x["wgName"]):
|
|
print(x)
|
|
x["data_id"]=i
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "d2203":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "DTS22_PNUP_03" in str(x["wgName"]):
|
|
print(x)
|
|
x["data_id"]=i
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "d2204":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "DTS22_PNUP_04" in str(x["wgName"]):
|
|
print(x)
|
|
x["data_id"]=i
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "d2205":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "DTS22_PNUP_05" in str(x["wgName"]):
|
|
print(x)
|
|
x["data_id"]=i
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "d2206":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "DTS22_TELU" in str(x["wgName"]):
|
|
print(x)
|
|
x["data_id"]=i
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "GCI":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "GCI" in str(x["wgName"]):
|
|
x["data_id"]=i
|
|
print(x)
|
|
final_data.append(x)
|
|
i = i+1
|
|
elif param == "META":
|
|
print("x"*100)
|
|
i = 1
|
|
for x in data:
|
|
if "NIS" in str(x["wgName"]):
|
|
print(x["data_id"])
|
|
x["data_id"]=i
|
|
print(x["data_id"])
|
|
final_data.append(x)
|
|
i = i+1
|
|
else:
|
|
final_data = data
|
|
|
|
final_data = json.dumps(final_data)
|
|
|
|
return HttpResponse(final_data, content_type='application')
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
# @permission_classes([IsAuthenticated])
|
|
def wgViewClients(request):
|
|
|
|
param = request.GET.get('param', '')
|
|
filter = request.GET.get('filter', '')
|
|
|
|
data = get_profiles()
|
|
# data = json.loads(data)
|
|
|
|
|
|
final_data = []
|
|
|
|
# if request.user.is_authenticated:
|
|
if filter :
|
|
filter = str(filter).split(" ")
|
|
for x in filter:
|
|
print("-> ",x)
|
|
final_data = data
|
|
if not (filter[0] == "" and filter[1] == "undefined" and filter[2] == "undefined" and filter[3] == "undefined"):
|
|
if filter[0] != "":
|
|
f_name = filter[0]
|
|
i = 0
|
|
tmp_data = []
|
|
for x in final_data:
|
|
if str(f_name).lower() in str(x["name"]).lower():
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
final_data = tmp_data
|
|
|
|
if filter[1] != "undefined":
|
|
f_orgs = filter[1]
|
|
i = 0
|
|
tmp_data = []
|
|
for x in final_data:
|
|
if str(f_orgs).lower() in str(x["name"]).lower():
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
final_data = tmp_data
|
|
|
|
if filter[2] != "undefined":
|
|
i = 0
|
|
f_email = filter[2]
|
|
tmp_data = []
|
|
|
|
if f_email == "" :
|
|
print("Empty mails...")
|
|
for x in final_data:
|
|
if str(x["email"]).lower() == "":
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
else:
|
|
for x in final_data:
|
|
if str(f_email).lower() in str(x["email"]).lower():
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
|
|
final_data = tmp_data
|
|
|
|
if filter[3] != "undefined":
|
|
i = 0
|
|
f_state = filter[3]
|
|
tmp_data = []
|
|
|
|
if f_state == "" :
|
|
print("Empty State...")
|
|
for x in final_data:
|
|
if str(x["enabled"]).lower() == "":
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
else:
|
|
for x in final_data:
|
|
if str(f_state).lower() in str(x["enabled"]).lower():
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
|
|
final_data = tmp_data
|
|
|
|
else:
|
|
final_data = data
|
|
|
|
print(final_data)
|
|
final_data = json.loads(final_data)
|
|
final_data = sorted(final_data, key=lambda x: (-x["enabled"], x["name"]))
|
|
final_data = json.dumps(final_data)
|
|
|
|
elif len(param)>0:
|
|
|
|
if param == "email":
|
|
groups = []
|
|
for x in data:
|
|
if str("@").lower() in str(x["email"]).lower():
|
|
tmp_val = x["email"]
|
|
tmp_val = str(tmp_val).split("@")[1]
|
|
tmp_val = tmp_val.lower()
|
|
|
|
if tmp_val not in groups:
|
|
groups.append(tmp_val)
|
|
|
|
# if {"email": tmp_val} not in groups:
|
|
# # print("-> ",tmp_val)
|
|
# groups.append({"email": tmp_val})
|
|
|
|
final_data = json.dumps({"email":groups})
|
|
|
|
if param == "orgs":
|
|
groups = []
|
|
for x in data:
|
|
if str("-").lower() in str(x["name"]).lower():
|
|
tmp_val = x["name"]
|
|
tmp_val = str(tmp_val).split("-")[0]
|
|
tmp_val = tmp_val.upper()
|
|
|
|
if tmp_val not in groups:
|
|
groups.append(tmp_val)
|
|
|
|
# if {"orgs": tmp_val} not in groups:
|
|
# # print("-> ",tmp_val)
|
|
# groups.append({"orgs": tmp_val})
|
|
|
|
final_data = json.dumps({"orgs": groups})
|
|
|
|
if param == "stats":
|
|
data_logs = get_logs()
|
|
data = json.loads(data_logs)
|
|
|
|
sum_data = count_clients(data)
|
|
connected_data = count_connection(data)
|
|
traffic_data = len(data)
|
|
|
|
percentage_data = count_percentage(data)
|
|
broken_data = count_broken(data)
|
|
|
|
traffic_data = count_traffic(data)
|
|
if traffic_data > 1000000000:
|
|
traffic_data="{:.2f}".format(traffic_data/1000000000)+" GB"
|
|
else:
|
|
traffic_data="{:.2f}".format(traffic_data/1000000)+" MB"
|
|
|
|
data = {}
|
|
|
|
data["clienttotal"]=sum_data
|
|
data["traffictotal"]=traffic_data
|
|
data["connectedtotal"]=connected_data
|
|
data["percentagetotal"]=percentage_data
|
|
data["brokentotal"]=broken_data
|
|
|
|
final_data = json.dumps(data)
|
|
|
|
else :
|
|
final_data = json.dumps(data)
|
|
|
|
# else:
|
|
# final_data = {"Not Logged In"}
|
|
# print(request.GET.get('param', ''))
|
|
|
|
# final_data = [final_data]
|
|
return HttpResponse(final_data, content_type='json')
|
|
# return JsonResponse({final_data})
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
@permission_classes([IsAuthenticated])
|
|
def get_ApplyConfig(request):
|
|
|
|
# id = request.GET.get('id', '')
|
|
# state = request.GET.get('state', '')
|
|
# print("Edit Request...")
|
|
|
|
req_response = req_apply_sys()
|
|
|
|
return HttpResponse(req_response)
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET", "POST"])
|
|
@permission_classes([IsAuthenticated])
|
|
def get_EditState(request):
|
|
|
|
id = request.GET.get('id', '')
|
|
state = request.GET.get('state', '')
|
|
print("Edit Request...")
|
|
|
|
if state and id:
|
|
if id != "bulk":
|
|
print("[ Edit ]=======")
|
|
print(id)
|
|
print(state)
|
|
|
|
req_edit_state(id, state)
|
|
else:
|
|
print("[ Bulk handler ]=======")
|
|
print(request.body)
|
|
|
|
target_ids = request.body
|
|
|
|
for x in json.loads(target_ids):
|
|
req_edit_state(str(x), state)
|
|
print(x)
|
|
|
|
final_data = json.dumps({"state":"Success"})
|
|
|
|
return HttpResponse(final_data, content_type='application')
|
|
|
|
# def get_Cookie(request):
|
|
#
|
|
# return get_token()
|
|
|
|
# @csrf_exempt
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
@permission_classes([IsAuthenticated])
|
|
def get_EditClient(request):
|
|
|
|
my_token = get_token()
|
|
|
|
print("TOKEN ...")
|
|
print(my_token)
|
|
|
|
id = request.GET.get('id', '')
|
|
|
|
if request.method == "POST":
|
|
print(request)
|
|
|
|
if id:
|
|
print(id)
|
|
ret_val = req_edit_user(id)
|
|
|
|
|
|
else:
|
|
ret_val = {"data": "Failed"}
|
|
|
|
# ret_val = json.dumps(ret_val)
|
|
|
|
ret_val = ret_val["Client"]
|
|
|
|
ret_val = json.dumps(ret_val)
|
|
|
|
|
|
return HttpResponse(ret_val, content_type='application')
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
@permission_classes([IsAuthenticated])
|
|
def get_user_param_recommendation(request):
|
|
|
|
ret_val = req_ip_recommendation()
|
|
|
|
return HttpResponse(ret_val, content_type='application')
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
# @permission_classes([IsAuthenticated])
|
|
|
|
def wgFilterClients(request):
|
|
|
|
param = request.GET.get('param', '')
|
|
filter = request.GET.get('filter', '')
|
|
name = request.GET.get('names', '')
|
|
orgs = request.GET.get('orgs', '')
|
|
emails = request.GET.get('emails', '')
|
|
state = request.GET.get('state', '')
|
|
|
|
print("param ",param)
|
|
print("filter ",filter)
|
|
print("name ",name)
|
|
print("orgs ",orgs)
|
|
print("emails ",emails)
|
|
print("state ",state)
|
|
|
|
data = get_profiles()
|
|
data = json.loads(data)
|
|
|
|
final_data = []
|
|
|
|
if orgs:
|
|
orgs = str(orgs).split(", ")
|
|
tmp_data = []
|
|
for x in orgs:
|
|
print(x)
|
|
f_orgs = x
|
|
i = 0
|
|
for x in data:
|
|
if str(f_orgs).lower() in str(x["name"]).lower():
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
|
|
print(tmp_data)
|
|
|
|
if len(final_data) < 1:
|
|
final_data = tmp_data
|
|
else:
|
|
for x in tmp_data:
|
|
final_data.append(x)
|
|
|
|
if emails:
|
|
emails = str(emails).split(", ")
|
|
tmp_data = []
|
|
for x in emails:
|
|
print(x)
|
|
f_emails = x
|
|
i = 0
|
|
for x in data:
|
|
if str(f_emails).lower() in str(x["email"]).lower():
|
|
x["data_id"]=i
|
|
tmp_data.append(x)
|
|
i = i+1
|
|
|
|
if len(final_data) < 1:
|
|
final_data = tmp_data
|
|
else:
|
|
for x in tmp_data:
|
|
final_data.append(x)
|
|
|
|
if not (orgs or filter or name or emails):
|
|
final_data = data
|
|
|
|
# SANITY Starts here -------------------------------
|
|
|
|
no_duplicate = []
|
|
for x in final_data:
|
|
if x not in no_duplicate:
|
|
no_duplicate.append(x)
|
|
|
|
ret_val = json.dumps(no_duplicate)
|
|
|
|
return HttpResponse(ret_val, content_type='application')
|
|
|
|
@csrf_exempt
|
|
@api_view(["POST"])
|
|
#@permission_classes([IsAuthenticated])
|
|
def wgBulkReg(request):
|
|
|
|
if request.method == "POST":
|
|
print(request)
|
|
print("-> Bulk Registration")
|
|
|
|
print(request.body)
|
|
print("-"*20)
|
|
|
|
RegData = request.body.decode('utf-8')
|
|
|
|
RegData = json.loads(RegData)
|
|
print(RegData)
|
|
|
|
#req_ip = req_ip_recommendation()
|
|
#print(req_ip)
|
|
req_commit = reg_bulk(RegData)
|
|
|
|
return HttpResponse(json.dumps({"Reg":"Success"}), content_type='application')
|
|
|
|
|
|
@csrf_exempt
|
|
@api_view(["POST"])
|
|
#@permission_classes([IsAuthenticated])
|
|
def wg_DelClient(request):
|
|
|
|
if request.method == "POST":
|
|
print(request)
|
|
print("-> Bulk Registration")
|
|
|
|
print(request.body)
|
|
print("-"*20)
|
|
|
|
RegData = request.body.decode('utf-8')
|
|
RegData = json.loads(RegData)
|
|
|
|
req_commit = req_del_user(RegData)
|
|
|
|
return HttpResponse(json.dumps({"Reg":"Success"}), content_type='application')
|
|
|
|
@csrf_exempt
|
|
@api_view(["GET"])
|
|
#@permission_classes([IsAuthenticated])
|
|
def wg_GetClient(request):
|
|
if request.method == "GET":
|
|
print(request)
|
|
print("-> Bulk Registration")
|
|
|
|
print(request.body)
|
|
print("-"*20)
|
|
|
|
#id = request.body.decode('utf-8')
|
|
id = request.GET.get("id")
|
|
#id = json.loads(id)
|
|
|
|
req_commit = req_get_client(id)
|
|
|
|
return HttpResponse(json.dumps(req_commit['Client']), content_type='application')
|