Merge branch 'moreUpgrading' into dataViz-annotations

1 files changed, 46 insertions, 84 deletions

diff --git a/src/server/ApiManagers/UploadManager.ts b/src/server/ApiManagers/UploadManager.ts
index ea5d8cb33..9b0457a25 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';
@@ -11,7 +11,7 @@ import RouteSubscriber from '../RouteSubscriber';
 import { AcceptableMedia, Upload } from '../SharedMediaTypes';
 import ApiManager, { Registration } from './ApiManager';
 import { SolrManager } from './SearchManager';
-import v4 = require('uuid/v4');
+import * as uuid from 'uuid';
 import { DashVersion } from '../../fields/DocSymbols';
 const AdmZip = require('adm-zip');
 const imageDataUri = require('image-data-uri');
@@ -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) {
@@ -63,7 +63,7 @@ export default class UploadManager extends ApiManager {
             method: Method.POST,
             subscription: '/uploadFormData',
             secureHandler: async ({ req, res }) => {
-                const form = new formidable.IncomingForm();
+                const form = new formidable.IncomingForm({ keepExtensions: true, uploadDir: pathToDirectory(Directory.parsed_files) });
                 let fileguids = '';
                 let filesize = '';
                 form.on('field', (e: string, value: string) => {
@@ -74,28 +74,32 @@ 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);
                 return new Promise<void>(resolve => {
                     form.parse(req, async (_err, _fields, files) => {
                         const results: Upload.FileResponse[] = [];
                         if (_err?.message) {
                             results.push({
                                 source: {
+                                    filepath: '',
+                                    originalFilename: 'none',
+                                    newFilename: 'none',
+                                    mimetype: 'text',
                                     size: 0,
-                                    path: 'none',
-                                    name: 'none',
-                                    type: 'none',
-                                    toJSON: () => ({ name: 'none', path: '' }),
+                                    hashAlgorithm: 'md5',
+                                    toJSON: () => ({ name: 'none', size: 0, length: 0, mtime: new Date(), filepath: '', originalFilename: 'none', newFilename: 'none', mimetype: 'text' }),
                                 },
                                 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)) {
-                                const result = await DashUploadUtils.upload(f, key); // key is the guid used by the client to track upload progress.
+                            if (f) {
+                                const result = await DashUploadUtils.upload(f[0], key); // key is the guid used by the client to track upload progress.
                                 result && !(result.result instanceof Error) && results.push(result);
                             }
                         }
@@ -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),
@@ -193,15 +197,14 @@ export default class UploadManager extends ApiManager {
             method: Method.POST,
             subscription: '/uploadDoc',
             secureHandler: ({ req, res }) => {
-                const form = new formidable.IncomingForm();
-                form.keepExtensions = true;
+                const form = new formidable.IncomingForm({ keepExtensions: true });
                 // let path = req.body.path;
                 const ids: { [id: string]: string } = {};
                 let remap = true;
                 const getId = (id: string): string => {
                     if (!remap || id.endsWith('Proto')) return id;
                     if (id in ids) return ids[id];
-                    return (ids[id] = v4());
+                    return (ids[id] = uuid.v4());
                 };
                 const mapFn = (doc: any) => {
                     if (doc.id) {
@@ -241,56 +244,35 @@ export default class UploadManager extends ApiManager {
                 };
                 return new Promise<void>(resolve => {
                     form.parse(req, async (_err, fields, files) => {
-                        remap = fields.remap !== 'false';
+                        remap = Object.keys(fields).some(key => key === 'remap' && !fields.remap?.includes('false')); //.remap !== 'false'; // bcz: looking to see if the field 'remap' is set to 'false'
                         let id: string = '';
                         let docids: string[] = [];
                         let linkids: string[] = [];
                         try {
                             for (const name in files) {
                                 const f = files[name];
-                                const path_2 = Array.isArray(f) ? '' : f.path;
-                                const zip = new AdmZip(path_2);
+                                if (!f) continue;
+                                const path_2 = f[0]; // what about the rest of the array? are we guaranteed only one value is set?
+                                const zip = new AdmZip(path_2.filepath);
                                 zip.getEntries().forEach((entry: any) => {
                                     let entryName = entry.entryName.replace(/%%%/g, '/');
                                     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);
                                     }
@@ -317,7 +299,7 @@ export default class UploadManager extends ApiManager {
                                 } catch (e) {
                                     console.log(e);
                                 }
-                                unlink(path_2, () => {});
+                                unlink(path_2.filepath, () => {});
                             }
                             SolrManager.update();
                             res.send(JSON.stringify({ id, docids, linkids } || 'error'));
@@ -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 = serverPathToFile(Directory.images, InjectSize(filename, suffix) + ext);
+                                    if (!width) createReadStream(savedName).pipe(createWriteStream(outputPath));
+                                    else img = img.resize(width, Jimp.AUTO).write(outputPath);
+                                })
+                        );
                     }
                     res.send(clientPathToFile(Directory.images, filename + ext));
                 });