merged with master

1 files changed, 29 insertions, 67 deletions

diff --git a/src/server/ApiManagers/UploadManager.ts b/src/server/ApiManagers/UploadManager.ts
index ea5d8cb33..391f67bbb 100644
--- a/src/server/ApiManagers/UploadManager.ts
+++ b/src/server/ApiManagers/UploadManager.ts
@@ -1,7 +1,7 @@
 import * as formidable from 'formidable';
 import { createReadStream, createWriteStream, unlink, writeFile } from 'fs';
-import { basename, dirname, extname, normalize } from 'path';
-import * as sharp from 'sharp';
+import * as path from 'path';
+import Jimp from 'jimp';
 import { filesDirectory, publicDirectory } from '..';
 import { retrocycle } from '../../decycler/decycler';
 import { DashUploadUtils, InjectSize, SizeSuffix } from '../DashUploadUtils';
@@ -29,11 +29,11 @@ export enum Directory {
 }
 
 export function serverPathToFile(directory: Directory, filename: string) {
-    return normalize(`${filesDirectory}/${directory}/${filename}`);
+    return path.normalize(`${filesDirectory}/${directory}/${filename}`);
 }
 
 export function pathToDirectory(directory: Directory) {
-    return normalize(`${filesDirectory}/${directory}`);
+    return path.normalize(`${filesDirectory}/${directory}`);
 }
 
 export function clientPathToFile(directory: Directory, filename: string) {
@@ -74,6 +74,8 @@ export default class UploadManager extends ApiManager {
                         filesize = value;
                     }
                 });
+                fileguids.split(';').map(guid => DashUploadUtils.uploadProgress.set(guid, `upload starting`));
+
                 form.on('progress', e => fileguids.split(';').map(guid => DashUploadUtils.uploadProgress.set(guid, `read:(${Math.round((100 * +e) / +filesize)}%) ${e} of ${filesize}`)));
                 form.keepExtensions = true;
                 form.uploadDir = pathToDirectory(Directory.parsed_files);
@@ -92,6 +94,8 @@ export default class UploadManager extends ApiManager {
                                 result: { name: 'failed upload', message: `${_err.message}` },
                             });
                         }
