1 files changed, 55 insertions, 28 deletions

diff --git a/src/server/apis/google/GooglePhotosUploadUtils.ts b/src/server/apis/google/GooglePhotosUploadUtils.ts
index 35f986250..c2656cc1c 100644
--- a/src/server/apis/google/GooglePhotosUploadUtils.ts
+++ b/src/server/apis/google/GooglePhotosUploadUtils.ts
@@ -5,6 +5,7 @@ import { Utils } from '../../../Utils';
 import * as path from 'path';
 import { Opt } from '../../../new_fields/Doc';
 import * as sharp from 'sharp';
+import { MediaItemCreationResult, NewMediaItemResult } from './SharedTypes';
 
 const uploadDirectory = path.join(__dirname, "../../public/files/");
 
@@ -49,27 +50,44 @@ export namespace GooglePhotosUploadUtils {
             uri: prepend('uploads'),
             body
         };
-        return new Promise<any>(resolve => request(parameters, (error, _response, body) => resolve(error ? undefined : body)));
+        return new Promise<any>((resolve, reject) => request(parameters, (error, _response, body) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve(body);
+        }));
     };
 
-    export const CreateMediaItems = (newMediaItems: any[], album?: { id: string }) => {
-        return new Promise<any>((resolve, reject) => {
+
+
+    export const CreateMediaItems = async (newMediaItems: any[], album?: { id: string }): Promise<MediaItemCreationResult> => {
+        const quota = newMediaItems.length;
+        let handled = 0;
+        const newMediaItemResults: NewMediaItemResult[] = [];
+        while (handled < quota) {
+            const cap = Math.min(newMediaItems.length, handled + 50);
+            const batch = newMediaItems.slice(handled, cap);
+            console.log(batch.length);
             const parameters = {
                 method: 'POST',
                 headers: headers('json'),
                 uri: prepend('mediaItems:batchCreate'),
-                body: { newMediaItems } as any,
+                body: { newMediaItems: batch } as any,
                 json: true
             };
             album && (parameters.body.albumId = album.id);
-            request(parameters, (error, _response, body) => {
-                if (error) {
-                    reject(error);
-                } else {
-                    resolve(body);
-                }
-            });
-        });
+            newMediaItemResults.push(...(await new Promise<MediaItemCreationResult>((resolve, reject) => {
+                request(parameters, (error, _response, body) => {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        resolve(body);
+                    }
+                });
+            })).newMediaItemResults);
+            handled = cap;
+        }
+        return { newMediaItemResults };
     };
 
 }
@@ -87,10 +105,12 @@ export namespace DownloadUtils {
         LARGE: { width: 900, suffix: "_l" },
     };
 
-    const png = ".png";
-    const pngs = [".png", ".PNG"];
-    const jpgs = [".jpg", ".JPG", ".jpeg", ".JPEG"];
-    const formats = [".jpg", ".png", ".gif"];
+    const gifs = [".gif"];
+    const pngs = [".png"];
+    const jpgs = [".jpg", ".jpeg"];
+    const imageFormats = [...pngs, ...jpgs, ...gifs];
+    const videoFormats = [".mov", ".mp4"];
+
     const size = "content-length";
     const type = "content-type";
 
@@ -106,7 +126,7 @@ export namespace DownloadUtils {
 
     export const UploadImage = async (url: string, filename?: string, prefix = ""): Promise<Opt<UploadInformation>> => {
         const resolved = filename ? sanitize(filename) : generate(prefix, url);
-        const extension = path.extname(url) || path.extname(resolved) || png;
+        const extension = (path.extname(url) || path.extname(resolved)).toLowerCase() || ".png";
         let information: UploadInformation = {
             mediaPaths: [],
             fileNames: { clean: resolved }
@@ -137,19 +157,26 @@ export namespace DownloadUtils {
                 resizers.forEach(element => element.resizer = element.resizer.png());
             } else if (jpgs.includes(extension)) {
                 resizers.forEach(element => element.resizer = element.resizer.jpeg());
-            } else if (!formats.includes(extension.toLowerCase())) {
-                return reject();
+            } else if (![...imageFormats, ...videoFormats].includes(extension.toLowerCase())) {
+                return resolve(undefined);
+            }
+            if (imageFormats.includes(extension)) {
+                for (let resizer of resizers) {
+                    const suffix = resizer.suffix;
+                    let mediaPath: string;
+                    await new Promise<void>(resolve => {
+                        const filename = resolved.substring(0, resolved.length - extension.length) + suffix + extension;
+                        information.mediaPaths.push(mediaPath = uploadDirectory + filename);
+                        information.fileNames[suffix] = filename;
+                        stream(url).pipe(resizer.resizer).pipe(fs.createWriteStream(mediaPath))
+                            .on('close', resolve)
+                            .on('error', reject);
+                    });
+                }
             }
-            for (let resizer of resizers) {
-                const suffix = resizer.suffix;
-                let mediaPath: string;
+            if (!isLocal) {
                 await new Promise<void>(resolve => {
-                    const filename = resolved.substring(0, resolved.length - extension.length) + suffix + extension;
-                    information.mediaPaths.push(mediaPath = uploadDirectory + filename);
-                    information.fileNames[suffix] = filename;
-                    stream(url).pipe(resizer.resizer).pipe(fs.createWriteStream(mediaPath))
-                        .on('close', resolve)
-                        .on('error', reject);
+                    stream(url).pipe(fs.createWriteStream(uploadDirectory + resolved)).on('close', resolve);
                 });
             }
             resolve(information);