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, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
data = {
"email": serializer.data["email"],
"first_name": serializer.data["first_name"],
"last_name": serializer.data["last_name"]
} # Some unique field for reference
secret_key = "GAMEAPPISFUNNY"
algorithm = "HS256" # You can use MD5 or whatever you want
token_code_data = jwt.encode(data, secret_key, algorithm)
url = 'http://192.168.0.103:8080/user_register/confirm/' + token_code_data.decode(
'utf-8')
# # user = serializer.save()
# if user:
# # token = Token.objects.create(user=user)
# # json = serializer.data
# # json['token'] = token.key
# return Response("User Registration Completed but Pending for Verification", status=status.HTTP_201_CREATED)
try:
send_mail('Verificaion link for Game App', url,
'*****@*****.**',
[serializer.data["email"]])
except:
return Response(
"Please try again later after some time/Report here @ [email protected]",
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(
"User Registration Completed but Pending for Verification",
status=status.HTTP_200_OK)
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, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
print(serializer.errors)
return Response({})
def test_serializer_success_by_payload(self):
serializer = UserSerializer(data=self.payload)
serializer.is_valid(raise_exception=True)
data = serializer.data
self.assertEqual(data["email"], "*****@*****.**")
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 check_account(self, request):
"""
检查用户信息
:param request:
:return:
"""
params = request.data
encryptedData = params.get('encryptedData')
iv = params.get('iv')
if not (iv, encryptedData):
raise serializers.ValidationError('encryptedData、iv参数不能为空')
user_info = User.objects.filter(open_id=params.get('user_id')).first()
data = UserSerializer(user_info)
if not data.data:
logger.info('无法通过用户open_id获取用户记录: user_id=%s' % params.get('user_id'))
raise serializers.ValidationError('无法通过用户open_id获取用户记录: user_id=%s' % params.get('user_id'))
# 用户每日登陆获取new币
NewCornCompute.compute_new_corn(user_info.open_id, NewCornType.DAILY_LOGIN.value)
# 录入用户信息到数据库，同时也要注意微信用户可能会更换信息
if user_info.nick_name != params.get('nick_name') or user_info.avatar_url != params.get('avatar_url'):
logger.info('check_account更新用户信息: user_id=%s' % params.get('user_id'))
user_info.nick_name = params.get('nick_name')
user_info.gender = params.get('gender')
user_info.province = params.get('province')
user_info.country = params.get('country')
user_info.city = params.get('city')
user_info.avatar_url = params.get('avatar_url')
user_info.language = params.get('language')
user_info.save()
temp = UserSerializer(user_info).data
logger.info('Update User from Redis')
logger.info(temp)
redis_client.set_instance(user_info.open_id, temp)
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 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 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):
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 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, 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 create_account(request):
print('Check here', request.user, request.data)
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
User.objects.create_user(username=serialized.initial_data['username'],
email=serialized.initial_data['email'],
password=serialized.initial_data['password'])
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def test_serializer_with_repeated_email(self):
self.payload["email"] = "*****@*****.**"
serializer = UserSerializer(data=self.payload)
with self.assertRaises(ValidationError) as exc:
serializer.is_valid(raise_exception=True)
self.assertIn("email", exc.exception.detail)
self.assertNotIn("password", exc.exception.detail)
self.assertNotIn("password_confirm", exc.exception.detail)
def register(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serialized = UserSerializer(data=data)
if serialized.is_valid():
UserSerializer.create(serialized, data)
return JsonResponse(serialized.data,
status=status.HTTP_201_CREATED)
else:
return JsonResponse(serialized._errors,
status=status.HTTP_400_BAD_REQUEST)
def test_serializer_with_empty_payload(self):
empty_payload = {}
serializer = UserSerializer(data=empty_payload)
with self.assertRaises(ValidationError) as exc:
serializer.is_valid(raise_exception=True)
self.assertIn("email", exc.exception.detail)
self.assertIn("password", exc.exception.detail)
self.assertIn("password_confirm", exc.exception.detail)
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 get(self, request, pk=None, *args, **kwargs):
if not pk:
users = User.objects()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
try:
user = User.objects.get(pk=pk)
except:
return Response({}, status=status.HTTP_204_NO_CONTENT)
else:
serializer = UserSerializer(user)
return Response(serializer.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 create(self, request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
User.objects.create_user(
username=serialized.initial_data.get('username'),
email=serialized.initial_data.get('email'),
password=serialized.initial_data.get('password'),
first_name=serialized.initial_data.get('firstName', ''),
last_name=serialized.initial_data.get('lastName', ''))
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors,
status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data):
author_data = validated_data.pop('author')
author = UserSerializer.create(UserSerializer(),
validated_data=author_data)
ingredient, created = Ingredient.objects.update_or_create(
name=validated_data.pop('name'),
img=validated_data.pop('img'),
quantity=validated_data.pop('quantity'),
unit=validated_data.pop('unit'),
cost=validated_data.pop('cost'),
author=author,
)
return ingredient
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 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 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 post(self, request):
body = json.loads(request.body)
serializer_user = UserSerializer(data=request.data)
username = body['username']
email = body['email']
password = body['password']
if serializer_user.is_valid(): # Cria o User
user = User.objects.create_user(username, email, password)
return Response(data={"User created."}, status=200)
else:
return Response(data={"Invalid user or already created."},
status=400)
class AttendanceSerializer(serializers.ModelSerializer):
# session_id = SabhaSessionSerializer(read_only=True)
user = UserSerializer(read_only=True, fields=('username', ))
last_modified_by = UserSerializer(read_only=True, fields=('username', ))
# To change the key name in response
session_info = GetSabhaSessionSerializer(read_only=True,
source='session_id',
fields=('id', 'sabhatype'))
class Meta:
model = Attendance
fields = ('status', 'user', 'last_modified_by', 'session_info',
'leave_reason')
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 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 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)
