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 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 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 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): 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 _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 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 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)