576 lines
26 KiB
Python
576 lines
26 KiB
Python
import io
|
|
import json
|
|
from datetime import datetime
|
|
|
|
import pytz
|
|
import requests
|
|
from flask import current_app, request
|
|
from flask_restx import Namespace, Resource, fields, reqparse
|
|
from flask_jwt_extended import jwt_required, get_jwt_identity
|
|
from werkzeug.datastructures import FileStorage
|
|
from werkzeug.utils import secure_filename
|
|
from common.utils.document_utils import (
|
|
create_document_stack, process_url, start_embedding_task,
|
|
EveAIInvalidLanguageException, EveAIDoubleURLException, EveAIUnsupportedFileType,
|
|
get_documents_list, edit_document, refresh_document, edit_document_version,
|
|
refresh_document_with_info, lookup_document, refresh_document_with_content
|
|
)
|
|
from common.utils.eveai_exceptions import EveAIException
|
|
from eveai_api.api.auth import requires_service
|
|
|
|
|
|
def validate_date(date_str):
|
|
try:
|
|
return datetime.fromisoformat(date_str).replace(tzinfo=pytz.UTC)
|
|
except ValueError:
|
|
raise ValueError("Invalid date format. Use ISO format (YYYY-MM-DDTHH:MM:SS).")
|
|
|
|
|
|
def validate_json(json_str):
|
|
try:
|
|
return json.loads(json_str)
|
|
except json.JSONDecodeError:
|
|
raise ValueError("Invalid JSON format for user_metadata.")
|
|
|
|
|
|
document_ns = Namespace('documents', description='Document related operations')
|
|
|
|
# Define models for request parsing and response serialization
|
|
upload_parser = reqparse.RequestParser()
|
|
upload_parser.add_argument('catalog_id', location='form', type=int, required=True, help='The catalog to add the file to')
|
|
upload_parser.add_argument('file', location='files', type=FileStorage, required=True, help='The file to upload')
|
|
upload_parser.add_argument('name', location='form', type=str, required=False, help='Name of the document')
|
|
upload_parser.add_argument('language', location='form', type=str, required=True, help='Language of the document')
|
|
upload_parser.add_argument('user_context', location='form', type=str, required=False,
|
|
help='User context for the document')
|
|
upload_parser.add_argument('valid_from', location='form', type=validate_date, required=False,
|
|
help='Valid from date for the document (ISO format)')
|
|
upload_parser.add_argument('user_metadata', location='form', type=validate_json, required=False,
|
|
help='User metadata for the document (JSON format)')
|
|
upload_parser.add_argument('catalog_properties', location='form', type=validate_json, required=False,
|
|
help='The catalog configuration to be passed along (JSON format). Validity is against catalog requirements '
|
|
'is not checked, and is the responsibility of the calling client.')
|
|
|
|
add_document_response = document_ns.model('AddDocumentResponse', {
|
|
'message': fields.String(description='Status message'),
|
|
'document_id': fields.Integer(description='ID of the created document'),
|
|
'document_version_id': fields.Integer(description='ID of the created document version'),
|
|
'task_id': fields.String(description='ID of the embedding task')
|
|
})
|
|
|
|
|
|
@document_ns.route('/add_document')
|
|
class AddDocument(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.expect(upload_parser)
|
|
@document_ns.response(201, 'Document added successfully', add_document_response)
|
|
@document_ns.response(400, 'Validation Error')
|
|
@document_ns.response(500, 'Internal Server Error')
|
|
def post(self):
|
|
"""
|
|
Add a new document by providing the content of a file (Multipart/form-data).
|
|
"""
|
|
tenant_id = get_jwt_identity()
|
|
current_app.logger.info(f'Adding document for tenant {tenant_id}')
|
|
|
|
try:
|
|
args = upload_parser.parse_args()
|
|
except Exception as e:
|
|
current_app.logger.error(f"Error parsing arguments: {str(e)}")
|
|
current_app.logger.error(f"Exception type: {type(e)}")
|
|
raise
|
|
|
|
try:
|
|
file = args['file']
|
|
filename = secure_filename(file.filename)
|
|
extension = filename.rsplit('.', 1)[1].lower()
|
|
|
|
# validate_file_type(extension)
|
|
|
|
api_input = {
|
|
'catalog_id': args.get('catalog_id'),
|
|
'name': args.get('name') or filename,
|
|
'language': args.get('language'),
|
|
'user_context': args.get('user_context'),
|
|
'valid_from': args.get('valid_from'),
|
|
'user_metadata': args.get('user_metadata'),
|
|
'catalog_properties': args.get('catalog_properties'),
|
|
}
|
|
|
|
new_doc, new_doc_vers = create_document_stack(api_input, file, filename, extension, tenant_id)
|
|
task_id = start_embedding_task(tenant_id, new_doc_vers.id)
|
|
|
|
return {
|
|
'message': f'Processing on document {new_doc.name}, version {new_doc_vers.id} started. Task ID: {task_id}.',
|
|
'document_id': new_doc.id,
|
|
'document_version_id': new_doc_vers.id,
|
|
'task_id': task_id
|
|
}, 201
|
|
|
|
except (EveAIInvalidLanguageException, EveAIUnsupportedFileType) as e:
|
|
current_app.logger.error(f'Error adding document: {str(e)}')
|
|
document_ns.abort(400, str(e))
|
|
except Exception as e:
|
|
current_app.logger.error(f'Error adding document: {str(e)}')
|
|
document_ns.abort(500, 'Error adding document')
|
|
|
|
|
|
# Models for AddDocumentThroughURL
|
|
add_document_through_url = document_ns.model('AddDocumentThroughURL', {
|
|
'catalog_id': fields.Integer(required=True, description='ID of the catalog the URL needs to be added to'),
|
|
'temp_url': fields.String(required=True, description='Temporary URL of the document to add'),
|
|
'name': fields.String(required=True, description='Name of the document'),
|
|
'language': fields.String(required=True, description='Language of the document'),
|
|
'user_context': fields.String(required=False, description='User context for the document'),
|
|
'valid_from': fields.String(required=False, description='Valid from date for the document'),
|
|
'user_metadata': fields.String(required=False, description='User metadata for the document'),
|
|
'system_metadata': fields.String(required=False, description='System metadata for the document'),
|
|
'catalog_properties': fields.String(required=False, description='The catalog configuration to be passed along (JSON '
|
|
'format). Validity is against catalog requirements '
|
|
'is not checked, and is the responsibility of the '
|
|
'calling client.'),
|
|
})
|
|
|
|
add_document_through_url_response = document_ns.model('AddDocumentThroughURLResponse', {
|
|
'message': fields.String(description='Status message'),
|
|
'document_id': fields.Integer(description='ID of the created document'),
|
|
'document_version_id': fields.Integer(description='ID of the created document version'),
|
|
'task_id': fields.String(description='ID of the embedding task')
|
|
})
|
|
|
|
@document_ns.route('/add_document_through_url')
|
|
class AddDocumentThroughURL(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.expect(add_document_through_url)
|
|
@document_ns.response(201, 'Document added successfully', add_document_through_url)
|
|
@document_ns.response(400, 'Validation Error')
|
|
@document_ns.response(422, 'File could not be processed')
|
|
@document_ns.response(500, 'Internal Server Error')
|
|
def post(self):
|
|
"""
|
|
Add a new document using a URL. The URL can be temporary, and will not be stored.
|
|
Mainly used for passing temporary URLs like used in e.g. Zapier
|
|
"""
|
|
tenant_id = get_jwt_identity()
|
|
current_app.logger.info(f'Adding document through url for tenant {tenant_id}')
|
|
|
|
try:
|
|
args = document_ns.payload
|
|
except Exception as e:
|
|
current_app.logger.error(f"Error parsing arguments: {str(e)}")
|
|
current_app.logger.error(f"Exception type: {type(e)}")
|
|
raise
|
|
|
|
try:
|
|
# Step 1: Download from stashed URL
|
|
stashed_url = args['temp_url']
|
|
current_app.logger.info(f"Downloading stashed file from URL: {stashed_url}")
|
|
response = requests.get(stashed_url, stream=True)
|
|
response.raise_for_status()
|
|
|
|
hydration_url = response.text.strip()
|
|
current_app.logger.info(f"Downloading actual file from URL: {hydration_url}")
|
|
# Step 2: Download from hydration URL
|
|
actual_file_response = requests.get(hydration_url, stream=True)
|
|
actual_file_response.raise_for_status()
|
|
hydrated_file_content = actual_file_response.content
|
|
|
|
# Get filename from URL or use provided name
|
|
filename = secure_filename(args.get('name'))
|
|
extension = filename.rsplit('.', 1)[1].lower() if '.' in filename else ''
|
|
|
|
# Create FileStorage object from downloaded content
|
|
file_content = io.BytesIO(hydrated_file_content)
|
|
file = FileStorage(
|
|
stream=file_content,
|
|
filename=filename,
|
|
content_type=response.headers.get('content-type', 'application/octet-stream')
|
|
)
|
|
|
|
current_app.logger.info(f"Successfully downloaded file: {filename}")
|
|
except requests.RequestException as e:
|
|
current_app.logger.error(f"Error downloading file: {str(e)}")
|
|
return {'message': f'Error downloading file: {str(e)}'}, 422
|
|
|
|
try:
|
|
# Prepare API input
|
|
api_input = {
|
|
'catalog_id': args.get('catalog_id'),
|
|
'name': args.get('name') or filename,
|
|
'language': args.get('language'),
|
|
'user_context': args.get('user_context'),
|
|
'valid_from': args.get('valid_from'),
|
|
'user_metadata': args.get('user_metadata'),
|
|
'catalog_properties': args.get('catalog_properties'),
|
|
}
|
|
|
|
new_doc, new_doc_vers = create_document_stack(api_input, file, filename, extension, tenant_id)
|
|
task_id = start_embedding_task(tenant_id, new_doc_vers.id)
|
|
|
|
return {
|
|
'message': f'Processing on document {new_doc.name}, version {new_doc_vers.id} started. Task ID: {task_id}.',
|
|
'document_id': new_doc.id,
|
|
'document_version_id': new_doc_vers.id,
|
|
'task_id': task_id
|
|
}, 201
|
|
except (EveAIInvalidLanguageException, EveAIUnsupportedFileType) as e:
|
|
current_app.logger.error(f'Error adding document: {str(e)}')
|
|
return {'message': str(e)}, 400
|
|
except Exception as e:
|
|
current_app.logger.error(f'Error adding document: {str(e)}')
|
|
return {'message': 'Error adding document'}, 500
|
|
|
|
|
|
# Models for AddURL
|
|
add_url_model = document_ns.model('AddURL', {
|
|
'catalog_id': fields.Integer(required='True', description='ID of the catalog the URL needs to be added to'),
|
|
'url': fields.String(required=True, description='URL of the document to add'),
|
|
'name': fields.String(required=False, description='Name of the document'),
|
|
'language': fields.String(required=True, description='Language of the document'),
|
|
'user_context': fields.String(required=False, description='User context for the document'),
|
|
'valid_from': fields.String(required=False, description='Valid from date for the document'),
|
|
'user_metadata': fields.String(required=False, description='User metadata for the document'),
|
|
'system_metadata': fields.String(required=False, description='System metadata for the document'),
|
|
'catalog_properties': fields.String(required=False, description='The catalog configuration to be passed along (JSON '
|
|
'format). Validity is against catalog requirements '
|
|
'is not checked, and is the responsibility of the '
|
|
'calling client.'),
|
|
})
|
|
|
|
add_url_response = document_ns.model('AddURLResponse', {
|
|
'message': fields.String(description='Status message'),
|
|
'document_id': fields.Integer(description='ID of the created document'),
|
|
'document_version_id': fields.Integer(description='ID of the created document version'),
|
|
'task_id': fields.String(description='ID of the embedding task')
|
|
})
|
|
|
|
|
|
@document_ns.route('/add_url')
|
|
class AddURL(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.expect(add_url_model)
|
|
@document_ns.response(201, 'Document added successfully', add_url_response)
|
|
@document_ns.response(400, 'Validation Error')
|
|
@document_ns.response(500, 'Internal Server Error')
|
|
def post(self):
|
|
"""
|
|
Add a new document from URL. The URL in this case is stored and can be used to refresh the document.
|
|
As a consequence, this must be a permanent and accessible URL.
|
|
"""
|
|
tenant_id = get_jwt_identity()
|
|
current_app.logger.info(f'Adding document from URL for tenant {tenant_id}')
|
|
|
|
try:
|
|
args = document_ns.payload
|
|
file_content, filename, extension = process_url(args['url'], tenant_id)
|
|
|
|
api_input = {
|
|
'catalog_id': args['catalog_id'],
|
|
'url': args['url'],
|
|
'name': args.get('name') or filename,
|
|
'language': args['language'],
|
|
'user_context': args.get('user_context'),
|
|
'valid_from': args.get('valid_from'),
|
|
'user_metadata': args.get('user_metadata'),
|
|
'catalog_properties': args.get('catalog_properties'),
|
|
}
|
|
|
|
new_doc, new_doc_vers = create_document_stack(api_input, file_content, filename, extension, tenant_id)
|
|
task_id = start_embedding_task(tenant_id, new_doc_vers.id)
|
|
|
|
return {
|
|
'message': f'Processing on document {new_doc.name}, version {new_doc_vers.id} started. Task ID: {task_id}.',
|
|
'document_id': new_doc.id,
|
|
'document_version_id': new_doc_vers.id,
|
|
'task_id': task_id
|
|
}, 201
|
|
|
|
except EveAIDoubleURLException:
|
|
document_ns.abort(400, f'A document with URL {args["url"]} already exists.')
|
|
except (EveAIInvalidLanguageException, EveAIUnsupportedFileType) as e:
|
|
document_ns.abort(400, str(e))
|
|
except Exception as e:
|
|
current_app.logger.error(f'Error adding document from URL: {str(e)}')
|
|
document_ns.abort(500, 'Error adding document from URL')
|
|
|
|
|
|
document_list_model = document_ns.model('DocumentList', {
|
|
'id': fields.Integer(description='Document ID'),
|
|
'name': fields.String(description='Document name'),
|
|
'valid_from': fields.DateTime(description='Valid from date'),
|
|
'valid_to': fields.DateTime(description='Valid to date'),
|
|
})
|
|
|
|
|
|
@document_ns.route('/list')
|
|
class DocumentList(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.doc('list_documents')
|
|
@document_ns.marshal_list_with(document_list_model, envelope='documents')
|
|
def get(self):
|
|
"""List all documents"""
|
|
page = request.args.get('page', 1, type=int)
|
|
per_page = request.args.get('per_page', 10, type=int)
|
|
pagination = get_documents_list(page, per_page)
|
|
return pagination.items, 200
|
|
|
|
|
|
edit_document_model = document_ns.model('EditDocument', {
|
|
'name': fields.String(required=True, description='New name for the document'),
|
|
'valid_from': fields.DateTime(required=False, description='New valid from date'),
|
|
'valid_to': fields.DateTime(required=False, description='New valid to date'),
|
|
})
|
|
|
|
|
|
@document_ns.route('/<int:document_id>')
|
|
class DocumentResource(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.doc('edit_document')
|
|
@document_ns.expect(edit_document_model)
|
|
@document_ns.response(200, 'Document updated successfully')
|
|
@document_ns.response(400, 'Validation Error')
|
|
@document_ns.response(404, 'Document not found')
|
|
@document_ns.response(500, 'Internal Server Error')
|
|
def put(self, document_id):
|
|
"""Edit a document. The content of the document will not be refreshed!"""
|
|
try:
|
|
current_app.logger.debug(f'Editing document {document_id}')
|
|
data = request.json
|
|
tenant_id = get_jwt_identity()
|
|
updated_doc, error = edit_document(tenant_id, document_id, data.get('name', None),
|
|
data.get('valid_from', None), data.get('valid_to', None))
|
|
if updated_doc:
|
|
return {'message': f'Document {updated_doc.id} updated successfully'}, 200
|
|
else:
|
|
return {'message': f'Error updating document: {error}'}, 400
|
|
except EveAIException as e:
|
|
return e.to_dict(), e.status_code
|
|
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.doc('refresh_document')
|
|
@document_ns.response(200, 'Document refreshed successfully')
|
|
def post(self, document_id):
|
|
"""Refresh a document. In this case, the content of the document will be refreshed! This requires the document
|
|
version to have a permanent and accessible URL!"""
|
|
tenant_id = get_jwt_identity()
|
|
new_version, result = refresh_document(document_id, tenant_id)
|
|
if new_version:
|
|
return {'message': f'Document refreshed. New version: {new_version.id}. Task ID: {result}'}, 200
|
|
else:
|
|
return {'message': f'Error refreshing document: {result}'}, 400
|
|
|
|
|
|
edit_document_version_model = document_ns.model('EditDocumentVersion', {
|
|
'user_context': fields.String(required=True, description='New user context for the document version'),
|
|
'catalog_properties': fields.String(required=True, description='New catalog properties for the document version'),
|
|
})
|
|
|
|
|
|
@document_ns.route('/version/<int:version_id>')
|
|
class DocumentVersionResource(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.doc('edit_document_version')
|
|
@document_ns.expect(edit_document_version_model)
|
|
@document_ns.response(200, 'Document version updated successfully')
|
|
def put(self, version_id):
|
|
"""Edit a document version"""
|
|
data = request.json
|
|
tenant_id = get_jwt_identity()
|
|
updated_version, error = edit_document_version(tenant_id, version_id, data['user_context'], data.get('catalog_properties'))
|
|
if updated_version:
|
|
return {'message': f'Document Version {updated_version.id} updated successfully'}, 200
|
|
else:
|
|
return {'message': f'Error updating document version: {error}'}, 400
|
|
|
|
|
|
# Define the model for the request body of refresh_with_info
|
|
refresh_document_model = document_ns.model('RefreshDocument', {
|
|
'name': fields.String(required=False, description='New name for the document'),
|
|
'language': fields.String(required=False, description='Language of the document'),
|
|
'user_context': fields.String(required=False, description='User context for the document'),
|
|
'user_metadata': fields.Raw(required=False, description='User metadata for the document'),
|
|
'catalog_properties': fields.Raw(required=False, description='Catalog properties for the document'),
|
|
})
|
|
|
|
|
|
@document_ns.route('/<int:document_id>/refresh')
|
|
class RefreshDocument(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.response(200, 'Document refreshed successfully')
|
|
@document_ns.response(404, 'Document not found')
|
|
def post(self, document_id):
|
|
"""
|
|
Refresh a document without additional information. In this case, the content of the document will be refreshed!
|
|
This requires the document version to have a permanent and accessible URL!
|
|
"""
|
|
tenant_id = get_jwt_identity()
|
|
current_app.logger.info(f'Refreshing document {document_id} for tenant {tenant_id}')
|
|
|
|
try:
|
|
new_version, result = refresh_document(document_id, tenant_id)
|
|
|
|
if new_version:
|
|
return {
|
|
'message': f'Document refreshed successfully. New version: {new_version.id}. Task ID: {result}',
|
|
'document_id': document_id,
|
|
'document_version_id': new_version.id,
|
|
'task_id': result
|
|
}, 200
|
|
else:
|
|
return {'message': f'Error refreshing document: {result}'}, 400
|
|
|
|
except Exception as e:
|
|
current_app.logger.error(f'Error refreshing document: {str(e)}')
|
|
return {'message': 'Internal server error'}, 500
|
|
|
|
|
|
@document_ns.route('/<int:document_id>/refresh_with_info')
|
|
class RefreshDocumentWithInfo(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.expect(refresh_document_model)
|
|
@document_ns.response(200, 'Document refreshed successfully')
|
|
@document_ns.response(400, 'Validation Error')
|
|
@document_ns.response(404, 'Document not found')
|
|
def post(self, document_id):
|
|
"""
|
|
Refresh a document with new version information.
|
|
"""
|
|
tenant_id = get_jwt_identity()
|
|
current_app.logger.info(f'Refreshing document {document_id} with info for tenant {tenant_id}')
|
|
|
|
try:
|
|
api_input = request.json
|
|
new_version, result = refresh_document_with_info(document_id, tenant_id, api_input)
|
|
|
|
if new_version:
|
|
return {
|
|
'message': f'Document refreshed successfully with new info. New version: {new_version.id}. Task ID: {result}',
|
|
'document_id': document_id,
|
|
'document_version_id': new_version.id,
|
|
'task_id': result
|
|
}, 200
|
|
else:
|
|
return {'message': f'Error refreshing document with info: {result}'}, 400
|
|
|
|
except Exception as e:
|
|
current_app.logger.error(f'Error refreshing document with info: {str(e)}')
|
|
return {'message': 'Internal server error'}, 500
|
|
|
|
|
|
# Define models for lookup requests
|
|
lookup_model = document_ns.model('DocumentLookup', {
|
|
'lookup_criteria': fields.Raw(required=True,
|
|
description='JSON object containing key-value pairs to match in metadata. '
|
|
'Example: {"external_id": "123", "source": "zapier", "source_type": "google_docs"}'),
|
|
'metadata_type': fields.String(required=True, enum=['user_metadata', 'system_metadata'],
|
|
description='Which metadata field to search in')
|
|
})
|
|
|
|
lookup_response = document_ns.model('DocumentLookupResponse', {
|
|
'document_id': fields.Integer(description='ID of the found document'),
|
|
'document_version_id': fields.Integer(description='ID of the latest document version'),
|
|
'name': fields.String(description='Document name'),
|
|
'metadata': fields.Raw(description='Full metadata of the found document')
|
|
})
|
|
|
|
|
|
@document_ns.route('/lookup')
|
|
class DocumentLookup(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.expect(lookup_model)
|
|
@document_ns.marshal_with(lookup_response)
|
|
@document_ns.response(200, 'Document found', lookup_response)
|
|
@document_ns.response(404, 'No document found matching criteria')
|
|
def post(self):
|
|
"""
|
|
Look up a document using metadata criteria
|
|
"""
|
|
tenant_id = get_jwt_identity()
|
|
try:
|
|
data = request.json
|
|
document, version = lookup_document(
|
|
tenant_id,
|
|
data['lookup_criteria'],
|
|
data['metadata_type']
|
|
)
|
|
|
|
return {
|
|
'document_id': document.id,
|
|
'document_version_id': version.id,
|
|
'name': document.name,
|
|
'metadata': getattr(version, data['metadata_type'])
|
|
}
|
|
|
|
except EveAIException as e:
|
|
return e.to_dict(), e.status_code
|
|
|
|
except KeyError as e:
|
|
return {'message': f'Missing required field: {str(e)}'}, 400
|
|
|
|
|
|
refresh_content_model = document_ns.model('RefreshDocumentContent', {
|
|
'file_content': fields.Raw(required=True, description='The new file content'),
|
|
'language': fields.String(required=False, description='Language of the document'),
|
|
'user_context': fields.String(required=False, description='User context for the document'),
|
|
'user_metadata': fields.Raw(required=False, description='Custom metadata fields'),
|
|
'catalog_properties': fields.Raw(required=False, description='Catalog-specific properties'),
|
|
'trigger_service': fields.String(required=False, description='Service that triggered the update')
|
|
})
|
|
|
|
|
|
@document_ns.route('/<int:document_id>/refresh_content')
|
|
class RefreshDocumentContent(Resource):
|
|
@jwt_required()
|
|
@requires_service('DOCAPI')
|
|
@document_ns.expect(refresh_content_model)
|
|
@document_ns.response(200, 'Document refreshed successfully')
|
|
def post(self, document_id):
|
|
"""Refresh a document with new content"""
|
|
tenant_id = get_jwt_identity()
|
|
try:
|
|
data = request.json
|
|
file_content = data['file_content']
|
|
|
|
# Build user_metadata by merging:
|
|
# 1. Existing metadata (if any)
|
|
# 2. New metadata from request
|
|
# 3. Zapier-specific fields
|
|
user_metadata = data.get('user_metadata', {})
|
|
user_metadata.update({
|
|
'source': 'zapier',
|
|
'trigger_service': data.get('trigger_service')
|
|
})
|
|
data['user_metadata'] = user_metadata
|
|
|
|
# Keep catalog_properties separate
|
|
if 'catalog_properties' in data:
|
|
# We could add validation here against catalog configuration
|
|
data['catalog_properties'] = data['catalog_properties']
|
|
|
|
new_version, task_id = refresh_document_with_content(
|
|
document_id,
|
|
tenant_id,
|
|
file_content,
|
|
data
|
|
)
|
|
|
|
return {
|
|
'message': f'Document refreshed successfully. New version: {new_version.id}. Task ID: {task_id}',
|
|
'document_id': document_id,
|
|
'document_version_id': new_version.id,
|
|
'task_id': task_id
|
|
}, 200
|
|
|
|
except EveAIException as e:
|
|
return e.to_dict(), e.status_code
|