@tstdl/base 0.92.86 → 0.92.88

package/document-management/server/services/document-management.service.js

@@ -4,41 +4,157 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { AiService } from '../../../ai/ai.service.js';
-import { getEntityMap } from '../../../database/index.js';
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var DocumentManagementService_1;
+import { and, eq, inArray, ne, notExists, sql } from 'drizzle-orm';
+import { P, match } from 'ts-pattern';
+import { AiService } from '../../../ai/index.js';
 import { Enumerable } from '../../../enumerable/index.js';
 import { BadRequestError } from '../../../errors/index.js';
-import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
-import { Singleton, inject, injectArgument, provide, resolveArgumentType } from '../../../injector/index.js';
+import { TemporaryFile, getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
+import { Singleton, afterResolve, inject, injectArgument, provide, resolveArgumentType } from '../../../injector/index.js';
+import { Logger } from '../../../logger/logger.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
-import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../../orm/server/index.js';
-import { array, enumeration, integer, nullable, object, string } from '../../../schema/index.js';
-import { toArray } from '../../../utils/array/index.js';
-import { assertDefinedPass, assertStringPass, compareByValueSelectionToOrder, currentTimestamp, digest, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, millisecondsPerMinute } from '../../../utils/index.js';
+import { getEntityMap } from '../../../orm/index.js';
+import { DatabaseConfig, EntityRepositoryConfig, TRANSACTION_TIMESTAMP, arrayAgg, coalesce, injectRepository, jsonAgg, toJsonb } from '../../../orm/server/index.js';
+import { getPdfPageCount } from '../../../pdf/index.js';
+import { Queue } from '../../../queue/queue.js';
+import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
+import { distinct, toArray } from '../../../utils/array/index.js';
+import { compareByValueSelectionToOrder } from '../../../utils/comparison.js';
+import { digest } from '../../../utils/cryptography.js';
+import { currentTimestamp, dateObjectToNumericDate } from '../../../utils/date-time.js';
 import { groupToMap } from '../../../utils/iterable-helpers/index.js';
+import { fromEntries, objectEntries } from '../../../utils/object/object.js';
 import { readBinaryStream } from '../../../utils/stream/index.js';
-import { Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentProperty, DocumentPropertyBooleanValue, DocumentPropertyDataType, DocumentPropertyDecimalValue, DocumentPropertyIntegerValue, DocumentPropertyTextValue, DocumentRequest, DocumentRequestCollection, DocumentRequestFile, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty } from '../../models/index.js';
+import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
+import { assertBooleanPass, assertDefined, assertDefinedPass, assertNotNullPass, assertNumberPass, assertStringPass, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, isUndefined } from '../../../utils/type-guards.js';
+import { millisecondsPerMinute } from '../../../utils/units.js';
+import { Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestAssignmentTask, DocumentRequestAssignmentTaskCollection, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestCollection, DocumentRequestFile, DocumentRequestFilePropertyValue, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty } from '../../models/index.js';
 import { DocumentManagementConfig } from '../module.js';
-let DocumentManagementService = class DocumentManagementService {
+import { documentCategory, documentProperty, documentRequest, documentRequestAssignmentTask, documentRequestAssignmentTaskCollection, documentRequestAssignmentTaskPropertyValue, documentRequestCollection, documentRequestFile, documentType } from '../schemas.js';
+import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
+const defaultGenerationOptions = {
+    model: 'gemini-2.0-flash',
+    generationOptions: {
+        maxOutputTokens: 2048,
+        temperature: 0.2,
+        topP: 0.2
+    }
+};
+let DocumentManagementService = DocumentManagementService_1 = class DocumentManagementService {
     #aiService = inject(AiService);
-    documentService = injectRepository(Document);
-    documentFileService = injectRepository(DocumentFile);
-    documentCollectionService = injectRepository(DocumentCollection);
+    ancillaryService = inject(DocumentManagementAncillaryService);
     documentCategoryService = injectRepository(DocumentCategory);
-    documentTypeService = injectRepository(DocumentType);
+    documentCollectionDocumentService = injectRepository(DocumentCollectionDocument);
+    documentCollectionService = injectRepository(DocumentCollection);
+    documentFileService = injectRepository(DocumentFile);
+    documentPropertyService = injectRepository(DocumentProperty);
+    documentPropertyValueService = injectRepository(DocumentPropertyValue);
+    documentRequestAssignmentTaskCollectionService = injectRepository(DocumentRequestAssignmentTaskCollection);
+    documentRequestAssignmentTaskService = injectRepository(DocumentRequestAssignmentTask);
+    documentRequestCollectionService = injectRepository(DocumentRequestCollection);
+    documentRequestFilePropertyValueService = injectRepository(DocumentRequestFilePropertyValue);
+    documentRequestAssignmentTaskPropertyValueService = injectRepository(DocumentRequestAssignmentTaskPropertyValue);
+    documentRequestFileService = injectRepository(DocumentRequestFile);
     documentRequestService = injectRepository(DocumentRequest);
     documentRequestsTemplateService = injectRepository(DocumentRequestsTemplate);
     documentRequestTemplateService = injectRepository(DocumentRequestTemplate);
-    documentRequestCollectionService = injectRepository(DocumentRequestCollection);
-    documentRequestFileService = injectRepository(DocumentRequestFile);
-    documentPropertyService = injectRepository(DocumentProperty);
+    documentService = injectRepository(Document);
     documentTypePropertyService = injectRepository(DocumentTypeProperty);
-    documentPropertyTextValueService = injectRepository(DocumentPropertyTextValue);
-    documentPropertyIntegerValueService = injectRepository(DocumentPropertyIntegerValue);
-    documentPropertyDecimalValueService = injectRepository(DocumentPropertyDecimalValue);
-    documentPropertyBooleanValueService = injectRepository(DocumentPropertyBooleanValue);
-    documentCollectionDocumentService = injectRepository(DocumentCollectionDocument);
+    documentTypeService = injectRepository(DocumentType);
     fileObjectStorage = inject(ObjectStorage, (injectArgument(this, { optional: true }) ?? inject(DocumentManagementConfig)).fileObjectStorageModule);
+    extractionQueue = inject((Queue), { name: 'DocumentManagement:extraction', processTimeout: 15 * millisecondsPerMinute });
+    assignmentQueue = inject((Queue), { name: 'DocumentManagement:assignment', processTimeout: 15 * millisecondsPerMinute });
+    logger = inject(Logger, DocumentManagementService_1.name);
+    [afterResolve](_, { cancellationSignal }) {
+        this.processQueues(cancellationSignal);
+    }
+    processQueues(cancellationSignal) {
+        this.extractionQueue.process({ concurrency: 1, cancellationSignal }, async (job) => {
+            const [entry] = objectEntries(job.data);
+            this.logger.info(`Processing extraction job for ${entry?.[0]} "${entry?.[1]}"`);
+            await match(job.data)
+                .with({ documentId: P.string.select() }, async (documentId) => this.enrichDocument(documentId))
+                .with({ requestFileId: P.string.select() }, async (requestFileId) => this.enrichDocumentRequestFile(requestFileId))
+                .with({ requestAssignmentTaskId: P.string.select() }, async (requestAssignmentTaskId) => this.enrichDocumentRequestAssignmentTask(requestAssignmentTaskId))
+                .exhaustive();
+        }, this.logger);
+        this.assignmentQueue.process({ concurrency: 1, cancellationSignal }, async (job) => {
+            this.logger.info(`Processing assignment job "${job.data.requestAssignmentTaskId}"`);
+            await this.assignDocumentRequest(job.data.requestAssignmentTaskId);
+        }, this.logger);
+    }
+    async resolveNames(...collectionsOrIds) {
+        if (collectionsOrIds.length == 0) {
+            return [];
+        }
+        const loadIds = collectionsOrIds.filter((collection) => isString(collection));
+        if (loadIds.length == 0) {
+            return this.ancillaryService.resolveNames(collectionsOrIds);
+        }
+        const loadedCollections = await this.documentCollectionService.loadManyByQuery({ id: { $in: loadIds } });
+        const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
+            ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
+            : collectionOrId);
+        return this.ancillaryService.resolveNames(collections);
+    }
+    async resolveNamesMap(...collectionsOrIds) {
+        const names = await this.resolveNames(...collectionsOrIds);
+        const entries = collectionsOrIds.map((collectionOrId, index) => [isString(collectionOrId) ? collectionOrId : collectionOrId.id, names[index]]);
+        return fromEntries(entries);
+    }
     async loadData(collectionIds, collectionsMetadata) {
         return this.documentCollectionService.transaction(async (_, transaction) => {
             const [collections, collectionDocuments, requestCollections, categories, types] = await Promise.all([
@@ -50,20 +166,17 @@ let DocumentManagementService = class DocumentManagementService {
             ]);
             const documentIds = collectionDocuments.map((document) => document.documentId);
             const requestIds = requestCollections.map((requestCollection) => requestCollection.requestId);
-            const [documents, requests, requestFiles, textValues, integerValues, decimalValues, booleanValues] = await Promise.all([
+            const [documents, requests, requestFiles, propertyValues] = await Promise.all([
                 this.documentService.withTransaction(transaction).loadManyByQuery({ id: { $in: documentIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.documentRequestService.withTransaction(transaction).loadManyByQuery({ id: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
                 this.documentRequestFileService.withTransaction(transaction).loadManyByQuery({ requestId: { $in: requestIds } }, { order: { 'metadata.createTimestamp': 'desc' } }),
-                this.documentPropertyTextValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
-                this.documentPropertyIntegerValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
-                this.documentPropertyDecimalValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } }),
-                this.documentPropertyBooleanValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } })
+                this.documentPropertyValueService.withTransaction(transaction).loadManyByQuery({ documentId: { $in: documentIds } })
             ]);
             const documentFileIds = documents.map((document) => document.fileId);
             const requestFileIds = requestFiles.map((requestFile) => requestFile.fileId);
             const files = await this.documentFileService.withTransaction(transaction).loadManyByQuery({ id: { $in: [...documentFileIds, ...requestFileIds] } }, { order: { 'metadata.createTimestamp': 'desc' } });
             const requestsFilesMap = groupToMap(requestFiles, (requestFile) => requestFile.requestId);
-            const valuesMap = Enumerable.from(textValues).concat(integerValues).concat(decimalValues).concat(booleanValues).groupToMap((value) => value.documentId);
+            const valuesMap = Enumerable.from(propertyValues).groupToMap((value) => value.documentId);
             const collectionViews = collections.toSorted(compareByValueSelectionToOrder(collectionIds, (collection) => collection.id)).map((collection) => ({
                 ...collection,
                 name: collectionsMetadata?.[collection.id]?.name ?? null,
@@ -172,19 +285,20 @@ let DocumentManagementService = class DocumentManagementService {
     async deleteDocumentRequestTemplate(parameters) {
         return this.documentRequestTemplateService.delete(parameters.id);
     }
-    async createDocument({ typeId, title, date, expiration, originalFileName, collectionIds, properties, metadata }, content) {
-        return this.documentService.transaction(async (_, transaction) => {
+    async createDocument({ typeId, title, subtitle, pages, date, summary, tags, originalFileName, collectionIds, properties, metadata }, content) {
+        const document = await this.documentService.transaction(async (_, transaction) => {
             const documentFile = await this.createDocumentFile(content, originalFileName, transaction);
-            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, title, date, expiration, metadata });
+            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, title, subtitle, pages, date, summary, tags, metadata });
             for (const collectionId of toArray(collectionIds)) {
                 await this.documentCollectionDocumentService.withTransaction(transaction).insert({ collectionId, documentId: document.id, archiveTimestamp: null });
             }
             if (isDefined(properties)) {
-                const mappedProperties = properties.map((property) => ({ ...property, documentId: document.id }));
-                await this.setDocumentProperties(mappedProperties, transaction);
+                await this.setPropertyValues({ documentId: document.id, properties }, transaction);
             }
             return document;
         });
+        void tryIgnoreLogAsync(async () => this.extractionQueue.enqueue({ documentId: document.id }), this.logger);
+        return document;
     }
     async approveDocumentRequestFile({ id, approvalComment, documentMetadata, requestFileMetadata }) {
         return this.documentRequestFileService.transaction(async (_, transaction) => {
@@ -198,14 +312,17 @@ let DocumentManagementService = class DocumentManagementService {
                 fileId: requestFile.fileId,
                 typeId: request.typeId,
                 title: requestFile.title,
-                date: null,
-                expiration: null,
+                subtitle: requestFile.subtitle,
+                pages: requestFile.pages,
+                date: requestFile.date,
+                summary: requestFile.summary,
+                tags: requestFile.tags,
                 metadata: documentMetadata
             });
             for (const { collectionId } of requestCollections) {
                 await this.addDocumentToCollection({ collectionId, documentId: document.id }, transaction);
             }
-            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: true, approvalComment, approvalTimestamp: currentTimestamp(), createdDocumentId: document.id, metadata: requestFileMetadata });
+            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: true, approvalComment, approvalTimestamp: TRANSACTION_TIMESTAMP, createdDocumentId: document.id, metadata: requestFileMetadata });
             return document;
         });
     }
@@ -215,7 +332,7 @@ let DocumentManagementService = class DocumentManagementService {
             if (requestFile.approval == true) {
                 throw new BadRequestError('Document request file already accepted.');
             }
-            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: false, approvalComment, approvalTimestamp: currentTimestamp(), metadata });
+            await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: false, approvalComment, approvalTimestamp: TRANSACTION_TIMESTAMP, metadata });
         });
     }
     async updateDocumentRequestFile({ id, title, approvalComment, metadata }) {
@@ -228,12 +345,14 @@ let DocumentManagementService = class DocumentManagementService {
         }
         await this.documentRequestFileService.delete(id, metadata);
     }
