def create(self, request):
serializer = UserSerializer(
data={
"username": request.data.get("username"),
"password": request.data.get("password"),
"first_name": request.data.get("firstName"),
"last_name": request.data.get("lastName"),
"email": request.data.get("email"),
})
serializer.is_valid(raise_exception=True)
new_user = serializer.save()
sponsee_serializer = SponseeCreateSerializer(
data={
"user": new_user.pk,
"address": request.data.get("address"),
"phone": request.data.get("phone"),
"birth_certificate": request.data.get("birthCertificate"),
"national_id": request.data.get("nationalId"),
})
sponsee_serializer.is_valid(raise_exception=True)
new_sponsee = sponsee_serializer.save()
headers = self.get_success_headers(
SponseeCreateSerializer(new_sponsee).data)
return Response(SponseeListSerializer(new_sponsee).data,
headers=headers)
def get(self, request, *args, **kwargs):
queryset = Our_User.objects.filter(Q(first_insurer__isnull=False) | Q(second_insurer__isnull=False))
serialize = UserSerializer(data=queryset, many=True)
serialize.is_valid()
return Response(data=serialize.data, status=status.HTTP_200_OK)
def signup(request):
serializer = UserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
auth_login(request, user)
return Response(UserSerializer(instance=user).data,
status=status.HTTP_201_CREATED)
def patch(self, request):
user = request.user
serializer = UserSerializer(data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
phone_number = serializer.validated_data.get('phone_number', None)
serializer.validated_data.get()
if phone_number:
user.phone_number = phone_number
user.save()
return Response(UserSerializer(user).data)
def create(self, request):
serializer = UserSerializer(
data={
"username": request.data.get("username"),
"password": request.data.get("password"),
"first_name": request.data.get("firstName"),
"last_name": request.data.get("lastName"),
"email": request.data.get("email"),
})
serializer.is_valid(raise_exception=True)
new_user = serializer.save()
new_sponser = Sponser.objects.create(user=new_user)
headers = self.get_success_headers(SponserSerializer(new_sponser).data)
return Response(SponserSerializer(new_sponser).data, headers=headers)
def user_detail(request, pk):
"""
Retrieve, update or delete a code snippet.
"""
if request.user.is_authenticated:
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = UserSerializer(user)
return Response(serializer.data)
elif request.method == 'PUT':
request.data['password'] = hashlib.sha256(
str(request.data['password']).encode()).hexdigest()
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)
elif request.method == 'DELETE':
user.delete()
return Response({'mgs': "success"},
status=status.HTTP_204_NO_CONTENT)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response({'msg': "login required"},
status=status.HTTP_403_FORBIDDEN)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors)
def post(self, request):
"""
Handles the POST request made to the '/accounts/' URL.
This view will take the 'data' property from the 'request'
object, deserialize it into a 'User' object and store
in the DB.
IT WILL CREATE NEW USERS and return 201 (successfully created)
if the user is successfully created, otherwise returns a
400(bad request)
"""
serializer = UserSerializer(data=request.data)
# Check to see if the data in the `request` is valid.
# If the cannot be deserialized into a User object then
# a bad request response will be returned.
# Else, save the data and return the data and a successfully
# created status
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the 'username' contained in
# the data 'dict'
user = User.objects.create(username=data["username"])
# Use the 'set_password' method to create a HASHED password
# using the password provided in the 'data' dict
user.set_password(data["password"])
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
user.roles.add(Role.USER)
user.save()
to_email = serializer.data.get('email')
from_email = settings.EMAIL_HOST_USER
token = RefreshToken.for_user(user).access_token
domain_name = get_current_site(request).domain
relativeLink = reverse('email-verify')
final_link = "http://localhost:3000/activate/" + str(token)
subject = 'Activate your account'
message = 'Hi, ' + user.first_name + ' ' + user.last_name + ' click on this link to activate your account.\n' + final_link
send_mail(subject, message, from_email, [
to_email,
])
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
Handles the POST request made to the `/accounts/` URL.
This view will take the `data` property from the `request` object,
deserialize it into a `User` object and store in the DB.
Returns a 201 (successfully created) if the user is successfully
created, otherwise returns a 400 (bad request)
:param request:
:return:
"""
serializer = UserSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the username contained in the data dict
user = User.objects.create(username=data["username"])
# User the set password method to create a hashed password
# using the password provided in the data dict
user.set_password(data["password"])
# Finally save the new user object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def create_user(request):
"""
{
"email": "*****@*****.**",
"password": "******",
"gender": "m",
"type": "i"
}
"""
data = request.data
data['emoji'], data['nickname'] = get_nickname()
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(
{
"status": "success",
"message": "회원가입에 성공하였습니다.",
"data": {
"nickname": data['nickname'],
"emoji": data['emoji']
}
},
status=status.HTTP_201_CREATED)
return Response({
"status": "fail",
"message": serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
Handles the POST request made to the `/accounts/` URL.
This view will take the `data` property from the `request` object,
deserialize it into a `User` object and store in the DB.
Returns a 201 (successfully created) if the user is successfully
created, otherwise returns a 400 (bad request)
"""
serializer = UserSerializer(data=request.data)
# Check to see if the data in the `request` is valid.
# If the cannot be deserialized into a Todo object then
# a bad request response will be returned.
# Else, save the data and return the data and a successfully
# created status
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the `username` contained in
# the `data` dict
user = User.objects.create(username=data["username"])
# Use the `set_password` method to create a hashed password
# using the password provided in the `data` dict
user.set_password(data["password"])
# Finally, save the new `user` object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def update_user_keyword(request):
user = request.user
keyword1_list = Rating.objects.filter(user_id=user.id).values('keyword1').annotate(key_cnt=Count('keyword1')).order_by('-key_cnt')
keyword2_list = Rating.objects.filter(user_id=user.id).values('keyword2').annotate(key_cnt=Count('keyword2')).order_by('-key_cnt')
key_cnts = {}
for keyword in keyword1_list:
if keyword.get('keyword1') in key_cnts.keys():
key_cnts[keyword['keyword1']] += keyword['key_cnt']
else:
key_cnts[keyword['keyword1']] = keyword['key_cnt']
for keyword in keyword2_list:
if keyword.get('keyword2') in key_cnts.keys():
key_cnts[keyword['keyword2']] += keyword['key_cnt']
else:
key_cnts[keyword['keyword2']] = keyword['key_cnt']
import collections
sorted_cnts = sorted(key_cnts.items(), key=lambda kv: kv[1], reverse=True)
sorted_key_cnts = collections.OrderedDict(sorted_cnts)
sorted_key_cnts_keylist = list(sorted_key_cnts)
keyword1 = sorted_key_cnts_keylist[0]
keyword2 = sorted_key_cnts_keylist[1]
serializer = UserSerializer(instance=user, data={'keyword1':keyword1, 'keyword2':keyword2}, partial=True)
if serializer.is_valid():
serializer.save()
return Response(status=200, data={'message': '평점 작성 성공'})
def post(self, request):
data = request.data
response_data = {}
response_data["success"] = True
if not 'email' in data:
response_data["message"] = _("email is required ")
response_data["success"] = False
return Response(data=response_data, status=status.HTTP_400_BAD_REQUEST)
existUser = self.getObjectOrNone(User, email=data["email"])
if existUser is not None:
response_data["success"] = False
response_data["message"] = _("Email already in use")
return Response(data=response_data, status=status.HTTP_206_PARTIAL_CONTENT)
serializer = UserSerializer(data=data, many=False)
if not serializer.is_valid():
response_data["success"] = False
response_data["message"] = self.returnSerializerErrors(serializer.errors)
return Response(data=response_data, status=status.HTTP_400_BAD_REQUEST)
created_user = serializer.save()
response_data = ProfileSerializer(created_user, many=False).data
return Response(data=response_data, status=status.HTTP_201_CREATED)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
data = request.data
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def post(self, request):
"""
Handles the POST request made to the '/accounts/' URL
This view will take the 'data' property from the 'request'
object, desrialize it into a 'User' object and store in the DB
Returns a 201 (successfully created) if the user is successfully
created. Otherwise returns a 400 (bad request)
:param request:
:return:
"""
serializer = UserSerializer(data=request.data)
# Check to see if the data in the 'request' is valid
# If they cannot be desrialized into a User object then
# a bad request response will be returned
# Else, save the data and return the data and a
# sucessfully created status
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the 'username' contained in
# the 'data' dict
user = User.objects.create(username=data["username"])
# Use the 'set password' method to create a hashed password
# using the data provided in the 'data dict
user.set_password(data['password'])
# Finally, save the new 'user' object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def add_user_to_database(data):
serializer = UserPaymentSerializer(data=data)
if serializer.is_valid():
user = serializer.save()
if user:
user_data = {}
user_phone = data.get('sender_phone')
user_phone = format_phone_number(user_phone)
user_password = "******"
user_data['phone_number'] = user_phone
user_data['balance'] = data.get('amount')
user_data['password'] = user_password
jibambe_user_serializer = UserSerializer(data=user_data)
if jibambe_user_serializer.is_valid():
jibambe_user_serializer.save()
response = {"status": "01", "description": "Accepted",
"subscriber_message": "Welcome to Jibambe na Ma Movie. Your account details are " \
"Phone:{0} Password: {1}".format(user_phone, user_password)}
return response, status.HTTP_200_OK
else:
return jibambe_user_serializer.errors, status.HTTP_400_BAD_REQUEST
return serializer.errors, status.HTTP_400_BAD_REQUEST
def userDetailApi(request, *args, **kwargs):
if request.method == 'GET':
nim = kwargs['pk']
user = CustomUser.objects.filter(nim=nim)
if user:
serializer = UserSerializer(user[0])
return Response({
'count': 1,
'results': [
{**serializer.data}
]
})
else:
return Response({
'count': 0,
'results': []
})
if request.method == 'PUT':
nim = kwargs['pk']
user = get_object_or_404(CustomUser, nim=nim)
serializer = UpdateUserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(
serializer.data,
)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
if request.method == 'DELETE':
nim = kwargs['pk']
user = get_object_or_404(CustomUser, nim=nim)
user.delete()
return Response(status=status.HTTP_200_OK)
def put(self, request, pk, format=None):
user = self.get_object(pk)
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):
"""
Handles the POST request made to the `/accounts/` URL.
This view will take the `data` property from the `request` object,
deserialize it into a `User` object and store in the DB.
Returns a 201 (successfully created) if the user is successfully
created, otherwise returns a 400 (bad request)
"""
serializer = UserSerializer(data=request.data)
# Check to see if the data in the `request` is valid.
# If the cannot be deserialized into a Todo object then
# a bad request respose will be returned.
# Else, save the data and return the data and a successfully
# created status
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the `username` contained in
# the `data` dict
user = User.objects.create(username=data["username"])
# Use the `set_password` method to create a hashed password
# using the password provided in the `data` dict
user.set_password(data["password"])
# Finally, save the new `user` object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def post(self, request):
"""
Handles the POST request made to the `/accounts/` URL.
This view will take the `data` property from the `request` object,
deserialize it into a `User` object and store in the DB.
Returns a 201 (successfully created) if the user is successfully
created, otherwise returns a 400 (bad request)
:param request:
:return:
"""
serializer = UserSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the username contained in the data dict
user = User.objects.create(username=data["username"])
# User the set password method to create a hashed password
# using the password provided in the data dict
user.set_password(data["password"])
# Finally save the new user object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def put(self, request, *args, **kwargs):
serializer = UserSerializer(request.user, data=request.data)
# user = self.get_object(pk)
# serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def post(self, request):
serialized = UserSerializer(data=request.DATA)
if serialized.is_valid():
user = User.objects.create_user(**request.DATA)
data = {'token': Token.objects.get(user=user).key}
return Response(data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
data = request.data
serializer = UserSerializer(data=data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response("""Пользователь успешно зарегистрирован.
Для активации аккаунта перейдите по ссылке, которую мы отправили вам на почту""",
status=201)
def test_update_preferred_valid_name(self):
data = {"first_name": "new_preferred"}
serializer = UserSerializer(self.user, data=data, partial=True)
self.assertTrue(serializer.is_valid())
serializer.save()
self.assertEqual(self.user.preferred_name, "new_preferred")
self.assertEqual(self.user.first_name, "First")
def post(self, request, format=None):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
user.set_password(request.data['password'])
user.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def register(request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
api_key, key = APIKey.objects.create_key(name="remote-access-key")
Token.objects.get_or_create(user=user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
tasks.message.delay('verify', recipient=request.data['email'])
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_user(request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({'message': Message.SUCCESS},
status=status.HTTP_201_CREATED)
else:
return Response({'message': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serialized = UserSerializer(data=request.DATA)
if serialized.is_valid():
user = User.objects.create_user(**request.DATA)
data = {'token': Token.objects.get(user=user).key}
return Response(data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors,
status=status.HTTP_400_BAD_REQUEST)
def create_user(request):
if request.method == 'POST':
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data, context={'request': request})
if serializer.is_valid():
user = serializer.save()
if user:
json = serializer.data
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
print('post -> data', request.data)
if serializer.is_valid():
user = serializer.save()
if user:
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'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = User.objects.create_user(**serializer.validated_data)
token = Token.create_token(user.id)
data = {
'username': user.username,
'token': token
}
return Response(data, status=201)
return Response(serializer.errors, status=400)
def setUp(self):
self.url = reverse('auth')
# User info
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
# make sure our example data is valid
serializer = UserSerializer(data={'username': self.username,
'email': self.email,
'password': self.password})
if serializer.is_valid():
self.user = serializer.save()
else:
self.fail()
def setUp(self):
# url
self.user_list = 'api:user-list'
self.user_detail = 'api:user-detail'
# User info
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
# make sure our example data is valid
serializer = UserSerializer(data={'username': self.username,
'email': self.email,
'password': self.password})
if serializer.is_valid():
self.user = serializer.save()
else:
self.fail()
def post(self, request):
logger.info("UpdatePasswordView.post is called. User: {0}".format(request.user.log_guid))
# TODO: check if front end sends a json file or normal request
data = request.data
update_password_serializer = self.serializer_class(data=data)
if update_password_serializer.is_valid():
password = update_password_serializer.validated_data['password']
account = authenticate(email=request.user.email, password=password)
if account is not None:
if account.is_active:
new_password = update_password_serializer.validated_data['new_password']
try:
# we use partial to avoid passing required fields into serializer
serializer = UserSerializer(account, data={'password': new_password}, partial=True)
if serializer.is_valid():
serializer.save()
account = authenticate(email=request.user.email, password=new_password)
login(request, account)
logger.info(self.msgs['finish_success'].format(request.user.log_guid))
return Response({
'status': _('Success'), 'message': self.msgs['update_pass_success']},
status=status.HTTP_200_OK)
else:
logger.error(self.errs['ser_not_valid'].format(data))
return Response({'status': _('Bad request'), 'message': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(self.errs['exception'].format(e.message))
return Response({'status': _('Bad request'), 'message': self.msgs['internal_server_error']},
status=status.HTTP_400_BAD_REQUEST)
else:
logger.error(self.errs['user_inactive'].format(request.user.log_guid))
return Response({'status': _('Unauthorized'), 'message': self.msgs['cannot_update_pass']},
status=status.HTTP_401_UNAUTHORIZED)
else:
logger.error(self.errs['combination_invalid'])
return Response({
'status': _('Unauthorized'), 'message': self.msgs['combination_invalid']},
status=status.HTTP_401_UNAUTHORIZED)
else:
logger.error(update_password_serializer.errors)
return Response({'status': 'Bad request', 'message': self.msgs['password_mismatch'],
'errors': 'Validation error'},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
#print("Valid")
user = serializer.save()
if user:
if request.data["isStudent"] == 1:
new_student = Student(user=user, contact_no=request.data["contact_no"])
new_student.save()
elif request.data["isStudent"] == 0:
new_teacher = Teacher(user=user, contact_no=request.data["contact_no"])
new_teacher.save()
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(request):
"""
Endpoint for registration.
Does not require any permissions, so that anyone can access it.
"""
USER_FIELDS = ['username', 'password', 'email', 'role']
serialized = UserSerializer(data=request.data)
if serialized.is_valid(raise_exception=True):
user_data = {
field: data
for (field, data) in request.data.items()
if field in USER_FIELDS
}
user = User.objects.create_user(
**user_data
)
return Response(
UserSerializer(instance=user, context={'request': request}).data,
status=status.HTTP_201_CREATED,
)
def setUp(self):
self.token_list = 'api:token-list'
self.token_detail = 'api:token-detail'
# Clients cannot be created via view or serialzier
self.name = 'reddit'
self.api_url = 'https://oauth.reddit.com/api/v1/'
self.authorize_url = 'https://www.reddit.com/api/v1/'
self.token_url = 'https://www.reddit.com/api/v1/access_token/'
self.client_id = 'some-client-id'
self.client_secret = 'some-secret'
self.redirect_uri = 'http://*****:*****@example.com'
self.password = '******'
# make sure our example data is valid
serializer = UserSerializer(data={'username': self.username,
'email': self.email,
'password': self.password})
if serializer.is_valid():
self.user = serializer.save()
else:
self.fail()
def post(self, request):
data = json.loads(request.body)
guid = data.get('guid', None)
logger.info("SetPasswordView.post is called. GUID: {0}".format(guid))
password_serializer = PasswordSerializer(data=data, partial=True)
if not password_serializer.is_valid():
return Response({
'status': _('Bad request'),
'message': self.msgs['password_mismatch'],
'errors': 'Validation error'
}, status=status.HTTP_400_BAD_REQUEST)
try:
user_uid = UserUID.objects.get(guid=guid)
except ObjectDoesNotExist:
logger.exception(self.errs['GUID_invalid'].format(guid))
return Response({
'status': _('Bad request'),
'message': self.msgs['activation_invalid']
}, status=status.HTTP_400_BAD_REQUEST)
now_offset_aware = timezone.make_aware(datetime.datetime.utcnow(), timezone.get_current_timezone())
if user_uid.expiration_date < now_offset_aware:
logger.error(self.errs['GUID_expired'].format(guid, user_uid.expiration_date, now_offset_aware))
return Response({
'status': _('Bad request'),
'message': self.msgs['activation_invalid']
}, status=status.HTTP_400_BAD_REQUEST)
try:
account = User.objects.get(id=user_uid.user_id)
except ObjectDoesNotExist:
logger.exception(self.msgs['GUID_invalid'].format(guid))
return Response({
'status': _('Fail'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if account is not None:
se_data = dict()
se_data['password'] = password_serializer.validated_data['new_password']
se_data['confirm_password'] = password_serializer.validated_data['confirm_password']
se_data['email'] = account.email
se_data['username'] = account.username
se_data['log_guid'] = account.log_guid
try:
with transaction.atomic():
serializer = UserSerializer(account, data=se_data)
if serializer.is_valid():
serializer.save()
# We need to mark the forgotpassword GUID as expired
uid_data = dict()
uid_data['guid'] = guid
uid_data['user'] = user_uid.user_id
uid_data['expiration_date'] = datetime.datetime.utcnow()
uidSerializer = UserUIDSerializer(user_uid, data=uid_data)
if uidSerializer.is_valid():
uidSerializer.save()
logger.info(self.msgs['finish_success'].format(guid))
return Response({
'status': _('Success'),
'message': self.msgs['update_pass_success']
}, status=status.HTTP_200_OK)
else:
logger.error(self.errs['ser_not_valid'].format(guid, user_uid.user_id, uid_data['expiration_date']))
return Response({
'status': _('Fail'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
logger.error(self.errs['server_error'])
return Response({
'status': _('Fail'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except Exception as e:
logger.exception(self.errs['exception'].format(guid, e.message))
return Response({
'status': _('Bad request'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
logger.exception(self.errs['GUID_none'].format(guid))
return Response({
'status': _('Bad request'),
'message': self.msgs['activation_invalid']
}, status=status.HTTP_400_BAD_REQUEST)
