def create(self, validated_data):
address = validated_data.pop('address')
user = Customuser(**validated_data)
user.save()
serializer = AddressSerializer(data=address)
if serializer.is_valid(raise_exception=True):
serializer.save(customuser=user)
return user
def test_serializer_invalid_zip_code():
address = {
"street": "test test",
"number": 10,
"zip_code": "000000",
"city": "SP",
"state": "SP"
}
serializer = AddressSerializer(data=address)
assert not serializer.is_valid()
class ProfileDetailSerializer(serializers.ModelSerializer):
address = AddressSerializer()
user = UserSerializer()
class Meta:
model = Profile
fields = ('id', 'user', 'image', 'birth_date', 'address')
read_only_fields = ('id',)
def update(self, instance, validated_data):
address = instance.address
address_data = validated_data.get('address')
address.street = address_data.get('street', address.street)
address.complement = address_data.get('complement', address.complement)
address.post_code = address_data.get('post_code', address.post_code)
address.city = address_data.get('city', address.city)
address.state = address_data.get('state', address.state)
address.country = address_data.get('country', address.country)
address.save()
instance.image = validated_data.get('image', instance.image)
instance.birth_date = validated_data.get('birth_date', instance.birth_date)
instance.address = address
instance.save()
return instance
class CommunitySerializer(serializers.ModelSerializer):
leadership = CommunityLeadershipSerializer()
contacts = CommunityContactsSerializer(many=True)
images = CommunityPictureSerializer(many=True)
schools = CommunitySchoolSerializer(many=True)
biomes = CommunityBiomesSerializer(many=True)
craftworks = CommunityCraftworkSerializer(many=True)
address = AddressSerializer()
products = ProductSerializer(many=True)
class Meta:
model = Community
fields = ('id', 'name', 'geo_lat', 'geo_long', 'distance_from_capital',
'idh_state', 'idh_city', 'energy_type', 'families_number',
'religion', 'traditional_culture', 'craftworks', 'traditional_events',
'sanctuaries', 'hospitals_number', 'ready_care_number', 'psf_number',
'address', 'leadership', 'products', 'contacts', 'images', 'schools',
'biomes')
read_only_fields = ('id',)
def create(self, validated_data):
address_data = validated_data.pop('address')
address = Address.objects.create(**address_data)
community = Community(**validated_data)
community.address = address
community.save()
leaderships_data = validated_data.pop('leadership')
for leadership_data in leaderships_data:
CommunityLeadership.objects.create(community=community, **leadership_data)
contacts_data = validated_data.pop('contacts')
for contact_data in contacts_data:
CommunityContacts.objects.create(community=community, **contact_data)
images_data = validated_data.pop('images')
for image_data in images_data:
CommunityPicture.objects.create(community=community, **image_data)
schools_data = validated_data.pop('schools')
for school_data in schools_data:
CommunitySchools.objects.create(community=community, **school_data)
biomes_data = validated_data.pop('biomes')
for biome_data in biomes_data:
CommunityBiomes.objects.create(community=community, **biome_data)
craftworks_data = validated_data.pop('craftwork')
for craftwork_data in craftworks_data:
CommunityCraftwork.objects.create(community=community, **craftwork_data)
return community
class CommunityListSerializer(serializers.ModelSerializer):
address = AddressSerializer()
images = CommunityPictureSerializer(many=True)
class Meta:
model = Community
fields = ('name', 'address', 'images')
class ProfileSerializer(serializers.ModelSerializer):
"""Serializer for Profile model"""
address = AddressSerializer(allow_null=True)
class Meta:
model = Profile
fields = ("gender", "birth_date", "address")
def create(self, validated_data):
address_data = validated_data.pop("address", None)
profile = Profile.objects.create(**validated_data)
if address_data:
Address.objects.create(user_profile=profile, **address_data)
def update(self, instance, validated_data):
address_data = validated_data.pop("address", None)
address = instance.address
if address_data and address:
address.address_line = address_data.get("address_line",
address.address_line)
address.district = address_data.get("district", address.district)
address.save()
elif address_data:
address = Address.objects.create(**address_data)
instance.address = address
instance.gender = validated_data.get("gender", instance.gender)
instance.birth_date = validated_data.get("birth_date",
instance.birth_date)
instance.save()
return instance
class ApartmentSerializer(serializers.ModelSerializer):
house = serializers.PrimaryKeyRelatedField(queryset=House.objects.all())
meters = MeterSerializer(many=True, read_only=True)
account = AccountSerializer(read_only=True)
address = AddressSerializer(read_only=True)
number = serializers.IntegerField(write_only=True, required=False)
class Meta:
model = Apartment
fields = (
'id',
'address',
'number',
'house',
'floor',
'entrance',
'room_number',
'total_area',
'dwelling_space',
'heating_area',
'meters',
'account',
)
depth = 1
def create(self, validated_data):
"""
Create an apartment with the data taken from `validated_data`.
"""
apartment_number = validated_data.pop('number', '')
if not apartment_number:
raise serializers.ValidationError('Field "number" is required.')
house = validated_data.get('house')
address = Address.objects.create_apartment_address(
house.address, apartment_number)
apartment = Apartment.objects.create(address=address, **validated_data)
account = Account.objects.create(apartment=apartment)
coop_services = house.cooperative.services.all()
for coop_service in coop_services:
ApartmentTariff.objects.create(apartment=apartment,
service=coop_service.service)
if coop_service.service.requires_meter:
meter = Meter.objects.create(apartment=apartment,
service=coop_service.service)
meter.create_indicators()
return apartment
class HouseSerializer(serializers.ModelSerializer):
apartments = ApartmentSerializer(many=True, read_only=True)
cooperative = serializers.PrimaryKeyRelatedField(
queryset=HousingCooperative.objects.all())
address = AddressSerializer(read_only=True)
street = serializers.CharField(write_only=True, required=False)
number = serializers.CharField(write_only=True, required=False)
class Meta:
model = House
fields = (
'id',
'cooperative',
'address',
'street',
'number',
'apartments',
)
depth = 2
def get_street(self, obj):
return obj.address.street.name
def get_number(self, obj):
return obj.address.house.number
def create(self, validated_data):
"""
Create a house with data taken from the given
`validated_data`.
"""
msg = None
street_name = validated_data.pop('street', '')
if not street_name:
msg = 'Street field is required.'
house_number = validated_data.pop('number', '')
if not house_number:
msg = 'House number field is required.'
if msg:
raise serializers.ValidationError(msg)
address = Address.objects.create_house_address(street_name,
house_number)
house = House.objects.create(address=address, **validated_data)
coop_services = house.cooperative.services.all()
for coop_service in coop_services:
HouseTariff.objects.create(house=house,
service=coop_service.service)
return house
def test_create_address(self):
"""Test create address with current user"""
address_new = sample_address(user=self.user)
res = self.client.get(ADDRESS_URL)
addresses = Address.objects.all()
serializer = AddressSerializer(addresses, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
self.assertEqual(address_new.user, self.user)
def test_serializer_create():
address = {
"street": "test test",
"number": 10,
"zip_code": "00000000",
"city": "SP",
"state": "SP"
}
serializer = AddressSerializer(data=address)
serializer.is_valid(raise_exception=True)
serializer.save()
class CompanySerializer(serializers.ModelSerializer):
address = AddressSerializer()
class Meta:
model = Company
fields = ('id', 'name', 'company_reg', 'sector', 'type', 'address',)
read_only_field = ('id',)
def create(self, validated_data):
address_data = validated_data.pop('address')
address = Address.objects.create(**address_data)
company = Company(**validated_data)
company.address = address
company.save()
return company
def key_addresses(request, pk):
try:
privatekey: PrivateKey = PrivateKey.objects.get(pk=pk)
except PrivateKey.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
user_id = request.user.id
if PrivateKey.objects.filter(owner=user_id, id=pk).count() == 0:
return JsonResponse({"address": None})
models = Address.objects.filter(private_key=pk)
response = {}
for current_model in models:
serialized = AddressSerializer(current_model).data
response[current_model.n] = serialized
return JsonResponse({"address": response})
class ProfileSerializer(serializers.ModelSerializer):
address = AddressSerializer()
class Meta:
model = Profile
fields = ('id', 'user', 'image', 'birth_date', 'is_support', 'is_manager', 'is_admin', 'address',)
read_only_fields = ('id',)
def create(self, validated_data):
address_data = validated_data.pop('address')
address = Address.objects.create(**address_data)
profile = Profile(**validated_data)
profile.address = address
profile.save()
return profile
class CustomUserDetailSerializer(serializers.ModelSerializer):
address = AddressSerializer(serializers.ModelSerializer)
class Meta:
model = Customuser
fields = ('id', 'username', 'first_name', 'last_name', 'email', 'phone', 'address')
def create(self, validated_data):
address = validated_data.pop('address')
user = Customuser(**validated_data)
user.save()
serializer = AddressSerializer(data=address)
if serializer.is_valid(raise_exception=True):
serializer.save(customuser=user)
return user
def update(self, instance, validated_data):
address = validated_data.pop('address')
address_instance = Address.objects.get(customuser=instance.id) # TODO poprawic
address_instance.street = address.get('street', address_instance.street)
address_instance.local_number = address.get('local_number', address_instance.local_number)
address_instance.postal_code = address.get('postal_code', address_instance.postal_code)
address_instance.city = address.get('city', address_instance.city)
address_instance.country = address.get('country', address_instance.country)
address_instance.save()
instance.first_name = validated_data.get('first_name', instance.first_name)
instance.last_name = validated_data.get('last_name', instance.last_name)
instance.username = validated_data.get('username', instance.username)
instance.email = validated_data.get('email', instance.email)
instance.phone = validated_data.get('phone', instance.phone)
instance.save()
return instance
class PatientSerializer(serializers.ModelSerializer):
address = AddressSerializer()
class Meta:
model = Patient
fields = ("id", "name", "email", "cpf", "birth_date", "phone",
"address")
def create(self, validated_data):
address = Address.objects.create(**validated_data["address"])
validated_data["address"] = address
return Patient.objects.create(**validated_data)
def update(self, instance, validated_data):
Address.objects.filter(pk=instance.address.pk).update(
**validated_data["address"])
instance.name = validated_data["name"]
instance.email = validated_data["email"]
instance.cpf = validated_data["cpf"]
instance.birth_date = validated_data["birth_date"]
instance.phone = validated_data["phone"]
instance.save()
validated_data["id"] = instance.pk
return validated_data
def _get_or_create_address(self, validated_data):
address = validated_data.pop('address')
address_serializer = AddressSerializer(data=address)
address_serializer.is_valid(raise_exception=True)
return address_serializer.save()
