1 files changed, 0 insertions, 141 deletions
diff --git a/src/server/index.ts b/src/server/index.ts
index d68e9faa1..59752d6de 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -99,147 +99,6 @@ function routeSetter(router: RouteManager) {
             }
         }
     });
-
-    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)],
-    ]);
-
-    router.addSupervisedRoute({
-        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);
-        }
-    });
-
-    router.addSupervisedRoute({
-        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);
-        }
-    });
-
-    router.addSupervisedRoute({
-        method: Method.POST,
-        subscription: "/writeGoogleAccessToken",
-        onValidation: async ({ user, req, res }) => {
-            res.send(await GoogleApiServerUtils.processNewUser(user.id, req.body.authenticationCode));
-        }
-    });
-
-    const authenticationError = "Unable to authenticate Google credentials before uploading to Google Photos!";
-    const mediaError = "Unable to convert all uploaded bytes to media items!";
-    interface GooglePhotosUploadFailure {
-        batch: number;
-        index: number;
-        url: string;
-        reason: string;
-    }
-
-    router.addSupervisedRoute({
-        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<GooglePhotosUploadUtils.NewMediaItem>(
-                { magnitude: 100, unit: TimeUnit.Milliseconds },
-                async (batch, collector, { completedBatches }) => {
-                    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)
-            );
-        }
-    });
-
-    interface MediaItem {
-        baseUrl: string;
-        filename: string;
-    }
-    const prefix = "google_photos_";
-
-    const downloadError = "Encountered an error while executing downloads.";
-    const requestError = "Unable to execute download: the body's media items were malformed.";
-
-    const UploadError = (count: number) => `Unable to upload ${count} images to Dash's server`;
-    router.addSupervisedRoute({
-        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);
-        }
-    });
 }
 
 (async function start() {