class ProcessingQueueSerializer(serializers.ModelSerializer):
# Powers the RECAP upload endpoint
uploader = serializers.HiddenField(
default=serializers.CurrentUserDefault(), )
court = serializers.PrimaryKeyRelatedField(
queryset=Court.federal_courts.all(),
html_cutoff=500, # Show all values in HTML view.
)
docket = serializers.HyperlinkedRelatedField(
many=False,
read_only=True,
view_name="docket-detail",
style={"base_template": "input.html"},
)
docket_entry = serializers.HyperlinkedRelatedField(
many=False,
read_only=True,
view_name="docketentry-detail",
style={"base_template": "input.html"},
)
recap_document = serializers.HyperlinkedRelatedField(
many=False,
read_only=True,
view_name="recapdocument-detail",
style={"base_template": "input.html"},
)
class Meta:
model = ProcessingQueue
fields = "__all__"
read_only_fields = (
"error_message",
"status",
"docket",
"docket_entry",
"recap_document",
)
extra_kwargs = {"filepath_local": {"write_only": True}}
def validate(self, attrs):
for attr_name in [
"pacer_doc_id",
"pacer_case_id",
"document_number",
"attachment_number",
]:
# Regardless of upload type, we don't want values to be set to
# "undefined"
if attrs.get(attr_name) == "undefined":
raise ValidationError(
"'%s' field cannot have the literal value 'undefined'." %
attr_name)
if attrs["upload_type"] in [
UPLOAD_TYPE.DOCKET,
UPLOAD_TYPE.APPELLATE_DOCKET,
UPLOAD_TYPE.CLAIMS_REGISTER,
]:
# Dockets shouldn't have these fields completed.
numbers_not_blank = any([
attrs.get("pacer_doc_id"),
attrs.get("document_number"),
attrs.get("attachment_number"),
])
if numbers_not_blank:
raise ValidationError(
"PACER document ID, document number and attachment number "
"must be blank for docket or claims register uploads.")
if attrs["upload_type"] in [
UPLOAD_TYPE.DOCKET,
UPLOAD_TYPE.DOCKET_HISTORY_REPORT,
]:
# These are district court dockets. Is the court valid?
district_court_ids = (
Court.federal_courts.district_pacer_courts().values_list(
"pk", flat=True))
if attrs["court"].pk not in district_court_ids:
raise ValidationError(
"%s is not a district or bankruptcy court ID. Did you "
"mean to use the upload_type for appellate dockets?" %
attrs["court"])
if attrs["upload_type"] == UPLOAD_TYPE.CLAIMS_REGISTER:
# Only allowed on bankruptcy courts
district_court_ids = (
Court.federal_courts.bankruptcy_pacer_courts().values_list(
"pk", flat=True))
if attrs["court"].pk not in district_court_ids:
raise ValidationError(
"%s is not a bankruptcy court ID. Only bankruptcy cases "
"should have claims registry pages." % attrs["court"])
if attrs["upload_type"] == UPLOAD_TYPE.APPELLATE_DOCKET:
# Appellate court dockets. Is the court valid?
appellate_court_ids = (
Court.federal_courts.appellate_pacer_courts().values_list(
"pk", flat=True))
if attrs["court"].pk not in appellate_court_ids:
raise ValidationError(
"%s is not an appellate court ID. Did you mean to use the "
"upload_type for district dockets?" % attrs["court"])
if attrs["upload_type"] == UPLOAD_TYPE.PDF:
# PDFs require pacer_doc_id and document_number values.
if not all(
[attrs.get("pacer_doc_id"),
attrs.get("document_number")]):
raise ValidationError(
"Uploaded PDFs must have the pacer_doc_id and "
"document_number fields completed.")
if attrs["upload_type"] != UPLOAD_TYPE.PDF:
# Everything but PDFs require the case ID.
if not attrs.get("pacer_case_id"):
raise ValidationError(
"PACER case ID is required for for all non-document "
"uploads.")
return attrs
class LikeSerializer(serializers.Serializer):
"""点赞"""
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
like = serializers.BooleanField(required=True)
class CarDetailSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Car
fields = '__all__'
class RoomSerializer(AdminRoomSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class AssetSerializer(ModelSerializer):
class Meta:
model = Asset
fields = ['pk', 'owner', 'balance', 'description', 'name']
owner = serializers.HiddenField(default=serializers.CurrentUserDefault(), )
class DeviceSerializer(serializers.ModelSerializer):
user = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault())
class Meta:
model = DeviceInfo
fields = ('id', 'user', 'device_id', 'push_token', 'is_active')
class CurrentUserSerializer(serializers.ModelSerializer):
usuario = serializers.HiddenField(default=serializers.CurrentUserDefault())
class WithUserImageSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
image = serializers.HiddenField(default=CurrentImageDefault())
class ImageCreateUpdateDestroySerializer(WithCountersSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Image
fields = '__all__'
class ClassRandomNameIforgetHow(serializers.Serializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
email = serializers.Serializer(
label='Введите email',
required=True) #можно много гибких настроек валидации задать.
class ReportUploadViewSerializer(serializers.ModelSerializer):
"""Serializer for the user report upload"""
created_by = serializers.CharField(
default=serializers.CurrentUserDefault())
owned_by = serializers.CharField(default=serializers.CurrentUserDefault())
report_file = serializers.FileField(required=False)
file_data = serializers.DictField(required=False)
class Meta:
model = ReportDumpUploadbkp
fields = (
'report_file',
'file_data',
'created_by',
'owned_by',
)
def create(self, validated_data):
user = self.context['request'].user
created_by = validated_data.get('created_by')
owned_by = validated_data.get('owned_by')
upload_file = validated_data.get('report_file')
file_name = upload_file.name
file_exist = ReportDumpUploadbkp.objects.filter(
user=user, file_name=file_name).exists()
file_data = xml_to_json(upload_file)
file_json = json.loads(file_data)
if file_exist:
raise CustomAPIException(
None,
"Duplicate ! The file with same name is already in data base ",
status_code=status.HTTP_400_BAD_REQUEST)
domain_list = Domains.objects.filter(
tenant__tenantusermapping__user=user).values_list('domain',
flat=True)
in_active_domain_list = Domains.objects.filter(
tenant__tenantusermapping__user=user,
is_active=False).values_list('domain', flat=True)
to_check = file_json['feedback']['policy_published']['domain']
if to_check not in domain_list:
raise CustomAPIException(
None,
"sorry ! Report does not belong to any of registered domain" +
" please add " + to_check + " to upload this report",
status_code=status.HTTP_400_BAD_REQUEST)
elif to_check in in_active_domain_list:
raise CustomAPIException(
None,
"sorry ! registered domain is not active " +
"please run domain status check on " + to_check +
" to upload this report",
status_code=status.HTTP_400_BAD_REQUEST)
with transaction.atomic():
ReportDumpUploadbkp.objects.create(user=user,
data=file_json,
file_name=file_name,
created_by=created_by,
owned_by=owned_by)
meta_data_report = ReportFeedbackMetaData.objects.create(
user=user,
org_name=file_json['feedback']['report_metadata']['org_name'],
email=file_json['feedback']['report_metadata']['email'],
extra_contact_info=file_json['feedback']['report_metadata']
['extra_contact_info'] if 'extra_contact_info'
in file_json['feedback']['report_metadata'] else None,
report_id=file_json['feedback']['report_metadata']
['report_id'],
begin=datetime.fromtimestamp(
int(file_json['feedback']['report_metadata']['date_range']
['begin'])),
end=datetime.fromtimestamp(
int(file_json['feedback']['report_metadata']['date_range']
['end'])),
domain=file_json['feedback']['policy_published']['domain'],
adkim=file_json['feedback']['policy_published']['adkim'],
aspf=file_json['feedback']['policy_published']['aspf'],
p=file_json['feedback']['policy_published']['p'],
sp=file_json['feedback']['policy_published']['sp']
if 'sp' in file_json['feedback']['policy_published'] else None,
pct=file_json['feedback']['policy_published']['pct'],
created_by=created_by,
owned_by=owned_by)
records = file_json['feedback']['record']
if isinstance(records, (list)):
for record in records:
try:
rev_name = reversename.from_address(
record['row']['source_ip'])
reversed_dns = str(resolver.query(rev_name, "PTR")[0])
except Exception:
reversed_dns = record['row']['source_ip']
records_created = ReportFeedbackRecord.objects.create(
meta_report=meta_data_report,
source_ip=record['row']['source_ip'],
ip_name=reversed_dns,
count=record['row']['count'],
disposition=record['row']['policy_evaluated']
['disposition'],
dkim=record['row']['policy_evaluated']['dkim'],
spf=record['row']['policy_evaluated']['spf'],
header_from=record['identifiers']['header_from']
if 'header_from' in record['identifiers'] else None,
envelope_from=record['identifiers']['envelope_from']
if 'envelope_from' in record['identifiers'] else None,
)
auth_dkim = record['auth_results'][
'dkim'] if 'dkim' in record['auth_results'] else None
auth_spf = record['auth_results'][
'spf'] if 'spf' in record['auth_results'] else None
if auth_dkim:
if isinstance(auth_dkim, (list)):
for au_dkim in auth_dkim:
ReportFeedbackRecordAuthResultsDkim.objects.\
create(
record=records_created,
domain=au_dkim[
'domain'
] if 'domain' in au_dkim else None,
selector=au_dkim[
'selector'
] if 'selector' in au_dkim else None,
result=au_dkim[
'result'
] if 'result' in au_dkim else None,
created_by=created_by,
owned_by=owned_by
)
else:
ReportFeedbackRecordAuthResultsDkim.objects.create(
record=records_created,
domain=auth_dkim['domain']
if 'domain' in auth_dkim else None,
selector=auth_dkim['selector']
if 'selector' in auth_dkim else None,
result=auth_dkim['result']
if 'result' in auth_dkim else None,
created_by=created_by,
owned_by=owned_by)
if auth_spf:
if isinstance(auth_spf, (list)):
for au_spf in auth_spf:
ReportFeedbackRecordAuthResultsSpf.objects.\
create(
record=records_created,
domain=au_spf[
'domain'
] if 'domain' in au_spf else None,
scope=au_spf[
'scope'
] if 'scope' in au_spf else None,
result=au_spf[
'result'
] if 'result' in au_spf else None,
created_by=created_by,
owned_by=owned_by
)
else:
ReportFeedbackRecordAuthResultsSpf.objects.create(
record=records_created,
domain=auth_spf['domain']
if 'domain' in auth_spf else None,
scope=auth_spf['scope']
if 'scope' in auth_spf else None,
result=auth_spf['result']
if 'result' in auth_spf else None,
created_by=created_by,
owned_by=owned_by)
else:
try:
rev_name = reversename.from_address(
records['row']['source_ip'])
reversed_dns = str(resolver.query(rev_name, "PTR")[0])
except Exception:
reversed_dns = records['row']['source_ip']
records_created = ReportFeedbackRecord.objects.create(
meta_report=meta_data_report,
source_ip=records['row']['source_ip'],
ip_name=reversed_dns,
count=records['row']['count'],
disposition=records['row']['policy_evaluated']
['disposition'],
dkim=records['row']['policy_evaluated']['dkim'],
spf=records['row']['policy_evaluated']['spf'],
header_from=records['identifiers']['header_from']
if 'header_from' in records['identifiers'] else None,
envelope_from=records['identifiers']['envelope_from']
if 'envelope_from' in records['identifiers'] else None,
)
auth_dkim = records['auth_results'][
'dkim'] if 'dkim' in records['auth_results'] else None
auth_spf = records['auth_results']['spf'] if 'spf' in records[
'auth_results'] else None
if auth_dkim:
if isinstance(auth_dkim, (list)):
for au_dkim in auth_dkim:
ReportFeedbackRecordAuthResultsDkim.objects.create(
record=records_created,
domain=au_dkim['domain']
if 'domain' in au_dkim else None,
selector=au_dkim['selector']
if 'selector' in au_dkim else None,
result=au_dkim['result']
if 'result' in au_dkim else None,
created_by=created_by,
owned_by=owned_by)
else:
ReportFeedbackRecordAuthResultsDkim.objects.create(
record=records_created,
domain=auth_dkim['domain']
if 'domain' in auth_dkim else None,
selector=auth_dkim['selector']
if 'selector' in auth_dkim else None,
result=auth_dkim['result']
if 'result' in auth_dkim else None,
created_by=created_by,
owned_by=owned_by)
if auth_spf:
if isinstance(auth_spf, (list)):
for au_spf in auth_spf:
ReportFeedbackRecordAuthResultsSpf.objects.create(
record=records_created,
domain=au_spf['domain']
if 'domain' in au_spf else None,
scope=au_spf['scope']
if 'scope' in au_spf else None,
result=au_spf['result']
if 'result' in au_spf else None,
created_by=created_by,
owned_by=owned_by)
else:
ReportFeedbackRecordAuthResultsSpf.objects.create(
record=records_created,
domain=auth_spf['domain']
if 'domain' in auth_spf else None,
scope=auth_spf['scope']
if 'scope' in auth_spf else None,
result=auth_spf['result']
if 'result' in auth_spf else None,
created_by=created_by,
owned_by=owned_by)
validated_data.pop('report_file')
validated_data['file_data'] = file_json
return validated_data
class UserAddressSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = UserAddress
fields = '__all__'
class BookSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Book
fields = ('title', 'category', 'status', 'availability', 'owner')
class PipelineItemSerializer(serializers.ModelSerializer):
"""Serialiser for pipeline item."""
default_error_messages = {
'archived_company':
gettext_lazy("An archived company can't be added to the pipeline."),
'field_cannot_be_updated':
gettext_lazy('field not allowed to be update.'),
'field_cannot_be_empty':
gettext_lazy('This field may not be blank.'),
'field_is_required':
gettext_lazy('This field is required.'),
}
company = NestedRelatedField(
Company,
# If this list of fields is changed, update the equivalent list in the QuerySet.only()
# call in the queryset module
extra_fields=('name', 'turnover', 'export_potential'),
)
adviser = serializers.HiddenField(default=serializers.CurrentUserDefault())
sector = NestedRelatedField(
metadata_models.Sector,
extra_fields=('id', 'segment'),
required=False,
allow_null=True,
)
contacts = NestedRelatedField(
Contact,
many=True,
extra_fields=('id', 'name'),
required=False,
allow_null=True,
)
def validate_company(self, company):
"""Make sure company is not archived"""
if company.archived:
raise serializers.ValidationError(
self.error_messages['archived_company'], )
return company
def validate_name(self, name):
"""Make sure name is not blank"""
if not name:
raise serializers.ValidationError(
self.error_messages['field_cannot_be_empty'], )
return name
def validate(self, data):
"""
Raise a validation error if:
- anything else other than allowed fields is updated.
- name field is empty when editing.
- contact doesn't belong to the company being added
"""
if self.instance is None:
if (data.get('name') in (None, '')):
raise serializers.ValidationError(
self.error_messages['field_is_required'], )
if self.partial and self.instance:
allowed_fields = {
'status',
'name',
'contacts',
'sector',
'potential_value',
'likelihood_to_win',
'expected_win_date',
'archived',
'archived_on',
'archived_reason',
}
fields = data.keys()
extra_fields = fields - allowed_fields
if extra_fields:
errors = {
field: self.error_messages['field_cannot_be_updated']
for field in extra_fields
}
raise serializers.ValidationError(errors)
return data
def update(self, instance, validated_data):
"""
Update modified_on field with current date time
during PATCH transactions
"""
if self.partial and self.instance:
self.instance.modified_on = now().isoformat()
return super().update(instance, validated_data)
class Meta:
model = PipelineItem
fields = (
'id',
'company',
'name',
'status',
'adviser',
'created_on',
'modified_on',
'contacts',
'sector',
'potential_value',
'likelihood_to_win',
'expected_win_date',
'archived',
'archived_on',
'archived_reason',
)
read_only_fields = (
'id',
'adviser',
'created_on',
)
class OrderCreateSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Order
fields = '__all__'
class CodebaseSerializer(serializers.ModelSerializer, FeaturedImageMixin):
absolute_url = serializers.URLField(source='get_absolute_url',
read_only=True)
all_contributors = ContributorSerializer(many=True, read_only=True)
date_created = serializers.DateTimeField(
read_only=True, default=serializers.CreateOnlyDefault(timezone.now))
download_count = serializers.IntegerField(read_only=True)
first_published_at = serializers.DateTimeField(format=PUBLISH_DATE_FORMAT,
read_only=True)
last_published_on = serializers.DateTimeField(format=PUBLISH_DATE_FORMAT,
read_only=True)
latest_version_number = serializers.ReadOnlyField(
source='latest_version.version_number')
releases = serializers.SerializerMethodField()
submitter = LinkedUserSerializer(read_only=True,
default=serializers.CurrentUserDefault())
summarized_description = serializers.CharField(read_only=True)
identifier = serializers.ReadOnlyField()
tags = TagSerializer(many=True)
# FIXME: output should be raw markdown, not rendered
description = MarkdownField()
def get_releases(self, obj):
request = self.context.get('request')
user = request.user if request else User.get_anonymous()
queryset = CodebaseRelease.objects.filter(
codebase_id=obj.pk).accessible(user).order_by('-version_number')
# queryset = obj.releases.order_by('-version_number')
return RelatedCodebaseReleaseSerializer(queryset,
read_only=True,
many=True,
context=self.context).data
def create(self, validated_data):
serialized_tags = TagSerializer(many=True,
data=validated_data.pop('tags'))
codebase = Codebase(**validated_data)
codebase.submitter = self.context['request'].user
codebase.identifier = codebase.uuid
set_tags(codebase, serialized_tags)
codebase.save()
return codebase
def update(self, instance, validated_data):
validated_data['draft'] = False
return update(super().update, instance, validated_data)
class Meta:
model = Codebase
fields = (
'absolute_url',
'all_contributors',
'date_created',
'download_count',
'featured_image',
'repository_url',
'first_published_at',
'last_published_on',
'latest_version_number',
'releases',
'submitter',
'summarized_description',
'tags',
'description',
'title',
'doi',
'identifier',
'id',
'references_text',
'associated_publication_text',
'replication_text',
'peer_reviewed',
)
class CatalogCreateSerializer(serializers.ModelSerializer):
baker = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Catalog
fields = '__all__'
class EmailAccountSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(
default=serializers.CurrentUserDefault()
)
incoming = IncomingMailBoxSerializer(required=False, allow_null=True)
outgoing = OutgoingSmtpConnectionSettingsSerializer(required=False, allow_null=True)
default_password = serializers.CharField(
write_only=True, required=False, allow_blank=True,
help_text='password which is used in case password fields in incoming and outgoing configurations skipped'
)
sender_name = serializers.CharField(default=ContextualDefault(
lambda field: get_default_sender_name(field.context['request'].user)))
signature = serializers.CharField(allow_blank=True, default=ContextualDefault(
lambda field: get_default_signature(field.context['request'].user)
))
class Meta:
model = EmailAccount
fields = ('id', 'user', 'email', 'sender_name', 'incoming', 'outgoing', 'default_password',
'signature', 'default',)
def create(self, validated_data: dict) -> EmailAccount:
incoming_data = validated_data.pop('incoming', None)
assert incoming_data is not None, 'You can user `create` only for fully defined data'
incoming_uri = CoolMailbox.get_uri_from(
IncomingConfiguration(
host=incoming_data.get('location'),
port=incoming_data.get('port'),
encryption=incoming_data.get('encryption_type'),
username_or_template=incoming_data.get('username'),
authentication=incoming_data.get('authentication'),
),
incoming_data.get('password'),
incoming_data.get('provider'),
)
validated_data['incoming'] = CoolMailbox.objects.create(uri=incoming_uri)
outgoing_data = validated_data.pop('outgoing', None)
assert outgoing_data is not None, 'You can user `create` only for fully defined data'
outgoing_uri = SmtpConnectionSettings.get_uri_from(
OutgoingConfiguration(
host=outgoing_data.get('location'),
port=outgoing_data.get('port'),
encryption=outgoing_data.get('encryption_type'),
username_or_template=outgoing_data.get('username'),
authentication=outgoing_data.get('authentication'),
),
outgoing_data.get('password'),
outgoing_data.get('provider'),
)
validated_data['outgoing'] = SmtpConnectionSettings.objects.create(uri=outgoing_uri)
return super().create(validated_data)
def update(self, instance: EmailAccount, validated_data: dict) -> EmailAccount:
default = validated_data.get('default', False)
if default:
validated_data.pop('default')
incoming_data = validated_data.pop('incoming', {})
outgoing_data = validated_data.pop('outgoing', {})
instance = super().update(instance, validated_data)
if default:
instance.set_as_default()
if incoming_data:
mailbox = instance.incoming
password = incoming_data.pop('password', mailbox.password)
provider = incoming_data.pop('provider', mailbox.provider)
incoming_configuration = mailbox.to_configuration()
for k, v in self.fields.get('incoming').remap(incoming_data).items():
setattr(incoming_configuration, k, v)
mailbox.uri = CoolMailbox.get_uri_from(
incoming_configuration,
password=password,
provider=provider
)
mailbox.drop_status()
mailbox.save()
if outgoing_data:
smtp_connection_settings = instance.outgoing
password = outgoing_data.pop('password', smtp_connection_settings.password)
provider = outgoing_data.pop('provider', smtp_connection_settings.provider)
outgoing_configuration = smtp_connection_settings.to_configuration()
for k, v in self.fields.get('outgoing').remap(outgoing_data).items():
setattr(outgoing_configuration, k, v)
smtp_connection_settings.uri = SmtpConnectionSettings.get_uri_from(
outgoing_configuration,
password=password,
provider=provider
)
smtp_connection_settings.drop_status()
smtp_connection_settings.save()
return instance
def to_internal_value(self, data: dict) -> dict:
if 'default_password' not in data:
return super().to_internal_value(data)
data = data.copy()
default_password = data.pop('default_password')
for path in ['incoming.password', 'outgoing.password', ]:
if not data.get(path, None):
data[path] = default_password
return super().to_internal_value(data)
def validate(self, attrs: dict) -> dict:
if email_address_exists(attrs.get('email'), attrs.get('user')):
raise serializers.ValidationError(
_("A user is already registered with this e-mail address."))
return super().validate(attrs)
def validate_default(self, value: bool) -> bool:
if not value and self.instance and self.instance.default:
raise serializers.ValidationError(
"You can not set provider to be not 'default'. Choose other one to be default."
)
return value
class FavourViewSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = models.Course
fields = "__all__"
class TelegramContactSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = TelegramContact
fields = '__all__'
class CategorySerializer(AdminCategorySerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class NewsDetailSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = News
fields = ('pub_date', 'title', 'news_text', 'user')
class UserPlantSerializer(AdminUserPlantSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class AuthorSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault(), )
class Meta:
model = Author
fields: Tuple = ('author', )
class ReadRecordSerializer(ModelSerializer):
class Meta:
model = Record
fields = [
'pk',
'owner',
'asset_from',
'asset_to',
'created_dt',
'delta',
'description',
'extra',
'mode',
'tags',
]
VALID_MODES_MAPPING = {
(True, True): Record.TRANSFER,
(True, False): Record.INCOME,
(False, True): Record.EXPENSE
}
owner = serializers.HiddenField(default=serializers.CurrentUserDefault(), )
asset_to = UserPrimaryKeyRelatedField(
user_field_name='owner',
queryset=Asset.objects,
allow_null=True,
)
asset_from = UserPrimaryKeyRelatedField(
user_field_name='owner',
queryset=Asset.objects,
allow_null=True,
)
created_dt = UserDateTimeField(
user_field_name='owner',
read_only=False,
)
tags = UserPrimaryKeyRelatedField(
user_field_name='owner',
queryset=Tag.objects,
many=True,
allow_null=True,
)
delta = MoneyField(
required=True,
decimal_places=DECIMAL_PLACES,
max_digits=MAX_DIGITS,
)
def validate(self, attrs):
return self._validate_assets(attrs)
def _validate_assets(self, attrs):
to_from_mode = (bool(attrs['asset_to']), bool(attrs['asset_from']))
try:
if attrs['mode'] != self.VALID_MODES_MAPPING[to_from_mode]:
raise serializers.ValidationError(
_('VALIDATE-0002: Invalid mode or assets data'))
except KeyError as e:
raise serializers.ValidationError(
_('VALIDATE-0001: Either of the assets and mode must be defined in a record'
)) from e
return attrs
class ArgumentacionParrafoSerializer(serializers.ModelSerializer):
autor = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = ArgumentacionParrafo
fields = ('autor', 'parrafo', 'calificacion')
class CreateRideSerializer(serializers.ModelSerializer):
"""Ride model serializer."""
offered_by = serializers.HiddenField(
default=serializers.CurrentUserDefault())
available_seats = serializers.IntegerField(min_value=1, max_value=15)
class Meta:
"""Meta class."""
model = Ride
exclude = ('offered_in', 'passengers', 'rating', 'is_active')
def validate_departure_date(self, data):
"""Verify date is not in the past."""
min_date = timezone.now() + timedelta(minutes=10)
if data < min_date:
raise serializers.ValidationError(
'Departure time must be at least pass the next 20 minutes window.'
)
return data
def validate(self, data):
"""Validate.
Verify that the person who offers the ride is member
and also the same user making the request.
"""
if self.context['request'].user != data['offered_by']:
raise serializers.ValidationError(
'Rides offered on behalf of others are not allowed')
user = data['offered_by']
circle = self.context['circle']
try:
membership = Membership.objects.get(user=user,
circle=circle,
is_active=True)
except Membership.DoesNotExists:
raise serializers.ValidationError(
'User is not an active member of the circle.')
if data['arrival_date'] <= data['departure_data']:
raise serializers.ValidationError(
'Departure data must happen after arrival date.')
self.context['membership'] = membership
return data
def create(self, data):
"""Create ride and update stats."""
circle = self.context['circle']
ride = Ride.objects.create(**data, circle=circle)
# Circle
circle.rides_offered += 1
circle.save()
# Membership
membership = self.context['membership']
membership.rides_offered += 1
membership.save()
# Profile
profile = data['offered_by'].profile
profile.offered_by += 1
profile.save()
return ride
class FeedbackSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Feedback
fields = ["url","message","stars","author","date"]
author = serializers.HiddenField(default=serializers.CurrentUserDefault())
date = serializers.DateField(read_only=True,default=date.today)
class AddMemberSerializer(serializers.Serializer):
"""Add member serializer.
Handle the addition of a new member to a circle.
Circle object must be provided in the context.
"""
invitation_code = serializers.CharField(min_length=8)
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
def validate_user(self, data):
"""Verify user isn't already a member."""
circle = self.context['circle']
user = data
q = Membership.objects.filter(circle=circle, user=user)
if q.exists():
raise serializers.ValidationError(
'User is already member of this circle')
return data
def validate_invitation_code(self, data):
"""Verify code exists and that it is related to the circle."""
try:
invitation = Invitation.objects.get(code=data,
circle=self.context['circle'],
used=False)
except Invitation.DoesNotExist:
raise serializers.ValidationError('Invalid invitation code.')
self.context['invitation'] = invitation
return data
def validate(self, data):
"""Verify circle is capable of accepting a new member."""
circle = self.context['circle']
if circle.is_limited and circle.members.count() >= circle.member_limit:
raise serializers.ValidationError(
'Circle has reached its member limit :(')
return data
def create(self, data):
"""Create new circle member."""
circle = self.context['circle']
invitation = self.context['invitation']
user = data['user']
now = timezone.now()
# Member creation
member = Membership.objects.create(user=user,
profile=user.profile,
circle=circle,
invited_by=invitation.issued_by)
# Update Invitation
invitation.used_by = user
invitation.used = True
invitation.used_at = now
invitation.save()
# Update issuer data
issuer = Membership.objects.get(user=invitation.issued_by,
circle=circle)
issuer.used_invitations += 1
issuer.remaining_invitations -= 1
issuer.save()
return member
class PacerFetchQueueSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
court = serializers.PrimaryKeyRelatedField(
queryset=Court.federal_courts.all(),
html_cutoff=500, # Show all values in HTML view.
required=False,
)
docket = serializers.PrimaryKeyRelatedField(queryset=Docket.objects.all(),
required=False)
recap_document = serializers.PrimaryKeyRelatedField(
queryset=RECAPDocument.objects.all(), required=False)
pacer_username = serializers.CharField(write_only=True)
pacer_password = serializers.CharField(write_only=True)
class Meta:
model = PacerFetchQueue
fields = "__all__"
read_only_fields = (
"date_created",
"date_modified",
"date_completed",
"status",
"message",
)
def validate(self, attrs):
# Is it a good court value?
district_court_ids = (
Court.federal_courts.district_pacer_courts().values_list(
"pk", flat=True))
if attrs.get("court") and attrs["court"].pk not in district_court_ids:
raise ValidationError("Invalid court id: %s" % attrs["court"].pk)
# Docket validations
if attrs.get("pacer_case_id") and not attrs.get("court"):
# If a pacer_case_id is included, is a court also?
raise ValidationError("Cannot use 'pacer_case_id' parameter "
"without 'court' parameter.")
if attrs.get("docket_number") and not attrs.get("court"):
# If a docket_number is included, is a court also?
raise ValidationError("Cannot use 'docket_number' parameter "
"without 'court' parameter.")
if attrs.get("show_terminated_parties"
) and not attrs.get("show_parties_and_counsel"):
raise ValidationError(
"You've requested to show_terminated_parties parties while "
"show_parties_and_counsel is False. To show terminated "
"parties, you must also request showing parties and counsel "
"generally.")
# Attachment page and PDF validation
if attrs["request_type"] in [
REQUEST_TYPE.PDF,
REQUEST_TYPE.ATTACHMENT_PAGE,
]:
if not attrs.get("recap_document"):
raise ValidationError(
"recap_document is a required field for attachment page "
"and PDF fetches.")
# PDF validations
if attrs["request_type"] == REQUEST_TYPE.PDF:
rd = attrs["recap_document"]
if rd.is_available:
raise ValidationError(
"Cannot fetch a PDF for recap_document %s. That document "
"is already marked as available in our database "
"(is_available = True)." % rd.pk)
# Do the PACER credentials work?
try:
_ = get_or_cache_pacer_cookies(
attrs["user"].pk,
username=attrs.pop("pacer_username"),
password=attrs.pop("pacer_password"),
)
except PacerLoginException as e:
raise ValidationError("PacerLoginException: %s" % e.message)
return attrs
