Merge branch 'parker' of https://github.com/brown-dash/Dash-Web into parker

12 files changed, 715 insertions, 561 deletions

diff --git a/src/server/ApiManagers/UploadManager.ts b/src/server/ApiManagers/UploadManager.ts
index bfa07d47a..787e331c5 100644
--- a/src/server/ApiManagers/UploadManager.ts
+++ b/src/server/ApiManagers/UploadManager.ts
@@ -1,31 +1,30 @@
-import ApiManager, { Registration } from "./ApiManager";
-import { Method, _success } from "../RouteManager";
+import ApiManager, { Registration } from './ApiManager';
+import { Method, _success } from '../RouteManager';
 import * as formidable from 'formidable';
 import v4 = require('uuid/v4');
 const AdmZip = require('adm-zip');
 import { extname, basename, dirname } from 'path';
-import { createReadStream, createWriteStream, unlink, writeFile } from "fs";
-import { publicDirectory, filesDirectory } from "..";
-import { Database } from "../database";
-import { DashUploadUtils, InjectSize, SizeSuffix } from "../DashUploadUtils";
+import { createReadStream, createWriteStream, unlink, writeFile } from 'fs';
+import { publicDirectory, filesDirectory } from '..';
+import { Database } from '../database';
+import { DashUploadUtils, InjectSize, SizeSuffix } from '../DashUploadUtils';
 import * as sharp from 'sharp';
-import { AcceptableMedia, Upload } from "../SharedMediaTypes";
-import { normalize } from "path";
-import RouteSubscriber from "../RouteSubscriber";
+import { AcceptableMedia, Upload } from '../SharedMediaTypes';
+import { normalize } from 'path';
+import RouteSubscriber from '../RouteSubscriber';
 const imageDataUri = require('image-data-uri');
-import { isWebUri } from "valid-url";
-import { Opt } from "../../fields/Doc";
-import { SolrManager } from "./SearchManager";
-import { StringDecoder } from "string_decoder";
+import { SolrManager } from './SearchManager';
+const fs = require('fs');
 
 export enum Directory {
-    parsed_files = "parsed_files",
-    images = "images",
-    videos = "videos",
-    pdfs = "pdfs",
-    text = "text",
-    pdf_thumbnails = "pdf_thumbnails",
-    audio = "audio",
+    parsed_files = 'parsed_files',
+    images = 'images',
+    videos = 'videos',
+    pdfs = 'pdfs',
+    text = 'text',
+    pdf_thumbnails = 'pdf_thumbnails',
+    audio = 'audio',
+    csv = 'csv',
 }
 
 export function serverPathToFile(directory: Directory, filename: string) {
@@ -41,12 +40,19 @@ export function clientPathToFile(directory: Directory, filename: string) {
 }
 
 export default class UploadManager extends ApiManager {
-
     protected initialize(register: Registration): void {
+        register({
+            method: Method.POST,
+            subscription: '/concatVideos',
+            secureHandler: async ({ req, res }) => {
+                // req.body contains the array of server paths to the videos
+                _success(res, await DashUploadUtils.concatVideos(req.body));
+            },
+        });
 
         register({
             method: Method.POST,
-            subscription: "/uploadFormData",
+            subscription: '/uploadFormData',
             secureHandler: async ({ req, res }) => {
                 const form = new formidable.IncomingForm();
                 form.keepExtensions = true;
@@ -65,16 +71,16 @@ export default class UploadManager extends ApiManager {
                         resolve();
                     });
                 });
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: "/uploadYoutubeVideo",
+            subscription: '/uploadYoutubeVideo',
             secureHandler: async ({ req, res }) => {
                 //req.readableBuffer.head.data
                 return new Promise<void>(async resolve => {
-                    req.addListener("data", async (args) => {
+                    req.addListener('data', async args => {
                         console.log(args);
                         const payload = String.fromCharCode.apply(String, args);
                         const videoId = JSON.parse(payload).videoId;
@@ -85,12 +91,12 @@ export default class UploadManager extends ApiManager {
                         resolve();
                     });
                 });
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: new RouteSubscriber("youtubeScreenshot"),
+            subscription: new RouteSubscriber('youtubeScreenshot'),
             secureHandler: async ({ req, res }) => {
                 const { id, timecode } = req.body;
                 const convert = (raw: string) => {
@@ -115,34 +121,32 @@ export default class UploadManager extends ApiManager {
                         await DashUploadUtils.outputResizedImages(() => createReadStream(resolvedPath), resolvedName, pathToDirectory(Directory.images));
                         res.send({
                             accessPaths: {
-                                agnostic: DashUploadUtils.getAccessPaths(Directory.images, resolvedName)
-                            }
+                                agnostic: DashUploadUtils.getAccessPaths(Directory.images, resolvedName),
+                            },
                         } as Upload.FileInformation);
                         resolve();
                     });
                 });
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: "/uploadRemoteImage",
+            subscription: '/uploadRemoteImage',
             secureHandler: async ({ req, res }) => {
-
                 const { sources } = req.body;
                 if (Array.isArray(sources)) {
                     const results = await Promise.all(sources.map(source => DashUploadUtils.UploadImage(source)));
                     return res.send(results);
                 }
                 res.send();
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: "/uploadDoc",
+            subscription: '/uploadDoc',
             secureHandler: ({ req, res }) => {
-
                 const form = new formidable.IncomingForm();
                 form.keepExtensions = true;
                 // let path = req.body.path;
@@ -150,11 +154,11 @@ export default class UploadManager extends ApiManager {
                 let remap = true;
                 const getId = (id: string): string => {
                     if (!remap) return id;
-                    if (id.endsWith("Proto")) return id;
+                    if (id.endsWith('Proto')) return id;
                     if (id in ids) {
                         return ids[id];
                     } else {
-                        return ids[id] = v4();
+                        return (ids[id] = v4());
                     }
                 };
                 const mapFn = (doc: any) => {
@@ -162,26 +166,30 @@ export default class UploadManager extends ApiManager {
                         doc.id = getId(doc.id);
                     }
                     for (const key in doc.fields) {
-                        if (!doc.fields.hasOwnProperty(key)) { continue; }
+                        if (!doc.fields.hasOwnProperty(key)) {
+                            continue;
+                        }
                         const field = doc.fields[key];
-                        if (field === undefined || field === null) { continue; }
+                        if (field === undefined || field === null) {
+                            continue;
+                        }
 
-                        if (field.__type === "Doc") {
+                        if (field.__type === 'Doc') {
                             mapFn(field);
-                        } else if (field.__type === "proxy" || field.__type === "prefetch_proxy") {
+                        } else if (field.__type === 'proxy' || field.__type === 'prefetch_proxy') {
                             field.fieldId = getId(field.fieldId);
-                        } else if (field.__type === "script" || field.__type === "computed") {
+                        } else if (field.__type === 'script' || field.__type === 'computed') {
                             if (field.captures) {
                                 field.captures.fieldId = getId(field.captures.fieldId);
                             }
-                        } else if (field.__type === "list") {
+                        } else if (field.__type === 'list') {
                             mapFn(field);
-                        } else if (typeof field === "string") {
+                        } else if (typeof field === 'string') {
                             const re = /("(?:dataD|d)ocumentId"\s*:\s*")([\w\-]*)"/g;
                             doc.fields[key] = (field as any).replace(re, (match: any, p1: string, p2: string) => {
                                 return `${p1}${getId(p2)}"`;
                             });
-                        } else if (field.__type === "RichTextField") {
+                        } else if (field.__type === 'RichTextField') {
                             const re = /("href"\s*:\s*")(.*?)"/g;
                             field.Data = field.Data.replace(re, (match: any, p1: string, p2: string) => {
                                 return `${p1}${getId(p2)}"`;
@@ -191,87 +199,110 @@ export default class UploadManager extends ApiManager {
                 };
                 return new Promise<void>(resolve => {
                     form.parse(req, async (_err, fields, files) => {
-                        remap = fields.remap !== "false";
-                        let id: string = "";
+                        remap = fields.remap !== 'false';
+                        let id: string = '';
                         try {
                             for (const name in files) {
                                 const f = files[name];
-                                const path_2 = Array.isArray(f) ? "" : f.path;
+                                const path_2 = Array.isArray(f) ? '' : f.path;
                                 const zip = new AdmZip(path_2);
                                 zip.getEntries().forEach((entry: any) => {
-                                    if (!entry.entryName.startsWith("files/")) return;
-                                    let directory = dirname(entry.entryName) + "/";
+                                    if (!entry.entryName.startsWith('files/')) return;
+                                    let directory = dirname(entry.entryName) + '/';
                                     const extension = extname(entry.entryName);
-                                    const base = basename(entry.entryName).split(".")[0];
+                                    const base = basename(entry.entryName).split('.')[0];
                                     try {
                                         zip.extractEntryTo(entry.entryName, publicDirectory, true, false);
-                                        directory = "/" + directory;
+                                        directory = '/' + directory;
 
-                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + "_o" + extension));
-                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + "_s" + extension));
-                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + "_m" + extension));
-                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + "_l" + extension));
+                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + '_o' + extension));
+                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + '_s' + extension));
+                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + '_m' + extension));
+                                        createReadStream(publicDirectory + directory + base + extension).pipe(createWriteStream(publicDirectory + directory + base + '_l' + extension));
                                     } catch (e) {
                                         console.log(e);
                                     }
                                 });
-                                const json = zip.getEntry("doc.json");
+                                const json = zip.getEntry('doc.json');
                                 try {
-                                    const data = JSON.parse(json.getData().toString("utf8"));
+                                    const data = JSON.parse(json.getData().toString('utf8'));
                                     const datadocs = data.docs;
                                     id = getId(data.id);
                                     const docs = Object.keys(datadocs).map(key => datadocs[key]);
                                     docs.forEach(mapFn);
-                                    await Promise.all(docs.map((doc: any) => new Promise<void>(res => {
-                                        Database.Instance.replace(doc.id, doc, (err, r) => {
-                                            err && console.log(err);
-                                            res();
-                                        }, true);
-                                    })));
-                                } catch (e) { console.log(e); }
-                                unlink(path_2, () => { });
+                                    await Promise.all(
+                                        docs.map(
+                                            (doc: any) =>
+                                                new Promise<void>(res => {
+                                                    Database.Instance.replace(
+                                                        doc.id,
+                                                        doc,
+                                                        (err, r) => {
+                                                            err && console.log(err);
+                                                            res();
+                                                        },
+                                                        true
+                                                    );
+                                                })
+                                        )
+                                    );
+                                } catch (e) {
+                                    console.log(e);
+                                }
+                                unlink(path_2, () => {});
                             }
                             SolrManager.update();
-                            res.send(JSON.stringify(id || "error"));
-                        } catch (e) { console.log(e); }
+                            res.send(JSON.stringify(id || 'error'));
+                        } catch (e) {
+                            console.log(e);
+                        }
                         resolve();
                     });
                 });
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: "/inspectImage",
+            subscription: '/inspectImage',
             secureHandler: async ({ req, res }) => {
-
                 const { source } = req.body;
-                if (typeof source === "string") {
+                if (typeof source === 'string') {
                     return res.send(await DashUploadUtils.InspectImage(source));
                 }
                 res.send({});
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: "/uploadURI",
+            subscription: '/uploadURI',
             secureHandler: ({ req, res }) => {
                 const uri = req.body.uri;
                 const filename = req.body.name;
                 const origSuffix = req.body.nosuffix ? SizeSuffix.None : SizeSuffix.Original;
+                const deleteFiles = req.body.replaceRootFilename;
                 if (!uri || !filename) {
-                    res.status(401).send("incorrect parameters specified");
+                    res.status(401).send('incorrect parameters specified');
                     return;
                 }
+                if (deleteFiles) {
+                    const path = serverPathToFile(Directory.images, '');
+                    const regex = new RegExp(`${deleteFiles}.*`);
+                    fs.readdirSync(path)
+                        .filter((f: any) => regex.test(f))
+                        .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: "_m" }] : [
-                        { resizer: sharp().resize(100, undefined, { withoutEnlargement: true }), suffix: "_s" },
-                        { resizer: sharp().resize(400, undefined, { withoutEnlargement: true }), suffix: "_m" },
-                        { resizer: sharp().resize(900, undefined, { withoutEnlargement: true }), suffix: "_l" },
-                    ];
+                    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 => {
@@ -286,18 +317,19 @@ export default class UploadManager extends ApiManager {
                     }
                     if (isImage) {
                         resizers.forEach(resizer => {
-                            const path = serverPathToFile(Directory.images, filename + resizer.suffix + ext);
-                            createReadStream(savedName).pipe(resizer.resizer).pipe(createWriteStream(path));
+                            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)));
                         });
-
                     }
                     res.send(clientPathToFile(Directory.images, filename + ext));
                 });
