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
