def get(self, request, format=None):
objectID = self.request.query_params.get('id')
detail = DistrictMinorWork.objects.filter(identifier=objectID).first()
detail_type = "dmw"
serializer_class = DistrictMinorWorkSerializer
if detail is not None:
data = serializer_class(detail, many=False).data
print(data)
data["properties"]["type"] = detail_type
data["properties"]["category"] = CategorySerializer(
detail.metadata.category, many=False).data
data["properties"]["other_versions"] = []
return Response(data)
detail_type = "comm"
detail = CommunityActivityMetaData.objects.filter(
code=objectID).first()
if detail is not None:
children = CommunityActivityMetaData.objects.filter(
parent=objectID)
other_versions = []
for child in children:
print(child)
other_versions.append({
"document_date": child.document_date,
"document_no": child.document_no,
"document_url": child.document_url
})
activity = detail.activity
serializer_class = CommunityActivityMetaDataSerializer
metadata = serializer_class(detail, many=False).data
f = GeometryField(precision=None)
if activity is None:
d = f.to_representation(detail.point)
metadata.point = None
else:
d = f.to_representation(detail.activity.mpoly)
metadata.activity = None
cat = CategorySerializer(detail.category, many=False).data
return Response({
"geometry": d,
"type": "Feature",
"properties": {
"metadata": metadata,
"type": "comm",
"category": cat,
"other_versions": other_versions
}
})
raise Http404
class ViewpointSerializerWithPicture(ViewpointSerializer):
picture = SimplePictureSerializer(required=False, write_only=True)
pictures = SimplePictureSerializer(many=True, read_only=True)
point = GeometryField(required=True, write_only=True)
geometry = GeometryField(source='point.geom', read_only=True)
class Meta:
model = Viewpoint
fields = ('id', 'label', 'geometry', 'properties', 'point', 'picture',
'pictures')
def create(self, validated_data):
point_data = validated_data.pop('point', None)
layer, created = Layer.objects.get_or_create(
name=settings.TROPP_BASE_LAYER_NAME)
feature = Feature.objects.create(
geom=point_data,
layer=layer,
properties={},
)
validated_data.setdefault('point', feature)
picture_data = validated_data.pop('picture', None)
viewpoint = super().create(validated_data)
if picture_data:
Picture.objects.create(
viewpoint=viewpoint,
owner=self.context['request'].user,
**picture_data,
)
return viewpoint
def update(self, instance, validated_data):
picture_data = validated_data.pop('picture', None)
if picture_data:
Picture.objects.create(
viewpoint=instance,
owner=self.context['request'].user,
**picture_data,
)
point_data = validated_data.pop('point', None)
if point_data:
feature = instance.point
feature.geom = point_data
feature.save()
return super().update(instance, validated_data)
class HouseholdBSerializer(GeoFeatureModelSerializer):
bgeom = GeometryField()
class Meta:
model = Household
geo_field = 'bgeom'
fields = '__all__'
class TransportDataSerializer(serializers.ModelSerializer):
"""
# id_user_transport_data = serializers.IntegerField()
id = serializers.IntegerField()
id_user_transport = serializers.RelatedField(read_only=True)
altitude = serializers.IntegerField()
when_added = serializers.DateTimeField()
speed = serializers.DecimalField(max_digits=7, decimal_places=2)
satellite = serializers.IntegerField()
flags1 = serializers.IntegerField()
point = GeometryField()
"""
point = GeometryField()
class Meta:
model = TransportData
fields = [
'id',
'id_user_transport',
'altitude',
'when_added',
'speed',
'point',
'satellite',
]
class UserSerializer(serializers.ModelSerializer):
location = GeometryField(
required=False,
help_text="Location format: POINT (lat lon)",
)
age = serializers.SerializerMethodField()
score = serializers.FloatField(required=False)
class Meta:
model = get_user_model()
exclude = ('password', 'user_permissions', 'groups', 'is_staff',
'is_superuser')
read_only_fields = ('last_login', 'username', 'email', 'is_active',
'date_joined', 'score')
def to_representation(self, instance):
representation = super(UserSerializer,
self).to_representation(instance)
representation[
'location'] = None if instance.location is None else str(
instance.location)
return representation
@staticmethod
def get_age(obj):
return birthday_to_age(obj.birthday)
@staticmethod
def get_score(obj):
if obj.gendre == "male" and len(obj.owned_relations) == 0:
return 10
class Scan(rest.HALSerializer):
dataset = 'scans'
_display = rest.DisplayField()
geometrie = GeometryField()
class Meta(object):
model = models.Scan
fields = (
'_links',
'_display',
'scan_moment',
'scan_source',
'parkeervak_id',
'parkeervak_soort',
'buurtcode',
'sperscode',
'qualcode',
'bgt_wegdeel',
'bgt_wegdeel_functie',
'nha_hoogte',
'nha_nr',
'geometrie',
)
class SiteGeojsonSerializer(GeoFeatureModelSerializer, SiteSerializer):
# Annotated geom field with API_SRID
api_geom = GeometryField(read_only=True, precision=7)
class Meta(SiteSerializer.Meta):
geo_field = 'api_geom'
fields = SiteSerializer.Meta.fields + ('api_geom', )
class AreaOfInterestSerializer(GeoFeatureModelSerializer):
changesets_url = SerializerMethodField()
user = HiddenField(default=CurrentUserDefault())
geometry = GeometryField(read_only=True)
class Meta:
model = AreaOfInterest
geo_field = 'geometry'
fields = [
'id', 'name', 'filters', 'geometry', 'date', 'changesets_url',
'user'
]
validators = [
UniqueTogetherValidator(queryset=AreaOfInterest.objects.all(),
fields=('name', 'user'))
]
def get_changesets_url(self, obj):
return reverse('supervise:aoi-list-changesets', args=[obj.id])
def validate(self, data):
if data.get('filters') is None and data.get('geometry') is None:
raise ValidationError(
'Set a value to the filters field or to the geometry to be able to save the AoI'
)
return data
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 Serializer(GeoFeatureModelSerializer):
api_geom = GeometryField(read_only=True, precision=7)
class Meta:
model = _model
geo_field = 'api_geom'
id_field = 'id'
exclude = []
class GastroRegistrationSerializer(serializers.ModelSerializer):
geometry = GeometryField(precision=14)
area = GeometryField(precision=14,
required=False,
allow_null=True,
default=None)
class Meta:
model = GastroSignup
fields = [
'campaign',
'shop_name',
'first_name',
'last_name',
'category',
'email',
'phone',
'usage',
'address',
'geometry',
'area',
'shopfront_length',
'opening_hours',
'tos_accepted',
'followup_accepted',
'agreement_accepted',
'status',
'regulation',
'application_received',
'application_decided',
'permit_start',
'permit_end',
'renewal_application',
'note',
]
read_only_fields = [
'regulation',
'certificate',
'application_received',
'application_decided',
'permit_start',
'permit_end',
'renewal_application',
'note',
]
class WegStukSerializer(HALSerializer):
mline = GeometryField()
_display = DisplayField()
class Meta:
model = WegStuk
fields = ('id', 'name', 'type', 'timestamp', 'length', 'traveltime',
'velocity', 'mline', '_links', '_display')
class DealLocationSerializer(serializers.Serializer):
point_lat = serializers.DecimalField(max_digits=11, decimal_places=8)
point_lon = serializers.DecimalField(max_digits=11, decimal_places=8)
contract_area = GeometryField()
intended_area = GeometryField()
production_area = GeometryField()
def to_representation(self, obj):
'''
Convert our binary polygon representation to a GEOSGeometry.
'''
# TODO: DRY, we should have a model with a list of these fields
for geo_field in ('contract_area', 'intended_area', 'production_area'):
if geo_field in obj and obj[geo_field]:
if not isinstance(obj[geo_field], GEOSGeometry):
obj[geo_field] = GEOSGeometry(obj[geo_field], srid=4326)
return super().to_representation(obj)
class SignalGeoSerializer(GeoFeatureModelSerializer):
# For use with the "geography" action
location = GeometryField(source='location.geometrie')
class Meta:
model = Signal
id_field = False
geo_field = 'location'
fields = ['id', 'created_at']
class HouseholdsBufferSerializer(GeoFeatureModelSerializer):
spray_points = serializers.SerializerMethodField()
percentage_sprayed = serializers.SerializerMethodField('get_perc_sprayed')
geom = GeometryField()
class Meta:
model = HouseholdsBuffer
geo_field = 'geom'
fields = '__all__'
def get_spray_points(self, obj):
if obj:
if hasattr(obj, '_cache_spray_points'):
return obj._cache_spray_points
queryset = SprayDay.objects.filter(geom__coveredby=obj.geom)
request = self.context.get('request')
if request and request.GET.get('spray_date'):
spray_date = request.GET.get('spray_date')
queryset = queryset.filter(spray_date=spray_date)
obj._cache_spray_points = queryset.count()
return obj._cache_spray_points
def get_perc_sprayed(self, obj):
if obj:
if obj.num_households == 0:
return 0
return round(
(self.get_spray_points(obj) / obj.num_households) * 100, 2)
def _get_color(self, obj):
if obj:
perc = self.get_perc_sprayed(obj)
color = ZERO_COLOR
if perc > 99:
color = _100_COLOR
elif perc > 66:
color = _66_COLOR
elif perc > 33:
color = _33_COLOR
elif perc > 0:
color = _1_COLOR
return color
def to_representation(self, value):
ret = super(HouseholdsBufferSerializer, self).to_representation(value)
if 'style' not in ret and value is not None:
ret['style'] = {'fillColor': self._get_color(value)}
return ret
class LocationSerializer(serializers.Serializer):
name = serializers.CharField(source="location_name")
address1 = serializers.CharField(source="location_address1")
address2 = serializers.CharField(source="location_address2",
required=False,
allow_blank=True)
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",
required=False)
shortLocation = serializers.CharField(source="short_location",
required=False)
coordinates = GeometryField(required=False)
staticMapUrl = serializers.SerializerMethodField(read_only=True)
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)
def get_staticMapUrl(self, obj):
if obj.coordinates is None:
return ""
static_map_image = StaticMapImage.objects.filter(center__distance_lt=(
obj.coordinates,
StaticMapImage.UNIQUE_CENTER_MAX_DISTANCE,
), ).first()
if static_map_image is None:
create_static_map_image_from_coordinates.delay(
[obj.coordinates[0], obj.coordinates[1]])
return ""
return static_map_image.image.url
def _set_geometry_attributes(attribute_data, project):
attribute_geometries = ProjectAttributeMultipolygonGeometry.objects.filter(
project=project)
geometry_attributes = {
attribute_geometry.attribute.identifier:
GeometryField().to_representation(
value=attribute_geometry.geometry)
for attribute_geometry in attribute_geometries
}
attribute_data.update(geometry_attributes)
class QueryAreaSerializer(serializers.Serializer):
provider_name = serializers.ReadOnlyField(source='provider.name')
area_name = serializers.ReadOnlyField(source='name')
area = GeometryField()
class Meta:
model = ServiceArea
fields = (
'provider_name',
'area_name',
'area',
)
def to_representation(self, instance: TrackPoint):
return {
'location':
GeometryField().to_representation(instance.location),
'collected_at':
instance.time_created.isoformat(),
'internal_type':
'TrackPoint', # We use this field for future usage on WS
'resource':
ListRetrieveResourceProfileSerializer().to_representation(
instance.incident_resource.resource),
}
class ProjectSerializer(serializers.HyperlinkedModelSerializer):
faq = QuestionSerializer(many=True)
photos = PhotoSerializer(many=True, default=[Photo(**PLACEHOLDER_PHOTO)])
geometry = GeometryField(precision=14)
center = GeometryField(precision=14)
length = serializers.DecimalField(None, 0)
likes = serializers.SerializerMethodField()
def get_likes(self, obj):
return len(obj.likes.all())
class Meta:
model = Project
fields = (
'id',
'url',
'project_key',
'title',
'description',
'short_description',
'category',
'street_name',
'borough',
'side',
'costs',
'draft_submitted',
'construction_started',
'construction_completed',
'construction_completed_date',
'phase',
'responsible',
'external_url',
'cross_section',
'faq',
'geometry',
'center',
'length',
'photos',
'likes',
)
class ForestSerializer(ModelSerializer):
geodata = GeometryField(allow_null=True,
required=False,
source="geodata4326")
contracts = SerializerMethodField()
class Meta:
model = Forest
exclude = ["deleted"]
def get_contracts(self, forest):
contract_types = dict(ContractType.objects.values_list("code", "name"))
return map_forests_contracts(forest, contract_types).contracts
class PlaceSerializer(serializers.ModelSerializer):
position = GeometryField(source="get_position_wgs84")
class Meta:
model = Place
fields = ["id", "name", "distance", "position"]
def validate(self, attrs):
if 'get_position_wgs84' in attrs:
position = attrs.pop('get_position_wgs84')
position.srid = DEFAULT_WGS84_SRID
attrs['position'] = make_point_projected(position)
return attrs
class AreaGeoSerializer(GeoFeatureModelSerializer):
geometry = GeometryField()
type = AreaTypeSerializer(source='_type')
class Meta:
model = Area
id_field = False
geo_field = 'geometry'
fields = (
'name',
'code',
'type',
)
class JunkPointSerializer(serializers.ModelSerializer):
location = GeometryField(help_text=_("Location as GeoJSON Point"))
class Meta:
model = JunkPoint
fields = ("id", "street_name", "description", "location", "types")
def to_representation(self, instance):
response = super().to_representation(instance)
for index in range(len(response["types"])):
response["types"][index] = JunkPointTypeSerializer(
instance.types.all()[index]).data
return response
class SimpleViewpointSerializer(serializers.ModelSerializer):
picture = SerializerMethodField()
geometry = GeometryField(source='point.geom', read_only=True)
class Meta:
model = Viewpoint
fields = ('id', 'label', 'picture', 'geometry')
def get_picture(self, viewpoint):
try:
return VersatileImageFieldSerializer('tropp').to_native(
viewpoint.pictures.first().file)
except AttributeError:
return None
class SprayDayNamibiaSerializer(SprayBaseNamibia, GeoFeatureModelSerializer):
sprayed = serializers.SerializerMethodField()
reason = serializers.SerializerMethodField()
spray_operator = serializers.SerializerMethodField()
spray_operator_code = serializers.SerializerMethodField()
irs_sticker_num = serializers.SerializerMethodField()
geom = GeometryField()
class Meta:
model = SprayDay
fields = ('submission_id', 'spray_date', 'sprayed', 'reason',
'spray_operator', 'spray_operator_code', 'irs_sticker_num',
'id')
geo_field = 'geom'
class TrackDataSerializer(serializers.ModelSerializer):
point = GeometryField()
class Meta:
model = TransportData
fields = [
'id',
'id_user_transport',
'altitude',
'when_added',
'speed',
'point',
'satellite',
]
class ServiceAreaSerializer(serializers.ModelSerializer):
provider_name = serializers.ReadOnlyField(
source='provider.name'
)
area = GeometryField()
class Meta:
model = ServiceArea
fields = (
'id',
'name',
'area',
'price',
'provider',
'provider_name',
)
class TrackingSerializer(serializers.ModelSerializer):
worker_id = serializers.PrimaryKeyRelatedField(queryset=Worker.objects,
allow_null=True,
required=False)
session_id = serializers.PrimaryKeyRelatedField(queryset=Session.objects,
required=False)
created_at = TimestampField(allow_null=True, required=False)
gps = GeometryField()
class Meta:
model = Tracking
fields = [
'id', 'worker_id', 'session_id', 'gps', 'noise_level',
'light_level', 'acceleration', 'created_at'
]
read_only_fields = ['id', 'worker_id']
def to_representation(self, instance: Incident):
location_point = GeometryField().to_representation(instance.location_point)
return {
'id': instance.id,
'domain_name': instance.domain_config.domain_name,
'incident_type_name': instance.incident_type.name,
'external_assistance': instance.external_assistance,
'data_status': instance.data_status,
'status': instance.status,
'location_as_string_reference': instance.location_as_string_reference,
'location_point': location_point,
'reference': instance.reference,
'created_at': instance.created_at,
'updated_at': instance.updated_at,
'cancelled_at': instance.cancelled_at,
'finalized_at': instance.finalized_at,
}