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