igs-slm 0.1.0b0__py3-none-any.whl

slm/settings/routines.py

@@ -0,0 +1,43 @@
+from django.utils.translation import gettext_lazy as _
+from django_routines import command, routine
+
+
+routine(
+    "deploy",
+    _(
+        "Run collection of commands that likely need to be run whenever code is updated."
+    ),
+    switch_helps={
+        "initial": _(
+            "Run collection of commands that should only be run on the first deployment."
+        ),
+        "validate": _("Run validation routines on the entire database."),
+    },
+)
+
+routine(
+    "import",
+    _("Import equipment from the IGS and site log data from your own archive."),
+)
+
+routine(
+    "install",
+    _("Install a fresh deployment of the SLM and import data from external sources."),
+)
+
+command("deploy", "check", "--deploy")
+command("deploy", "shellcompletion", "install", switches=["initial"])
+command("deploy", "migrate", priority=11)
+command("deploy", "renderstatic", priority=20)
+command("deploy", "collectstatic", "--no-input", priority=21)
+command("deploy", "set_site", priority=22)
+command("deploy", "validate_db", "--schema", priority=30, switches=["re-validate"])
+command("deploy", "synchronize", priority=32, switches=["re-validate"])
+
+command("import", "import_equipment", "antennas", "radomes", "receivers", priority=10)
+command("import", "import_archive", priority=20)
+command("import", "validate_db", "--schema", priority=30)
+
+command("install", "routine", "deploy", "--initial", priority=0)
+command("install", "createsuperuser", priority=10)
+command("install", "routine", "import", priority=20)

slm/settings/secrets.py

@@ -0,0 +1,37 @@
+import os
+from pathlib import Path
+
+from slm.settings import get_setting
+
+SLM_SECRETS_DIR = get_setting(
+    "SLM_SECRETS_DIR", Path(get_setting("SITE_DIR")) / "secrets"
+)
+
+
+def generate_secret_key(filename):
+    from django.core.management.utils import get_random_secret_key
+
+    with open(filename, "w") as f:
+        f.write("%s\n" % get_random_secret_key())
+    os.chmod(filename, 0o640)
+
+
+def get_secret_key(filename):
+    with open(filename, "r") as f:
+        return f.readlines()[0]
+
+
+if not os.path.exists(SLM_SECRETS_DIR):
+    os.makedirs(SLM_SECRETS_DIR)
+
+
+sk_file = os.path.join(SLM_SECRETS_DIR, "secret_key")
+
+if not os.path.exists(sk_file):
+    generate_secret_key(sk_file)
+
+SECRET_KEY = get_secret_key(sk_file)
+
+if len(SECRET_KEY) == 0:
+    generate_secret_key(sk_file)
+    SECRET_KEY = get_secret_key(sk_file)

slm/settings/security.py

@@ -0,0 +1,5 @@
+SECURE_SSL_REDIRECT = True
+CSRF_COOKIE_SECURE = True
+SESSION_COOKIE_SECURE = True
+SECURE_REFERRER_POLICY = "origin"
+X_FRAME_OPTIONS = "DENY"

slm/settings/slm.py

