mirror of
https://github.com/dograh-hq/dograh.git
synced 2026-06-07 07:55:16 +02:00
272 lines
9.6 KiB
Python
272 lines
9.6 KiB
Python
from typing import Union
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from pydantic import BaseModel
|
|
|
|
from api.constants import DEFAULT_CAMPAIGN_RETRY_CONFIG, DEFAULT_ORG_CONCURRENCY_LIMIT
|
|
from api.db import db_client
|
|
from api.db.models import UserModel
|
|
from api.enums import OrganizationConfigurationKey
|
|
from api.schemas.telephony_config import (
|
|
CloudonixConfigurationRequest,
|
|
CloudonixConfigurationResponse,
|
|
TelephonyConfigurationResponse,
|
|
TwilioConfigurationRequest,
|
|
TwilioConfigurationResponse,
|
|
VobizConfigurationRequest,
|
|
VobizConfigurationResponse,
|
|
VonageConfigurationRequest,
|
|
VonageConfigurationResponse,
|
|
)
|
|
from api.services.auth.depends import get_user
|
|
from api.services.configuration.masking import is_mask_of, mask_key
|
|
|
|
router = APIRouter(prefix="/organizations", tags=["organizations"])
|
|
|
|
# Provider configuration constants
|
|
PROVIDER_MASKED_FIELDS = {
|
|
"twilio": ["account_sid", "auth_token"],
|
|
"vonage": ["private_key", "api_key", "api_secret"],
|
|
"vobiz": ["auth_id", "auth_token"],
|
|
"cloudonix": ["bearer_token"],
|
|
}
|
|
|
|
|
|
# TODO: Make endpoints provider-agnostic
|
|
@router.get("/telephony-config", response_model=TelephonyConfigurationResponse)
|
|
async def get_telephony_configuration(user: UserModel = Depends(get_user)):
|
|
"""Get telephony configuration for the user's organization with masked sensitive fields."""
|
|
if not user.selected_organization_id:
|
|
raise HTTPException(status_code=400, detail="No organization selected")
|
|
|
|
config = await db_client.get_configuration(
|
|
user.selected_organization_id,
|
|
OrganizationConfigurationKey.TELEPHONY_CONFIGURATION.value,
|
|
)
|
|
|
|
if not config or not config.value:
|
|
return TelephonyConfigurationResponse()
|
|
|
|
stored_provider = config.value.get("provider", "twilio")
|
|
|
|
if stored_provider == "twilio":
|
|
account_sid = config.value.get("account_sid", "")
|
|
auth_token = config.value.get("auth_token", "")
|
|
from_numbers = (
|
|
config.value.get("from_numbers", []) if account_sid and auth_token else []
|
|
)
|
|
|
|
return TelephonyConfigurationResponse(
|
|
twilio=TwilioConfigurationResponse(
|
|
provider="twilio",
|
|
account_sid=mask_key(account_sid) if account_sid else "",
|
|
auth_token=mask_key(auth_token) if auth_token else "",
|
|
from_numbers=from_numbers,
|
|
),
|
|
vonage=None,
|
|
vobiz=None,
|
|
cloudonix=None,
|
|
)
|
|
elif stored_provider == "vonage":
|
|
application_id = config.value.get("application_id", "")
|
|
private_key = config.value.get("private_key", "")
|
|
api_key = config.value.get("api_key", "")
|
|
api_secret = config.value.get("api_secret", "")
|
|
from_numbers = (
|
|
config.value.get("from_numbers", [])
|
|
if application_id and private_key
|
|
else []
|
|
)
|
|
|
|
return TelephonyConfigurationResponse(
|
|
twilio=None,
|
|
vonage=VonageConfigurationResponse(
|
|
provider="vonage",
|
|
application_id=application_id,
|
|
private_key=mask_key(private_key) if private_key else "",
|
|
api_key=mask_key(api_key) if api_key else None,
|
|
api_secret=mask_key(api_secret) if api_secret else None,
|
|
from_numbers=from_numbers,
|
|
),
|
|
vobiz=None,
|
|
cloudonix=None,
|
|
)
|
|
elif stored_provider == "vobiz":
|
|
auth_id = config.value.get("auth_id", "")
|
|
auth_token = config.value.get("auth_token", "")
|
|
from_numbers = (
|
|
config.value.get("from_numbers", []) if auth_id and auth_token else []
|
|
)
|
|
|
|
return TelephonyConfigurationResponse(
|
|
twilio=None,
|
|
vonage=None,
|
|
vobiz=VobizConfigurationResponse(
|
|
provider="vobiz",
|
|
auth_id=mask_key(auth_id) if auth_id else "",
|
|
auth_token=mask_key(auth_token) if auth_token else "",
|
|
from_numbers=from_numbers,
|
|
),
|
|
cloudonix=None,
|
|
)
|
|
elif stored_provider == "cloudonix":
|
|
bearer_token = config.value.get("bearer_token", "")
|
|
domain_id = config.value.get("domain_id", "")
|
|
from_numbers = config.value.get("from_numbers", [])
|
|
|
|
return TelephonyConfigurationResponse(
|
|
twilio=None,
|
|
vonage=None,
|
|
cloudonix=CloudonixConfigurationResponse(
|
|
provider="cloudonix",
|
|
bearer_token=mask_key(bearer_token) if bearer_token else "",
|
|
domain_id=domain_id,
|
|
from_numbers=from_numbers,
|
|
),
|
|
vobiz=None,
|
|
)
|
|
else:
|
|
return TelephonyConfigurationResponse()
|
|
|
|
|
|
@router.post("/telephony-config")
|
|
async def save_telephony_configuration(
|
|
request: Union[
|
|
TwilioConfigurationRequest,
|
|
VonageConfigurationRequest,
|
|
VobizConfigurationRequest,
|
|
CloudonixConfigurationRequest,
|
|
],
|
|
user: UserModel = Depends(get_user),
|
|
):
|
|
"""Save telephony configuration for the user's organization."""
|
|
if not user.selected_organization_id:
|
|
raise HTTPException(status_code=400, detail="No organization selected")
|
|
|
|
# Fetch existing configuration to handle masked values
|
|
existing_config = await db_client.get_configuration(
|
|
user.selected_organization_id,
|
|
OrganizationConfigurationKey.TELEPHONY_CONFIGURATION.value,
|
|
)
|
|
|
|
# Build single-provider configuration
|
|
if request.provider == "twilio":
|
|
config_value = {
|
|
"provider": "twilio",
|
|
"account_sid": request.account_sid,
|
|
"auth_token": request.auth_token,
|
|
"from_numbers": request.from_numbers,
|
|
}
|
|
elif request.provider == "vonage":
|
|
config_value = {
|
|
"provider": "vonage",
|
|
"application_id": request.application_id,
|
|
"private_key": request.private_key,
|
|
"api_key": getattr(request, "api_key", None),
|
|
"api_secret": getattr(request, "api_secret", None),
|
|
"from_numbers": request.from_numbers,
|
|
}
|
|
elif request.provider == "vobiz":
|
|
config_value = {
|
|
"provider": "vobiz",
|
|
"auth_id": request.auth_id,
|
|
"auth_token": request.auth_token,
|
|
"from_numbers": request.from_numbers,
|
|
}
|
|
elif request.provider == "cloudonix":
|
|
config_value = {
|
|
"provider": "cloudonix",
|
|
"bearer_token": request.bearer_token,
|
|
"domain_id": request.domain_id,
|
|
"from_numbers": request.from_numbers,
|
|
}
|
|
else:
|
|
raise HTTPException(
|
|
status_code=400, detail=f"Unsupported provider: {request.provider}"
|
|
)
|
|
|
|
if existing_config and existing_config.value:
|
|
existing_provider = existing_config.value.get("provider")
|
|
|
|
if existing_provider == request.provider:
|
|
preserve_masked_fields(request, existing_config, config_value)
|
|
|
|
await db_client.upsert_configuration(
|
|
user.selected_organization_id,
|
|
OrganizationConfigurationKey.TELEPHONY_CONFIGURATION.value,
|
|
config_value,
|
|
)
|
|
|
|
return {"message": "Telephony configuration saved successfully"}
|
|
|
|
|
|
def preserve_masked_fields(request, existing_config, config_value):
|
|
provider = request.provider
|
|
masked_fields = PROVIDER_MASKED_FIELDS.get(provider, [])
|
|
|
|
for field_name in masked_fields:
|
|
if hasattr(request, field_name):
|
|
field_value = getattr(request, field_name)
|
|
# Check if field has a value and is a masked version of the existing value
|
|
if field_value and is_mask_of(
|
|
field_value, existing_config.value.get(field_name, "")
|
|
):
|
|
config_value[field_name] = existing_config.value[field_name]
|
|
|
|
|
|
class RetryConfigResponse(BaseModel):
|
|
enabled: bool
|
|
max_retries: int
|
|
retry_delay_seconds: int
|
|
retry_on_busy: bool
|
|
retry_on_no_answer: bool
|
|
retry_on_voicemail: bool
|
|
|
|
|
|
class CampaignLimitsResponse(BaseModel):
|
|
concurrent_call_limit: int
|
|
from_numbers_count: int
|
|
default_retry_config: RetryConfigResponse
|
|
|
|
|
|
@router.get("/campaign-limits", response_model=CampaignLimitsResponse)
|
|
async def get_campaign_limits(user: UserModel = Depends(get_user)):
|
|
"""Get campaign limits for the user's organization.
|
|
|
|
Returns the organization's concurrent call limit and default retry configuration.
|
|
"""
|
|
if not user.selected_organization_id:
|
|
raise HTTPException(status_code=400, detail="No organization selected")
|
|
|
|
# Get concurrent call limit
|
|
concurrent_limit = DEFAULT_ORG_CONCURRENCY_LIMIT
|
|
try:
|
|
config = await db_client.get_configuration(
|
|
user.selected_organization_id,
|
|
OrganizationConfigurationKey.CONCURRENT_CALL_LIMIT.value,
|
|
)
|
|
if config and config.value:
|
|
concurrent_limit = int(
|
|
config.value.get("value", DEFAULT_ORG_CONCURRENCY_LIMIT)
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
# Get from_numbers count from telephony configuration
|
|
from_numbers_count = 0
|
|
try:
|
|
telephony_config = await db_client.get_configuration(
|
|
user.selected_organization_id,
|
|
OrganizationConfigurationKey.TELEPHONY_CONFIGURATION.value,
|
|
)
|
|
if telephony_config and telephony_config.value:
|
|
from_numbers = telephony_config.value.get("from_numbers", [])
|
|
from_numbers_count = len(from_numbers)
|
|
except Exception:
|
|
pass
|
|
|
|
return CampaignLimitsResponse(
|
|
concurrent_call_limit=concurrent_limit,
|
|
from_numbers_count=from_numbers_count,
|
|
default_retry_config=RetryConfigResponse(**DEFAULT_CAMPAIGN_RETRY_CONFIG),
|
|
)
|