def update_location(self, request, pk=None): #print("UPDATE LOCATION") serializer = self.get_serializer(data=request.data) if serializer.is_valid(): track = self.get_object() point_serializer = PointField() #print(track) if track.path is None: track.path = MultiPointField(child=PointField( required=False)).to_internal_value([]) track.path.append(point_serializer.to_internal_value(request.data)) timestamp = request.data.pop('timestamp', '') if track.timestamps is None: track.timestamps = [] track.timestamps.append(timestamp) track.save() return response.Response({'ok': True}) else: #print(serializer.errors) return response.Response(data=serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class RouteSerializer(serializers.ModelSerializer): user = serializers.CharField() start_point = PointField() finish_point = PointField() class Meta: model = Route fields = ['id', 'user', 'date_and_time', 'start_point', 'finish_point']
class AddressSerializer(serializers.ModelSerializer): # lat = PointSerializer(source='point.y', read_only=True) lat = PointField(source='point.y', read_only=True) lng = PointField(source='point.x', read_only=True) class Meta: model = Address fields = ("street", "street_cp", "city", "province", "postal_code", "country", "lat", "lng")
class TransportationSerializer(serializers.ModelSerializer): start_point = PointField() end_point = PointField() type_of_hazardous_material = HazardousMaterialSerializer() class Meta: model = Transportation fields = ('id', 'start_point', 'end_point', 'checkpoint_set', 'volume', 'distance', 'risk_value', 'type_of_hazardous_material')
class TripSerializer(commonserializer.CommonSerializer): tripId = serializers.IntegerField() carId = serializers.IntegerField() driverId = serializers.IntegerField() sourceLocation = PointField() destinationLocation = PointField() startTimeInEpochs = serializers.IntegerField() endTimeInEpochs = serializers.IntegerField() tripPrice = serializers.FloatField(min_value=0.0) tripStatus = serializers.ChoiceField(choices=utils.enumTuples(TripStatus)) paymentMode = serializers.ChoiceField(choices=utils.enumTuples(PaymentMode))
class RouteSerializer(serializers.ModelSerializer): user = serializers.SlugRelatedField(many=False, queryset=User.objects.all(), slug_field='id') steps = StepSerializer(many=True, read_only=True) origin = PointField() destination = PointField() #purchase = serializers.IntegerField(max_length=255, min_length=4, validators=[]) #purchase = serializers.SlugRelatedField(many=False,queryset=Purchase.objects.all(),slug_field='id', required=False) class Meta: model = Route #fields = ('id','distance', 'init_time', 'user', 'steps') fields = "__all__"
class ComputingSalarySerializer(serializers.Serializer): ''' serializer for validating fields of the function ''' to_formated_address = serializers.CharField(required=True) from_formated_address = serializers.CharField(required=True) weight = serializers.IntegerField(required=True) from_location = PointField(required=True) to_location = PointField(required=True) def validate(self, attrs): to_location = attrs["to_location"] from_location = attrs["from_location"] PackageSerializer.distance_between_points(to_location, from_location) return attrs
class InstEducativaSerializer(serializers.ModelSerializer): ubicacion = PointField(required=False) departamento_nombre = serializers.SerializerMethodField() provincia_nombre = serializers.SerializerMethodField() distrito_nombre = serializers.SerializerMethodField() class Meta: model = InstitucionEducativa fields = ('codigo_colegio', 'codigo_modular', 'nombre', 'ubigeo', 'direccion', 'nivel', 'nivel_descripcion', 'tipo', 'tipo_descripcion', 'nombre_ugel', 'establecimiento_renaes', 'establecimiento_nombre', 'ubicacion', 'departamento_nombre', 'provincia_nombre', 'distrito_nombre',) def get_departamento_nombre(self, obj): if obj.ubigeo: try: departamento = UbigeoDepartamento.objects.get(cod_ubigeo_inei_departamento=obj.ubigeo[:2]) return departamento.ubigeo_departamento except UbigeoDepartamento.DoesNotExist: return '' def get_provincia_nombre(self, obj): if obj.ubigeo: try: provincia = UbigeoProvincia.objects.get(cod_ubigeo_inei_provincia=obj.ubigeo[:4]) return provincia.ubigeo_provincia except UbigeoProvincia.DoesNotExist: return '' def get_distrito_nombre(self, obj): if obj.ubigeo: try: distrito = UbigeoDistrito.objects.get(cod_ubigeo_inei_distrito=obj.ubigeo) return distrito.ubigeo_distrito except UbigeoDistrito.DoesNotExist: return ''
class TrackSerializer(serializers.ModelSerializer): """ created = serializers.DateTimeField( format=settings.DATETIME_FORMAT, required=False ) """ timestamps = serializers.ListField( child=serializers.DateTimeField(format=settings.DATETIME_FORMAT, required=False), required=False, style={ 'base_template': 'textarea.html', 'rows': 8 }, help_text='Array of "YYYY-MM-DDT00:00:00Z" strings') path = MultiPointField( child=PointField(required=False, ), style={ 'base_template': 'textarea.html', 'rows': 8 }, help_text='Array of {latitude,longitude} JSON objects', required=False) class Meta: model = Track fields = '__all__' name = 'track'
class UserSerializer(ModelSerializer): location = PointField() class Meta: model = User fields = ('id', 'username', 'first_name', 'last_name', 'location')
class LocationSerializer(serializers.ModelSerializer): location = PointField(required=False) class Meta: model = Location fields = [ 'id', 'number', 'street', 'unit', 'neighborhood', 'city', 'state', 'zipcode', 'country', 'location', 'name', 'type', 'comment', 'updated_by', 'updated_on' ] read_only_fields = ('id', 'updated_by') def create(self, validated_data): # get current user user = validated_data['updated_by'] # check credentials # only super can create if not user.is_superuser: raise PermissionDenied() return super().create(validated_data) def update(self, instance, validated_data): # get current user user = validated_data['updated_by'] # check credentials # only super can update if not user.is_superuser: raise PermissionDenied() return super().update(instance, validated_data)
class TargetSerializer(serializers.ModelSerializer): title = serializers.CharField(max_length=60) topic = serializers.ChoiceField(choices=TOPIC_CHOICES) position = PointField() radius_in_m = serializers.FloatField() class Meta: model = Target fields = ( 'id', 'title', 'topic', 'position', 'radius_in_m', ) def validate(self, attrs): current_user = self.context['request'].user user_targets = Target.objects.filter(user_id=current_user.id) if (user_targets.count() >= MAX_TARGETS_PER_USER): raise serializers.ValidationError( "Users can't register more than " f"{MAX_TARGETS_PER_USER} targets.") else: return super().validate(attrs) def validate_radius_in_m(self, value): if value < 0.0: raise serializers.ValidationError( 'radius must be equal or higher than 0.') return value
class FacilityUpsertSerializer(serializers.ModelSerializer): """ Use only for listing and upserting - Upsert based on name and district uniqueness """ capacity = serializers.ListSerializer(child=FacilityCapacitySerializer(), source="facilitycapacity_set") location = PointField(required=False) district = serializers.IntegerField() class Meta: model = Facility fields = [ "id", "name", "facility_type", "address", "district", "location", "oxygen_capacity", "phone_number", "capacity", "created_by", ] def validate_name(self, value): return str(value).strip().replace(" ", " ") def validate_phone_number(self, value): return str(value).strip().replace(" ", " ") def create(self, validated_data): raise NotImplementedError() def update(self, instance, validated_data): raise NotImplementedError()
class RideSerializer(serializers.ModelSerializer): """ Serializer for public rides """ passengers = BaseUserSerializer(many=True, read_only=True) owner = BaseUserSerializer(many=False, read_only=True) vehicle = VehicleSerializer(many=False, read_only=True) start_loc = PointField(required=True) end_loc = PointField(required=True) class Meta: model = Ride fields = [ 'owner', 'start_loc_name', 'end_loc_name', 'start_loc', 'end_loc', 'time', 'vehicle', 'passengers', 'id', 'title', 'description' ]
class UserSerializer(serializers.ModelSerializer): coords = PointField() class Meta: model = Account fields = ('id', 'email', 'first_name', 'last_name', 'level', 'location', 'coords', 'personal_description')
class PlaceSerializer(serializers.ModelSerializer): geom = PointField() class Meta: model = Place exclude = ['id'] read_only_fields = ['id']
class FacilitySerializer(FacilityBasicInfoSerializer): """Serializer for facility.models.Facility.""" facility_type = ChoiceField(choices=FACILITY_TYPES) # A valid location => { # "latitude": 49.8782482189424, # "longitude": 24.452545489 # } location = PointField(required=False) class Meta: model = Facility fields = [ "id", "name", "local_body", "district", "state", "facility_type", "address", "location", "oxygen_capacity", "phone_number", "local_body_object", "district_object", "state_object", "modified_date", "created_date", ] read_only_fields = ("modified_date", "created_date") def create(self, validated_data): validated_data["created_by"] = self.context["request"].user return super().create(validated_data)
class FacilitySerializer(serializers.ModelSerializer): """Serializer for facility.models.Facility.""" facility_type = ChoiceField(choices=FACILITY_TYPES) # A valid location => { # "latitude": 49.8782482189424, # "longitude": 24.452545489 # } location = PointField(required=False) local_body_object = LocalBodySerializer(source="local_body", read_only=True) district_object = DistrictSerializer(source="district", read_only=True) state_object = StateSerializer(source="state", read_only=True) class Meta: model = Facility fields = [ "id", "name", "local_body", "district", "state", "facility_type", "address", "location", "oxygen_capacity", "phone_number", "local_body_object", "district_object", "state_object", ]
class AddressSerializer(serializers.ModelSerializer): ''' serializer for client address used ad a field ''' location = PointField() class Meta: model = Address fields = ('id', 'formated_address', 'location', 'address_description')
class MyRideSerializer(serializers.ModelSerializer): """ Serializer for authenticated user's own rides """ passengers = BaseUserSerializer(many=True, read_only=True) start_loc = PointField(required=True) end_loc = PointField(required=True) def create(self, validated_data): return Ride.objects.create(**validated_data) class Meta: model = Ride fields = [ 'owner', 'start_loc_name', 'end_loc_name', 'start_loc', 'end_loc', 'time', 'vehicle', 'passengers', 'id', 'title', 'description' ]
class LocationSerializer(serializers.ModelSerializer): location = PointField() class Meta: model = Location fields = ("uuid", "name", "location", "elevation") read_only_fields = ["uuid", "elevation"]
class ClosestLocationSerializer(serializers.ModelSerializer): distance = serializers.IntegerField(source="distance.m", read_only=True) location = PointField() class Meta: model = Location fields = ("uuid", "name", "location", "elevation", "distance") read_only_fields = ["uuid", "elevation", "distance"]
class AmbulanceSerializer(serializers.ModelSerializer): location = PointField(required=False) class Meta: model = Ambulance fields = [ 'id', 'identifier', 'capability', 'status', 'orientation', 'location', 'location_timestamp', 'comment', 'updated_by', 'updated_on' ] read_only_fields = ('updated_by', ) def validate(self, data): # location and location_timestamp must be defined together if 'location' in data or 'location_timestamp' in data: if not ('location' in data and 'location_timestamp' in data): raise serializers.ValidationError( 'location and location_timestamp must be set together') if data['location'] and not data['location_timestamp']: raise serializers.ValidationError( 'location cannot be set without location_timestamp') if not data['location'] and data['location_timestamp']: raise serializers.ValidationError( 'location_timestamp cannot be set without location') return data def create(self, validated_data): # get current user user = validated_data['updated_by'] # check credentials # only super can create if not user.is_superuser: raise PermissionDenied() return super().create(validated_data) def update(self, instance, validated_data): # get current user user = validated_data['updated_by'] # check credentials if not user.is_superuser: # serializer.instance will always exist! if not user.profile.ambulances.filter(can_write=True, ambulance=instance.id): raise PermissionDenied() return super().update(instance, validated_data)
def point2str(point): if point is None: return None if isinstance(point, GEOSGeometry): return PointField().to_representation(point) elif isinstance(point, dict): return {'latitude': point['latitude'], 'longitude': point['longitude']} else: raise Exception("Unknown point type")
class AmbulanceUpdateCompactSerializer(serializers.ModelSerializer): location = PointField(required=False) updated_by_username = serializers.CharField(source='updated_by.username', required=False) class Meta: model = AmbulanceUpdate fields = ['status', 'orientation', 'location', 'timestamp', 'updated_by_username', 'updated_on'] read_only_fields = ['updated_by_username', 'updated_on']
class FacilityUpsertSerializer(serializers.ModelSerializer): """ Use only for listing and upserting - Upsert based on name and district uniqueness """ capacity = serializers.ListSerializer(child=FacilityCapacitySerializer(), source="facilitycapacity_set") location = PointField(required=False) class Meta: model = Facility fields = [ "id", "name", "district", "facility_type", "address", "location", "oxygen_capacity", "phone_number", "capacity", "created_by", ] def validate_name(self, value): return str(value).strip().replace(" ", " ") def validate_phone_number(self, value): return str(value).strip().replace(" ", " ") def create(self, validated_data): capacities = validated_data.pop("facilitycapacity_set") facility = Facility.objects.filter( **{ "name__iexact": validated_data["name"], "district": validated_data["district"], }).first() user = self.context["user"] if not facility: validated_data["created_by"] = user facility = Facility.objects.create(**validated_data) else: if facility.created_by != user and not user.is_superuser: raise PermissionDenied(f"{facility} is owned by another user") for k, v in validated_data.items(): setattr(facility, k, v) facility.save() for ca in capacities: facility.facilitycapacity_set.update_or_create( room_type=ca["room_type"], defaults=ca) return facility def update(self, instance, validated_data): raise NotImplementedError()
class LastLocationSerializer(serializers.ModelSerializer): user = serializers.SlugRelatedField(many=False, queryset=User.objects.all(), slug_field='id', required=False) location = PointField() class Meta: model = LastLocation fields = ('location', 'timestamp', 'user')
class PointOfInterestSerializer(TaggitSerializer, SerializerErrorMessagesMixin, serializers.HyperlinkedModelSerializer): img = Base64ImageField(required=False) id = serializers.ReadOnlyField() htags = TagListSerializerField() location = PointField(required=False) class Meta: model = PointOfInterest fields = "__all__"
class PointSerializer(serializers.Serializer): point = PointField(required=False) created = serializers.DateTimeField() def update(self, instance, validated_data): instance.point = validated_data['point'] return instance def create(self, validated_data): return SavePoint(**validated_data)
class TreeSerializer(serializers.ModelSerializer): location = PointField() class Meta: model = Tree fields = '__all__' def create(self, validated_data): obj, created = Tree.objects.get_or_create(**validated_data) return obj, created