def test_update_user(self): self.test_create_user() username_to_update = 'updatedUserSerializer' first_name_to_update = "UpdatedUser" last_name_to_update = "UsingSerializer2" user_data_to_update = { 'username': username_to_update, 'email': self.email, 'password': '******', 'first_name': first_name_to_update, 'last_name': last_name_to_update, "profile": { "role": Profile.PHYSICIAN } } user_in_database = User.objects.get(email=self.email) user_serialized = UserSerializer(instance=user_in_database, data=user_data_to_update) user_serialized_valid = user_serialized.is_valid() user_created = user_serialized.save() user_in_database_after_updated = User.objects.get(email=self.email) self.assertTrue(user_serialized_valid) self.assertEquals(user_in_database_after_updated, user_created) self.assertEquals(user_in_database_after_updated.username, username_to_update) self.assertEquals(user_in_database_after_updated.first_name, first_name_to_update) self.assertEquals(user_in_database_after_updated.last_name, last_name_to_update)
def register(self, request): ''' Allows users to register themselves. Being then put on a waiting list to be approved. ''' if request.user.is_authenticated(): return Response( { 'error': "An already registered user can't register new users!" }, status.HTTP_400_BAD_REQUEST) dataRequest = request.data.copy() password = dataRequest.pop('password', None) email = dataRequest.get('email', None) if email != None and password != None: email = email.lower() try: user = User.objects.get(email=email) return Response( {'error': "An user with this email already exists"}, status=status.HTTP_400_BAD_REQUEST) except User.DoesNotExist: if (not 'username' in dataRequest): dataRequest['username'] = email[:30] dataRequest['email'] = email serializer = UserSerializer(data=dataRequest, context={'request': request}) user_validated = serializer.is_valid(raise_exception=True) if user_validated: new_user = serializer.save() new_user.set_password(password) new_user.is_active = False new_user.save() staff = User.objects.filter(is_staff=True) History.new(event=History.ADD, actor=new_user, object=new_user, authorized=staff) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response({'error': "User details invalid"}, status=status.HTTP_400_BAD_REQUEST) return Response( { 'error': "Email and password are mandatory fields on registering a new user" }, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() # generating tokens for the user if user: token = Token.objects.create(user=user) json = serializer.data json['token'] = token.key print(token) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs): form = FileSerializer(data=request.data) if form.is_valid(): input = form.save() path = os.path.join(settings.MEDIA_ROOT, str(input.file)) workbook = xlrd.open_workbook(filename=path) sheet = workbook.sheet_by_index(0) if sheet.nrows < 2: return Response({'message': 'There is no users in file'}, status=status.HTTP_400_BAD_REQUEST) else: for i in range(2, sheet.nrows): student_id = sheet.cell(i, 0).value last_name = sheet.cell(i, 1).value first_name = sheet.cell(i, 2).value major_string = sheet.cell(i, 4).value email = sheet.cell(i, 6).value if major_string.lower().strip() == 'программная инженерия': major = Major.SE.name else: major = Major.AMI.name username = email.split("@")[0].strip() data = { 'username': username, 'first_name': first_name, 'last_name': last_name, 'email': email, 'password': student_id, } serialized = UserSerializer(data=data) if serialized.is_valid(): user = serialized.save() response = serialized.data UserPreferences.objects.create( user=user, user_preference=Preference.STUDENT.name ) UserMajor.objects.create( user=user, user_major=major ) Mark.objects.create(user=user, first_name=user.first_name, second_name=user.last_name, major=major) UserStudentID.objects.create(user=user, student_id=student_id) del response['password'] del response['first_name'] del response['last_name'] return Response({"status": "OK"}, status=status.HTTP_201_CREATED)
class ReviewReadSerializer(serializers.ModelSerializer): user = UserSerializer() book = BookWriteSerializer() class Meta: model = Review fields = '__all__'
def login(self, request): serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response( { "success": False, "massage": "Please check input.", "errors": serializer.errors, }, status=400) #validation ok , login username = serializer.validated_data['username'] password = serializer.validated_data['password'] if not User.objects.filter(username=username).exists(): return Response( { "success": False, "massage": "User does not exists." }, status=400) user = django_authenticate(username=username, password=password) if not user or user.is_anonymous: return Response( { "success": False, "massage": "Username and password does not match.", }, status=400) django_login(request, user) return Response({ "success": True, "user": UserSerializer(instance=user).data })
def get_all_user_api_view(request): try: users = User.objects.all() profile = Profile.objects.all() except ObjectDoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) staff_user = request.user.is_staff admin_user = request.user.is_admin if not staff_user and not admin_user: return Response( {'Response': 'You do not have the permission to view this'}) if request.method == 'GET': user_serializer = UserSerializer(users, many=True) profile_serializer = ProfileSerializer(profile, many=True) return JsonResponse( { 'users': user_serializer.data, 'profile': profile_serializer.data }, safe=False, status=status.HTTP_200_OK)
def login(self, request): # get username and password from request # data就是用户post的request中的数据 # check request serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): # 如果登录出错 return Response( { "success": False, "message": "Please check input.", "errors": serializer.errors, }, status=400) # validation ok # check password username = serializer.validated_data['username'] password = serializer.validated_data['password'] user = django_authenticate(username=username, password=password) if not user or user.is_anonymous: return Response( { "success": False, "message": "Username and password does not match.", }, status=400) # login django_login(request, user) return Response({ "success": True, "user": UserSerializer(user).data, })
def signup(self, request): """ username, email, password to signup :param request: :return: """ serializer = SignupSerializer(data=request.data) if not serializer.is_valid(): return Response( { 'success': False, 'message': "Please check input", 'errors': serializer.errors, }, status=400) user = serializer.save() # create UserProfile object user.profile django_login(request, user) return Response({ 'success': True, 'user': UserSerializer(user).data, })
def create(self, request): serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response( { 'success': False, 'message': 'Please check input', 'errors': serializer.errors, }, status=400) username = serializer.validated_data['username'] password = serializer.validated_data['password'] user = authenticate(username=username, password=password) if not user or user.is_anonymous: return Response( { 'success': False, 'message': 'username and password does not match', }, status=400) login(request, user) return Response({ 'success': True, 'user': UserSerializer(user).data, })
def get(self,request,event_id,format=None): # 'event_id'is passed as extra arguement to get()-->check url event_id=self.kwargs['event_id'] event_object=get_object_or_404(Event,id=event_id)#to check event exists print(event_object) #below query will return only one object if it exists try: highest_bid_object=Bid.objects.filter(event_id=event_id).order_by("-bid_price")[0:1].get() if request.user.is_staff: #admin can check details of user placing highest bid at the moment highest_bid_user=User.objects.get(id=highest_bid_object.user_id) user_serializer=UserSerializer(highest_bid_user)#serializing object return Response({"user":user_serializer.data,"highest_bid":highest_bid_object.bid_price}) else: return Response({"user":None,"highest_bid": highest_bid_object.bid_price}) except ObjectDoesNotExist: return Response({"detail":"not bids received for this event"},status=status.HTTP_404_NOT_FOUND)
class FollowingSerializer(serializers.ModelSerializer): user = UserSerializer(source='to_user') created_at = serializers.DateTimeField() class Meta: model = Friendship fields = ('user', 'created_at')
class MessageSerializer(serializers.ModelSerializer): class Meta: model = Message fields = ('id', 'subject', 'body', 'sender', 'recipients', 'parent', 'reply_to', 'sent_at', 'sender_deleted_at', 'created_at', 'updated_at', 'files', 'children', 'has_unread', 'is_unread', 'last_activity', 'quote', 'project', 'type') read_only_fields = ('sender', 'files', 'recipients', 'children', 'has_unread', 'is_unread', 'last_activity', 'quote', 'project', 'type') sender = UserSerializer(read_only=True) files = MessageFileSerializer(many=True, read_only=True) recipients = MessageRecipientSerializer(many=True, read_only=True, source='message_recipients') children = MessageChildrenManyRelatedField( child_relation=MessageChildrenField()) has_unread = fields.SerializerMethodField() is_unread = fields.SerializerMethodField() last_activity = fields.SerializerMethodField() quote = QuoteSerializer(required=False, read_only=True) def get_has_unread(self, obj): return getattr(obj, 'has_unread', None) def get_is_unread(self, obj): return getattr(obj, 'is_unread', None) def get_last_activity(self, obj): return getattr(obj, 'last_activity', None)
def login(self, request): serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response( { 'success': False, 'message': "Please check input", 'errors': serializer.errors, }, status=400) username = serializer.validated_data['username'] password = serializer.validated_data['password'] # queryset = User.objects.filter(username=username) # print(queryset.query) user = django_authenticate(username=username, password=password) if not user or user.is_anonymous: return Response( { 'success': False, 'message': "username and password does not match", }, status=400) django_login(request, user) return Response({ 'success': True, 'user': UserSerializer(instance=user).data })
def login(self, request): serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response( { "success": False, "message": "Input is not valid. Please check input", "errors": serializer.errors, }, status=400) username = serializer.validated_data['username'] password = serializer.validated_data['password'] user = django_authenticate(username=username, password=password) if not user or user.is_anonymous: return Response( { "success": False, "message": "Username and password are not matched. Please try again", }, status=400) django_login(request, user) return Response({ "success": True, "user": UserSerializer(user).data, })
class UserProfileSerializer(serializers.ModelSerializer): user = UserSerializer() class Meta: permission_classes = [permissions.IsAuthenticated] model = Profile exclude = ['id']
class OrderSerializer(serializers.ModelSerializer): items = OrderItemSerializer(many=True, read_only=True) customer = UserSerializer(read_only=True) url = serializers.CharField(source='get_api_url', read_only=True) class Meta: model = BaseOrder fields = ['id', 'url', 'customer', 'total', 'subtotal', 'status', 'is_valid','items']
class QuestionSerializer(serializers.ModelSerializer): answers = AnswerSerializer(many=True, read_only=True) user = UserSerializer(read_only=True) # read only mean class Meta: model = Question fields = "__all__"
def signup(self, request): serializer = SignupSerializer(data=request.data) if not serializer.is_valid(): return Response( { 'success': False, 'message': 'Please check input', 'errors': serializer.errors }, status=400) user = serializer.save() # create a new profile for the new user user.profile # automatically login django_login(request, user) return Response( { 'success': True, 'user': UserSerializer(instance=user).data }, status=201)
def retrieve(self, request, pk=None): if pk == 'i': return Response( UserSerializer(request.user, context={ 'request': request }).data) return super(UserViewSet, self).retrieve(request, pk)
class TweetSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) date_display = serializers.SerializerMethodField() timesince = serializers.SerializerMethodField() parent = ParentTweetModelSerializer(read_only=True) likes = serializers.SerializerMethodField() did_like = serializers.SerializerMethodField() class Meta: model = Tweet fields = [ 'id', 'user', 'content', 'publish', 'date_display', 'timesince', 'parent', 'likes', 'did_like' ] def get_date_display(self, obj): return obj.publish.strftime("%b %d, at %H:%M") def get_timesince(self, obj): return timesince(obj.publish) + " ago" def get_likes(self, obj): return obj.liked.all().count() def get_did_like(self, obj): request = self.context.get("request") user = request.user if user.is_authenticated: if user in obj.liked.all(): return True return False
class ParentTweetSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) date_display = serializers.SerializerMethodField() timesince = serializers.SerializerMethodField() likes = serializers.SerializerMethodField() did_like = serializers.SerializerMethodField() class Meta: model = Tweet fields = ('user', 'content', 'time', 'date_display', 'timesince', 'id', "likes", "did_like") def get_did_like(self, obj): try: request = self.context.get("request") user = request.user if user.is_authenticated: if user in obj.liked.all(): return True return False except: pass def get_date_display(self, obj): return obj.time.strftime("%b %d, %Y | %I:%M %p") def get_timesince(self, obj): return timesince(obj.time) + " ago" def get_likes(self, obj): return obj.liked.all().count()
def my_jwt_response_handler(token, user=None, request=None): return { 'token': token, 'user': UserSerializer(user, context={ 'request': request }).data }
class EventSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) address = serializers.SerializerMethodField() def get_address(self, instance): return "{line1} {line2} {city}-{postalCode}, {country}".format( line1=instance.line1, line2=instance.line2, postalCode=instance.postalCode, city=instance.city, country=instance.country) class Meta: model = EventModel fields = ( 'user', 'id', 'title', 'slug', 'description', 'image', 'company', 'hostName', 'category', 'address', 'date_of_event', ) lookup_field = 'slug' extra_kwargs: {'id': {'lookup_field': 'slug'}} def create(self, validated_data): user = self.context['request'].user return EventModel.objects.create(user=user, **validated_data)
def post(self, request, *args, **kwargs): user = User.get_user_by_uuid(request.user.id) if user: user.first_name = request.data['first_name'] user.last_name = request.data['last_name'] user.bio = request.data['bio'] user.email = request.data['email'] user.setPictureFromRest(request.data['picture']) address = request.data['address'] if address: address = json.loads(address) if address: if len(address) == 5: user.street = address[0] user.city = address[1] user.state = address[2] user.country = address[3] user.zip = int(address[4] or 0) user.save() return Response({ "user": UserSerializer(user, context=self.get_serializer_context()).data, })
def login_status(self, request): # check login status data = {'has_logged_in': request.user.is_authenticated} if request.user.is_authenticated: data['user'] = UserSerializer(request.user).data return Response(data)
class TweetSerializer(serializers.ModelSerializer): user = UserSerializer() comments_count = serializers.SerializerMethodField() likes_count = serializers.SerializerMethodField() has_liked = serializers.SerializerMethodField() class Meta: model = Tweet fields = ( 'id', 'user', 'created_at', 'content', 'comments_count', 'likes_count', 'has_liked', ) def get_likes_count(self, obj): return obj.like_set.count() def get_comments_count(self, obj): return obj.comment_set.count() def get_has_liked(self, obj): return LikeService.has_liked(self.context['request'].user, obj)
def signup(self, request): """ 使用 username, email, password 进行注册 """ # 不太优雅的写法 # username = request.data.get('username') # if not username: # return Response("username required", status=400) # password = request.data.get('password') # if not password: # return Response("password required", status=400) # if User.objects.filter(username=username).exists(): # return Response("password required", status=400) serializer = SignupSerializer(data=request.data) if not serializer.is_valid(): return Response( { 'success': False, 'message': "Please check input", 'errors': serializer.errors, }, status=400) user = serializer.save() # Create UserProfile object user.profile django_login(request, user) return Response({ 'success': True, 'user': UserSerializer(user).data, }, status=201)
def login(self, request): """ 默认的 username 是 admin, password 也是 admin """ serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response( { "success": False, "message": "Please check input", "errors": serializer.errors, }, status=400) username = serializer.validated_data['username'] password = serializer.validated_data['password'] user = django_authenticate(username=username, password=password) if not user or user.is_anonymous: return Response( { "success": False, "message": "username and password does not match", }, status=400) django_login(request, user) return Response({ "success": True, "user": UserSerializer(instance=user).data, })
def login(self, request): serializer = LoginSerializer(data=request.data) if not serializer.is_valid(): return Response({ "success": False, "error": serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) # login username = serializer.validated_data['username'] password = serializer.validated_data['password'] user = django_authenticate(request, username=username, password=password) # username and password not match if not user or user.is_anonymous: return Response( { "success": False, "message": "Username and password not match" }, status=status.HTTP_400_BAD_REQUEST) # valid username and password django_login(request, user) return Response( { "success": True, "user": UserSerializer(instance=user).data, }, status=status.HTTP_200_OK)
def create_users(self): """ Create ordinary Users. """ prompt(_(u'Create the users (%d)' % self._total_users)) for item in RandomItemSupplier(self._total_users): user_serializer = UserSerializer(data=item) if user_serializer.is_valid(): user_data = user_serializer.data user_data['is_staff'] = False user_data['is_active'] = True user_data['password'] = RandomItemSupplier.USER_PASSWORD user = self.create_user_by_api(**user_data) if user: self._users.append(user) item['user'] = user.pk person_serializer = PersonSerializer(data=item) if person_serializer.is_valid(): person_data = person_serializer.data person = self.create_person_by_api(**person_data) if person: self._persons.append(person) info(_(u'Done'))