request image size now server-side and improved image upload routine

2 files changed, 39 insertions, 31 deletions

diff --git a/src/server/DashUploadUtils.ts b/src/server/DashUploadUtils.ts
index d9d985ca5..62a702a92 100644
--- a/src/server/DashUploadUtils.ts
+++ b/src/server/DashUploadUtils.ts
@@ -12,8 +12,9 @@ import { basename } from "path";
 import { createIfNotExists } from './ActionUtilities';
 import { ParsedPDF } from "../server/PdfTypes";
 const parse = require('pdf-parse');
-import { Directory, serverPathToFile, clientPathToFile } from './ApiManagers/UploadManager';
+import { Directory, serverPathToFile, clientPathToFile, pathToDirectory } from './ApiManagers/UploadManager';
 import { red } from 'colors';
+const requestImageSize = require("../client/util/request-image-size");
 
 export enum SizeSuffix {
     Small = "_s",
@@ -134,12 +135,13 @@ export namespace DashUploadUtils {
     };
 
     export interface InspectionResults {
-        isLocal: boolean;
-        stream: any;
-        normalizedUrl: string;
+        source: string;
+        requestable: string;
         exifData: EnrichedExifData;
-        contentSize?: number;
-        contentType?: string;
+        contentSize: number;
+        contentType: string;
+        nativeWidth: number;
+        nativeHeight: number;
     }
 
     export interface EnrichedExifData {
@@ -152,6 +154,12 @@ export namespace DashUploadUtils {
         return Promise.all(pending);
     }
 
+    export interface RequestedImageSize {
+        width: number;
+        height: number;
+        type: string;
+    }
+
     /**
      * Based on the url's classification as local or remote, gleans
      * as much information as possible about the specified image
@@ -159,24 +167,22 @@ export namespace DashUploadUtils {
      * @param source is the path or url to the image in question
      */
     export const InspectImage = async (source: string): Promise<InspectionResults> => {
-        const { isLocal, stream, normalized: normalizedUrl } = classify(source);
-        const exifData = await parseExifData(source);
+        const url = convert(source);
+        const exifData = await parseExifData(url);
         const results = {
             exifData,
-            isLocal,
-            stream,
-            normalizedUrl
+            requestable: url
         };
-        // stop here if local, since request.head() can't handle local paths, only urls on the web
-        if (isLocal) {
-            return results;
-        }
         const { headers } = (await new Promise<any>((resolve, reject) => {
-            request.head(source, (error, res) => error ? reject(error) : resolve(res));
-        }));
+            request.head(url, (error, res) => error ? reject(error) : resolve(res));
+        }).catch(error => console.error(error)));
+        const { width: nativeWidth, height: nativeHeight }: RequestedImageSize = await requestImageSize(url);
         return {
+            source,
             contentSize: parseInt(headers[size]),
             contentType: headers[type],
+            nativeWidth,
+            nativeHeight,
             ...results
         };
     };
@@ -192,9 +198,9 @@ export namespace DashUploadUtils {
     }
 
     export const UploadInspectedImage = async (metadata: InspectionResults, filename?: string, format?: string, prefix = ""): Promise<ImageUploadInformation> => {
-        const { isLocal, stream, normalizedUrl, contentSize, contentType, exifData } = metadata;
-        const resolved = filename || generate(prefix, normalizedUrl);
-        const extension = format || sanitizeExtension(normalizedUrl || resolved);
+        const { requestable, source, contentSize, contentType, exifData } = metadata;
+        const resolved = filename || generate(prefix, requestable);
+        const extension = format || sanitizeExtension(requestable || resolved);
         const information: ImageUploadInformation = {
             clientAccessPath: clientPathToFile(Directory.images, resolved),
             serverAccessPaths: {},
@@ -220,27 +226,29 @@ export namespace DashUploadUtils {
                 await new Promise<void>(resolve => {
                     const filename = InjectSize(resolved, suffix);
                     information.serverAccessPaths[suffix] = serverPathToFile(Directory.images, filename);
-                    stream(normalizedUrl).pipe(resizer).pipe(fs.createWriteStream(serverPathToFile(Directory.images, filename)))
+                    request(requestable).pipe(resizer).pipe(fs.createWriteStream(serverPathToFile(Directory.images, filename)))
                         .on('close', resolve)
                         .on('error', reject);
                 });
             }
-            if (isLocal) {
+            if (source.includes("Dash-Web")) {
                 await new Promise<boolean>(resolve => {
-                    fs.unlink(normalizedUrl, error => resolve(error === null));
+                    fs.unlink(source, error => resolve(error === null));
                 });
             }
             resolve(information);
         });
     };
 
-    const classify = (url: string) => {
-        const isLocal = /Dash-Web(\\|\/)src(\\|\/)server(\\|\/)public(\\|\/)files/g.test(url);
-        return {
-            isLocal,
-            stream: isLocal ? fs.createReadStream : request,
-            normalized: isLocal ? path.normalize(url) : url
-        };
+    const convert = (url: string) => {
+        let resolved: string;
+        const matches = /Dash-Web[\\\/]src[\\\/]server[\\\/]public[\\\/](.*)/.exec(url);
+        if (matches === null) {
+            resolved = url;
+        } else {
+            resolved = `http://localhost:1050/${matches[1].split("\\").join("/")}`;
+        }
+        return resolved;
     };
 
     const parseExifData = async (source: string): Promise<EnrichedExifData> => {
diff --git a/src/server/RouteManager.ts b/src/server/RouteManager.ts
index 6bc75ca21..63e957cd1 100644
--- a/src/server/RouteManager.ts
+++ b/src/server/RouteManager.ts
@@ -180,7 +180,7 @@ export const STATUS = {
 };
 
 export function _error(res: Response, message: string, error?: any) {
-    console.error(message);
+    console.error(message, error);
     res.statusMessage = message;
     res.status(STATUS.EXECUTION_ERROR).send(error);
 }