igs-slm 0.1.0b0__py3-none-any.whl

slm/utils.py

@@ -0,0 +1,299 @@
+import json
+import re
+from datetime import date, datetime, timedelta
+from math import atan2, cos, sin, sqrt
+
+import numpy as np
+from dateutil import parser as date_parser
+from django.conf import settings
+from django.contrib.gis.geos import Point
+from django.core import serializers
+from django.core.exceptions import ImproperlyConfigured
+from PIL import ExifTags, Image
+
+PROTOCOL = getattr(settings, "SLM_HTTP_PROTOCOL", None)
+GPS_EPOCH = date(year=1980, month=1, day=6)
+
+_site_record = None
+
+
+def get_record_model():
+    global _site_record
+    if _site_record is not None:
+        return _site_record
+
+    from django.apps import apps
+
+    slm_site_record = getattr(settings, "SLM_SITE_RECORD", "slm.DefaultSiteRecord")
+    try:
+        app_label, model_class = slm_site_record.split(".")
+        _site_record = apps.get_app_config(app_label).get(model_class.lower(), None)
+        if not _site_record:
+            raise ImproperlyConfigured(
+                f'SLM_SITE_RECORD "{slm_site_record}" is not a registered ' f"model"
+            )
+        return _site_record
+    except ValueError as ve:
+        raise ImproperlyConfigured(
+            f"SLM_SITE_RECORD value {slm_site_record} is invalid, must be "
+            f'"app_label.ModelClass"'
+        ) from ve
+
+
+def dddmmssss_to_decimal(dddmmssss):
+    if dddmmssss is not None:
+        if isinstance(dddmmssss, str):
+            dddmmssss = float(dddmmssss)
+        dddmmssss /= 10000
+        degrees = int(dddmmssss)
+        minutes = (dddmmssss - degrees) * 100
+        seconds = float((minutes - int(minutes)) * 100)
+        return degrees + int(minutes) / 60 + seconds / 3600
+    return None
+
+
+def decimal_to_dddmmssss(dec):
+    if dec is not None:
+        if isinstance(dec, str):
+            dec = float(dec)
+        degrees = int(dec)
+        minutes = (dec - degrees) * 60
+        seconds = float(minutes - int(minutes)) * 60
+        return degrees * 10000 + int(minutes) * 100 + seconds
+    return None
+
+
+def dddmmss_ss_parts(dec):
+    """
+    Return (degrees, minutes, seconds) from decimal degrees
+    :param dec: Decimal degrees lat or lon
+    :return:
+    """
+    if dec is not None:
+        if isinstance(dec, str):
+            dec = float(dec)
+        degrees = int(dec)
+        minutes = (dec - degrees) * 60
+        seconds = float(minutes - int(minutes)) * 60
+        return degrees, abs(int(minutes)), abs(seconds)
+    return None, None, None
+
+
+def set_protocol(request):
+    global PROTOCOL
+    if not PROTOCOL:
+        PROTOCOL = "https" if request.is_secure() else "http"
+
+
+def get_protocol():
+    global PROTOCOL
+    if PROTOCOL is not None:
+        return PROTOCOL
+    return "https" if getattr(settings, "SECURE_SSL_REDIRECT", False) else "http"
+
+
+def build_absolute_url(path, request=None):
+    if path.startswith("mailto:"):
+        return path
+    if request:
+        return request.build_absolute_uri(path)
+    return f'{get_url()}/{path.lstrip("/")}'
+
+
+def get_url():
+    from django.contrib.sites.models import Site
+
+    return f"{get_protocol()}://{Site.objects.get_current().domain}"
+
+
+def from_email():
+    from django.contrib.sites.models import Site
+
+    return getattr(
+        settings, "SERVER_EMAIL", f"noreply@{Site.objects.get_current().domain}"
+    )
+
+
+def clear_caches():
+    from slm.models import Site, User
+
+    User.is_moderator.cache_clear()
+    Site.is_moderator.cache_clear()
+
+
+def to_bool(bool_str):
+    if bool_str is None:
+        return None
+    if isinstance(bool_str, str):
+        return bool_str.lower() not in ["0", "no", "false"]
+    return bool(bool_str)
+
+
+def to_snake_case(string):
+    snake = string
+    if string:
+        snake = string[0].lower()
+        new = False
+        for char in string[1:]:
+            if char == " ":
+                new = True
+            elif char.isupper() or new:
+                snake += f"_{char.lower()}"
+                new = False
+            elif char.isalnum():
+                snake += char
+    return snake
+
+
+def date_to_str(date_obj):
+    if date_obj:
+        return f"{date_obj.year}-{date_obj.month:02}-{date_obj.day:02}"
+    return ""
+
+
+def gps_week(date_obj=datetime.now()):
+    """
+    Return GPS week number for a given datetime, date or date string
+    :param date_obj: Date object, datetime object or date string
+    :return: 2-tuple: GPS week number, GPS day of week
+    :raises ValueError: If date_obj is earlier than the GPS epoch
+    """
+    # todo move this to igs_tools
+    if date_obj is None:
+        date_obj = datetime.now().date()
+    if isinstance(date_obj, str):
+        date_obj = date_parser.parse(date_obj)
+    if isinstance(date_obj, datetime):
+        date_obj = date_obj.date()
+    delta = date_obj - GPS_EPOCH
+    if delta.days >= 0:
+        return delta.days // 7, delta.days % 7
+    raise ValueError(f"{date_obj} is earlier than the GPS epoch {GPS_EPOCH}.")
+
+
+def date_from_gps_week(gps_week, day_of_week=0):
+    """
+    Return a date object for a given GPS week number and day of week
+    :param gps_week: GPS week number
+    :param day_of_week: GPS day of week, 0-6
+    :return: Date object
+    """
+    # todo move this to igs_tools
+    return GPS_EPOCH + timedelta(days=gps_week * 7 + day_of_week)
+
+
+def day_of_year(date_obj=datetime.now()):
+    """
+    Return the day of the year for the given object representing a date.
+
+    :param date_obj: Date object, datetime object or date string
+    :return: integer day of year
+    """
+    # todo move this to igs_tools
+    if isinstance(date_obj, str):
+        date_obj = date_parser.parse(date_obj)
+    if isinstance(date_obj, datetime):
+        date_obj = date_obj.date()
+    return (date_obj - date(date_obj.year, 1, 1) + timedelta(days=1)).days
+
+
+def http_accepts(accepted_types, mimetype):
+    if "*/*" in accepted_types:
+        return True
+    if mimetype in accepted_types:
+        return True
+    typ, sub_type = mimetype.split("/")
+    if f"{typ}/*" in accepted_types:
+        return True
+    if f"*/{sub_type}" in accepted_types:
+        return True
+    return False
+
+
+class SectionEncoder(json.JSONEncoder):
+    def default(self, obj):
+        from django.db.models import Manager, Model, QuerySet
+
+        from slm.models import Equipment, Manufacturer, SiteSection
+
+        if hasattr(obj, "isoformat"):
+            return obj.isoformat()
+        if isinstance(obj, SiteSection):
+            return {field: getattr(obj, field) for field in obj.site_log_fields()}
+        if isinstance(obj, Equipment):
+            return {field: getattr(obj, field) for field in ["model", "manufacturer"]}
+        if isinstance(obj, Manufacturer):
+            return {field: getattr(obj, field) for field in ["name"]}
+
+        if isinstance(obj, Model):
+            # catch-all
+            return json.loads(serializers.serialize("json", [obj]))[0]
+
+        if isinstance(obj, (Manager, QuerySet)):
+            return [related for related in obj.all()]
+
+        if isinstance(obj, Point):
+            return obj.coords
+        return json.JSONEncoder.default(self, obj)
+
+
+def get_exif_tags(file_path):
+    # not all images have exif, (e.g. gifs)
+    image_exif = getattr(Image.open(file_path), "_getexif", lambda: None)()
+    if image_exif:
+        exif = {
+            ExifTags.TAGS[k]: v
+            for k, v in image_exif.items()
+            if k in ExifTags.TAGS and not isinstance(v, bytes)
+        }
+        return exif
+    return {}
+
+
+def xyz2llh(xyz):
+    a_e = 6378.1366e3  # meters
+    f_e = 1 / 298.25642  # IERS2000 standards
+    radians2degree = 45 / atan2(1, 1)
+
+    xyz_array = np.array(xyz) / a_e
+    (x, y, z) = (xyz_array[0], xyz_array[1], xyz_array[2])
+    e2 = f_e * (2 - f_e)
+    z2 = z**2
+    p2 = x**2 + y**2
+    p = sqrt(p2)
+    r = sqrt(p2 + z2)
+    mu = atan2(z * (1 - f_e + e2 / r), p)
+    phi = atan2(
+        z * (1 - f_e) + e2 * (sin(mu)) ** 3, (1 - f_e) * (p - e2 * (cos(mu)) ** 3)
+    )
+    lat = phi * radians2degree
+    lon = atan2(y, x) * radians2degree
+    if lon < 0:
+        lon = lon + 360
+    h = a_e * (p * cos(phi) + z * sin(phi) - sqrt(1 - e2 * (sin(phi)) ** 2))
+
+    return lat, lon, h
+
+
+def convert_9to4(text: str, name: str) -> str:
+    """
+    In any text convert the 9 character string to the equivalent 4 character site name.
+    """
+    return re.compile(re.escape(name), re.IGNORECASE).sub(
+        lambda match: match.group(0)[0:4], text
+    )
+
+
+def convert_4to9(text: str, name: str) -> str:
+    """
+    In any text convert the 4 character string to the equivalent 9 character site name.
+    """
+
+    def match_case(match: str) -> str:
+        if match.isupper():
+            return name.upper()
+        elif match.islower():
+            return name.lower()
+        return name
+
+    return re.compile(re.escape(name[0:4]), re.IGNORECASE).sub(match_case, text)

