@acorex/modules 19.4.8 → 19.4.10

package/fesm2022/{acorex-modules-platform-management-acorex-modules-platform-management-DtXOjIIK.mjs → acorex-modules-platform-management-acorex-modules-platform-management-l00277iI.mjs}

@@ -3605,6 +3605,7 @@ function sanitizeForStorage(obj) {
 }
 async function promotionEntityFactory(injector) {
     const dataService = injector.get(AXMAppPromotionService);
+    const fileStorageService = injector.get(AXPFileStorageService);
     const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
@@ -3699,7 +3700,7 @@ async function promotionEntityFactory(injector) {
                     interface: {
                         type: AXPWidgetsCatalog.fileUploader,
                         options: {
-                            multiple: false,
+                            multiple: true,
                         },
                     },
                 },
@@ -3840,87 +3841,100 @@ async function promotionEntityFactory(injector) {
         commands: {
             create: {
                 execute: async (data) => {
-                    // First deeply sanitize the data object to remove non-serializable content
                     data = sanitizeForStorage(data);
-                    // Convert array of File objects to serializable format for IndexedDB storage
-                    if (data.imageId && Array.isArray(data.imageId)) {
-                        const processedFiles = await Promise.all((data.imageId || []).map(async (file) => {
-                            if (file instanceof File) {
-                                return {
-                                    name: file.name,
-                                    type: file.type,
-                                    size: file.size,
-                                    lastModified: file.lastModified,
-                                    // Convert File to base64 string for storage
-                                    data: await new Promise((resolve) => {
-                                        const reader = new FileReader();
-                                        reader.onloadend = () => resolve(reader.result);
-                                        reader.readAsDataURL(file);
-                                    })
-                                };
+                    const entityPayload = { ...data };
+                    const filesToUploadAfterSave = [];
+                    // const originalImageIdArray = Array.isArray(entityPayload.imageId) ? [...entityPayload.imageId] : [];
+                    if (entityPayload.imageId && Array.isArray(entityPayload.imageId)) {
+                        const processedImageIdForEntitySave = [];
+                        for (const fileItem of entityPayload.imageId) {
+                            if (fileItem.source?.kind === 'blob' && fileItem.source.value instanceof Blob) {
+                                filesToUploadAfterSave.push({ fileItem, blob: fileItem.source.value });
+                                processedImageIdForEntitySave.push({
+                                    tempId: fileItem.id,
+                                    name: fileItem.name,
+                                    size: fileItem.size,
+                                    type: fileItem.source.value.type, // Type from blob is reliable
+                                    status: 'pending_upload'
+                                });
                             }
-                            // Handle new file structure with source.value containing the blob
-                            else if (file && file.source && file.source.value) {
-                                try {
-                                    const blob = file.source.value;
-                                    // Ensure we're working with a proper Blob object
-                                    if (blob instanceof Blob) {
-                                        return {
-                                            id: file.id || null,
-                                            name: file.name || 'file',
-                                            type: file.type || blob.type || 'application/octet-stream',
-                                            size: file.size || blob.size || 0,
-                                            status: file.status || 'attached',
-                                            // Convert Blob to base64 string for storage
-                                            data: await new Promise((resolve) => {
-                                                const reader = new FileReader();
-                                                reader.onloadend = () => resolve(reader.result);
-                                                reader.readAsDataURL(blob);
-                                            })
-                                        };
-                                    }
-                                    else {
-                                        console.warn('Invalid blob in file.source.value', file);
-                                        return {
-                                            name: file.name || 'file',
-                                            type: file.type || 'application/octet-stream',
-                                            size: file.size || 0,
-                                            status: file.status || 'attached'
-                                        };
-                                    }
-                                }
-                                catch (error) {
-                                    console.error('Error processing file for storage', error);
-                                    return {
-                                        name: file.name || 'file',
-                                        type: file.type || 'application/octet-stream',
-                                        size: file.size || 0,
-                                        status: file.status || 'attached'
-                                    };
-                                }
+                            else if (fileItem.source?.kind === 'fileId' && fileItem.id && typeof fileItem.source.value === 'string') {
+                                // If it's a fileId, we assume it's already processed. We don't have type directly on AXPFileListItem.
+                                // We'll reconstruct it from fileStorageService or it should be part of what's saved if needed.
+                                processedImageIdForEntitySave.push({
+                                    id: fileItem.id,
+                                    name: fileItem.name,
+                                    size: fileItem.size,
+                                    // type: fileItem.type, // Removed: AXPFileListItem does not have .type
+                                    status: 'uploaded',
+                                    source: { kind: 'fileId', value: fileItem.source.value }
+                                });
                             }
-                            // If it's already a serialized object with data property, keep it as is
-                            else if (file && file.data && typeof file.data === 'string') {
-                                return file;
+                            else if (fileItem.id && fileItem.name) { // Fallback for items that might be from a previous save
+                                processedImageIdForEntitySave.push({
+                                    id: fileItem.id,
+                                    name: fileItem.name,
+                                    size: fileItem.size,
+                                    // type: fileItem.type, // Removed: AXPFileListItem does not have .type
+                                    status: fileItem.status, // Preserve existing status
+                                    source: fileItem.source ? { kind: fileItem.source.kind, value: fileItem.source.value } : undefined
+                                });
                             }
-                            // For any other format, return a clean version without complex objects
-                            else if (file) {
-                                return {
-                                    id: file.id || null,
-                                    name: file.name || 'unknown',
-                                    type: file.type || 'application/octet-stream',
-                                    size: file.size || 0,
-                                    status: file.status || 'attached'
-                                };
+                        }
+                        entityPayload.imageId = processedImageIdForEntitySave;
+                    }
+                    const savedEntityId = await dataService.insertOne(entityPayload);
+                    // const entityId = savedEntity.id; // Corrected based on typical service return
+                    const finalImageIdReferences = (entityPayload.imageId || [])
+                        .filter((f) => f.status !== 'pending_upload');
+                    for (const { fileItem, blob } of filesToUploadAfterSave) {
+                        try {
+                            if (!fileStorageService) {
+                                throw new Error('fileStorageService is not available.');
                             }
-                            return null;
-                        }));
-                        // Filter out nulls after awaiting the promise
-                        data.imageId = processedFiles.filter(Boolean);
+                            const fileStorageInfo = await fileStorageService.save({
+                                file: blob,
+                                refId: savedEntityId,
+                                refType: `${RootConfig.module.name}.${RootConfig.entities.promotion.name}`,
+                                category: '',
+                                name: blob.name,
+                            });
+                            finalImageIdReferences.push({
+                                id: fileStorageInfo.fileId,
+                                name: fileStorageInfo.name || blob.name,
+                                size: fileStorageInfo.size || blob.size,
+                                type: fileStorageInfo.mimeType || blob.type,
+                                status: 'uploaded',
+                                source: { kind: 'fileId', value: fileStorageInfo.fileId }
+                            });
+                        }
+                        catch (err) { // Typed error
+                            console.error('Error uploading file to FileStorage for entityId:', savedEntityId, 'file:', fileItem.name, err);
+                            finalImageIdReferences.push({
+                                tempId: fileItem.id,
+                                name: fileItem.name,
+                                size: fileItem.size,
+                                type: blob.type, // Correctly access type from Blob/File
+                                status: 'upload_failed',
+                                error: err.message
+                            });
+                        }
                     }
-                    const res = await dataService.insertOne(data);
-                    // Return the same ID format that was used for storage
-                    return { id: res };
+                    if (filesToUploadAfterSave.length > 0) {
+                        let needsUpdate = true;
+                        if (entityPayload.imageId && entityPayload.imageId.length === finalImageIdReferences.length) {
+                            const oldIds = entityPayload.imageId.map((f) => f.id || f.tempId).sort().join(',');
+                            const newIds = finalImageIdReferences.map((f) => f.id || f.tempId).sort().join(',');
+                            if (oldIds === newIds && !finalImageIdReferences.some((f) => f.status === 'upload_failed')) {
+                                needsUpdate = false;
+                            }
+                        }
+                        if (needsUpdate) {
+                            // Assuming updateOne takes the ID and an object of fields to update
+                            await dataService.updateOne(savedEntityId, { imageId: finalImageIdReferences });
+                        }
+                    }
+                    return { id: savedEntityId };
                 },
             },
             delete: {
@@ -3930,85 +3944,93 @@ async function promotionEntityFactory(injector) {
             },
             update: {
                 execute: async (data) => {
-                    // First deeply sanitize the data object to remove non-serializable content
-                    data = sanitizeForStorage(data);
-                    // Convert array of File objects to serializable format for IndexedDB storage
+                    const entityId = data.id;
+                    const filesToUpload = [];
+                    const processedImageReferences = []; // Will hold final file objects for DB
+                    // Ensure fileStorageService is available (it's injected at the factory level)
+                    // const fileStorageService = injector.get(AXPFileStorageService); // Already available in this scope from factory
                     if (data.imageId && Array.isArray(data.imageId)) {
-                        const processedFiles = await Promise.all((data.imageId || []).map(async (file) => {
-                            if (file instanceof File) {
-                                return {
-                                    name: file.name,
-                                    type: file.type,
-                                    size: file.size,
-                                    lastModified: file.lastModified,
-                                    // Convert File to base64 string for storage
-                                    data: await new Promise((resolve) => {
-                                        const reader = new FileReader();
-                                        reader.onloadend = () => resolve(reader.result);
-                                        reader.readAsDataURL(file);
-                                    })
-                                };
+                        for (const fileItem of data.imageId) {
+                            if (fileItem.status === 'deleted') {
+                                // File marked for deletion. Skip.
+                                // Optionally, you might want to call fileStorageService.delete(fileId) here
+                                // if fileItem.id points to an existing stored file and actual deletion is needed.
+                                // For now, we just disassociate it from the entity.
+                                continue;
                             }
-                            // Handle new file structure with source.value containing the blob
-                            else if (file && file.source && file.source.value) {
-                                try {
-                                    const blob = file.source.value;
-                                    // Ensure we're working with a proper Blob object
-                                    if (blob instanceof Blob) {
-                                        return {
-                                            id: file.id || null,
-                                            name: file.name || 'file',
-                                            type: file.type || blob.type || 'application/octet-stream',
-                                            size: file.size || blob.size || 0,
-                                            status: file.status || 'attached',
-                                            // Convert Blob to base64 string for storage
-                                            data: await new Promise((resolve) => {
-                                                const reader = new FileReader();
-                                                reader.onloadend = () => resolve(reader.result);
-                                                reader.readAsDataURL(blob);
-                                            })
-                                        };
-                                    }
-                                    else {
-                                        console.warn('Invalid blob in file.source.value', file);
-                                        return {
-                                            name: file.name || 'file',
-                                            type: file.type || 'application/octet-stream',
-                                            size: file.size || 0,
-                                            status: file.status || 'attached'
-                                        };
-                                    }
-                                }
-                                catch (error) {
-                                    console.error('Error processing file for storage', error);
-                                    return {
-                                        name: file.name || 'file',
-                                        type: file.type || 'application/octet-stream',
-                                        size: file.size || 0,
-                                        status: file.status || 'attached'
-                                    };
-                                }
+                            if (fileItem.source?.kind === 'blob' && fileItem.source.value instanceof Blob) {
+                                filesToUpload.push({ fileItem, blob: fileItem.source.value });
+                                // Actual reference will be added to processedImageReferences after successful upload.
                             }
-                            // If it's already a serialized object with data property, keep it as is
-                            else if (file && file.data && typeof file.data === 'string') {
-                                return file;
+                            else if (fileItem.source?.kind === 'fileId' && fileItem.id && typeof fileItem.source.value === 'string') {
+                                // This is an existing file, keep its reference.
+                                processedImageReferences.push({
+                                    id: fileItem.id,
+                                    name: fileItem.name,
+                                    size: fileItem.size,
+                                    status: fileItem.status || 'uploaded', // Default to 'uploaded' if status is missing
+                                    source: { kind: 'fileId', value: fileItem.source.value }
+                                    // 'type' is not typically part of AXPFileListItem for existing fileIds in 'create'
+                                });
                             }
-                            // For any other format, return a clean version without complex objects
-                            else if (file) {
-                                return {
-                                    id: file.id || null,
-                                    name: file.name || 'unknown',
-                                    type: file.type || 'application/octet-stream',
-                                    size: file.size || 0,
-                                    status: file.status || 'attached'
-                                };
+                            else if (fileItem.id && fileItem.name) {
+                                // Fallback for items that might be from a previous save state (already processed)
+                                // These are likely already processed files that are being kept.
+                                processedImageReferences.push({
+                                    id: fileItem.id,
+                                    name: fileItem.name,
+                                    size: fileItem.size,
+                                    status: fileItem.status || 'uploaded',
+                                    source: fileItem.source ? { kind: fileItem.source.kind, value: fileItem.source.value } : undefined
+                                });
                             }
-                            return null;
-                        }));
-                        // Filter out nulls after awaiting the promise
-                        data.imageId = processedFiles.filter(Boolean);
+                            // Else: unknown fileItem structure, it will be ignored or you can log an error.
+                        }
                     }
-                    return await dataService.updateOne(data.id, data);
+                    // Upload new files and add their successful/failed info to processedImageReferences
+                    for (const { fileItem, blob } of filesToUpload) {
+                        try {
+                            if (!fileStorageService) {
+                                throw new Error('fileStorageService is not available.');
+                            }
+                            const fileStorageInfo = await fileStorageService.save({
+                                file: blob,
+                                refId: entityId, // ID of the entity being updated
+                                refType: `${RootConfig.module.name}.${RootConfig.entities.promotion.name}`,
+                                category: '', // Add category if applicable
+                                name: blob.name,
+                            });
+                            processedImageReferences.push({
+                                id: fileStorageInfo.fileId,
+                                name: fileStorageInfo.name || blob.name,
+                                size: fileStorageInfo.size || blob.size,
+                                type: fileStorageInfo.mimeType || blob.type, // Store MIME type
+                                status: 'uploaded',
+                                source: { kind: 'fileId', value: fileStorageInfo.fileId }
+                            });
+                        }
+                        catch (err) {
+                            console.error('Error uploading file to FileStorage during update for entityId:', entityId, 'file:', fileItem.name, err);
+                            processedImageReferences.push({
+                                tempId: fileItem.id, // Use fileItem.id if it's a unique temp client-side ID, or generate one
+                                name: fileItem.name,
+                                size: fileItem.size,
+                                type: blob.type,
+                                status: 'upload_failed',
+                                error: err.message
+                            });
+                        }
+                    }
+                    // Construct the final data payload for the update.
+                    // Create a mutable copy of the input data.
+                    const finalUpdatePayload = { ...data };
+                    // Replace the original imageId array with the newly processed one.
+                    finalUpdatePayload.imageId = processedImageReferences;
+                    // Sanitize the entire payload before sending it to dataService.updateOne.
+                    // This ensures that the processedImageReferences (which are plain objects)
+                    // and all other fields in the payload are clean and serializable.
+                    const fullySanitizedPayload = sanitizeForStorage(finalUpdatePayload);
+                    return await dataService.updateOne(entityId, fullySanitizedPayload);
                 },
             },
         },
@@ -4048,29 +4070,6 @@ async function promotionEntityFactory(injector) {
                                 console.warn(`No record found with id: ${validId}`);
                                 return null;
                             }
-                            // Deserialize imageId field if it contains serialized file objects
-                            if (data.imageId && Array.isArray(data.imageId)) {
-                                data.imageId = await Promise.all(data.imageId.map(async (fileData) => {
-                                    // Check if this is a serialized file
-                                    if (fileData && fileData.data && fileData.name && fileData.type) {
-                                        try {
-                                            // Convert base64 string back to a Blob
-                                            const response = await fetch(fileData.data);
-                                            const blob = await response.blob();
-                                            // Create a new File object
-                                            return new File([blob], fileData.name, {
-                                                type: fileData.type,
-                                                lastModified: fileData.lastModified
-                                            });
-                                        }
-                                        catch (error) {
-                                            console.error('Failed to deserialize file:', fileData.name, error);
-                                            return fileData; // Return original data if deserialization fails
-                                        }
-                                    }
-                                    return fileData; // Return as is if not a serialized file
-                                })); // Cast to any to avoid type conflict
-                            }
                             return data;
                         }
                         catch (error) {
@@ -4387,8 +4386,8 @@ async function promotionEntityFactory(injector) {
                                 options: {
                                     id: '{{ context.eval("id") }}',
                                     files: '{{ context.eval("imageId") }}',
-                                    multiple: false,
-                                    accept: 'image/*',
+                                    multiple: true,
+                                    accept: '.jpg,.jpeg,.png,.gif,.webp',
                                     key: 'imageId',
                                 }
                             },
@@ -4805,7 +4804,7 @@ class AXMPlatformManagementCommonModule {
                 provide: AXP_SETTING_DEFINITION_PROVIDER,
                 useFactory: async () => {
                     const injector = inject(Injector);
-                    const provider = (await import('./acorex-modules-platform-management-settings.provider-BO-1dmVc.mjs')).AXMRegionalSettingProvider;
+                    const provider = (await import('./acorex-modules-platform-management-settings.provider-DKwQuq9_.mjs')).AXMRegionalSettingProvider;
                     return new provider(injector);
                 },
                 multi: true
@@ -4844,7 +4843,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
                             provide: AXP_SETTING_DEFINITION_PROVIDER,
                             useFactory: async () => {
                                 const injector = inject(Injector);
-                                const provider = (await import('./acorex-modules-platform-management-settings.provider-BO-1dmVc.mjs')).AXMRegionalSettingProvider;
+                                const provider = (await import('./acorex-modules-platform-management-settings.provider-DKwQuq9_.mjs')).AXMRegionalSettingProvider;
                                 return new provider(injector);
                             },
                             multi: true
@@ -5089,7 +5088,7 @@ class AXMShowReleaseNotesPopupAction extends AXPWorkflowAction {
     }
     async execute(context) {
         const scope = RootConfig.config.i18n;
-        const comp = await (await import('./acorex-modules-platform-management-list-version.component-DY4yMd8n.mjs')).AXMListVersionComponent;
+        const comp = await (await import('./acorex-modules-platform-management-list-version.component-CbjbxadS.mjs')).AXMListVersionComponent;
         this.popupService.open(comp, {
             title: `t('release-notes',{scope: "${scope}"})`,
         });
@@ -5748,4 +5747,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
  */
 
 export { AXPRegionalSetting as A, AXMGlossaryServiceImpl as B, metaDataDefinitionFactory as C, AXMMetaDataDefinitionService as D, AXMPMetaDataDefinitionServiceImpl as E, metaDataDefinitionCategoryEntityFactory as F, AXMMetaDataDefinitionCategoryService as G, AXMMetaDataDefinitionCategoryServiceImpl as H, AXMPromotionSlotComponent as I, promotionEntityFactory as J, AXMAppPromotionService as K, AXMPromotionServiceImpl as L, AXPRegionalStoreService as M, AXMUpdaterModule as N, AXPUpdaterService as O, RootConfig as R, AXMAppVersionService as a, AXMPlatformManagementModule as b, appTermEntityEntityFactory as c, AXMAppTermService as d, AXMAppTermServiceImpl as e, AXMListTermsComponent as f, AXMNotifyNewTermPopupAction as g, AXMTermUpdateSettingAction as h, AXMNewTermWorkflow as i, appVersionEntityEntityFactory as j, AXMAppVersionServiceImpl as k, AXMNotifyAppComponent as l, AXMAppVersionSlotComponent as m, AXMChangeLogPopupAction as n, AXMChangeLogUpdateSettingAction as o, AXMWhatsNewWorkflow as p, AXMCheckNewVersionAction as q, AXMCheckNewVersionWorkflow as r, dataSourceEntityFactory as s, AXMDataSourceService as t, AXMDataSourceServiceImpl as u, globalVariableEntityFactory as v, AXMGlobalVariablesService as w, AXMGlobalVariablesServiceImpl as x, glossaryEntityFactory as y, AXMGlossaryService as z };
-//# sourceMappingURL=acorex-modules-platform-management-acorex-modules-platform-management-DtXOjIIK.mjs.map
+//# sourceMappingURL=acorex-modules-platform-management-acorex-modules-platform-management-l00277iI.mjs.map