feat(dwc): add clone endpoint, list APIs, and Export Packages tool shell

Adds the first set of mapping/dataset CRUD endpoints and the Export Packages
tool entry point:
- list_mappings — returns all schema mappings as JSON
- list_export_datasets — returns all export datasets as JSON
- clone_mapping — deep-copies a SchemaMapping (new SpQuery, all SpQueryFields,
  new SchemaMapping pointing to the new query)
- urls.py: register the three new endpoints
- OverlayRoutes: register Export Packages route
- ExportPackages/index.tsx: list view shell for Export Packages tool

Field references adapted to Caroline's schemamapping schema (mapping_type,
is_default), and clone_mapping sets specifyuser/createdbyagent (required by
schema). Restored test_clone_mapping which depends on this layer's endpoint.

Fixes #7712 (cloning of schema mapping queries), #7723 (Export Packages tool).

Author: foozleface

specifyweb/backend/export/tests/test_models.py

@@ -172,6 +172,70 @@ def test_export_dataset_extension(self):
                 exportdataset=ds, schemamapping=ext_mapping, sortorder=2,
             )
 
+    def test_clone_mapping(self):
+        """Clone endpoint creates new SpQuery, SpQueryFields, and SchemaMapping."""
+        original_mapping = self._make_mapping('Original')
+        original_query = original_mapping.query
+
+        # Add query fields to the original query
+        Spqueryfield.objects.create(
+            query=original_query,
+            fieldname='catalogNumber',
+            operstart=0,
+            sorttype=0,
+            position=0,
+            startvalue='',
+            stringid='1.collectionobject.catalogNumber',
+            tablelist='1',
+            term='http://rs.tdwg.org/dwc/terms/catalogNumber',
+        )
+        Spqueryfield.objects.create(
+            query=original_query,
+            fieldname='locality',
+            operstart=0,
+            sorttype=0,
+            position=1,
+            startvalue='',
+            stringid='1.collectionobject.locality',
+            tablelist='1',
+            term='http://rs.tdwg.org/dwc/terms/locality',
+            isstatic=True,
+            staticvalue='Some Place',
+        )
+
+        from django.test import RequestFactory
+        from specifyweb.backend.export.views import clone_mapping
+
+        factory = RequestFactory()
+        request = factory.post(f'/export/clone_mapping/{original_mapping.id}/')
+        request.user = self.specifyuser
+        request.specify_user = self.specifyuser
+
+        # Mock permission check — in tests, permissions are not configured
+        from unittest.mock import patch
+        with patch('specifyweb.backend.export.views.check_permission_targets'):
+            response = clone_mapping(request, original_mapping.id)
+
+        self.assertEqual(response.status_code, 200)
+        import json
+        data = json.loads(response.content)
+        self.assertIn('id', data)
+        self.assertEqual(data['name'], 'Copy of Original')
+        self.assertFalse(data['isDefault'])
+        self.assertNotEqual(data['queryId'], original_query.id)
+
+        # Verify new query has cloned fields
+        new_query = Spquery.objects.get(id=data['queryId'])
+        self.assertEqual(new_query.name, f'Copy of {original_query.name}')
+        self.assertEqual(new_query.fields.count(), 2)
+
+        # Verify field data was cloned
+        cloned_field = new_query.fields.get(position=0)
+        self.assertEqual(cloned_field.term, 'http://rs.tdwg.org/dwc/terms/catalogNumber')
+        cloned_static = new_query.fields.get(position=1)
+        self.assertTrue(cloned_static.isstatic)
+        self.assertEqual(cloned_static.staticvalue, 'Some Place')
+
     def test_cache_table_meta(self):
         mapping = self._make_mapping()
         meta = CacheTableMeta.objects.create(

specifyweb/backend/export/urls.py

@@ -9,4 +9,7 @@
     path('extract_query/<int:query_id>/', views.extract_query),
     path('force_update/', views.force_update),
     path('schema_terms/', views.get_schema_terms),
+    path('list_mappings/', views.list_mappings),
+    path('list_export_datasets/', views.list_export_datasets),
+    path('clone_mapping/<int:mapping_id>/', views.clone_mapping),
 ]

specifyweb/backend/export/views.py

@@ -211,3 +211,116 @@ def get_schema_terms(request):
     terms_path = os.path.join(os.path.dirname(__file__), 'schema_terms.json')
     with open(terms_path) as f:
         return HttpResponse(f.read(), content_type='application/json')