@@ -0,0 +1,188 @@
+"""
+SLM Specific Configuration parameters go here.
+"""
+
+import os
+
+from slm.defines import (
+    AlertLevel,
+    GeodesyMLVersion,
+    SiteFileUploadStatus,
+    SiteLogStatus,
+)
+from slm.settings import get_setting, set_default
+
+# manage.py will set this to true if django has been loaded to run a
+# management command
+SLM_MANAGEMENT_MODE = os.environ.get("SLM_MANAGEMENT_FLAG", False) == "ON"
+
+set_default(
+    "SLM_ALERT_COLORS",
+    {
+        AlertLevel.NOTICE: "#12CAF0",
+        AlertLevel.WARNING: "#E3AA00",
+        AlertLevel.ERROR: "#DD3444",
+    },
+)
+
+set_default(
+    "SLM_STATUS_COLORS",
+    {
+        SiteLogStatus.FORMER: "#3D4543",
+        SiteLogStatus.SUSPENDED: "#E0041A",
+        SiteLogStatus.PROPOSED: "#913D88",
+        SiteLogStatus.UPDATED: "#0079AD",
+        SiteLogStatus.PUBLISHED: "#0D820D",
+        SiteLogStatus.EMPTY: "#D3D3D3",
+    },
+)
+
+set_default(
+    "SLM_FILE_COLORS",
+    {
+        SiteFileUploadStatus.UNPUBLISHED: "#0079AD",
+        SiteFileUploadStatus.PUBLISHED: "#0D820D",
+        SiteFileUploadStatus.INVALID: "#8b0000",
+        SiteFileUploadStatus.WARNINGS: "#E3AA00",
+        SiteFileUploadStatus.VALID: "#0D820D",
+    },
+)
+
+# if True, for subsections and missing sections, placeholder structures will
+# be added to the logs
+set_default("SLM_LEGACY_PLACEHOLDERS", True)
+
+# the maximum file upload size in Mega Bytes
+set_default("SLM_MAX_UPLOAD_SIZE_MB", 100)
+
+# a map of file icons (css) from mimetype subtypes
+set_default(
+    "SLM_FILE_ICONS",
+    {
+        "zip": "bi bi-file-zip",
+        "x-tar": "bi bi-file-zip",
+        "plain": "bi bi-filetype-txt",
+        "jpeg": "bi bi-filetype-jpg",
+        "svg+xml": "bi bi-filetype-svg",
+        "xml": "bi bi-filetype-xml",
+        "json": "bi bi-filetype-json",
+        "png": "bi bi-filetype-png",
+        "tiff": "bi bi-filetype-tiff",
+        "pdf": "bi bi-filetype-pdf",
+        "gif": "bi bi-filetype-gif",
+        "csv": "bi bi-filetype-csv",
+        "bmp": "bi bi-filetype-bmp",
+        "vnd.openxmlformats-officedocument.wordprocessingml.document": "bi bi-filetype-doc",
+        "msword": "bi bi-filetype-doc",
+    },
+)
+
+# generated image thumbnail size in pixels - this is a tuple of maximum width
+# and height - the aspect ratio will be preserved
+set_default("SLM_THUMBNAIL_SIZE", 250)
+
+# during deploy the current Site will be set to SLM_SITE_NAME, SLM_ORG_NAME
+# The name of the organization used in communications
+set_default("SLM_ORG_NAME", "SLM")
+
+set_default("SLM_SITE_NAME", (get_setting("ALLOWED_HOSTS", []) or ["localhost"])[0])
+
+# set this to either http or https, this will be used to determine the protocol
+# of absolute uri links where a request object is not present
+set_default("SLM_HTTP_PROTOCOL", None)
+
+# this should point to a cached property that holds the set of Django
+# permissions relevant to the SLM - if you extend the permission set override
+# this property
+set_default("SLM_PERMISSIONS", "slm.authentication.default_permissions")
+
+# These default permission groups will be created on migration
+set_default(
+    "SLM_DEFAULT_PERMISSION_GROUPS",
+    {"Agency Manager": ["propose_sites", "moderate_sites"]},
+)
+
+# the xsd schemas that should be preloaded on start - if a schema is used
+# that is not preloaded it will be lazily loaded which can take some time and
+# will prolong the request. It can be useful to disable this during testing to
+# reduce load times. It is recommended to leave this set to the default setting
+# in production
+set_default("SLM_PRELOAD_SCHEMAS", [geo for geo in GeodesyMLVersion])
+
+# By default the SLM will not send moderation related emails to user accounts
+# who have never logged in, set this to False to disable this behavior
+# This does not apply to account related emails like password reset requests
+set_default("SLM_EMAILS_REQUIRE_LOGIN", True)
+
+# Automated alert configuration
+#
+set_default(
+    "SLM_AUTOMATED_ALERTS",
+    {
+        "slm.GeodesyMLInvalid": {
+            "issue": [
+                "slm.signals.site_published",
+                "slm.signals.site_file_published",
+                "slm.signals.site_file_unpublished",
+            ],
+            "level": AlertLevel.ERROR,
+            "send_email": False,
+        },
+        "slm.ReviewRequested": {
+            "issue": ["slm.signals.review_requested"],
+            "rescind": [
+                "slm.signals.updates_rejected",
+                "slm.signals.site_published",
+                "slm.signals.section_added",
+                "slm.signals.section_edited",
+                "slm.signals.section_deleted",
+            ],
+            "level": AlertLevel.NOTICE,
+            "send_email": True,
+        },
+        "slm.UpdatesRejected": {
+            "issue": ["slm.signals.updates_rejected"],
+            "rescind": [
+                "slm.signals.review_requested",
+                "slm.signals.site_published",
+                "slm.signals.section_added",
+                "slm.signals.section_edited",
+                "slm.signals.section_deleted",
+            ],
+            "level": AlertLevel.ERROR,
+            "send_email": True,
+        },
+        "slm.SiteLogPublished": {
+            "issue": {"slm.signals.site_published"},
+            "level": AlertLevel.NOTICE,
+            "send_email": True,
+        },
+        "slm.UnpublishedFilesAlert": {
+            "issue": {
+                "slm.signals.site_file_uploaded",
+                "slm.signals.site_file_unpublished",
+            },
+            "rescind": [
+                "slm.signals.site_file_published",
+                "slm.signals.site_file_deleted",
+            ],
+            "level": AlertLevel.NOTICE,
+            "send_email": True,
+        },
+    },
+)
+
+# slm provides an implementation of urls.py that will load this list into
+# url patterns. This should be a list of 2-tuples where the first tuple is the
+# path stem mount point for the included apps' URLs and the second element is
+# the string that will be passed to django.urls.include
+SLM_URL_MOUNTS = []
+
+
+# control the domain used to generate absolute links to the SLM log document
+# attachments including images and files. Any standalone artifacts produced by
+# the slm that include links to files served by the SLM will use this domain
+# as the stem. If empty the default site domain will be used. You probably
+# do not need to set this field unless you are serving files off a different
+# instance than the instance that generates serialized artifacts
+SLM_FILE_DOMAIN = None

