476 lines
17 KiB
Python
476 lines
17 KiB
Python
"""EspoCRM API client for Motia III"""
|
|
import aiohttp
|
|
import asyncio
|
|
import logging
|
|
import time
|
|
from typing import Optional, Dict, Any, List
|
|
import os
|
|
|
|
from services.exceptions import (
|
|
EspoCRMAPIError,
|
|
EspoCRMAuthError,
|
|
EspoCRMTimeoutError,
|
|
RetryableError,
|
|
ValidationError
|
|
)
|
|
from services.redis_client import get_redis_client
|
|
from services.config import ESPOCRM_CONFIG, API_CONFIG
|
|
from services.logging_utils import get_service_logger
|
|
|
|
|
|
class EspoCRMAPI:
|
|
"""
|
|
EspoCRM API Client for BitByLaw integration.
|
|
|
|
Supports:
|
|
- API Key authentication (X-Api-Key header)
|
|
- Standard REST operations (GET, POST, PUT, DELETE)
|
|
- Entity management (CBeteiligte, CVmhErstgespraech, etc.)
|
|
|
|
Environment variables required:
|
|
- ESPOCRM_API_BASE_URL (e.g., https://crm.bitbylaw.com/api/v1)
|
|
- ESPOCRM_API_KEY (Marvin API key)
|
|
- ESPOCRM_API_TIMEOUT_SECONDS (optional, default: 30)
|
|
"""
|
|
|
|
def __init__(self, context=None):
|
|
"""
|
|
Initialize EspoCRM API client.
|
|
|
|
Args:
|
|
context: Motia FlowContext for logging (optional)
|
|
"""
|
|
self.context = context
|
|
self.logger = get_service_logger('espocrm', context)
|
|
self.logger.debug("EspoCRMAPI initializing")
|
|
|
|
# Load configuration from environment
|
|
self.api_base_url = os.getenv('ESPOCRM_API_BASE_URL', 'https://crm.bitbylaw.com/api/v1')
|
|
self.api_key = os.getenv('ESPOCRM_API_KEY', '')
|
|
self.api_timeout_seconds = int(os.getenv('ESPOCRM_API_TIMEOUT_SECONDS', str(API_CONFIG.default_timeout_seconds)))
|
|
|
|
if not self.api_key:
|
|
raise EspoCRMAuthError("ESPOCRM_API_KEY not configured in environment")
|
|
|
|
self.logger.info(f"EspoCRM API initialized with base URL: {self.api_base_url}")
|
|
|
|
self._session: Optional[aiohttp.ClientSession] = None
|
|
self._entity_defs_cache: Dict[str, Dict[str, Any]] = {}
|
|
self._entity_defs_cache_ttl_seconds = int(os.getenv('ESPOCRM_METADATA_TTL_SECONDS', '300'))
|
|
|
|
# Optional Redis for caching/rate limiting (centralized)
|
|
self.redis_client = get_redis_client(strict=False)
|
|
if self.redis_client:
|
|
self.logger.info("Connected to Redis for EspoCRM operations")
|
|
else:
|
|
self.logger.warning("⚠️ Redis unavailable - caching disabled")
|
|
|
|
def _log(self, message: str, level: str = 'info') -> None:
|
|
"""Delegate to IntegrationLogger with optional level"""
|
|
log_func = getattr(self.logger, level, self.logger.info)
|
|
log_func(message)
|
|
|
|
def _get_headers(self) -> Dict[str, str]:
|
|
"""Generate request headers with API key"""
|
|
return {
|
|
'X-Api-Key': self.api_key,
|
|
'Content-Type': 'application/json',
|
|
'Accept': 'application/json'
|
|
}
|
|
|
|
async def _get_session(self) -> aiohttp.ClientSession:
|
|
if self._session is None or self._session.closed:
|
|
self._session = aiohttp.ClientSession()
|
|
return self._session
|
|
|
|
async def close(self) -> None:
|
|
if self._session and not self._session.closed:
|
|
await self._session.close()
|
|
|
|
async def get_entity_def(self, entity_type: str) -> Dict[str, Any]:
|
|
now = time.monotonic()
|
|
cached = self._entity_defs_cache.get(entity_type)
|
|
if cached and (now - cached['ts']) < self._entity_defs_cache_ttl_seconds:
|
|
return cached['data']
|
|
|
|
try:
|
|
data = await self.api_call(f"/Metadata/EntityDefs/{entity_type}", method='GET')
|
|
except EspoCRMAPIError:
|
|
all_defs = await self.api_call("/Metadata/EntityDefs", method='GET')
|
|
data = all_defs.get(entity_type, {}) if isinstance(all_defs, dict) else {}
|
|
|
|
self._entity_defs_cache[entity_type] = {'ts': now, 'data': data}
|
|
return data
|
|
|
|
async def api_call(
|
|
self,
|
|
endpoint: str,
|
|
method: str = 'GET',
|
|
params: Optional[Dict] = None,
|
|
json_data: Optional[Dict] = None,
|
|
timeout_seconds: Optional[int] = None
|
|
) -> Any:
|
|
"""
|
|
Make an API call to EspoCRM.
|
|
|
|
Args:
|
|
endpoint: API endpoint (e.g., '/CBeteiligte/123' or '/CVmhErstgespraech')
|
|
method: HTTP method (GET, POST, PUT, DELETE)
|
|
params: Query parameters
|
|
json_data: JSON body for POST/PUT
|
|
timeout_seconds: Request timeout
|
|
|
|
Returns:
|
|
Parsed JSON response or None
|
|
|
|
Raises:
|
|
EspoCRMAuthError: Authentication failed
|
|
EspoCRMTimeoutError: Request timed out
|
|
EspoCRMAPIError: Other API errors
|
|
"""
|
|
# Ensure endpoint starts with /
|
|
if not endpoint.startswith('/'):
|
|
endpoint = '/' + endpoint
|
|
|
|
url = self.api_base_url.rstrip('/') + endpoint
|
|
headers = self._get_headers()
|
|
effective_timeout = aiohttp.ClientTimeout(
|
|
total=timeout_seconds or self.api_timeout_seconds
|
|
)
|
|
|
|
session = await self._get_session()
|
|
try:
|
|
with self.logger.api_call(endpoint, method):
|
|
async with session.request(
|
|
method,
|
|
url,
|
|
headers=headers,
|
|
params=params,
|
|
json=json_data,
|
|
timeout=effective_timeout
|
|
) as response:
|
|
# Handle errors
|
|
if response.status == 401:
|
|
raise EspoCRMAuthError(
|
|
"Authentication failed - check API key",
|
|
status_code=401
|
|
)
|
|
elif response.status == 403:
|
|
raise EspoCRMAPIError(
|
|
"Access forbidden",
|
|
status_code=403
|
|
)
|
|
elif response.status == 404:
|
|
raise EspoCRMAPIError(
|
|
f"Resource not found: {endpoint}",
|
|
status_code=404
|
|
)
|
|
elif response.status >= 500:
|
|
error_text = await response.text()
|
|
raise RetryableError(
|
|
f"Server error {response.status}: {error_text}"
|
|
)
|
|
elif response.status >= 400:
|
|
error_text = await response.text()
|
|
raise EspoCRMAPIError(
|
|
f"API error {response.status}: {error_text}",
|
|
status_code=response.status,
|
|
response_body=error_text
|
|
)
|
|
|
|
# Parse response
|
|
if response.content_type == 'application/json':
|
|
result = await response.json()
|
|
return result
|
|
else:
|
|
# For DELETE or other non-JSON responses
|
|
return None
|
|
|
|
except asyncio.TimeoutError:
|
|
raise EspoCRMTimeoutError(
|
|
f"Request timed out after {effective_timeout.total}s",
|
|
status_code=408
|
|
)
|
|
except aiohttp.ClientError as e:
|
|
self.logger.error(f"API call failed: {e}")
|
|
raise EspoCRMAPIError(f"Request failed: {str(e)}")
|
|
|
|
async def get_entity(self, entity_type: str, entity_id: str) -> Dict[str, Any]:
|
|
"""
|
|
Get a single entity by ID.
|
|
|
|
Args:
|
|
entity_type: Entity type (e.g., 'CBeteiligte', 'CVmhErstgespraech')
|
|
entity_id: Entity ID
|
|
|
|
Returns:
|
|
Entity data as dict
|
|
"""
|
|
self._log(f"Getting {entity_type} with ID: {entity_id}")
|
|
return await self.api_call(f"/{entity_type}/{entity_id}", method='GET')
|
|
|
|
async def list_entities(
|
|
self,
|
|
entity_type: str,
|
|
where: Optional[List[Dict]] = None,
|
|
select: Optional[str] = None,
|
|
order_by: Optional[str] = None,
|
|
offset: int = 0,
|
|
max_size: int = 50
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
List entities with filtering and pagination.
|
|
|
|
Args:
|
|
entity_type: Entity type
|
|
where: Filter conditions (EspoCRM format)
|
|
select: Comma-separated field list
|
|
order_by: Sort field
|
|
offset: Pagination offset
|
|
max_size: Max results per page
|
|
|
|
Returns:
|
|
Dict with 'list' and 'total' keys
|
|
"""
|
|
params = {
|
|
'offset': offset,
|
|
'maxSize': max_size
|
|
}
|
|
|
|
if where:
|
|
import json
|
|
# EspoCRM expects JSON-encoded where clause
|
|
params['where'] = where if isinstance(where, str) else json.dumps(where)
|
|
if select:
|
|
params['select'] = select
|
|
if order_by:
|
|
params['orderBy'] = order_by
|
|
|
|
self._log(f"Listing {entity_type} entities")
|
|
return await self.api_call(f"/{entity_type}", method='GET', params=params)
|
|
|
|
async def list_related(
|
|
self,
|
|
entity_type: str,
|
|
entity_id: str,
|
|
link: str,
|
|
where: Optional[List[Dict]] = None,
|
|
select: Optional[str] = None,
|
|
order_by: Optional[str] = None,
|
|
order: Optional[str] = None,
|
|
offset: int = 0,
|
|
max_size: int = 50
|
|
) -> Dict[str, Any]:
|
|
params = {
|
|
'offset': offset,
|
|
'maxSize': max_size
|
|
}
|
|
|
|
if where:
|
|
import json
|
|
params['where'] = where if isinstance(where, str) else json.dumps(where)
|
|
if select:
|
|
params['select'] = select
|
|
if order_by:
|
|
params['orderBy'] = order_by
|
|
if order:
|
|
params['order'] = order
|
|
|
|
self._log(f"Listing related {entity_type}/{entity_id}/{link}")
|
|
return await self.api_call(f"/{entity_type}/{entity_id}/{link}", method='GET', params=params)
|
|
|
|
async def create_entity(
|
|
self,
|
|
entity_type: str,
|
|
data: Dict[str, Any]
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Create a new entity.
|
|
|
|
Args:
|
|
entity_type: Entity type
|
|
data: Entity data
|
|
|
|
Returns:
|
|
Created entity with ID
|
|
"""
|
|
self._log(f"Creating {entity_type} entity")
|
|
return await self.api_call(f"/{entity_type}", method='POST', json_data=data)
|
|
|
|
async def update_entity(
|
|
self,
|
|
entity_type: str,
|
|
entity_id: str,
|
|
data: Dict[str, Any]
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Update an existing entity.
|
|
|
|
Args:
|
|
entity_type: Entity type
|
|
entity_id: Entity ID
|
|
data: Updated fields
|
|
|
|
Returns:
|
|
Updated entity
|
|
"""
|
|
self._log(f"Updating {entity_type} with ID: {entity_id}")
|
|
return await self.api_call(f"/{entity_type}/{entity_id}", method='PUT', json_data=data)
|
|
|
|
async def delete_entity(self, entity_type: str, entity_id: str) -> bool:
|
|
"""
|
|
Delete an entity.
|
|
|
|
Args:
|
|
entity_type: Entity type
|
|
entity_id: Entity ID
|
|
|
|
Returns:
|
|
True if successful
|
|
"""
|
|
self._log(f"Deleting {entity_type} with ID: {entity_id}")
|
|
await self.api_call(f"/{entity_type}/{entity_id}", method='DELETE')
|
|
return True
|
|
|
|
async def search_entities(
|
|
self,
|
|
entity_type: str,
|
|
query: str,
|
|
fields: Optional[List[str]] = None
|
|
) -> List[Dict[str, Any]]:
|
|
"""
|
|
Search entities by text query.
|
|
|
|
Args:
|
|
entity_type: Entity type
|
|
query: Search query
|
|
fields: Fields to search in
|
|
|
|
Returns:
|
|
List of matching entities
|
|
"""
|
|
where = [{
|
|
'type': 'textFilter',
|
|
'value': query
|
|
}]
|
|
|
|
result = await self.list_entities(entity_type, where=where)
|
|
return result.get('list', [])
|
|
|
|
async def upload_attachment(
|
|
self,
|
|
file_content: bytes,
|
|
filename: str,
|
|
parent_type: str,
|
|
parent_id: str,
|
|
field: str,
|
|
mime_type: str = 'application/octet-stream',
|
|
role: str = 'Attachment'
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Upload an attachment to EspoCRM.
|
|
|
|
Args:
|
|
file_content: File content as bytes
|
|
filename: Name of the file
|
|
parent_type: Parent entity type (e.g., 'Document')
|
|
parent_id: Parent entity ID
|
|
field: Field name for the attachment (e.g., 'preview')
|
|
mime_type: MIME type of the file
|
|
role: Attachment role (default: 'Attachment')
|
|
|
|
Returns:
|
|
Attachment entity data
|
|
"""
|
|
self._log(f"Uploading attachment: {filename} ({len(file_content)} bytes) to {parent_type}/{parent_id}/{field}")
|
|
|
|
url = self.api_base_url.rstrip('/') + '/Attachment'
|
|
headers = {
|
|
'X-Api-Key': self.api_key,
|
|
# Content-Type wird automatisch von aiohttp gesetzt für FormData
|
|
}
|
|
|
|
# Erstelle FormData
|
|
form_data = aiohttp.FormData()
|
|
form_data.add_field('file', file_content, filename=filename, content_type=mime_type)
|
|
form_data.add_field('parentType', parent_type)
|
|
form_data.add_field('parentId', parent_id)
|
|
form_data.add_field('field', field)
|
|
form_data.add_field('role', role)
|
|
form_data.add_field('name', filename)
|
|
|
|
self._log(f"Upload params: parentType={parent_type}, parentId={parent_id}, field={field}, role={role}")
|
|
|
|
effective_timeout = aiohttp.ClientTimeout(total=self.api_timeout_seconds)
|
|
|
|
session = await self._get_session()
|
|
try:
|
|
async with session.post(url, headers=headers, data=form_data, timeout=effective_timeout) as response:
|
|
self._log(f"Upload response status: {response.status}")
|
|
|
|
if response.status == 401:
|
|
raise EspoCRMAuthError("Authentication failed - check API key")
|
|
elif response.status == 403:
|
|
raise EspoCRMError("Access forbidden")
|
|
elif response.status == 404:
|
|
raise EspoCRMError(f"Attachment endpoint not found")
|
|
elif response.status >= 400:
|
|
error_text = await response.text()
|
|
self._log(f"❌ Upload failed with {response.status}. Response: {error_text}", level='error')
|
|
raise EspoCRMError(f"Upload error {response.status}: {error_text}")
|
|
|
|
# Parse response
|
|
if response.content_type == 'application/json':
|
|
result = await response.json()
|
|
attachment_id = result.get('id')
|
|
self._log(f"✅ Attachment uploaded successfully: {attachment_id}")
|
|
return result
|
|
else:
|
|
response_text = await response.text()
|
|
self._log(f"⚠️ Non-JSON response: {response_text[:200]}", level='warn')
|
|
return {'success': True, 'response': response_text}
|
|
|
|
except aiohttp.ClientError as e:
|
|
self._log(f"Upload failed: {e}", level='error')
|
|
raise EspoCRMError(f"Upload request failed: {e}") from e
|
|
|
|
async def download_attachment(self, attachment_id: str) -> bytes:
|
|
"""
|
|
Download an attachment from EspoCRM.
|
|
|
|
Args:
|
|
attachment_id: Attachment ID
|
|
|
|
Returns:
|
|
File content as bytes
|
|
"""
|
|
self._log(f"Downloading attachment: {attachment_id}")
|
|
|
|
url = self.api_base_url.rstrip('/') + f'/Attachment/file/{attachment_id}'
|
|
headers = {
|
|
'X-Api-Key': self.api_key,
|
|
}
|
|
|
|
effective_timeout = aiohttp.ClientTimeout(total=self.api_timeout_seconds)
|
|
|
|
session = await self._get_session()
|
|
try:
|
|
async with session.get(url, headers=headers, timeout=effective_timeout) as response:
|
|
if response.status == 401:
|
|
raise EspoCRMAuthError("Authentication failed - check API key")
|
|
elif response.status == 403:
|
|
raise EspoCRMError("Access forbidden")
|
|
elif response.status == 404:
|
|
raise EspoCRMError(f"Attachment not found: {attachment_id}")
|
|
elif response.status >= 400:
|
|
error_text = await response.text()
|
|
raise EspoCRMError(f"Download error {response.status}: {error_text}")
|
|
|
|
content = await response.read()
|
|
self._log(f"✅ Downloaded {len(content)} bytes")
|
|
return content
|
|
|
|
except aiohttp.ClientError as e:
|
|
self._log(f"Download failed: {e}", level='error')
|
|
raise EspoCRMError(f"Download request failed: {e}") from e
|