def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
print(serializer.errors)
return Response({})
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
print(serializer.errors)
return Response({})
def patch(self, request, id):
user = User.objects.get(id=id)
serializer = UserSerializer(instance=user, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
user = request.user
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
""" Create a User """
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
user_data = UserSerializer(data=request.data)
if not user_data.is_valid():
return Response({'message': 'Invalid data'}, status=400)
user_data.save()
return Response(user_data.data)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
# if serializer.user is not None:
# token = Token.objects.create(user=serializer.user)
# send_mail('helo lall', f'{token.key}', '*****@*****.**', [serializer.user.email], fail_silently=False)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({"message": "Registration successful"},
status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request):
user = User.objects.get(id=request.user.id)
user_data = UserSerializer(instance=user, data=request.data)
if not user_data.is_valid():
return Response({'message': 'Invalid data'}, status=400)
user_data.save()
return Response(user_data.data)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
try:
serializer.save()
return Response({'message': 'Registration successful'}, 201)
except IntegrityError as e:
return Response({'error': e.message}, 400)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
try:
serializer.save()
return Response({'message': 'Registration successful'}, 201)
except IntegrityError as e:
return Response({'error': e.message}, 400)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.user_dict = {
'first_name': 'aamish',
'last_name': 'baloch',
'email': '*****@*****.**',
'username': '******',
'password': '******',
}
serializer = UserSerializer(data=self.user_dict)
if serializer.is_valid():
serializer.save()
def patch(self, request):
serialized_user = UserSerializer(request.user,
data=request.data,
partial=True,
context={'request': request})
if serialized_user.is_valid():
serialized_user.save()
return response.Response(serialized_user.data,
status=status.HTTP_200_OK)
return response.Response(serialized_user.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_invalid_credentials(self):
"""
Ensure we can't login with invalid credentials.
"""
serializer = UserSerializer(data=self.user_dict)
if serializer.is_valid():
serializer.save()
url = reverse('login')
data = {
"username": self.user_dict['username'],
"password": '******',
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response.ok(
data = serializer.data,
status = status.HTTP_200_OK,
message= "Registrasi berhasil"
)
return Response.badRequest(
data=serializer.errors,
status=status.HTTP_400_BAD_REQUEST,
message= "Registrasi gagal"
)
def post(self, request, sub):
if request.user.sub != int(sub):
raise PermissionDenied()
serializer = UserSerializer(
data=request.data,
partial=True
)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors)
def test_login_user(self):
"""
Ensure we can login with a valid user.
"""
serializer = UserSerializer(data=self.user_dict)
if serializer.is_valid():
serializer.save()
url = reverse('login')
data = {
"username": self.user_dict['username'],
"password": self.user_dict['password'],
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
register_step = request.data.pop('register_step', None)
if register_step == 0:
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
request.session['USER'] = request.data
return Response({})
else:
return Response(serializer.errors, status=400)
elif register_step == 1:
otp_code = request.data.pop('otp_code', None)
user_serializer = UserSerializer(data=request.session.get('USER'))
key = request.session.get('OTP_KEY', 0)
if pyotp.TOTP(key).verify(otp_code) and user_serializer.is_valid():
user = user_serializer.save()
SecretKey.objects.create(user=user, key=key)
request.session.flush()
login(request,
user,
backend='django.contrib.auth.backends.ModelBackend')
return Response(UserSerializer(user).data)
else:
return Response({'error': 'OTP doesn\'t match'}, status=400)
else:
return Response(
{'error': 'Unknown register_step %s' % register_step},
status=400)
def post(self, request):
data = request.data
user = User.objects.filter(username=data['email'])
if user:
return {'success': 0, 'error': 'user already exist', 'status': status.HTTP_409_CONFLICT}
user_ser = UserSerializer(data=data)
if user_ser.is_valid():
user = user_ser.save()
data = {
'activation_code': generate_activation_token(),
'user': user.id
}
# saving activation code to Activation Model through UserActivationSerializer
user_activation_ser = UserActivationSerializer(data=data)
if user_activation_ser.is_valid(raise_exception=True):
token = user_activation_ser.save()
send_user_mail(
template="activation.html",
first_name=user.first_name,
last_name=user.last_name,
subject="Activate Account",
activation_url="http://localhost:8000?activate="+token.activation_code,
user=user
)
return {'success': 1, 'status': status.HTTP_201_CREATED}
def user_profile(request):
try:
user = request.user
except User.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = UserSerializer(user)
return JsonResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = UserSerializer(user, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
def create(self, request, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
return Response({"id": str(user.id)}, status=status.HTTP_201_CREATED, content_type="application/json")
return Response({
'status': 'Bad request',
'message': 'Account could not be created with received data.'
}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
userSerializer = UserSerializer(data=request.data)
if userSerializer.is_valid():
user = userSerializer.save()
if user:
return Response(userSerializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, *args, **kwargs):
user = self.get_object()
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
user = serializer.save()
update_session_auth_hash(request, user)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response({
'status': 'Failed',
'message': 'Update failed with submitted data'
}, status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, sub):
manager = request.user
if not manager.is_staff:
if request.user.sub != int(sub) or "is_staff" in request.data:
raise PermissionDenied
elif "is_staff" in request.data and request.data["is_staff"]:
raise PermissionDenied
else:
try:
user = User.objects.get(sub=sub)
except User.DoesNotExist:
raise NotFound
serializer = UserSerializer(
user,
data=request.data,
partial=True
)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(serializer.data)
else:
try:
user = User.objects.get(sub=sub)
except User.DoesNotExist:
raise NotFound
serializer = UserSerializer(
user,
data=request.data,
partial=True
)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors)
def update(self, request, *args, **kwargs):
"""
update a specific user
:param request:
:param args:
:param kwargs:
:return:
"""
data = request.DATA
first_name = data.pop('firstName', None)
last_name = data.pop('lastName', None)
email = data.pop('email', None)
password = data.pop('password', None)
update_data = {}
if first_name is not None:
update_data['first_name'] = first_name
if last_name is not None:
update_data['last_name'] = last_name
if email is not None:
update_data['email'] = email
if password is not None:
encrypted_password = make_password(password)
update_data['password'] = encrypted_password
user = User.objects.get(pk=request.user.id)
user_serializer = UserSerializer(instance=user, partial=True,
data=update_data)
if user_serializer.is_valid():
user_serializer.save()
return Response(user_serializer.data)
def setUp(self):
user_dict = {
'first_name': 'aamish',
'last_name': 'baloch',
'email': '*****@*****.**',
'username': '******',
'password': '******',
}
serializer = UserSerializer(data=user_dict)
if serializer.is_valid():
self.user = serializer.save()
url = reverse('login')
data = {
"username": user_dict['username'],
"password": user_dict['password'],
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.token = response.data['token']
def post(self, request):
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user_serializer.save()
return Response(user_serializer.data, status = status.HTTP_201_CREATED)
return Response(serializers.error, status = status.HTTP_400_BAD_REQUEST)
