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'
]
