6 files changed, 181 insertions, 8 deletions

diff --git a/src/server/ApiManagers/DeleteManager.ts b/src/server/ApiManagers/DeleteManager.ts
index 88dfa6a64..be452c0ff 100644
--- a/src/server/ApiManagers/DeleteManager.ts
+++ b/src/server/ApiManagers/DeleteManager.ts
@@ -1,5 +1,5 @@
 import ApiManager, { Registration } from "./ApiManager";
-import { Method, _permission_denied } from "../RouteManager";
+import { Method, _permission_denied, PublicHandler } from "../RouteManager";
 import { WebSocket } from "../Websocket/Websocket";
 import { Database } from "../database";
 
@@ -31,6 +31,21 @@ export default class DeleteManager extends ApiManager {
             }
         });
 
+        const hi: PublicHandler = async ({ res, isRelease }) => {
+            if (isRelease) {
+                return _permission_denied(res, deletionPermissionError);
+            }
+            await Database.Instance.deleteAll('users');
+            res.redirect("/home");
+        };
+
+        // register({
+        //     method: Method.GET,
+        //     subscription: "/deleteUsers",
+        //     onValidation: hi,
+        //     onUnauthenticated: hi
+        // });
+
 
         register({
             method: Method.GET,
diff --git a/src/server/ApiManagers/SearchManager.ts b/src/server/ApiManagers/SearchManager.ts
index 316ba09ed..4ce12f9f3 100644
--- a/src/server/ApiManagers/SearchManager.ts
+++ b/src/server/ApiManagers/SearchManager.ts
@@ -8,6 +8,7 @@ import { red, cyan, yellow } from "colors";
 import RouteSubscriber from "../RouteSubscriber";
 import { exec } from "child_process";
 import { onWindows } from "..";
+import { get } from "request-promise";
 
 export class SearchManager extends ApiManager {
 
@@ -68,18 +69,25 @@ export class SearchManager extends ApiManager {
 
 export namespace SolrManager {
 
+    const command = onWindows ? "solr.cmd" : "solr";
+
     export async function SetRunning(status: boolean): Promise<boolean> {
         const args = status ? "start" : "stop -p 8983";
-        console.log(`Solr management: trying to ${args}`);
-        exec(`${onWindows ? "solr.cmd" : "solr"} ${args}`, { cwd: "./solr-8.3.1/bin" }, (error, stdout, stderr) => {
+        console.log(`solr management: trying to ${args}`);
+        exec(`${command} ${args}`, { cwd: "./solr-8.3.1/bin" }, (error, stdout, stderr) => {
             if (error) {
+                console.log(red(`solr management error: unable to ${args} server`));
                 console.log(red(error.message));
-                console.log(red(`Solr management error: unable to ${args}`));
             }
             console.log(cyan(stdout));
             console.log(yellow(stderr));
         });
-        return true;
+        try {
+            await get("http://localhost:8983");
+            return true;
+        } catch {
+            return false;
+        }
     }
 
 }
\ No newline at end of file
diff --git a/src/server/ApiManagers/SessionManager.ts b/src/server/ApiManagers/SessionManager.ts
new file mode 100644
index 000000000..f1629b8f0
--- /dev/null
+++ b/src/server/ApiManagers/SessionManager.ts
@@ -0,0 +1,58 @@
+import ApiManager, { Registration } from "./ApiManager";
+import { Method, _permission_denied, AuthorizedCore, SecureHandler } from "../RouteManager";
+import RouteSubscriber from "../RouteSubscriber";
+import { sessionAgent } from "..";
+import { DashSessionAgent } from "../DashSession/DashSessionAgent";
+
+const permissionError = "You are not authorized!";
+
+export default class SessionManager extends ApiManager {
+
+    private secureSubscriber = (root: string, ...params: string[]) => new RouteSubscriber(root).add("session_key", ...params);
+
+    private authorizedAction = (handler: SecureHandler) => {
+        return (core: AuthorizedCore) => {
+            const { req: { params }, res, isRelease } = core;
+            if (!isRelease) {
+                return res.send("This can be run only on the release server.");
+            }
+            if (params.session_key !== process.env.session_key) {
+                return _permission_denied(res, permissionError);
+            }
+            return handler(core);
+        };
+    }
+
+    protected initialize(register: Registration): void {
+
+        register({
+            method: Method.GET,
+            subscription: this.secureSubscriber("debug", "to?"),
+            secureHandler: this.authorizedAction(async ({ req: { params }, res }) => {
+                const to = params.to || DashSessionAgent.notificationRecipient;
+                const { error } = await sessionAgent.serverWorker.emit("debug", { to });
+                res.send(error ? error.message : `Your request was successful: the server captured and compressed (but did not save) a new back up. It was sent to ${to}.`);
+            })
+        });
+
+        register({
+            method: Method.GET,
+            subscription: this.secureSubscriber("backup"),
+            secureHandler: this.authorizedAction(async ({ res }) => {
+                const { error } = await sessionAgent.serverWorker.emit("backup");
+                res.send(error ? error.message : "Your request was successful: the server successfully created a new back up.");
+            })
+        });
+
+        register({
+            method: Method.GET,
+            subscription: this.secureSubscriber("kill"),
+            secureHandler: this.authorizedAction(({ res }) => {
+                res.send("Your request was successful: the server and its session have been killed.");
+                sessionAgent.killSession("an authorized user has manually ended the server session via the /kill route");
+            })
+        });
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/server/ApiManagers/UploadManager.ts b/src/server/ApiManagers/UploadManager.ts
index e76d9b7a2..e18b6826e 100644
--- a/src/server/ApiManagers/UploadManager.ts
+++ b/src/server/ApiManagers/UploadManager.ts
@@ -40,7 +40,7 @@ export default class UploadManager extends ApiManager {
 
         register({
             method: Method.POST,
-            subscription: "/upload",
+            subscription: "/uploadFormData",
             secureHandler: async ({ req, res }) => {
                 console.log("/upload register");
                 const form = new formidable.IncomingForm();
@@ -62,6 +62,18 @@ export default class UploadManager extends ApiManager {
 
         register({
             method: Method.POST,
+            subscription: "/uploadRemoteImage",
+            secureHandler: async ({ req, res }) => {
+                const { sources } = req.body;
+                if (Array.isArray(sources)) {
+                    return res.send(await Promise.all(sources.map(url => DashUploadUtils.UploadImage(url))));
+                }
+                res.send();
+            }
+        });
+
+        register({
+            method: Method.POST,
             subscription: "/uploadDoc",
             secureHandler: ({ req, res }) => {
                 const form = new formidable.IncomingForm();
@@ -170,8 +182,7 @@ export default class UploadManager extends ApiManager {
             secureHandler: async ({ req, res }) => {
                 const { source } = req.body;
                 if (typeof source === "string") {
-                    const { serverAccessPaths } = await DashUploadUtils.UploadImage(source);
-                    return res.send(await DashUploadUtils.InspectImage(serverAccessPaths[SizeSuffix.Original]));
+                    return res.send(await DashUploadUtils.InspectImage(source));
                 }
                 res.send({});
             }
diff --git a/src/server/ApiManagers/UserManager.ts b/src/server/ApiManagers/UserManager.ts
index f2ef22961..b0d868918 100644
--- a/src/server/ApiManagers/UserManager.ts
+++ b/src/server/ApiManagers/UserManager.ts
@@ -2,6 +2,8 @@ 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 "../../new_fields/Doc";
 
 export const timeMap: { [id: string]: number } = {};
 interface ActivityUnit {
@@ -37,6 +39,59 @@ export default class UserManager extends ApiManager {
         });
 
         register({
+            method: Method.POST,
+            subscription: '/internalResetPassword',
+            secureHandler: async ({ user, req, res }) => {
+                const result: any = {};
+                const { curr_pass, new_pass, new_confirm } = req.body;
+                // perhaps should assert whether curr password is entered correctly
+                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" }];
+                            res.send(result);
+                            resolve(undefined);
+                        } else {
+                            resolve(passwords_match);
+                        }
+                    });
+                });
+
+                if (validated === undefined) {
+                    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);
+                if (curr_pass === new_pass) {
+                    result.error = [{ msg: "Current and new password are the same" }];
+                }
+                // was there error in validating new passwords?
+                if (req.validationErrors()) {
+                    // was there error?
+                    result.error = req.validationErrors();
+                }
+
+                // will only change password if there are no errors.
+                if (!result.error) {
+                    user.password = new_pass;
+                    user.passwordResetToken = undefined;
+                    user.passwordResetExpires = undefined;
+                }
+
+                user.save(err => {
+                    if (err) {
+                        result.error = [{ msg: "Error while saving new password" }];
+                    }
+                });
+
+                res.send(result);
+            }
+        });
+
+
+
+        register({
             method: Method.GET,
             subscription: "/activity",
             secureHandler: ({ res }) => {
diff --git a/src/server/ApiManagers/UtilManager.ts b/src/server/ApiManagers/UtilManager.ts
index a0d0d0f4b..32aecd3c6 100644
--- a/src/server/ApiManagers/UtilManager.ts
+++ b/src/server/ApiManagers/UtilManager.ts
@@ -4,6 +4,11 @@ import { exec } from 'child_process';
 import { command_line } from "../ActionUtilities";
 import RouteSubscriber from "../RouteSubscriber";
 import { red } from "colors";
+import { IBM_Recommender } from "../../client/apis/IBM_Recommender";
+import { Recommender } from "../Recommender";
+
+const recommender = new Recommender();
+recommender.testModel();
 
 export default class UtilManager extends ApiManager {
 
@@ -23,6 +28,27 @@ export default class UtilManager extends ApiManager {
         });
 
         register({
+            method: Method.POST,
+            subscription: "/IBMAnalysis",
+            secureHandler: async ({ req, res }) => res.send(await IBM_Recommender.analyze(req.body))
+        });
+
+        register({
+            method: Method.POST,
+            subscription: "/recommender",
+            secureHandler: async ({ req, res }) => {
+                const keyphrases = req.body.keyphrases;
+                const wordvecs = await recommender.vectorize(keyphrases);
+                let embedding: Float32Array = new Float32Array();
+                if (wordvecs && wordvecs.dataSync()) {
+                    embedding = wordvecs.dataSync() as Float32Array;
+                }
+                res.send(embedding);
+            }
+        });
+
+
+        register({
             method: Method.GET,
             subscription: "/pull",
             secureHandler: async ({ res }) => {