slm/settings/static_templates.py

@@ -0,0 +1,53 @@
+from slm.settings import get_setting
+
+
+def get_enum_context():
+    # this needs to be wrapped in a function call because these enums use the
+    # translation infrastructure which cannot be invoked before settings have
+    # been fully realized.
+    from slm.defines import (
+        AlertLevel,
+        LogEntryType,
+        SiteFileUploadStatus,
+        SiteLogFormat,
+        SiteLogStatus,
+        SLMFileType,
+    )
+
+    return {
+        "enums": [
+            LogEntryType,
+            SiteLogStatus,
+            AlertLevel,
+            SiteFileUploadStatus,
+            SiteLogFormat,
+            SLMFileType,
+        ]
+    }
+
+
+def get_defines_context():
+    from slm.defines import AlertLevel, SiteLogStatus
+
+    return {"AlertLevel": AlertLevel, "SiteLogStatus": SiteLogStatus}
+
+
+def get_icon_context():
+    from django.conf import settings
+
+    from slm.templatetags.slm import file_icon
+
+    return {
+        "ICON_MAP": getattr(settings, "SLM_FILE_ICONS", {}),
+        "DEFAULT_ICON": file_icon(""),
+    }
+
+
+STATIC_TEMPLATES = {
+    "templates": [
+        ("slm/js/urls.js", {"dest": get_setting("STATIC_ROOT") / "urls.js"}),
+        ("slm/js/enums.js", {"context": get_enum_context}),
+        ("slm/js/fileIcons.js", {"context": get_icon_context}),
+        ("slm/css/defines.css", {"context": get_defines_context}),
+    ]
+}

slm/settings/templates.py

