Flowise

1
import { Request, Response, NextFunction } from 'express'
2
import { StatusCodes } from 'http-status-codes'
3
import { InternalFlowiseError } from '../../errors/internalFlowiseError'
4
import openAIAssistantVectorStoreService from '../../services/openai-assistants-vector-store'
5

6
const getAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
7
    try {
8
        if (typeof req.params === 'undefined' || !req.params.id) {
9
            throw new InternalFlowiseError(
10
                StatusCodes.PRECONDITION_FAILED,
11
                `Error: openaiAssistantsVectorStoreController.getAssistantVectorStore - id not provided!`
12
            )
13
        }
14
        if (typeof req.query === 'undefined' || !req.query.credential) {
15
            throw new InternalFlowiseError(
16
                StatusCodes.PRECONDITION_FAILED,
17
                `Error: openaiAssistantsVectorStoreController.getAssistantVectorStore - credential not provided!`
18
            )
19
        }
20
        const apiResponse = await openAIAssistantVectorStoreService.getAssistantVectorStore(req.query.credential as string, req.params.id)
21
        return res.json(apiResponse)
22
    } catch (error) {
23
        next(error)
24
    }
25
}
26

27
const listAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
28
    try {
29
        if (typeof req.query === 'undefined' || !req.query.credential) {
30
            throw new InternalFlowiseError(
31
                StatusCodes.PRECONDITION_FAILED,
32
                `Error: openaiAssistantsVectorStoreController.listAssistantVectorStore - credential not provided!`
33
            )
34
        }
35
        const apiResponse = await openAIAssistantVectorStoreService.listAssistantVectorStore(req.query.credential as string)
36
        return res.json(apiResponse)
37
    } catch (error) {
38
        next(error)
39
    }
40
}
41

42
const createAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
43
    try {
44
        if (!req.body) {
45
            throw new InternalFlowiseError(
46
                StatusCodes.PRECONDITION_FAILED,
47
                `Error: openaiAssistantsVectorStoreController.createAssistantVectorStore - body not provided!`
48
            )
49
        }
50
        if (typeof req.query === 'undefined' || !req.query.credential) {
51
            throw new InternalFlowiseError(
52
                StatusCodes.PRECONDITION_FAILED,
53
                `Error: openaiAssistantsVectorStoreController.createAssistantVectorStore - credential not provided!`
54
            )
55
        }
56
        const apiResponse = await openAIAssistantVectorStoreService.createAssistantVectorStore(req.query.credential as string, req.body)
57
        return res.json(apiResponse)
58
    } catch (error) {
59
        next(error)
60
    }
61
}
62

63
const updateAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
64
    try {
65
        if (typeof req.params === 'undefined' || !req.params.id) {
66
            throw new InternalFlowiseError(
67
                StatusCodes.PRECONDITION_FAILED,
68
                `Error: openaiAssistantsVectorStoreController.updateAssistantVectorStore - id not provided!`
69
            )
70
        }
71
        if (typeof req.query === 'undefined' || !req.query.credential) {
72
            throw new InternalFlowiseError(
73
                StatusCodes.PRECONDITION_FAILED,
74
                `Error: openaiAssistantsVectorStoreController.updateAssistantVectorStore - credential not provided!`
75
            )
76
        }
77
        if (!req.body) {
78
            throw new InternalFlowiseError(
79
                StatusCodes.PRECONDITION_FAILED,
80
                `Error: openaiAssistantsVectorStoreController.updateAssistantVectorStore - body not provided!`
81
            )
82
        }
83
        const apiResponse = await openAIAssistantVectorStoreService.updateAssistantVectorStore(
84
            req.query.credential as string,
85
            req.params.id,
86
            req.body
87
        )
88
        return res.json(apiResponse)
89
    } catch (error) {
90
        next(error)
91
    }
92
}
93

