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