298 lines
10 KiB
Python
298 lines
10 KiB
Python
from django.shortcuts import render
|
|
from django.utils import timezone
|
|
from rest_framework.views import APIView
|
|
from rest_framework import serializers
|
|
from rest_framework.response import Response
|
|
from django.db import transaction
|
|
from apps.jwt_auth.models import JwtToken as JwtTokenModel, CUserRoleLoginOpt
|
|
from apps.cuser.models import CuserRole as CuserRoleModel, RoleType as RoleTypeModel
|
|
from apps.customer.models import Customer as CustomerModel, CustomerResponsible as CustomerResponsibleModel
|
|
from rest_framework_simplejwt.tokens import RefreshToken, AccessToken, Token
|
|
from rest_framework_simplejwt.authentication import JWTAuthentication
|
|
from apps.workspace.models import Workspace as WorkspaceModel
|
|
from apps.jwt_auth.services import login_by_username, login_by_mobile, verify_mobile_and_get_token
|
|
from django.contrib.auth import get_user_model
|
|
from rest_framework import status
|
|
CUser = get_user_model()
|
|
|
|
# Create your views here.
|
|
|
|
|
|
class VerifyMobileAndGetTokenView(APIView):
|
|
|
|
class InputSerializer(serializers.Serializer):
|
|
mobile = serializers.IntegerField(required=True)
|
|
opt = serializers.IntegerField(required=True)
|
|
|
|
|
|
class OutputSerializer(serializers.ModelSerializer):
|
|
|
|
class CUserRoleSerializer(serializers.ModelSerializer):
|
|
|
|
class RoleTypeSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = RoleTypeModel
|
|
fields = ('role_name', )
|
|
|
|
role_type = RoleTypeSerializer()
|
|
|
|
class Meta:
|
|
model = CuserRoleModel
|
|
fields = ('name_family', 'title', 'role_type')
|
|
|
|
cuser_role = CUserRoleSerializer()
|
|
|
|
class Meta:
|
|
model = CUserRoleLoginOpt
|
|
fields = ('cuser_role', 'expire', 'uuid')
|
|
|
|
def post(self, request):
|
|
serializer = self.InputSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
login_opts = verify_mobile_and_get_token(**serializer.validated_data)
|
|
|
|
response_data = self.OutputSerializer(login_opts, many=True).data
|
|
|
|
return Response(response_data)
|
|
|
|
|
|
class LoginByMobileView(APIView):
|
|
|
|
class InputSerializer(serializers.Serializer):
|
|
mobile = serializers.IntegerField(required=True)
|
|
|
|
def post(self, request):
|
|
serializer = self.InputSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
login_by_mobile(**serializer.validated_data)
|
|
|
|
output = {
|
|
"result": {
|
|
"mobile": serializer.validated_data.get('mobile'),
|
|
"message": "opt code send"
|
|
}
|
|
}
|
|
|
|
return Response(output)
|
|
|
|
|
|
class LoginByUserView(APIView):
|
|
|
|
class InputSerializer(serializers.Serializer):
|
|
username = serializers.CharField(required=True)
|
|
password = serializers.CharField(required=True)
|
|
|
|
class OutputSerializer(serializers.ModelSerializer):
|
|
|
|
class CUserRoleSerializer(serializers.ModelSerializer):
|
|
|
|
class RoleTypeSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = RoleTypeModel
|
|
fields = ('role_name', )
|
|
|
|
role_type = RoleTypeSerializer()
|
|
|
|
class Meta:
|
|
model = CuserRoleModel
|
|
fields = ('name_family', 'title', 'role_type')
|
|
|
|
cuser_role = CUserRoleSerializer()
|
|
|
|
class Meta:
|
|
model = CUserRoleLoginOpt
|
|
fields = ('cuser_role', 'expire', 'uuid')
|
|
|
|
def post(self, request):
|
|
serializer = self.InputSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
username = serializer.validated_data.get('username')
|
|
password = serializer.validated_data.get('password')
|
|
|
|
login_opts = login_by_username(username=username, password=password)
|
|
|
|
response_data = self.OutputSerializer(login_opts, many=True).data
|
|
|
|
return Response(response_data)
|
|
|
|
|
|
class CustomTokenObtainPairView(APIView):
|
|
|
|
class InputSerializer(serializers.Serializer):
|
|
uuid_opt = serializers.CharField(required=True)
|
|
|
|
class OutputSerializer(serializers.Serializer):
|
|
access = serializers.CharField(required=True)
|
|
refresh = serializers.CharField(required=True)
|
|
|
|
def post(self, request):
|
|
serializer = self.InputSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
uuid_opt = serializer.validated_data.get('uuid_opt')
|
|
|
|
try:
|
|
user_login_opt = CUserRoleLoginOpt.objects.get(uuid=uuid_opt)
|
|
user = user_login_opt.cuser
|
|
cuser_role = user_login_opt.cuser_role
|
|
|
|
|
|
workspace = cuser_role.sys_ws
|
|
|
|
if user_login_opt:
|
|
refresh = RefreshToken.for_user(user)
|
|
|
|
#if 'user_id' in refresh:
|
|
# del refresh['user_id']
|
|
#print(cuser_role.uuid)
|
|
|
|
|
|
'''try:
|
|
#customerObj = CustomerModel.objects.get(cuser_role__uuid=str(cuser_role.uuid))
|
|
# workspace = customerObj.sys_ws
|
|
|
|
workspace = cuser_role.sys_ws
|
|
|
|
except:
|
|
operator = CustomerResponsibleModel.objects.get(cuser_role=cuser_role)
|
|
workspace = operator.sys_ws'''
|
|
|
|
refresh['workspace_uuid'] = str(workspace.uuid)
|
|
|
|
refresh['cuser_role_uuid'] = str(cuser_role.uuid)
|
|
|
|
refresh['user_uuid'] = str(user.uuid)
|
|
|
|
#print(str(refresh))
|
|
|
|
try:
|
|
jwt_db = JwtTokenModel(refresh=str(refresh), access=str(refresh.access_token),
|
|
cuser=user, cuser_role=cuser_role)
|
|
jwt_db.save()
|
|
|
|
try:
|
|
CUserRoleLoginOpt.objects.filter(cuser=user).delete()
|
|
except Exception as exp:
|
|
pass
|
|
|
|
except Exception as exp:
|
|
return Response({'error': str(exp)})
|
|
|
|
new_token_data = {
|
|
'refresh': str(refresh),
|
|
'access': str(refresh.access_token),
|
|
}
|
|
|
|
out_data = self.OutputSerializer(data=new_token_data)
|
|
out_data.is_valid(raise_exception=True)
|
|
|
|
return Response(out_data.data)
|
|
else:
|
|
return Response({"error": 'userpass is not True'})
|
|
except CUserRoleLoginOpt.DoesNotExist:
|
|
return Response({"error": 'Token not valid'})
|
|
except Exception as exp:
|
|
return Response({"error": 'user or pass is not true 2'})
|
|
|
|
|
|
class CustomTokenRefreshView(APIView):
|
|
|
|
class InputSerializer(serializers.Serializer):
|
|
refresh = serializers.CharField(required=True)
|
|
|
|
class OutputSerializer(serializers.Serializer):
|
|
access = serializers.CharField(required=True)
|
|
refresh = serializers.CharField(required=True)
|
|
|
|
def post(self, request):
|
|
with transaction.atomic():
|
|
try:
|
|
|
|
serializer = self.InputSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
refresh_token = serializer.validated_data.get('refresh')
|
|
|
|
print(refresh_token)
|
|
|
|
# check: token is valid?
|
|
ref_token = RefreshToken(token=refresh_token)
|
|
|
|
print("ref")
|
|
|
|
# first token must exists in whitelist and not blocked
|
|
token_exist = JwtTokenModel.objects.get(refresh=str(refresh_token))
|
|
|
|
print("exsist")
|
|
|
|
token_is_blocked = JwtTokenModel.objects.get(refresh=str(refresh_token)).is_blocked
|
|
|
|
print("yess")
|
|
|
|
if token_exist and token_is_blocked is False:
|
|
JwtTokenModel.objects.get(refresh=str(refresh_token)).delete()
|
|
else:
|
|
raise ValueError('refresh token is not in whitelist or blocked!')
|
|
|
|
user_uuid = ref_token.payload.get('user_uuid')
|
|
user_id = ref_token.payload.get('user_id')
|
|
cuser_role_uuid = ref_token.payload.get('cuser_role_uuid')
|
|
|
|
token_exp_timestamp = ref_token.payload.get('exp')
|
|
token_exp = timezone.make_aware(timezone.datetime.fromtimestamp(token_exp_timestamp), timezone.utc)
|
|
user = CUser.objects.get(id=user_id)
|
|
cuser_role = CuserRoleModel.objects.get(uuid=cuser_role_uuid)
|
|
|
|
|
|
print("OKH###")
|
|
|
|
if ref_token:
|
|
new_token = RefreshToken.for_user(user)
|
|
|
|
#if 'user_id' in new_token:
|
|
#del new_token['user_id']
|
|
|
|
new_token['user_uuid'] = str(user.uuid)
|
|
new_token['cuser_role_uuid'] = str(cuser_role.uuid)
|
|
|
|
print("OKOKKO 555")
|
|
|
|
#workspace = WorkspaceModel.objects.get(cuser_role_owner__uuid=str(cuser_role.uuid))
|
|
|
|
try:
|
|
customerObj = CustomerModel.objects.get(cuser_role__uuid=str(cuser_role.uuid))
|
|
new_token['workspace_uuid'] = str(customerObj.sys_ws.uuid)
|
|
except:
|
|
operator = CustomerResponsibleModel.objects.get(cuser_role__uuid=str(cuser_role.uuid))
|
|
new_token['workspace_uuid'] = str(operator.sys_ws.uuid)
|
|
|
|
|
|
new_access_token = new_token.access_token
|
|
|
|
new_token_data = {
|
|
'refresh': str(new_token),
|
|
'access': str(new_access_token),
|
|
}
|
|
|
|
print("OKOKKO")
|
|
|
|
new_token_obj = JwtTokenModel(refresh=str(new_token),
|
|
access=str(new_token_data.get('access')),
|
|
expire=token_exp,
|
|
cuser=user,
|
|
cuser_role=cuser_role
|
|
)
|
|
|
|
print("OKOKKO 222")
|
|
new_token_obj.save()
|
|
out_data = self.OutputSerializer(data=new_token_data)
|
|
out_data.is_valid(raise_exception=True)
|
|
return Response(out_data.data)
|
|
|
|
except Exception as e:
|
|
transaction.set_rollback(True)
|
|
return Response({"error": str(e)})
|