-            }
+            },
         });
-
     }
-
 }
 function delay(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -305,7 +337,7 @@ function delay(ms: number) {
 /**
  * On success, returns a buffer containing the bytes of a screenshot
  * of the video (optionally, at a timecode) specified by @param targetUrl.
- * 
+ *
  * On failure, returns undefined.
  */
 async function captureYoutubeScreenshot(targetUrl: string) {
@@ -330,4 +362,4 @@ async function captureYoutubeScreenshot(targetUrl: string) {
 
     // return buffer;
     return null;
-}
\ No newline at end of file
+}
diff --git a/src/server/ApiManagers/UserManager.ts b/src/server/ApiManagers/UserManager.ts
index 7be8a1e9f..53e55c1c3 100644
--- a/src/server/ApiManagers/UserManager.ts
+++ b/src/server/ApiManagers/UserManager.ts
@@ -1,10 +1,10 @@
-import ApiManager, { Registration } from "./ApiManager";
-import { Method } from "../RouteManager";
-import { Database } from "../database";
-import { msToTime } from "../ActionUtilities";
-import * as bcrypt from "bcrypt-nodejs";
-import { Opt } from "../../fields/Doc";
-import { WebSocket } from "../websocket";
+import ApiManager, { Registration } from './ApiManager';
+import { Method } from '../RouteManager';
+import { Database } from '../database';
+import { msToTime } from '../ActionUtilities';
+import * as bcrypt from 'bcrypt-nodejs';
+import { Opt } from '../../fields/Doc';
+import { WebSocket } from '../websocket';
 
 export const timeMap: { [id: string]: number } = {};
 interface ActivityUnit {
@@ -13,28 +13,26 @@ interface ActivityUnit {
 }
 
 export default class UserManager extends ApiManager {
-
     protected initialize(register: Registration): void {
-
         register({
             method: Method.GET,
-            subscription: "/getUsers",
+            subscription: '/getUsers',
             secureHandler: async ({ res }) => {
-                const cursor = await Database.Instance.query({}, { email: 1, linkDatabaseId: 1, sharingDocumentId: 1 }, "users");
+                const cursor = await Database.Instance.query({}, { email: 1, linkDatabaseId: 1, sharingDocumentId: 1 }, 'users');
                 const results = await cursor.toArray();
                 res.send(results.map((user: any) => ({ email: user.email, linkDatabaseId: user.linkDatabaseId, sharingDocumentId: user.sharingDocumentId })));
-            }
+            },
         });
 
         register({
             method: Method.POST,
-            subscription: "/setCacheDocumentIds",
+            subscription: '/setCacheDocumentIds',
             secureHandler: async ({ user, req, res }) => {
                 const result: any = {};
                 user.cacheDocumentIds = req.body.cacheDocumentIds;
                 user.save(err => {
                     if (err) {
-                        result.error = [{ msg: "Error while caching documents" }];
+                        result.error = [{ msg: 'Error while caching documents' }];
                     }
                 });
 
@@ -42,32 +40,35 @@ export default class UserManager extends ApiManager {
                 //     console.log(e);
                 // });
                 res.send(result);
-            }
+            },
         });
 
         register({
             method: Method.GET,
-            subscription: "/getUserDocumentIds",
-            secureHandler: ({ res, user }) => res.send({ userDocumentId: user.userDocumentId, linkDatabaseId: user.linkDatabaseId, sharingDocumentId: user.sharingDocumentId })
+            subscription: '/getUserDocumentIds',
+            secureHandler: ({ res, user }) => res.send({ userDocumentId: user.userDocumentId, linkDatabaseId: user.linkDatabaseId, sharingDocumentId: user.sharingDocumentId }),
+            publicHandler: ({ res }) => res.send({ userDocumentId: '__guest__', linkDatabaseId: 3, sharingDocumentId: 2 }),
         });
 
         register({
             method: Method.GET,
-            subscription: "/getSharingDocumentId",
-            secureHandler: ({ res, user }) => res.send(user.sharingDocumentId)
+            subscription: '/getSharingDocumentId',
+            secureHandler: ({ res, user }) => res.send(user.sharingDocumentId),
+            publicHandler: ({ res }) => res.send(2),
         });
 
         register({
             method: Method.GET,
-            subscription: "/getLinkDatabaseId",
-            secureHandler: ({ res, user }) => res.send(user.linkDatabaseId)
+            subscription: '/getLinkDatabaseId',
+            secureHandler: ({ res, user }) => res.send(user.linkDatabaseId),
+            publicHandler: ({ res }) => res.send(3),
         });
 
         register({
             method: Method.GET,
-            subscription: "/getCurrentUser",
+            subscription: '/getCurrentUser',
             secureHandler: ({ res, user: { _id, email, cacheDocumentIds } }) => res.send(JSON.stringify({ id: _id, email, cacheDocumentIds })),
-            publicHandler: ({ res }) => res.send(JSON.stringify({ id: "__guest__", email: "" }))
+            publicHandler: ({ res }) => res.send(JSON.stringify({ id: '__guest__', email: 'guest' })),
         });
 
         register({
@@ -80,7 +81,7 @@ export default class UserManager extends ApiManager {
                 const validated = await new Promise<Opt<boolean>>(resolve => {
                     bcrypt.compare(curr_pass, user.password, (err, passwords_match) => {
                         if (err || !passwords_match) {
-                            result.error = [{ msg: "Incorrect current password" }];
+                            result.error = [{ msg: 'Incorrect current password' }];
                             res.send(result);
                             resolve(undefined);
                         } else {
@@ -93,10 +94,10 @@ export default class UserManager extends ApiManager {
                     return;
                 }
 
-                req.assert("new_pass", "Password must be at least 4 characters long").len({ min: 4 });
-                req.assert("new_confirm", "Passwords do not match").equals(new_pass);
+                req.assert('new_pass', 'Password must be at least 4 characters long').len({ min: 4 });
+                req.assert('new_confirm', 'Passwords do not match').equals(new_pass);
                 if (curr_pass === new_pass) {
-                    result.error = [{ msg: "Current and new password are the same" }];
+                    result.error = [{ msg: 'Current and new password are the same' }];
                 }
                 // was there error in validating new passwords?
                 if (req.validationErrors()) {
@@ -113,17 +114,17 @@ export default class UserManager extends ApiManager {
 
                 user.save(err => {
                     if (err) {
-                        result.error = [{ msg: "Error while saving new password" }];
+                        result.error = [{ msg: 'Error while saving new password' }];
                     }
                 });
 
                 res.send(result);
-            }
+            },
         });
 
         register({
             method: Method.GET,
-            subscription: "/activity",
+            subscription: '/activity',
             secureHandler: ({ res }) => {
                 const now = Date.now();
 
@@ -135,25 +136,23 @@ export default class UserManager extends ApiManager {
                     const socketPair = Array.from(WebSocket.socketMap).find(pair => pair[1] === user);
                     if (socketPair && !socketPair[0].disconnected) {
                         const duration = now - time;
-                        const target = (duration / 1000) < (60 * 5) ? activeTimes : inactiveTimes;
+                        const target = duration / 1000 < 60 * 5 ? activeTimes : inactiveTimes;
                         target.push({ user, duration });
                     }
                 }
 
-                const process = (target: { user: string, duration: number }[]) => {
+                const process = (target: { user: string; duration: number }[]) => {
                     const comparator = (first: ActivityUnit, second: ActivityUnit) => first.duration - second.duration;
                     const sorted = target.sort(comparator);
                     return sorted.map(({ user, duration }) => `${user} (${msToTime(duration)})`);
                 };
 
-                res.render("user_activity.pug", {
-                    title: "User Activity",
+                res.render('user_activity.pug', {
+                    title: 'User Activity',
                     active: process(activeTimes),
-                    inactive: process(inactiveTimes)
+                    inactive: process(inactiveTimes),
                 });
-            }
+            },
         });
-
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/server/DashSession/Session/agents/applied_session_agent.ts b/src/server/DashSession/Session/agents/applied_session_agent.ts
index 12064668b..8339a06dc 100644
--- a/src/server/DashSession/Session/agents/applied_session_agent.ts
+++ b/src/server/DashSession/Session/agents/applied_session_agent.ts
@@ -9,8 +9,8 @@ export abstract class AppliedSessionAgent {
 
     // the following two methods allow the developer to create a custom
     // session and use the built in customization options for each thread
-    protected abstract async initializeMonitor(monitor: Monitor): Promise<string>;
-    protected abstract async initializeServerWorker(): Promise<ServerWorker>;
+    protected abstract initializeMonitor(monitor: Monitor): Promise<string>;
+    protected abstract initializeServerWorker(): Promise<ServerWorker>;
 
     private launched = false;
 
diff --git a/src/server/DashUploadUtils.ts b/src/server/DashUploadUtils.ts
index 552ab57a5..cae35da60 100644
--- a/src/server/DashUploadUtils.ts
+++ b/src/server/DashUploadUtils.ts
@@ -1,9 +1,9 @@
 import { green, red } from 'colors';
 import { ExifImage } from 'exif';
+import * as exifr from 'exifr';
 import { File } from 'formidable';
 import { createWriteStream, existsSync, readFileSync, rename, unlinkSync, writeFile } from 'fs';
 import * as path from 'path';
-import * as exifr from 'exifr';
 import { basename } from "path";
 import * as sharp from 'sharp';
 import { Stream } from 'stream';
@@ -17,9 +17,12 @@ import { resolvedServerUrl } from "./server_Initialization";
 import { AcceptableMedia, Upload } from './SharedMediaTypes';
 import request = require('request-promise');
 import formidable = require('formidable');
+import { file } from 'jszip';
+import { csvParser } from './DataVizUtils';
 const { exec } = require("child_process");
 const parse = require('pdf-parse');
 const ffmpeg = require("fluent-ffmpeg");
+const fs = require("fs");
 const requestImageSize = require("../client/util/request-image-size");
 
 export enum SizeSuffix {
@@ -60,6 +63,43 @@ export namespace DashUploadUtils {
     const type = "content-type";
 
     const { imageFormats, videoFormats, applicationFormats, audioFormats } = AcceptableMedia; //TODO:glr 
+    
+    export async function concatVideos(filePaths: string[]): Promise<Upload.AccessPathInfo> {
+        // make a list of paths to create the ordered text file for ffmpeg
+        const inputListName = 'concat.txt';
+        const textFilePath = path.join(filesDirectory, inputListName);
+        // make a list of paths to create the ordered text file for ffmpeg
+      const filePathsText = filePaths.map(filePath => `file '${filePath}'`).join('\n');
+        // write the text file to the file system
+        writeFile(textFilePath, filePathsText, (err) => console.log(err));
+
+        // make output file name based on timestamp
+        const outputFileName = `output-${Utils.GenerateGuid()}.mp4`;
+        // create the output file path in the videos directory
+        const outputFilePath = path.join(pathToDirectory(Directory.videos), outputFileName);
+
+        // concatenate the videos
+        await new Promise((resolve, reject) => {
+            var merge = ffmpeg();
+            merge.input(textFilePath)
+            .inputOptions(['-f concat', '-safe 0'])
+                .outputOptions('-c copy')
+                //.videoCodec("copy")
+                .save(outputFilePath)
+                .on("error", reject)
+                .on("end", resolve);
+        })
+
+      // delete concat.txt from the file system
+      unlinkSync(textFilePath);
+      // delete the old segment videos from the server
+      filePaths.forEach(filePath => unlinkSync(filePath));
+
+      // return the path(s) to the output file
+      return {
+          accessPaths: getAccessPaths(Directory.videos, outputFileName)
+        }
+    }
 
     export function uploadYoutube(videoId: string): Promise<Upload.FileResponse> {
         console.log("UPLOAD " + videoId);
@@ -85,7 +125,7 @@ export namespace DashUploadUtils {
         const category = types[0];
         let format = `.${types[1]}`;
         console.log(green(`Processing upload of file (${name}) and format (${format}) with upload type (${type}) in category (${category}).`));
-
+        
         switch (category) {
             case "image":
                 if (imageFormats.includes(format)) {
@@ -94,6 +134,7 @@ export namespace DashUploadUtils {
                 }
             case "video":
                 if (format.includes("x-matroska")) {
+                    console.log("case video");
                     await new Promise(res => ffmpeg(file.path)
                         .videoCodec("copy") // this will copy the data instead of reencode it
                         .save(file.path.replace(".mkv", ".mp4"))
@@ -116,6 +157,11 @@ export namespace DashUploadUtils {
                 if (audioFormats.includes(format)) {
                     return UploadAudio(file, format);
                 }
+            case "text":
+                if (types[1] == "csv") {
+                    return UploadCsv(file);
+                }
+            
         }
 
         console.log(red(`Ignoring unsupported file (${name}) with upload type (${type}).`));
@@ -135,6 +181,16 @@ export namespace DashUploadUtils {
         return MoveParsedFile(file, Directory.pdfs, undefined, result.text);
     }
 
+    async function UploadCsv(file: File) {
+       const { path: sourcePath } = file;
+       // read the file as a string
+        const data = readFileSync(sourcePath, 'utf8');
+        // split the string into an array of lines
+        return MoveParsedFile(file, Directory.csv, undefined, data);
+        // console.log(csvParser(data));
+
+    }
+
     const manualSuffixes = [".webm"];
 
     async function UploadAudio(file: File, format: string) {
@@ -220,6 +276,7 @@ export namespace DashUploadUtils {
         }
         let resolvedUrl: string;
         /**
+         * 
          * At this point, we want to take whatever url we have and make sure it's requestable.
          * Anything that's hosted by some other website already is, but if the url is a local file url
          * (locates the file on this server machine), we have to resolve the client side url by cutting out the
diff --git a/src/server/DataVizUtils.ts b/src/server/DataVizUtils.ts
new file mode 100644
index 000000000..4fd0ca6ff
--- /dev/null
+++ b/src/server/DataVizUtils.ts
@@ -0,0 +1,13 @@
+export function csvParser(csv: string) {
+    const lines = csv.split("\n");
+    const headers = lines[0].split(",");
+    const data = lines.slice(1).map(line => {
+        const values = line.split(",");
+        const obj: any = {};
+        for (let i = 0; i < headers.length; i++) {
+            obj[headers[i]] = values[i];
+        }
+        return obj;
+    });
+    return data;
+}
\ No newline at end of file
diff --git a/src/server/RouteManager.ts b/src/server/RouteManager.ts
index aa9bfcfa7..5683cd539 100644
--- a/src/server/RouteManager.ts
+++ b/src/server/RouteManager.ts
@@ -1,12 +1,12 @@
 import { cyan, green, red } from 'colors';
 import { Express, Request, Response } from 'express';
-import { AdminPriviliges } from ".";
-import { DashUserModel } from "./authentication/DashUserModel";
-import RouteSubscriber from "./RouteSubscriber";
+import { AdminPriviliges } from '.';
+import { DashUserModel } from './authentication/DashUserModel';
+import RouteSubscriber from './RouteSubscriber';
 
 export enum Method {
     GET,
-    POST
+    POST,
 }
 
 export interface CoreArguments {
@@ -33,13 +33,13 @@ const registered = new Map<string, Set<Method>>();
 
 enum RegistrationError {
     Malformed,
-    Duplicate
+    Duplicate,
 }
 
 export default class RouteManager {
     private server: Express;
     private _isRelease: boolean;
-    private failedRegistrations: { route: string, reason: RegistrationError }[] = [];
+    private failedRegistrations: { route: string; reason: RegistrationError }[] = [];
 
     public get isRelease() {
         return this._isRelease;
@@ -74,39 +74,42 @@ export default class RouteManager {
             }
             process.exit(1);
         } else {
-            console.log(green("all server routes have been successfully registered:"));
-            Array.from(registered.keys()).sort().forEach(route => console.log(cyan(route)));
+            console.log(green('all server routes have been successfully registered:'));
+            Array.from(registered.keys())
+                .sort()
+                .forEach(route => console.log(cyan(route)));
             console.log();
         }
-    }
+    };
 
     static routes: string[] = [];
     /**
-     * 
-     * @param initializer 
+     *
+     * @param initializer
      */
     addSupervisedRoute = (initializer: RouteInitializer): void => {
         const { method, subscription, secureHandler, publicHandler, errorHandler, requireAdminInRelease: requireAdmin } = initializer;
 
-        typeof (initializer.subscription) === "string" && RouteManager.routes.push(initializer.subscription);
+        typeof initializer.subscription === 'string' && RouteManager.routes.push(initializer.subscription);
         initializer.subscription instanceof RouteSubscriber && RouteManager.routes.push(initializer.subscription.root);
-        initializer.subscription instanceof Array && initializer.subscription.map(sub => {
-            typeof (sub) === "string" && RouteManager.routes.push(sub);
-            sub instanceof RouteSubscriber && RouteManager.routes.push(sub.root);
-        });
+        initializer.subscription instanceof Array &&
+            initializer.subscription.map(sub => {
+                typeof sub === 'string' && RouteManager.routes.push(sub);
+                sub instanceof RouteSubscriber && RouteManager.routes.push(sub.root);
+            });
         const isRelease = this._isRelease;
         const supervised = async (req: Request, res: Response) => {
             let user = req.user as Partial<DashUserModel> | undefined;
             const { originalUrl: target } = req;
-            if (process.env.DB === "MEM" && !user) {
-                user = { id: "guest", email: "", userDocumentId: "guestDocId" };
+            if (process.env.DB === 'MEM' && !user) {
+                user = { id: 'guest', email: 'guest', userDocumentId: '__guest__' };
             }
             const core = { req, res, isRelease };
             const tryExecute = async (toExecute: (args: any) => any | Promise<any>, args: any) => {
                 try {
                     await toExecute(args);
                 } catch (e) {
-                    console.log(red(target), user && ("email" in user) ? "<user logged out>" : undefined);
+                    console.log(red(target), user && 'email' in user ? '<user logged out>' : undefined);
                     if (errorHandler) {
                         errorHandler({ ...core, error: e });
                     } else {
@@ -119,7 +122,7 @@ export default class RouteManager {
                     if (AdminPriviliges.get(user.id)) {
                         AdminPriviliges.delete(user.id);
                     } else {
-                        return res.redirect(`/admin/${req.originalUrl.substring(1).replace("/", ":")}`);
+                        return res.redirect(`/admin/${req.originalUrl.substring(1).replace('/', ':')}`);
                     }
                 }
                 await tryExecute(secureHandler, { ...core, user });
@@ -128,10 +131,10 @@ export default class RouteManager {
                 if (publicHandler) {
                     await tryExecute(publicHandler, core);
                     if (!res.headersSent) {
-                        res.redirect("/login");
+                        // res.redirect("/login");
                     }
                 } else {
-                    res.redirect("/login");
+                    res.redirect('/login');
                 }
             }
             setTimeout(() => {
@@ -144,7 +147,7 @@ export default class RouteManager {
         };
         const subscribe = (subscriber: RouteSubscriber | string) => {
             let route: string;
-            if (typeof subscriber === "string") {
+            if (typeof subscriber === 'string') {
                 route = subscriber;
             } else {
                 route = subscriber.build;
@@ -152,7 +155,7 @@ export default class RouteManager {
             if (!/^\/$|^\/[A-Za-z\*]+(\/\:[A-Za-z?_\*]+)*$/g.test(route)) {
                 this.failedRegistrations.push({
                     reason: RegistrationError.Malformed,
-                    route
+                    route,
                 });
             } else {
                 const existing = registered.get(route);
@@ -160,7 +163,7 @@ export default class RouteManager {
                     if (existing.has(method)) {
                         this.failedRegistrations.push({
                             reason: RegistrationError.Duplicate,
-                            route
+                            route,
                         });
                         return;
                     }
@@ -184,15 +187,14 @@ export default class RouteManager {
         } else {
             subscribe(subscription);
         }
-    }
-
+    };
 }
 
 export const STATUS = {
     OK: 200,
     BAD_REQUEST: 400,
     EXECUTION_ERROR: 500,
-    PERMISSION_DENIED: 403
+    PERMISSION_DENIED: 403,
 };
 
 export function _error(res: Response, message: string, error?: any) {
diff --git a/src/server/authentication/AuthenticationManager.ts b/src/server/authentication/AuthenticationManager.ts
index b736f0d35..52d876e95 100644
--- a/src/server/authentication/AuthenticationManager.ts
+++ b/src/server/authentication/AuthenticationManager.ts
@@ -1,14 +1,14 @@
-import { default as User, DashUserModel } from "./DashUserModel";
-import { Request, Response, NextFunction } from "express";
-import * as passport from "passport";
-import { IVerifyOptions } from "passport-local";
-import "./Passport";
-import flash = require("express-flash");
+import { default as User, DashUserModel, initializeGuest } from './DashUserModel';
+import { Request, Response, NextFunction } from 'express';
+import * as passport from 'passport';
+import { IVerifyOptions } from 'passport-local';
+import './Passport';
+import flash = require('express-flash');
 import * as async from 'async';
 import * as nodemailer from 'nodemailer';
-import c = require("crypto");
-import { Utils } from "../../Utils";
-import { MailOptions } from "nodemailer/lib/stream-transport";
+import c = require('crypto');
+import { emptyFunction, Utils } from '../../Utils';
+import { MailOptions } from 'nodemailer/lib/stream-transport';
 
 /**
  * GET /signup
@@ -17,10 +17,10 @@ import { MailOptions } from "nodemailer/lib/stream-transport";
  */
 export let getSignup = (req: Request, res: Response) => {
     if (req.user) {
-        return res.redirect("/home");
+        return res.redirect('/home');
     }
-    res.render("signup.pug", {
-        title: "Sign Up",
+    res.render('signup.pug', {
+        title: 'Sign Up',
         user: req.user,
     });
 };
@@ -30,45 +30,50 @@ export let getSignup = (req: Request, res: Response) => {
  * Create a new local account.
  */
 export let postSignup = (req: Request, res: Response, next: NextFunction) => {
-    req.assert("email", "Email is not valid").isEmail();
-    req.assert("password", "Password must be at least 4 characters long").len({ min: 4 });
-    req.assert("confirmPassword", "Passwords do not match").equals(req.body.password);
-    req.sanitize("email").normalizeEmail({ gmail_remove_dots: false });
+    const email = req.body.email as String;
+    req.assert('email', 'Email is not valid').isEmail();
+    req.assert('password', 'Password must be at least 4 characters long').len({ min: 4 });
+    req.assert('confirmPassword', 'Passwords do not match').equals(req.body.password);
+    req.sanitize('email').normalizeEmail({ gmail_remove_dots: false });
 
     const errors = req.validationErrors();
 
     if (errors) {
-        return res.redirect("/signup");
+        return res.redirect('/signup');
     }
 
-    const email = req.body.email as String;
     const password = req.body.password;
 
     const model = {
         email,
         password,
-        userDocumentId: Utils.GenerateGuid(),
-        sharingDocumentId: Utils.GenerateGuid(),
-        linkDatabaseId: Utils.GenerateGuid(),
-        cacheDocumentIds: ""
+        userDocumentId: email === 'guest' ? '__guest__' : Utils.GenerateGuid(),
+        sharingDocumentId: email === 'guest' ? 2 : Utils.GenerateGuid(),
+        linkDatabaseId: email === 'guest' ? 3 : Utils.GenerateGuid(),
+        cacheDocumentIds: '',
     } as Partial<DashUserModel>;
 
     const user = new User(model);
 
     User.findOne({ email }, (err: any, existingUser: any) => {
-        if (err) { return next(err); }
+        if (err) {
+            return next(err);
+        }
         if (existingUser) {
-            return res.redirect("/login");
+            return res.redirect('/login');
         }
         user.save((err: any) => {
-            if (err) { return next(err); }
-            req.logIn(user, (err) => {
-                if (err) { return next(err); }
+            if (err) {
+                return next(err);
+            }
+            req.logIn(user, err => {
+                if (err) {
+                    return next(err);
+                }
                 tryRedirectToTarget(req, res);
             });
         });
     });
-
 };
 
 const tryRedirectToTarget = (req: Request, res: Response) => {
@@ -76,11 +81,10 @@ const tryRedirectToTarget = (req: Request, res: Response) => {
     if (req.session && target) {
         res.redirect(target);
     } else {
-        res.redirect("/home");
+        res.redirect('/home');
     }
 };
 
-
 /**
  * GET /login
  * Login page.
@@ -88,11 +92,11 @@ const tryRedirectToTarget = (req: Request, res: Response) => {
 export let getLogin = (req: Request, res: Response) => {
     if (req.user) {
         //req.session.target = undefined;
-        return res.redirect("/home");
+        return res.redirect('/home');
     }
-    res.render("login.pug", {
-        title: "Log In",
-        user: req.user
+    res.render('login.pug', {
+        title: 'Log In',
+        user: req.user,
     });
 };
 
@@ -102,27 +106,38 @@ export let getLogin = (req: Request, res: Response) => {
  * On failure, redirect to signup page
  */
 export let postLogin = (req: Request, res: Response, next: NextFunction) => {
-    req.assert("email", "Email is not valid").isEmail();
-    req.assert("password", "Password cannot be blank").notEmpty();
-    req.sanitize("email").normalizeEmail({ gmail_remove_dots: false });
-
-    const errors = req.validationErrors();
+    if (req.body.email === '') {
+        User.findOne({ email: 'guest' }, (err: any, user: DashUserModel) => !user && initializeGuest());
+        req.body.email = 'guest';
+        req.body.password = 'guest';
+    } else {
+        req.assert('email', 'Email is not valid').isEmail();
+        req.assert('password', 'Password cannot be blank').notEmpty();
+        req.sanitize('email').normalizeEmail({ gmail_remove_dots: false });
+    }
 
-    if (errors) {
-        req.flash("errors", "Unable to login at this time. Please try again.");
-        return res.redirect("/signup");
+    if (req.validationErrors()) {
+        req.flash('errors', 'Unable to login at this time. Please try again.');
+        return res.redirect('/signup');
     }
 
-    passport.authenticate("local", (err: Error, user: DashUserModel, _info: IVerifyOptions) => {
-        if (err) { next(err); return; }
+    const callback = (err: Error, user: DashUserModel, _info: IVerifyOptions) => {
+        if (err) {
+            next(err);
+            return;
+        }
         if (!user) {
-            return res.redirect("/signup");
+            return res.redirect('/signup');
         }
-        req.logIn(user, (err) => {
-            if (err) { next(err); return; }
+        req.logIn(user, err => {
+            if (err) {
+                next(err);
+                return;
+            }
             tryRedirectToTarget(req, res);
         });
-    })(req, res, next);
+    };
+    setTimeout(() => passport.authenticate('local', callback)(req, res, next), 500);
 };
 
 /**
@@ -131,140 +146,154 @@ export let postLogin = (req: Request, res: Response, next: NextFunction) => {
  * and destroys the user's current session.
  */
 export let getLogout = (req: Request, res: Response) => {
-    req.logout();
+    req.logout(emptyFunction);
     const sess = req.session;
     if (sess) {
-        sess.destroy((err) => { if (err) { console.log(err); } });
+        sess.destroy(err => {
+            if (err) {
+                console.log(err);
+            }
+        });
     }
-    res.redirect("/login");
+    res.redirect('/login');
 };
 
 export let getForgot = function (req: Request, res: Response) {
-    res.render("forgot.pug", {
-        title: "Recover Password",
+    res.render('forgot.pug', {
+        title: 'Recover Password',
         user: req.user,
     });
 };
 
 export let postForgot = function (req: Request, res: Response, next: NextFunction) {
     const email = req.body.email;
-    async.waterfall([
-        function (done: any) {
-            c.randomBytes(20, function (err: any, buffer: Buffer) {
-                if (err) {
-                    done(null);
-                    return;
-                }
-                done(null, buffer.toString('hex'));
-            });
-        },
-        function (token: string, done: any) {
-            User.findOne({ email }, function (err: any, user: DashUserModel) {
-                if (!user) {
-                    // NO ACCOUNT WITH SUBMITTED EMAIL
-                    res.redirect("/forgotPassword");
-                    return;
-                }
-                user.passwordResetToken = token;
-                user.passwordResetExpires = new Date(Date.now() + 3600000); // 1 HOUR
-                user.save(function (err: any) {
-                    done(null, token, user);
+    async.waterfall(
+        [
+            function (done: any) {
+                c.randomBytes(20, function (err: any, buffer: Buffer) {
+                    if (err) {
+                        done(null);
+                        return;
+                    }
+                    done(null, buffer.toString('hex'));
                 });
-            });
-        },
-        function (token: Uint16Array, user: DashUserModel, done: any) {
-            const smtpTransport = nodemailer.createTransport({
-                service: 'Gmail',
-                auth: {
-                    user: 'browndashptc@gmail.com',
-                    pass: 'TsarNicholas#2'
-                }
-            });
-            const mailOptions = {
-                to: user.email,
-                from: 'browndashptc@gmail.com',
-                subject: 'Dash Password Reset',
-                text: 'You are receiving this because you (or someone else) have requested the reset of the password for your account.\n\n' +
-                    'Please click on the following link, or paste this into your browser to complete the process:\n\n' +
-                    'http://' + req.headers.host + '/resetPassword/' + token + '\n\n' +
-                    'If you did not request this, please ignore this email and your password will remain unchanged.\n'
-            } as MailOptions;
-            smtpTransport.sendMail(mailOptions, function (err: Error | null) {
-                // req.flash('info', 'An e-mail has been sent to ' + user.email + ' with further instructions.');
-                done(null, err, 'done');
-            });
+            },
+            function (token: string, done: any) {
+                User.findOne({ email }, function (err: any, user: DashUserModel) {
+                    if (!user) {
+                        // NO ACCOUNT WITH SUBMITTED EMAIL
+                        res.redirect('/forgotPassword');
+                        return;
+                    }
+                    user.passwordResetToken = token;
+                    user.passwordResetExpires = new Date(Date.now() + 3600000); // 1 HOUR
+                    user.save(function (err: any) {
+                        done(null, token, user);
+                    });
+                });
+            },
+            function (token: Uint16Array, user: DashUserModel, done: any) {
+                const smtpTransport = nodemailer.createTransport({
+                    service: 'Gmail',
+                    auth: {
+                        user: 'browndashptc@gmail.com',
+                        pass: 'TsarNicholas#2',
+                    },
+                });
+                const mailOptions = {
+                    to: user.email,
+                    from: 'browndashptc@gmail.com',
+                    subject: 'Dash Password Reset',
+                    text:
+                        'You are receiving this because you (or someone else) have requested the reset of the password for your account.\n\n' +
+                        'Please click on the following link, or paste this into your browser to complete the process:\n\n' +
+                        'http://' +
+                        req.headers.host +
+                        '/resetPassword/' +
+                        token +
+                        '\n\n' +
+                        'If you did not request this, please ignore this email and your password will remain unchanged.\n',
+                } as MailOptions;
+                smtpTransport.sendMail(mailOptions, function (err: Error | null) {
+                    // req.flash('info', 'An e-mail has been sent to ' + user.email + ' with further instructions.');
+                    done(null, err, 'done');
+                });
+            },
+        ],
+        function (err) {
+            if (err) return next(err);
+            res.redirect('/forgotPassword');
         }
-    ], function (err) {
-        if (err) return next(err);
-        res.redirect("/forgotPassword");
-    });
+    );
 };
 
 export let getReset = function (req: Request, res: Response) {
     User.findOne({ passwordResetToken: req.params.token, passwordResetExpires: { $gt: Date.now() } }, function (err: any, user: DashUserModel) {
         if (!user || err) {
-            return res.redirect("/forgotPassword");
+            return res.redirect('/forgotPassword');
         }
-        res.render("reset.pug", {
-            title: "Reset Password",
+        res.render('reset.pug', {
+            title: 'Reset Password',
             user: req.user,
         });
     });
 };
 
 export let postReset = function (req: Request, res: Response) {
-    async.waterfall([
-        function (done: any) {
-            User.findOne({ passwordResetToken: req.params.token, passwordResetExpires: { $gt: Date.now() } }, function (err: any, user: DashUserModel) {
-                if (!user || err) {
-                    return res.redirect('back');
-                }
+    async.waterfall(
+        [
+            function (done: any) {
+                User.findOne({ passwordResetToken: req.params.token, passwordResetExpires: { $gt: Date.now() } }, function (err: any, user: DashUserModel) {
+                    if (!user || err) {
+                        return res.redirect('back');
+                    }
 
-                req.assert("password", "Password must be at least 4 characters long").len({ min: 4 });
-                req.assert("confirmPassword", "Passwords do not match").equals(req.body.password);
+                    req.assert('password', 'Password must be at least 4 characters long').len({ min: 4 });
+                    req.assert('confirmPassword', 'Passwords do not match').equals(req.body.password);
 
-                if (req.validationErrors()) {
-                    return res.redirect('back');
-                }
+                    if (req.validationErrors()) {
+                        return res.redirect('back');
+                    }
 
-                user.password = req.body.password;
-                user.passwordResetToken = undefined;
-                user.passwordResetExpires = undefined;
+                    user.password = req.body.password;
+                    user.passwordResetToken = undefined;
+                    user.passwordResetExpires = undefined;
 
-                user.save(function (err) {
-                    if (err) {
-                        res.redirect("/login");
-                        return;
-                    }
-                    req.logIn(user, function (err) {
+                    user.save(function (err) {
                         if (err) {
+                            res.redirect('/login');
                             return;
                         }
+                        req.logIn(user, function (err) {
+                            if (err) {
+                                return;
+                            }
+                        });
+                        done(null, user);
                     });
-                    done(null, user);
                 });
-            });
-        },
-        function (user: DashUserModel, done: any) {
-            const smtpTransport = nodemailer.createTransport({
-                service: 'Gmail',
-                auth: {
-                    user: 'browndashptc@gmail.com',
-                    pass: 'TsarNicholas#2'
-                }
-            });
-            const mailOptions = {
-                to: user.email,
-                from: 'browndashptc@gmail.com',
-                subject: 'Your password has been changed',
-                text: 'Hello,\n\n' +
-                    'This is a confirmation that the password for your account ' + user.email + ' has just been changed.\n'
-            } as MailOptions;
-            smtpTransport.sendMail(mailOptions, function (err) {
-                done(null, err);
-            });
+            },
+            function (user: DashUserModel, done: any) {
+                const smtpTransport = nodemailer.createTransport({
+                    service: 'Gmail',
+                    auth: {
+                        user: 'browndashptc@gmail.com',
+                        pass: 'TsarNicholas#2',
+                    },
+                });
+                const mailOptions = {
+                    to: user.email,
+                    from: 'browndashptc@gmail.com',
+                    subject: 'Your password has been changed',
+                    text: 'Hello,\n\n' + 'This is a confirmation that the password for your account ' + user.email + ' has just been changed.\n',
+                } as MailOptions;
+                smtpTransport.sendMail(mailOptions, function (err) {
+                    done(null, err);
+                });
+            },
+        ],
+        function (err) {
+            res.redirect('/login');
         }
-    ], function (err) {
-        res.redirect("/login");
-    });
-};
\ No newline at end of file
+    );
+};
diff --git a/src/server/authentication/DashUserModel.ts b/src/server/authentication/DashUserModel.ts
index bee28b96d..a1883beab 100644
--- a/src/server/authentication/DashUserModel.ts
+++ b/src/server/authentication/DashUserModel.ts
@@ -1,13 +1,13 @@
 //@ts-ignore
-import * as bcrypt from "bcrypt-nodejs";
+import * as bcrypt from 'bcrypt-nodejs';
 //@ts-ignore
 import * as mongoose from 'mongoose';
 
 export type DashUserModel = mongoose.Document & {
-    email: String,
-    password: string,
-    passwordResetToken?: string,
-    passwordResetExpires?: Date,
+    email: String;
+    password: string;
+    passwordResetToken?: string;
+    passwordResetExpires?: Date;
 
     userDocumentId: string;
     sharingDocumentId: string;
@@ -15,66 +15,74 @@ export type DashUserModel = mongoose.Document & {
     cacheDocumentIds: string;
 
     profile: {
-        name: string,
-        gender: string,
-        location: string,
-        website: string,
-        picture: string
-    },
+        name: string;
+        gender: string;
+        location: string;
+        website: string;
+        picture: string;
+    };
 
-    comparePassword: comparePasswordFunction,
+    comparePassword: comparePasswordFunction;
 };
 
 type comparePasswordFunction = (candidatePassword: string, cb: (err: any, isMatch: any) => {}) => void;
 
 export type AuthToken = {
-    accessToken: string,
-    kind: string
+    accessToken: string;
+    kind: string;
 };
 
-const userSchema = new mongoose.Schema({
-    email: String,
-    password: String,
-    passwordResetToken: String,
-    passwordResetExpires: Date,
+const userSchema = new mongoose.Schema(
+    {
+        email: String,
+        password: String,
+        passwordResetToken: String,
+        passwordResetExpires: Date,
 
-    userDocumentId: String,    // id that identifies a document which hosts all of a user's account data
-    sharingDocumentId: String, // id that identifies a document that stores documents shared to a user, their user color, and any additional info needed to communicate between users
-    linkDatabaseId: String,
-    cacheDocumentIds: String, // set of document ids to retreive on startup
+        userDocumentId: String, // id that identifies a document which hosts all of a user's account data
+        sharingDocumentId: String, // id that identifies a document that stores documents shared to a user, their user color, and any additional info needed to communicate between users
+        linkDatabaseId: String,
+        cacheDocumentIds: String, // set of document ids to retreive on startup
 
-    facebook: String,
-    twitter: String,
-    google: String,
+        facebook: String,
+        twitter: String,
+        google: String,
 
-    profile: {
-        name: String,
-        gender: String,
-        location: String,
-        website: String,
-        picture: String
-    }
-}, { timestamps: true });
+        profile: {
+            name: String,
+            gender: String,
+            location: String,
+            website: String,
+            picture: String,
+        },
+    },
+    { timestamps: true }
+);
 
 /**
  * Password hash middleware.
  */
-userSchema.pre("save", function save(next) {
+userSchema.pre('save', function save(next) {
     const user = this as DashUserModel;
-    if (!user.isModified("password")) {
+    if (!user.isModified('password')) {
         return next();
     }
     bcrypt.genSalt(10, (err: any, salt: string) => {
         if (err) {
             return next(err);
         }
-        bcrypt.hash(user.password, salt, () => void {}, (err: mongoose.Error, hash: string) => {
-            if (err) {
-                return next(err);
+        bcrypt.hash(
+            user.password,
+            salt,
+            () => void {},
+            (err: mongoose.Error, hash: string) => {
+                if (err) {
+                    return next(err);
+                }
+                user.password = hash;
+                next();
             }
-            user.password = hash;
-            next();
-        });
+        );
     });
 });
 
@@ -88,5 +96,15 @@ const comparePassword: comparePasswordFunction = function (this: DashUserModel,
 
 userSchema.methods.comparePassword = comparePassword;
 
-const User = mongoose.model("User", userSchema);
-export default User;
\ No newline at end of file
+const User = mongoose.model('User', userSchema);
+export function initializeGuest() {
+    new User({
+        email: 'guest',
+        password: 'guest',
+        userDocumentId: '__guest__',
+        sharingDocumentId: '2',
+        linkDatabaseId: '3',
+        cacheDocumentIds: '',
+    }).save();
+}
+export default User;
diff --git a/src/server/database.ts b/src/server/database.ts
index 2a55c14de..725b66836 100644
--- a/src/server/database.ts
+++ b/src/server/database.ts
@@ -34,7 +34,13 @@ export namespace Database {
                         console.log(`mongoose established default connection at ${url}`);
                         resolve();
                     });
-                    mongoose.connect(url, { useNewUrlParser: true, useUnifiedTopology: true, dbName: schema });
+                    mongoose.connect(url, {
+                        useNewUrlParser: true, 
+                        useUnifiedTopology: true, 
+                        dbName: schema,
+                        // reconnectTries: Number.MAX_VALUE,
+                        // reconnectInterval: 1000,
+                    }); 
                 });
             }
         } catch (e) {
diff --git a/src/server/index.ts b/src/server/index.ts
index f8c32103b..6e6bde3cb 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -1,35 +1,35 @@
 require('dotenv').config();
-import { yellow } from "colors";
+import { yellow } from 'colors';
 import * as mobileDetect from 'mobile-detect';
 import * as path from 'path';
 import * as qs from 'query-string';
-import { log_execution } from "./ActionUtilities";
-import DeleteManager from "./ApiManagers/DeleteManager";
+import { log_execution } from './ActionUtilities';
+import DeleteManager from './ApiManagers/DeleteManager';
 import DownloadManager from './ApiManagers/DownloadManager';
-import GeneralGoogleManager from "./ApiManagers/GeneralGoogleManager";
-import GooglePhotosManager from "./ApiManagers/GooglePhotosManager";
-import PDFManager from "./ApiManagers/PDFManager";
+import GeneralGoogleManager from './ApiManagers/GeneralGoogleManager';
+import GooglePhotosManager from './ApiManagers/GooglePhotosManager';
+import PDFManager from './ApiManagers/PDFManager';
 import { SearchManager } from './ApiManagers/SearchManager';
-import SessionManager from "./ApiManagers/SessionManager";
-import UploadManager from "./ApiManagers/UploadManager";
+import SessionManager from './ApiManagers/SessionManager';
+import UploadManager from './ApiManagers/UploadManager';
 import UserManager from './ApiManagers/UserManager';
 import UtilManager from './ApiManagers/UtilManager';
 import { GoogleCredentialsLoader, SSL } from './apis/google/CredentialsLoader';
-import { GoogleApiServerUtils } from "./apis/google/GoogleApiServerUtils";
-import { DashSessionAgent } from "./DashSession/DashSessionAgent";
-import { AppliedSessionAgent } from "./DashSession/Session/agents/applied_session_agent";
+import { GoogleApiServerUtils } from './apis/google/GoogleApiServerUtils';
+import { DashSessionAgent } from './DashSession/DashSessionAgent';
+import { AppliedSessionAgent } from './DashSession/Session/agents/applied_session_agent';
 import { DashUploadUtils } from './DashUploadUtils';
 import { Database } from './database';
-import { Logger } from "./ProcessFactory";
+import { Logger } from './ProcessFactory';
 import RouteManager, { Method, PublicHandler } from './RouteManager';
 import RouteSubscriber from './RouteSubscriber';
 import initializeServer, { resolvedPorts } from './server_Initialization';
 
 export const AdminPriviliges: Map<string, boolean> = new Map();
-export const onWindows = process.platform === "win32";
+export const onWindows = process.platform === 'win32';
 export let sessionAgent: AppliedSessionAgent;
-export const publicDirectory = path.resolve(__dirname, "public");
-export const filesDirectory = path.resolve(publicDirectory, "files");
+export const publicDirectory = path.resolve(__dirname, 'public');
+export const filesDirectory = path.resolve(publicDirectory, 'files');
 
 /**
  * These are the functions run before the server starts
@@ -43,11 +43,11 @@ async function preliminaryFunctions() {
     await GoogleCredentialsLoader.loadCredentials();
     SSL.loadCredentials();
     GoogleApiServerUtils.processProjectCredentials();
-    if (process.env.DB !== "MEM") {
+    if (process.env.DB !== 'MEM') {
         await log_execution({
-            startMessage: "attempting to initialize mongodb connection",
-            endMessage: "connection outcome determined",
-            action: Database.tryInitializeConnection
+            startMessage: 'attempting to initialize mongodb connection',
+            endMessage: 'connection outcome determined',
+            action: Database.tryInitializeConnection,
         });
     }
 }
@@ -56,27 +56,16 @@ async function preliminaryFunctions() {
  * Either clustered together as an API manager
  * or individually referenced below, by the completion
  * of this function's execution, all routes will
- * be registered on the server 
+ * be registered on the server
  * @param router the instance of the route manager
  * that will manage the registration of new routes
  * with the server
  */
 function routeSetter({ isRelease, addSupervisedRoute, logRegistrationOutcome }: RouteManager) {
-    const managers = [
-        new SessionManager(),
-        new UserManager(),
-        new UploadManager(),
-        new DownloadManager(),
-        new SearchManager(),
-        new PDFManager(),
-        new DeleteManager(),
-        new UtilManager(),
-        new GeneralGoogleManager(),
-        new GooglePhotosManager(),
-    ];
+    const managers = [new SessionManager(), new UserManager(), new UploadManager(), new DownloadManager(), new SearchManager(), new PDFManager(), new DeleteManager(), new UtilManager(), new GeneralGoogleManager(), new GooglePhotosManager()];
 
     // initialize API Managers
-    console.log(yellow("\nregistering server routes..."));
+    console.log(yellow('\nregistering server routes...'));
     managers.forEach(manager => manager.register(addSupervisedRoute));
 
     /**
@@ -84,88 +73,87 @@ function routeSetter({ isRelease, addSupervisedRoute, logRegistrationOutcome }:
      */
     addSupervisedRoute({
         method: Method.GET,
-        subscription: "/",
-        secureHandler: ({ res }) => res.redirect("/home")
+        subscription: '/',
+        secureHandler: ({ res }) => res.redirect('/home'),
     });
 
-
     addSupervisedRoute({
         method: Method.GET,
-        subscription: "/serverHeartbeat",
-        secureHandler: ({ res }) => res.send(true)
+        subscription: '/serverHeartbeat',
+        secureHandler: ({ res }) => res.send(true),
     });
 
     addSupervisedRoute({
         method: Method.GET,
-        subscription: "/resolvedPorts",
-        secureHandler: ({ res }) => res.send(resolvedPorts)
+        subscription: '/resolvedPorts',
+        secureHandler: ({ res }) => res.send(resolvedPorts),
+        publicHandler: ({ res }) => res.send(resolvedPorts),
     });
 
     const serve: PublicHandler = ({ req, res }) => {
-        const detector = new mobileDetect(req.headers['user-agent'] || "");
+        const detector = new mobileDetect(req.headers['user-agent'] || '');
         const filename = detector.mobile() !== null ? 'mobile/image.html' : 'index.html';
         res.sendFile(path.join(__dirname, '../../deploy/' + filename));
     };
 
     /**
-     * Serves a simple password input box for any 
+     * Serves a simple password input box for any
      */
     addSupervisedRoute({
         method: Method.GET,
-        subscription: new RouteSubscriber("admin").add("previous_target"),
+        subscription: new RouteSubscriber('admin').add('previous_target'),
         secureHandler: ({ res, isRelease }) => {
             const { PASSWORD } = process.env;
             if (!(isRelease && PASSWORD)) {
-                return res.redirect("/home");
+                return res.redirect('/home');
             }
-            res.render("admin.pug", { title: "Enter Administrator Password" });
-        }
+            res.render('admin.pug', { title: 'Enter Administrator Password' });
+        },
     });
 
     addSupervisedRoute({
         method: Method.POST,
-        subscription: new RouteSubscriber("admin").add("previous_target"),
+        subscription: new RouteSubscriber('admin').add('previous_target'),
         secureHandler: async ({ req, res, isRelease, user: { id } }) => {
             const { PASSWORD } = process.env;
             if (!(isRelease && PASSWORD)) {
-                return res.redirect("/home");
+                return res.redirect('/home');
             }
             const { password } = req.body;
             const { previous_target } = req.params;
             let redirect: string;
             if (password === PASSWORD) {
                 AdminPriviliges.set(id, true);
-                redirect = `/${previous_target.replace(":", "/")}`;
+                redirect = `/${previous_target.replace(':', '/')}`;
             } else {
                 redirect = `/admin/${previous_target}`;
             }
             res.redirect(redirect);
-        }
+        },
     });
 
     addSupervisedRoute({
         method: Method.GET,
-        subscription: ["/home", new RouteSubscriber("doc").add("docId")],
+        subscription: ['/home', new RouteSubscriber('doc').add('docId')],
         secureHandler: serve,
         publicHandler: ({ req, res, ...remaining }) => {
             const { originalUrl: target } = req;
-            const sharing = qs.parse(qs.extract(req.originalUrl), { sort: false }).sharing === "true";
-            const docAccess = target.startsWith("/doc/");
+            const sharing = qs.parse(qs.extract(req.originalUrl), { sort: false }).sharing === 'true';
+            const docAccess = target.startsWith('/doc/');
             // since this is the public handler, there's no meaning of '/home' to speak of
             // since there's no user logged in, so the only viable operation
             // for a guest is to look at a shared document
-            if (sharing && docAccess) {
+            if (docAccess) {
                 serve({ req, res, ...remaining });
             } else {
-                res.redirect("/login");
+                res.redirect('/login');
             }
-        }
+        },
     });
 
     logRegistrationOutcome();
 }
 
-
 /**
  * This function can be used in two different ways. If not in release mode,
  * this is simply the logic that is invoked to start the server. In release mode,
@@ -174,9 +162,9 @@ function routeSetter({ isRelease, addSupervisedRoute, logRegistrationOutcome }:
  */
 export async function launchServer() {
     await log_execution({
-        startMessage: "\nstarting execution of preliminary functions",
-        endMessage: "completed preliminary functions\n",
-        action: preliminaryFunctions
+        startMessage: '\nstarting execution of preliminary functions',
+        endMessage: 'completed preliminary functions\n',
+        action: preliminaryFunctions,
     });
     await initializeServer(routeSetter);
 }
diff --git a/src/server/server_Initialization.ts b/src/server/server_Initialization.ts
index 24cc3b796..fd000a83c 100644
--- a/src/server/server_Initialization.ts
+++ b/src/server/server_Initialization.ts
@@ -171,54 +171,53 @@ function registerCorsProxy(server: express.Express) {
 
 function proxyServe(req: any, requrl: string, response: any) {
     const htmlBodyMemoryStream = new (require('memorystream'))();
-    req.headers.cookie = "";
-    req.pipe(request(requrl))
-        .on("error", (e: any) => console.log(`Malformed CORS url: ${requrl}`, e))
-        .on("end", () => {
-            var rewrittenHtmlBody: any = undefined;
-            req.pipe(request(requrl))
-                .on("response", (res: any) => {
-                    const headers = Object.keys(res.headers);
-                    const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
-                    headers.forEach(headerName => {
-                        const header = res.headers[headerName];
-                        if (Array.isArray(header)) {
-                            res.headers[headerName] = header.filter(h => !headerCharRegex.test(h));
-                        } else if (headerCharRegex.test(header || "")) {
-                            delete res.headers[headerName];
-                        }
-                        if (headerName === "content-encoding" && header.includes("gzip")) {
-                            try {
-                                const replacer = (match: any, href: string, offset: any, string: any) => {
-                                    return `href="${resolvedServerUrl + "/corsProxy/http" + href}"`;
-                                };
-                                const zipToStringDecoder = new (require('string_decoder').StringDecoder)('utf8');
-                                // const htmlText = zipToStringDecoder.write(zlib.gunzipSync(htmlBodyMemoryStream.read()).toString('utf8')
-                                //     .replace('<head>', '<head> <style>[id ^= "google"] { display: none; } </style>')
-                                //     .replace(/href="http([^"]*)"/g, replacer)
-                                //     .replace(/target="_blank"/g, ""));
-                                // rewrittenHtmlBody = zlib.gzipSync(htmlText);
-                                const bodyStream = htmlBodyMemoryStream.read();
-                                if (bodyStream) {
-                                    const htmlText = zipToStringDecoder.write(zlib.gunzipSync(bodyStream).toString('utf8')
-                                        .replace('<head>', '<head> <style>[id ^= "google"] { display: none; } </style>')
-                                        // .replace(/href="http([^"]*)"/g, replacer)
-                                        .replace(/target="_blank"/g, ""));
-                                    rewrittenHtmlBody = zlib.gzipSync(htmlText);
-                                } else {
-                                    console.log("EMPTY body: href");
-                                }
-                            } catch (e) { console.log(e); }
-                        }
-                    });
-                })
-                .on('data', (e: any) => {
-                    rewrittenHtmlBody && response.send(rewrittenHtmlBody);
-                    rewrittenHtmlBody = undefined;
-                })
-                .pipe(response);
-        })
-        .pipe(htmlBodyMemoryStream);
+    var retrieveHTTPBody: any;
+    const sendModifiedBody = () => {
+        const header = response.headers["content-encoding"];
+        if (header && header.includes("gzip")) {
+            try {
+                const replacer = (match: any, href: string, offset: any, string: any) => {
+                    return `href="${resolvedServerUrl + "/corsProxy/http" + href}"`;
+                };
+                const zipToStringDecoder = new (require('string_decoder').StringDecoder)('utf8');
+                const bodyStream = htmlBodyMemoryStream.read();
+                if (bodyStream) {
+                    const htmlText = zipToStringDecoder.write(zlib.gunzipSync(bodyStream).toString('utf8')
+                        .replace('<head>', '<head> <style>[id ^= "google"] { display: none; } </style>')
+                        .replace(/href="https?([^"]*)"/g, replacer)
+                        .replace(/target="_blank"/g, ""));
+                    response.send(zlib.gzipSync(htmlText));
+                } else {
+                    req.pipe(request(requrl)).pipe(response);
+                    console.log("EMPTY body:" + req.url);
+                }
+            } catch (e) {
+                console.log("EROR?: ", e);
+            }
+        } else req.pipe(request(requrl)).pipe(response);
+    };
+    retrieveHTTPBody = () => {
+        req.headers.cookie = "";
+        req.pipe(request(requrl))
+            .on("error", (e: any) => console.log(`Malformed CORS url: ${requrl}`, e))
+            .on("response", (res: any) => {
+                res.headers;
+                const headers = Object.keys(res.headers);
+                const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+                headers.forEach(headerName => {
+                    const header = res.headers[headerName];
+                    if (Array.isArray(header)) {
+                        res.headers[headerName] = header.filter(h => !headerCharRegex.test(h));
+                    } else if (headerCharRegex.test(header || "")) {
+                        delete res.headers[headerName];
+                    } else res.headers[headerName] = header;
+                });
+                response.headers = response._headers = res.headers;
+            })
+            .on("end", sendModifiedBody)
+            .pipe(htmlBodyMemoryStream);
+    };
+    retrieveHTTPBody();
 }
 
 function registerEmbeddedBrowseRelativePathHandler(server: express.Express) {
@@ -226,12 +225,17 @@ function registerEmbeddedBrowseRelativePathHandler(server: express.Express) {
         const relativeUrl = req.originalUrl;
         if (!req.user) res.redirect("/home");  // When no user is logged in, we interpret a relative URL as being a reference to something they don't have access to and redirect to /home 
         else if (!res.headersSent && req.headers.referer?.includes("corsProxy")) { // a request for something by a proxied referrer means it must be a relative reference.  So construct a proxied absolute reference here.
-            const proxiedRefererUrl = decodeURIComponent(req.headers.referer); // (e.g., http://localhost:<port>/corsProxy/https://en.wikipedia.org/wiki/Engelbart)
-            const dashServerUrl = proxiedRefererUrl.match(/.*corsProxy\//)![0]; // the dash server url (e.g.: http://localhost:<port>/corsProxy/ )
-            const actualReferUrl = proxiedRefererUrl.replace(dashServerUrl, ""); // the url of the referer without the proxy (e.g., : http:s//en.wikipedia.org/wiki/Engelbart)
-            const absoluteTargetBaseUrl = actualReferUrl.match(/http[s]?:\/\/[^\/]*/)![0]; // the base of the original url (e.g.,  https://en.wikipedia.org)
-            const redirectedProxiedUrl = dashServerUrl + encodeURIComponent(absoluteTargetBaseUrl + relativeUrl); // the new proxied full url (e..g, http://localhost:<port>/corsProxy/https://en.wikipedia.org/<somethingelse>)
-            res.redirect(redirectedProxiedUrl);
+            try {
+                const proxiedRefererUrl = decodeURIComponent(req.headers.referer); // (e.g., http://localhost:<port>/corsProxy/https://en.wikipedia.org/wiki/Engelbart)
+                const dashServerUrl = proxiedRefererUrl.match(/.*corsProxy\//)![0]; // the dash server url (e.g.: http://localhost:<port>/corsProxy/ )
+                const actualReferUrl = proxiedRefererUrl.replace(dashServerUrl, ""); // the url of the referer without the proxy (e.g., : https://en.wikipedia.org/wiki/Engelbart)
+                const absoluteTargetBaseUrl = actualReferUrl.match(/https?:\/\/[^\/]*/)![0]; // the base of the original url (e.g.,  https://en.wikipedia.org)
+                const redirectedProxiedUrl = dashServerUrl + encodeURIComponent(absoluteTargetBaseUrl + relativeUrl); // the new proxied full url (e.g., http://localhost:<port>/corsProxy/https://en.wikipedia.org/<somethingelse>)
+                if (relativeUrl.startsWith("//")) res.redirect("http:" + relativeUrl);
+                else res.redirect(redirectedProxiedUrl);
+            } catch (e) {
+                console.log("Error embed: ", e);
+            }
         } else if (relativeUrl.startsWith("/search") && !req.headers.referer?.includes("corsProxy")) { // detect search query and use default search engine
             res.redirect(req.headers.referer + "corsProxy/" + encodeURIComponent("http://www.google.com" + relativeUrl));
         } else {
diff --git a/src/server/websocket.ts b/src/server/websocket.ts
index 1b7f5919f..9b91a35a6 100644
--- a/src/server/websocket.ts
+++ b/src/server/websocket.ts
@@ -1,24 +1,24 @@
-import * as express from "express";
-import { blue, green } from "colors";
-import { createServer, Server } from "https";
-import { networkInterfaces } from "os";
+import { blue } from 'colors';
+import * as express from 'express';
+import { createServer, Server } from 'https';
+import { networkInterfaces } from 'os';
 import * as sio from 'socket.io';
-import { Socket } from "socket.io";
-import { Utils } from "../Utils";
+import { Socket } from 'socket.io';
+import { Opt } from '../fields/Doc';
+import { Utils } from '../Utils';
 import { logPort } from './ActionUtilities';
-import { timeMap } from "./ApiManagers/UserManager";
-import { GoogleCredentialsLoader, SSL } from "./apis/google/CredentialsLoader";
-import YoutubeApi from "./apis/youtube/youtubeApiSample";
-import { Client } from "./Client";
-import { Database } from "./database";
-import { DocumentsCollection } from "./IDatabase";
-import { Diff, GestureContent, MessageStore, MobileDocumentUploadContent, MobileInkOverlayContent, Transferable, Types, UpdateMobileInkOverlayPositionContent, YoutubeQueryInput, YoutubeQueryTypes } from "./Message";
-import { Search } from "./Search";
+import { timeMap } from './ApiManagers/UserManager';
+import { GoogleCredentialsLoader, SSL } from './apis/google/CredentialsLoader';
+import YoutubeApi from './apis/youtube/youtubeApiSample';
+import { initializeGuest } from './authentication/DashUserModel';
+import { Client } from './Client';
+import { Database } from './database';
+import { DocumentsCollection } from './IDatabase';
+import { Diff, GestureContent, MessageStore, MobileDocumentUploadContent, MobileInkOverlayContent, Transferable, Types, UpdateMobileInkOverlayPositionContent, YoutubeQueryInput, YoutubeQueryTypes } from './Message';
+import { Search } from './Search';
 import { resolvedPorts } from './server_Initialization';
-import { Opt } from "../fields/Doc";
 
 export namespace WebSocket {
-
     export let _socket: Socket;
     const clients: { [key: string]: Client } = {};
     export const socketMap = new Map<SocketIO.Socket, string>();
@@ -32,14 +32,14 @@ export namespace WebSocket {
                 resolvedPorts.socket = Number(socketPort);
             }
             let socketEndpoint: Opt<Server>;
-            await new Promise<void>(resolve => socketEndpoint = createServer(SSL.Credentials, app).listen(resolvedPorts.socket, resolve));
+            await new Promise<void>(resolve => (socketEndpoint = createServer(SSL.Credentials, app).listen(resolvedPorts.socket, resolve)));
             io = sio(socketEndpoint!, SSL.Credentials as any);
         } else {
             io = sio().listen(resolvedPorts.socket);
         }
-        logPort("websocket", resolvedPorts.socket);
+        logPort('websocket', resolvedPorts.socket);
 
-        io.on("connection", function (socket: Socket) {
+        io.on('connection', function (socket: Socket) {
             _socket = socket;
             socket.use((_packet, next) => {
                 const userEmail = socketMap.get(socket);
@@ -70,14 +70,14 @@ export namespace WebSocket {
                     socket.join(room);
                     console.log('Client ID ' + socket.id + ' created room ' + room);
                     socket.emit('created', room, socket.id);
-
                 } else if (numClients === 1) {
                     console.log('Client ID ' + socket.id + ' joined room ' + room);
                     socket.in(room).emit('join', room);
                     socket.join(room);
                     socket.emit('joined', room, socket.id);
                     socket.in(room).emit('ready');
-                } else { // max two clients
+                } else {
+                    // max two clients
                     socket.emit('full', room);
                 }
             });
@@ -97,10 +97,10 @@ export namespace WebSocket {
                 console.log('received bye');
             });
 
-            Utils.Emit(socket, MessageStore.Foo, "handshooken");
+            Utils.Emit(socket, MessageStore.Foo, 'handshooken');
 
             Utils.AddServerHandler(socket, MessageStore.Bar, guid => barReceived(socket, guid));
-            Utils.AddServerHandler(socket, MessageStore.SetField, (args) => setField(socket, args));
+            Utils.AddServerHandler(socket, MessageStore.SetField, args => setField(socket, args));
             Utils.AddServerHandlerCallback(socket, MessageStore.GetField, getField);
             Utils.AddServerHandlerCallback(socket, MessageStore.GetFields, getFields);
             if (isRelease) {
@@ -126,26 +126,26 @@ export namespace WebSocket {
              */
 
             disconnect = () => {
-                socket.broadcast.emit("connection_terminated", Date.now());
+                socket.broadcast.emit('connection_terminated', Date.now());
                 socket.disconnect(true);
             };
         });
     }
 
     function processGesturePoints(socket: Socket, content: GestureContent) {
-        socket.broadcast.emit("receiveGesturePoints", content);
+        socket.broadcast.emit('receiveGesturePoints', content);
     }
 
     function processOverlayTrigger(socket: Socket, content: MobileInkOverlayContent) {
-        socket.broadcast.emit("receiveOverlayTrigger", content);
+        socket.broadcast.emit('receiveOverlayTrigger', content);
     }
 
     function processUpdateOverlayPosition(socket: Socket, content: UpdateMobileInkOverlayPositionContent) {
-        socket.broadcast.emit("receiveUpdateOverlayPosition", content);
+        socket.broadcast.emit('receiveUpdateOverlayPosition', content);
     }
 
     function processMobileDocumentUpload(socket: Socket, content: MobileDocumentUploadContent) {
-        socket.broadcast.emit("receiveMobileDocumentUpload", content);
+        socket.broadcast.emit('receiveMobileDocumentUpload', content);
     }
 
     function HandleYoutubeQuery([query, callback]: [YoutubeQueryInput, (result?: any[]) => void]) {
@@ -165,27 +165,22 @@ export namespace WebSocket {
         const target: string[] = [];
         onlyFields && target.push(DocumentsCollection);
         await Database.Instance.dropSchema(...target);
-        if (process.env.DISABLE_SEARCH !== "true") {
+        if (process.env.DISABLE_SEARCH !== 'true') {
             await Search.clear();
         }
+        initializeGuest();
     }
 
     function barReceived(socket: SocketIO.Socket, userEmail: string) {
         clients[userEmail] = new Client(userEmail.toString());
         const currentdate = new Date();
-        const datetime = currentdate.getDate() + "/"
-            + (currentdate.getMonth() + 1) + "/"
-            + currentdate.getFullYear() + " @ "
-            + currentdate.getHours() + ":"
-            + currentdate.getMinutes() + ":"
-            + currentdate.getSeconds();
+        const datetime = currentdate.getDate() + '/' + (currentdate.getMonth() + 1) + '/' + currentdate.getFullYear() + ' @ ' + currentdate.getHours() + ':' + currentdate.getMinutes() + ':' + currentdate.getSeconds();
         console.log(blue(`user ${userEmail} has connected to the web socket at: ${datetime}`));
-        socketMap.set(socket, userEmail + " at " + datetime);
+        socketMap.set(socket, userEmail + ' at ' + datetime);
     }
 
     function getField([id, callback]: [string, (result?: Transferable) => void]) {
-        Database.Instance.getDocument(id, (result?: Transferable) =>
-            callback(result ? result : undefined));
+        Database.Instance.getDocument(id, (result?: Transferable) => callback(result ? result : undefined));
     }
 
     function getFields([ids, callback]: [string[], (result: Transferable[]) => void]) {
@@ -193,9 +188,9 @@ export namespace WebSocket {
     }
 
     function setField(socket: Socket, newValue: Transferable) {
-        Database.Instance.update(newValue.id, newValue, () =>
-            socket.broadcast.emit(MessageStore.SetField.Message, newValue));  // broadcast set value to all other clients
-        if (newValue.type === Types.Text) {  // if the newValue has sring type, then it's suitable for searching -- pass it to SOLR
+        Database.Instance.update(newValue.id, newValue, () => socket.broadcast.emit(MessageStore.SetField.Message, newValue)); // broadcast set value to all other clients
+        if (newValue.type === Types.Text) {
+            // if the newValue has sring type, then it's suitable for searching -- pass it to SOLR
             Search.updateDocument({ id: newValue.id, data: { set: (newValue as any).data } });
         }
     }
@@ -213,34 +208,36 @@ export namespace WebSocket {
         Database.Instance.getDocuments(ids, callback);
     }
 
-    const suffixMap: { [type: string]: (string | [string, string | ((json: any) => any)]) } = {
-        "number": "_n",
-        "string": "_t",
-        "boolean": "_b",
-        "image": ["_t", "url"],
-        "video": ["_t", "url"],
-        "pdf": ["_t", "url"],
-        "audio": ["_t", "url"],
-        "web": ["_t", "url"],
-        "map": ["_t", "url"],
-        "script": ["_t", value => value.script.originalScript],
-        "RichTextField": ["_t", value => value.Text],
-        "date": ["_d", value => new Date(value.date).toISOString()],
-        "proxy": ["_i", "fieldId"],
-        "list": ["_l", list => {
-            const results = [];
-            for (const value of list.fields) {
-                const term = ToSearchTerm(value);
-                if (term) {
-                    results.push(term.value);
+    const suffixMap: { [type: string]: string | [string, string | ((json: any) => any)] } = {
+        number: '_n',
+        string: '_t',
+        boolean: '_b',
+        image: ['_t', 'url'],
+        video: ['_t', 'url'],
+        pdf: ['_t', 'url'],
+        audio: ['_t', 'url'],
+        web: ['_t', 'url'],
+        map: ['_t', 'url'],
+        script: ['_t', value => value.script.originalScript],
+        RichTextField: ['_t', value => value.Text],
+        date: ['_d', value => new Date(value.date).toISOString()],
+        proxy: ['_i', 'fieldId'],
+        list: [
+            '_l',
+            list => {
+                const results = [];
+                for (const value of list.fields) {
+                    const term = ToSearchTerm(value);
+                    if (term) {
+                        results.push(term.value);
+                    }
                 }
-            }
-            return results.length ? results : null;
-        }]
+                return results.length ? results : null;
+            },
+        ],
     };
 
-    function ToSearchTerm(val: any): { suffix: string, value: any } | undefined {
-
+    function ToSearchTerm(val: any): { suffix: string; value: any } | undefined {
         if (val === null || val === undefined) {
             return;
         }
@@ -252,69 +249,79 @@ export namespace WebSocket {
         }
         if (Array.isArray(suffix)) {
             const accessor = suffix[1];
-            if (typeof accessor === "function") {
+            if (typeof accessor === 'function') {
                 val = accessor(val);
             } else {
                 val = val[accessor];
-
             }
             suffix = suffix[0];
-
         }
         return { suffix, value: val };
     }
 
     function getSuffix(value: string | [string, any]): string {
-        return typeof value === "string" ? value : value[0];
+        return typeof value === 'string' ? value : value[0];
     }
 
     function addToListField(socket: Socket, diff: Diff, curListItems?: Transferable): void {
-        diff.diff.$set = diff.diff.$addToSet; delete diff.diff.$addToSet;// convert add to set to a query of the current fields, and then a set of the composition of the new fields with the old ones
+        diff.diff.$set = diff.diff.$addToSet;
+        delete diff.diff.$addToSet; // convert add to set to a query of the current fields, and then a set of the composition of the new fields with the old ones
         const updatefield = Array.from(Object.keys(diff.diff.$set))[0];
         const newListItems = diff.diff.$set[updatefield]?.fields;
         if (!newListItems) {
-            console.log("Error: addToListField - no new list items");
+            console.log('Error: addToListField - no new list items');
             return;
         }
-        const curList = (curListItems as any)?.fields?.[updatefield.replace("fields.", "")]?.fields.filter((item: any) => item !== undefined) || [];
-        diff.diff.$set[updatefield].fields = [...curList, ...newListItems];//, ...newListItems.filter((newItem: any) => newItem === null || !curList.some((curItem: any) => curItem.fieldId ? curItem.fieldId === newItem.fieldId : curItem.heading ? curItem.heading === newItem.heading : curItem === newItem))];
+        const curList = (curListItems as any)?.fields?.[updatefield.replace('fields.', '')]?.fields.filter((item: any) => item !== undefined) || [];
+        diff.diff.$set[updatefield].fields = [...curList, ...newListItems]; //, ...newListItems.filter((newItem: any) => newItem === null || !curList.some((curItem: any) => curItem.fieldId ? curItem.fieldId === newItem.fieldId : curItem.heading ? curItem.heading === newItem.heading : curItem === newItem))];
         const sendBack = diff.diff.length !== diff.diff.$set[updatefield].fields.length;
         delete diff.diff.length;
-        Database.Instance.update(diff.id, diff.diff,
+        Database.Instance.update(
+            diff.id,
+            diff.diff,
             () => {
                 if (sendBack) {
-                    console.log("Warning: list modified during update. Composite list is being returned.");
+                    console.log('Warning: list modified during update. Composite list is being returned.');
                     const id = socket.id;
-                    socket.id = "";
+                    socket.id = '';
                     socket.broadcast.emit(MessageStore.UpdateField.Message, diff);
                     socket.id = id;
                 } else socket.broadcast.emit(MessageStore.UpdateField.Message, diff);
                 dispatchNextOp(diff.id);
-            }, false);
+            },
+            false
+        );
     }
 
     function remFromListField(socket: Socket, diff: Diff, curListItems?: Transferable): void {
-        diff.diff.$set = diff.diff.$remFromSet; delete diff.diff.$remFromSet;
+        diff.diff.$set = diff.diff.$remFromSet;
+        delete diff.diff.$remFromSet;
         const updatefield = Array.from(Object.keys(diff.diff.$set))[0];
         const remListItems = diff.diff.$set[updatefield].fields;
-        const curList = (curListItems as any)?.fields?.[updatefield.replace("fields.", "")]?.fields.filter((f: any) => f !== null) || [];
-        diff.diff.$set[updatefield].fields = curList?.filter((curItem: any) => !remListItems.some((remItem: any) => remItem.fieldId ? remItem.fieldId === curItem.fieldId : remItem.heading ? remItem.heading === curItem.heading : remItem === curItem));
+        const curList = (curListItems as any)?.fields?.[updatefield.replace('fields.', '')]?.fields.filter((f: any) => f !== null) || [];
+        diff.diff.$set[updatefield].fields = curList?.filter(
+            (curItem: any) => !remListItems.some((remItem: any) => (remItem.fieldId ? remItem.fieldId === curItem.fieldId : remItem.heading ? remItem.heading === curItem.heading : remItem === curItem))
+        );
         const sendBack = diff.diff.length !== diff.diff.$set[updatefield].fields.length;
         delete diff.diff.length;
-        Database.Instance.update(diff.id, diff.diff,
+        Database.Instance.update(
+            diff.id,
+            diff.diff,
             () => {
                 if (sendBack) {
-                    console.log("SEND BACK");
+                    console.log('SEND BACK');
                     const id = socket.id;
-                    socket.id = "";
+                    socket.id = '';
                     socket.broadcast.emit(MessageStore.UpdateField.Message, diff);
                     socket.id = id;
                 } else socket.broadcast.emit(MessageStore.UpdateField.Message, diff);
                 dispatchNextOp(diff.id);
-            }, false);
+            },
+            false
+        );
     }
 
-    const pendingOps = new Map<string, { diff: Diff, socket: Socket }[]>();
+    const pendingOps = new Map<string, { diff: Diff; socket: Socket }[]>();
 
     function dispatchNextOp(id: string) {
         const next = pendingOps.get(id)!.shift();
@@ -341,7 +348,7 @@ export namespace WebSocket {
     function UpdateField(socket: Socket, diff: Diff) {
         if (CurUser !== socketMap.get(socket)) {
             CurUser = socketMap.get(socket);
-            console.log("Switch User: " + CurUser);
+            console.log('Switch User: ' + CurUser);
         }
         if (pendingOps.has(diff.id)) {
             pendingOps.get(diff.id)!.push({ diff, socket });
@@ -357,24 +364,25 @@ export namespace WebSocket {
         return GetRefFieldLocal([diff.id, (result?: Transferable) => SetField(socket, diff, result)]);
     }
     function SetField(socket: Socket, diff: Diff, curListItems?: Transferable) {
-        Database.Instance.update(diff.id, diff.diff,
-            () => socket.broadcast.emit(MessageStore.UpdateField.Message, diff), false);
+        Database.Instance.update(diff.id, diff.diff, () => socket.broadcast.emit(MessageStore.UpdateField.Message, diff), false);
         const docfield = diff.diff.$set || diff.diff.$unset;
         if (docfield) {
             const update: any = { id: diff.id };
             let dynfield = false;
             for (let key in docfield) {
-                if (!key.startsWith("fields.")) continue;
+                if (!key.startsWith('fields.')) continue;
                 dynfield = true;
                 const val = docfield[key];
                 key = key.substring(7);
-                Object.values(suffixMap).forEach(suf => { update[key + getSuffix(suf)] = { set: null }; });
+                Object.values(suffixMap).forEach(suf => {
+                    update[key + getSuffix(suf)] = { set: null };
+                });
                 const term = ToSearchTerm(val);
                 if (term !== undefined) {
                     const { suffix, value } = term;
                     update[key + suffix] = { set: value };
                     if (key.endsWith('lastModified')) {
-                        update["lastModified" + suffix] = value;
+                        update['lastModified' + suffix] = value;
                     }
                 }
             }
@@ -403,6 +411,4 @@ export namespace WebSocket {
     function CreateField(newValue: any) {
         Database.Instance.insert(newValue);
     }
-
 }
-