94
const deleteAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
95
    try {
96
        if (typeof req.params === 'undefined' || !req.params.id) {
97
            throw new InternalFlowiseError(
98
                StatusCodes.PRECONDITION_FAILED,
99
                `Error: openaiAssistantsVectorStoreController.deleteAssistantVectorStore - id not provided!`
100
            )
101
        }
102
        if (typeof req.query === 'undefined' || !req.query.credential) {
103
            throw new InternalFlowiseError(
104
                StatusCodes.PRECONDITION_FAILED,
105
                `Error: openaiAssistantsVectorStoreController.updateAssistantVectorStore - credential not provided!`
106
            )
107
        }
108
        const apiResponse = await openAIAssistantVectorStoreService.deleteAssistantVectorStore(
109
            req.query.credential as string,
110
            req.params.id as string
111
        )
112
        return res.json(apiResponse)
113
    } catch (error) {
114
        next(error)
115
    }
116
}
117

118
const uploadFilesToAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
119
    try {
120
        if (!req.body) {
121
            throw new InternalFlowiseError(
122
                StatusCodes.PRECONDITION_FAILED,
123
                `Error: openaiAssistantsVectorStoreController.uploadFilesToAssistantVectorStore - body not provided!`
124
            )
125
        }
126
        if (typeof req.params === 'undefined' || !req.params.id) {
127
            throw new InternalFlowiseError(
128
                StatusCodes.PRECONDITION_FAILED,
129
                `Error: openaiAssistantsVectorStoreController.uploadFilesToAssistantVectorStore - id not provided!`
130
            )
131
        }
132
        if (typeof req.query === 'undefined' || !req.query.credential) {
133
            throw new InternalFlowiseError(
134
                StatusCodes.PRECONDITION_FAILED,
135
                `Error: openaiAssistantsVectorStoreController.uploadFilesToAssistantVectorStore - credential not provided!`
136
            )
137
        }
138
        const files = req.files ?? []
139
        const uploadFiles: { filePath: string; fileName: string }[] = []
140

141
        if (Array.isArray(files)) {
142
            for (const file of files) {
143
                uploadFiles.push({
144
                    filePath: file.path,
145
                    fileName: file.originalname
146
                })
147
            }
148
        }
149

150
        const apiResponse = await openAIAssistantVectorStoreService.uploadFilesToAssistantVectorStore(
151
            req.query.credential as string,
152
            req.params.id as string,
153
            uploadFiles
154
        )
155
        return res.json(apiResponse)
156
    } catch (error) {
157
        next(error)
158
    }
159
}
160

161
const deleteFilesFromAssistantVectorStore = async (req: Request, res: Response, next: NextFunction) => {
162
    try {
163
        if (!req.body) {
164
            throw new InternalFlowiseError(
165
                StatusCodes.PRECONDITION_FAILED,
166
                `Error: openaiAssistantsVectorStoreController.deleteFilesFromAssistantVectorStore - body not provided!`
167
            )
168
        }
169
        if (typeof req.params === 'undefined' || !req.params.id) {
170
            throw new InternalFlowiseError(
171
                StatusCodes.PRECONDITION_FAILED,
172
                `Error: openaiAssistantsVectorStoreController.deleteFilesFromAssistantVectorStore - id not provided!`
173
            )
174
        }
175
        if (typeof req.query === 'undefined' || !req.query.credential) {
176
            throw new InternalFlowiseError(
177
                StatusCodes.PRECONDITION_FAILED,
178
                `Error: openaiAssistantsVectorStoreController.deleteFilesFromAssistantVectorStore - credential not provided!`
179
            )
180
        }
181

182
        const apiResponse = await openAIAssistantVectorStoreService.deleteFilesFromAssistantVectorStore(
183
            req.query.credential as string,
184
            req.params.id as string,
185
            req.body.file_ids
186
        )
187
        return res.json(apiResponse)
188
    } catch (error) {
189
        next(error)
190
    }
191
}
192

193
export default {
194
    getAssistantVectorStore,
195
    listAssistantVectorStore,
196
    createAssistantVectorStore,
197
    updateAssistantVectorStore,
198
    deleteAssistantVectorStore,
199
    uploadFilesToAssistantVectorStore,
200
    deleteFilesFromAssistantVectorStore
201
}
202