@@ -0,0 +1,29 @@
+from jinja2 import select_autoescape
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+            "builtins": ["slm.templatetags.slm"],
+        },
+    },
+    {
+        "BACKEND": "django.template.backends.jinja2.Jinja2",
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "autoescape": select_autoescape(
+                disabled_extensions=("log",),
+                default_for_string=True,
+                default=True,
+            ),
+            "environment": "slm.templatetags.jinja2.compat",
+        },
+    },
+]

slm/settings/uploads.py

@@ -0,0 +1,8 @@
+from slm.settings import get_setting, set_default
+
+MEDIA_URL = "/media/"
+set_default("MEDIA_ROOT", get_setting("SITE_DIR") / "media")
+
+# set RWX for Owner and Group for any uploaded files
+FILE_UPLOAD_PERMISSIONS = 0o770
+FILE_UPLOAD_DIRECTORY_PERMISSIONS = 0o770

slm/settings/urls.py

@@ -0,0 +1,126 @@
+"""
+SLM URL Configuration
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/stable/topics/http/urls/
+
+Instead of having to define your own urls.py for a deployment of SLM we try to
+do most of the work for you in this default file. If you develop an app and you
+want it to be automatically included in your SLM urls you should add the flag
+SLM_INCLUDE = True to your apps urls.py file. If you do so the urls in your
+app will be included into your deployment at the / mount point. If you wish to
+extend the APIs by providing your own endpoints you may do so by supplying an
+APIS dictionary. For example the slm.map app extends the public API like so:
+
+.. code-block: python
+
+    from django.urls import path
+    from slm.map.api.edit import views as edit_views
+    from slm.map.api.public import views as public_views
+    from slm.map.views import MapView
+
+    SLM_INCLUDE = True
+
+    APIS = {
+        'edit': {
+            'serializer_module': 'slm.map.api.edit.serializers',
+            'endpoints': [
+                ('stations', edit_views.StationListViewSet),
+                ('map', edit_views.StationMapViewSet),
+            ]
+        },
+        'public': {
+            'serializer_module': 'slm.map.api.public.serializers',
+            'endpoints': [
+                ('stations', public_views.StationListViewSet),
+                ('map', public_views.StationMapViewSet),
+            ]
+        }
+    }
+
+Other third party apps may be included at customizable mount points by
+providing a settings.SLM_URL_MOUNTS list. For example to include your app at
+the myapp path you might do this:
+
+.. code-block: python
+
+    SLM_URL_MOUNTS = [
+        ('myapp/', 'myapp.urls')
+    ]
+
+"""
+
+from importlib import import_module
+
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.staticfiles.urls import staticfiles_urlpatterns
+from django.urls import include, path
+from rest_framework.routers import DefaultRouter
+
+APIS = {}
+
+
+class ReregisterableRouter(DefaultRouter):
+    def register(self, prefix, viewset, base_name=None):
+        if base_name is None:
+            base_name = self.get_default_base_name(viewset)
+        idx = 0
+        for api in self.registry:
+            if prefix == api[0] and base_name == api[2]:
+                self.registry[idx] = (prefix, viewset, base_name)
+                idx += 1
+                return
+            idx += 1
+        self.registry.append((prefix, viewset, base_name))
+
+
+def bring_in_urls(urlpatterns):
+    routers = {}
+
+    for app in reversed(settings.INSTALLED_APPS):
+        try:
+            url_module = import_module(f"{app}.urls")
+            api = getattr(url_module, "APIS", None)
+            if api:
+                for api, endpoints in api.items():
+                    if api not in routers:
+                        routers[api] = ReregisterableRouter()
+                    router = routers[api]
+                    for endpoint in endpoints:
+                        router.register(
+                            endpoint[0],
+                            endpoint[1],
+                            base_name=(
+                                endpoint[0] if len(endpoint) < 3 else endpoint[2]
+                            ),
+                        )
+
+        except ImportError:
+            if app in {"slm", "slm.map", "network_map", "igs_ext"}:
+                raise
+            pass
+
+    for api, router in routers.items():
+        # todo how to nest under slm?
+        pattern = path(
+            f"api/{api}/", include((router.urls, "slm"), namespace=f"slm_{api}_api")
+        )
+        urlpatterns.append(pattern)
+        APIS.setdefault(f"{api}_api", []).append(pattern)
+
+
+urlpatterns = [
+    path("admin/", admin.site.urls),
+    path("accounts/", include("allauth.urls")),
+    path("ckeditor/", include("ckeditor_uploader.urls")),
+    path("", include("slm.urls")),
+]
+
+if getattr(settings, "DJANGO_DEBUG_TOOLBAR", False):
+    urlpatterns.append(path("__debug__/", include("debug_toolbar.urls")))
+
+# allows us to use static files like images
+urlpatterns += staticfiles_urlpatterns()
+
+bring_in_urls(urlpatterns)

