def dimensions(self, request, system_name):
"""
List Dimensions of a UnitSystem
"""
key = request.GET.get('key')
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
ordering = request.GET.get('ordering', 'name')
descending = False
if ordering and ordering[0] == '-':
ordering = ordering[1:]
descending = True
if ordering not in ['code', 'name']:
ordering = 'name'
try:
if request.user and request.user.is_authenticated:
us = UnitSystem(system_name=system_name,
user=request.user,
key=key,
fmt_locale=language)
else:
us = UnitSystem(system_name=system_name, fmt_locale=language)
serializer = DimensionSerializer(sorted(
us.available_dimensions().values(),
key=lambda x: getattr(x, ordering),
reverse=descending),
many=True,
context={'request': request})
return Response(serializer.data, content_type="application/json")
except UnitSystemNotFound as e:
return Response("Unknown unit system: " + str(e),
status=HTTP_404_NOT_FOUND)
def list(self, request: HttpRequest, system_name: str):
"""
List Units, ordered, filtered by key or dimension,
translated in language
"""
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
ordering = request.GET.get('ordering', 'name')
descending = False
if ordering and ordering[0] == '-':
ordering = ordering[1:]
descending = True
if ordering not in ['code', 'name']:
ordering = 'name'
try:
key = request.GET.get('key', None)
user = request.user if \
hasattr(request, 'user') and \
request.user.is_authenticated else None
us = UnitSystem(system_name=system_name,
fmt_locale=language,
user=user,
key=key)
units = []
dimension_param = request.GET.get(key='dimension')
domain_param = request.GET.get(key='domain')
if dimension_param:
try:
dimension = Dimension(unit_system=us, code=dimension_param)
units = dimension.units
except (DimensionNotFound, UnitNotFound) as e:
return Response(f'Invalid dimension filter: {str(e)}',
status=status.HTTP_400_BAD_REQUEST)
else:
available_units = us.available_unit_names()
if available_units:
units = [
us.unit(unit_name=unit_name)
for unit_name in available_units
]
if domain_param:
units = [
u for u in units
if u.code in PHYSICS_DOMAINS.get(domain_param, [])
]
units = sorted(units,
key=lambda x: getattr(x, ordering),
reverse=descending)
serializer = UnitSerializer(units,
many=True,
context={'request': request})
return Response(serializer.data)
except UnitSystemNotFound as e:
return Response(f'Invalid Unit System: {str(e)}',
status=status.HTTP_404_NOT_FOUND)
def retrieve(self, request, system_name):
"""
Retrieve UnitSystem
"""
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
try:
us = UnitSystem(system_name=system_name, fmt_locale=language)
serializer = UnitSystemSerializer(us, context={'request': request})
return Response(serializer.data, content_type="application/json")
except UnitSystemNotFound as e:
return Response("Unknown unit system: " + str(e),
status=HTTP_404_NOT_FOUND)
def reverse_geocode(self, request):
"""
Find country by reverse geocoding (giving latitude and longitude)
"""
if 'geocoding' not in getattr(settings, 'SERVICES'):
return Response("Geocoding service not configured",
status=status.HTTP_412_PRECONDITION_FAILED)
if not request.GET.get('geocoder', 'google') in \
settings.SERVICES['geocoding']:
return Response("Geocoder not found",
status=status.HTTP_404_NOT_FOUND)
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
geocoder = service(service_type='geocoding',
service_name=request.GET.get(
'geocoder', settings.GEOCODING_SERVICE))
try:
data = geocoder.reverse(lat=request.GET.get('latitude'),
lng=request.GET.get('longitude'),
key=request.GET.get(
'geocoder_api_key',
settings.GEOCODER_GOOGLE_KEY),
language=language)
except TypeError as e:
logging.error("Invalid parameters")
logging.error(e)
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
except json.JSONDecodeError as e:
logging.error("Invalid response")
logging.error(e)
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
except ValueError as e:
logging.error("Invalid API configuration")
logging.error(e)
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
except IOError as e:
logging.error("Invalid request")
logging.error(e)
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
except GeocoderRequestError as e:
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
addresses = geocoder.addresses(data)
serializer = AddressSerializer(addresses,
many=True,
context={'request': request})
return Response(serializer.data)
def list(self, request):
"""
List UnitSystems
"""
ordering = request.GET.get('ordering', 'system_name')
descending = False
if ordering and ordering[0] == '-':
ordering = ordering[1:]
descending = True
if ordering not in ['system_name']:
ordering = 'system_name'
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
us = UnitSystem(fmt_locale=language)
us = [{
'system_name': s
} for s in sorted(us.available_systems(), reverse=descending)]
return Response(us, content_type="application/json")
def get_translated_name(self, obj: Country) -> str:
"""
Country translation wrapper
:param obj: Country
"""
request = self.context.get('request', None)
if request:
try:
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
translation = gettext.translation('iso3166',
pycountry.LOCALES_DIR,
languages=[language])
translation.install()
return translation.gettext(obj.name)
except FileNotFoundError:
return obj.name
else:
return obj.name
def retrieve(self, request: HttpRequest, system_name: str, unit_name: str):
"""
Get unit information for unit in unit system
"""
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
try:
key = request.GET.get('key', None)
user = request.user if \
hasattr(request, 'user') and \
request.user.is_authenticated else None
us = UnitSystem(system_name=system_name,
fmt_locale=language,
user=user,
key=key)
unit = us.unit(unit_name=unit_name)
if not unit:
return Response("Unknown unit", status=HTTP_404_NOT_FOUND)
serializer = UnitSerializer(unit, context={'request': request})
return Response(serializer.data, content_type="application/json")
except (UnitSystemNotFound, UnitNotFound):
return Response("Unknown unit", status=HTTP_404_NOT_FOUND)
def list_per_dimension(self, request: HttpRequest, system_name: str):
"""
List Units grouped by dimension, filter on key, translated
"""
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
try:
key = request.GET.get('key', None)
user = request.user if \
hasattr(request, 'user') and \
request.user.is_authenticated else None
us = UnitSystem(system_name=system_name,
fmt_locale=language,
user=user,
key=key)
dimensions = us.dimensions_cache.values()
serializer = DimensionWithUnitsSerializer(
dimensions, many=True, context={'request': request})
return Response(serializer.data)
except UnitSystemNotFound as e:
logging.warning(str(e))
return Response('Invalid Unit System',
status=status.HTTP_404_NOT_FOUND)
def compatible_units(self, request: HttpRequest, system_name: str,
unit_name: str):
"""
List compatible Units
"""
language = validate_language(
request.GET.get('language', request.LANGUAGE_CODE))
ordering = request.GET.get('ordering', 'name')
descending = False
if ordering and ordering[0] == '-':
ordering = ordering[1:]
descending = True
if ordering not in ['code', 'name']:
ordering = 'name'
try:
key = request.GET.get('key', None)
user = request.user if \
hasattr(request, 'user') and \
request.user.is_authenticated else None
us = UnitSystem(system_name=system_name,
fmt_locale=language,
user=user,
key=key)
unit = us.unit(unit_name=unit_name)
compatible_units = sorted([
us.unit(unit_name=cunit)
for cunit in map(str, unit.unit.compatible_units())
],
key=lambda x: getattr(x, ordering),
reverse=descending)
serializer = UnitSerializer(compatible_units,
many=True,
context={'request': request})
return Response(serializer.data, content_type="application/json")
except (UnitSystemNotFound, UnitNotFound):
return Response("Unknown unit", status=HTTP_404_NOT_FOUND)