1 files changed, 131 insertions, 0 deletions
diff --git a/src/server/ApiManagers/AssistantManager.ts b/src/server/ApiManagers/AssistantManager.ts
new file mode 100644
index 000000000..82e48167a
--- /dev/null
+++ b/src/server/ApiManagers/AssistantManager.ts
@@ -0,0 +1,131 @@
+import * as fs from 'fs';
+import { createReadStream, writeFile } from 'fs';
+import OpenAI from 'openai';
+import * as path from 'path';
+import { promisify } from 'util';
+import * as uuid from 'uuid';
+import { filesDirectory, publicDirectory } from '..';
+import { Method } from '../RouteManager';
+import ApiManager, { Registration } from './ApiManager';
+
+export enum Directory {
+    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) {
+    return path.normalize(`${filesDirectory}/${directory}/${filename}`);
+}
+
+export function pathToDirectory(directory: Directory) {
+    return path.normalize(`${filesDirectory}/${directory}`);
+}
+
+export function clientPathToFile(directory: Directory, filename: string) {
+    return `/files/${directory}/${filename}`;
+}
+
+const writeFileAsync = promisify(writeFile);
+const readFileAsync = promisify(fs.readFile);
+
+export default class AssistantManager extends ApiManager {
+    protected initialize(register: Registration): void {
+        const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY, dangerouslyAllowBrowser: true });
+
+        register({
+            method: Method.POST,
+            subscription: '/uploadPDFToVectorStore',
+            secureHandler: async ({ req, res }) => {
+                const { urls, threadID, assistantID, vector_store_id } = req.body;
+
+                const csvFilesIds: string[] = [];
+                const otherFileIds: string[] = [];
+                const allFileIds: string[] = [];
+
+                const fileProcesses = urls.map(async (source: string) => {
+                    const fullPath = path.join(publicDirectory, source);
+                    const fileData = await openai.files.create({ file: createReadStream(fullPath), purpose: 'assistants' });
+                    allFileIds.push(fileData.id);
+                    if (source.endsWith('.csv')) {
+                        console.log(source);
+                        csvFilesIds.push(fileData.id);
+                    } else {
+                        openai.beta.vectorStores.files.create(vector_store_id, { file_id: fileData.id });
+                        otherFileIds.push(fileData.id);
+                    }
+                });
+                try {
+                    await Promise.all(fileProcesses).then(() => {
+                        res.send({ vector_store_id: vector_store_id, openai_file_ids: allFileIds });
+                    });
+                } catch (error) {
+                    res.status(500).send({ error: 'Failed to process files' + error });
+                }
+            },
+        });
+
+        register({
+            method: Method.POST,
+            subscription: '/downloadFileFromOpenAI',
+            secureHandler: async ({ req, res }) => {
+                const { file_id, file_name } = req.body;
+                //let files_directory: string;
+                let files_directory = '/files/openAIFiles/';
+                switch (file_name.split('.').pop()) {
+                    case 'pdf':
+                        files_directory = '/files/pdfs/';
+                        break;
+                    case 'csv':
+                        files_directory = '/files/csv/';
+                        break;
+                    case 'png':
+                    case 'jpg':
+                    case 'jpeg':
+                        files_directory = '/files/images/';
+                        break;
+                    default:
+                        break;
+                }
+
+                const directory = path.join(publicDirectory, files_directory);
+
+                if (!fs.existsSync(directory)) {
+                    fs.mkdirSync(directory);
+                }
+                const file = await openai.files.content(file_id);
+                const new_file_name = `${uuid.v4()}-${file_name}`;
+                const file_path = path.join(directory, new_file_name);
+                const file_array_buffer = await file.arrayBuffer();
+                const bufferView = new Uint8Array(file_array_buffer);
+                try {
+                    const written_file = await writeFileAsync(file_path, bufferView);
+                    console.log(written_file);
+                    console.log(file_path);
+                    console.log(file_array_buffer);
+                    console.log(bufferView);
+                    const file_object = new File([bufferView], file_name);
+                    //DashUploadUtils.upload(file_object, 'openAIFiles');
+                    res.send({ file_path: path.join(files_directory, new_file_name) });
+                    /* res.send( {
+                        source: "file",
+                        result: {
+                                  accessPaths: {
+                                      agnostic: {client: path.join('/files/openAIFiles/', `${uuid.v4()}-${file_name}`)}
+                                  },
+                                  rawText: "",
+                                  duration: 0,
+                              },
+                    } ); */
+                } catch (error) {
+                    res.status(500).send({ error: 'Failed to write file' + error });
+                }
+            },
+        });
+    }
+}