slm/settings/validation.py

@@ -0,0 +1,196 @@
+"""
+This file contains the default validation configuration configuration
+for site log fields. Amend or override SLM_DATA_VALIDATORS to use
+different routines.
+
+The format of SLM_DATA_VALIDATORS is
+{
+    <app_label>.<ModelCalss>: {
+        '<field_name>': [Validator1(), Validator2(), ...]
+    }
+}
+"""
+
+from slm.validators import (
+    ActiveEquipmentValidator,
+    ARPValidator,
+    EnumValidator,
+    FieldRequired,
+    NonEmptyValidator,
+    TimeRangeBookendValidator,
+    TimeRangeValidator,
+    VerifiedEquipmentValidator,
+)
+
+# toggling this off will prevent any validation configured to block edit saves
+# from doing so - instead flags will be issued.
+SLM_VALIDATION_BYPASS_BLOCK = False
+
+# do not allow a log to be published without these sections
+SLM_REQUIRED_SECTIONS_TO_PUBLISH = [
+    "siteform",
+    "siteidentification",
+    "sitelocation",
+    "sitereceiver",
+    "siteantenna",
+    # 'sitesurveyedlocalties',
+    # 'sitefrequencystandard',
+    # 'sitecollocation',
+    # 'sitehumiditysensor',
+    # 'sitepressuresensor',
+    # 'sitetemperaturesensor',
+    # 'sitewatervaporradiometer',
+    # 'siteotherinstrumentation',
+    # 'siteradiointerferences',
+    # 'sitemultipathsources',
+    # 'sitesignalobstructions',
+    # 'sitelocalepisodiceffects',
+    "siteoperationalcontact",
+    # 'siteresponsibleagency',
+    # 'sitemoreinformation'
+]
+
+# the model field to validator map
+SLM_DATA_VALIDATORS = {
+    "slm.SiteIdentification": {
+        "site_name": [FieldRequired()],
+        "fracture_spacing": [FieldRequired(desired=True), EnumValidator()],
+        "iers_domes_number": [FieldRequired()],
+        "date_installed": [FieldRequired()],
+    },
+    "slm.SiteLocation": {
+        "city": [FieldRequired()],
+        "country": [FieldRequired(), EnumValidator()],
+        "tectonic": [EnumValidator()],
+        "xyz": [FieldRequired()],
+        "llh": [FieldRequired()],
+    },
+    "slm.SiteReceiver": {
+        "receiver_type": [VerifiedEquipmentValidator(), ActiveEquipmentValidator()],
+        "satellite_system": [NonEmptyValidator()],
+        "serial_number": [FieldRequired()],
+        "firmware": [FieldRequired()],
+        "installed": [FieldRequired(), TimeRangeValidator(end_field="removed")],
+        "removed": [
+            TimeRangeValidator(start_field="installed"),
+            TimeRangeBookendValidator(),
+        ],
+    },
+    "slm.SiteAntenna": {
+        "antenna_type": [VerifiedEquipmentValidator(), ActiveEquipmentValidator()],
+        "radome_type": [VerifiedEquipmentValidator(), ActiveEquipmentValidator()],
+        "serial_number": [FieldRequired()],
+        "reference_point": [FieldRequired(), ARPValidator(), EnumValidator()],
+        "installed": [FieldRequired(), TimeRangeValidator(end_field="removed")],
+        "removed": [
+            TimeRangeValidator(start_field="installed"),
+            TimeRangeBookendValidator(),
+        ],
+        "marker_une": [FieldRequired(allow_legacy_nulls=True)],
+        "alignment": [FieldRequired(allow_legacy_nulls=True)],
+    },
+    "slm.SiteSurveyedLocalTies": {
+        "name": [FieldRequired()],
+        "measured": [FieldRequired(allow_legacy_nulls=True)],
+        "diff_xyz": [FieldRequired(allow_legacy_nulls=True)],
+    },
+    "slm.SiteFrequencyStandard": {
+        "standard_type": [FieldRequired(), EnumValidator()],
+        "effective_start": [
+            FieldRequired(),
+            TimeRangeValidator(end_field="effective_end"),
+        ],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteCollocation": {
+        "instrument_type": [FieldRequired()],
+        "status": [FieldRequired(allow_legacy_nulls=True), EnumValidator()],
+        "effective_start": [
+            FieldRequired(),
+            TimeRangeValidator(end_field="effective_end"),
+        ],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteHumiditySensor": {
+        "model": [FieldRequired()],
+        "manufacturer": [FieldRequired()],
+        "height_diff": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [TimeRangeValidator(end_field="effective_end")],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+        "aspiration": [FieldRequired(allow_legacy_nulls=True), EnumValidator()],
+    },
+    "slm.SitePressureSensor": {
+        "model": [FieldRequired()],
+        "manufacturer": [FieldRequired()],
+        "height_diff": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [TimeRangeValidator(end_field="effective_end")],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteTemperatureSensor": {
+        "model": [FieldRequired()],
+        "manufacturer": [FieldRequired()],
+        "height_diff": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [TimeRangeValidator(end_field="effective_end")],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+        "aspiration": [FieldRequired(allow_legacy_nulls=True), EnumValidator()],
+    },
+    "slm.SiteWaterVaporRadiometer": {
+        "model": [FieldRequired()],
+        "manufacturer": [FieldRequired()],
+        "distance_to_antenna": [FieldRequired(allow_legacy_nulls=True)],
+        "height_diff": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [TimeRangeValidator(end_field="effective_end")],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteOtherInstrumentation": {"instrumentation": [FieldRequired()]},
+    "slm.SiteRadioInterferences": {
+        "interferences": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [
+            FieldRequired(),
+            TimeRangeValidator(end_field="effective_end"),
+        ],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteMultiPathSources": {
+        "sources": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [
+            FieldRequired(),
+            TimeRangeValidator(end_field="effective_end"),
+        ],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteSignalObstructions": {
+        "obstructions": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [
+            FieldRequired(),
+            TimeRangeValidator(end_field="effective_end"),
+        ],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteLocalEpisodicEffects": {
+        "event": [FieldRequired(allow_legacy_nulls=True)],
+        "effective_start": [
+            FieldRequired(),
+            TimeRangeValidator(end_field="effective_end"),
+        ],
+        "effective_end": [TimeRangeValidator(start_field="effective_start")],
+    },
+    "slm.SiteOperationalContact": {
+        "agency": [FieldRequired()],
+        "preferred_abbreviation": [FieldRequired()],
+        "primary_name": [FieldRequired()],
+        "primary_phone1": [FieldRequired(desired=True)],
+        "primary_email": [FieldRequired(allow_legacy_nulls=True)],
+    },
+    "slm.SiteResponsibleAgency": {
+        "agency": [FieldRequired()],
+        "preferred_abbreviation": [FieldRequired()],
+        "primary_name": [FieldRequired()],
+        "primary_phone1": [FieldRequired(desired=True)],
+        "primary_email": [FieldRequired(allow_legacy_nulls=True)],
+    },
+    "slm.SiteMoreInformation": {
+        "primary": [FieldRequired()],
+        "secondary": [FieldRequired()],
+    },
+}