-    async createDocumentFile(content, originalFileName, dbTransaction) {
-        return this.documentFileService.useTransaction(dbTransaction, async (_, transaction) => {
-            const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
-            const hash = await digest('SHA-256', contentAsUint8Array).toHex();
-            const mimeType = await getMimeType(contentAsUint8Array);
-            const documentFile = await this.documentFileService.withTransaction(transaction).insert({
+    async createDocumentFile(content, originalFileName, transaction) {
+        const contentAsUint8Array = isUint8Array(content) ? content : await readBinaryStream(content);
+        const hash = await digest('SHA-256', contentAsUint8Array).toHex();
+        const mimeType = await getMimeType(contentAsUint8Array);
+        return this.documentFileService.useTransaction(transaction, async (_, transaction) => {
+            const documentFile = await this.documentFileService
+                .withTransaction(transaction)
+                .insert({
                 originalFileName,
                 mimeType,
                 hash,
@@ -244,8 +363,8 @@ let DocumentManagementService = class DocumentManagementService {
             return documentFile;
         });
     }
-    async createDocumentRequestFile({ requestId, title, originalFileName, metadata }, content) {
-        return this.documentRequestFileService.transaction(async (_, transaction) => {
+    async createDocumentRequestFile({ requestId, title, subtitle, date, summary, tags, originalFileName, metadata }, content) {
+        const documentRequestFile = await this.documentRequestFileService.transaction(async (_, transaction) => {
             const [request, existingRequestFiles] = await Promise.all([
                 this.documentRequestService.withTransaction(transaction).load(requestId),
                 this.documentRequestFileService.withTransaction(transaction).loadManyByQuery({ requestId })
@@ -255,8 +374,26 @@ let DocumentManagementService = class DocumentManagementService {
                 throw new BadRequestError('Maximum amount of allowed files reached.');
             }
             const file = await this.createDocumentFile(content, originalFileName, transaction);
-            return this.documentRequestFileService.withTransaction(transaction).insert({ requestId, fileId: file.id, title, createdDocumentId: null, approval: null, approvalComment: null, approvalTimestamp: null, metadata });
+            return await this.documentRequestFileService
+                .withTransaction(transaction)
+                .insert({
+                requestId,
+                fileId: file.id,
+                title,
+                subtitle,
+                pages: null,
+                date,
+                summary,
+                tags,
+                createdDocumentId: null,
+                approval: null,
+                approvalComment: null,
+                approvalTimestamp: null,
+                metadata
+            });
         });
+        void tryIgnoreLogAsync(async () => this.extractionQueue.enqueue({ requestFileId: documentRequestFile.id }), this.logger);
+        return documentRequestFile;
     }
     async createDocumentRequest(parameters, transaction) {
         if (parameters.collectionIds.length == 0) {
@@ -269,13 +406,36 @@ let DocumentManagementService = class DocumentManagementService {
             return request;
         });
     }
+    async createDocumentRequestAssignmentTask({ originalFileName, collectionIds }, content) {
+        if (collectionIds.length == 0) {
+            throw new BadRequestError('No target collectionId specified.');
+        }
+        const file = await this.createDocumentFile(content, originalFileName);
+        return this.documentRequestAssignmentTaskService.transaction(async (_, transaction) => {
+            const task = await this.documentRequestAssignmentTaskService.withTransaction(transaction).insert({
+                fileId: file.id,
+                assignedRequestFileId: null,
+                typeId: null,
+                title: null,
+                subtitle: null,
+                pages: null,
+                date: null,
+                summary: null,
+                tags: null,
+                assignmentTries: 0
+            });
+            const newTaksCollections = collectionIds.map((collectionId) => ({ requestAssignmentTaskId: task.id, collectionId }));
+            await this.documentRequestAssignmentTaskCollectionService.withTransaction(transaction).insertMany(newTaksCollections);
+            void tryIgnoreLogAsync(async () => this.extractionQueue.enqueue({ requestAssignmentTaskId: task.id }), this.logger);
+            return task;
+        });
+    }
     async updateDocument(parameters, transaction) {
         const { id: documentId, properties: propertyUpdates, ...update } = parameters;
         await this.documentService.useTransaction(transaction, async (repository, tx) => {
             await repository.update(documentId, update);
             if (isDefined(propertyUpdates)) {
-                const mappedPropertyUpdates = propertyUpdates.map((property) => ({ documentId, ...property }));
-                await this.setDocumentProperties(mappedPropertyUpdates, tx);
+                await this.setPropertyValues({ documentId, properties: propertyUpdates }, tx);
             }
         });
     }
@@ -298,19 +458,41 @@ let DocumentManagementService = class DocumentManagementService {
         }
         await this.documentRequestService.withOptionalTransaction(transaction).delete(id, metadata);
     }
-    async setDocumentProperties(setDocumentPropertyItems, transaction) {
-        if ((setDocumentPropertyItems.length == 0)) {
+    async setPropertyValues({ documentId, requestFileId, requestAssignmentTaskId, properties: items }, transaction) {
+        if ((items.length == 0)) {
             return;
         }
+        if ((Number(isDefined(documentId)) + Number(isDefined(requestFileId)) + Number(isDefined(requestAssignmentTaskId))) != 1) {
+            throw new BadRequestError('Exactly one of documentId, requestFileId or requestAssignmentTaskId must be specified.');
+        }
         await this.documentPropertyService.useTransaction(transaction, async (_, tx) => {
-            const propertyIds = setDocumentPropertyItems.map((property) => property.propertyId);
+            const propertyIds = items.map((property) => property.propertyId);
             const properties = await this.documentPropertyService.withTransaction(tx).loadManyByQuery({ id: { $in: propertyIds } });
             const propertiesMap = getEntityMap(properties);
-            for (const { documentId, propertyId, value, metadata } of setDocumentPropertyItems) {
+            const propertyItems = items.map(({ propertyId, value, metadata }) => {
                 const property = assertDefinedPass(propertiesMap.get(propertyId));
                 validatePropertyValue(propertyId, property.dataType, value);
-                const propertyValueService = this.getDocumentPropertyValueService(property.dataType);
-                await propertyValueService.withTransaction(tx).upsert(['documentId', 'propertyId'], { documentId, propertyId, value: value, metadata }, undefined);
+                return {
+                    propertyId,
+                    text: (property.dataType == 'text') ? assertStringPass(value) : null,
+                    integer: (property.dataType == 'integer') ? assertNumberPass(value) : null,
+                    decimal: (property.dataType == 'decimal') ? assertNumberPass(value) : null,
+                    boolean: (property.dataType == 'boolean') ? assertBooleanPass(value) : null,
+                    date: (property.dataType == 'date') ? assertNumberPass(value) : null,
+                    metadata
+                };
+            });
+            if (isDefined(documentId)) {
+                await this.documentPropertyValueService.withTransaction(tx)
+                    .upsertMany(['documentId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, documentId })));
+            }
+            else if (isDefined(requestFileId)) {
+                await this.documentRequestFilePropertyValueService.withTransaction(tx)
+                    .upsertMany(['requestFileId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, requestFileId })));
+            }
+            else if (isDefined(requestAssignmentTaskId)) {
+                await this.documentRequestAssignmentTaskPropertyValueService.withTransaction(tx)
+                    .upsertMany(['requestAssignmentTaskId', 'propertyId'], propertyItems.map((propertyItem) => ({ ...propertyItem, requestAssignmentTaskId })));
             }
         });
     }
@@ -318,7 +500,7 @@ let DocumentManagementService = class DocumentManagementService {
         await this.documentCollectionDocumentService.withOptionalTransaction(transaction).upsert(['collectionId', 'documentId'], { ...parameters, archiveTimestamp: null });
     }
     async archiveDocument({ collectionId, documentId, metadata }) {
-        await this.documentCollectionDocumentService.updateByQuery({ collectionId, documentId }, { archiveTimestamp: currentTimestamp(), metadata });
+        await this.documentCollectionDocumentService.updateByQuery({ collectionId, documentId }, { archiveTimestamp: TRANSACTION_TIMESTAMP, metadata });
     }
     async createProperty(parameters) {
         return this.documentPropertyService.insert(parameters);
@@ -326,66 +508,282 @@ let DocumentManagementService = class DocumentManagementService {
     async assignPropertyToType(parameters) {
         await this.documentTypePropertyService.insert(parameters);
     }
-    async extractDocumentInformation() {
-        const file = await this.#aiService.processFile({ path: '', mimeType: '' });
-        const types = await this.documentTypeService.loadAll();
-        const typeLabels = types.map((type) => type.label);
-        const generationSchema = object({
-            documentTitle: string(),
-            documentSubtitle: nullable(string()),
-            documentTypes: array(enumeration(typeLabels)),
-            documentSummary: string(),
-            documentTags: array(string()),
-            documentDate: nullable(object({ year: integer(), month: integer(), day: integer() }))
+    async enrichDocument(documentId) {
+        const document = await this.documentService.load(documentId);
+        const { properties, ...extractionResult } = await this.extractFileInformation(document.fileId, document.typeId);
+        await this.documentService.transaction(async (documentService, transaction) => {
+            await documentService.update(document.id, extractionResult);
+            await this.setPropertyValues({ documentId, properties: properties }, transaction);
+        });
+    }
+    async enrichDocumentRequestFile(requestFileId) {
+        const requestFile = await this.documentRequestFileService.load(requestFileId);
+        const request = await this.documentRequestService.load(requestFile.requestId);
+        const { properties, typeId: _, ...extractionResult } = await this.extractFileInformation(requestFile.fileId, request.typeId);
+        await this.documentRequestFileService.transaction(async (documentRequestFileService, transaction) => {
+            await documentRequestFileService.update(requestFile.id, extractionResult);
+            await this.setPropertyValues({ requestFileId, properties: properties }, transaction);
+        });
+    }
+    async enrichDocumentRequestAssignmentTask(requestAssignmentTaskId) {
+        const task = await this.documentRequestAssignmentTaskService.load(requestAssignmentTaskId);
+        const { properties, ...extractionResult } = await this.extractFileInformation(task.fileId);
+        await this.documentRequestAssignmentTaskService.transaction(async (documentRequestAssignmentTaskService, transaction) => {
+            await documentRequestAssignmentTaskService.update(task.id, extractionResult);
+            await this.setPropertyValues({ requestAssignmentTaskId, properties: properties }, transaction);
         });
-        const generation = await this.#aiService.generate({
-            model: 'gemini-2.0-flash',
+        void tryIgnoreLogAsync(async () => this.assignmentQueue.enqueue({ requestAssignmentTaskId }), this.logger);
+    }
+    async assignDocumentRequest(requestAssignmentTaskId) {
+        const session = this.documentRequestAssignmentTaskCollectionService.session;
+        const requestAssignmentTaskProperties = session.$with('requestAssignmentTaskProperty').as(session
+            .select({
+            requestAssignmentTaskId: documentRequestAssignmentTaskPropertyValue.requestAssignmentTaskId,
+            propertyId: documentRequestAssignmentTaskPropertyValue.propertyId,
+            label: documentProperty.label,
+            value: coalesce(toJsonb(documentRequestAssignmentTaskPropertyValue.text), toJsonb(documentRequestAssignmentTaskPropertyValue.integer), toJsonb(documentRequestAssignmentTaskPropertyValue.decimal), toJsonb(documentRequestAssignmentTaskPropertyValue.boolean), toJsonb(documentRequestAssignmentTaskPropertyValue.date)).as('value')
+        })
+            .from(documentRequestAssignmentTaskPropertyValue)
+            .innerJoin(documentProperty, eq(documentProperty.id, documentRequestAssignmentTaskPropertyValue.propertyId)));
+        const [task] = await session
+            .with(requestAssignmentTaskProperties)
+            .select({
+            fileId: documentRequestAssignmentTask.fileId,
+            collectionIds: arrayAgg(documentRequestAssignmentTaskCollection.collectionId),
+            typeCategory: documentCategory.label,
+            typeGroup: documentType.group,
+            typeLabel: documentType.label,
+            title: documentRequestAssignmentTask.title,
+            subtitle: documentRequestAssignmentTask.subtitle,
+            pages: documentRequestAssignmentTask.pages,
+            date: documentRequestAssignmentTask.date,
+            summary: documentRequestAssignmentTask.summary,
+            tags: documentRequestAssignmentTask.tags,
+            assignmentTries: documentRequestAssignmentTask.assignmentTries,
+            properties: sql `coalesce(${jsonAgg(requestAssignmentTaskProperties)} FILTER (WHERE ${requestAssignmentTaskProperties.propertyId} IS NOT NULL), '[]'::json)`
+        })
+            .from(documentRequestAssignmentTask)
+            .innerJoin(documentRequestAssignmentTaskCollection, eq(documentRequestAssignmentTaskCollection.requestAssignmentTaskId, documentRequestAssignmentTask.id))
+            .innerJoin(documentType, eq(documentType.id, documentRequestAssignmentTask.typeId))
+            .innerJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
+            .leftJoin(requestAssignmentTaskProperties, eq(requestAssignmentTaskProperties.requestAssignmentTaskId, documentRequestAssignmentTask.id))
+            .where(eq(documentRequestAssignmentTask.id, requestAssignmentTaskId))
+            .groupBy(documentRequestAssignmentTask.fileId, requestAssignmentTaskProperties.label, documentCategory.label, documentType.group, documentType.label, documentRequestAssignmentTask.title, documentRequestAssignmentTask.subtitle, documentRequestAssignmentTask.pages, documentRequestAssignmentTask.date, documentRequestAssignmentTask.summary, documentRequestAssignmentTask.tags, documentRequestAssignmentTask.assignmentTries);
+        assertDefined(task);
+        if (task.assignmentTries >= 3) {
+            this.logger.error(`Ignoring assignment task "${requestAssignmentTaskId}" because max tries are reached.`);
+            return;
+        }
+        const requestsWithoutFiles = await session
+            .select({
+            id: documentRequest.id,
+            collectionIds: arrayAgg(documentRequestCollection.collectionId),
+            documentCategory: documentCategory.label,
+            documentGroup: documentType.group,
+            documentType: documentType.label,
+            comment: documentRequest.comment
+        })
+            .from(documentRequest)
+            .innerJoin(documentRequestCollection, eq(documentRequestCollection.requestId, documentRequest.id))
+            .innerJoin(documentType, eq(documentType.id, documentRequest.typeId))
+            .innerJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
+            .where(and(inArray(documentRequestCollection.collectionId, task.collectionIds), notExists(session
+            .select()
+            .from(documentRequestFile)
+            .where(and(eq(documentRequestFile.requestId, documentRequest.id), ne(documentRequestFile.approval, false))))))
+            .groupBy(documentRequest.id, documentCategory.label, documentType.group, documentType.label, documentRequest.comment);
+        const requestsCollectionIds = distinct(requestsWithoutFiles.flatMap((request) => request.collectionIds));
+        const collectionNamesMap = await this.resolveNamesMap(...requestsCollectionIds);
+        const requests = requestsWithoutFiles.map((request) => ({
+            id: request.id,
+            collections: request.collectionIds.map((collectionId) => assertDefinedPass(collectionNamesMap[collectionId])),
+            documentCategory: request.documentCategory,
+            documentGroup: request.documentGroup ?? undefined,
+            documentType: request.documentType,
+            comment: request.comment ?? undefined
+        }));
+        const propertyEntries = task.properties.map((property) => [property.label, assertNotNullPass(property.value)]);
+        const context = {
+            file: {
+                documentCategory: task.typeCategory,
+                documentGroup: task.typeGroup ?? undefined,
+                documentType: task.typeLabel,
+                properties: fromEntries(propertyEntries)
+            },
+            requests
+        };
+        const result = await this.#aiService.generate({
+            ...defaultGenerationOptions,
             generationOptions: {
-                maxOutputTokens: 2048,
-                temperature: 0.2,
+                maxOutputTokens: 100,
+                temperature: 0,
                 topP: 0.2
             },
-            generationSchema,
-            contents: [
-                {
-                    role: 'user', parts: [
-                        { file: file.file },
+            generationSchema: object({ requestId: nullable(string()) }),
+            contents: [{
+                    role: 'user',
+                    parts: [
                         {
-                            text: `Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+                            text: `<context>
+${JSON.stringify(context, null, 2)}
+</context>
 
-Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
-Erstelle bis zu 7 möglichst spezifische Tags ohne allgemeinen Worte.
-Antworte auf deutsch.`
+Ordne die Datei unter "file" der passenden Anforderungen unter "requests" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Anforderung passt, setze requestId auf null.`
                         }
                     ]
-                }
-            ]
+                }]
+        });
+        await this.documentRequestAssignmentTaskService.update(requestAssignmentTaskId, { assignmentTries: sql `${documentRequestAssignmentTask.assignmentTries} + 1` });
+        if (isNull(result.json.requestId)) {
+            return;
+        }
+        await this.documentRequestFileService.transaction(async (_, transaction) => {
+            const requestFile = await this.documentRequestFileService.withTransaction(transaction).insert({
+                requestId: result.json.requestId,
+                fileId: task.fileId,
+                title: task.title,
+                subtitle: task.subtitle,
+                pages: task.pages,
+                date: task.date,
+                summary: task.summary,
+                tags: task.tags,
+                createdDocumentId: null,
+                approval: null,
+                approvalComment: null,
+                approvalTimestamp: null
+            });
+            await this.setPropertyValues({ requestFileId: requestFile.id, properties: task.properties }, transaction);
         });
-        const resultJson = JSON.parse(assertStringPass(generation.text, 'No text generated.'));
-        const result = generationSchema.parse(resultJson);
-        result.documentTags = result.documentTags.filter((tag) => (tag != result.documentTitle) && (tag != result.documentSubtitle));
-        return {
-            title: result.documentTitle,
-            subtitle: result.documentSubtitle,
-            types: result.documentTypes.map((typeLabel) => types.find((type) => type.label == typeLabel)).filter(isDefined),
-            summary: result.documentSummary,
-            tags: result.documentTags,
-            date: result.documentDate
-        };
     }
-    getDocumentPropertyValueService(dataType) {
-        switch (dataType) {
-            case DocumentPropertyDataType.Text:
-                return this.documentPropertyTextValueService;
-            case DocumentPropertyDataType.Integer:
-                return this.documentPropertyIntegerValueService;
-            case DocumentPropertyDataType.Decimal:
-                return this.documentPropertyDecimalValueService;
-            case DocumentPropertyDataType.Boolean:
-                return this.documentPropertyBooleanValueService;
-            default:
-                throw new BadRequestError('Unknown property data type.');
+    async extractFileInformation(fileId, assumeTypeId) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const file = await this.documentFileService.load(fileId);
+            const fileContentStream = this.getDocumentFileContentStream(fileId);
+            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
+            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: file.mimeType });
+            const pages = file.mimeType.includes('pdf')
+                ? await tryIgnoreLogAsync(async () => getPdfPageCount(tmpFile.path), this.logger, null)
+                : null;
+            const types = await this.documentTypeService.session
+                .select({
+                typeId: documentType.id,
+                categoryLabel: documentCategory.label,
+                typeGroup: documentType.group,
+                typeLabel: documentType.label
+            })
+                .from(documentType)
+                .leftJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
+                .where(isString(assumeTypeId) ? eq(documentType.id, assumeTypeId) : undefined);
+            const typeLabelEntries = types.map((type) => ({ id: type.typeId, label: `${type.categoryLabel} | ${type.typeGroup} | ${type.typeLabel}` }));
+            const typeLabels = typeLabelEntries.map(({ label }) => label);
+            const documentTypeGeneration = await this.#aiService.generate({
+                ...defaultGenerationOptions,
+                generationSchema: object({
+                    documentType: enumeration(typeLabels)
+                }),
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            { file: filePart.file },
+                            { text: `Klassifiziere den Inhalt des Dokuments in das angegebenen JSON Schema.` }
+                        ]
+                    }
+                ]
+            });
+            const typeId = typeLabelEntries.find((entry) => entry.label == documentTypeGeneration.json.documentType)?.id;
+            const typeProperties = isDefined(typeId) ? await this.documentTypePropertyService.loadManyByQuery({ typeId }) : undefined;
+            const propertyIds = typeProperties?.map((property) => property.propertyId);
+            const properties = isDefined(propertyIds) ? await this.documentPropertyService.loadManyByQuery({ id: { $in: propertyIds } }) : undefined;
+            const propertiesSchemaEntries = properties?.map((property) => {
+                const schema = match(property.dataType)
+                    .with('text', () => nullable(string()))
+                    .with('integer', () => nullable(integer()))
+                    .with('decimal', () => nullable(number()))
+                    .with('boolean', () => nullable(boolean()))
+                    .with('date', () => nullable(object({ year: integer(), month: integer(), day: integer() })))
+                    .exhaustive();
+                return [property.label, schema];
+            });
+            const generationSchema = object({
+                documentTitle: string(),
+                documentSubtitle: nullable(string()),
+                documentSummary: string(),
+                documentTags: array(string()),
+                documentDate: nullable(object({ year: integer(), month: integer(), day: integer() })),
+                ...((isUndefined(propertiesSchemaEntries) || (propertiesSchemaEntries.length == 0))
+                    ? {}
+                    : { documentProperties: object(fromEntries(propertiesSchemaEntries)) })
+            });
+            const { json: extraction } = await this.#aiService.generate({
+                model: 'gemini-2.0-flash',
+                generationOptions: {
+                    maxOutputTokens: 2048,
+                    temperature: 0.2,
+                    topP: 0.2
+                },
+                generationSchema,
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            { file: filePart.file },
+                            {
+                                text: `Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+
+Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen(ohne konkrete Werte).
+Erstelle bis zu 7 möglichst spezifische Tags.
+Antworte auf deutsch.`
+                            }
+                        ]
+                    }
+                ]
+            });
+            const filteredDocumentTags = extraction.documentTags.filter((tag) => (tag != extraction.documentTitle) && (tag != extraction.documentSubtitle));
+            const date = isNotNull(extraction.documentDate) ? dateObjectToNumericDate(extraction.documentDate) : null;
+            const parsedProperties = isUndefined(extraction.documentProperties)
+                ? []
+                : objectEntries(extraction.documentProperties)
+                    .map(([propertyLabel, rawValue]) => {
+                    if (isNull(rawValue)) {
+                        return null;
+                    }
+                    const property = assertDefinedPass(properties?.find((property) => property.label == propertyLabel));
+                    const value = match(rawValue)
+                        .with({ year: P.number }, (val) => dateObjectToNumericDate(val))
+                        .otherwise((val) => val);
+                    return { propertyId: property.id, dataType: property.dataType, value };
+                })
+                    .filter(isNotNull);
+            return {
+                typeId: typeId ?? null,
+                title: extraction.documentTitle,
+                subtitle: extraction.documentSubtitle,
+                pages,
+                date,
+                summary: extraction.documentSummary,
+                tags: filteredDocumentTags,
+                properties: parsedProperties
+            };
         }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async getDocumentFileContent(fileId) {
+        const key = getDocumentFileKey(fileId);
+        return this.fileObjectStorage.getContent(key);
+    }
+    getDocumentFileContentStream(fileId) {
+        const key = getDocumentFileKey(fileId);
+        return this.fileObjectStorage.getContentStream(key);
     }
     async getDocumentFileContentObjectUrl(title, file, download) {
         const key = getDocumentFileKey(file.id);
@@ -394,11 +792,11 @@ Antworte auf deutsch.`
         const filename = `${title}.${fileExtension}`;
         return this.fileObjectStorage.getDownloadUrl(key, currentTimestamp() + (5 * millisecondsPerMinute), {
             'Response-Content-Type': file.mimeType,
-            'Response-Content-Disposition': `${disposition}; filename="${encodeURIComponent(filename)}"`
+            'Response-Content-Disposition': `${disposition}; filename = "${encodeURIComponent(filename)}"`
         });
     }
 };
-DocumentManagementService = __decorate([
+DocumentManagementService = DocumentManagementService_1 = __decorate([
     Singleton({
         providers: [
             provide(EntityRepositoryConfig, { useValue: { schema: 'document_management' } }),
@@ -408,13 +806,14 @@ DocumentManagementService = __decorate([
 ], DocumentManagementService);
 export { DocumentManagementService };
 function getDocumentFileKey(id) {
-    return `${id.slice(0, 2)}/${id.slice(0, 4)}/${id}`;
+    return `${id.slice(0, 2)} /${id.slice(0, 4)}/${id} `;
 }
 const validators = {
     [DocumentPropertyDataType.Text]: (value) => isString(value) || isNull(value),
     [DocumentPropertyDataType.Integer]: (value) => isNumber(value) || isNull(value),
     [DocumentPropertyDataType.Decimal]: (value) => isNumber(value) || isNull(value),
-    [DocumentPropertyDataType.Boolean]: (value) => isBoolean(value) || isNull(value)
+    [DocumentPropertyDataType.Boolean]: (value) => isBoolean(value) || isNull(value),
+    [DocumentPropertyDataType.Date]: (value) => isNumber(value) || isNull(value)
 };
 function validatePropertyValue(propertyId, dataType, value) {
     const valid = validators[dataType](value);