@anzusystems/common-admin 1.49.0 → 2.0.0-rc.2

package/dist/domains/dam/uploadQueue/settlement/uploadSettlementTypes.d.ts

@@ -0,0 +1,207 @@
+import { DocId, DocIdNullable, IntegerId } from '../../../../shared/types/common';
+import { AssetDetailItemDto, DamAssetTypeType } from '../../types/Asset';
+import { AssetFileFailReasonType, AssetFileNullable } from '../../types/AssetFile';
+import { UploadQueue, UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+export declare const UploadRowRole: {
+    readonly Upload: "upload";
+    readonly Slot: "slot";
+    readonly MassEdit: "massEdit";
+    readonly Copy: "copy";
+    readonly ExternalImport: "externalImport";
+};
+export type UploadRowRoleType = (typeof UploadRowRole)[keyof typeof UploadRowRole];
+export interface UploadSettlePolicy {
+    /** What a tick reads the state of the row's file with. `none`: the row is never tracked. */
+    reader: 'asset' | 'slots' | 'none';
+    /**
+     * For the `processed` state ONLY.
+     * `read`: uploaded only from a read, the event merely starts that read.
+     * `event`: the state of the event is written at once, the read completes the row.
+     * `never`: `processed` does not change the state of the row (mass edit), it only completes it.
+     * `failed` and `duplicate` are written to every row that passes `matches(…, 'settle')`.
+     */
+    settleOn: 'read' | 'event' | 'never';
+    duplicate: 'becomeOriginal' | 'markDuplicate';
+    /** `load`: the row is to have a form, and its metadata is loaded into it. */
+    metadata: 'load' | 'none';
+}
+export interface UploadSettlementTarget {
+    assetId: DocId;
+    /** The file the event or the read speaks of; `null` when the caller does not know it. */
+    fileId: DocIdNullable;
+    /**
+     * The DAM configurations the target is of: with `configOf` of the profile, a row in a queue of another configuration
+     * is not concerned. Left out or empty: the rows of every queue. Two DAMs may give one asset id.
+     */
+    configNames?: string[];
+}
+/** What the settlement says of one request it asks a reader for. A reader that ignores it behaves as before. */
+export interface UploadReadOptions {
+    /**
+     * Whether a failure of this request is to be reported to whoever collects the errors of the application.
+     *
+     * The poll and the notifications ask again and again for as long as a row waits, so of their requests only
+     * the first that fails in a streak is `true`; a read that answers ends the streak (with `configOf` of the profile,
+     * a streak is of one configuration, and only a read of that configuration ends it). The streak begins with a
+     * failure that was written down (`readers.failureReported`): after one that was not, the next request is
+     * `true` again. An asset that does not exist (404) counts as such a failure: it is `true` once per row at most.
+     * A read the user asked for (the refresh) is always `true`.
+     */
+    report: boolean;
+    /**
+     * The queue the read is for: of the poll its own queue; of a read a notification or the refresh asked for, the
+     * queue of the first row it concerns. For a reader that asks under the configuration of the queue. Not given when
+     * the read concerns no row.
+     */
+    queueKey?: UploadQueueKey;
+}
+/** What a store hands its settlement. */
+export interface UploadSettlementProfile {
+    /** A live view of the queues of the store. The settlement keeps no rows, it always asks. */
+    queues(): Iterable<[UploadQueueKey, UploadQueue]>;
+    /**
+     * The DAM configuration the queue `queueKey` is of. With it, a target or an event that names configurations
+     * concerns only the rows of their queues: the poll of a queue names that of the queue, and every read made for a
+     * target or an event (one a notification asks for, the refresh, a known processed file, the original of a duplicate)
+     * is made once for each configuration it names, by the queue of its first concerned row of that configuration, and
+     * written into its rows alone; a configuration named whose queues have no row of the asset is not read. The reads of
+     * a configuration go one after another, beside those of the others (and those that name none in a lane of their
+     * own), each configuration with its own streak of failures. The caches are told the queue of the rows whose names
+     * they get. Without it, every row of the asset is concerned, all reads go one after another with one streak, and the
+     * caches are called without a queue, as before.
+     */
+    configOf?(queueKey: UploadQueueKey): string;
+    roleOf(row: UploadQueueItem): UploadRowRoleType;
+    policyFor(role: UploadRowRoleType): UploadSettlePolicy;
+    /**
+     * `settle`: the row may be given a state. `decorate`: it may be completed without a change of state.
+     * `metadata`: it may be given its metadata from the metadata notification.
+     */
+    matches(row: UploadQueueItem, target: UploadSettlementTarget, purpose: 'settle' | 'decorate' | 'metadata'): boolean;
+    readers: {
+        /** One asset; `null` when it does not exist (404). Throws only when the request fails. */
+        asset(assetId: DocId, options?: UploadReadOptions): Promise<AssetDetailItemDto | null>;
+        /** Assets of one licence. The missing ones are not in the answer. An answer that is no list throws. */
+        assets(licenceId: IntegerId, assetIds: DocId[], options?: UploadReadOptions): Promise<AssetDetailItemDto[]>;
+        /** DAM: the files of all the slots of an asset. An answer that is no list throws. */
+        slotFiles?(assetId: DocId, options?: UploadReadOptions): Promise<AssetFileNullable[]>;
+        /** LIB: the asset the original file of a duplicate belongs to. `queueKey`: of the first row that is to become it. */
+        duplicateOriginAsset?(originFileId: DocId, options?: Pick<UploadReadOptions, 'queueKey'>): Promise<AssetDetailItemDto>;
+        /** DAM: the original file of a duplicate, by its type. */
+        duplicateOriginFile?(originFileId: DocId, assetType: DamAssetTypeType): Promise<AssetFileNullable>;
+        /**
+         * Whether a failure of a read that was let report (`report: true`) was written down, by what the read threw:
+         * `apiErrorIsReported` for readers that report through the api error logger. One that was not (a timeout, a
+         * 401, a 403) has told nobody, and the next read is let report again. Without it, every such failure was.
+         */
+        failureReported?(error: unknown): boolean;
+    };
+    /**
+     * `queueKey`: the queue of the rows whose names are added, and the one whose names are to be fetched, given only to
+     * a profile with `configOf`, as the second argument (an `add` of `defineCached`, which takes every argument as an
+     * id, is to be wrapped). Such a profile is asked to fetch, where the fetch was asked for before (after a read,
+     * after a duplicate became its original), for each queue whose rows were given names since its last fetch. A
+     * profile without it is called without a queue, as before.
+     */
+    caches: {
+        addAuthors(ids: DocId[], queueKey?: UploadQueueKey): void;
+        addKeywords(ids: DocId[], queueKey?: UploadQueueKey): void;
+        fetchAuthors(queueKey?: UploadQueueKey): void;
+        fetchKeywords(queueKey?: UploadQueueKey): void;
+    };
+    messages: {
+        processingTooLong(row: UploadQueueItem): string;
+        readFailed(row: UploadQueueItem): string;
+        assetMissing(row: UploadQueueItem): string;
+        /**
+         * The text of an uploaded row still without its metadata whose asset was missing from as many reads as it
+         * takes: it fails with it. Without it, `assetMissing`.
+         */
+        assetGone?(row: UploadQueueItem): string;
+    };
+    /**
+     * `'load'`: this row may be given its metadata from the notification although it has failed. `undefined`: the
+     * default rules. DAM: a mass-edit row its batch load left out.
+     */
+    metadataGate?(queueKey: UploadQueueKey, row: UploadQueueItem): 'load' | undefined;
+    hooks: {
+        /** The row has reached a final state: count the queue again and start the next waiting upload. */
+        onRowFinal(queueKey: UploadQueueKey, row: UploadQueueItem): void;
+        /** After every asset that was read (DAM: the main file for the open detail). */
+        onAssetRead?(asset: AssetDetailItemDto): void;
+        /** A row with `settleOn: 'never'` has learnt its file is processed (an event, a tick or a manual read). */
+        onProcessedSeen?(queueKey: UploadQueueKey, row: UploadQueueItem): void;
+        /** The row was given its metadata. */
+        afterMetadataLoaded?(queueKey: UploadQueueKey, row: UploadQueueItem): void;
+        /**
+         * Whether a refresh may still change a failed row, told whenever that changes. For a store that offers
+         * refresh on a failed row only where it can help.
+         *
+         * `true`: the row is asked about although the client gave it up (`track(…, { clientFailed: true })`), or its
+         * file is a duplicate whose original could not be read. `false`: the server has said what became of the file
+         * (processed, failed, a duplicate that was settled), its asset is gone from as many reads as it takes, or the
+         * store took the row out (`untrack`, `dropQueue`). A row never told `true` is never told `false`. Not called
+         * by `dispose()`.
+         */
+        onRefreshMayHelp?(queueKey: UploadQueueKey, row: UploadQueueItem, mayHelp: boolean): void;
+    };
+    connection: {
+        /**
+         * Whether notifications come for the rows of the queue `queueKey`: its poll is then only a backup. A profile
+         * that keeps one state for all its queues may leave the queue unread.
+         */
+        isPushAlive(queueKey?: UploadQueueKey): boolean;
+        /** Called whenever that may have changed, for any queue. */
+        onChange(callback: () => void): () => void;
+    };
+}
+export interface UploadSettlementEvent {
+    kind: 'processed' | 'failed' | 'duplicate' | 'metadata' | 'copied';
+    assetId: DocId;
+    /** `event.data.id` */
+    fileId: DocIdNullable;
+    failReason?: AssetFileFailReasonType;
+    originAssetFile?: DocIdNullable;
+    assetType?: DamAssetTypeType | null;
+    /** The DAM configurations the event is of, as on `UploadSettlementTarget`. Left out: every queue. */
+    configNames?: string[];
+}
+/**
+ * `settled`: the main file is in a final state, or its asset was missing once too often and its rows were given
+ * up. `pending`: not yet. And what asking again may mend: `error`, the read failed; `missing`, the asset was not
+ * found; `originalUnread`, a row is left without the original of its duplicate, which could not be read.
+ */
+export type UploadRefreshOutcome = 'settled' | 'pending' | 'error' | 'missing' | 'originalUnread';
+/** What a store uses. */
+export interface UploadSettlement {
+    /** The row began to wait for the server. A row that is not in the queue `queueKey` is ignored. */
+    track(queueKey: UploadQueueKey, row: UploadQueueItem, options?: {
+        clientFailed?: boolean;
+    }): void;
+    untrack(row: UploadQueueItem): void;
+    /** The queue was cleared: its poller is dropped. */
+    dropQueue(queueKey: UploadQueueKey): void;
+    /** A notification. Resolves after the write (a delayed read included) or after a failed read; never rejects. */
+    notify(event: UploadSettlementEvent): Promise<void>;
+    /**
+     * The manual refresh: a read at once, with the metadata, without a hint. With `configOf` of the profile, a
+     * configuration the target names whose queues have no row of the asset is not read (`settled`); of several, the
+     * outcome first of `error`, `originalUnread`, `missing`, `pending`, `settled` that any of their reads had.
+     */
+    refreshAsset(target: UploadSettlementTarget): Promise<UploadRefreshOutcome>;
+    /** The caller knows the file is processed: a read at once, with the hint `processed`. */
+    settleKnownProcessed(target: UploadSettlementTarget, options: {
+        withMetadata: boolean;
+    }): Promise<void>;
+    /** A known duplicate without a read of the asset: the `duplicate` event, and a copy the licence already has. */
+    settleKnownDuplicate(target: UploadSettlementTarget, originFileId: DocIdNullable, assetType: DamAssetTypeType | null): Promise<void>;
+    /** A known failure, without a read. Synchronous. */
+    settleKnownFailed(target: UploadSettlementTarget, failReason: AssetFileFailReasonType): void;
+    /**
+     * The row failed by the read that was one too many to find no asset of it (the poll's, a notification's, a
+     * refresh's), and the server has settled it by nothing else since.
+     */
+    isGivenUpMissing(row: UploadQueueItem): boolean;
+    hasTracked(): boolean;
+    dispose(): void;
+}

package/dist/domains/dam/uploadQueue/settlement/uploadSettlementTypes.js

@@ -0,0 +1,12 @@
+//#region src/domains/dam/uploadQueue/settlement/uploadSettlementTypes.ts
+var e = {
+	Upload: "upload",
+	Slot: "slot",
+	MassEdit: "massEdit",
+	Copy: "copy",
+	ExternalImport: "externalImport"
+};
+//#endregion
+export { e as UploadRowRole };
+
+//# sourceMappingURL=uploadSettlementTypes.js.map

package/dist/domains/dam/uploadQueue/settlement/uploadSettlementTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadSettlementTypes.js","names":["UploadRowRole"],"sources":["../../../../../src/domains/dam/uploadQueue/settlement/uploadSettlementTypes.ts"],"sourcesContent":["import type { DocId, DocIdNullable, IntegerId } from '@/shared/types/common'\nimport type { AssetDetailItemDto, DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport type { AssetFileFailReasonType, AssetFileNullable } from '@/domains/dam/types/AssetFile'\nimport type { UploadQueue, UploadQueueItem, UploadQueueKey } from '@/domains/dam/types/UploadQueue'\n\nexport const UploadRowRole = {\n  Upload: 'upload',\n  Slot: 'slot',\n  MassEdit: 'massEdit',\n  Copy: 'copy',\n  ExternalImport: 'externalImport',\n} as const\nexport type UploadRowRoleType = (typeof UploadRowRole)[keyof typeof UploadRowRole]\n\nexport interface UploadSettlePolicy {\n  /** What a tick reads the state of the row's file with. `none`: the row is never tracked. */\n  reader: 'asset' | 'slots' | 'none'\n  /**\n   * For the `processed` state ONLY.\n   * `read`: uploaded only from a read, the event merely starts that read.\n   * `event`: the state of the event is written at once, the read completes the row.\n   * `never`: `processed` does not change the state of the row (mass edit), it only completes it.\n   * `failed` and `duplicate` are written to every row that passes `matches(…, 'settle')`.\n   */\n  settleOn: 'read' | 'event' | 'never'\n  duplicate: 'becomeOriginal' | 'markDuplicate'\n  /** `load`: the row is to have a form, and its metadata is loaded into it. */\n  metadata: 'load' | 'none'\n}\n\nexport interface UploadSettlementTarget {\n  assetId: DocId\n  /** The file the event or the read speaks of; `null` when the caller does not know it. */\n  fileId: DocIdNullable\n  /**\n   * The DAM configurations the target is of: with `configOf` of the profile, a row in a queue of another configuration\n   * is not concerned. Left out or empty: the rows of every queue. Two DAMs may give one asset id.\n   */\n  configNames?: string[]\n}\n\n/** What the settlement says of one request it asks a reader for. A reader that ignores it behaves as before. */\nexport interface UploadReadOptions {\n  /**\n   * Whether a failure of this request is to be reported to whoever collects the errors of the application.\n   *\n   * The poll and the notifications ask again and again for as long as a row waits, so of their requests only\n   * the first that fails in a streak is `true`; a read that answers ends the streak (with `configOf` of the profile,\n   * a streak is of one configuration, and only a read of that configuration ends it). The streak begins with a\n   * failure that was written down (`readers.failureReported`): after one that was not, the next request is\n   * `true` again. An asset that does not exist (404) counts as such a failure: it is `true` once per row at most.\n   * A read the user asked for (the refresh) is always `true`.\n   */\n  report: boolean\n  /**\n   * The queue the read is for: of the poll its own queue; of a read a notification or the refresh asked for, the\n   * queue of the first row it concerns. For a reader that asks under the configuration of the queue. Not given when\n   * the read concerns no row.\n   */\n  queueKey?: UploadQueueKey\n}\n\n/** What a store hands its settlement. */\nexport interface UploadSettlementProfile {\n  /** A live view of the queues of the store. The settlement keeps no rows, it always asks. */\n  queues(): Iterable<[UploadQueueKey, UploadQueue]>\n  /**\n   * The DAM configuration the queue `queueKey` is of. With it, a target or an event that names configurations\n   * concerns only the rows of their queues: the poll of a queue names that of the queue, and every read made for a\n   * target or an event (one a notification asks for, the refresh, a known processed file, the original of a duplicate)\n   * is made once for each configuration it names, by the queue of its first concerned row of that configuration, and\n   * written into its rows alone; a configuration named whose queues have no row of the asset is not read. The reads of\n   * a configuration go one after another, beside those of the others (and those that name none in a lane of their\n   * own), each configuration with its own streak of failures. The caches are told the queue of the rows whose names\n   * they get. Without it, every row of the asset is concerned, all reads go one after another with one streak, and the\n   * caches are called without a queue, as before.\n   */\n  configOf?(queueKey: UploadQueueKey): string\n  roleOf(row: UploadQueueItem): UploadRowRoleType\n  policyFor(role: UploadRowRoleType): UploadSettlePolicy\n  /**\n   * `settle`: the row may be given a state. `decorate`: it may be completed without a change of state.\n   * `metadata`: it may be given its metadata from the metadata notification.\n   */\n  matches(row: UploadQueueItem, target: UploadSettlementTarget, purpose: 'settle' | 'decorate' | 'metadata'): boolean\n\n  readers: {\n    /** One asset; `null` when it does not exist (404). Throws only when the request fails. */\n    asset(assetId: DocId, options?: UploadReadOptions): Promise<AssetDetailItemDto | null>\n    /** Assets of one licence. The missing ones are not in the answer. An answer that is no list throws. */\n    assets(licenceId: IntegerId, assetIds: DocId[], options?: UploadReadOptions): Promise<AssetDetailItemDto[]>\n    /** DAM: the files of all the slots of an asset. An answer that is no list throws. */\n    slotFiles?(assetId: DocId, options?: UploadReadOptions): Promise<AssetFileNullable[]>\n    /** LIB: the asset the original file of a duplicate belongs to. `queueKey`: of the first row that is to become it. */\n    duplicateOriginAsset?(\n      originFileId: DocId,\n      options?: Pick<UploadReadOptions, 'queueKey'>\n    ): Promise<AssetDetailItemDto>\n    /** DAM: the original file of a duplicate, by its type. */\n    duplicateOriginFile?(originFileId: DocId, assetType: DamAssetTypeType): Promise<AssetFileNullable>\n    /**\n     * Whether a failure of a read that was let report (`report: true`) was written down, by what the read threw:\n     * `apiErrorIsReported` for readers that report through the api error logger. One that was not (a timeout, a\n     * 401, a 403) has told nobody, and the next read is let report again. Without it, every such failure was.\n     */\n    failureReported?(error: unknown): boolean\n  }\n  /**\n   * `queueKey`: the queue of the rows whose names are added, and the one whose names are to be fetched, given only to\n   * a profile with `configOf`, as the second argument (an `add` of `defineCached`, which takes every argument as an\n   * id, is to be wrapped). Such a profile is asked to fetch, where the fetch was asked for before (after a read,\n   * after a duplicate became its original), for each queue whose rows were given names since its last fetch. A\n   * profile without it is called without a queue, as before.\n   */\n  caches: {\n    addAuthors(ids: DocId[], queueKey?: UploadQueueKey): void\n    addKeywords(ids: DocId[], queueKey?: UploadQueueKey): void\n    fetchAuthors(queueKey?: UploadQueueKey): void\n    fetchKeywords(queueKey?: UploadQueueKey): void\n  }\n  messages: {\n    processingTooLong(row: UploadQueueItem): string\n    readFailed(row: UploadQueueItem): string\n    assetMissing(row: UploadQueueItem): string\n    /**\n     * The text of an uploaded row still without its metadata whose asset was missing from as many reads as it\n     * takes: it fails with it. Without it, `assetMissing`.\n     */\n    assetGone?(row: UploadQueueItem): string\n  }\n  /**\n   * `'load'`: this row may be given its metadata from the notification although it has failed. `undefined`: the\n   * default rules. DAM: a mass-edit row its batch load left out.\n   */\n  metadataGate?(queueKey: UploadQueueKey, row: UploadQueueItem): 'load' | undefined\n  hooks: {\n    /** The row has reached a final state: count the queue again and start the next waiting upload. */\n    onRowFinal(queueKey: UploadQueueKey, row: UploadQueueItem): void\n    /** After every asset that was read (DAM: the main file for the open detail). */\n    onAssetRead?(asset: AssetDetailItemDto): void\n    /** A row with `settleOn: 'never'` has learnt its file is processed (an event, a tick or a manual read). */\n    onProcessedSeen?(queueKey: UploadQueueKey, row: UploadQueueItem): void\n    /** The row was given its metadata. */\n    afterMetadataLoaded?(queueKey: UploadQueueKey, row: UploadQueueItem): void\n    /**\n     * Whether a refresh may still change a failed row, told whenever that changes. For a store that offers\n     * refresh on a failed row only where it can help.\n     *\n     * `true`: the row is asked about although the client gave it up (`track(…, { clientFailed: true })`), or its\n     * file is a duplicate whose original could not be read. `false`: the server has said what became of the file\n     * (processed, failed, a duplicate that was settled), its asset is gone from as many reads as it takes, or the\n     * store took the row out (`untrack`, `dropQueue`). A row never told `true` is never told `false`. Not called\n     * by `dispose()`.\n     */\n    onRefreshMayHelp?(queueKey: UploadQueueKey, row: UploadQueueItem, mayHelp: boolean): void\n  }\n  connection: {\n    /**\n     * Whether notifications come for the rows of the queue `queueKey`: its poll is then only a backup. A profile\n     * that keeps one state for all its queues may leave the queue unread.\n     */\n    isPushAlive(queueKey?: UploadQueueKey): boolean\n    /** Called whenever that may have changed, for any queue. */\n    onChange(callback: () => void): () => void\n  }\n}\n\nexport interface UploadSettlementEvent {\n  kind: 'processed' | 'failed' | 'duplicate' | 'metadata' | 'copied'\n  assetId: DocId\n  /** `event.data.id` */\n  fileId: DocIdNullable\n  failReason?: AssetFileFailReasonType\n  originAssetFile?: DocIdNullable\n  assetType?: DamAssetTypeType | null\n  /** The DAM configurations the event is of, as on `UploadSettlementTarget`. Left out: every queue. */\n  configNames?: string[]\n}\n\n/**\n * `settled`: the main file is in a final state, or its asset was missing once too often and its rows were given\n * up. `pending`: not yet. And what asking again may mend: `error`, the read failed; `missing`, the asset was not\n * found; `originalUnread`, a row is left without the original of its duplicate, which could not be read.\n */\nexport type UploadRefreshOutcome = 'settled' | 'pending' | 'error' | 'missing' | 'originalUnread'\n\n/** What a store uses. */\nexport interface UploadSettlement {\n  /** The row began to wait for the server. A row that is not in the queue `queueKey` is ignored. */\n  track(queueKey: UploadQueueKey, row: UploadQueueItem, options?: { clientFailed?: boolean }): void\n  untrack(row: UploadQueueItem): void\n  /** The queue was cleared: its poller is dropped. */\n  dropQueue(queueKey: UploadQueueKey): void\n\n  /** A notification. Resolves after the write (a delayed read included) or after a failed read; never rejects. */\n  notify(event: UploadSettlementEvent): Promise<void>\n  /**\n   * The manual refresh: a read at once, with the metadata, without a hint. With `configOf` of the profile, a\n   * configuration the target names whose queues have no row of the asset is not read (`settled`); of several, the\n   * outcome first of `error`, `originalUnread`, `missing`, `pending`, `settled` that any of their reads had.\n   */\n  refreshAsset(target: UploadSettlementTarget): Promise<UploadRefreshOutcome>\n  /** The caller knows the file is processed: a read at once, with the hint `processed`. */\n  settleKnownProcessed(target: UploadSettlementTarget, options: { withMetadata: boolean }): Promise<void>\n  /** A known duplicate without a read of the asset: the `duplicate` event, and a copy the licence already has. */\n  settleKnownDuplicate(\n    target: UploadSettlementTarget,\n    originFileId: DocIdNullable,\n    assetType: DamAssetTypeType | null\n  ): Promise<void>\n  /** A known failure, without a read. Synchronous. */\n  settleKnownFailed(target: UploadSettlementTarget, failReason: AssetFileFailReasonType): void\n\n  /**\n   * The row failed by the read that was one too many to find no asset of it (the poll's, a notification's, a\n   * refresh's), and the server has settled it by nothing else since.\n   */\n  isGivenUpMissing(row: UploadQueueItem): boolean\n  hasTracked(): boolean\n  dispose(): void\n}\n"],"mappings":";AAKA,IAAaA,IAAgB;CAC3B,QAAQ;CACR,MAAM;CACN,UAAU;CACV,MAAM;CACN,gBAAgB;AAClB"}

package/dist/domains/dam/uploadQueue/store/uploadQueuesStore.d.ts

@@ -0,0 +1,55 @@
+import { UploadRefreshOutcome } from '../settlement/uploadSettlementTypes';
+import { DocId, DocIdNullable, IntegerId } from '../../../../shared/types/common';
+import { AssetDetailItemDto, DamAssetTypeType } from '../../types/Asset';
+import { AssetFileFailReasonType } from '../../types/AssetFile';
+import { UploadQueue, UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+/** The fields of a row the user edits, and the save of a detail writes. */
+export interface EditableFields {
+    keywords: DocId[];
+    authors: DocId[];
+    customData: UploadQueueItem['customData'];
+    mainFileSingleUse: boolean | null | undefined;
+}
+/** The rows of an asset as they were at a moment, field by field (`noteRowsOfAsset`). */
+export interface RowsNote {
+    assetId: DocId;
+    /** The DAM configuration of the queues the rows are in. */
+    configName: string;
+    rows: Map<UploadQueueItem, EditableFields>;
+}
+/**
+ * The rows a settle function of the store is for: those of the queues of the DAM configuration of this name, or of
+ * the configuration of the queue `queueKey`. Required: two DAMs may give one asset id.
+ */
+export type UploadQueueRowsOf = string | {
+    queueKey: UploadQueueKey;
+};
+export declare const useUploadQueuesStore: import('pinia').SetupStoreDefinition<"commonAdminUploadQueuesStore", {
+    getQueue: (queueKey: UploadQueueKey) => UploadQueue | null;
+    getQueueItems: (queueKey: UploadQueueKey) => UploadQueueItem[];
+    addByFiles: (queueKey: UploadQueueKey, extSystem: IntegerId, assetLicence: IntegerId, files: File[], configName: string) => Promise<void>;
+    addByCopyToLicence: (queueKey: UploadQueueKey, extSystem: IntegerId, assetLicence: IntegerId, assets: DocId[], configName: string) => Promise<void>;
+    queueItemProcessed: (assetId: DocId, of: UploadQueueRowsOf) => Promise<void>;
+    queueItemFullyProcessed: (assetId: DocId, of: UploadQueueRowsOf) => Promise<void>;
+    queueItemDuplicate: (assetId: DocId, originAssetFile: DocIdNullable, assetType: DamAssetTypeType | null, of: UploadQueueRowsOf) => Promise<void>;
+    queueItemFailed: (assetId: DocId, failReason: AssetFileFailReasonType, of: UploadQueueRowsOf) => Promise<void>;
+    refreshAsset: (assetId: DocId, of: UploadQueueRowsOf) => Promise<UploadRefreshOutcome>;
+    /**
+     * Whether a refresh may still change a failed row: its finish request went out before the client gave it up and
+     * the server has said nothing final about it since, or its file is a duplicate whose original could not be
+     * read. A row that failed otherwise has no use for refresh.
+     */
+    refreshMayHelp: (item: UploadQueueItem) => boolean;
+    /** The row failed because its asset was missing from as many reads as it takes ("Asset už neexistuje."). */
+    isGivenUpMissing: (item: UploadQueueItem) => boolean;
+    removeByIndex: (queueKey: UploadQueueKey, index: number) => void;
+    stopItemUpload: (queueKey: UploadQueueKey, queueItem: UploadQueueItem, _index?: number) => Promise<void>;
+    getQueueTotalCount: (queueKey: UploadQueueKey) => number;
+    getQueueProcessedCount: (queueKey: UploadQueueKey) => number;
+    stopUpload: (queueKey: UploadQueueKey) => void;
+    getQueueItemsTypes: (queueKey: UploadQueueKey) => DamAssetTypeType[];
+    updateFromDetail: (asset: AssetDetailItemDto, configName: string, mainFileSingleUse?: boolean | null, rowsAtSave?: RowsNote) => Promise<void>;
+    noteRowsOfAsset: (assetId: DocId, configName: string) => RowsNote;
+    forgetRowsNote: (note: RowsNote) => void;
+    forceReloadFileInput: (queueKey: UploadQueueKey) => void;
+}>;

package/dist/domains/dam/uploadQueue/store/uploadQueuesStore.js

@@ -0,0 +1,320 @@
+import { commonT as e } from "../../../../plugins/i18n.js";
+import { cloneDeep as t, isArray as n, isString as r, isUndefined as i } from "../../../../shared/utils/common.js";
+import { AnzuApiResponseCodeError as a } from "../../../../shared/error/AnzuApiResponseCodeError.js";
+import { apiErrorIsReported as o, apiErrorStatus as s, mapApiError as c, report as l } from "../../../api/utils/apiErrors.js";
+import { requestedUrl as u } from "../../../api/composables/request.js";
+import { damFileTypeFix as d } from "../../../ui/file/utils/fileType.js";
+import { DamAssetType as f } from "../../types/Asset.js";
+import { SYSTEM_CORE_DAM as p } from "../../api/damConstants.js";
+import { useCommonAdminCoreDamOptions as m } from "../../composables/commonAdminCoreDamOptions.js";
+import { useDamConfigState as h } from "../../config/composables/damConfigState.js";
+import { ENTITY as g, fetchAsset as _, fetchAssetByFileId as v, fetchAssetListByIds as y } from "../../api/damAssetApi.js";
+import { useDamCachedAuthors as b } from "../../author/composables/cachedAuthors.js";
+import { useDamCachedKeywords as x } from "../../keyword/composables/cachedKeywords.js";
+import { useUploadQueueItemFactory as S } from "../factory/UploadQueueItemFactory.js";
+import { useAssetSuggestions as C } from "../composables/assetSuggestions.js";
+import { DamNotificationName as w } from "../../composables/damNotificationsEventBus.js";
+import { useDamNotificationsConnection as T } from "../../composables/damNotificationsConnection.js";
+import { useDamNotifications as ee } from "../../composables/damNotifications.js";
+import { getAssetTypeByMimeType as E } from "../utils/mimeTypeHelper.js";
+import { UploadQueueItemStatus as D, UploadQueueItemType as O } from "../../types/UploadQueue.js";
+import { UploadRowRole as k } from "../settlement/uploadSettlementTypes.js";
+import { UPLOAD_QUEUE_ITEM_CHUNK_SIZE as A, createUploadQueueCore as j } from "../core/uploadQueueCore.js";
+import { libraryQueuePreset as te } from "../presets/queuePresets.js";
+import { getCurrentScope as ne, ref as re } from "vue";
+import { defineStore as M } from "pinia";
+//#region src/domains/dam/uploadQueue/store/uploadQueuesStore.ts
+var N = (e) => t({
+	keywords: e.keywords,
+	authors: e.authors,
+	customData: e.customData,
+	mainFileSingleUse: e.mainFileSingleUse
+}), P = (e, t) => JSON.stringify(e) === JSON.stringify(t), F = (e, n, r) => {
+	let a = {
+		fields: /* @__PURE__ */ new Set(),
+		customKeys: /* @__PURE__ */ new Set()
+	}, o = (t) => !n || P(e[t], n[t]) ? !0 : (a.fields.add(t), !1);
+	o("keywords") && (e.keywords = [...r.keywords]), o("authors") && (e.authors = [...r.authors]);
+	let s = t(r.customData);
+	if (n && s) {
+		let r = e.customData ?? {}, i = n.customData ?? {};
+		(/* @__PURE__ */ new Set([...Object.keys(r), ...Object.keys(i)])).forEach((e) => {
+			P(r[e], i[e]) || (a.customKeys.add(e), e in r ? s[e] = t(r[e]) : delete s[e]);
+		});
+	}
+	return e.customData = s, i(r.mainFileSingleUse) ? a.fields.add("mainFileSingleUse") : o("mainFileSingleUse") && (e.mainFileSingleUse = r.mainFileSingleUse), a;
+}, I = (e, n, r) => {
+	let i = e.rows.get(n);
+	if (!i) return;
+	r.fields.has("keywords") || (i.keywords = [...n.keywords]), r.fields.has("authors") || (i.authors = [...n.authors]), r.fields.has("mainFileSingleUse") || (i.mainFileSingleUse = n.mainFileSingleUse);
+	let a = n.customData ?? {}, o = i.customData = { ...i.customData };
+	(/* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(o)])).forEach((e) => {
+		r.customKeys.has(e) || (e in a ? o[e] = t(a[e]) : delete o[e]);
+	});
+}, L = M("commonAdminUploadQueuesStore", () => {
+	let t = re(/* @__PURE__ */ new Map()), { createDefault: M } = S(), P = /* @__PURE__ */ new Map(), L = (e) => (i(e) ? void 0 : P.get(e)) ?? "default", R = (e) => m(L(e)), z = {
+		roleOf: (e) => e.type === O.Asset ? k.Copy : k.Upload,
+		policyFor: () => ({
+			reader: "asset",
+			settleOn: "read",
+			duplicate: "becomeOriginal",
+			metadata: "load"
+		}),
+		matches: (e, t) => e.assetId === t.assetId,
+		readers: {
+			asset: async (e, t) => {
+				let { damClient: n, endPointAsset: r } = R(t?.queueKey);
+				try {
+					return t?.report === !1 ? await _(n, r, e, { report: !1 }) : await _(n, r, e);
+				} catch (e) {
+					if (s(e) === 404) return null;
+					throw e;
+				}
+			},
+			assets: async (e, t, r) => {
+				let { damClient: i, endPointAsset: o } = R(r?.queueKey);
+				try {
+					return await y(i, o, t, e);
+				} catch (s) {
+					if (r?.report) {
+						let r = n(s) ? s.at(-1) : void 0, d = `${o}/licence/${e}/ids/${t.join(",")}`, f = {
+							system: p,
+							entity: g,
+							url: u(i, d, {}, s, r?.config)
+						}, m = n(s) ? new a(r?.status ?? 0) : s;
+						throw l(c(m, f), f);
+					}
+					throw s;
+				}
+			},
+			duplicateOriginAsset: async (e, t) => {
+				let { damClient: n, endPointAsset: r } = R(t?.queueKey);
+				return v(n, r, e);
+			},
+			failureReported: o
+		},
+		configOf: L,
+		caches: {
+			addAuthors: (e, t) => b(L(t)).addToCachedAuthors(e),
+			addKeywords: (e, t) => x(L(t)).addToCachedKeywords(e),
+			fetchAuthors: (e) => b(L(e)).fetchCachedAuthors(),
+			fetchKeywords: (e) => x(L(e)).fetchCachedKeywords()
+		},
+		messages: {
+			processingTooLong: () => e("common.damImage.uploadErrors.processingTooLong"),
+			readFailed: () => e("common.damImage.uploadErrors.readFailed"),
+			assetMissing: () => e("common.damImage.uploadErrors.unknownError"),
+			assetGone: () => e("common.damImage.queueItem.assetGone")
+		},
+		connection: {
+			isPushAlive: (e) => T(L(e)).isPushAlive(),
+			onChange: T().onChange
+		}
+	}, B = j(te({
+		queues: t,
+		settlement: z,
+		configOf: L
+	})), { settlement: V } = B;
+	function H(e, t, n) {
+		let r = P.get(e);
+		if (!i(r) && r !== t && B.getQueueItems(e).length > 0) throw Error(`useUploadQueuesStore: the queue "${e}" has rows under the DAM configuration "${r}", none is added under "${t}".`);
+		P.set(e, t), B.addRow(e, n);
+	}
+	let U = ne(), W = (e, t) => {
+		switch (e.name) {
+			case w.AssetFileProcessed: return {
+				kind: "processed",
+				assetId: e.data.asset,
+				fileId: null,
+				configNames: t
+			};
+			case w.AssetFileFailed: return {
+				kind: "failed",
+				assetId: e.data.asset,
+				fileId: null,
+				failReason: e.data.failReason,
+				configNames: t
+			};
+			case w.AssetFileDuplicate: return {
+				kind: "duplicate",
+				assetId: e.data.asset,
+				fileId: null,
+				originAssetFile: e.data.originAssetFile,
+				assetType: e.data.assetType,
+				configNames: t
+			};
+			case w.AssetMetadataProcessed: return {
+				kind: "metadata",
+				assetId: e.data.asset,
+				fileId: null,
+				configNames: t
+			};
+			case w.AssetFileCopied: return {
+				kind: "copied",
+				assetId: e.data.asset,
+				fileId: null,
+				configNames: t
+			};
+		}
+		return null;
+	}, { addDamNotificationListener: G } = ee(), K = !1;
+	function q() {
+		if (K) return;
+		K = !0;
+		let e = () => G((e, t) => {
+			let n = W(e, t);
+			n && V.notify(n);
+		}, { all: !0 });
+		U ? U.run(e) : e();
+	}
+	async function ie(e, t, n, r, a) {
+		m(a);
+		let { getDamConfigExtSystem: o } = h(void 0, a), s = o(t);
+		if (i(s)) throw Error("useUploadQueuesStore.addByCopyToLicence: Ext system must be initialised.");
+		q();
+		for (let t of r) {
+			let r = M(B.uniqueKey("asset_" + t), O.Asset, D.Processing, f.Image, A, n);
+			r.assetId = t, H(e, a, r);
+			let i = B.getQueueItems(e).at(-1);
+			i && B.track(e, i);
+		}
+	}
+	async function ae(e, t, n, r, a) {
+		m(a);
+		let { getDamConfigExtSystem: o } = h(void 0, a), s = o(t);
+		if (i(s)) throw Error("useUploadQueuesStore.addByFiles: Ext system must be initialised.");
+		q();
+		for await (let t of r) {
+			let r = E(d(t), s);
+			if (!r || r !== f.Image) continue;
+			let i = M(B.uniqueKey("file_" + t.name), O.File, D.Waiting, r, A, n);
+			i.file = t, i.displayTitle = t.name, H(e, a, i);
+		}
+	}
+	let J = (e, t) => ({
+		assetId: e,
+		fileId: null,
+		configNames: [r(t) ? t : L(t.queueKey)]
+	});
+	function oe(e, t) {
+		return V.notify({
+			kind: "processed",
+			...J(e, t)
+		});
+	}
+	function se(e, t) {
+		return V.settleKnownProcessed(J(e, t), { withMetadata: !0 });
+	}
+	function ce(e, t, n, r) {
+		return V.settleKnownDuplicate(J(e, r), t, n);
+	}
+	async function le(e, t, n) {
+		V.settleKnownFailed(J(e, n), t);
+	}
+	function ue(e, t) {
+		return V.refreshAsset(J(e, t));
+	}
+	async function de(e, t, n) {
+		B.stopItemUpload(e, t);
+	}
+	let Y = /* @__PURE__ */ new Map(), fe = (e, t) => `${e}\u0000${t}`, pe = 0, X = /* @__PURE__ */ new Set();
+	function Z(e, n) {
+		let r = /* @__PURE__ */ new Map();
+		t.value.forEach((t, i) => {
+			L(i) === n && t.items.forEach((t) => {
+				t.assetId === e && t.type && r.set(t, N(t));
+			});
+		});
+		let i = {
+			assetId: e,
+			configName: n,
+			rows: r
+		};
+		return X.add(i), i;
+	}
+	function Q(e) {
+		X.delete(e);
+	}
+	let $ = (e, t, n) => {
+		X.forEach((r) => {
+			r !== e && r.assetId === e.assetId && r.configName === e.configName && I(r, t, n);
+		});
+	};
+	async function me(e, n, r, a) {
+		let { updateNewNames: o, getAuthorConflicts: s } = C(), c;
+		try {
+			c = m(n);
+		} catch {
+			return;
+		}
+		let { addToCachedKeywords: l, fetchCachedKeywords: u } = x(n), { addToCachedAuthors: d, fetchCachedAuthors: f } = b(n), p = () => Array.from(t.value.entries()).filter(([e]) => L(e) === n), h = p().flatMap(([, e]) => e.items);
+		if (!h.some((t) => t.assetId === e.id && !!t.type) && !h.some((t) => !!t.type && t.status === D.Processing && t.licenceId === e.licence)) {
+			a && Q(a);
+			return;
+		}
+		let g = a ?? Z(e.id, n), v = g.rows, y = ++pe, S = fe(n, e.id);
+		Y.set(S, y);
+		let w = () => Y.get(S) === y;
+		try {
+			let t = await _(c.damClient, c.endPointAsset, e.id);
+			if (!w()) return;
+			p().forEach(([e, n]) => {
+				n.items.forEach((e) => {
+					if (e.assetId === t.id && e.type) {
+						let r = F(e, v.get(e), {
+							keywords: t.keywords,
+							authors: t.authors,
+							customData: t.metadata.customData,
+							mainFileSingleUse: t.mainFileSingleUse
+						});
+						$(g, e, r), o(t.metadata.authorSuggestions, n.suggestions.newAuthorNames), o(t.metadata.keywordSuggestions, n.suggestions.newKeywordNames), e.authorConflicts = s(t.metadata.authorSuggestions), l(e.keywords), d(e.authors), d(e.authorConflicts);
+					}
+				}), B.recalculateQueueCounts(e), f(), u();
+			});
+		} catch {
+			if (!w()) return;
+			p().forEach(([, t]) => {
+				t.items.forEach((t) => {
+					if (t.assetId === e.id && t.type) {
+						let n = F(t, v.get(t), {
+							keywords: e.keywords,
+							authors: e.authors,
+							customData: e.metadata.customData,
+							mainFileSingleUse: i(r) ? void 0 : r
+						});
+						$(g, t, n), l(t.keywords), d(t.authors);
+					}
+				});
+			}), f(), u();
+		} finally {
+			Q(g), w() && Y.delete(S);
+		}
+	}
+	return {
+		getQueue: B.getQueue,
+		getQueueItems: B.getQueueItems,
+		addByFiles: ae,
+		addByCopyToLicence: ie,
+		queueItemProcessed: oe,
+		queueItemFullyProcessed: se,
+		queueItemDuplicate: ce,
+		queueItemFailed: le,
+		refreshAsset: ue,
+		refreshMayHelp: B.refreshMayHelp,
+		isGivenUpMissing: (e) => V.isGivenUpMissing(e),
+		removeByIndex: B.removeByIndex,
+		stopItemUpload: de,
+		getQueueTotalCount: B.getQueueTotalCount,
+		getQueueProcessedCount: B.getQueueProcessedCount,
+		stopUpload: B.stopUpload,
+		getQueueItemsTypes: B.getQueueItemsTypes,
+		updateFromDetail: me,
+		noteRowsOfAsset: Z,
+		forgetRowsNote: Q,
+		forceReloadFileInput: B.forceReloadFileInput
+	};
+});
+//#endregion
+export { L as useUploadQueuesStore };
+
+//# sourceMappingURL=uploadQueuesStore.js.map