+
+
+@require_GET
+@login_maybe_required
+def list_mappings(request):
+    """List all schema mappings."""
+    check_permission_targets(None, request.specify_user.id, [SchemaMappingPT.read])
+    from specifyweb.backend.export.models import SchemaMapping
+    mappings = SchemaMapping.objects.all().values('id', 'name', 'mapping_type', 'is_default', 'query_id')
+    return HttpResponse(json.dumps([
+        {
+            'id': m['id'],
+            'name': m['name'],
+            'mappingType': m['mapping_type'],
+            'isDefault': m['is_default'],
+            'queryId': m['query_id'],
+        }
+        for m in mappings
+    ]), content_type='application/json')
+
+
+@require_GET
+@login_maybe_required
+def list_export_datasets(request):
+    """List all export datasets."""
+    check_permission_targets(None, request.specify_user.id, [ExportPackagePT.read])
+    from specifyweb.backend.export.models import ExportDataSet
+    datasets = ExportDataSet.objects.all().values(
+        'id', 'exportname', 'filename', 'rss', 'frequency',
+        'coremapping_id', 'collection_id', 'lastexported'
+    )
+    return HttpResponse(json.dumps([
+        {
+            'id': d['id'],
+            'exportName': d['exportname'],
+            'fileName': d['filename'],
+            'isRss': d['rss'],
+            'frequency': d['frequency'],
+            'coreMappingId': d['coremapping_id'],
+            'collectionId': d['collection_id'],
+            'lastExported': d['lastexported'].isoformat() if d['lastexported'] else None,
+        }
+        for d in datasets
+    ]), content_type='application/json')
+
+
+@require_POST
+@login_maybe_required
+def clone_mapping(request, mapping_id):
+    """Deep-copy a SchemaMapping: creates new SpQuery with all SpQueryFields,
+    creates new SchemaMapping pointing to the new query."""
+    check_permission_targets(None, request.specify_user.id, [SchemaMappingPT.create])
+
+    from specifyweb.backend.export.models import SchemaMapping
+    from specifyweb.specify.models import Spqueryfield
+
+    try:
+        original = SchemaMapping.objects.select_related('query').get(id=mapping_id)
+    except SchemaMapping.DoesNotExist:
+        raise Http404
+
+    # Clone the SpQuery
+    old_query = original.query
+    new_query = Spquery.objects.create(
+        name=f'Copy of {old_query.name}',
+        contextname=old_query.contextname,
+        contexttableid=old_query.contexttableid,
+        specifyuser=request.specify_user,
+        isfavorite=False,
+        ordinal=old_query.ordinal,
+        searchsynonymy=old_query.searchsynonymy,
+        selectdistinct=old_query.selectdistinct,
+        smushed=old_query.smushed,
+        countonly=old_query.countonly,
+    )
+
+    # Clone all query fields
+    for field in old_query.fields.all():
+        Spqueryfield.objects.create(
+            query=new_query,
+            fieldname=field.fieldname,
+            stringid=field.stringid,
+            tablelist=field.tablelist,
+            operstart=field.operstart,
+            startvalue=field.startvalue,
+            position=field.position,
+            sorttype=field.sorttype,
+            isdisplay=field.isdisplay,
+            isnot=field.isnot,
+            isrelfld=field.isrelfld,
+            formatname=field.formatname,
+            term=field.term,
+            isstatic=field.isstatic,
+            staticvalue=field.staticvalue,
+        )
+
+    # Clone the SchemaMapping
+    new_mapping = SchemaMapping.objects.create(
+        query=new_query,
+        mapping_type=original.mapping_type,
+        name=f'Copy of {original.name}',
+        is_default=False,
+        specifyuser=request.specify_user,
+        createdbyagent=request.specify_user.agents.first(),
+    )
+
+    return HttpResponse(json.dumps({
+        'id': new_mapping.id,
+        'name': new_mapping.name,
+        'mappingType': new_mapping.mapping_type,
+        'isDefault': False,
+        'queryId': new_query.id,
+    }), content_type='application/json')

specifyweb/frontend/js_src/lib/components/Router/OverlayRoutes.tsx

@@ -209,6 +209,14 @@ export const overlayRoutes: RA<EnhancedRoute> = [
             ({ SchemaMapperOverlay }) => SchemaMapperOverlay
           ),
       },
+      {
+        path: 'export-packages',
+        title: headerText.exportPackages(),
+        element: () =>
+          import('../SchemaMapper/ExportPackages/index').then(
+            ({ ExportPackagesOverlay }) => ExportPackagesOverlay
+          ),
+      },
       {
         path: 'about',
         title: welcomeText.aboutSpecify(),

specifyweb/frontend/js_src/lib/components/SchemaMapper/ExportPackages/index.tsx

@@ -0,0 +1,71 @@
+import React from 'react';
+
+import { commonText } from '../../../localization/common';
+import { headerText } from '../../../localization/header';
+import { Button } from '../../Atoms/Button';
+import { icons } from '../../Atoms/Icons';
+import { Dialog } from '../../Molecules/Dialog';
+import { OverlayContext } from '../../Router/Router';
+
+type ExportPackageRecord = {
+  readonly id: number;
+  readonly exportName: string;
+  readonly fileName: string;
+  readonly isRss: boolean;
+  readonly lastExported: string | undefined;
+};
+
+export function ExportPackagesOverlay(): JSX.Element {
+  const handleClose = React.useContext(OverlayContext);
+  const [packages, setPackages] = React.useState<
+    ReadonlyArray<ExportPackageRecord>
+  >([]);
+
+  React.useEffect(() => {
+    fetch('/export/list_export_datasets/')
+      .then(async (response) => response.json())
+      .then(setPackages)
+      .catch(() => {});
+  }, []);
+
+  return (
+    <Dialog
+      buttons={<Button.DialogClose>{commonText.close()}</Button.DialogClose>}
+      header={headerText.exportPackages()}
+      icon={icons.archive}
+      onClose={handleClose}
+    >
+      <div className="flex flex-col gap-4">
+        {packages.length === 0 ? (
+          <p className="text-gray-500">No export packages configured</p>
+        ) : (
+          <ul className="flex flex-col gap-2">
+            {packages.map((pkg) => (
+              <li
+                className="flex items-center justify-between rounded border p-2"
+                key={pkg.id}
+              >
+                <div>
+                  <span className="font-medium">{pkg.exportName}</span>
+                  <span className="ml-2 text-sm text-gray-500">
+                    ({pkg.fileName})
+                  </span>
+                  {pkg.isRss && (
+                    <span className="ml-2 rounded bg-blue-100 px-1 text-xs text-blue-800">
+                      RSS
+                    </span>
+                  )}
+                </div>
+                <div className="flex gap-2">
+                  <Button.Small>Edit</Button.Small>
+                  <Button.Small>Clone</Button.Small>
+                </div>
+              </li>
+            ))}
+          </ul>
+        )}
+        <Button.Info>New Export Package</Button.Info>
+      </div>
+    </Dialog>
+  );
+}