def post(self, request):
"""
Function is used to create new object or value in table and return status.
:param request: request header with user info for creating new object.
:return: user info
"""
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
context = {
'username': serializer.data['username'],
'site_url': constants.SITE_URL + constants.LOGIN
}
# render email html
email_html_message = render_to_string(
'email_templates/register_success.html', context)
utils.send_email(subject="WELCOME!",
recipient=[serializer.data['email']],
body=email_html_message)
api_response = ApiResponse(status=1,
data=serializer.data,
message=constants.CREATE_USER_SUCCESS,
http_status=status.HTTP_201_CREATED)
return api_response.create_response()
api_response = ApiResponse(status=0,
message=get_error_message(serializer),
http_status=status.HTTP_400_BAD_REQUEST)
return api_response.create_response()
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 user_detail(request, name):
if name:
name = name.lower()
try:
user = None
user = User.objects.get(name__iexact=name)
except User.DoesNotExist:
if request.method == 'GET':
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
user_serializer = UserSerializer(user)
return JSONResponse(user_serializer.data)
elif request.method == 'PUT':
user_data = JSONParser().parse(request)
if not user:
user = User(name=name, dob=user_data['dob'])
user.save()
user_serializer = UserSerializer(user, data=user_data, partial=True)
if user_serializer.is_valid():
user_serializer.save()
return HttpResponse(status=status.HTTP_201_CREATED)
return JSONResponse(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
user.delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
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 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 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 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):
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user_serializer.save()
return Response(user_serializer.data)
return Response(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def user_detail(request, pk):
try:
usr_id = int(pk)
user = get_object_or_None(authUser, id=usr_id)
except ValueError:
user = get_object_or_None(authUser, username=pk)
if user is None:
return JSONError(message="User is not found",
code=404,
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
user_serializer = UserSerializer(user)
return JSONResponse(user_serializer.data)
elif request.method == 'PUT':
user_data = JSONParser().parse(request)
if ('username' in user_data):
if not isinstance(user_data['username'], (str, unicode)):
return JSONError(message="'username' value is not a String",
code=400,
status=status.HTTP_400_BAD_REQUEST)
user_serializer = UserSerializer(user, data=user_data)
if user_serializer.is_valid():
user_serializer.save()
return JSONResponse(user_serializer.data)
return JSONResponse(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
user.delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def post(self, request, format=None):
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, 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 user_list(request):
if 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):
"""
Function is used for modify the password
:param request: request header with required info.
:return: user info or proper error message
"""
user = request.user
if user:
data = {"password": request.data['password']}
serializer = UserSerializer(user, data=data, partial=True)
if serializer.is_valid():
serializer.save()
api_response = ApiResponse(
status=1,
data=serializer.data,
message=constants.CHANGE_PASSWORD_SUCCESS,
http_status=status.HTTP_201_CREATED)
return api_response.create_response()
api_response = ApiResponse(status=0,
message=get_error_message(serializer),
http_status=status.HTTP_400_BAD_REQUEST)
return api_response.create_response()
api_response = ApiResponse(status=0,
message=constants.USER_DOES_NOT_EXIST,
http_status=status.HTTP_404_NOT_FOUND)
return api_response.create_response()
def post(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return JsonResponse({'Status': False, 'Error': 'Log in required'}, status=403)
# проверяем обязательные аргументы
if 'password' in request.data:
errors = {}
# проверяем пароль на сложность
try:
validate_password(request.data['password'])
except Exception as password_error:
error_array = []
# noinspection PyTypeChecker
for item in password_error:
error_array.append(item)
return JsonResponse({'Status': False, 'Errors': {'password': error_array}})
else:
request.user.set_password(request.data['password'])
# проверяем остальные данные
user_serializer = UserSerializer(request.user, data=request.data, partial=True)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse({'Status': True})
else:
return JsonResponse({'Status': False, 'Errors': 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 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 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 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(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 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(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 post(request):
serializer = UserSerializer(data=request.data,
context={'request': request})
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 saveuser(request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
serialized.save()
return render(request, 'questionscore/login.html')
else:
return render(request, 'questionscore/createuser.html')
def put(self, request, pk):
"""
Function is used for modify user info
:param request: request header with required info.
:param pk: primary key of a object.
:return: user info or send proper error status
"""
try:
user = User.objects.get(id=pk)
except User.DoesNotExist as e:
logger.exception(e)
api_response = ApiResponse(status=0,
message=constants.USER_DOES_NOT_EXIST,
http_status=status.HTTP_404_NOT_FOUND)
return api_response.create_response()
serializer = UserSerializer(user, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
api_response = ApiResponse(status=1,
data=serializer.data,
message=constants.UPDATE_USER_SUCCESS,
http_status=status.HTTP_201_CREATED)
return api_response.create_response()
api_response = ApiResponse(status=0,
message=get_error_message(serializer),
http_status=status.HTTP_400_BAD_REQUEST)
return api_response.create_response()
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=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 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 put(self, request):
user = User.objects.get(email=request.user)
serializer = UserSerializer(user, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update(self, request):
user = request.user
serializer = UserSerializer(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 put(self, request, pk):
user = get_object_or_404(User, pk=pk)
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 set_password(self, request):
serialized = UserSerializer(data=request.DATA)
if serialized.is_valid():
serialized.save()
return Response(status=status.HTTP_205_RESET_CONTENT)
else:
return Response(serialized.errors,
status=status.HTTP_400_BAD_REQUEST)
def register(request):
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response({"Registration": serializer.errors}, status=400)
def put(self, request):
user = self.get_user(self)
serializer = UserSerializer(user, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response({"Status 201": "User updated successfully"},
status=status.HTTP_201_CREATED)
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 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)
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 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):
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):
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 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 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 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 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 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 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 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 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 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 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 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, 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 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 post(self, request, format=None):
ser = UserSerializer(request.DATA)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
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)
