aa-srp-access 0.1.0__tar.gz

aa_srp_access-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install build tools
+        run: python -m pip install --upgrade build twine
+      - name: Build distributions
+        run: python -m build
+      - name: Validate distributions
+        run: python -m twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/aa-srp-access
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish to PyPI with Trusted Publishing
+        uses: pypa/gh-action-pypi-publish@release/v1

aa_srp_access-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,38 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    services:
+      redis:
+        image: redis:7
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install package and test tools
+        run: python -m pip install --upgrade pip ".[test]"
+      - name: Django checks and tests
+        env:
+          DJANGO_SETTINGS_MODULE: testauth.settings
+        run: |
+          python -m django check
+          python -m django makemigrations srp_access --check --dry-run
+          python -m django test srp_access.tests
+      - name: Build distributions
+        run: python -m build
+      - name: Validate distributions
+        run: python -m twine check dist/*

aa_srp_access-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.sqlite3
+.coverage
+.pytest_cache/
+.venv/
+build/
+dist/
+*.egg-info/
+*.rej

aa_srp_access-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project are documented here. The project follows
+Semantic Versioning.
+
+## 0.1.0 - 2026-09-12
+
+- Add configurable State and Group authorization.
+- Add mappings for explicitly exposed built-in SRP fleets.
+- Add restricted fleet list, detail, and request submission views.
+- Store submissions as normal Alliance Auth built-in `SrpUserRequest` records.
+- Add server-side direct URL protection, administration, tests, packaging, and
+  Trusted Publishing workflow.

aa_srp_access-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aa-srp-access contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aa_srp_access-0.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.5
+Name: aa-srp-access
+Version: 0.1.0
+Summary: Restricted, configurable access to Alliance Auth's built-in SRP
+Project-URL: Homepage, https://github.com/thegriffenkd/aa-srp-access
+Project-URL: Changelog, https://github.com/thegriffenkd/aa-srp-access/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/thegriffenkd/aa-srp-access/issues
+Project-URL: Source, https://github.com/thegriffenkd/aa-srp-access
+Author: aa-srp-access contributors
+License: MIT License
+        
+        Copyright (c) 2026 aa-srp-access contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django :: 5.2
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: <3.15,>=3.10
+Requires-Dist: allianceauth<5.3,>=5.2
+Requires-Dist: django-solo<3,>=2.5
+Provides-Extra: test
+Requires-Dist: build>=1.2; extra == 'test'
+Requires-Dist: twine>=5; extra == 'test'
+Description-Content-Type: text/markdown
+
+# aa-srp-access
+
+`aa-srp-access` is a standalone Alliance Auth application that provides a
+restricted frontend for Alliance Auth's built-in Ship Replacement Program
+(SRP). It does not replace the built-in SRP backend or administration.
+
+Restricted users can access the frontend only when both conditions are true:
+
+- their Alliance Auth State is eligible; and
+- they belong to the configured Django/Alliance Auth Group.
+
+They see only built-in SRP fleets explicitly exposed by an administrator.
+Requests are stored as normal built-in `SrpUserRequest` records, so existing
+SRP administrators continue to approve, reject, update, and pay them through
+the normal Alliance Auth SRP interface.
+
+## Compatibility
+
+- Alliance Auth `5.2.x`
+- Python `3.10` through `3.14`, matching Alliance Auth 5.2 metadata
+- Django `5.2.x`, supplied by Alliance Auth
+
+The initial compatibility target is Alliance Auth 5.2.0. Test upgrades before
+changing either the Alliance Auth or app version constraint.
+
+## Security model
+
+Every plugin view performs server-side authorization. Navigation visibility is
+only a convenience and is not treated as access control. A submitted fleet ID
+is re-queried through the authorized fleet queryset, and an unexposed fleet
+returns a safe 404. Anonymous users are redirected to login; authenticated
+users who fail the State or Group check receive 403.
+
+State, Group, and fleet names are never authorization constants. Configuration
+uses database relations to `authentication.State`, `auth.Group`, and the
+built-in `srp.SrpFleetMain` model.
+
+## Requirements
+
+- A working Alliance Auth 5.2 installation with built-in SRP enabled
+- Django admin access
+- The built-in `auth.srp_management` permission for app configuration
+
+## Installation
+
+Add a pinned release to the Alliance Auth requirements file:
+
+```text
+aa-srp-access==0.1.0
+```
+
+Add the Python module to local settings:
+
+```python
+INSTALLED_APPS += [
+    "srp_access",
+]
+```
+
+Rebuild the application image, then run:
+
+```bash
+python manage.py migrate srp_access
+python manage.py collectstatic --noinput
+```
+
+Restart the web, worker, and scheduler processes using the deployment's normal
+procedure. No Alliance Auth core files or core migrations are changed.
+
+## Docker installation
+
+Service names vary between deployments. From the correct Compose project
+directory, the usual sequence is:
+
+1. Add `aa-srp-access==0.1.0` to `conf/requirements.txt`.
+2. Add `srp_access` to `INSTALLED_APPS` in local Django settings.
+3. Rebuild the Alliance Auth image with `docker compose build`.
+4. Run `docker compose run --rm <web-service> python manage.py migrate srp_access`.
+5. Run `docker compose run --rm <web-service> python manage.py collectstatic --noinput`.
+6. Recreate the web, workers, and beat/scheduler services.
+7. Verify container health and both the standard and restricted SRP pages.
+
+Back up the database and configuration first. Determine the correct Compose
+project and service names before running commands; do not copy the examples
+blindly into a production deployment.
+
+## Initial configuration
+
+1. Sign in to Django admin as a staff user with `auth.srp_management`.
+2. Open **Restricted SRP settings**.
+3. Select the required access Group.
+4. Choose State behavior:
+   - enable **allow any public state** to require `State.public=True`; or
+   - disable it and select one or more specific State objects.
+5. Add **Exposed SRP fleet** rows for existing built-in SRP fleets.
+6. Leave an exposure enabled only while that fleet should be available.
+
+An exposed fleet must also be open in built-in SRP: it needs a non-empty SRP
+code and an incomplete status. Disabling or completing it in built-in SRP
+removes it from the restricted list without deleting the exposure mapping.
+
+## Permissions and groups
+
+The access Group is application data selected in admin; its name is not fixed.
+State eligibility and Group membership are both mandatory. Superuser or staff
+status does not bypass the restricted frontend's State-and-Group rule.
+
+Configuration in Django admin is guarded by Alliance Auth's existing
+`auth.srp_management` permission. Normal built-in SRP permissions and pages are
+not modified.
+
+## How to expose fleets
+
+Create fleets through the normal built-in SRP interface. In Django admin, add
+an **Exposed SRP fleet** mapping and select the existing fleet object. The
+one-to-one relation prevents duplicate mappings. Removing a built-in fleet also
+removes its exposure mapping; it does not affect unrelated SRP data.
+
+## Upgrading
+
+1. Back up the Alliance Auth database and configuration.
+2. Pin the desired `aa-srp-access` version in requirements.
+3. Rebuild the image.
+4. Run `python manage.py migrate srp_access`.
+5. Run `collectstatic` when release notes require it.
+6. Recreate services and verify both SRP frontends.
+
+Test Alliance Auth upgrades on a test server with the currently pinned plugin
+version before upgrading production.
+
+## Uninstall considerations
+
+Removing the app does not remove built-in SRP fleets or requests. Plugin-owned
+settings and exposure mappings remain in the database unless their tables are
+explicitly removed. Back up first; do not reverse migrations casually on a
+production installation. Remove `srp_access` from `INSTALLED_APPS` only after
+planning whether to retain or remove those plugin tables.
+
+## Development and testing
+
+Run tests against a Redis instance on localhost database 15:
+
+```bash
+python -m django test srp_access.tests --settings=testauth.settings
+```
+
+Build and validate distributions:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+The test suite uses SQLite and arbitrary fixture names. It covers anonymous,
+State, Group, exposed-fleet, direct URL, submission, built-in SRP regression,
+and built-in administrator behavior.
+
+## Release process
+
+Update the changelog and version, merge tested changes, and create a deliberate
+GitHub Release. The release workflow builds and validates wheel/sdist artifacts
+before publishing through a PyPI Trusted Publisher and the protected `pypi`
+GitHub environment. Ordinary pushes never publish.

aa_srp_access-0.1.0/README.md

@@ -0,0 +1,164 @@
+# aa-srp-access
+
+`aa-srp-access` is a standalone Alliance Auth application that provides a
+restricted frontend for Alliance Auth's built-in Ship Replacement Program
+(SRP). It does not replace the built-in SRP backend or administration.
+
+Restricted users can access the frontend only when both conditions are true:
+
+- their Alliance Auth State is eligible; and
+- they belong to the configured Django/Alliance Auth Group.
+
+They see only built-in SRP fleets explicitly exposed by an administrator.
+Requests are stored as normal built-in `SrpUserRequest` records, so existing
+SRP administrators continue to approve, reject, update, and pay them through
+the normal Alliance Auth SRP interface.
+
+## Compatibility
+
+- Alliance Auth `5.2.x`
+- Python `3.10` through `3.14`, matching Alliance Auth 5.2 metadata
+- Django `5.2.x`, supplied by Alliance Auth
+
+The initial compatibility target is Alliance Auth 5.2.0. Test upgrades before
+changing either the Alliance Auth or app version constraint.
+
+## Security model
+
+Every plugin view performs server-side authorization. Navigation visibility is
+only a convenience and is not treated as access control. A submitted fleet ID
+is re-queried through the authorized fleet queryset, and an unexposed fleet
+returns a safe 404. Anonymous users are redirected to login; authenticated
+users who fail the State or Group check receive 403.
+
+State, Group, and fleet names are never authorization constants. Configuration
+uses database relations to `authentication.State`, `auth.Group`, and the
+built-in `srp.SrpFleetMain` model.
+
+## Requirements
+
+- A working Alliance Auth 5.2 installation with built-in SRP enabled
+- Django admin access
+- The built-in `auth.srp_management` permission for app configuration
+
+## Installation
+
+Add a pinned release to the Alliance Auth requirements file:
+
+```text
+aa-srp-access==0.1.0
+```
+
+Add the Python module to local settings:
+
+```python
+INSTALLED_APPS += [
+    "srp_access",
+]
+```
+
+Rebuild the application image, then run:
+
+```bash
+python manage.py migrate srp_access
+python manage.py collectstatic --noinput
+```
+
+Restart the web, worker, and scheduler processes using the deployment's normal
+procedure. No Alliance Auth core files or core migrations are changed.
+
+## Docker installation
+
+Service names vary between deployments. From the correct Compose project
+directory, the usual sequence is:
+
+1. Add `aa-srp-access==0.1.0` to `conf/requirements.txt`.
+2. Add `srp_access` to `INSTALLED_APPS` in local Django settings.
+3. Rebuild the Alliance Auth image with `docker compose build`.
+4. Run `docker compose run --rm <web-service> python manage.py migrate srp_access`.
+5. Run `docker compose run --rm <web-service> python manage.py collectstatic --noinput`.
+6. Recreate the web, workers, and beat/scheduler services.
+7. Verify container health and both the standard and restricted SRP pages.
+
+Back up the database and configuration first. Determine the correct Compose
+project and service names before running commands; do not copy the examples
+blindly into a production deployment.
+
+## Initial configuration
+
+1. Sign in to Django admin as a staff user with `auth.srp_management`.
+2. Open **Restricted SRP settings**.
+3. Select the required access Group.
+4. Choose State behavior:
+   - enable **allow any public state** to require `State.public=True`; or
+   - disable it and select one or more specific State objects.
+5. Add **Exposed SRP fleet** rows for existing built-in SRP fleets.
+6. Leave an exposure enabled only while that fleet should be available.
+
+An exposed fleet must also be open in built-in SRP: it needs a non-empty SRP
+code and an incomplete status. Disabling or completing it in built-in SRP
+removes it from the restricted list without deleting the exposure mapping.
+
+## Permissions and groups
+
+The access Group is application data selected in admin; its name is not fixed.
+State eligibility and Group membership are both mandatory. Superuser or staff
+status does not bypass the restricted frontend's State-and-Group rule.
+
+Configuration in Django admin is guarded by Alliance Auth's existing
+`auth.srp_management` permission. Normal built-in SRP permissions and pages are
+not modified.
+
+## How to expose fleets
+
+Create fleets through the normal built-in SRP interface. In Django admin, add
+an **Exposed SRP fleet** mapping and select the existing fleet object. The
+one-to-one relation prevents duplicate mappings. Removing a built-in fleet also
+removes its exposure mapping; it does not affect unrelated SRP data.
+
+## Upgrading
+
+1. Back up the Alliance Auth database and configuration.
+2. Pin the desired `aa-srp-access` version in requirements.
+3. Rebuild the image.
+4. Run `python manage.py migrate srp_access`.
+5. Run `collectstatic` when release notes require it.
+6. Recreate services and verify both SRP frontends.
+
+Test Alliance Auth upgrades on a test server with the currently pinned plugin
+version before upgrading production.
+
+## Uninstall considerations
+
+Removing the app does not remove built-in SRP fleets or requests. Plugin-owned
+settings and exposure mappings remain in the database unless their tables are
+explicitly removed. Back up first; do not reverse migrations casually on a
+production installation. Remove `srp_access` from `INSTALLED_APPS` only after
+planning whether to retain or remove those plugin tables.
+
+## Development and testing
+
+Run tests against a Redis instance on localhost database 15:
+
+```bash
+python -m django test srp_access.tests --settings=testauth.settings
+```
+
+Build and validate distributions:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+The test suite uses SQLite and arbitrary fixture names. It covers anonymous,
+State, Group, exposed-fleet, direct URL, submission, built-in SRP regression,
+and built-in administrator behavior.
+
+## Release process
+
+Update the changelog and version, merge tested changes, and create a deliberate
+GitHub Release. The release workflow builds and validates wheel/sdist artifacts
+before publishing through a PyPI Trusted Publisher and the protected `pypi`
+GitHub environment. Ordinary pushes never publish.

aa_srp_access-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aa-srp-access"
+dynamic = ["version"]
+description = "Restricted, configurable access to Alliance Auth's built-in SRP"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "aa-srp-access contributors" }]
+requires-python = ">=3.10,<3.15"
+dependencies = [
+    "allianceauth>=5.2,<5.3",
+    "django-solo>=2.5,<3",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Web Environment",
+    "Framework :: Django :: 5.2",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP",
+]
+
+[project.optional-dependencies]
+test = [
+    "build>=1.2",
+    "twine>=5",
+]
+
+[project.urls]
+Homepage = "https://github.com/thegriffenkd/aa-srp-access"
+Changelog = "https://github.com/thegriffenkd/aa-srp-access/blob/main/CHANGELOG.md"
+Issues = "https://github.com/thegriffenkd/aa-srp-access/issues"
+Source = "https://github.com/thegriffenkd/aa-srp-access"
+
+[tool.hatch.version]
+path = "srp_access/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["srp_access"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/.github",
+    "/srp_access",
+    "/testauth",
+    "/CHANGELOG.md",
+    "/LICENSE",
+    "/README.md",
+    "/pyproject.toml",
+]

aa_srp_access-0.1.0/srp_access/__init__.py

@@ -0,0 +1,3 @@
+"""Restricted frontend for Alliance Auth's built-in SRP application."""
+
+__version__ = "0.1.0"

aa_srp_access-0.1.0/srp_access/access.py

@@ -0,0 +1,79 @@
+from django.core.exceptions import ObjectDoesNotExist
+
+from allianceauth.srp.models import SrpFleetMain
+
+from .models import ExposedSrpFleet, SrpAccessSettings
+
+
+def get_access_settings():
+    """Return configured settings without creating database state during requests."""
+    return SrpAccessSettings.objects.first()
+
+
+def user_has_eligible_state(user, settings=None):
+    if not getattr(user, "is_authenticated", False):
+        return False
+
+    try:
+        state = user.profile.state
+    except ObjectDoesNotExist:
+        return False
+
+    if state is None:
+        return False
+
+    settings = settings or get_access_settings()
+    if settings is None:
+        return False
+
+    if settings.allow_any_public_state:
+        return bool(state.public)
+
+    return settings.selected_states.filter(pk=state.pk).exists()
+
+
+def user_in_required_group(user, settings=None):
+    if not getattr(user, "is_authenticated", False):
+        return False
+
+    settings = settings or get_access_settings()
+    if settings is None or settings.required_group_id is None:
+        return False
+
+    return user.groups.filter(pk=settings.required_group_id).exists()
+
+
+def fleet_is_exposed(fleet):
+    fleet_id = getattr(fleet, "pk", fleet)
+    if fleet_id is None:
+        return False
+    return ExposedSrpFleet.objects.filter(fleet_id=fleet_id, enabled=True).exists()
+
+
+def can_use_restricted_srp(user, fleet=None):
+    settings = get_access_settings()
+    if settings is None:
+        return False
+    if not user_has_eligible_state(user, settings):
+        return False
+    if not user_in_required_group(user, settings):
+        return False
+    if fleet is not None and not fleet_is_exposed(fleet):
+        return False
+    return True
+
+
+def accessible_fleets_for(user):
+    """Return exposed built-in fleets that currently accept SRP requests."""
+    if not can_use_restricted_srp(user):
+        return SrpFleetMain.objects.none()
+
+    return (
+        SrpFleetMain.objects.select_related("fleet_commander")
+        .filter(
+            srp_access_exposure__enabled=True,
+            fleet_srp_status="",
+        )
+        .exclude(fleet_srp_code="")
+        .order_by("-fleet_time", "-pk")
+    )

aa_srp_access-0.1.0/srp_access/admin.py

@@ -0,0 +1,39 @@
+from django.contrib import admin
+from solo.admin import SingletonModelAdmin
+
+from .models import ExposedSrpFleet, SrpAccessSettings
+
+
+class SrpManagementPermissionMixin:
+    management_permission = "auth.srp_management"
+
+    def _can_manage(self, request):
+        return request.user.has_perm(self.management_permission)
+
+    def has_module_permission(self, request):
+        return self._can_manage(request)
+
+    def has_view_permission(self, request, obj=None):
+        return self._can_manage(request)
+
+    def has_add_permission(self, request):
+        return self._can_manage(request)
+
+    def has_change_permission(self, request, obj=None):
+        return self._can_manage(request)
+
+    def has_delete_permission(self, request, obj=None):
+        return self._can_manage(request)
+
+
+@admin.register(SrpAccessSettings)
+class SrpAccessSettingsAdmin(SrpManagementPermissionMixin, SingletonModelAdmin):
+    filter_horizontal = ("selected_states",)
+
+
+@admin.register(ExposedSrpFleet)
+class ExposedSrpFleetAdmin(SrpManagementPermissionMixin, admin.ModelAdmin):
+    list_display = ("fleet", "enabled")
+    list_filter = ("enabled",)
+    list_select_related = ("fleet",)
+    search_fields = ("fleet__fleet_name", "fleet__fleet_srp_code")