slm/validators.py

@@ -0,0 +1,297 @@
+from collections import namedtuple
+from datetime import datetime, timezone
+
+from django.core.exceptions import ValidationError
+from django.core.validators import RegexValidator
+from django.db.models import Model
+from django.utils.translation import gettext as _
+
+from slm.defines import EquipmentState, FlagSeverity
+
+# we can't use actual nulls for times because it breaks things like
+# Greatest on MYSQL
+# NULL_TIME = datetime.utcfromtimestamp(0)
+NULL_TIME = datetime.fromtimestamp(0, timezone.utc)
+NULL_VALUES = [None, "", NULL_TIME]
+
+
+Flag = namedtuple("Flag", "message manual severity")
+
+
+def get_validators(model, field):
+    from django.conf import settings
+
+    """
+    Get the validator list for a given model and field from validation 
+    settings.
+    
+    :param model: The Django model name <app_name>.<ModelClass>
+    :param field: The field name 
+    :return:
+    """
+    if isinstance(model, Model) or (
+        isinstance(model, type) and issubclass(model, Model)
+    ):
+        model = model._meta.label
+    return getattr(settings, "SLM_DATA_VALIDATORS", {}).get(model, {}).get(field, [])
+
+
+# toggle this flag to allow save block bypassing.
+BYPASS_BLOCKS = None
+
+
+def set_bypass(toggle):
+    global BYPASS_BLOCKS
+    BYPASS_BLOCKS = bool(toggle)
+
+
+def bypass_block():
+    """
+    Return if we should bypass any validation save blocking. This setting
+    is controlled by the SLM_VALIDATION_BYPASS_BLOCK setting in settings or
+    can be preempted by toggling the BYPASS_BLOCKS flag above.
+
+    This is important when working with legacy data. All validators should
+    respect this flag.
+
+    :return: True if we should bypass any save blocks
+    """
+    from django.conf import settings
+
+    if BYPASS_BLOCKS is None:
+        return getattr(settings, "SLM_VALIDATION_BYPASS_BLOCK")
+    return bool(BYPASS_BLOCKS)
+
+
+class SLMValidator:
+    severity = FlagSeverity.NOTIFY
+
+    def __init__(self, *args, **kwargs):
+        self.severity = kwargs.pop("severity", self.severity)
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, instance, field, value):
+        raise NotImplementedError()
+
+    def validate(self, instance, field, validator):
+        try:
+            validator()
+        except ValidationError as ve:
+            if self.severity == FlagSeverity.BLOCK_SAVE and not bypass_block():
+                raise ve
+            self.throw_flag(ve.message, instance, field)
+
+    def throw_error(self, message, instance, field):
+        if self.severity == FlagSeverity.BLOCK_SAVE and not bypass_block():
+            raise ValidationError(_(message))
+        self.throw_flag(message, instance, field)
+
+    def throw_flag(self, message, instance, field):
+        if not instance._flags:
+            instance._flags = {}
+        instance._flags[field.name] = message
+        instance.save()
+
+
+class FieldRequired(SLMValidator):
+    required_msg = _("This field is required.")
+    desired_msg = _("This field is desired.")
+
+    allow_legacy_nulls = False
+
+    desired = False
+
+    def __init__(self, allow_legacy_nulls=allow_legacy_nulls, desired=desired):
+        self.allow_legacy_nulls = allow_legacy_nulls
+        self.desired = desired
+        super().__init__(severity=FlagSeverity.BLOCK_SAVE)
+
+    def __call__(self, instance, field, value):
+        if isinstance(value, str):
+            value = value.strip()
+        if value in NULL_VALUES:
+            if (
+                self.desired
+                or not self.allow_legacy_nulls
+                or instance.get_initial_value(field.name) in NULL_VALUES
+            ):
+                self.throw_flag(self.desired_msg, instance, field)
+            else:
+                self.throw_error(self.required_msg, instance, field)
+
+
+class EnumValidator(SLMValidator):
+    statement = _("Value not in Enumeration.")
+
+    def __call__(self, instance, field, value):
+        if isinstance(value, str):
+            value = value.strip()
+        if value not in NULL_VALUES:
+            try:
+                field.enum(value)
+            except ValueError:
+                self.throw_error(self.statement, instance, field)
+
+
+class VerifiedEquipmentValidator(SLMValidator):
+    statement = _("This equipment code has not been verified.")
+
+    def __call__(self, instance, field, value):
+        if value.state == EquipmentState.UNVERIFIED:
+            self.throw_error(self.statement, instance, field)
+        elif value.state == EquipmentState.LEGACY:
+            self.throw_error(self.statement, instance, field)
+
+
+class ActiveEquipmentValidator(SLMValidator):
+    statement = _("This equipment code is no longer in use.")
+    replaced_statement = _("This equipment code has been replaced by: {}.")
+
+    def __call__(self, instance, field, value):
+        if value.state == EquipmentState.LEGACY:
+            if value.replaced_by.exists():
+                self.throw_error(
+                    self.replaced_statement.format(
+                        ", ".join([eq.model for eq in value.replaced_by.all()])
+                    ),
+                    instance,
+                    field,
+                )
+            else:
+                self.throw_error(self.statement, instance, field)
+
+
+class NonEmptyValidator(SLMValidator):
+    statement = _("More than zero selections should be made.")
+
+    def __call__(self, instance, field, value):
+        if not value.all():
+            self.throw_error(self.statement, instance, field)
+
+
+class FourIDValidator(SLMValidator):
+    regex_val = RegexValidator(regex=r"[A-Z0-9]{4}")
+
+    def __call__(self, instance, field, value):
+        self.validate(instance, field, lambda: self.regex_val(value))
+        if not instance.site.name.startswith(value):
+            self.throw_error(
+                f"{field.verbose_name} "
+                f'{_("must be the prefix of the 9 character site name")}.',
+                instance,
+                field,
+            )
+
+
+class ARPValidator(SLMValidator):
+    def __call__(self, instance, field, value):
+        at_arp = getattr(
+            getattr(instance, "antenna_type", None), "reference_point", None
+        )
+        if at_arp != value:
+            self.throw_error(
+                f'{getattr(value, "name", None)} '
+                f'{_("must does not match the antenna reference point: ")}'
+                f'{getattr(at_arp, "name", None)}.',
+                instance,
+                field,
+            )
+
+
+class TimeRangeBookendValidator(SLMValidator):
+    """
+    Ensures that sections that should not have overlapping time ranges
+    are properly bookended - i.e. that the time range fields are closed before
+    the next section starts.
+    """
+
+    accessor: str
+    bookend_field: str
+
+    def __init__(
+        self, *args, bookend_field="installed", severity=FlagSeverity.NOTIFY, **kwargs
+    ):
+        self.bookend_field = bookend_field
+        assert self.bookend_field, "Bookend field must be specified."
+        super().__init__(*args, severity=severity, **kwargs)
+
+    def __call__(self, instance, field, value):
+        sections = (
+            getattr(
+                instance.site,
+                instance._meta.get_field("site").remote_field.get_accessor_name(),
+            )
+            .head()
+            .sort(reverse=True)
+        )
+        last = sections[0]
+        for section in sections[1:]:
+            # todo - this should be unnecessary when validation system is made
+            #   more robust
+            if "Must end before" in section._flags.get(field.name, ""):
+                del section._flags[field.name]
+                section.save()
+            ######
+
+            last_start = getattr(last, self.bookend_field, None)
+            if getattr(section, field.name, None) is None or (
+                last_start and last_start < getattr(section, field.name)
+            ):
+                self.throw_error(
+                    _("Must end before {} starts {}.").format(
+                        last, getattr(last, self.bookend_field, None)
+                    ),
+                    section,
+                    field,
+                )
+
+            last = section
+
+
+class TimeRangeValidator(SLMValidator):
+    start_field = None
+    end_field = None
+
+    def __init__(self, *args, severity=FlagSeverity.BLOCK_SAVE, **kwargs):
+        self.start_field = kwargs.pop("start_field", None)
+        self.end_field = kwargs.pop("end_field", None)
+        assert not (self.start_field and self.end_field)
+        super().__init__(*args, severity=severity, **kwargs)
+
+    def __call__(self, instance, field, value):
+        if self.start_field:
+            start = getattr(instance, self.start_field, None)
+            if start is not None and start != NULL_TIME and value:
+                if start > value:
+                    self.throw_error(
+                        f"{field.verbose_name} "
+                        f'{_("must be greater than")} '
+                        f"{instance._meta.get_field(self.start_field).verbose_name}",
+                        instance,
+                        field,
+                    )
+        if self.end_field:
+            end = getattr(instance, self.end_field, None)
+            if end is not None and end != NULL_TIME:
+                if (
+                    value is None
+                    or value == NULL_TIME
+                    and end is not None
+                    and end != NULL_TIME
+                ):
+                    self.throw_error(
+                        f'{_("Cannot define")} '
+                        f"{instance._meta.get_field(self.end_field).verbose_name} "
+                        f'{_("without defining")} '
+                        f"{field.verbose_name}.",
+                        instance,
+                        field,
+                    )
+                elif end < value:
+                    self.throw_error(
+                        f"{field.verbose_name} "
+                        f'{_("must be less than")} '
+                        f"{instance._meta.get_field(self.end_field).verbose_name}",
+                        instance,
+                        field,
+                    )