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

1 files changed, 0 insertions, 200 deletions

diff --git a/src/server/ApiManagers/SearchManager.ts b/src/server/ApiManagers/SearchManager.ts
deleted file mode 100644
index 684b49eaf..000000000
--- a/src/server/ApiManagers/SearchManager.ts
+++ /dev/null
@@ -1,200 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { exec } from 'child_process';
-import { cyan, green, red, yellow } from 'colors';
-import { logExecution } from '../ActionUtilities';
-import { Method } from '../RouteManager';
-import RouteSubscriber from '../RouteSubscriber';
-import { Search } from '../Search';
-import { Database } from '../database';
-import ApiManager, { Registration } from './ApiManager';
-
-export class SearchManager extends ApiManager {
-    protected initialize(register: Registration): void {
-        register({
-            method: Method.GET,
-            subscription: new RouteSubscriber('solr').add('action'),
-            secureHandler: async ({ req, res }) => {
-                const { action } = req.params;
-                switch (action) {
-                    case 'start':
-                    case 'stop':
-                        {
-                            const status = req.params.action === 'start';
-                            SolrManager.SetRunning(status);
-                        }
-                        break;
-                    case 'update':
-                        await SolrManager.update();
-                        break;
-                    default:
-                        console.log(yellow(`${action} is an unknown solr operation.`));
-                }
-                res.redirect('/home');
-            },
-        });
-
-        register({
-            method: Method.GET,
-            subscription: '/dashsearch',
-            secureHandler: async ({ req, res }) => {
-                const solrQuery: any = {};
-                ['q', 'fq', 'start', 'rows', 'sort', 'hl.maxAnalyzedChars', 'hl', 'hl.fl'].forEach(key => {
-                    solrQuery[key] = req.query[key];
-                });
-                if (solrQuery.q === undefined) {
-                    res.send([]);
-                    return;
-                }
-                const results = await Search.search(solrQuery);
-                res.send(results);
-            },
-        });
-    }
-}
-
-export namespace SolrManager {
-    export function SetRunning(status: boolean) {
-        const args = status ? 'start' : 'stop -p 8983';
-        console.log(`solr management: trying to ${args}`);
-        exec(`solr ${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(cyan(stdout));
-            console.log(yellow(stderr));
-        });
-        if (status) {
-            console.log(cyan('Start script is executing: please allow 15 seconds for solr to start on port 8983.'));
-        }
-    }
-
-    export async function update() {
-        console.log(green('Beginning update...'));
-        await logExecution<void>({
-            startMessage: 'Clearing existing Solr information...',
-            endMessage: 'Solr information successfully cleared',
-            action: Search.clear,
-            color: cyan,
-        });
-        const cursor = await logExecution({
-            startMessage: 'Connecting to and querying for all documents from database...',
-            endMessage: ({ result, error }) => {
-                const success = error === null && result !== undefined;
-                if (!success) {
-                    console.log(red('Unable to connect to the database.'));
-                    process.exit(0);
-                }
-                return 'Connection successful and query complete';
-            },
-            action: () => Database.Instance.query({}),
-            color: yellow,
-        });
-        const updates: any[] = [];
-        let numDocs = 0;
-        function updateDoc(doc: any) {
-            numDocs++;
-            if (numDocs % 50 === 0) {
-                console.log(`Batch of 50 complete, total of ${numDocs}`);
-            }
-            if (doc.__type !== 'Doc') {
-                return;
-            }
-            const { fields } = doc;
-            if (!fields) {
-                return;
-            }
-            const update2: any = { id: doc._id };
-            let dynfield = false;
-            fields.forEach((key: any) => {
-                const value = fields[key];
-                const term = ToSearchTerm(value);
-                if (term !== undefined) {
-                    const { suffix, value: tvalue } = term;
-                    if (key.endsWith('modificationDate')) {
-                        update2['modificationDate' + suffix] = tvalue;
-                    }
-                    update2[key + suffix] = value;
-                    dynfield = true;
-                }
-            });
-            if (dynfield) {
-                updates.push(update2);
-            }
-        }
-        await cursor?.forEach(updateDoc);
-        const result = await logExecution({
-            startMessage: `Dispatching updates for ${updates.length} documents`,
-            endMessage: 'Dispatched updates complete',
-            action: () => Search.updateDocuments(updates),
-            color: cyan,
-        });
-        try {
-            if (result) {
-                const { status } = JSON.parse(result).responseHeader;
-                console.log(status ? red(`Failed with status code (${status})`) : green('Success!'));
-            } else {
-                console.log(red('Solr is likely not running!'));
-            }
-        } catch (e) {
-            console.log(red('Error:'));
-            console.log(e);
-            console.log('\n');
-        }
-        await cursor?.close();
-    }
-
-    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'],
-        date: ['_d', value => new Date(value.date).toISOString()],
-        proxy: ['_i', 'fieldId'],
-        prefetch_proxy: ['_i', 'fieldId'],
-        list: [
-            '_l',
-            list => {
-                const results = [];
-                // eslint-disable-next-line no-restricted-syntax
-                for (const value of list.fields) {
-                    const term = ToSearchTerm(value);
-                    if (term) {
-                        results.push(term.value);
-                    }
-                }
-                return results.length ? results : null;
-            },
-        ],
-    };
-
-    function ToSearchTerm(valIn: any): { suffix: string; value: any } | undefined {
-        let val = valIn;
-        if (val === null || val === undefined) {
-            return undefined;
-        }
-        const type = val.__type || typeof val;
-        let suffix = suffixMap[type];
-        if (!suffix) {
-            return undefined;
-        }
-
-        if (Array.isArray(suffix)) {
-            const accessor = suffix[1];
-            if (typeof accessor === 'function') {
-                val = accessor(val);
-            } else {
-                val = val[accessor];
-            }
-            // eslint-disable-next-line prefer-destructuring
-            suffix = suffix[0];
-        }
-
-        return { suffix, value: val };
-    }
-}