add support restore images from backup

Xziy · Xziy · commit d82506d2ef77 · 2025-01-07T04:39:49.000+03:00
diff --git a/libs/BackupHandler.js b/libs/BackupHandler.js
@@ -75,32 +75,32 @@ class BackupHandler {
     // Import data and images from a tar file
     async importFromTar(filePath) {
         try {
-            // Получаем текущую директорию
+            // Get the current directory
             const currentDir = process.cwd();
-            // Создаем директорию для распаковки
+            // Create a directory for unpacking
             const timestamp = Date.now();
             this.workDir = path.join(currentDir, `.tmp/backup-${timestamp}`);
-            // Создаем папку, если она не существует
+            // Create a folder if it does not exist
             await fs_1.fsw.mkdir(this.workDir);
             console.log(`Extracting tar file to: ${this.workDir}`);
-            // Распаковываем архив в указанную директорию
+            // Unpack the archive into the specified directory
             await this.tar.x({
                 file: filePath,
                 cwd: this.workDir,
             });
-            // Читаем данные JSON
+            // Reading JSON data
             const jsonFilePath = path.join(this.workDir, 'data.json');
             const jsonData = await fs_1.fsw.readFile(jsonFilePath);
             const importedData = JSON.parse(jsonData);
             this.groups = importedData.groups;
             this.dishes = importedData.dishes;
-            // Проверяем и загружаем изображения
+            // Checking and uploading images
             for (const dish of this.dishes) {
                 if (dish.images && Array.isArray(dish.images)) {
                     let count = 1;
                     for (const image of dish.images) {
                         const ext = path.extname(image.originalFilePath) || '.webp';
-                        const imagePath = path.join(this.workDir, `${dish.id}_${count}${ext}`);
+                        const imagePath = path.join(this.workDir, `${dish.id}__${count}${ext}`);
                         this.checkAndLoadImage(imagePath);
                         count++;
                     }
@@ -129,16 +129,44 @@ class BackupHandler {
     }
     // Check file existence and load image
     async checkAndLoadImage(imagePath) {
+        // Извлечение имени файла
+        const fileName = path.basename(imagePath);
+        // Разделение имени файла по разделителю "__"
+        const parts = fileName.split('__');
+        if (parts.length !== 2) {
+            console.warn(`File name format is incorrect: ${fileName}`);
+            return;
+        }
+        const dishID = parts[0]; // Левая часть до "__"
+        const countPart = parts[1].split('.'); // Правая часть (порядковый номер и расширение)
+        if (countPart.length < 2) {
+            console.warn(`File name format is incorrect: ${fileName}`);
+            return;
+        }
+        const count = parseInt(countPart[0], 10); // Извлекаем порядковый номер (число)
+        if (isNaN(count)) {
+            console.warn(`File name format is incorrect: ${fileName}`);
+            return;
+        }
+        // Проверка существования файла
         if (await fs_1.fsw.exists(imagePath)) {
-            this.loadImage(imagePath);
+            await this.loadImage(imagePath, dishID, count);
         }
         else {
             console.warn(`Image not found: ${imagePath}`);
         }
     }
     // Simulate loading an image
-    loadImage(imagePath) {
+    async loadImage(imagePath, dishId, sortOrder) {
         console.log(`Loading image: ${imagePath}`);
+        const model = 'dish';
+        const mfAdater = await Adapter.getMediaFileAdapter();
+        const mediaFileImage = await mfAdater.toProcess(`file://${imagePath}`, model, "image");
+        let init = {};
+        init[`mediafile_${model}`] = mediaFileImage.id;
+        init[model] = dishId;
+        init["sortOrder"] = sortOrder;
+        await SelectedMediaFile.create(init).fetch();
     }
     // Export images to a directory
     async exportImages(dishes, exportDir) {
diff --git a/libs/BackupHandler.ts b/libs/BackupHandler.ts
@@ -26,37 +26,37 @@ export class BackupHandler {
   async exportToTar(filePath: string, options: Partial<BackupOptions> = {}): Promise<void> {
     try {
       const finalOptions = { ...defaultOptions, ...options };
-  
+
       // Получаем текущую директорию для создания временной папки
       const currentDir = process.cwd();
-  
+
       // Создаем временную директорию для экспорта
       const timestamp = Date.now();
       this.workDir = path.join(currentDir, `.tmp/backup-${timestamp}`);
-      
+
       // Создаем папку, если она не существует
       await fsw.mkdir(this.workDir);
-  
+
       // Путь для JSON файла
       const jsonFilePath = path.join(this.workDir, 'data.json');
-  
+
       // Создание JSON данных
       const jsonData = await this.createJSON(finalOptions);
       await fsw.writeFile(jsonFilePath, jsonData);
 
       // Экспорт изображений в временную директорию
       await this.exportImages(this.dishes, this.workDir);
-  
+
       // Упаковка всего содержимого в tar файл
       await this.tar.c({
         gzip: true,
         file: filePath,
         cwd: this.workDir
       }, ['.']);
-  
+
       // Удаление временных файлов
       await fsw.unlink(jsonFilePath);
-  
+
       console.log('Export completed:', filePath);
     } catch (error) {
       new Error
@@ -67,46 +67,46 @@ export class BackupHandler {
   // Import data and images from a tar file
   async importFromTar(filePath: string): Promise<void> {
     try {
-      // Получаем текущую директорию
+      // Get the current directory
       const currentDir = process.cwd();
-  
-      // Создаем директорию для распаковки
+
+      // Create a directory for unpacking
       const timestamp = Date.now();
       this.workDir = path.join(currentDir, `.tmp/backup-${timestamp}`);
-      
-      // Создаем папку, если она не существует
+
+      // Create a folder if it does not exist
       await fsw.mkdir(this.workDir);
-  
+
       console.log(`Extracting tar file to: ${this.workDir}`);
-  
-      // Распаковываем архив в указанную директорию
+
+      // Unpack the archive into the specified directory
       await this.tar.x({
         file: filePath,
         cwd: this.workDir,
       });
-  
-      // Читаем данные JSON
+
+      // Reading JSON data
       const jsonFilePath = path.join(this.workDir, 'data.json');
       const jsonData = await fsw.readFile(jsonFilePath);
       const importedData = JSON.parse(jsonData);
-  
+
       this.groups = importedData.groups;
       this.dishes = importedData.dishes;
-  
-      // Проверяем и загружаем изображения
+
+      // Checking and uploading images
       for (const dish of this.dishes) {
         if (dish.images && Array.isArray(dish.images)) {
           let count = 1;
           for (const image of dish.images) {
             const ext = path.extname(image.originalFilePath) || '.webp';
-            const imagePath = path.join(this.workDir, `${dish.id}_${count}${ext}`);
+            const imagePath = path.join(this.workDir, `${dish.id}__${count}${ext}`);
             this.checkAndLoadImage(imagePath);
             count++;
           }
         }
       }
 
-  
+
       console.log('Import completed:', filePath);
     } catch (error) {
       console.error('Import error:', error);
@@ -134,23 +134,59 @@ export class BackupHandler {
 
   // Check file existence and load image
   private async checkAndLoadImage(imagePath: string): Promise<void> {
+    // Извлечение имени файла
+    const fileName = path.basename(imagePath);
+
+    // Разделение имени файла по разделителю "__"
+    const parts = fileName.split('__');
+    if (parts.length !== 2) {
+      console.warn(`File name format is incorrect: ${fileName}`);
+      return;
+    }
+
+    const dishID = parts[0]; // Левая часть до "__"
+    const countPart = parts[1].split('.'); // Правая часть (порядковый номер и расширение)
+
+    if (countPart.length < 2) {
+      console.warn(`File name format is incorrect: ${fileName}`);
+      return;
+    }
+
+    const count = parseInt(countPart[0], 10); // Извлекаем порядковый номер (число)
+    if (isNaN(count)) {
+      console.warn(`File name format is incorrect: ${fileName}`);
+      return;
+    }
+
+    // Проверка существования файла
     if (await fsw.exists(imagePath)) {
-      this.loadImage(imagePath);
+      await this.loadImage(imagePath, dishID, count);
     } else {
       console.warn(`Image not found: ${imagePath}`);
     }
   }
 
+
   // Simulate loading an image
-  private loadImage(imagePath: string): void {
+  private async loadImage(imagePath: string, dishId: string, sortOrder: number): Promise<void> {
     console.log(`Loading image: ${imagePath}`);
+
+    const model = 'dish'
+    const mfAdater = await Adapter.getMediaFileAdapter();
+    const mediaFileImage = await mfAdater.toProcess(`file://${imagePath}`, model, "image");
+
+    let init: Record<string, string | number> = {};
+    init[`mediafile_${model}`] = mediaFileImage.id;
+    init[model] = dishId;
+    init["sortOrder"] = sortOrder;
+    await SelectedMediaFile.create(init).fetch();
   }
 
   // Export images to a directory
   private async exportImages(dishes: DishRecord[], exportDir: string): Promise<void> {
     this.workDir = exportDir;
     const imagesDir = path.join(this.workDir);
-  
+
     for (const dish of dishes) {
       if (dish.images && Array.isArray(dish.images)) {
         let count = 1;
@@ -159,19 +195,19 @@ export class BackupHandler {
             const ext = path.extname(image.originalFilePath);
             const imageFileName = `${dish.id}_${count}${ext}`;
             const destinationPath = path.join(imagesDir, imageFileName);
-  
+
             if (await fsw.exists(image.originalFilePath)) {
               await fsw.copyFile(image.originalFilePath, destinationPath);
               console.log(`Image exported: ${imageFileName}`);
             } else {
               console.warn(`Image file not found: ${image.originalFilePath}`);
             }
-  
+
             count++;
           }
         }
       }
     }
   }
-  
+
 }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "author": {
-    "name": "Webresto team"
+    "name": "RestoApp team"
   },
   "contributors": [
     {
@@ -79,7 +79,7 @@
     "type": "git",
     "url": "http://github.com/webresto/core.git"
   },
-  "homepage": "http://webresto.org/",
+  "homepage": "http://restoapp.org",
   "sails": {
     "isHook": true,
     "hookName": "restocore"
@@ -98,4 +98,4 @@
   },
   "appId": "restocore",
   "version": "2.2.0"
-}
+}
diff --git a/test/unit/backupHandler/backupHandler.test.js b/test/unit/backupHandler/backupHandler.test.js
@@ -97,8 +97,8 @@ describe('BackupHandler', () => {
         // Check that methods were called
         // sinon.assert.calledOnce(tarX); // Check that tar.x was called once
         sinon.assert.calledOnce(fsReadFile); // Check that fs.readFile was called once
-        sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-1_1.jpg`); // Check that fs.exists was called with the correct argument
-        sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-2_1.jpg`); // Check that fs.exists was called with the correct argument
+        sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-1__1.jpg`); // Check that fs.exists was called with the correct argument
+        sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-2__1.jpg`); // Check that fs.exists was called with the correct argument
     });
     it('should generate correct JSON data from createJSON method', async () => {
         const backupHandler = new BackupHandler_1.BackupHandler();
@@ -116,8 +116,8 @@ describe('BackupHandler', () => {
         // Spy on console.warn
         const spy = sinon.spy(console, 'warn');
         // Check that a warning appears when an image is not found
-        await backupHandler['checkAndLoadImage']('nonexistent.jpg'); // await добавлен
-        sinon.assert.calledWith(spy, 'Image not found: nonexistent.jpg');
+        await backupHandler['checkAndLoadImage']('/nonexistent__1.jpg'); // await добавлен
+        sinon.assert.calledWith(spy, 'Image not found: /nonexistent__1.jpg');
         spy.restore();
     });
     it('should export images correctly', async () => {
@@ -130,4 +130,18 @@ describe('BackupHandler', () => {
         sinon.assert.calledWith(fsCopyFile, 'image1.jpg', sinon.match.string); // Check that fs.copyFile was called with the expected arguments
         sinon.assert.calledWith(fsCopyFile, 'image2.jpg', sinon.match.string); // Check that fs.copyFile was called with the expected arguments
     });
+    it('should load image when file exists', async () => {
+        const backupHandler = new BackupHandler_1.BackupHandler();
+        // Mock fs.exists to simulate existing file
+        fsExists.resolves(true);
+        // Spy on loadImage method
+        const loadImageStub = sinon.stub(backupHandler, 'loadImage').resolves();
+        const imagePath = '/dish:123__4.jpg';
+        const dishID = "dish:123";
+        const sortOrder = 4;
+        // Call checkAndLoadImage
+        await backupHandler['checkAndLoadImage'](imagePath);
+        // Check that loadImage was called with the correct arguments
+        sinon.assert.calledWith(loadImageStub, imagePath, dishID, sortOrder);
+    });
 });
diff --git a/test/unit/backupHandler/backupHandler.test.ts b/test/unit/backupHandler/backupHandler.test.ts
@@ -82,8 +82,8 @@ describe('BackupHandler', () => {
     // Check that methods were called
     // sinon.assert.calledOnce(tarX); // Check that tar.x was called once
     sinon.assert.calledOnce(fsReadFile); // Check that fs.readFile was called once
-    sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-1_1.jpg`); // Check that fs.exists was called with the correct argument
-    sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-2_1.jpg`); // Check that fs.exists was called with the correct argument
+    sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-1__1.jpg`); // Check that fs.exists was called with the correct argument
+    sinon.assert.calledWith(fsExists, `${backupHandler.workDir}/dish-2__1.jpg`); // Check that fs.exists was called with the correct argument
   });
 
   it('should generate correct JSON data from createJSON method', async () => {
@@ -108,9 +108,9 @@ describe('BackupHandler', () => {
     const spy = sinon.spy(console, 'warn');
   
     // Check that a warning appears when an image is not found
-    await backupHandler['checkAndLoadImage']('nonexistent.jpg'); // await добавлен
+    await backupHandler['checkAndLoadImage']('/nonexistent__1.jpg'); // await добавлен
   
-    sinon.assert.calledWith(spy, 'Image not found: nonexistent.jpg');
+    sinon.assert.calledWith(spy, 'Image not found: /nonexistent__1.jpg');
   
     spy.restore();
   });
@@ -129,4 +129,24 @@ describe('BackupHandler', () => {
     sinon.assert.calledWith(fsCopyFile, 'image1.jpg', sinon.match.string); // Check that fs.copyFile was called with the expected arguments
     sinon.assert.calledWith(fsCopyFile, 'image2.jpg', sinon.match.string); // Check that fs.copyFile was called with the expected arguments
   });
+
+  it('should load image when file exists', async () => {
+    const backupHandler = new BackupHandler();
+  
+    // Mock fs.exists to simulate existing file
+    fsExists.resolves(true);
+  
+    // Spy on loadImage method
+    const loadImageStub = sinon.stub(backupHandler as any, 'loadImage').resolves();
+  
+    const imagePath = '/dish:123__4.jpg';
+    const dishID = "dish:123";
+    const sortOrder = 4;
+  
+    // Call checkAndLoadImage
+    await backupHandler['checkAndLoadImage'](imagePath);
+  
+    // Check that loadImage was called with the correct arguments
+    sinon.assert.calledWith(loadImageStub, imagePath, dishID, sortOrder);
+  });
 });
