def post(self, request, format=None):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
#serializer.data
message = "from User2"
return Response({"message": message, "data": serializer.data})
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self,request, format=None):
data = request.DATA
graph = facebook.GraphAPI(data['token'])
profile = graph.get_object("me")
picture = graph.get_connections("me", "picture")
objUser = {}
objUser['first_name'] = profile['first_name']
objUser['last_name'] = profile['last_name']
objUser['email'] = profile['email']
objUser['username'] = profile['id']
objUser['is_active'] = True
objProfile = {}
objProfile['access_token'] = data['token']
objProfile['profile_picture'] = picture['url']
objProfile['gender'] = profile['gender']
objUser['user_profile'] = objProfile
user = UserSerializer()
serializer = UserSerializer(data=objUser)
try:
userobj = User.objects.get(username=objUser['username'])
return Response(objUser, status=status.HTTP_200_OK)
except User.DoesNotExist:
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 createUser(self, 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 post(self, request):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
else:
return Response(serializer.errors, status=400)
def put(self, request):
"""
"""
# Si cambia el email puede generar problemas serios, por eso se retorna
# un nuevo token
decoded_token = decode_token(request.META)
serializer = UserSerializer(
MyUser.objects.get(email=decoded_token['email']),
data=request.data,
partial=True)
if serializer.is_valid():
user = serializer.save()
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return Response({"token": token}, status=status.HTTP_200_OK)
else:
return Response({
'data': serializer.errors,
'message': 'User could not be created with the received data.'
}, status=status.HTTP_400_BAD_REQUEST)
def create_user(request):
data = request.data
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response({'message': 'Created'})
return Response(serializer.errors)
def post(self, request):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid(): # los serializer funcionan como los djangoforms, así que hay que validarlo
serializer.save() # guardamos en la base de datos el nuevo usuario
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
queryset = Logistics_user.objects.all()
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):
serializer = UserSerializer(data=request.DATA) # en lugar request.POST
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 user_with_id(id):
pretty = True
if 'X-Requested-With' in request.headers:
pretty = False
print pretty
if request.method == 'GET':
user = User.query.filter_by(id=id).first_or_404()
pv = PageView(page='User')
db.session.add(pv)
db.session.commit()
return Response(
UserSerializer().serialize(user, pretty=pretty),
mimetype='application/json' if not pretty else 'text/html')
elif request.method == 'DELETE':
user = User.query.filter_by(id=id).first_or_404()
pv = PageView(page='User')
db.session.add(pv)
db.session.delete(user)
db.session.commit()
return '', 204
elif request.method == 'PUT':
user = User.query.filter_by(id=id).first_or_404()
user.save(**(request.json))
pv = PageView(page='User')
db.session.add(pv)
db.session.commit()
return Response(
UserSerializer().serialize(user, pretty=pretty),
mimetype='application/json' if not pretty else 'text/html')
def user():
pretty = True
if 'X-Requested-With' in request.headers:
pretty = False
print pretty
if request.method == 'GET':
pv = PageView(page='User')
db.session.add(pv)
db.session.commit()
return Response(
UserSerializer().serialize(User.query.all(),
many=True,
pretty=pretty),
mimetype='application/json' if not pretty else 'text/html')
elif request.method == 'POST':
user = User(**(request.json))
pv = PageView(page='User')
db.session.add(pv)
db.session.add(user)
db.session.commit()
return Response(
UserSerializer().serialize(user, pretty=pretty),
status=201,
mimetype='application/json' if not pretty else 'text/html')
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
kwargs = serializer.validated_data
user_data = User(**kwargs)
print datetime.now(pytz.timezone('America/Phoenix'))
user_data.creationTime = datetime.now(
pytz.timezone('America/Phoenix'))
global condition_url
city_data = City.objects.filter(id=self.request.data['cityId'])
if city_data is not None:
name = city_data[0].name
state = city_data[0].state
request_URL = condition_url + state.replace(
" ", "_") + "/" + name.replace(" ", "_") + ".json"
print request_URL
request_data = requests.get(request_URL)
request_json = json.loads(request_data.content)
user_data.timezone = request_json['current_observation'][
'local_tz_short']
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
user_data.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
else:
return Response(serializer.errors, status=400)
def create(self, request, *args, **kwargs):
"""
"""
app = None
try:
app = Application.objects.get(client_id=self.kwargs['client_id'])
except Application.DoesNotExist:
return Response({
'message': 'Invalid client_id.'
}, status=status.HTTP_400_BAD_REQUEST)
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.create()
application_user = ApplicationUser(application=app,
user=user)
application_user.save()
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return Response({"token": token}, status=status.HTTP_201_CREATED)
else:
return Response({
'data': serializer.errors,
'message': 'User could not be created with the received data.'
}, status=status.HTTP_400_BAD_REQUEST)
def userEdit(request):
try:
print request.data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
#print "valid"
#print serializer.data
return Response(
{
'status': True,
'data': None,
'message': 'Updated'
},
status=status.HTTP_200_OK)
else:
return Response(
{
'status': False,
'data': None,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response({
'status': False,
'data': None,
'message': str(e)
},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
queryset = Logistics_user.objects.all()
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 get(self, request, *args, **kwargs):
if request.user.is_authenticated():
user_data = UserSerializer(request.user).data
user_data.update(token=Token.objects.get_or_create(user=request.user)[0].key)
return self.get_response(True, data=user_data)
else:
return self.get_response(False)
def put(self, request, pk, format=None):
user = Logistics_user.objects.get(pk=pk)
serializer = UserSerializer(user, data=request.data)#, many=True, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def patch(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 put(self, request, id, format=None):
snippet = self.get_object(id=id)
serializer = UserSerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def user_signup(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 post(self, request):
"""
Creates a new account
:param request:
{
"username": "******",
"first_name": "string",
"last_name": "string",
"password": "******",
"email": "string",
"user_type": integer,
"access_level": integer,
"company_id": integer,
"invite_id": integer
}
:return: {message: string, user: UserSerializer, data: DataSerializer}
"""
data = json.loads(request.body)
user = UserSerializer(data=data)
if user.is_valid():
saved_user = user.save()
try:
userdata = Data.objects.create(
user=saved_user,
user_type=data.get('user_type'),
access_level=1,
company_id=data.get('company_id'))
# if the user is a Client, test if it is the first one of that company
# to change ownership
if data.get('user_type') == Data.CLIENT:
company = Company.objects.get(id=data.get('company_id'))
if company.owner is None:
company.owner = saved_user
company.save()
userdata.access_level = Data.ADMIN
userdata.save()
if data.get('invite_id', None):
invite = Invite.objects.get(id=data.get('invite_id'))
invite.accepted = True
invite.save()
return Response(
{
'message': 'User created successfully',
'user': user.data,
'data': DataSerializer(userdata).data
}, status.HTTP_201_CREATED)
except Exception as e:
saved_user.delete()
return Response({'message': 'User couldnt be created'},
status=status.HTTP_400_BAD_REQUEST)
return Response({'message': 'User could not be created'})
def post(self, request, format=None):
#Si existe el usuario dar mensaje de error de que ya existe.
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, format=None):
serializer_context = {
'request': Request(request),
}
user_data = {}
user_data['email'] = request.data.pop('email')[0]
user_data['username'] = request.data.pop('username')[0]
user_data['password'] = request.data.pop('password')[0]
user_data['first_name'] = request.data.pop('first_name')[0]
user_seriliazer = UserSerializer(data=user_data)
if user_seriliazer.is_valid(request.data):
user = user_seriliazer.save()
request.data['user'] = user.id
serializer = SBUserSerializer(data=request.data,
context=serializer_context)
if serializer.is_valid():
employee = serializer.save()
if request.data.get('user_type') == 'EMPLOYEE':
EmployeeRole.objects.create(
employee=employee,
department=Department.objects.get(
pk=request.data.get('department')),
role=request.data.get('role'))
return Response(serializer.data,
status=status.HTTP_201_CREATED)
else:
user.delete()
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 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, format=None):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = authenticate(username=serializer.data['username'], password=serializer.data['password'])
if user:
token = Token.objects.get_or_create(user=user)
return Response({'token': token[0].key, 'id': user.id})
return Response({'errors': 'Username/Password is not correct'}, 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, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def modifyUserInfo(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 create(self, request):
serializer = UserSerializer(data=request.DATA) # en lugar request.POST
if serializer.is_valid():
new_user = serializer.save()
self.send_welcome_email(new_user)
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) # en lugar request.POST
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):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
serialized.save()
Player.objects.create(user_id=serialized.data['id'])
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def authenticate_ldap(username, password, token):
connection = ldap.initialize("ldap://ldap.iitb.ac.in")
search_result = connection.search_s(
'dc=iitb,dc=ac,dc=in', ldap.SCOPE_SUBTREE, 'uid=%s' % username,
['uid', 'cn', 'givenName', 'sn', 'mail', 'employeeNumber'])
response_data = {
'error': False,
'error_message': "",
'first_name': "",
'last_name': "",
'email': "",
'employeeNumber': "",
'ldap': "",
'name': "",
'token': "",
}
if len(search_result) < 1 or search_result[0][1]['uid'][0] != username:
response_data['error'] = True
response_data['error_message'] = "Invalid Username/Password"
else:
try:
bind_ds = search_result[0][0]
connection.bind_s(bind_ds, password)
response_data['error'] = False
result_dict = search_result[0][1]
response_data['first_name'] = result_dict['givenName'][0]
response_data['last_name'] = result_dict['sn'][0]
response_data['name'] = result_dict['cn'][0]
response_data['email'] = result_dict['mail'][0]
response_data['ldap'] = result_dict['uid'][0]
response_data['employeeNumber'] = result_dict['employeeNumber'][0]
user_serialized = UserSerializer(data=response_data)
if user_serialized.is_valid():
user = user_serialized.save()
user.backend = "django.contrib.auth.backends.ModelBackend"
response_data['id'] = user.id
if token:
user_token = UserToken(user=user)
user_token.save()
response_data['token'] = user_token.token.hex
return response_data, user
else:
response_data['error'] = True
response_data[
'error_message'] = 'Unable to login. Please contact admin'
except ldap.INVALID_CREDENTIALS:
response_data['error'] = True
response_data['error_message'] = "Invalid Credentials"
except:
response_data['error'] = True
response_data['error_message'] = 'Unable to authenticate'
return response_data, None
def register(request):
serialized = UserSerializer(data=request.POST)
if serialized.is_valid():
user_data = utils.get_user_data(request.POST)
utils.create_inactive_user(**user_data)
return Response(utils.USER_CREATED_RESPONSE_DATA,
status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
user = Logistics_user.objects.get(pk=pk[0])
serializer = UserSerializer(
user,
data=request.data) #, many=True, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(request):
serialized = UserSerializer(data=request.POST)
if serialized.is_valid():
user_data = utils.get_user_data(request.POST)
utils.create_inactive_user(**user_data)
return Response(utils.USER_CREATED_RESPONSE_DATA,
status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def _test_google_auth(self):
auth_token = confidential.google_auth_token
client = APIClient()
request = client.post('user/google_auth/',data={'auth_token':auth_token})
self.assertEqual(request.status_cod, status.HTTP_200_OK)
serializer = UserSerializer(data=request.data)
self.assertTrue(serializer.is_valid(raise_exception=False))
def register(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse({'success': True})
else:
return JsonResponse({'success': False})
def authenticate_ldap(username, password, token):
connection = ldap.initialize("ldap://ldap.iitb.ac.in")
search_result = connection.search_s('dc=iitb,dc=ac,dc=in', ldap.SCOPE_SUBTREE, 'uid=%s' % username,
['uid', 'cn', 'givenName', 'sn', 'mail', 'employeeNumber'])
response_data = {
'error': False,
'error_message': "",
'first_name': "",
'last_name': "",
'email': "",
'employeeNumber': "",
'ldap': "",
'name': "",
'token': "",
}
if len(search_result) < 1 or search_result[0][1]['uid'][0] != username:
response_data['error'] = True
response_data['error_message'] = "Invalid Username/Password"
else:
try:
bind_ds = search_result[0][0]
connection.bind_s(bind_ds, password)
response_data['error'] = False
result_dict = search_result[0][1]
response_data['first_name'] = result_dict['givenName'][0]
response_data['last_name'] = result_dict['sn'][0]
response_data['name'] = result_dict['cn'][0]
response_data['email'] = result_dict['mail'][0]
response_data['ldap'] = result_dict['uid'][0]
response_data['employeeNumber'] = result_dict['employeeNumber'][0]
user_serialized = UserSerializer(data=response_data)
if user_serialized.is_valid():
user = user_serialized.save()
user.backend = "django.contrib.auth.backends.ModelBackend"
response_data['id'] = user.id
if token:
user_token = UserToken(user=user)
user_token.save()
response_data['token'] = user_token.token.hex
return response_data, user
else:
response_data['error'] = True
response_data['error_message'] = 'Unable to login. Please contact admin'
except ldap.INVALID_CREDENTIALS:
response_data['error'] = True
response_data['error_message'] = "Invalid Credentials"
except:
response_data['error'] = True
response_data['error_message'] = 'Unable to authenticate'
return response_data, None
def register(request):
serialized = UserSerializer(data=request.DATA)
if serialized.is_valid():
get_user_model().objects.create_user(
serialized.init_data['email'],
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):
# Para crear un usuario
# Hay que pasar request.DATA en vez de request.POST
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# Algo ha ido mal
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
ser = UserSerializer(data=request.POST)
if ser.is_valid():
user = ser.save()
auth.login(request, user)
if request.accepted_renderer.format == "html":
return redirect("/")
else:
return Response(ser.data)
return Response(ser.errors)
def put(self,request,pk):
user = get_object_or_404(User,pk=pk)
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 login_handle(request, pk):
try:
user = UserInfo.objects.get(pk=pk)
except user.DoesNotExist:
return HttpResponse(status=404)
#
if request.method == 'POST':
serializer = UserSerializer(user)
return JSONResponse(serializer.data)
# 获得指定用户的信息
elif request.method == 'GET':
serializer = UserSerializer(user)
return JSONResponse(serializer.data)
# 修改指定用户的信息（忘记密码）
elif request.method == 'PUT':
data = JSONParser().parse(request)
try:
user = UserInfo.objects.get(pk=pk)
except user.DoesNotExist:
return HttpResponse(status=404)
serializer = UserSerializer(user, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
# 删除指定用户信息
elif request.method == 'DELETE':
user.delete()
return HttpResponse(status=204)
def register_user(request): serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): User.objects.create_user( serialized.initial_data['username'], serialized.initial_data['email'], serialized.initial_data['password'] ) return Response(status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = self.get_object(pk)
if request.user.has_perm("umaa.edit_user") or request.user == user:
serializer = UserSerializer(user, data=request.DATA, partial=True)
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(UNAUTHORIZED_MSG, status=status.HTTP_401_UNAUTHORIZED)
def users(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
else:
return JSONResponse(serializer.errors, status=400)
return HttpResponse(status=400)
def post(self, request):
# Para crear un usuario
# Hay que pasar request.DATA en vez de request.POST
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# Algo ha ido mal
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=202)
else:
return Response(serializer.errors, status=400)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def put(self, request, pk):
user = self.get_object(pk)
if request.user.has_perm('umaa.edit_user') or request.user == user:
serializer = UserSerializer(user, data=request.DATA, partial=True)
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(UNAUTHORIZED_MSG, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format=None):
serializer = UserSerializer(data=request.data)
print request.data
if serializer.is_valid():
user = authenticate(username=serializer.data['username'], password=serializer.data['password'])
if user:
if user.first_name == 'facebook':
return Response({'errors': 'Facebook User'}, status=status.HTTP_400_BAD_REQUEST)
token = Token.objects.get_or_create(user=user)
return Response({'token': token[0].key})
return Response({'errors': 'Username/Password is not correct'}, status=status.HTTP_400_BAD_REQUEST)
def users(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
else:
return JSONResponse(serializer.errors, status=400)
return HttpResponse(status=400)
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'] = user
return Response(json, status=status.HTTP_201_CREATED)
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(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)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data,status=202)
else:
return Response(serializer.errors,status=400)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
try:
user = User.objects.get(username=serializer.data['username'])
except ObjectDoesNotExist:
user = User.objects.create_user(serializer.data['username'], password=serializer.data['password'])
user.save()
token = Token.objects.create(user=user)
return Response({'token': token.key}, status=status.HTTP_201_CREATED)
return Response({'errors': 'Username already exists'}, status=status.HTTP_400_BAD_REQUEST)
return Response({'errors': 'Fields may not be blank'}, status=status.HTTP_400_BAD_REQUEST)
def register(request):
if "application/json" in request.META.get("CONTENT_TYPE"):
data = json.loads(request.body)
else:
data = request.POST
serialized = UserSerializer(data=data)
if serialized.is_valid():
user_data = utils.get_user_data(data)
utils.create_inactive_user(request, **user_data)
return Response(utils.USER_CREATED_RESPONSE_DATA,
status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def user_collection(request):
if request.method == 'GET':
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
if request.method == 'PUT':
serializer = UserSerializer(data = request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(serializer.data)
