2 files changed, 194 insertions, 0 deletions
diff --git a/src/server/ApiManagers/GeneralGoogleManager.ts b/src/server/ApiManagers/GeneralGoogleManager.ts
new file mode 100644
index 000000000..89efebf78
--- /dev/null
+++ b/src/server/ApiManagers/GeneralGoogleManager.ts
@@ -0,0 +1,83 @@
+import ApiManager, { Registration } from "./ApiManager";
+import { Method, _permission_denied } from "../RouteManager";
+import { GoogleApiServerUtils } from "../apis/google/GoogleApiServerUtils";
+import { Database } from "../database";
+import RouteSubscriber from "../RouteSubscriber";
+
+const deletionPermissionError = "Cannot perform specialized delete outside of the development environment!";
+const ServicesApiKeyMap = new Map<string, string | undefined>([
+    ["face", process.env.FACE],
+    ["vision", process.env.VISION],
+    ["handwriting", process.env.HANDWRITING]
+]);
+const EndpointHandlerMap = new Map<GoogleApiServerUtils.Action, GoogleApiServerUtils.ApiRouter>([
+    ["create", (api, params) => api.create(params)],
+    ["retrieve", (api, params) => api.get(params)],
+    ["update", (api, params) => api.batchUpdate(params)],
+]);
+
+export default class GeneralGoogleManager extends ApiManager {
+
+    protected initialize(register: Registration): void {
+
+        register({
+            method: Method.GET,
+            subscription: "/readGoogleAccessToken",
+            onValidation: async ({ user, res }) => {
+                const userId = user.id;
+                const token = await GoogleApiServerUtils.retrieveAccessToken(userId);
+                if (!token) {
+                    return res.send(GoogleApiServerUtils.generateAuthenticationUrl());
+                }
+                return res.send(token);
+            }
+        });
+
+        register({
+            method: Method.POST,
+            subscription: "/writeGoogleAccessToken",
+            onValidation: async ({ user, req, res }) => {
+                res.send(await GoogleApiServerUtils.processNewUser(user.id, req.body.authenticationCode));
+            }
+        });
+
+        register({
+            method: Method.GET,
+            subscription: "/deleteWithGoogleCredentials",
+            onValidation: async ({ res, isRelease }) => {
+                if (isRelease) {
+                    return _permission_denied(res, deletionPermissionError);
+                }
+                await Database.Auxiliary.GoogleAuthenticationToken.DeleteAll();
+                res.redirect("/delete");
+            }
+        });
+
+        register({
+            method: Method.GET,
+            subscription: new RouteSubscriber("/cognitiveServices").add('requestedservice'),
+            onValidation: ({ req, res }) => {
+                let service = req.params.requestedservice;
+                res.send(ServicesApiKeyMap.get(service));
+            }
+        });
+
+        register({
+            method: Method.POST,
+            subscription: new RouteSubscriber("/googleDocs").add("sector", "action"),
+            onValidation: async ({ req, res, user }) => {
+                let sector: GoogleApiServerUtils.Service = req.params.sector as GoogleApiServerUtils.Service;
+                let action: GoogleApiServerUtils.Action = req.params.action as GoogleApiServerUtils.Action;
+                const endpoint = await GoogleApiServerUtils.GetEndpoint(GoogleApiServerUtils.Service[sector], user.id);
+                let handler = EndpointHandlerMap.get(action);
+                if (endpoint && handler) {
+                    handler(endpoint, req.body)
+                        .then(response => res.send(response.data))
+                        .catch(exception => res.send(exception));
+                    return;
+                }
+                res.send(undefined);
+            }
+        });
+    }
+}
+\ No newline at end of file
diff --git a/src/server/ApiManagers/GooglePhotosManager.ts b/src/server/ApiManagers/GooglePhotosManager.ts
new file mode 100644
index 000000000..1f6051c28
--- /dev/null
+++ b/src/server/ApiManagers/GooglePhotosManager.ts
@@ -0,0 +1,111 @@
+import ApiManager, { Registration } from "./ApiManager";
+import { Method, _error, _success, _invalid } from "../RouteManager";
+import * as path from "path";
+import { GoogleApiServerUtils } from "../apis/google/GoogleApiServerUtils";
+import { BatchedArray, TimeUnit } from "array-batcher";
+import { GooglePhotosUploadUtils } from "../apis/google/GooglePhotosUploadUtils";
+import { Opt } from "../../new_fields/Doc";
+import { DashUploadUtils } from "../DashUploadUtils";
+import { Database } from "../database";
+
+const authenticationError = "Unable to authenticate Google credentials before uploading to Google Photos!";
+const mediaError = "Unable to convert all uploaded bytes to media items!";
+const UploadError = (count: number) => `Unable to upload ${count} images to Dash's server`;
+const requestError = "Unable to execute download: the body's media items were malformed.";
+const downloadError = "Encountered an error while executing downloads.";
+interface GooglePhotosUploadFailure {
+    batch: number;
+    index: number;
+    url: string;
+    reason: string;
+}
+interface MediaItem {
+    baseUrl: string;
+    filename: string;
+}
+interface NewMediaItem {
+    description: string;
+    simpleMediaItem: {
+        uploadToken: string;
+    };
+}
+const prefix = "google_photos_";
+
+export default class GooglePhotosManager extends ApiManager {
+
+    protected initialize(register: Registration): void {
+
+        register({
+            method: Method.POST,
+            subscription: "/googlePhotosMediaUpload",
+            onValidation: async ({ user, req, res }) => {
+                const { media } = req.body;
+                const token = await GoogleApiServerUtils.retrieveAccessToken(user.id);
+                if (!token) {
+                    return _error(res, authenticationError);
+                }
+                let failed: GooglePhotosUploadFailure[] = [];
+                const batched = BatchedArray.from<GooglePhotosUploadUtils.UploadSource>(media, { batchSize: 25 });
+                const newMediaItems = await batched.batchedMapPatientInterval<NewMediaItem>(
+                    { magnitude: 100, unit: TimeUnit.Milliseconds },
+                    async (batch: any, collector: any, { completedBatches }: any) => {
+                        for (let index = 0; index < batch.length; index++) {
+                            const { url, description } = batch[index];
+                            const fail = (reason: string) => failed.push({ reason, batch: completedBatches + 1, index, url });
+                            const uploadToken = await GooglePhotosUploadUtils.DispatchGooglePhotosUpload(token, url).catch(fail);
+                            if (!uploadToken) {
+                                fail(`${path.extname(url)} is not an accepted extension`);
+                            } else {
+                                collector.push({
+                                    description,
+                                    simpleMediaItem: { uploadToken }
+                                });
+                            }
+                        }
+                    }
+                );
+                const failedCount = failed.length;
+                if (failedCount) {
+                    console.error(`Unable to upload ${failedCount} image${failedCount === 1 ? "" : "s"} to Google's servers`);
+                    console.log(failed.map(({ reason, batch, index, url }) => `@${batch}.${index}: ${url} failed:\n${reason}`).join('\n\n'));
+                }
+                return GooglePhotosUploadUtils.CreateMediaItems(token, newMediaItems, req.body.album).then(
+                    results => _success(res, { results, failed }),
+                    error => _error(res, mediaError, error)
+                );
+            }
+        });
+
+        register({
+            method: Method.POST,
+            subscription: "/googlePhotosMediaDownload",
+            onValidation: async ({ req, res }) => {
+                const contents: { mediaItems: MediaItem[] } = req.body;
+                let failed = 0;
+                if (contents) {
+                    const completed: Opt<DashUploadUtils.UploadInformation>[] = [];
+                    for (let item of contents.mediaItems) {
+                        const { contentSize, ...attributes } = await DashUploadUtils.InspectImage(item.baseUrl);
+                        const found: Opt<DashUploadUtils.UploadInformation> = await Database.Auxiliary.QueryUploadHistory(contentSize!);
+                        if (!found) {
+                            const upload = await DashUploadUtils.UploadInspectedImage({ contentSize, ...attributes }, item.filename, prefix).catch(error => _error(res, downloadError, error));
+                            if (upload) {
+                                completed.push(upload);
+                                await Database.Auxiliary.LogUpload(upload);
+                            } else {
+                                failed++;
+                            }
+                        } else {
+                            completed.push(found);
+                        }
+                    }
+                    if (failed) {
+                        return _error(res, UploadError(failed));
+                    }
+                    return _success(res, completed);
+                }
+                _invalid(res, requestError);
+            }
+        });
+    }
+}
+\ No newline at end of file