class PersonSerializer(serializers.ModelSerializer): country = CountryField() other_country = CountryField(country_dict=True, required=False) class Meta: model = Person fields = ('name', 'country', 'other_country')
class ProfileSerializer(serializers.Serializer): """Profile serializer.""" username = serializers.CharField(read_only=True) email = serializers.EmailField(read_only=True) personal_identity_number = serializers.CharField(read_only=True, source="pin") full_name = serializers.CharField(read_only=True) picture = serializers.ImageField(read_only=True) phone_number = serializers.CharField(read_only=True) born = CountryField(read_only=True, country_dict=True) nationality = CountryField(read_only=True, country_dict=True) date_of_birth = serializers.DateTimeField(read_only=True) date_joined = serializers.DateTimeField(read_only=True) expired_at = serializers.DateTimeField(read_only=True) has_expired = serializers.BooleanField(read_only=True) expired_natural_time = serializers.CharField(read_only=True, source="natural_time") expired_natural_day = serializers.CharField(read_only=True, source="natural_day")
class ProfileSerializer(serializers.ModelSerializer): first_name = serializers.CharField(max_length=255, required=False) last_name = serializers.CharField(max_length=255, required=False) country = CountryField(required=False) nationality = CountryField(required=False) birthdate = serializers.DateField(required=False) location = GeometryField(required=False) class Meta: model = Profile fields = ('first_name', 'last_name', 'full_name', 'country', 'nationality', 'birthdate', 'location', 'profile_picture_url')
class LocalitiesSerializer(serializers.HyperlinkedModelSerializer): #id = serializers.IntegerField(read_only=False) locality_name = serializers.CharField(required=True, allow_blank=True, max_length=255) meeting_address = serializers.CharField(required=True, allow_blank=True, max_length=255) locality_state_or_province = serializers.CharField(required=True, allow_blank=True, max_length=255) locality_country = CountryField(required=True, country_dict=True) locality_phone_number = serializers.CharField(required=False, allow_blank=True, max_length=255) locality_email = serializers.EmailField(required=False, allow_blank=True, max_length=255) locality_web = serializers.CharField( style={'base_template': 'textarea.html'}) #position = GeopositionField() class Meta: model = ChurchPage fields = ('url', 'locality_name', 'meeting_address', 'locality_state_or_province', 'locality_country', 'locality_phone_number', 'locality_email', 'locality_web', 'location', 'trimmed_address') def create(self, validated_data): """ Create and return a new `localities` instance, given the validated data. """ return ChurchPage.objects.create(**validated_data) def update(self, instance, validated_data): """ Update and return an existing `localities` instance, given the validated data. """ instance.url = validated_data.get('url', instance.get_absolute_url()) instance.locality_name = validated_data.get('locality_name', instance.locality_name) instance.meeting_address = validated_data.get('meeting_address', instance.meeting_address) instance.locality_state_or_province = validated_data.get( 'locality_state_or_province', instance.locality_state_or_province) instance.locality_country = validated_data.get( 'locality_country', instance.locality_country) instance.position = validated_data.get('position', instance.position) instance.locality_phone_number = validated_data.get( 'locality_phone_number', instance.locality_phone_number) instance.locality_email = validated_data.get('locality_email', instance.locality_email) instance.locality_web = validated_data.get('locality_web', instance.locality_web) #instance.position = validated_data.get('position', instance.position) instance.location = validated_data.get('location', instance.location) instance.save() return instance
class LocationSerializer(serializers.Serializer): name = serializers.CharField(source="location_name") address1 = serializers.CharField(source="location_address1") address2 = serializers.CharField(source="location_address2") zip = serializers.CharField(source="location_zip") city = serializers.CharField(source="location_city") country = CountryField(source="location_country") address = serializers.SerializerMethodField() shortAddress = serializers.CharField(source="short_address") shortLocation = serializers.CharField(source="short_location") coordinates = GeometryField() def to_representation(self, instance): data = super().to_representation(instance=instance) if not ["name"] and not data["zip"] and not data["city"]: return None return data def get_address(self, obj): parts = [ obj.location_address1, obj.location_address2, f"{obj.location_zip} {obj.location_city}".strip(), ] if obj.location_country and obj.location_country != "FR": parts.append(obj.location_country.name) return "\n".join(p for p in parts if p)
class TeamSerializer(serializers.ModelSerializer): id = serializers.ReadOnlyField() country = CountryField() class Meta: model = Team fields = ('url', 'id', 'name', 'full_name', 'competitions', 'country')
class UserCustomerSerializer(serializers.Serializer): name = serializers.CharField() email = serializers.EmailField() city = serializers.CharField() state = serializers.CharField() country = CountryField() code = serializers.CharField()
class OpenRegistrationSerializer(serializers.ModelSerializer): country = CountryField(country_dict=True, required=False) fields = JsonField() class Meta: model = OpenRegistration exclude = ("id", )
class OrganisationSerializerCreateUpdate(serializers.ModelSerializer): orgType = serializers.PrimaryKeyRelatedField(queryset=OrganisationType.objects.all(), many=False) country = CountryField(required=False) class Meta: model = Organisation fields = ['id', 'name', 'url', 'description' , 'orgType', 'logo','contactPoint', 'contactPointEmail', 'latitude', 'longitude','country'] def save(self, args, **kwargs): logo = self.validated_data.get('logo') if(logo): photo = logo image = Image.open(photo) image_path = saveImageWithPath(image, photo.name) logo = image_path moreItems = [('creator', args.user), ('logo', logo)] data = dict( list(self.validated_data.items()) + list(kwargs.items()) + list(moreItems) ) self.instance = self.create(data) return "success"
class SiteProfileSerializer(serializers.ModelSerializer): country = CountryField(required=False, countries=CountriesWithBlank()) class Meta: model = models.SiteProfile fields = '__all__' read_only_fields = ( 'uuid', 'organization_uuid', ) def validate_profiletype(self, value): if (self.initial_data['organization_uuid'] != str( value.organization_uuid)): raise serializers.ValidationError( 'Invalid ProfileType. It should belong to your organization') return value def validate(self, attrs): """Validate that at least one of the defined fields is filled.""" one_of_required_fields = ( 'name', 'country', 'city', 'latitude', 'longitude', 'address_line1', 'address_line2', 'address_line3', 'address_line4', ) if not set(one_of_required_fields).intersection(attrs.keys()): raise serializers.ValidationError( f'One of {one_of_required_fields} must be defined.') return super().validate(attrs)
class BloggerActionSerializer(ModelActionSerializer): country = CountryField(source='profile.country', required=False) blogs_num = serializers.IntegerField(source='profile.blogs_num', required=False) birth_date = serializers.DateField(source='profile.birth_date', required=False) phone_number = PhoneNumberField(source='profile.phone_number', required=False) bio = serializers.CharField(source='profile.bio', required=False) class Meta: model = User fields = ( 'id', 'username', 'blogs_num', 'birth_date', 'phone_number', 'country', 'bio', ) action_fields = { "list": { "fields": ( 'id', 'username', 'blogs_num', ) }, # "retrieve": {"fields": ('id', 'username', 'blogs_num',)}, }
class CountryAreaSerializer(CountryFieldMixin, FlexFieldsModelSerializer): """Serializer for :model:`world.CountryArea`: `**Fields:**` 01. `country` : `CharField` 02. `id` : `AutoField` 03. `name` : `CharField` `**Reverse Fields:**` 01. `city` : `ForeignKey` [:model:`world.City`] """ country = CountryField(country_dict=True) class Meta: model = CountryArea fields = [ # Fields 'country', 'id', 'name', # Reverse Fields # 'city', ] read_only_fields = []
class AddressSerializer(serializers.ModelSerializer): country = CountryField() class Meta: model = Address fields = ('id', 'user', 'street_address', 'apartment_address', 'country', 'zip', 'address_type', 'default')
class OrganizationDetailSerializer(OrganizationSerializer): default_timezone = serializers.CharField( required=False, help_text=_("Timezone to use when reporting metrics")) email = serializers.EmailField(help_text=_("E-mail address")) phone = serializers.CharField(required=False, allow_blank=True, help_text=_("Phone number")) street_address = serializers.CharField(required=False, allow_blank=True, help_text=_("Street address")) locality = serializers.CharField(required=False, allow_blank=True, help_text=_("City/Town")) region = serializers.CharField(required=False, allow_blank=True, help_text=_("State/Province/County")) postal_code = serializers.CharField(required=False, allow_blank=True, help_text=_("Zip/Postal code")) country = CountryField(required=False, allow_blank=True, help_text=_("Country")) extra = serializers.CharField( required=False, allow_null=True, help_text=_("Extra meta data (can be stringify JSON)")) class Meta(OrganizationSerializer.Meta): fields = OrganizationSerializer.Meta.fields + ( 'created_at', 'email', 'phone', 'street_address', 'locality', 'region', 'postal_code', 'country', 'default_timezone', 'is_provider', 'is_bulk_buyer', 'extra') read_only_fields = ('created_at', )
class UserSerializer(GeoFeatureModelSerializer): source = serializers.StringRelatedField(source='source.name') country = CountryField(country_dict=True) languages = LanguageSerializer(many=True) roles = RoleSerializer(many=True) class Meta: model = get_user_model() geo_field = 'geom' fields = ( 'id', 'email', 'first_name', 'middle_name', 'last_name', 'roles', 'address', 'city', 'state', 'postal_code', 'country', 'languages', 'phone', 'url', 'bio', 'source', )
class CardTokenSerializer(NoModelSerializer): """ Updates a payment method on file. """ token = serializers.CharField( help_text=_("Processor token to retrieve the payment method")) full_name = serializers.CharField(required=False, help_text=_("Full name")) email = serializers.EmailField( required=False, help_text=_("E-mail address for the account")) phone = serializers.CharField(required=False, allow_blank=True, help_text=_("Phone number")) street_address = serializers.CharField(required=False, allow_blank=True, help_text=_("Street address")) locality = serializers.CharField(required=False, allow_blank=True, help_text=_("City/Town")) region = serializers.CharField(required=False, allow_blank=True, help_text=_("State/Province/County")) postal_code = serializers.CharField(required=False, allow_blank=True, help_text=_("Zip/Postal code")) country = CountryField(required=False, allow_blank=True, help_text=_("Country"))
class OrganizationSerializer(GeoFeatureModelSerializer): categories = serializers.StringRelatedField(many=True) source = serializers.StringRelatedField() stage = serializers.StringRelatedField() type = serializers.StringRelatedField() languages = LanguageSerializer(many=True) country = CountryField(country_dict=True) sectors = serializers.StringRelatedField(many=True) socialnetworks = serializers.StringRelatedField(many=True) tools = serializers.StringRelatedField(many=True) class Meta: model = Organization geo_field = 'geom' fields = ( 'id', 'name', 'description', 'address', 'city', 'state', 'postal_code', 'country', 'languages', 'url', 'socialnetworks', 'categories', 'type', 'sectors', 'stage', 'tools', 'source', )
class ProjectSerializer(serializers.ModelSerializer): topic = TopicSerializer(many=True, required=False) status = StatusSerializer(many=False) keywords = KeywordSerializer(many=True, required=False) fundingBody = FundingBodySerializer(many=False, required=False) originDatabase = OriginDatabaseSerializer(many=False, required=False) customField = CustomFieldSerializer(many=True, required=False) country = CountryField(required=False) start_date = serializers.DateTimeField(format="%Y-%m-%d", required=False) end_date = serializers.DateTimeField(format="%Y-%m-%d", required=False) mainOrganisation = OrganisationSerializer(many=False, required=False) organisation = OrganisationSerializer(many=True, required=False) class Meta: model = Project fields = [ 'id', 'name', 'aim', 'description', 'keywords', 'status', 'topic', 'start_date', 'end_date', 'url', 'mainOrganisation', 'organisation', 'latitude', 'longitude', 'country', 'author', 'author_email', 'image1', 'imageCredit1', 'image2', 'imageCredit2', 'image3', 'imageCredit3', 'host', 'howToParticipate', 'doingAtHome', 'equipment', 'fundingBody', 'fundingProgram', 'originDatabase', 'originURL', 'originUID', 'featured', 'customField', 'dateCreated', 'origin' ]
class TeamSerializer(serializers.ModelSerializer): country = CountryField(country_dict=True) parent = ParentTeamSerializer() class Meta: model = Team fields = ['name', 'country', 'url', 'parent']
class EventSerializer(serializers.ModelSerializer): url = serializers.HyperlinkedIdentityField(view_name="v1:event-detail", lookup_field="code") country = CountryField(country_dict=True, read_only=True) registration_early_deadline = serializers.DateTimeField(allow_null=True) is_active = serializers.BooleanField(read_only=True) is_closed = serializers.BooleanField(read_only=True) is_open_for_registration = serializers.BooleanField(read_only=True) allows_invoices = serializers.BooleanField(read_only=True) days = DaySerializer(many=True, read_only=True) fees = FeeSerializer(many=True, read_only=True) dates = ImportantDateSerializer(many=True, read_only=True) dates_display = serializers.CharField(read_only=True) papers = PaperSerializer(many=True, read_only=True) sessions = SessionSerializer(many=True, read_only=True) topics = TopicSerializer(many=True, read_only=True) tracks = TrackSerializer(many=True, read_only=True) venues = VenueSerializer(many=True, read_only=True) href_registration = serializers.URLField(source="get_registration_url", read_only=True) custom_fields = serializers.JSONField(read_only=True) extra_data = serializers.JSONField() class Meta: model = Event exclude = ("id", "wbs_element", "ingenico_salt", "test_mode", "signature") read_only_fields = ("code", ) def validate(self, data): validate_event_dates(Event(**data)) return data
class CompanySerializer(NestedModelSerializer, ContentTypeAnnotatedModelSerializer): user = SimplestUserSerializer(required=False, read_only=False) city = serializers.CharField(required=False, allow_blank=True, allow_null=True) skills = SimpleSkillSerializer(required=False, many=True) country = CountryField(required=False) country_name = serializers.CharField(required=False, read_only=True) class Meta: model = Company fields = '__all__' def save_nested_user(self, data, instance, created=False): user = instance.user if user: user.first_name = data.get('first_name', user.first_name) user.last_name = data.get('last_name', user.last_name) image = data.get('image', None) if image: user.image = image user.save() def save_nested_skills(self, data, instance, created=False): if data is not None: instance.skills = ', '.join( [skill.get('name', '') for skill in data]) instance.save() def save_nested_city(self, data, instance, created=False): if data: instance.city = data instance.save()
class ProfileListSerializer(ModelSerializer): country = CountryField(country_dict=True) user = UserSerializer() class Meta: model = Profile fields = ['user', 'first_name', 'last_name', 'dob', 'image', 'country']
class CustomRegisterSerializer(CountryFieldMixin, RegisterSerializer): """ Registration serializer """ email = serializers.EmailField(required=True, write_only=True) password1 = serializers.CharField(required=True, write_only=True, style={'input_type': 'password'}) password2 = serializers.CharField(required=True, write_only=True, style={'input_type': 'password'}) username = serializers.CharField(required=True, min_length=1, max_length=30, write_only=True) profile_photo = serializers.ImageField(required=False, write_only=True) country = CountryField(required=True, write_only=True) def validate_country(self, data): return data def validate_email(self, email): email = get_adapter().clean_email(email) if email and email_address_exists(email): raise serializers.ValidationError( _("A user is already registered with this e-mail address.")) return email def validate_password1(self, password): return get_adapter().clean_password(password) def validate(self, data): if data['password1'] != data['password2']: raise serializers.ValidationError( _("The two password fields didn't match.")) return data def get_cleaned_data(self): return { 'password1': self.validated_data.get('password1', ''), 'email': self.validated_data.get('email', ''), 'username': self.validated_data.get('username', ''), 'profile_photo': self.validated_data.get('profile_photo', ''), 'country': self.validated_data.get('country', '') } def save(self, request): adapter = get_adapter() user = adapter.new_user(request) self.cleaned_data = self.get_cleaned_data() adapter.save_user(request, user, self) setup_user_email(request, user, []) ## User extra data assignation user.profile_photo = self.cleaned_data['profile_photo'] user.country = self.cleaned_data['country'] user.save() return user
class UserSerializer(serializers.ModelSerializer): """ User serializer. """ full_name = serializers.ReadOnlyField(label=_("full name"), source="get_full_name") short_name = serializers.ReadOnlyField(label=_("short name"), source="get_short_name") country = CountryField(read_only=True, label=_("country"), country_dict=True) class Meta: model = User read_only_fields = [ "is_staff", "is_superuser", "is_active", "date_joined", "avatar", "full_name", "short_name", ] extra_kwargs = { "url": {"view_name": "users:user-detail", }, model.USERNAME_FIELD: {"required": True, }, "email": {"required": True, }, "password": {"write_only": True}, } fields = [ "id", "first_name", "last_name", "full_name", "short_name", "is_active", "date_joined", "avatar", model.USERNAME_FIELD, "email", "password", "country", "language", "url", ] def create(self, validated_data): """ On creation, replace the raw password with a hashed version. :param validated_data: serializer validated data. :type validated_data: dict. :return: user model instance. :rtype: mk42.apps.users.models.user.User. """ obj = super(UserSerializer, self).create(validated_data=validated_data) obj.set_password(obj.password) obj.save() return obj
class AddressSerializer(serializers.ModelSerializer): country = CountryField(country_dict=True) class Meta: list_serializer_class = FilteredListSerializer model = Address fields = "__all__"
class RoadshowNestedSerializer(serializers.ModelSerializer): country = CountryField(country_dict=True) institutions = InstitutionNestedSerializer(many=True) href = serializers.CharField(source="get_absolute_url", read_only=True) class Meta: model = Roadshow exclude = ()
class LocationSerializer(serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField( view_name="pubapp:location-detail", ) country = CountryField(country_dict=True) class Meta: model = models.Location fields = '__all__'
class AddressSerializer(serializers.ModelSerializer): country = CountryField() class Meta: model = Address fields = ('id', 'user', 'contact_person', 'mobile', 'address1', 'address2', 'city', 'state', 'zip_code', 'country', 'default')
class ListenerSerializer(serializers.ModelSerializer): country = CountryField() user_agent = serializers.CharField(source='user_agent.name', read_only=True) stream = serializers.CharField(source='stream.mountpoint', read_only=True) class Meta: model = Listener fields = ('ip_address', 'stream', 'connected_at', 'disconnected_at', 'duration', 'user_agent', 'country', 'city',)
class ProfileDataSerializer(serializers.ModelSerializer): location = CountryField(required=False, allow_null=True) class Meta: model = ProfileData fields = [ 'id', 'age', 'gender', 'location', 'personality', 'depressed' ]