def update(self, request, pk=None):
queryset = models.User.objects.all()
user = get_object_or_404(queryset, pk=pk)
serializer = UserSerializer(user, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def post(self, request):
try:
user = request.data.copy()
logger.info("Creating new user %s", str(user))
user['username'] = user['email'].split('@')[0]
user['password'] = encode(user['password'])
serializer = UserSerializer(data=user)
serializer.is_valid(raise_exception=True)
serializer.save()
logger.info("New user creation was successful, welcome: %s" %
user['username'])
return Response(serializer.data, status=status.HTTP_201_CREATED)
except ValidationError as e:
msg = "Registration failed: "
for detail in e.detail.values():
msg += detail[0] + " "
logger.exception("Registration failed")
logger.error(msg)
return get_error_response(msg)
except Exception as e:
logger.error("Registration failed because %s" % str(e), e)
res = {'error': e}
return Response(res)
def test_create_user_with_generated_username(mocker, valid_address_dict):
"""
Integration test to assert that create_user_with_generated_username tries to find an available
username and try again to save a User if there was a username collision
"""
username = "******"
# Create a user with the desired username before calling the function so we get a collision
UserFactory.create(username=username)
data = {
"username": username,
"email": "*****@*****.**",
"name": "Test User",
"legal_address": valid_address_dict,
"password": "******",
}
serializer = UserSerializer(data=data)
serializer.is_valid()
patched_find_username = mocker.patch(
"authentication.api.find_available_username", return_value="testuser1")
created_user = api.create_user_with_generated_username(
serializer, username)
patched_find_username.assert_called_once_with(username)
assert created_user is not None
assert created_user.username == patched_find_username.return_value
def put(self, request, *args, **kwargs):
request.data["id"] = request.user.id
user = User.objects.get(id=request.user.id)
serializer = UserSerializer(user, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def post(request):
output = {}
try:
user = request.data
# check user with clearbit
# response = clearbit.Enrichment.find(email=user['email'], stream=True)
# if response:
# #Make some action with received data
# pass
serializer = UserSerializer(data=user)
serializer.is_valid(raise_exception=True)
serializer.save()
output['answer'] = serializer.data
except ValidationError as exception:
output['answer'] = {
"error": {
"status_code": str(exception.status_code),
"status_details": str(exception.default_detail),
"status_message": exception.get_full_details()
}
}
return Response({"response": output}, status=status.HTTP_201_CREATED)
def user_detail(request, pk):
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = UserSerializer(user)
return JsonResponse(serializer.data)
elif request.method == 'PATCH':
data = JSONParser().parse(request)
serializer = UserSerializer(user, data=data, partial=True)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
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)
elif request.method == 'DELETE':
user.delete()
return HttpResponse(status=204)
def update(self, request, partial=False, pk=None):
print(partial)
user = self.get_object()
serializer = UserSerializer(user, request.data, partial=partial)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def register(self, request):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user_serializer = UserSerializer(data=serializer.validated_data)
user_serializer.is_valid(raise_exception=True)
user = User.objects.create_user(**user_serializer.validated_data)
token = self.perform_login(request, user)
return Response({'token': token.key})
def put(self, request, *args, **kwargs):
serializer = UserSerializer(
request.user, data=request.data, partial=True
)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def me(self, request):
user = request.user
if request.method == 'GET':
serializer = UserSerializer(user)
return Response(serializer.data, status=status.HTTP_200_OK)
elif request.method == 'PATCH':
serializer = UserSerializer(user, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def post(self, request):
#try:
serializer = UserSerializer(
data={
"name": request.data.get('name'),
'password': make_password(request.data.get('password'))
})
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def get_user(request):
if request.method == 'GET':
return SuccessResponse(
UserSerializer(request.user).data, status.HTTP_200_OK)
elif request.method == 'PUT':
user = request.user
user_serializer = UserSerializer(user, data=request.data, partial=True)
user_serializer.is_valid(raise_exception=True)
user_serializer.save()
return SuccessResponse(user_serializer.data, status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
data = {"id": request.user.id, **request.data}
serializer = UserSerializer(data=data)
serializer.is_valid(raise_exception=True)
user = User.objects.get(id=request.user.id)
serializer.update(instance=user,
validated_data=serializer.validated_data)
response = UserSerializer(user).data
return JsonResponse(response)
def post(self, requests):
data = json.loads(requests.body.decode('utf-8'))
try:
serializer = UserSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
except Exception as e:
print(e)
return Response({'error': 'provide field'},
status=status.HTTP_403_FORBIDDEN)
def create(self, request, *args, **kwargs):
request.data['email'] = request.data.get('email', None)
request.data['username'] = request.data.get('email', None)
user_serializer = UserSerializer(data=request.data)
user_serializer.is_valid(raise_exception=True)
user_serializer.save()
request.data['user'] = user_serializer.data['id']
user_profile_serializer = self.serializer_class(data=request.data)
user_profile_serializer.is_valid(raise_exception=True)
user_profile_serializer.save()
return Response(user_profile_serializer.data,
status=status.HTTP_201_CREATED)
def forwards_func(apps, schema_editor):
serializer = UserSerializer(
data={
'email': '*****@*****.**',
'password': '******',
'first_name': 'Anonymous',
'last_name': 'Anonymous'
})
serializer.is_valid(raise_exception=True)
serializer.save()
Student = apps.get_model('users', 'Student')
Student.objects.create(user=apps.get_model('users', 'User').objects.get(
email='*****@*****.**'))
def put(self, requests):
data = json.loads(requests.body.decode('utf-8'))
user = User.objects.get(email=data['email'],
password=data['oldPassword'])
if user:
data['password'] = data['newPassword']
serializer = UserSerializer(user, data=data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response({'error': 'cant find user'},
status=status.HTTP_403_FORBIDDEN)
def test_validate_email(self):
data = {
'name': 'John Doe',
'email': 'invalidemail.com',
'password': '******'
}
serializer = UserSerializer(data=data)
with self.assertRaises(serializers.ValidationError):
serializer.is_valid(raise_exception=True)
self.assertIn('email', serializer.errors.keys())
self.assertIn(
'Enter a valid email address',
str(serializer.errors)
)
def test_validate_name_alphanumeric_only(self):
data = {
'name': 'j0hn',
'email': '*****@*****.**',
'password': '******'
}
serializer = UserSerializer(data=data)
with self.assertRaises(serializers.ValidationError):
serializer.is_valid(raise_exception=True)
self.assertIn('name', serializer.errors.keys())
self.assertIn(
'Must contain only alphanumeric characters',
str(serializer.errors)
)
def test_validate_name_min_length(self):
data = {
'name': 'john Do',
'email': '*****@*****.**',
'password': '******'
}
serializer = UserSerializer(data=data)
with self.assertRaises(serializers.ValidationError):
serializer.is_valid(raise_exception=True)
self.assertIn('name', serializer.errors.keys())
self.assertIn(
'Must contain at least 8 characters',
str(serializer.errors)
)
def test_validate_password(self):
data = {
'name': 'John Doe',
'email': '*****@*****.**',
'password': '******'
}
serializer = UserSerializer(data=data)
with self.assertRaises(serializers.ValidationError):
serializer.is_valid(raise_exception=True)
self.assertIn('password', serializer.errors.keys())
self.assertIn(
'This password is too short',
str(serializer.errors)
)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
def post(self, request):
serializer = UserSerializer(data=request.data) #en rest framework los datos que se envían están en data, y no en POST
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=HTTP_201_CREATED)
else:
return Response(serializer.errors, 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)
# class APIUserDetails(APIView):
# def post(self, request, format='json'):
# print("###### GET USER DATA: ", request.data)
# userData = request.data
# print("###### GET USER DATA: ", request.data)
# username = request.user.username
# email = request.user.email
# print("# Username", username)
# print("# email", username)
# cursor = connection.cursor()
# query = "SELECT username, email FROM auth_user"
# cursor.execute(query)
# return Response(username, status=200)
def create(self, req):
serializer = UserSerializer(data=req.data, context={'request': req})
if serializer.is_valid():
new_user = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
logger.info('user with id: {} registered.'.format(user.id))
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None):
my_profile = request.user.get_profile()
# User should be able to edit first_name, last_name, email here
# TODO: Make sure this is safe as we are making two calls to serialize the request
user_serializer = UserSerializer(
request.user,
data=request.DATA,
partial=True
)
if not user_serializer.is_valid():
return errors.New400BadRequest(user_serializer.errors)
user_serializer.save()
serializer = ProfileSerializer(
my_profile,
data=request.DATA,
partial=True
)
print serializer.errors
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return errors.New400BadRequest(serializer.errors)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def registration(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(status=HTTP_201_CREATED)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def create(request):
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def put(self, request, user_id):
user = self.get_object(user_id)
serializer = UserSerializer(user, data=request.data)
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 post(self, request, format=None):
request_data = request.data
client_data = request_data["client"]
try:
client = Client.objects.get(user__email=client_data["user"]["email"])
user_serializer = UserSerializer(client.user, data=client_data["user"])
except Client.DoesNotExist:
client = None
user_serializer = UserSerializer(data=client_data["user"])
# Update information for user.
if user_serializer.is_valid():
user_serializer.save()
else:
return Response(user_serializer.errors)
del client_data["user"]
client_data["user_id"] = user_serializer.instance.id
# Update information for client.
if client:
serializer = ClientSerializer(client, data=client_data)
else:
serializer = ClientSerializer(data=client_data)
if serializer.is_valid():
serializer.save()
# Add this client to the provision table.
users_db_utils.add_to_client_provision(
serializer.instance.id)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def register_user(request):
token_generator = AppTokenGenerator()
data = {'username':request.data["userName"], 'password':request.data["password"], 'email':request.data["email"]}
user_serializer = UserSerializer(data=data)
if user_serializer.is_valid():
user = user_serializer.save()
data = {'user_id':user.id,'first_name':request.data["firstName"], 'last_name':request.data["lastName"], 'email':request.data["email"], 'birth_date':None, 'country':None}
profile_serializer = ProfileSerializer(data=data)
if profile_serializer.is_valid():
profile_serializer.save()
else:
logger.error(profile_serializer.errors)
login(request, user)
logger.info("Preparing email...")
FRONTEND_URL = settings.FRONTEND_URL
BACKEND_URL = settings.BACKEND_URL
# token = get_random_string(length=32)
token = token_generator.make_token(user)
verify_link = FRONTEND_URL + 'verify-email/' + token
subject, from_email, to = 'Verify your email', settings.EMAIL_HOST_USER, request.data["email"]
html_content = render_to_string('verify_email.html', {'verify_link': verify_link, 'base_url': FRONTEND_URL, 'backend_url': BACKEND_URL})
text_content = strip_tags(html_content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to, '*****@*****.**'])
msg.attach_alternative(html_content, "text/html")
msg.send()
logger.info("Verification email sent")
return Response({'user': user_serializer.data})
else:
logger.error(user_serializer.errors)
def post(self, request):
data = request.data
serializer = UserSerializer(data=data)
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, userid):
user = self.get_user(userid)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
send_mail(u"Bienvenido!", u"Bienvenido a Frikr!", "*****@*****.**", [new_user.email], fail_silently=True)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(User, request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk):
user = get_object_or_404(User, pk=pk)
# Paso al serializados que instancia y con que la tiene que actualizar.
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user) # compruebo si el usuario autenticado puede hacer PUT en este user
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
# Devolvemos los datos después de crear el recurso, es como un acuse de recibo.
# no todas las apis devuelven los datos.
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, req, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(req, user) # permisos a mano
serializer = UserSerializer(instance=user, data=req.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_404_NOT_FOUND)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user) # llama a has_object_permission
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=HTTP_202_ACCEPTED)
else:
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def update(self, request, pk):
self.check_permissions(request)
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(instance=user, data=request.data) #Serializa este usuario con data datos
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
blog = Blog()
blog.title = request.data.get("blog")
blog.owner = new_user
blog.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user.username == user.username:
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
def list_matches(self, request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
User.objects.create_user(
serialized.init_data['email'],
serialized.init_data['date_of_birth'],
serialized.init_data['password']
)
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data) # se inicializa el serializer con los datos que me llegan por http mediante POST
if serializer.is_valid():
new_user = serializer.save() # Guarda el objeto en BB.DD. y me lo devuelve
new_blog = Blog()
new_blog.name = 'El blog de {0} {1}'.format(request.data.get('first_name'), request.data.get('last_name'))
new_blog.author = new_user
new_blog.save()
# serializer almacena los datos en 'serializer.data'
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# serializer almacena los errores en 'serializer.errors'
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data) #TODOS LOS MÉTODOS REST VIENEN POR EL PARAMETRO 'DATA' DE LA REQUEST
if serializer.is_valid():
new_user = serializer.save()
# TODO - crear el usuario y su blog en una sóla llamada
blog_for_newUser = Blog()
blog_for_newUser.owner = new_user
blog_for_newUser.name = new_user.first_name + ' ' + new_user.last_name + '\'s Personal Blog'
blog_for_newUser.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk) # devuelve el objeto o, si este no existe, un error 404
# compruebo si el usuario autenticado puede hacer PUT en este user
# Hay que hacerlo a mano porque estamos heredando de una GenericAPIView
# Al hacer la recuperación del objeto 'user' manualmente, la comprobacion tambien debe ser manual
self.check_object_permissions(request, user)
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_user_creation(self):
data = {"username": "******", "email": "*****@*****.**",
"password": "******", "first_name": "tester",
"last_name": "testington"}
serializer = UserSerializer(data=data)
self.assertTrue(serializer.is_valid(), msg=serializer.errors)
user = serializer.create(serializer.validated_data)
self.assertEqual(data['username'], user.username)
self.assertEqual(data['email'], user.email)
self.assertEqual(data['first_name'], user.first_name)
self.assertEqual(data['last_name'], user.last_name)
def create_auth(request):
serialized = UserSerializer(data=request.data)
if request.data['secret_code'] == settings.SECRET_CODE:
if serialized.is_valid():
User.objects.create_user(
serialized.data['username'],
serialized.data['email'],
serialized.data['password']
)
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors , status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'Incorrect inscription code' : [", please contact our team to get yours"]} , status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
"""
Endpoint de modificación de usuario. Por convención, se utiliza la url de listado con una petición PUT para la modificación de un objeto de ese listado. En el serializer.save() comprueba automáticamente si tiene instancia del User; si la tiene, coge esa instancia y llama al update() del serializer; si no la tiene, llama al método create() del serializer, como en el caso del POST del UserListAPI
"""
user = get_object_or_404(User, pk=pk)
# compruebo manualmente si el usuario autenticado puede hacer PUT en este user
self.check_object_permissions(request, user)
# Actualiza los datos de la instancia recuperada con los datos que me pasan por la API
serializer = UserSerializer(instance=user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
"""
Endpoint de creación de usuario. Guardamos automáticamente también el blog con su nombre de usuario
:param request:
:return:
"""
# Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST,
# request.GET, etc., se utiliza simplemente data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
# Guardamos blog para el nuevo usuario
user_blog = Blog()
user_blog.owner = new_user
user_blog.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
Endpoint de creación de usuario. Por convención, se utiliza la url de listado con una petición POST para la creación de un objeto de ese listado. En el serializer.save() comprueba automáticamente si tiene instasncia del User; si no la tiene, llama al método create del serializer.
"""
# Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST,
# request.GET, etc., se utiliza simplemente data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
# Guardamos el usuario a través del serializer y devolvemos los datos del objeto creado
new_user = serializer.save()
# Guardamos blog para el nuevo usuario
user_blog = Blog()
user_blog.owner = new_user
user_blog.save()
# Respondemos código 201 (creado) y los datos del objeto creado
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# Devolvemos diccionario con errores y el código 400 (petición errónea) si algo fue mal
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def user_list(request):
"""
List all users, or create a new user.
"""
if request.method == 'GET':
username = str(request.GET.get('username', ''))
if username == '':
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
else:
user = User.objects.get(username=username)
serializer = UserSerializer(user, many=False)
return Response(serializer.data)
elif request.method == 'POST':
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 put(self, request, username, format=None):
data = UserAccountSerializer(data=request.data).data
user = User.objects.get(username=username)
user_serializer = UserSerializer(user,
data=data['user'])
if user_serializer.is_valid():
user_serializer.save()
account = self.get_object(username)
account.school = data.get('school')
account.class_in_school = data.get('class_in_school')
# client should put facebook_id to enable this
# account.facebook_id = data.get('facebook_id')
account.save()
update_session_auth_hash(request, user)
return Response(UserAccountSerializer(account).data)
return Response(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def user_detail(request, pk):
"""
Retrieve, update or delete a user instance.
"""
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':
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(status=status.HTTP_204_NO_CONTENT)
def put(self, request, username, format=None):
serializer = UserAccountSerializer(data=request.data)
if serializer.is_valid() is False:
return Response(
{"message": "Cannnot update profile with provided information"}, status=status.HTTP_400_BAD_REQUEST
)
data = serializer.validated_data
password = data["user"].get("password")
confirm_password = data["user"].get("confirm_password")
if password != confirm_password:
return Response(
{"message": "Password and confirm password don't match"}, status=status.HTTP_400_BAD_REQUEST
)
user = User.objects.get(username=username)
user_serializer = UserSerializer(user, data=data["user"])
if user_serializer.is_valid():
user_serializer.save()
account = self.get_object(username)
account.school = data.get("school")
account.class_in_school = data.get("class_in_school")
# client should put facebook_id to enable this
# account.facebook_id = data.get('facebook_id')
account.save()
update_session_auth_hash(request, user)
return Response(UserAccountSerializer(account).data)
return Response(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def _handle_put(self, request, *args, **kwargs):
"""
PUT handler for User Detail
:request - HTTP request from the api call
Here is how you change the user:
{
"username": "******", OPTIONAL
"first_name": "Roberto", OPTIONAL
"last_name": "Garrison III", OPTIONAL
"email": "*****@*****.**" OPTIONAL
}
if you want to change the password pass in the following json fields:
{
"username": "******", OPTIONAL
"first_name": "Roberto", OPTIONAL
"last_name": "Garrison III", OPTIONAL
"email": "*****@*****.**", OPTIONAL
"password_1": "myPa55W0rd!", REQUIRED
"password_2": "myPa55W0rd!" REQUIRED
}
Kwargs
:pk - PK of the user that you want to get detail on
"""
user = self.get_object(kwargs.get('pk'))
response = {}
put_data = request.DATA
errors = False
if put_data.get('username', None) is not None:
if user.username != put_data.get('username') and User.objects.filter(username=put_data.get('username')).count() > 0:
response['username'] = [
'Username "{0}" is currently taken, please try another.'.format(
put_data.get('username')),
]
errors = True
if put_data.get('email', None) is not None:
if user.email != put_data.get('email') and User.objects.filter(email=put_data.get('email')).count() > 0:
response['email'] = [
'Email "{0}" is currently in use, please try another.'.format(
put_data.get('email')),
]
errors = True
if put_data.get('password_1', None) is not None and put_data.get('password_2', None) is not None:
if put_data.get('password_1') == put_data.get('password_2'):
# update the password
user.set_password(put_data.get('password_1'))
else:
response['password_1'] = [
'Password\'s don\'t match please try again!',
]
response['password_2'] = [
'Password\'s don\'t match please try again!',
]
errors = True
if errors:
self.raise_bad_request(response)
serializer = UserSerializer(user, data=put_data)
if serializer.is_valid():
serializer.save()
return serializer.data
return self.raise_bad_request(serializer.errors)
