OpenRAG 0.1.25__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- agent.py +669 -0
- api/__init__.py +0 -0
- api/auth.py +84 -0
- api/chat.py +181 -0
- api/connector_router.py +78 -0
- api/connectors.py +437 -0
- api/docling.py +120 -0
- api/documents.py +103 -0
- api/flows.py +66 -0
- api/knowledge_filter.py +468 -0
- api/langflow_files.py +296 -0
- api/models.py +148 -0
- api/nudges.py +44 -0
- api/oidc.py +111 -0
- api/router.py +206 -0
- api/search.py +53 -0
- api/settings.py +762 -0
- api/tasks.py +35 -0
- api/upload.py +202 -0
- auth_context.py +75 -0
- auth_middleware.py +84 -0
- config/__init__.py +0 -0
- config/config_manager.py +214 -0
- config/settings.py +602 -0
- connectors/__init__.py +11 -0
- connectors/base.py +149 -0
- connectors/connection_manager.py +532 -0
- connectors/google_drive/__init__.py +4 -0
- connectors/google_drive/connector.py +1112 -0
- connectors/google_drive/oauth.py +152 -0
- connectors/langflow_connector_service.py +342 -0
- connectors/onedrive/__init__.py +4 -0
- connectors/onedrive/connector.py +494 -0
- connectors/onedrive/oauth.py +322 -0
- connectors/service.py +402 -0
- connectors/sharepoint/__init__.py +4 -0
- connectors/sharepoint/connector.py +567 -0
- connectors/sharepoint/oauth.py +329 -0
- main.py +1186 -0
- models/__init__.py +0 -0
- models/processors.py +769 -0
- models/tasks.py +46 -0
- openrag-0.1.25.dist-info/METADATA +166 -0
- openrag-0.1.25.dist-info/RECORD +112 -0
- openrag-0.1.25.dist-info/WHEEL +5 -0
- openrag-0.1.25.dist-info/entry_points.txt +2 -0
- openrag-0.1.25.dist-info/licenses/LICENSE +201 -0
- openrag-0.1.25.dist-info/top_level.txt +12 -0
- services/__init__.py +0 -0
- services/auth_service.py +401 -0
- services/chat_service.py +537 -0
- services/conversation_persistence_service.py +130 -0
- services/document_service.py +213 -0
- services/flows_service.py +906 -0
- services/knowledge_filter_service.py +347 -0
- services/langflow_file_service.py +338 -0
- services/langflow_history_service.py +172 -0
- services/langflow_mcp_service.py +275 -0
- services/models_service.py +372 -0
- services/monitor_service.py +305 -0
- services/search_service.py +477 -0
- services/session_ownership_service.py +109 -0
- services/task_service.py +435 -0
- session_manager.py +235 -0
- tui/__init__.py +8 -0
- tui/_assets/docker-compose-cpu.yml +127 -0
- tui/_assets/docker-compose.yml +126 -0
- tui/_assets/documents/docling.pdf +0 -0
- tui/_assets/documents/ibm_anthropic.pdf +0 -0
- tui/_assets/documents/openrag-documentation.pdf +0 -0
- tui/_assets/documents/warmup_ocr.pdf +0 -0
- tui/_assets/flows/components/ollama_embedding.json +142 -0
- tui/_assets/flows/components/ollama_llm.json +682 -0
- tui/_assets/flows/components/ollama_llm_text.json +683 -0
- tui/_assets/flows/components/watsonx_embedding.json +207 -0
- tui/_assets/flows/components/watsonx_llm.json +521 -0
- tui/_assets/flows/components/watsonx_llm_text.json +521 -0
- tui/_assets/flows/ingestion_flow.json +4199 -0
- tui/_assets/flows/openrag_agent.json +2875 -0
- tui/_assets/flows/openrag_nudges.json +2350 -0
- tui/_assets/flows/openrag_url_mcp.json +3621 -0
- tui/main.py +521 -0
- tui/managers/__init__.py +1 -0
- tui/managers/container_manager.py +892 -0
- tui/managers/docling_manager.py +488 -0
- tui/managers/env_manager.py +442 -0
- tui/screens/__init__.py +1 -0
- tui/screens/config.py +690 -0
- tui/screens/diagnostics.py +572 -0
- tui/screens/logs.py +356 -0
- tui/screens/monitor.py +858 -0
- tui/screens/welcome.py +446 -0
- tui/utils/__init__.py +1 -0
- tui/utils/clipboard.py +50 -0
- tui/utils/platform.py +209 -0
- tui/utils/validation.py +139 -0
- tui/widgets/__init__.py +3 -0
- tui/widgets/command_modal.py +379 -0
- tui/widgets/diagnostics_notification.py +40 -0
- tui/widgets/error_notification.py +40 -0
- tui/widgets/waves.py +146 -0
- utils/__init__.py +0 -0
- utils/container_utils.py +298 -0
- utils/document_processing.py +370 -0
- utils/embedding_fields.py +178 -0
- utils/embeddings.py +198 -0
- utils/file_utils.py +60 -0
- utils/gpu_detection.py +47 -0
- utils/hash_utils.py +76 -0
- utils/logging_config.py +117 -0
- utils/opensearch_queries.py +55 -0
- utils/process_pool.py +13 -0
api/flows.py
ADDED
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
"""Reset Flow API endpoints"""
|
|
2
|
+
|
|
3
|
+
from starlette.requests import Request
|
|
4
|
+
from starlette.responses import JSONResponse
|
|
5
|
+
from utils.logging_config import get_logger
|
|
6
|
+
|
|
7
|
+
logger = get_logger(__name__)
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
async def reset_flow_endpoint(
|
|
11
|
+
request: Request,
|
|
12
|
+
chat_service,
|
|
13
|
+
):
|
|
14
|
+
"""Reset a Langflow flow by type (nudges, retrieval, or ingest)"""
|
|
15
|
+
|
|
16
|
+
# Get flow type from path parameter
|
|
17
|
+
flow_type = request.path_params.get("flow_type")
|
|
18
|
+
|
|
19
|
+
if flow_type not in ["nudges", "retrieval", "ingest"]:
|
|
20
|
+
return JSONResponse(
|
|
21
|
+
{
|
|
22
|
+
"success": False,
|
|
23
|
+
"error": "Invalid flow type. Must be 'nudges', 'retrieval', or 'ingest'"
|
|
24
|
+
},
|
|
25
|
+
status_code=400
|
|
26
|
+
)
|
|
27
|
+
|
|
28
|
+
try:
|
|
29
|
+
# Get user information from session for logging
|
|
30
|
+
|
|
31
|
+
# Call the chat service to reset the flow
|
|
32
|
+
result = await chat_service.reset_langflow_flow(flow_type)
|
|
33
|
+
|
|
34
|
+
if result.get("success"):
|
|
35
|
+
logger.info(
|
|
36
|
+
f"Flow reset successful",
|
|
37
|
+
flow_type=flow_type,
|
|
38
|
+
flow_id=result.get("flow_id")
|
|
39
|
+
)
|
|
40
|
+
return JSONResponse(result, status_code=200)
|
|
41
|
+
else:
|
|
42
|
+
logger.error(
|
|
43
|
+
f"Flow reset failed",
|
|
44
|
+
flow_type=flow_type,
|
|
45
|
+
error=result.get("error")
|
|
46
|
+
)
|
|
47
|
+
return JSONResponse(result, status_code=500)
|
|
48
|
+
|
|
49
|
+
except ValueError as e:
|
|
50
|
+
logger.error(f"Invalid request for flow reset", error=str(e))
|
|
51
|
+
return JSONResponse(
|
|
52
|
+
{
|
|
53
|
+
"success": False,
|
|
54
|
+
"error": str(e)
|
|
55
|
+
},
|
|
56
|
+
status_code=400
|
|
57
|
+
)
|
|
58
|
+
except Exception as e:
|
|
59
|
+
logger.error(f"Unexpected error in flow reset", error=str(e))
|
|
60
|
+
return JSONResponse(
|
|
61
|
+
{
|
|
62
|
+
"success": False,
|
|
63
|
+
"error": f"Internal server error: {str(e)}"
|
|
64
|
+
},
|
|
65
|
+
status_code=500
|
|
66
|
+
)
|
api/knowledge_filter.py
ADDED
|
@@ -0,0 +1,468 @@
|
|
|
1
|
+
from starlette.requests import Request
|
|
2
|
+
from starlette.responses import JSONResponse
|
|
3
|
+
import uuid
|
|
4
|
+
import json
|
|
5
|
+
from datetime import datetime
|
|
6
|
+
from utils.logging_config import get_logger
|
|
7
|
+
|
|
8
|
+
logger = get_logger(__name__)
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
async def create_knowledge_filter(
|
|
12
|
+
request: Request, knowledge_filter_service, session_manager
|
|
13
|
+
):
|
|
14
|
+
"""Create a new knowledge filter"""
|
|
15
|
+
payload = await request.json()
|
|
16
|
+
|
|
17
|
+
name = payload.get("name")
|
|
18
|
+
if not name:
|
|
19
|
+
return JSONResponse(
|
|
20
|
+
{"error": "Knowledge filter name is required"}, status_code=400
|
|
21
|
+
)
|
|
22
|
+
|
|
23
|
+
description = payload.get("description", "")
|
|
24
|
+
query_data = payload.get("queryData")
|
|
25
|
+
if not query_data:
|
|
26
|
+
return JSONResponse({"error": "Query data is required"}, status_code=400)
|
|
27
|
+
|
|
28
|
+
user = request.state.user
|
|
29
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
30
|
+
|
|
31
|
+
# Create knowledge filter document
|
|
32
|
+
filter_id = str(uuid.uuid4())
|
|
33
|
+
filter_doc = {
|
|
34
|
+
"id": filter_id,
|
|
35
|
+
"name": name,
|
|
36
|
+
"description": description,
|
|
37
|
+
"query_data": query_data, # Store the full search query JSON
|
|
38
|
+
"owner": user.user_id,
|
|
39
|
+
"allowed_users": payload.get("allowedUsers", []), # ACL field for future use
|
|
40
|
+
"allowed_groups": payload.get("allowedGroups", []), # ACL field for future use
|
|
41
|
+
"created_at": datetime.utcnow().isoformat(),
|
|
42
|
+
"updated_at": datetime.utcnow().isoformat(),
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
result = await knowledge_filter_service.create_knowledge_filter(
|
|
46
|
+
filter_doc, user_id=user.user_id, jwt_token=jwt_token
|
|
47
|
+
)
|
|
48
|
+
|
|
49
|
+
# Return appropriate HTTP status codes
|
|
50
|
+
if result.get("success"):
|
|
51
|
+
return JSONResponse(result, status_code=201) # Created
|
|
52
|
+
else:
|
|
53
|
+
error_msg = result.get("error", "")
|
|
54
|
+
if (
|
|
55
|
+
"AuthenticationException" in error_msg
|
|
56
|
+
or "access denied" in error_msg.lower()
|
|
57
|
+
):
|
|
58
|
+
return JSONResponse(result, status_code=403)
|
|
59
|
+
else:
|
|
60
|
+
return JSONResponse(result, status_code=500)
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
async def search_knowledge_filters(
|
|
64
|
+
request: Request, knowledge_filter_service, session_manager
|
|
65
|
+
):
|
|
66
|
+
"""Search for knowledge filters by name, description, or query content"""
|
|
67
|
+
payload = await request.json()
|
|
68
|
+
|
|
69
|
+
query = payload.get("query", "")
|
|
70
|
+
limit = payload.get("limit", 20)
|
|
71
|
+
|
|
72
|
+
user = request.state.user
|
|
73
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
74
|
+
|
|
75
|
+
result = await knowledge_filter_service.search_knowledge_filters(
|
|
76
|
+
query, user_id=user.user_id, jwt_token=jwt_token, limit=limit
|
|
77
|
+
)
|
|
78
|
+
|
|
79
|
+
# Return appropriate HTTP status codes
|
|
80
|
+
if result.get("success"):
|
|
81
|
+
return JSONResponse(result, status_code=200)
|
|
82
|
+
else:
|
|
83
|
+
error_msg = result.get("error", "")
|
|
84
|
+
if (
|
|
85
|
+
"AuthenticationException" in error_msg
|
|
86
|
+
or "access denied" in error_msg.lower()
|
|
87
|
+
):
|
|
88
|
+
return JSONResponse(result, status_code=403)
|
|
89
|
+
else:
|
|
90
|
+
return JSONResponse(result, status_code=500)
|
|
91
|
+
|
|
92
|
+
|
|
93
|
+
async def get_knowledge_filter(
|
|
94
|
+
request: Request, knowledge_filter_service, session_manager
|
|
95
|
+
):
|
|
96
|
+
"""Get a specific knowledge filter by ID"""
|
|
97
|
+
filter_id = request.path_params.get("filter_id")
|
|
98
|
+
if not filter_id:
|
|
99
|
+
return JSONResponse(
|
|
100
|
+
{"error": "Knowledge filter ID is required"}, status_code=400
|
|
101
|
+
)
|
|
102
|
+
|
|
103
|
+
user = request.state.user
|
|
104
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
105
|
+
|
|
106
|
+
result = await knowledge_filter_service.get_knowledge_filter(
|
|
107
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
108
|
+
)
|
|
109
|
+
|
|
110
|
+
# Return appropriate HTTP status codes
|
|
111
|
+
if result.get("success"):
|
|
112
|
+
return JSONResponse(result, status_code=200)
|
|
113
|
+
else:
|
|
114
|
+
error_msg = result.get("error", "")
|
|
115
|
+
if "not found" in error_msg.lower():
|
|
116
|
+
return JSONResponse(result, status_code=404)
|
|
117
|
+
elif (
|
|
118
|
+
"AuthenticationException" in error_msg
|
|
119
|
+
or "access denied" in error_msg.lower()
|
|
120
|
+
):
|
|
121
|
+
return JSONResponse(result, status_code=403)
|
|
122
|
+
else:
|
|
123
|
+
return JSONResponse(result, status_code=500)
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
async def update_knowledge_filter(
|
|
127
|
+
request: Request, knowledge_filter_service, session_manager
|
|
128
|
+
):
|
|
129
|
+
"""Update an existing knowledge filter by delete + recreate (due to DLS limitations)"""
|
|
130
|
+
filter_id = request.path_params.get("filter_id")
|
|
131
|
+
if not filter_id:
|
|
132
|
+
return JSONResponse(
|
|
133
|
+
{"error": "Knowledge filter ID is required"}, status_code=400
|
|
134
|
+
)
|
|
135
|
+
|
|
136
|
+
payload = await request.json()
|
|
137
|
+
|
|
138
|
+
user = request.state.user
|
|
139
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
140
|
+
|
|
141
|
+
# First, get the existing knowledge filter
|
|
142
|
+
existing_result = await knowledge_filter_service.get_knowledge_filter(
|
|
143
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
144
|
+
)
|
|
145
|
+
if not existing_result.get("success"):
|
|
146
|
+
return JSONResponse(
|
|
147
|
+
{"error": "Knowledge filter not found or access denied"}, status_code=404
|
|
148
|
+
)
|
|
149
|
+
|
|
150
|
+
existing_filter = existing_result["filter"]
|
|
151
|
+
|
|
152
|
+
# Delete the existing knowledge filter
|
|
153
|
+
delete_result = await knowledge_filter_service.delete_knowledge_filter(
|
|
154
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
155
|
+
)
|
|
156
|
+
if not delete_result.get("success"):
|
|
157
|
+
return JSONResponse(
|
|
158
|
+
{"error": "Failed to delete existing knowledge filter"}, status_code=500
|
|
159
|
+
)
|
|
160
|
+
|
|
161
|
+
# Create updated knowledge filter document with same ID
|
|
162
|
+
updated_filter = {
|
|
163
|
+
"id": filter_id,
|
|
164
|
+
"name": payload.get("name", existing_filter["name"]),
|
|
165
|
+
"description": payload.get("description", existing_filter["description"]),
|
|
166
|
+
"query_data": payload.get("queryData", existing_filter["query_data"]),
|
|
167
|
+
"owner": existing_filter["owner"],
|
|
168
|
+
"allowed_users": payload.get(
|
|
169
|
+
"allowedUsers", existing_filter.get("allowed_users", [])
|
|
170
|
+
),
|
|
171
|
+
"allowed_groups": payload.get(
|
|
172
|
+
"allowedGroups", existing_filter.get("allowed_groups", [])
|
|
173
|
+
),
|
|
174
|
+
"created_at": existing_filter["created_at"], # Preserve original creation time
|
|
175
|
+
"updated_at": datetime.utcnow().isoformat(),
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
# Recreate the knowledge filter
|
|
179
|
+
result = await knowledge_filter_service.create_knowledge_filter(
|
|
180
|
+
updated_filter, user_id=user.user_id, jwt_token=jwt_token
|
|
181
|
+
)
|
|
182
|
+
|
|
183
|
+
# Return appropriate HTTP status codes
|
|
184
|
+
if result.get("success"):
|
|
185
|
+
return JSONResponse(result, status_code=200) # Updated successfully
|
|
186
|
+
else:
|
|
187
|
+
error_msg = result.get("error", "")
|
|
188
|
+
if (
|
|
189
|
+
"AuthenticationException" in error_msg
|
|
190
|
+
or "access denied" in error_msg.lower()
|
|
191
|
+
):
|
|
192
|
+
return JSONResponse(result, status_code=403)
|
|
193
|
+
else:
|
|
194
|
+
return JSONResponse(result, status_code=500)
|
|
195
|
+
|
|
196
|
+
|
|
197
|
+
async def delete_knowledge_filter(
|
|
198
|
+
request: Request, knowledge_filter_service, session_manager
|
|
199
|
+
):
|
|
200
|
+
"""Delete a knowledge filter"""
|
|
201
|
+
filter_id = request.path_params.get("filter_id")
|
|
202
|
+
if not filter_id:
|
|
203
|
+
return JSONResponse(
|
|
204
|
+
{"error": "Knowledge filter ID is required"}, status_code=400
|
|
205
|
+
)
|
|
206
|
+
|
|
207
|
+
user = request.state.user
|
|
208
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
209
|
+
|
|
210
|
+
result = await knowledge_filter_service.delete_knowledge_filter(
|
|
211
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
212
|
+
)
|
|
213
|
+
|
|
214
|
+
# Return appropriate HTTP status codes
|
|
215
|
+
if result.get("success"):
|
|
216
|
+
return JSONResponse(result, status_code=200)
|
|
217
|
+
else:
|
|
218
|
+
error_msg = result.get("error", "")
|
|
219
|
+
if "not found" in error_msg.lower() or "already deleted" in error_msg.lower():
|
|
220
|
+
return JSONResponse(result, status_code=404)
|
|
221
|
+
elif (
|
|
222
|
+
"access denied" in error_msg.lower()
|
|
223
|
+
or "insufficient permissions" in error_msg.lower()
|
|
224
|
+
):
|
|
225
|
+
return JSONResponse(result, status_code=403)
|
|
226
|
+
else:
|
|
227
|
+
return JSONResponse(result, status_code=500)
|
|
228
|
+
|
|
229
|
+
|
|
230
|
+
async def subscribe_to_knowledge_filter(
|
|
231
|
+
request: Request, knowledge_filter_service, monitor_service, session_manager
|
|
232
|
+
):
|
|
233
|
+
"""Create a subscription to a knowledge filter"""
|
|
234
|
+
filter_id = request.path_params.get("filter_id")
|
|
235
|
+
if not filter_id:
|
|
236
|
+
return JSONResponse(
|
|
237
|
+
{"error": "Knowledge filter ID is required"}, status_code=400
|
|
238
|
+
)
|
|
239
|
+
|
|
240
|
+
payload = await request.json()
|
|
241
|
+
user = request.state.user
|
|
242
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
243
|
+
|
|
244
|
+
# Get the knowledge filter to validate it exists and get its details
|
|
245
|
+
filter_result = await knowledge_filter_service.get_knowledge_filter(
|
|
246
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
247
|
+
)
|
|
248
|
+
if not filter_result.get("success"):
|
|
249
|
+
return JSONResponse(
|
|
250
|
+
{"error": "Knowledge filter not found or access denied"}, status_code=404
|
|
251
|
+
)
|
|
252
|
+
|
|
253
|
+
filter_doc = filter_result["filter"]
|
|
254
|
+
|
|
255
|
+
# Create the monitor for this subscription
|
|
256
|
+
monitor_result = await monitor_service.create_knowledge_filter_monitor(
|
|
257
|
+
filter_id=filter_id,
|
|
258
|
+
filter_name=filter_doc["name"],
|
|
259
|
+
query_data=filter_doc["query_data"],
|
|
260
|
+
user_id=user.user_id,
|
|
261
|
+
jwt_token=jwt_token,
|
|
262
|
+
notification_config=payload.get("notification_config"),
|
|
263
|
+
)
|
|
264
|
+
|
|
265
|
+
if not monitor_result.get("success"):
|
|
266
|
+
return JSONResponse(monitor_result, status_code=500)
|
|
267
|
+
|
|
268
|
+
# Store subscription info in the knowledge filter document
|
|
269
|
+
subscription_data = {
|
|
270
|
+
"subscription_id": monitor_result["subscription_id"],
|
|
271
|
+
"monitor_id": monitor_result["monitor_id"],
|
|
272
|
+
"webhook_url": monitor_result["webhook_url"],
|
|
273
|
+
"created_at": datetime.utcnow().isoformat(),
|
|
274
|
+
"notification_config": payload.get("notification_config", {}),
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
# Add subscription to the filter document
|
|
278
|
+
update_result = await knowledge_filter_service.add_subscription(
|
|
279
|
+
filter_id, subscription_data, user_id=user.user_id, jwt_token=jwt_token
|
|
280
|
+
)
|
|
281
|
+
|
|
282
|
+
if update_result.get("success"):
|
|
283
|
+
return JSONResponse(
|
|
284
|
+
{
|
|
285
|
+
"success": True,
|
|
286
|
+
"subscription_id": monitor_result["subscription_id"],
|
|
287
|
+
"monitor_id": monitor_result["monitor_id"],
|
|
288
|
+
"webhook_url": monitor_result["webhook_url"],
|
|
289
|
+
"message": f"Successfully subscribed to knowledge filter: {filter_doc['name']}",
|
|
290
|
+
},
|
|
291
|
+
status_code=201,
|
|
292
|
+
)
|
|
293
|
+
else:
|
|
294
|
+
# If we can't update the filter doc, clean up the monitor
|
|
295
|
+
await monitor_service.delete_monitor(
|
|
296
|
+
monitor_result["monitor_id"], user.user_id, jwt_token
|
|
297
|
+
)
|
|
298
|
+
return JSONResponse({"error": "Failed to create subscription"}, status_code=500)
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
async def list_knowledge_filter_subscriptions(
|
|
302
|
+
request: Request, knowledge_filter_service, session_manager
|
|
303
|
+
):
|
|
304
|
+
"""List subscriptions for a knowledge filter"""
|
|
305
|
+
filter_id = request.path_params.get("filter_id")
|
|
306
|
+
if not filter_id:
|
|
307
|
+
return JSONResponse(
|
|
308
|
+
{"error": "Knowledge filter ID is required"}, status_code=400
|
|
309
|
+
)
|
|
310
|
+
|
|
311
|
+
user = request.state.user
|
|
312
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
313
|
+
|
|
314
|
+
result = await knowledge_filter_service.get_filter_subscriptions(
|
|
315
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
316
|
+
)
|
|
317
|
+
|
|
318
|
+
if result.get("success"):
|
|
319
|
+
return JSONResponse(result, status_code=200)
|
|
320
|
+
else:
|
|
321
|
+
error_msg = result.get("error", "")
|
|
322
|
+
if "not found" in error_msg.lower():
|
|
323
|
+
return JSONResponse(result, status_code=404)
|
|
324
|
+
elif "access denied" in error_msg.lower():
|
|
325
|
+
return JSONResponse(result, status_code=403)
|
|
326
|
+
else:
|
|
327
|
+
return JSONResponse(result, status_code=500)
|
|
328
|
+
|
|
329
|
+
|
|
330
|
+
async def cancel_knowledge_filter_subscription(
|
|
331
|
+
request: Request, knowledge_filter_service, monitor_service, session_manager
|
|
332
|
+
):
|
|
333
|
+
"""Cancel a subscription to a knowledge filter"""
|
|
334
|
+
filter_id = request.path_params.get("filter_id")
|
|
335
|
+
subscription_id = request.path_params.get("subscription_id")
|
|
336
|
+
|
|
337
|
+
if not filter_id or not subscription_id:
|
|
338
|
+
return JSONResponse(
|
|
339
|
+
{"error": "Knowledge filter ID and subscription ID are required"},
|
|
340
|
+
status_code=400,
|
|
341
|
+
)
|
|
342
|
+
|
|
343
|
+
user = request.state.user
|
|
344
|
+
jwt_token = session_manager.get_effective_jwt_token(user.user_id, request.state.jwt_token)
|
|
345
|
+
|
|
346
|
+
# Get subscription details to find the monitor ID
|
|
347
|
+
subscriptions_result = await knowledge_filter_service.get_filter_subscriptions(
|
|
348
|
+
filter_id, user_id=user.user_id, jwt_token=jwt_token
|
|
349
|
+
)
|
|
350
|
+
if not subscriptions_result.get("success"):
|
|
351
|
+
return JSONResponse(
|
|
352
|
+
{"error": "Knowledge filter not found or access denied"}, status_code=404
|
|
353
|
+
)
|
|
354
|
+
|
|
355
|
+
# Find the specific subscription
|
|
356
|
+
subscription = None
|
|
357
|
+
for sub in subscriptions_result.get("subscriptions", []):
|
|
358
|
+
if sub.get("subscription_id") == subscription_id:
|
|
359
|
+
subscription = sub
|
|
360
|
+
break
|
|
361
|
+
|
|
362
|
+
if not subscription:
|
|
363
|
+
return JSONResponse({"error": "Subscription not found"}, status_code=404)
|
|
364
|
+
|
|
365
|
+
# Delete the monitor
|
|
366
|
+
monitor_result = await monitor_service.delete_monitor(
|
|
367
|
+
subscription["monitor_id"], user.user_id, jwt_token
|
|
368
|
+
)
|
|
369
|
+
|
|
370
|
+
# Remove subscription from the filter document
|
|
371
|
+
remove_result = await knowledge_filter_service.remove_subscription(
|
|
372
|
+
filter_id, subscription_id, user_id=user.user_id, jwt_token=jwt_token
|
|
373
|
+
)
|
|
374
|
+
|
|
375
|
+
if remove_result.get("success"):
|
|
376
|
+
return JSONResponse(
|
|
377
|
+
{"success": True, "message": "Subscription cancelled successfully"},
|
|
378
|
+
status_code=200,
|
|
379
|
+
)
|
|
380
|
+
else:
|
|
381
|
+
return JSONResponse({"error": "Failed to cancel subscription"}, status_code=500)
|
|
382
|
+
|
|
383
|
+
|
|
384
|
+
async def knowledge_filter_webhook(
|
|
385
|
+
request: Request, knowledge_filter_service, session_manager
|
|
386
|
+
):
|
|
387
|
+
"""Handle webhook notifications from OpenSearch monitors"""
|
|
388
|
+
filter_id = request.path_params.get("filter_id")
|
|
389
|
+
subscription_id = request.path_params.get("subscription_id")
|
|
390
|
+
|
|
391
|
+
if not filter_id or not subscription_id:
|
|
392
|
+
return JSONResponse({"error": "Invalid webhook URL"}, status_code=400)
|
|
393
|
+
|
|
394
|
+
try:
|
|
395
|
+
# Get the webhook payload
|
|
396
|
+
payload = await request.json()
|
|
397
|
+
|
|
398
|
+
logger.info(
|
|
399
|
+
"Knowledge filter webhook received",
|
|
400
|
+
filter_id=filter_id,
|
|
401
|
+
subscription_id=subscription_id,
|
|
402
|
+
payload_size=len(str(payload)),
|
|
403
|
+
)
|
|
404
|
+
|
|
405
|
+
# Extract findings from the payload
|
|
406
|
+
findings = payload.get("findings", [])
|
|
407
|
+
if not findings:
|
|
408
|
+
logger.info(
|
|
409
|
+
"No findings in webhook payload", subscription_id=subscription_id
|
|
410
|
+
)
|
|
411
|
+
return JSONResponse({"status": "no_findings"})
|
|
412
|
+
|
|
413
|
+
# Process the findings - these are the documents that matched the knowledge filter
|
|
414
|
+
matched_documents = []
|
|
415
|
+
for finding in findings:
|
|
416
|
+
# Extract document information from the finding
|
|
417
|
+
matched_documents.append(
|
|
418
|
+
{
|
|
419
|
+
"document_id": finding.get("_id"),
|
|
420
|
+
"index": finding.get("_index"),
|
|
421
|
+
"source": finding.get("_source", {}),
|
|
422
|
+
"score": finding.get("_score"),
|
|
423
|
+
}
|
|
424
|
+
)
|
|
425
|
+
|
|
426
|
+
# Log the matched documents
|
|
427
|
+
logger.info(
|
|
428
|
+
"Knowledge filter matched documents",
|
|
429
|
+
filter_id=filter_id,
|
|
430
|
+
matched_count=len(matched_documents),
|
|
431
|
+
)
|
|
432
|
+
for doc in matched_documents:
|
|
433
|
+
logger.debug(
|
|
434
|
+
"Matched document",
|
|
435
|
+
document_id=doc["document_id"],
|
|
436
|
+
index=doc["index"],
|
|
437
|
+
score=doc.get("score"),
|
|
438
|
+
)
|
|
439
|
+
|
|
440
|
+
# Here you could add additional processing:
|
|
441
|
+
# - Send notifications to external webhooks
|
|
442
|
+
# - Email notifications
|
|
443
|
+
# - Store alerts in a database
|
|
444
|
+
# - Trigger other workflows
|
|
445
|
+
|
|
446
|
+
return JSONResponse(
|
|
447
|
+
{
|
|
448
|
+
"status": "processed",
|
|
449
|
+
"filter_id": filter_id,
|
|
450
|
+
"subscription_id": subscription_id,
|
|
451
|
+
"matched_documents": len(matched_documents),
|
|
452
|
+
"timestamp": datetime.utcnow().isoformat(),
|
|
453
|
+
}
|
|
454
|
+
)
|
|
455
|
+
|
|
456
|
+
except Exception as e:
|
|
457
|
+
logger.error(
|
|
458
|
+
"Failed to process knowledge filter webhook",
|
|
459
|
+
filter_id=filter_id,
|
|
460
|
+
subscription_id=subscription_id,
|
|
461
|
+
error=str(e),
|
|
462
|
+
)
|
|
463
|
+
import traceback
|
|
464
|
+
|
|
465
|
+
traceback.print_exc()
|
|
466
|
+
return JSONResponse(
|
|
467
|
+
{"error": f"Webhook processing failed: {str(e)}"}, status_code=500
|
|
468
|
+
)
|