class ExtentsSerializerMixin(serializers.ModelSerializer):
center = fields.GeometryField(
help_text='Assign a GeoJSON string',
required=False,
style={'base_template': 'json.html', 'rows': 5}
)
field_list = ('center',)
class MapSerializerList(NamedSerializerMixin, ProjectSerializerMixin,
BaseSerializer):
url = serializers.HyperlinkedIdentityField(view_name='map-detail', )
sharing_url = serializers.SerializerMethodField()
# project_id = serializers.SerializerMethodField()
center = fields.GeometryField(help_text='Assign a GeoJSON string',
required=True,
style={
'base_template': 'json.html',
'rows': 5
})
panel_styles = fields.JSONField(style={
'base_template': 'json.html',
'rows': 5
},
required=False)
metadata = fields.JSONField(style={
'base_template': 'json.html',
'rows': 5
},
required=False,
validators=[MetadataValidator()])
last_updated_by = serializers.SerializerMethodField(read_only=True)
thumb_url = serializers.SerializerMethodField(read_only=True)
basemap = serializers.PrimaryKeyRelatedField(
queryset=models.TileSet.objects.all())
zoom = serializers.IntegerField(min_value=1, max_value=20, default=17)
layers = serializers.SerializerMethodField()
layers_url = serializers.SerializerMethodField()
field_list = ('sharing_url', 'center', 'basemap', 'zoom', 'project_id')
def get_sharing_url(self, obj):
return '{0}/maps/{1}'.format(settings.SERVER_URL, obj.slug)
def get_thumb_url(self, obj):
return obj.get_thumb_url()
def get_last_updated_by(self, obj):
return obj.last_updated_by.username
def get_layers(self, obj):
layers = models.Layer.objects.filter(styled_map=obj)
return LayerSerializer(layers, many=True, context={'request': {}}).data
def get_layers_url(self, obj):
return '%s/api/0/maps/%s/layers/' % (settings.SERVER_URL, obj.id)
class Meta:
model = models.StyledMap
read_only_fields = ('time_stamp', 'date_created', 'last_updated_by',
'thumb_url')
fields = BaseSerializer.field_list + \
NamedSerializerMixin.field_list + \
ProjectSerializerMixin.field_list + (
'sharing_url', 'thumb_url', 'center', 'basemap', 'zoom',
'time_stamp', 'date_created', 'last_updated_by', 'slug',
'panel_styles', 'layers', 'layers_url', 'metadata'
)
depth = 0
class MapImageOverlayUpdateSerializer(AuditSerializerMixin,
serializers.ModelSerializer):
file_path = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
geometry = fields.GeometryField(help_text='Assign a GeoJSON string',
allow_null=True,
required=False,
read_only=False,
style={'base_template': 'json.html'},
source='extents')
def get_url(self, obj):
model_name_plural = models.MapImage.model_name_plural
return '%s/api/0/%s/%s/overlays/%s/' % (settings.SERVER_URL,
model_name_plural,
obj.source_mapimage.id, obj.id)
def get_file_path(self, obj):
return obj.encrypt_url(obj.file_name_orig)
class Meta:
model = models.ImageOpts
read_only_fields = ('file_path', 'file_name_orig')
fields = ('id', 'url', 'geometry', 'file_path', 'file_name_orig',
'opacity', 'name')
depth = 0
class GeometrySerializerMixin(serializers.ModelSerializer):
geometry = fields.GeometryField(
help_text='Assign a GeoJSON string',
allow_null=True,
required=False,
style={'base_template': 'json.html', 'rows': 5},
source='point'
)
field_list = ('geometry',)
class UserProfileMixin(AuditSerializerMixin,
serializers.HyperlinkedModelSerializer):
class Meta:
fields = ('url', 'id', 'first_name', 'last_name', 'email', 'username',
'email_announcements', 'default_view_authority',
'default_location', 'contacts', 'date_created', 'time_stamp',
'user')
read_only_fields = ('date_created', 'time_stamp')
user = serializers.HyperlinkedRelatedField(label='user',
view_name='user-detail',
read_only=True)
email = serializers.CharField(required=False,
allow_blank=True,
label='email',
source='user.email')
email_announcements = serializers.BooleanField(
required=True, style={'base_template': 'checkbox.html'})
default_location = fields.GeometryField(required=False,
allow_null=True,
style={
'base_template': 'json.html',
'rows': 5
})
first_name = serializers.CharField(required=False,
allow_blank=True,
label='first_name',
source='user.first_name')
last_name = serializers.CharField(required=False,
allow_blank=True,
label='last_name',
source='user.last_name')
username = serializers.CharField(read_only=True,
label='username',
source='user.username')
contacts = serializers.RelatedField(many=True,
label='contacts',
read_only=True)
default_view_authority = serializers.PrimaryKeyRelatedField(
required=False, queryset=ObjectAuthority.objects.all())
class PrintSerializerDetail(PrintSerializerMixin):
center = fields.GeometryField(
help_text='Assign a GeoJSON center point',
style={'base_template': 'json.html', 'rows': 5},
read_only=True
)
zoom = serializers.IntegerField(
min_value=1, max_value=20, default=17, read_only=True)
layout = serializers.SerializerMethodField()
map_provider = serializers.SerializerMethodField()
class Meta:
model = models.Print
fields = PrintSerializerMixin.Meta.fields
depth = 0
def get_map_provider(self, obj):
return obj.map_provider.id
def get_layout(self, obj):
return obj.layout.id
class PrintSerializer(PrintSerializerMixin):
class Meta:
model = models.Print
fields = PrintSerializerMixin.Meta.fields
fields_read_only = ('id', 'uuid')
depth = 0
center = fields.GeometryField(
help_text='Assign a GeoJSON string',
required=True,
style={'base_template': 'json.html', 'rows': 5}
)
def create(self, validated_data):
from django.contrib.gis.geos import GEOSGeometry
point = GEOSGeometry(validated_data.get('center'))
# Do some extra work to generate the PDF and calculate the map extents:
instance = models.Print.insert_print_record(
self.context.get('request').user,
validated_data.get('project'),
validated_data.get('layout'),
validated_data.get('map_provider'),
validated_data.get('zoom'),
validated_data.get('center'),
self.context.get('request').get_host(),
map_title=validated_data.get('name'),
instructions=validated_data.get('description'),
do_save=False
)
d = {
'uuid': instance.uuid,
'virtual_path': instance.virtual_path,
'layout': validated_data.get('layout'),
'name': validated_data.get('name'),
'description': validated_data.get('description'),
'map_provider': validated_data.get('map_provider'),
'zoom': validated_data.get('zoom'),
'center': validated_data.get('center'),
'project': validated_data.get('project'),
'northeast': instance.northeast,
'southwest': instance.southwest,
'extents': instance.extents,
'host': instance.host,
'map_image_path': instance.map_image_path,
'pdf_path': instance.pdf_path,
'preview_image_path': instance.preview_image_path,
'map_width': instance.map_width,
'map_height': instance.map_height
}
d.update(self.get_presave_create_dictionary())
self.instance = self.Meta.model.objects.create(**d)
pdf_report = instance.generate_pdf()
pdf_file_path = pdf_report.path + '/' + pdf_report.file_name
thumb_file_path = pdf_report.path + '/' + 'thumbnail.jpg'
# Transfer the PDF from file system to Amazon S3
self.instance.pdf_path_S3.save(
pdf_report.file_name, File(open(pdf_file_path)))
self.instance.map_image_path_S3.save(
'thumbnail_' + instance.uuid + '.jpg', File(open(thumb_file_path)))
# serializer.save(**d)
return self.instance
class MapImageSerializerCreate(NamedSerializerMixin, ProjectSerializerMixin,
BaseSerializer):
def __init__(self, *args, **kwargs):
super(MapImageSerializerCreate, self).__init__(*args, **kwargs)
if not self.instance:
return
try:
model = self.instance[0]
except Exception:
model = self.instance
# Sets the storage location upon initialization:
model.media_file_thumb.storage.location = model.get_storage_location()
ext_whitelist = ['jpg', 'jpeg', 'gif', 'png']
media_file = serializers.CharField(source='file_name_orig',
required=True,
style={'base_template': 'file.html'},
help_text='Valid file types are: ' +
', '.join(ext_whitelist))
status = serializers.PrimaryKeyRelatedField(
read_only=False,
required=False,
default=1,
queryset=models.StatusCode.objects.all())
source_print = serializers.PrimaryKeyRelatedField(
queryset=models.Print.objects.all(), required=False, allow_null=True)
geometry = fields.GeometryField(help_text='Assign a GeoJSON string',
allow_null=True,
required=False,
read_only=True,
style={'base_template': 'json.html'},
source='processed_image.extents')
overlay_path = serializers.SerializerMethodField()
file_path = serializers.SerializerMethodField()
file_name = serializers.SerializerMethodField()
media_thumb_url = serializers.SerializerMethodField()
media_scaled_url = serializers.SerializerMethodField()
class Meta:
model = models.MapImage
fields = BaseSerializer.field_list + \
NamedSerializerMixin.field_list + \
ProjectSerializerMixin.field_list + (
'overlay_type', 'source_print', 'geometry',
'overlay_path', 'media_file', 'file_path', 'file_name',
'uuid', 'status', 'media_thumb_url', 'media_scaled_url'
)
read_only_fields = ('uuid', )
def create(self, validated_data):
# Overriding the create method to handle file processing
# owner = self.context.get('request').user
f = self.initial_data.get('media_file')
# ensure filetype is valid:
upload_helpers.validate_file(f, self.ext_whitelist)
owner = self.context.get('request').user
validated_data = {}
validated_data.update(self.validated_data)
validated_data.update(self.get_presave_create_dictionary())
validated_data.update({
'uuid':
generic.generateID(),
'status':
models.StatusCode.objects.get(
id=models.StatusCode.READY_FOR_PROCESSING),
'upload_source':
models.UploadSource.objects.get(id=models.UploadSource.WEB_FORM),
'attribution':
validated_data.get('attribution') or owner.username,
'host':
settings.SERVER_HOST
})
self.instance = self.Meta.model.objects.create(**validated_data)
# process map onto the instance
# from localground.apps.tasks import process_map
# result = process_map.delay(self.instance)
# now save the map_image to S3
self.instance.process_mapImage_to_S3(f)
return self.instance
def get_file_path(self, obj):
try:
return obj.media_file_thumb.url
except Exception:
return None
def get_file_name(self, obj):
try:
return obj.media_file_thumb.name
except Exception:
return None
def get_overlay_path(self, obj):
return obj.processed_map_url_path()
def get_media_thumb_url(self, obj):
try:
return obj.media_file_thumb.url
except Exception:
return None
def get_media_scaled_url(self, obj):
try:
return obj.media_file_scaled.url
except Exception:
return None
