diff --git a/specifyweb/frontend/js_src/lib/components/AppResources/TabDefinitions.tsx b/specifyweb/frontend/js_src/lib/components/AppResources/TabDefinitions.tsx
index 32576883d96..2fcacf391cf 100644
--- a/specifyweb/frontend/js_src/lib/components/AppResources/TabDefinitions.tsx
+++ b/specifyweb/frontend/js_src/lib/components/AppResources/TabDefinitions.tsx
@@ -20,6 +20,7 @@ import type {
SpViewSetObj,
} from '../DataModel/types';
import { RssExportFeedEditor } from '../ExportFeed';
+import { DwcaDefinitionEditor } from '../DwcaDefinition/DwcaDefinition';
import { exportFeedSpec } from '../ExportFeed/spec';
import { ExpressSearchConfigResourceEditor } from '../ExpressSearchConfig/ExpressSearchConfigEditor';
import { FieldFormattersEditor } from '../FieldFormatters/Editor';
@@ -168,6 +169,10 @@ export const visualAppResourceEditors = f.store<
visual: RssExportFeedEditor,
xml: generateXmlEditor(exportFeedSpec),
},
+ dwcaDefinition: {
+ visual: DwcaDefinitionEditor,
+ xml: generateXmlEditor(undefined),
+ },
expressSearchConfig: {
visual: ExpressSearchConfigResourceEditor,
xml: AppResourceTextEditor,
diff --git a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/AppResourcesFilters.test.tsx b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/AppResourcesFilters.test.tsx
index 471c51d4d04..8a9453fb530 100644
--- a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/AppResourcesFilters.test.tsx
+++ b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/AppResourcesFilters.test.tsx
@@ -61,6 +61,7 @@ describe('AppResourcesFilters', () => {
'dataEntryTables',
'dataObjectFormatters',
'defaultUserPreferences',
+ 'dwcaDefinition',
'expressSearchConfig',
'interactionsTables',
'label',
diff --git a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/CreateAppResource.test.tsx b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/CreateAppResource.test.tsx
index cbf9483ddf8..37b027f67ef 100644
--- a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/CreateAppResource.test.tsx
+++ b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/CreateAppResource.test.tsx
@@ -58,7 +58,7 @@ describe('CreateAppResource', () => {
// This is a lot more cleaner than the inner HTML
expect(getByRole('dialog').textContent).toMatchInlineSnapshot(
- `"Select Resource TypeTypeDocumentationLabelDocumentationReportDocumentationDefault User PreferencesDocumentationLeaflet LayersDocumentationRSS Export FeedDocumentationExpress Search ConfigDocumentationType SearchesDocumentationWeb LinksDocumentationField FormattersDocumentationRecord FormattersDocumentationData Entry TablesDocumentationInteractions TablesDocumentationOther XML ResourceOther JSON ResourceOther Properties ResourceOther ResourceCancel"`
+ `"Select Resource TypeTypeDocumentationLabelDocumentationReportDocumentationDefault User PreferencesDocumentationLeaflet LayersDocumentationRSS Export FeedDocumentationDarwin Core definitionExpress Search ConfigDocumentationType SearchesDocumentationWeb LinksDocumentationField FormattersDocumentationRecord FormattersDocumentationData Entry TablesDocumentationInteractions TablesDocumentationOther XML ResourceOther JSON ResourceOther Properties ResourceOther ResourceCancel"`
);
});
diff --git a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/allAppResources.test.ts b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/allAppResources.test.ts
index 293b78f890a..dc03a0a9ac3 100644
--- a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/allAppResources.test.ts
+++ b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/allAppResources.test.ts
@@ -2,25 +2,26 @@ import { allAppResources } from '../filtersHelpers';
test('allAppResources', () => {
expect(allAppResources).toMatchInlineSnapshot(`
- [
- "collectionPreferences",
- "dataEntryTables",
- "dataObjectFormatters",
- "defaultUserPreferences",
- "expressSearchConfig",
- "interactionsTables",
- "label",
- "leafletLayers",
- "otherAppResources",
- "otherJsonResource",
- "otherPropertiesResource",
- "otherXmlResource",
- "report",
- "rssExportFeed",
- "typeSearches",
- "uiFormatters",
- "userPreferences",
- "webLinks",
- ]
- `);
+[
+ "collectionPreferences",
+ "dataEntryTables",
+ "dataObjectFormatters",
+ "defaultUserPreferences",
+ "dwcaDefinition",
+ "expressSearchConfig",
+ "interactionsTables",
+ "label",
+ "leafletLayers",
+ "otherAppResources",
+ "otherJsonResource",
+ "otherPropertiesResource",
+ "otherXmlResource",
+ "report",
+ "rssExportFeed",
+ "typeSearches",
+ "uiFormatters",
+ "userPreferences",
+ "webLinks",
+]
+`);
});
diff --git a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/defaultAppResourceFilters.test.ts b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/defaultAppResourceFilters.test.ts
index 4be98addc17..f39980db099 100644
--- a/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/defaultAppResourceFilters.test.ts
+++ b/specifyweb/frontend/js_src/lib/components/AppResources/__tests__/defaultAppResourceFilters.test.ts
@@ -9,6 +9,7 @@ test('defaultAppResourceFilters', () => {
"dataObjectFormatters",
"defaultUserPreferences",
"expressSearchConfig",
+ "dwcaDefinition",
"interactionsTables",
"label",
"leafletLayers",
diff --git a/specifyweb/frontend/js_src/lib/components/AppResources/types.tsx b/specifyweb/frontend/js_src/lib/components/AppResources/types.tsx
index 8a0b8f089da..53f512de311 100644
--- a/specifyweb/frontend/js_src/lib/components/AppResources/types.tsx
+++ b/specifyweb/frontend/js_src/lib/components/AppResources/types.tsx
@@ -1,5 +1,6 @@
import type { LocalizedString } from 'typesafe-i18n';
+import { dwcaText } from '../../localization/dwca';
import { preferencesText } from '../../localization/preferences';
import { reportsText } from '../../localization/report';
import { resourcesText } from '../../localization/resources';
@@ -127,6 +128,14 @@ export const appResourceSubTypes = ensure
>()({
icon: icons.upload,
label: resourcesText.rssExportFeed(),
},
+ dwcaDefinition: {
+ mimeType: 'application/vnd.specify.dwca+xml',
+ name: undefined,
+ documentationUrl: undefined,
+ icon: icons.upload,
+ label: dwcaText.dwcaDefinition(),
+ useTemplate: false,
+ },
expressSearchConfig: {
mimeType: 'text/xml',
name: 'ExpressSearchConfig',
diff --git a/specifyweb/frontend/js_src/lib/components/DwcaDefinition/DwcaDefinition.tsx b/specifyweb/frontend/js_src/lib/components/DwcaDefinition/DwcaDefinition.tsx
new file mode 100644
index 00000000000..2d76e42a6a1
--- /dev/null
+++ b/specifyweb/frontend/js_src/lib/components/DwcaDefinition/DwcaDefinition.tsx
@@ -0,0 +1,1693 @@
+import React from 'react';
+
+import { useSearchParameter } from '../../hooks/navigation';
+import { useAsyncState } from '../../hooks/useAsyncState';
+import { commonText } from '../../localization/common';
+import { dwcaText } from '../../localization/dwca';
+import { queryText } from '../../localization/query';
+import { resourcesText } from '../../localization/resources';
+import type { RA } from '../../utils/types';
+import { localized } from '../../utils/types';
+import { replaceItem } from '../../utils/utils';
+import type { AppResourceTabProps } from '../AppResources/TabDefinitions';
+import { ErrorMessage } from '../Atoms';
+import { Button } from '../Atoms/Button';
+import { className } from '../Atoms/className';
+import { Input, Label, Select } from '../Atoms/Form';
+import { icons } from '../Atoms/Icons';
+import { Link } from '../Atoms/Link';
+import { fetchCollection } from '../DataModel/collection';
+import type { SerializedResource } from '../DataModel/helperTypes';
+import type { SpecifyResource } from '../DataModel/legacyTypes';
+import { fetchResource } from '../DataModel/resource';
+import type { SpecifyTable } from '../DataModel/specifyTable';
+import {
+ deserializeResource,
+ serializeResource,
+} from '../DataModel/serializers';
+import { fetchContext as fetchTables, tables } from '../DataModel/tables';
+import type { SpQuery, SpQueryField } from '../DataModel/types';
+import { getField } from '../DataModel/helpers';
+import { userInformation } from '../InitialContext/userInformation';
+import { getFieldBlockerKey, useSaveBlockers } from '../DataModel/saveBlockers';
+import { createQuery } from '../QueryBuilder';
+import { QueryBuilder } from '../QueryBuilder/Wrapped';
+import { parseQueryFields } from '../QueryBuilder/helpers';
+import type { QueryField } from '../QueryBuilder/helpers';
+import { Dialog, dialogClassNames, LoadingScreen } from '../Molecules/Dialog';
+import gbifCores from './data/gbifCores.json';
+import { defaultTemplates, type DwcaTemplate } from './data/defaultTemplates';
+import { coreTermPatterns, occurrenceIdTerm } from './data/coreTermPatterns';
+import gbifExtensions from './data/gbifExtensions.json';
+
+type ExtensionDefinition = (typeof gbifExtensions)[number];
+type CoreDefinition = (typeof gbifCores)[number];
+type Definition = CoreDefinition | ExtensionDefinition;
+type Mapping = {
+ readonly extension: boolean;
+ readonly coreRowType: string;
+ readonly baseTable: SpecifyTable;
+ readonly extensionDefinition: Definition | undefined;
+ readonly rowType: string;
+ readonly fileName: string;
+ readonly query: SpecifyResource;
+ readonly fields: RA>;
+ readonly terms: RA;
+};
+
+type TermDefinition = {
+ readonly name: string;
+ readonly title?: string;
+ readonly description?: string;
+ readonly vocabulary?: string;
+ readonly iri?: string;
+ readonly group?: string;
+ readonly required?: boolean;
+};
+
+const customTermOption = '__custom__';
+const customRowTypeOption = '__custom_row_type__';
+const customExtensionOption = '__custom_extension__';
+const dwcaTabParameter = 'dwcaTab';
+const occurrenceCoreRowType = 'http://rs.tdwg.org/dwc/terms/Occurrence';
+const coreDefinitions: readonly CoreDefinition[] = gbifCores;
+const occurrenceCore = coreDefinitions.find(
+ ({ rowType }) => rowType === occurrenceCoreRowType
+)!;
+const coreIdentifierTerms: Readonly> = {
+ 'http://rs.tdwg.org/dwc/terms/Event': 'http://rs.tdwg.org/dwc/terms/eventID',
+ 'http://rs.tdwg.org/dwc/terms/Taxon': 'http://rs.tdwg.org/dwc/terms/taxonID',
+};
+const getCoreIdentifierTerm = (rowType: string): string =>
+ coreIdentifierTerms[rowType] ?? occurrenceIdTerm;
+
+export function getBaseTableForCore(coreRowType: string): SpecifyTable {
+ switch (coreRowType) {
+ case 'http://rs.tdwg.org/dwc/terms/Event':
+ return tables.CollectingEvent;
+ case 'http://rs.tdwg.org/dwc/terms/Taxon':
+ return tables.Taxon;
+ default:
+ return tables.CollectionObject;
+ }
+}
+
+type MappingTabMapping = Pick &
+ Partial>;
+
+function slugifyTabValue(value: string): string {
+ return (
+ value
+ .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+ .toLowerCase()
+ .replace(/[^a-z0-9]+/g, '-')
+ .replace(/^-|-$/g, '') || 'custom'
+ );
+}
+
+export function getMappingTabValue(mapping: MappingTabMapping): string {
+ if (!mapping.extension) return 'core';
+ return slugifyTabValue(
+ mapping.extensionDefinition?.name ??
+ mapping.rowType.split(/[\/#]/).at(-1) ??
+ ''
+ );
+}
+
+export function getMappingTabValues(
+ mappings: ReadonlyArray
+): RA {
+ const occurrences = new Map();
+ return mappings.map((mapping) => {
+ const base = getMappingTabValue(mapping);
+ const occurrence = occurrences.get(base) ?? 0;
+ occurrences.set(base, occurrence + 1);
+ return occurrence === 0 ? base : `${base}-${occurrence + 1}`;
+ });
+}
+
+function getMappingTabIndex(
+ mappings: ReadonlyArray,
+ tabValues: ReadonlyArray,
+ tabValue: string | undefined
+): number {
+ if (tabValue === undefined) return -1;
+ const index = tabValues.indexOf(tabValue);
+ if (index >= 0) return index;
+
+ // Keep links generated by the previous URL format working.
+ const oldPrefix = 'extension:';
+ if (!tabValue.startsWith(oldPrefix)) return -1;
+ const rowType = tabValue.slice(oldPrefix.length);
+ return mappings.findIndex(
+ (mapping) => mapping.extension && mapping.rowType === rowType
+ );
+}
+
+export function getMappingTerm(
+ mapping: {
+ readonly extension: boolean;
+ readonly rowType?: string;
+ readonly fields: ReadonlyArray<{ readonly stringId: string }>;
+ readonly terms: RA;
+ },
+ field: Partial> &
+ Partial>
+): string | undefined {
+ const fieldIndex = getMappingFieldIndex(mapping, field);
+ return !mapping.extension && fieldIndex === 0
+ ? getCoreIdentifierTerm(mapping.rowType ?? occurrenceCoreRowType)
+ : mapping.terms[fieldIndex];
+}
+
+function getMappingFieldIndex(
+ mapping: {
+ readonly fields: ReadonlyArray<{ readonly stringId: string }>;
+ },
+ field: Partial> &
+ Partial>
+): number {
+ if (field.sourceStringId !== undefined) {
+ const exactIndex = mapping.fields.findIndex(
+ ({ stringId }) =>
+ stringId.toLowerCase() === field.sourceStringId!.toLowerCase()
+ );
+ if (exactIndex >= 0) return exactIndex;
+ }
+ if (field.mappingPath !== undefined) {
+ const pathKey = JSON.stringify(field.mappingPath).toLowerCase();
+ const pathIndex = mapping.fields.findIndex(
+ (candidate) => fieldTermKey(candidate) === pathKey
+ );
+ if (pathIndex >= 0) return pathIndex;
+ }
+ return field.sourceIndex ?? field.id ?? -1;
+}
+
+export function updateMappingTerm(
+ mapping: Mapping,
+ field: Pick &
+ Partial>,
+ term: string | undefined
+): Mapping {
+ const fieldIndex = getMappingFieldIndex(mapping, field);
+ if (fieldIndex < 0 || fieldIndex >= mapping.fields.length) return mapping;
+ return {
+ ...mapping,
+ terms: replaceItem(mapping.terms, fieldIndex, term),
+ };
+}
+
+export function getSerializedMappingTerm(
+ mapping: {
+ readonly fields: ReadonlyArray<{ readonly stringId: string }>;
+ readonly terms: RA;
+ },
+ field: { readonly stringId: string },
+ fallbackIndex: number
+): string | undefined {
+ const fieldIndex = mapping.fields.findIndex(
+ ({ stringId }) => stringId.toLowerCase() === field.stringId.toLowerCase()
+ );
+ const resolvedIndex = fieldIndex >= 0 ? fieldIndex : fallbackIndex;
+ return mapping.terms[resolvedIndex];
+}
+
+const groupLabel = (group: string | undefined): string => {
+ const label = group?.split('#').at(-1) ?? '';
+ return label === '' ? '' : label[0].toUpperCase() + label.slice(1);
+};
+
+function getTermNameParts(name: string): RA {
+ return name.split(/[\/#]/).filter((part) => part !== '');
+}
+
+export function getTermDisplayLabel(
+ term: Pick,
+ terms: ReadonlyArray>
+): string {
+ const title = term.title ?? term.name;
+ const duplicateTitles = terms.filter(
+ (candidate) => (candidate.title ?? candidate.name) === title
+ );
+ if (duplicateTitles.length < 2) return title;
+
+ const parts = getTermNameParts(term.name);
+ const qualifier = Array.from({ length: parts.length }, (_, index) =>
+ parts.slice(-(index + 1)).join('/')
+ ).find((candidate) =>
+ duplicateTitles.every(
+ (candidateTerm) =>
+ candidateTerm.name === term.name ||
+ getTermNameParts(candidateTerm.name)
+ .slice(candidate.split('/').length * -1)
+ .join('/') !== candidate
+ )
+ );
+
+ return dwcaText.dwcaTermWithQualifier({
+ title,
+ qualifier: qualifier ?? term.name,
+ });
+}
+
+export const defaultRowTypes = Array.from(
+ new Set(gbifExtensions.map(({ rowType }) => rowType))
+);
+
+export const defaultCoreRowTypes = Array.from(
+ new Set(coreDefinitions.map(({ rowType }) => rowType))
+);
+
+export const getExtensionDefinitionForRowType = (
+ rowType: string
+): ExtensionDefinition | undefined =>
+ gbifExtensions.find((extension) => extension.rowType === rowType);
+
+export const getCoreDefinitionForRowType = (
+ rowType: string
+): CoreDefinition | undefined =>
+ coreDefinitions.find((core) => core.rowType === rowType);
+
+export function isExtensionApplicableToCore(
+ extension: Pick,
+ coreRowType: string
+): boolean {
+ const subject = extension.subject.trim();
+ if (subject === '') return true;
+ const core = getCoreDefinitionForRowType(coreRowType);
+ if (core === undefined) return true;
+ return subject.split(/\s+/).includes(`dwc:${core.name}`);
+}
+
+const getRowTypeOptionLabel = (rowType: string): string =>
+ getCoreDefinitionForRowType(rowType)?.title ??
+ getExtensionDefinitionForRowType(rowType)?.title ??
+ rowType;
+
+function TermInfoDialog({
+ term,
+ extension,
+ onClose,
+}: {
+ readonly term: TermDefinition;
+ readonly extension: boolean;
+ readonly onClose: () => void;
+}): JSX.Element {
+ return (
+
+ );
+}
+
+export function getTemplateMapping(
+ template: DwcaTemplate,
+ mapping: Pick,
+ coreRowType?: string
+): Mapping | undefined {
+ if (
+ !template.targets.some(
+ (target) =>
+ target.extension === mapping.extension &&
+ target.rowType === mapping.rowType
+ )
+ )
+ return undefined;
+ if (
+ coreRowType !== undefined &&
+ !isTemplateApplicableToCore(template, coreRowType)
+ )
+ return undefined;
+ return parseDefinition(template.definition).find(
+ (candidate) =>
+ candidate.extension === mapping.extension &&
+ candidate.rowType === mapping.rowType
+ );
+}
+
+export function isTemplateApplicableToCore(
+ template: DwcaTemplate,
+ coreRowType: string
+): boolean {
+ if (template.coreRowTypes !== undefined)
+ return template.coreRowTypes.includes(coreRowType);
+ return template.targets.some((target) =>
+ target.extension
+ ? isExtensionApplicableToCore(
+ getExtensionDefinitionForRowType(target.rowType) ?? { subject: '' },
+ coreRowType
+ )
+ : target.rowType === coreRowType
+ );
+}
+
+const getFields = (
+ query: SpecifyResource
+): RA> => {
+ const fields =
+ (query.get('fields') as unknown) ??
+ (serializeResource(query) as unknown as { readonly fields?: unknown })
+ .fields;
+ return Array.isArray(fields)
+ ? fields.map((field) =>
+ serializeResource(field as unknown as SpecifyResource)
+ )
+ : [];
+};
+
+const normalizeStringId = (stringId: string, table: SpecifyTable): string =>
+ stringId.includes('.')
+ ? stringId
+ : `${table.tableId}.${table.name.toLowerCase()}.${stringId}`;
+
+/*
+ * QueryBuilder writes the current relationship names into stringId. Older
+ * DwCA XML can contain the same field with only relationship table IDs (for
+ * example `1,9-determinations,4.taxon.Kingdom`). Match those representations
+ * by their resolved query path as well as by their serialized stringId.
+ */
+function fieldTermKey(
+ field: Pick, 'stringId'> &
+ Partial>
+): string {
+ try {
+ const [parsed] = parseQueryFields([
+ field as SerializedResource,
+ ]);
+ return parsed === undefined
+ ? field.stringId.toLowerCase()
+ : JSON.stringify(parsed.mappingPath).toLowerCase();
+ } catch {
+ return field.stringId.toLowerCase();
+ }
+}
+
+function fieldShapesEqual(
+ left: RA>,
+ right: RA>
+): boolean {
+ try {
+ const shape = (fields: RA>) =>
+ parseQueryFields(fields).map(
+ ({ mappingPath, sortType, isDisplay, filters }) => ({
+ mappingPath,
+ sortType,
+ isDisplay,
+ filters,
+ })
+ );
+ return JSON.stringify(shape(left)) === JSON.stringify(shape(right));
+ } catch {
+ return false;
+ }
+}
+
+function availableTermNames(
+ extension: boolean,
+ definition: Definition | undefined,
+ coreRowType: string
+): ReadonlySet {
+ return new Set(
+ (extension
+ ? [
+ (
+ getCoreDefinitionForRowType(coreRowType) ?? occurrenceCore
+ ).fields.find(
+ ({ name }) => name === getCoreIdentifierTerm(coreRowType)
+ ),
+ ...(definition?.fields ?? []),
+ ]
+ : (definition ?? occurrenceCore).fields
+ )
+ .map((term) => term?.name)
+ .filter((name): name is string => name !== undefined)
+ );
+}
+
+export function updateMappingFields(
+ mapping: Mapping,
+ newFields: RA>
+): Mapping {
+ const oldMetadata = new Map>();
+ mapping.fields.forEach((field, index) => {
+ const key = fieldTermKey(field);
+ oldMetadata.set(key, [
+ ...(oldMetadata.get(key) ?? []),
+ mapping.terms[index],
+ ]);
+ });
+ const oldStringIds = new Map(
+ mapping.fields.map((field, index) => [
+ field.stringId.toLowerCase(),
+ mapping.terms[index],
+ ])
+ );
+ const availableTerms = availableTermNames(
+ mapping.extension,
+ mapping.extensionDefinition,
+ mapping.coreRowType
+ );
+ const fields = [...newFields];
+ if (!mapping.extension) {
+ const automaticTerms = autoMapCoreFields(fields, availableTerms);
+ const occurrenceIndex = fields.findIndex(
+ (field, index) =>
+ (oldStringIds.get(field.stringId.toLowerCase()) ??
+ oldMetadata.get(fieldTermKey(field))?.[0] ??
+ automaticTerms[index]) === getCoreIdentifierTerm(mapping.coreRowType)
+ );
+ if (occurrenceIndex > 0) {
+ const [occurrence] = fields.splice(occurrenceIndex, 1);
+ fields.unshift(occurrence);
+ }
+ }
+ const autoMapped = autoMapCoreFields(fields, availableTerms);
+ const usedTerms = new Set();
+ const terms = fields.map((field, index) => {
+ const key = fieldTermKey(field);
+ const oldTerm = oldStringIds.get(field.stringId.toLowerCase());
+ const pathTerms = oldMetadata.get(key);
+ const pathTerm = pathTerms?.[0];
+ if (pathTerms !== undefined) oldMetadata.set(key, pathTerms.slice(1));
+ const candidateTerm = oldTerm ?? pathTerm ?? autoMapped[index];
+ if (candidateTerm === undefined) return undefined;
+ // Pick-list terms may only be mapped once. Custom terms are intentionally
+ // left untouched, even when they are not present in the catalogs.
+ if (availableTerms.has(candidateTerm)) {
+ if (usedTerms.has(candidateTerm)) return undefined;
+ usedTerms.add(candidateTerm);
+ }
+ return candidateTerm;
+ });
+ const updatedMapping = {
+ ...mapping,
+ query: mapping.query.set('fields', fields),
+ fields,
+ terms,
+ };
+ return mapping.extension
+ ? updatedMapping
+ : ensureIdentifierTerm(updatedMapping);
+}
+
+function autoMapCoreFields(
+ fields: RA>,
+ availableTerms: ReadonlySet
+): RA {
+ const usedTerms = new Set();
+ const terms = fields.map((field) => {
+ const stringId = field.stringId.toLowerCase();
+ const match = Object.entries(coreTermPatterns).find(
+ ([term, patterns]) =>
+ availableTerms.has(term) &&
+ !usedTerms.has(term) &&
+ patterns.some((pattern) => stringId.includes(pattern))
+ )?.[0];
+ if (match !== undefined) usedTerms.add(match);
+ return match;
+ });
+ return terms;
+}
+
+function newMapping(
+ extension: boolean,
+ definition: Definition | undefined,
+ coreRowType = occurrenceCoreRowType
+): Mapping {
+ const baseTable = getBaseTableForCore(coreRowType);
+ const query = createQuery(
+ definition?.name ?? (extension ? 'extension' : 'core'),
+ baseTable
+ );
+ return ensureIdentifierTerm({
+ extension,
+ coreRowType,
+ baseTable,
+ extensionDefinition: definition,
+ rowType: extension
+ ? (definition?.rowType ?? '')
+ : (definition?.rowType ?? coreRowType),
+ fileName: definition
+ ? `${definition.name}.csv`
+ : extension
+ ? ''
+ : 'core.csv',
+ query,
+ fields: [],
+ terms: [],
+ });
+}
+
+function mappingFromQuery(
+ mapping: Mapping,
+ query: SpecifyResource
+): Mapping {
+ const fields = getFields(query);
+ return ensureIdentifierTerm(
+ updateMappingFields(
+ {
+ ...mapping,
+ // A seed query is a complete replacement. Do not let terms from the
+ // previous mapping attach to the new query by array position.
+ fields: [],
+ terms: [],
+ query: query
+ .set('fields', fields)
+ .set('contextTableId', mapping.baseTable.tableId),
+ },
+ fields
+ )
+ );
+}
+
+const isCoreIdentifierField = (
+ mapping: Pick,
+ field: SerializedResource
+): boolean => {
+ const stringId = field.stringId.toLowerCase();
+ const pattern = `${mapping.baseTable.name.toLowerCase()}.guid`;
+ return stringId === pattern || stringId.endsWith(`.${pattern}`);
+};
+
+export function ensureIdentifierTerm(mapping: Mapping): Mapping {
+ const identifierIndex = mapping.fields.findIndex((field) =>
+ isCoreIdentifierField(mapping, field)
+ );
+ const identifierStringId = `${mapping.baseTable.tableId}.${mapping.baseTable.name.toLowerCase()}.guid`;
+ const identifierTerm = getCoreIdentifierTerm(mapping.coreRowType);
+ const fields =
+ identifierIndex >= 0
+ ? [
+ {
+ ...mapping.fields[identifierIndex]!,
+ stringId: identifierStringId,
+ isDisplay: true,
+ },
+ ...mapping.fields.filter((_, index) => index !== identifierIndex),
+ ]
+ : [
+ serializeResource(
+ new tables.SpQueryField.Resource({
+ stringId: identifierStringId,
+ isRelFld: false,
+ operStart: 8,
+ startValue: '',
+ isNot: false,
+ isDisplay: true,
+ position: 0,
+ sortType: 0,
+ isStrict: false,
+ })
+ ),
+ ...mapping.fields,
+ ];
+ const positionedFields = fields.map((field, position) => ({
+ ...field,
+ position,
+ }));
+ const terms = [
+ identifierTerm,
+ ...mapping.terms
+ .filter((_, index) => index !== identifierIndex)
+ .map((term) => (term === identifierTerm ? undefined : term)),
+ ];
+ return {
+ ...mapping,
+ query: mapping.query.set('fields', positionedFields),
+ fields: positionedFields,
+ terms,
+ };
+}
+
+function ExtensionDialog({
+ extensions,
+ coreRowType,
+ queries,
+ onAdd,
+ onClose,
+}: {
+ readonly extensions: RA;
+ readonly coreRowType: string;
+ readonly queries: RA>;
+ readonly onAdd: (
+ extension: ExtensionDefinition | undefined,
+ query?: SpecifyResource,
+ template?: DwcaTemplate
+ ) => void;
+ readonly onClose: () => void;
+}): JSX.Element {
+ const [extensionName, setExtensionName] = React.useState('');
+ const [queryName, setQueryName] = React.useState('');
+ const extension = extensions.find(({ name }) => name === extensionName);
+ const isFromScratch = extensionName === customExtensionOption;
+ const templates =
+ extension === undefined
+ ? []
+ : defaultTemplates.filter(
+ (template) =>
+ isTemplateApplicableToCore(template, coreRowType) &&
+ template.targets.some(
+ ({ extension: isExtension, rowType }) =>
+ isExtension && rowType === extension.rowType
+ )
+ );
+ return (
+