+                        fileguids.split(';').map(guid => DashUploadUtils.uploadProgress.set(guid, `resampling images`));
+
                         for (const key in files) {
                             const f = files[key];
                             if (!Array.isArray(f)) {
@@ -164,7 +168,7 @@ export default class UploadManager extends ApiManager {
                         if (error) {
                             return res.send();
                         }
-                        await DashUploadUtils.outputResizedImages(() => createReadStream(resolvedPath), resolvedName, pathToDirectory(Directory.images));
+                        await DashUploadUtils.outputResizedImages(resolvedPath, resolvedName, pathToDirectory(Directory.images));
                         res.send({
                             accessPaths: {
                                 agnostic: DashUploadUtils.getAccessPaths(Directory.images, resolvedName),
@@ -255,42 +259,20 @@ export default class UploadManager extends ApiManager {
                                     if (!entryName.startsWith('files/')) {
                                         return;
                                     }
-                                    const extension = extname(entryName);
+                                    const extension = path.extname(entryName);
                                     const pathname = publicDirectory + '/' + entry.entryName;
                                     const targetname = publicDirectory + '/' + entryName;
                                     try {
                                         zip.extractEntryTo(entry.entryName, publicDirectory, true, false);
                                         createReadStream(pathname).pipe(createWriteStream(targetname));
-                                        if (extension !== '.pdf') {
-                                            const { pngs, jpgs } = AcceptableMedia;
-                                            const resizers = [
-                                                { resizer: sharp().resize(100, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Small },
-                                                { resizer: sharp().resize(400, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Medium },
-                                                { resizer: sharp().resize(900, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Large },
-                                            ];
-                                            let isImage = false;
-                                            if (pngs.includes(extension)) {
-                                                resizers.forEach(element => {
-                                                    element.resizer = element.resizer.png();
-                                                });
-                                                isImage = true;
-                                            } else if (jpgs.includes(extension)) {
-                                                resizers.forEach(element => {
-                                                    element.resizer = element.resizer.jpeg();
-                                                });
-                                                isImage = true;
-                                            }
-                                            if (isImage) {
-                                                resizers.forEach(resizer => {
-                                                    createReadStream(pathname)
-                                                        .on('error', e => console.log('Resizing read:' + e))
-                                                        .pipe(resizer.resizer)
-                                                        .on('error', e => console.log('Resizing write: ' + e))
-                                                        .pipe(createWriteStream(targetname.replace('_o' + extension, resizer.suffix + extension)).on('error', e => console.log('Resizing write: ' + e)));
-                                                });
-                                            }
-                                        }
-                                        unlink(pathname, () => {});
+                                        Jimp.read(pathname).then(img => {
+                                            DashUploadUtils.imageResampleSizes(extension).forEach(({ width, suffix }) => {
+                                                const outputPath = InjectSize(targetname, suffix);
+                                                if (!width) createReadStream(pathname).pipe(createWriteStream(outputPath));
+                                                else img = img.resize(width, Jimp.AUTO).write(outputPath);
+                                            });
+                                            unlink(pathname, () => {});
+                                        });
                                     } catch (e) {
                                         console.log(e);
                                     }
@@ -346,7 +328,7 @@ export default class UploadManager extends ApiManager {
             method: Method.POST,
             subscription: '/uploadURI',
             secureHandler: ({ req, res }) => {
-                const uri = req.body.uri;
+                const uri: any = req.body.uri;
                 const filename = req.body.name;
                 const origSuffix = req.body.nosuffix ? SizeSuffix.None : SizeSuffix.Original;
                 const deleteFiles = req.body.replaceRootFilename;
@@ -362,36 +344,16 @@ export default class UploadManager extends ApiManager {
                         .map((f: any) => fs.unlinkSync(path + f));
                 }
                 return imageDataUri.outputFile(uri, serverPathToFile(Directory.images, InjectSize(filename, origSuffix))).then((savedName: string) => {
-                    const ext = extname(savedName).toLowerCase();
-                    const { pngs, jpgs } = AcceptableMedia;
-                    const resizers = !origSuffix
-                        ? [{ resizer: sharp().resize(400, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Medium }]
-                        : [
-                              { resizer: sharp().resize(100, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Small },
-                              { resizer: sharp().resize(400, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Medium },
-                              { resizer: sharp().resize(900, undefined, { withoutEnlargement: true }), suffix: SizeSuffix.Large },
-                          ];
-                    let isImage = false;
-                    if (pngs.includes(ext)) {
-                        resizers.forEach(element => {
-                            element.resizer = element.resizer.png();
-                        });
-                        isImage = true;
-                    } else if (jpgs.includes(ext)) {
-                        resizers.forEach(element => {
-                            element.resizer = element.resizer.jpeg();
-                        });
-                        isImage = true;
-                    }
-                    if (isImage) {
-                        resizers.forEach(resizer => {
-                            const path = serverPathToFile(Directory.images, InjectSize(filename, resizer.suffix) + ext);
-                            createReadStream(savedName)
-                                .on('error', e => console.log('Resizing read:' + e))
-                                .pipe(resizer.resizer)
-                                .on('error', e => console.log('Resizing write: ' + e))
-                                .pipe(createWriteStream(path).on('error', e => console.log('Resizing write: ' + e)));
-                        });
+                    const ext = path.extname(savedName).toLowerCase();
+                    if (AcceptableMedia.imageFormats.includes(ext)) {
+                        Jimp.read(savedName).then(img =>
+                            (!origSuffix ? [{ width: 400, suffix: SizeSuffix.Medium }] : Object.values(DashUploadUtils.Sizes)) //
+                                .forEach(({ width, suffix }) => {
+                                    const outputPath = InjectSize(filename, suffix);
+                                    if (!width) createReadStream(savedName).pipe(createWriteStream(outputPath));
+                                    else img = img.resize(width, Jimp.AUTO).write(outputPath);
+                                })
+                        );
                     }
                     res.send(clientPathToFile(Directory.images, filename + ext));
                 });