def perform_update(self, serializer): if serializer.is_valid(raise_exception=True): date = serializer.validated_data.get('date') if date: log = TimeLog.objects.get(id=self.kwargs['pk']) logs_for_date = TimeLog.objects.filter( date=date, created_by=self.request.user).first() if date > datetime.date.today(): data = { "success": False, "message": "Sorry, future date not allowed" } raise ValidationError(data) if logs_for_date: if logs_for_date != log: if (logs_for_date.created_by == log.created_by): data = { "success": False, "message": f"You've already logged time for {date}" } raise ValidationError(data) serializer.save()
def validate_participant_list(self, participant_list=list()): if not isinstance(participant_list, list): raise ValidationError("Invalid participant_list data type. " "Need list.") for email in participant_list: if not User.objects.filter(email=email).exists(): raise ValidationError(f"No user with email {email} exists.")
def validate(self, attrs): # print(self.initial_data) postMethod = self.initial_data.get("postMethod") dataType = self.initial_data.get("dataType") attr = self.initial_data.get("attr") if postMethod == "" or postMethod == None: raise ValidationError("请求方法必须填写") if dataType == "" or dataType == None: raise ValidationError("请求数据类型必须填写") if attr == "" or attr == None: raise ValidationError("请求地址必须填写") # addEnv=self.initial_data["addEnv"] #如果允许变量名称重复 就把这个判断去掉 # Env_list=json.loads(addEnv)["keys"] # for item in Env_list: # key=item["name"] # envId=item["envId"] # obj=projectModels.Environments.objects.get(id=envId).value # obj=json.loads(obj) # keys_list=list(map(lambda x:list(x.keys())[0],obj)) # if key in keys_list: # raise ValidationError("%s:变量名已存在"%key) # if attrs.get("headers") == "": # raise ValidationError("请求类型为必须填写") # if attrs.get("data")=="": # raise ValidationError("请求类型为必须填写") return attrs
def to_internal_value(self, data): if type(data) != list: raise ValidationError('a list of strings is required') if data: if not all(isinstance(x, str) for x in data): raise ValidationError('a list of strings is required') return data
def get(self, request, *args, **kwargs): coupon_code = request.GET.get("promo_code") user_id = request.GET.get("user_id") try: # user_id = int(request.POST['id']) user = User.objects.get(id=user_id) except User.DoesNotExist: content = {'errors': 'user id not exist'} raise ValidationError(content) # raise ValidationError(status) # user = User.objects.get(username=request.user.username) # user = User.objects.get(id=user_code) # user = User.objects.first() status = validate_coupon(coupon_code=coupon_code, user=user) if status['valid']: coupon = Coupon.objects.get(code=coupon_code) coupon.use_coupon(user=user) # return HttpResponse("OK") # return Response({'some': 'data'}) return Response(status) raise ValidationError(status) return HttpResponse(status['message']) # class MyOwnView(APIView): # def get(self, request): # return Response({'some': 'data'})
def get_queryset(self): params = self.request.query_params # breakpoint() user_id = params.get('user_id') status = params.get('status') if user_id and status: if User.objects.filter(id=user_id).exists(): queryset = Dispute.objects.filter(user_id=user_id).filter(status=status) else: content = {'errors': 'user id not exist'} raise ValidationError(content) elif user_id: if User.objects.filter(id=user_id).exists(): queryset = Dispute.objects.filter(user_id=user_id) else: content = {'errors': 'user id not exist'} raise ValidationError(content) elif status: if Dispute.objects.filter(status=status).exists(): queryset = Dispute.objects.filter(order_status=status) else: content = {'errors': 'Order status not exist'} raise ValidationError(content) else: queryset = Dispute.objects.all() return queryset
def to_internal_value(self, value): if not isinstance(value, dict): raise ValidationError({ 'expected dict, got {value}'.format( value=value.__class__.__name__) }) taganomy_id = value.pop('taganomy_id', None) tags = value.pop('tags', None) # Perform the data validation. if taganomy_id is None: raise ValidationError({'id': 'This field is required.'}) try: taganomy_inst = Taganomy.objects.get(id=taganomy_id) except: raise ValidationError({'id': 'Invalid Taganomy instance'}) if tags is None: raise ValidationError({'tags': 'This field is required.'}) tags = super(TaganomySerializerField, self).to_internal_value(tags) out = dict(taganomy=taganomy_inst, tags=tags) return out
def get(self, request, *args, **kwargs): permissions = ['product.view_commodityforstate'] if utils.check_permission(request=self.request, permissions=permissions): get_parameter = self.request.query_params.get('state') if get_parameter: try: commodity_state_list = models.CommodityForState.objects.filter(state_id=get_parameter) data = [] for commodity_state in commodity_state_list: data.append({ 'id': commodity_state.pk, 'metal': commodity_state.metal.name, 'metal_category': commodity_state.metal_category.name, 'purity': [purity.name for purity in commodity_state.metal_purity.all()], 'is_active': commodity_state.is_active }) except Exception as e: raise ValidationError(detail=e) else: state_id_list = models.CommodityForState.objects.values('state_id').distinct() state_queryset = models.State.objects.filter(id__in=state_id_list).order_by('state_name') data = [] for state in state_queryset: data.append( { "id": state.pk, "state": state.state_name } ) if not data: raise ValidationError(detail={'details': "Wrongly Queried."}) return Response(data=data, status=status.HTTP_201_CREATED)
def create(self, validated_data): inviting_user = validated_data['inviting_user'] invited_user = validated_data['invited_user'] if self.context['request'].user.id != inviting_user.id: raise ValidationError('You can only send invites as yourself!') validate_not_equal( inviting_user.id, invited_user.id, 'The fields inviting_user and invited_user cannot be the same.') try: FriendInvitation.objects.get(invited_user=inviting_user, inviting_user=invited_user) raise ValidationError( 'Invited user already sent invitation to you.') except FriendInvitation.DoesNotExist: pass friend_invitation = FriendInvitation.objects.create(**validated_data) NotificationSender().send_notification( user_id=invited_user.id, title='Zaproszenie do znajomych', message=f'Użytkownik {inviting_user.username} ' f'zaprasza Cię do swojego grona znajomych!') return friend_invitation
def create(self, validated_data): email = validated_data['email'] validation = verify_email(email) if validation.get('result') != 'deliverable': if validation.get('errors'): logging.error(f'Hunter.io: {validation}') else: logging.error( f'{email} is invalid. Status: {validation.get("result")}') raise ValidationError(validation) logging.info(f'{email} is valid') user = User.objects.create(email=email, username=validated_data['username']) user.set_password(validated_data['password']) user.save() try: data = get_clearbit_data(email) except HTTPError: logging.error(f'Clearbit data error for {email}') raise ValidationError('Invalid email') Account.objects.create(user=user, **data) logging.info(f'Account for {email} was created') return user
def view_invoice_for_payment(request, invoice_id): user_id = request.query_params.get('user_id', None) if user_id is None: raise ValidationError('The request made to this server was bad') if request.user.is_authenticated and request.user.user_id == user_id: raise ValidationError('The request made to this server was bad') data = OrderedDict() queryset = getattr(settings, 'AUTH_USER_MODEL') #user = get_object_or_404(queryset, user_id=user_id) try: user = get_user_model().objects.get(user_id=user_id) invoice = get_object_or_404(Invoice, invoice_id=invoice_id) except get_user_model().DoesNotExist: raise ValidationError('The request made to this server was bad') except Invoice.DoesNotExist: raise ValidationError('The request made to this server was bad') user_detail = { 'business_name': user.buiness_info.business_name, 'business_number': user.buiness_info.business_number, 'business_address': user.buiness_info.business_address, 'business_email': user.email } invoice_detail = InvoiceSerializer(instance=invoice).data data['user'] = user_detail data['invoice_detail'] = invoice_detail return Response(data)
def validate(self, data): user_obj = None username = data.get('username') password = data['password'] if not username: raise ValidationError("A username must exist to login") user = User.objects.filter(Q(username=username)).distinct() if user.exists() and user.count() == 1: user_obj = user.first() else: raise ValidationError("Username is not valid") if user_obj: if not user_obj.check_password(password): raise ValidationError("Incorrect credentials try again") data["token"] = "Random" # username = validated_data['username'] # email = validated_data['email'] # password = validated_data['password'] # # user_obj = User( username = username , email = email) # user_obj.setpassword(password) # user_obj.save() return data
def validate_location(self, location=None): if location: if not isinstance(location, int): raise ValidationError("Invalid location data type. Need int.") if not ConferenceRoom.objects.filter(id=location).exists(): raise ValidationError("No such conference room.") return location
def create(self, validated_data): user = self.context['request'].user invited_user = validated_data['invited_user'] event_date = validated_data['event_date'] if not isinstance(user, UserProfile): raise ValidationError( 'You have to be logged in in order to invite to meeting!') if MeetingInvitation.objects.filter(inviting_user=user, invited_user=invited_user, event_date=event_date): raise ValidationError( 'Meeting invitation from you to this person for this date has already been sent!' ) meeting_invitation = MeetingInvitation.objects.create( **validated_data, inviting_user=user) if user.id != invited_user.id: NotificationSender().send_notification( user_id=invited_user.id, title='Zaproszenie na spotkanie', message=f'Użytkownik {user.username} ' f'zaprasza Cię na spotkanie. Zobacz szczegóły w aplikacji.') return meeting_invitation
def __call__(self, value, *args, **kwargs): _split_number = value.split('-') if len(_split_number) != 3: raise ValidationError(self._message) elif _split_number[0] != '010' or len(_split_number[1]) != 4 or len( _split_number[2]) != 4: raise ValidationError(self._message)
def __call__(self, value): try: customer = Customer.objects.get( cbs_customer_number=value['customer']['cbs_customer_number']) except Customer.DoesNotExist: raise ValidationError("Incorrect CBS customer number.") if customer.type != self._required_type: raise ValidationError("Incorrect customer type.")
def to_internal_value(self, data): if not isinstance(data, str): raise ValidationError("This value needs to be the owner ID") try: return User.objects.get(username=data) except User.DoesNotExist: raise ValidationError("This user does not exist!")
def __call__(self, value, *args, **kwargs): if self._is_sufficiently_long(value) is False: raise ValidationError( 'Password must be at least 8 characters long') if self._does_contain_number(value) is False: raise ValidationError('Password must contain number(s)') if self._does_contain_uppercase(value) is False: raise ValidationError('Password must contain uppercase(s)')
def validate(self, attrs): cron = attrs.get("cron") name = attrs.get("taskName") rep = self.CronValid(cron) if int(rep["status"]) != 1: raise ValidationError("Cron表达式错误") if len(PeriodicTask.objects.filter(name=name)) > 1: raise ValidationError("任务名称重复") return attrs
def validate(self, data): model_class = self._get_model_class(data) if model_class is None: raise ValidationError( {'content_type': 'Content type does not exists.'}) liked_object = model_class.objects.filter(id=data['object_id']).first() if not liked_object: raise ValidationError({"object_id": "Object does not exists."}) return data
def clean(self, *args, **kwargs): if self.end < self.start: raise ValidationError( {'end': ["The meeting cannot end before it " "was started."]}) if self.end - self.start > timezone.timedelta(hours=8): raise ValidationError( {'end': ["The meeting cannot be longer than " "8 hours."]}) super(Event, self).clean(*args, **kwargs)
def to_internal_value(self, data): if isinstance(data, dict): return data if '/' not in data: raise ValidationError("protocol not contain /: {}".format(data)) v = data.split("/") if len(v) != 2: raise ValidationError("protocol format should be name/port: {}".format(data)) name, port = v cleaned_data = {"name": name, "port": port} return cleaned_data
def validate(self, value): remote_oj = value['remote_oj'] remote_id = value['remote_id'] language = value['language'] if Problem.objects.filter(remote_oj=remote_oj, remote_id=remote_id).exists() is False: raise ValidationError('problem not exist') if Language.objects.filter(oj_name=remote_oj, oj_language=language).exists() is False: raise ValidationError('language not exist') return value
def validate_email(self, email): user = self.context['request'].user if user.email == email: raise ValidationError('Cannot change to the same email.') if User.objects.exclude(id=user.id).filter(email=email).exists(): raise ValidationError( 'Another account already exists with this email.') return email
def perform_create(self, serializer): try: report = Report.objects.get(pk=self.kwargs["report_pk"]) if report.patient != self.request.user: raise ValidationError("Not Found") except Exception as e: raise ValidationError("Not Found") doctor = serializer.validated_data["doctor"] if not doctor.is_doctor: raise ValidationError("Not Found") serializer.save(assign_report=report)
def perform_create(self, serializer): try: report = Report.objects.get(pk=self.kwargs["report_pk"]) if report.patient != self.request.user: raise ValidationError("Not Found") except Exception as e: raise ValidationError("Not Found") result = get_cancer_name() # skin_image = serializer.validated_data["skin_image"] serializer.save(web_opinion=result, report=report)
def likes_analytics(request, *args, **kwargs): query_params = request.query_params if 'date_from' not in query_params: raise ValidationError({'date_from': 'This parameter is required'}) if 'date_to' not in query_params: raise ValidationError({'date_to': 'This parameter is required'}) date_from = date.fromisoformat(query_params.get('date_from')) date_to = date.fromisoformat(query_params.get('date_to')) likes = LikesByDay.objects.filter(date__gte=date_from, date__lte=date_to) serializer = LikesCountByDaySerializer(likes, many=True) return Response({'dates': serializer.data}, status=200)
def validate(self, attrs): try: uid = force_text(urlsafe_base64_decode(attrs['uid'])) self.user = User.objects.get(pk=uid) except (ValueError, User.DoesNotExist): raise ValidationError({'uid': ['Invalid value']}) if attrs['password1'] != attrs['password2']: raise ValidationError({'password2': ['Passwords do not match']}) validate_password(attrs['password2'], self.user) if not default_token_generator.check_token(self.user, attrs['token']): raise ValidationError({'token': ['Invalid value']}) return attrs
def __call__(self, data, serializer_field): from_owner = getattr(serializer_field.parent.context['request'], 'user') if self.m2m: for i in data: if getattr(i, self.to_owner_field) != from_owner: raise ValidationError('不允许关联他人的%s' % serializer_field.source_attrs[-1]) else: if getattr(data, self.to_owner_field) != from_owner: raise ValidationError('不允许关联他人的%s' % serializer_field.source_attrs[-1])
def __call__(self, data, serializer_field): num = len(data) if self.min_num is not None: if num < self.min_num: raise ValidationError( '%s关联不得少于%d个' % (serializer_field.source_attrs[-1], self.min_num)) if self.max_num is not None: if num > self.max_num: raise ValidationError( '%s关联不得多于%d个' % (serializer_field.source_attrs[-1], self.max_num))