109 lines
4.2 KiB
Python
109 lines
4.2 KiB
Python
"""
|
|
Copyright 2024-2026 ReplyPier
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
"""
|
|
|
|
from typing import List
|
|
from uuid import UUID
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.api.channels.accounts import get_org_account_or_404, to_account_out
|
|
from app.channels.sms import get_provider, list_providers
|
|
from app.core.auth import get_current_organization, require_permissions
|
|
from app.core.config import settings
|
|
from app.database import get_db
|
|
from app.models.channels import ChannelType
|
|
from app.models.organization import Organization
|
|
from app.models.schemas.channel import ChannelAccountOut, SmsConnectRequest, SmsProviderInfo
|
|
from app.models.user import User
|
|
from app.repositories.channels import ChannelAccountRepository
|
|
from app.core.logger import get_logger
|
|
|
|
router = APIRouter()
|
|
logger = get_logger(__name__)
|
|
|
|
|
|
@router.get("/providers", response_model=List[SmsProviderInfo])
|
|
async def list_sms_providers(
|
|
current_user: User = Depends(require_permissions("manage_organization")),
|
|
):
|
|
"""Available SMS providers and the credential fields each needs — drives
|
|
the connect form's provider dropdown."""
|
|
return [
|
|
SmsProviderInfo(
|
|
name=p.name, label=p.label,
|
|
fields=[{"key": f.key, "label": f.label, "secret": f.secret, "optional": f.optional}
|
|
for f in p.credential_fields],
|
|
)
|
|
for p in list_providers()
|
|
]
|
|
|
|
|
|
@router.post("", response_model=ChannelAccountOut)
|
|
async def connect_sms(
|
|
request: SmsConnectRequest,
|
|
current_user: User = Depends(require_permissions("manage_organization")),
|
|
organization: Organization = Depends(get_current_organization),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
"""Connect an SMS number through one of the supported providers. Validates
|
|
the credentials with the provider before saving."""
|
|
provider = get_provider(request.provider)
|
|
if provider is None:
|
|
raise HTTPException(status_code=400, detail=f"Unknown SMS provider '{request.provider}'")
|
|
|
|
phone = request.phone_number.strip()
|
|
try:
|
|
await provider.validate_credentials(phone, request.credentials)
|
|
except ValueError as e:
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
|
|
repo = ChannelAccountRepository(db)
|
|
existing = repo.get_by_external_id(ChannelType.SMS.value, phone)
|
|
if existing is not None:
|
|
if existing.organization_id != organization.id:
|
|
raise HTTPException(status_code=409, detail="This number is already connected to another organization")
|
|
repo.update_credentials(existing, request.credentials)
|
|
existing.settings = {**(existing.settings or {}), "provider": request.provider}
|
|
db.commit()
|
|
account = repo.set_active(existing, True)
|
|
else:
|
|
account = repo.create_account(
|
|
organization_id=organization.id,
|
|
channel_type=ChannelType.SMS.value,
|
|
external_account_id=phone,
|
|
credentials=request.credentials,
|
|
display_name=f"SMS {phone} ({provider.label})",
|
|
settings={"provider": request.provider},
|
|
)
|
|
out = to_account_out(db, account)
|
|
out.webhook_url = f"{settings.BACKEND_URL.rstrip('/')}{settings.API_V1_STR}/webhooks/sms/{request.provider}/{account.id}"
|
|
return out
|
|
|
|
|
|
@router.delete("/{account_id}")
|
|
async def disconnect_sms(
|
|
account_id: UUID,
|
|
current_user: User = Depends(require_permissions("manage_organization")),
|
|
organization: Organization = Depends(get_current_organization),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
account = get_org_account_or_404(db, account_id, organization)
|
|
if account.channel_type != ChannelType.SMS.value:
|
|
raise HTTPException(status_code=404, detail="Channel account not found")
|
|
ChannelAccountRepository(db).delete(account)
|
|
return {"status": "disconnected"}
|