def post(self, request, format=None): user = request.user print(user.id) try: query_set = User.objects.get(pk=user.id) print(user.id) print(user.address_1) print(user.postcode) except User.DoesNotExist: return Response("no user found", status=HTTP_404_NOT_FOUND) print("we got a queryset") data = request.data print("we got data") print(data) serializer = UserProfileSerializer(request.user, data=data) if serializer.is_valid(): serializer.save() return Response("Yay we did it!", HTTP_200_OK) else: return Response(serializer.errors)
def register_user(request): if request.method == 'POST': serializers = UserProfileSerializer(data=request.data) if serializers.is_valid(): serializers.save() return Response(serializers.data, status=status.HTTP_201_CREATED) return Response(serializers.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None): user = request.user profile = get_object_or_404(UserProfile, user=user) serializer = UserProfileSerializer(data=request.data) if serializer.is_valid(): serializer.update(instance=profile, validated_data=serializer.data) return Response(serializer.data, status=status.HTTP_202_ACCEPTED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, username, format=None): profile = self.get_object(username) serializer = UserProfileSerializer(profile, 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 test_serializer_accepts_valid_data(self): """ Serializer.is_valid() should return true when instantiated with valid data. """ serializer = UserProfileSerializer( data=self.data, context=self.context ) self.assertTrue(serializer.is_valid())
def post(self,request,*args, **kwargs): user=request.user user_profile=UserProfile.objects.get_or_create(user=user) serializer=UserProfileSerializer(user_profile[0],data=request.data) if serializer.is_valid(): serializer.save() return JsonResponse({'detail':'success'}) else: print("pp:",serializer.errors) return JsonResponse(serializer.errors,status=400)
def test_save_updates_correct_fields(self): """ Calling `.save()` should update correct fields on model. """ serializer = UserProfileSerializer( self.profile, data=self.data, context=self.context ) if serializer.is_valid(): new_profile = serializer.save() self.assertEqual(new_profile.website, self.data['website']) self.assertEqual(new_profile.about_me, self.data['about_me']) self.assertEqual(new_profile.user, self.user)
def elm_settings(user): try: profile = user.profile except AttributeError: profile = UserProfile.nullProfile() config = SiteConfiguration.get_solo() elm = { 'userPerms': UserProfileSerializer(profile).data, 'twilioSendingCost': settings.TWILIO_SENDING_COST, 'twilioFromNumber': settings.TWILIO_FROM_NUM, 'smsCharLimit': config.sms_char_limit, 'defaultNumberPrefix': config.default_number_prefix, 'noAccessMessage': config.not_approved_msg, 'blockedKeywords': [ x.keyword for x in Keyword.objects.all().prefetch_related('owners') if x.is_locked and not x.can_user_access(user) ], } return mark_safe(json.dumps(elm))
def elm_settings(user): try: profile = user.profile except AttributeError: profile = UserProfile.nullProfile() config = SiteConfiguration.get_solo() try: twilio_settings = config.get_twilio_settings() # remove sensitive settings: del twilio_settings['auth_token'] del twilio_settings['sid'] except ConfigurationError: twilio_settings = None bk_key = f'blocked_keywords_user_{user.pk}' blocked_keywords = cache.get(bk_key) if blocked_keywords is None: blocked_keywords = [ x.keyword for x in Keyword.objects.all().prefetch_related('owners') if not x.can_user_access(user) ] cache.set(bk_key, blocked_keywords, 120) elm = { 'userPerms': UserProfileSerializer(profile).data, 'twilio': twilio_settings, 'isEmailSetup': config.is_email_setup(), 'smsCharLimit': config.sms_char_limit, 'defaultNumberPrefix': config.default_number_prefix, 'noAccessMessage': config.not_approved_msg, 'blockedKeywords': blocked_keywords, } return mark_safe(json.dumps(elm))
def get(self, request): try: profile = request.user.userprofile serializer = UserProfileSerializer(profile, context={'request': request}) return Response(serializer.data) except AttributeError: return Response({'nodetail': 'Anonymous User'})
def elm_settings(user): try: profile = user.profile except AttributeError: profile = UserProfile.nullProfile() config = SiteConfiguration.get_solo() try: twilio_settings = config.get_twilio_settings() # remove sensitive settings: del twilio_settings["auth_token"] del twilio_settings["sid"] except ConfigurationError: twilio_settings = None bk_key = f"blocked_keywords_user_{user.pk}" blocked_keywords = cache.get(bk_key) if blocked_keywords is None: blocked_keywords = [ x.keyword for x in Keyword.objects.all().prefetch_related("owners") if not x.can_user_access(user) ] cache.set(bk_key, blocked_keywords, 120) elm = { "userPerms": UserProfileSerializer(profile).data, "twilio": twilio_settings, "isEmailSetup": config.is_email_setup(), "smsCharLimit": config.sms_char_limit, "defaultNumberPrefix": config.default_number_prefix, "noAccessMessage": config.not_approved_msg, "blockedKeywords": blocked_keywords, } return mark_safe(json.dumps(elm))
def get(self,request,*args,**kwargs): user = request.user obj = UserProfile.objects.get(user=user) serializer = UserProfileSerializer(obj) return JsonResponse(serializer.data)
def post(self, request, pk=0): # create profile serializer = UserProfileSerializer(data=request.data) try: if serializer.is_valid(raise_exception=True): if serializer.create(serializer.data) is not None: return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) except Exception: strerr = "Erreur post profile : [{}] [{}]".format( sys.exc_info()[0], sys.exc_info()[1]) return Response(strerr, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs): serializer = self.serializer_class(data=request.data, context={'request': request}) serializer.is_valid(raise_exception=True) user = serializer.validated_data['user'] token, created = Token.objects.get_or_create(user=user) user_profile = UserProfile.objects.get(user=user) user_profile_serializer = UserProfileSerializer(user_profile) return Response({'token': token.key, 'user_profile': user_profile_serializer.data})
def update(self, request, pk=None): #get the authenticated user user = request.user data = request.data serializer = UserProfileSerializer(user, data=data) if serializer.is_valid(): serializer.save() if user: return Response("user profile updated successfully", HTTP_200_OK) else: return Response(serializer.errors, HTTP_400_BAD_REQUEST)
def put(self, request, pk): # modify profile if pk == "": profile = get_object_or_404(Profile, uzer_id=request.user.pk) pk = profile.pk instance = get_object_or_404(Profile, pk=pk) serializer = UserProfileSerializer(instance, data=request.data, partial=True) try: 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) except Exception: strerr = "Erreur put profile : [{}] [{}]".format( sys.exc_info()[0], sys.exc_info()[1]) return Response(strerr, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = AvatarSerializer(data=request.data) if serializer.is_valid(): profile = request.user.userprofile if 'avatar' in serializer.data: curr_avatar = profile.avatar if curr_avatar.name != 'no-avatar.svg': profile.avatar.delete() _handle_avatar_upload(request.FILES['avatar'], profile) serializer_out = UserProfileSerializer(profile) return Response(serializer_out.data, status=status.HTTP_201_CREATED)
def authenticate_user(email, password,request=None): user = User.objects.get(email=email) user = authenticate(email=email,password=password) if user: seralizer=UserProfileSerializer(user,data=request.DATA) seralizer_dict=seralizer.data seralizer_dict["message"]="Login Successful" return Response(seralizer_dict, status=status.HTTP_200_OK) else: return Response( messages.INVALID_EMAIL_OR_PASSWORD, status=status.HTTP_401_UNAUTHORIZED)
def test_get_includes_expected_fields(self): """ GET requests should include url, user, created_date, slug, picture, website, and about_me fields. """ serializer = UserProfileSerializer(self.profile, context=self.context) expeted_fields = ['url', 'user', 'created_date', 'slug', 'website', 'about_me'] for field in expeted_fields: self.assertIn(field, serializer.data)
def current(self, request, pk=None): """get the current user profile data for an authenticated user""" user = request.user if user: #just make sure we have data for the user here serializer = UserProfileSerializer(user) return Response(serializer.data, HTTP_200_OK) else: return Response("userProfile not found", HTTP_404_NOT_FOUND)
def post(self, request, format=None): userprofile_serializer = UserProfileSerializer(data=request.DATA) reg_serializer = RegistrationSerializer(data=request.DATA) if 'device' in request.DATA: phone_serializer = DeviceSerializer(data=request.DATA['device']) else: phone_serializer = DeviceSerializer(data=request.DATA) errors = {} if userprofile_serializer.is_valid() and reg_serializer.is_valid() and phone_serializer.is_valid(): user = reg_serializer.save() data = reg_serializer.data phone = phone_serializer.object phone.user = user phone_serializer.save() data.update(phone_serializer.data) user_profile = userprofile_serializer.object user_profile.user = user userprofile_serializer.save() data.update(userprofile_serializer.data) # trigger user activation to send welcome email signals.user_activated.send(sender=self.__class__, user=user, request=request) # return the right client client = Client.objects.get(pk=1) data.update({'client_id': client.client_id, 'client_secret': client.client_secret}) return Response(data, status=status.HTTP_201_CREATED) errors.update(reg_serializer.errors) errors.update(phone_serializer.errors) errors.update(userprofile_serializer.errors) return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def userinfo(request, id=None): if request.method == 'GET': if not id: id = request.user.id base_user = User.objects.filter(pk=id) if not base_user: return generate_response(message="No such user", status=status.HTTP_400_BAD_REQUEST) serializer = UserProfileSerializer(base_user[0]) return generate_response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, pk): # get profile if pk == "": profile = get_object_or_404(Profile, uzer_id=request.user.pk) pk = profile.pk instance = get_object_or_404(Profile, pk=pk) serializer = UserProfileSerializer(instance) try: return Response(serializer.data) except Exception: strerr = "Erreur get profile : [{}] [{}]".format( sys.exc_info()[0], sys.exc_info()[1]) return Response(strerr, status=status.HTTP_400_BAD_REQUEST)
def search_user(request): username = request.data.get("username") password = request.data.get("password") if User.objects.filter(password=password, username=username).exists(): user = User.objects.get(password=password, username=username) user_profile = UserProfile.objects.get(user=user) data = { **UserSerializer(user).data, **UserProfileSerializer(user_profile).data } return Response(data, status=status.HTTP_200_OK) else: return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None): user = request.user try: profile = UserProfile.objects.get(user=user) serializer = UserProfileSerializer(profile) return Response(serializer.data, status=status.HTTP_200_OK) except UserProfile.DoesNotExist: serializer = UserProfileSerializer(data=request.data) if serializer.is_valid(): serializer.save(user=request.user) _create_default_labels(request.user) _create_customer_profile(request.user) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): try: user = User.objects.create_user( username=request.POST.get('username'), first_name=request.POST.get('first_name'), last_name=request.POST.get('last_name'), email=request.POST.get('email'), password=request.POST.get('password'), ) profile = UserProfile.objects.create( user=user, avatar=request.FILES.get('avatar') ) serializer = UserProfileSerializer( profile, context={'request': request}) return Response({'user': serializer.data}) except Exception as e: return Response({'message': 'Fail to register an user.'})
def post(self, request): try: user = authenticate( request=request, username=request.POST.get('username'), password=request.POST.get('password') ) if user: login( request, user ) try: profile = user.userprofile serializer = UserProfileSerializer( profile, context={'request': request}) return Response({'user': serializer.data}) except AttributeError: return Response({'message': 'wat'}) return Response({'message': 'Error on log in'}) except User.DoesNotExist: return Response({'message': 'User dows not exist'})
def jwt_response_payload_handler(token, user=None, request=None): try: userdetail = applyApplication.objects.get(id=user.id) userProject = 0 for project in Project.objects.all(): for member in project.members.all(): if member.id == user.id: userProject = Project.objects.get(id=project.id) break except: return { 'token': token, 'user': UserSerializer(user, context={'request': request}).data, } return { 'token': token, 'user': UserSerializer(user, context={'request': request}).data, 'userdetail':UserProfileSerializer(userdetail, context={'request':request}).data, 'userproject':ProjectSerializer(userProject, context={'request':request}).data }
def get(self, request): user = request.user search = request.query_params print(search) if (user.is_staff == 1): query_set = User.objects.all() if ('first_name' in search): query_set = query_set.filter( first_name__icontains=search['first_name'].strip('"')) if ('last_name' in search): query_set = query_set.filter( last_name__icontains=search['last_name'].strip('"')) if ('dob_before' in search): query_set = query_set.filter(dob__lte=search['dob'].strip('"')) if ('dob_after' in search): query_set = query_set.filter(dob__gte=search['dob'].strip('"')) if ('is_staff' in search): query_set = query_set.filter( is_staff__iexact=search['is_staff'].strip('"')) if ('is_driver' in search): query_set = query_set.filter() if query_set: #we got data serializer = UserProfileSerializer(query_set, many=True) print(serializer) return Response(serializer.data, HTTP_200_OK) else: return Response("no users found", HTTP_404_NOT_FOUND)
def get(self, request): user_profiles = UserProfile.objects.all()[:20] data = UserProfileSerializer(user_profiles, many=True).data return Response(data)