feat: Actions system — scheduled mutations on external services
Full-stack implementation of provider-scoped Actions with extensible executor architecture. First action type: Immich auto_organize (sort assets into albums by person, CLIP search, date range, favorites). Core: - ActionTypeDefinition registry + ActionExecutor ABC with execute/validate/dry-run - ImmichActionExecutor with multi-album support and client-side filtering - ImmichClient write methods: add/remove assets, create album, paginated search Server: - Action, ActionRule, ActionExecution DB models - Full CRUD API + manual execute + dry-run + execution history endpoints - APScheduler integration (interval + cron) for automated execution - Action type discovery API + provider people endpoint Frontend: - Actions page with CRUD, execute/dry-run buttons, inline rule editor - RuleEditor: person/album MultiEntitySelect pickers, criteria config - ExecutionHistory: expandable per-rule result details - MultiEntitySelect reusable component (searchable multi-pick palette) - Notification tracker album picker migrated to MultiEntitySelect - Fixed MdiIcon race condition (icons missing after cache-clearing reload)
This commit is contained in:
@@ -0,0 +1,162 @@
|
||||
"""Action rule management API routes."""
|
||||
|
||||
import logging
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, status
|
||||
from pydantic import BaseModel
|
||||
from sqlmodel import select
|
||||
from sqlmodel.ext.asyncio.session import AsyncSession
|
||||
|
||||
from ..auth.dependencies import get_current_user
|
||||
from ..database.engine import get_session
|
||||
from ..database.models import Action, ActionRule, User
|
||||
|
||||
_LOGGER = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/api/actions", tags=["action-rules"])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Request schemas
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class ActionRuleCreate(BaseModel):
|
||||
name: str = ""
|
||||
rule_config: dict = {}
|
||||
enabled: bool = True
|
||||
order: int = 0
|
||||
|
||||
|
||||
class ActionRuleUpdate(BaseModel):
|
||||
name: str | None = None
|
||||
rule_config: dict | None = None
|
||||
enabled: bool | None = None
|
||||
order: int | None = None
|
||||
|
||||
|
||||
class ReorderBody(BaseModel):
|
||||
rule_ids: list[int]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _rule_response(rule: ActionRule) -> dict:
|
||||
return {
|
||||
"id": rule.id,
|
||||
"action_id": rule.action_id,
|
||||
"name": rule.name,
|
||||
"rule_config": rule.rule_config,
|
||||
"enabled": rule.enabled,
|
||||
"order": rule.order,
|
||||
"created_at": rule.created_at.isoformat() if rule.created_at else None,
|
||||
}
|
||||
|
||||
|
||||
async def _get_user_action(
|
||||
session: AsyncSession, action_id: int, user: User
|
||||
) -> Action:
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
return action
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Routes
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@router.get("/{action_id}/rules")
|
||||
async def list_rules(
|
||||
action_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
await _get_user_action(session, action_id, user)
|
||||
result = await session.exec(
|
||||
select(ActionRule)
|
||||
.where(ActionRule.action_id == action_id)
|
||||
.order_by(ActionRule.order)
|
||||
)
|
||||
return [_rule_response(r) for r in result.all()]
|
||||
|
||||
|
||||
@router.post("/{action_id}/rules", status_code=status.HTTP_201_CREATED)
|
||||
async def create_rule(
|
||||
action_id: int,
|
||||
body: ActionRuleCreate,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
await _get_user_action(session, action_id, user)
|
||||
rule = ActionRule(action_id=action_id, **body.model_dump())
|
||||
session.add(rule)
|
||||
await session.commit()
|
||||
await session.refresh(rule)
|
||||
return _rule_response(rule)
|
||||
|
||||
|
||||
@router.put("/{action_id}/rules/reorder")
|
||||
async def reorder_rules(
|
||||
action_id: int,
|
||||
body: ReorderBody,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
await _get_user_action(session, action_id, user)
|
||||
result = await session.exec(
|
||||
select(ActionRule).where(ActionRule.action_id == action_id)
|
||||
)
|
||||
rules_by_id = {r.id: r for r in result.all()}
|
||||
|
||||
for idx, rule_id in enumerate(body.rule_ids):
|
||||
rule = rules_by_id.get(rule_id)
|
||||
if rule:
|
||||
rule.order = idx
|
||||
session.add(rule)
|
||||
|
||||
await session.commit()
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@router.put("/{action_id}/rules/{rule_id}")
|
||||
async def update_rule(
|
||||
action_id: int,
|
||||
rule_id: int,
|
||||
body: ActionRuleUpdate,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
await _get_user_action(session, action_id, user)
|
||||
rule = await session.get(ActionRule, rule_id)
|
||||
if not rule or rule.action_id != action_id:
|
||||
raise HTTPException(status_code=404, detail="Rule not found")
|
||||
|
||||
updates = body.model_dump(exclude_unset=True)
|
||||
for key, value in updates.items():
|
||||
setattr(rule, key, value)
|
||||
session.add(rule)
|
||||
await session.commit()
|
||||
await session.refresh(rule)
|
||||
return _rule_response(rule)
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/{action_id}/rules/{rule_id}", status_code=status.HTTP_204_NO_CONTENT
|
||||
)
|
||||
async def delete_rule(
|
||||
action_id: int,
|
||||
rule_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
await _get_user_action(session, action_id, user)
|
||||
rule = await session.get(ActionRule, rule_id)
|
||||
if not rule or rule.action_id != action_id:
|
||||
raise HTTPException(status_code=404, detail="Rule not found")
|
||||
await session.delete(rule)
|
||||
await session.commit()
|
||||
@@ -0,0 +1,78 @@
|
||||
"""Action type discovery API routes."""
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
|
||||
from notify_bridge_core.providers.actions import (
|
||||
get_action_type,
|
||||
get_action_types,
|
||||
get_all_action_types,
|
||||
)
|
||||
from notify_bridge_core.providers.capabilities import get_all_capabilities
|
||||
|
||||
from ..auth.dependencies import get_current_user
|
||||
from ..database.models import User
|
||||
|
||||
router = APIRouter(prefix="/api/action-types", tags=["action-types"])
|
||||
|
||||
|
||||
@router.get("")
|
||||
async def list_all_action_types(
|
||||
user: User = Depends(get_current_user),
|
||||
):
|
||||
"""All action types grouped by provider."""
|
||||
all_types = get_all_action_types()
|
||||
result: dict[str, list[dict]] = {}
|
||||
for provider_type, defns in all_types.items():
|
||||
result[provider_type] = [
|
||||
{
|
||||
"key": d.key,
|
||||
"provider_type": d.provider_type,
|
||||
"display_name": d.display_name,
|
||||
"description": d.description,
|
||||
}
|
||||
for d in defns
|
||||
]
|
||||
# Also include providers with no action types (from capabilities)
|
||||
all_caps = get_all_capabilities()
|
||||
for ptype in all_caps:
|
||||
if ptype not in result:
|
||||
result[ptype] = []
|
||||
return result
|
||||
|
||||
|
||||
@router.get("/{provider_type}")
|
||||
async def list_provider_action_types(
|
||||
provider_type: str,
|
||||
user: User = Depends(get_current_user),
|
||||
):
|
||||
"""Action types for a specific provider."""
|
||||
defns = get_action_types(provider_type)
|
||||
return [
|
||||
{
|
||||
"key": d.key,
|
||||
"provider_type": d.provider_type,
|
||||
"display_name": d.display_name,
|
||||
"description": d.description,
|
||||
}
|
||||
for d in defns
|
||||
]
|
||||
|
||||
|
||||
@router.get("/{provider_type}/{key}/schema")
|
||||
async def get_action_type_schema(
|
||||
provider_type: str,
|
||||
key: str,
|
||||
user: User = Depends(get_current_user),
|
||||
):
|
||||
"""Get rule and config JSON schemas for an action type."""
|
||||
defn = get_action_type(provider_type, key)
|
||||
if not defn:
|
||||
raise HTTPException(status_code=404, detail="Action type not found")
|
||||
return {
|
||||
"key": defn.key,
|
||||
"provider_type": defn.provider_type,
|
||||
"display_name": defn.display_name,
|
||||
"description": defn.description,
|
||||
"rule_schema": defn.rule_schema,
|
||||
"config_schema": defn.config_schema,
|
||||
}
|
||||
@@ -0,0 +1,291 @@
|
||||
"""Action management API routes — CRUD, execute, dry-run, executions."""
|
||||
|
||||
import logging
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
||||
from pydantic import BaseModel
|
||||
from sqlmodel import select
|
||||
from sqlmodel.ext.asyncio.session import AsyncSession
|
||||
|
||||
from ..auth.dependencies import get_current_user
|
||||
from ..database.engine import get_session
|
||||
from ..database.models import (
|
||||
Action,
|
||||
ActionExecution,
|
||||
ActionRule,
|
||||
ServiceProvider,
|
||||
User,
|
||||
)
|
||||
|
||||
_LOGGER = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/api/actions", tags=["actions"])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Request / response schemas
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class ActionCreate(BaseModel):
|
||||
provider_id: int
|
||||
name: str
|
||||
icon: str = ""
|
||||
action_type: str
|
||||
config: dict = {}
|
||||
schedule_type: str = "interval"
|
||||
schedule_interval: int = 3600
|
||||
schedule_cron: str = ""
|
||||
enabled: bool = False
|
||||
|
||||
|
||||
class ActionUpdate(BaseModel):
|
||||
name: str | None = None
|
||||
icon: str | None = None
|
||||
config: dict | None = None
|
||||
schedule_type: str | None = None
|
||||
schedule_interval: int | None = None
|
||||
schedule_cron: str | None = None
|
||||
enabled: bool | None = None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
async def _action_response(session: AsyncSession, action: Action) -> dict:
|
||||
"""Build response dict with rules inlined."""
|
||||
result = await session.exec(
|
||||
select(ActionRule)
|
||||
.where(ActionRule.action_id == action.id)
|
||||
.order_by(ActionRule.order)
|
||||
)
|
||||
rules = result.all()
|
||||
return {
|
||||
"id": action.id,
|
||||
"user_id": action.user_id,
|
||||
"provider_id": action.provider_id,
|
||||
"name": action.name,
|
||||
"icon": action.icon,
|
||||
"action_type": action.action_type,
|
||||
"config": action.config,
|
||||
"schedule_type": action.schedule_type,
|
||||
"schedule_interval": action.schedule_interval,
|
||||
"schedule_cron": action.schedule_cron,
|
||||
"enabled": action.enabled,
|
||||
"last_run_at": action.last_run_at.isoformat() if action.last_run_at else None,
|
||||
"last_run_status": action.last_run_status,
|
||||
"created_at": action.created_at.isoformat() if action.created_at else None,
|
||||
"rules": [
|
||||
{
|
||||
"id": r.id,
|
||||
"action_id": r.action_id,
|
||||
"name": r.name,
|
||||
"rule_config": r.rule_config,
|
||||
"enabled": r.enabled,
|
||||
"order": r.order,
|
||||
"created_at": r.created_at.isoformat() if r.created_at else None,
|
||||
}
|
||||
for r in rules
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# CRUD
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@router.get("")
|
||||
async def list_actions(
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
result = await session.exec(
|
||||
select(Action).where(Action.user_id == user.id)
|
||||
)
|
||||
actions = result.all()
|
||||
return [await _action_response(session, a) for a in actions]
|
||||
|
||||
|
||||
@router.post("", status_code=status.HTTP_201_CREATED)
|
||||
async def create_action(
|
||||
body: ActionCreate,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
provider = await session.get(ServiceProvider, body.provider_id)
|
||||
if not provider or provider.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Provider not found")
|
||||
|
||||
# Validate action_type against the registry
|
||||
from notify_bridge_core.providers.actions import get_action_type
|
||||
if not get_action_type(provider.type, body.action_type):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Invalid action type '{body.action_type}' for provider type '{provider.type}'",
|
||||
)
|
||||
|
||||
action = Action(user_id=user.id, **body.model_dump())
|
||||
session.add(action)
|
||||
await session.commit()
|
||||
await session.refresh(action)
|
||||
|
||||
if action.enabled:
|
||||
from ..services.scheduler import schedule_action
|
||||
await schedule_action(
|
||||
action.id,
|
||||
action.schedule_type,
|
||||
action.schedule_interval,
|
||||
action.schedule_cron,
|
||||
)
|
||||
|
||||
return await _action_response(session, action)
|
||||
|
||||
|
||||
@router.get("/{action_id}")
|
||||
async def get_action(
|
||||
action_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
return await _action_response(session, action)
|
||||
|
||||
|
||||
@router.put("/{action_id}")
|
||||
async def update_action(
|
||||
action_id: int,
|
||||
body: ActionUpdate,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
|
||||
updates = body.model_dump(exclude_unset=True)
|
||||
for key, value in updates.items():
|
||||
setattr(action, key, value)
|
||||
session.add(action)
|
||||
await session.commit()
|
||||
await session.refresh(action)
|
||||
|
||||
# Reschedule or unschedule based on enabled state
|
||||
from ..services.scheduler import schedule_action, unschedule_action
|
||||
if action.enabled:
|
||||
await schedule_action(
|
||||
action.id,
|
||||
action.schedule_type,
|
||||
action.schedule_interval,
|
||||
action.schedule_cron,
|
||||
)
|
||||
else:
|
||||
await unschedule_action(action.id)
|
||||
|
||||
return await _action_response(session, action)
|
||||
|
||||
|
||||
@router.delete("/{action_id}", status_code=status.HTTP_204_NO_CONTENT)
|
||||
async def delete_action(
|
||||
action_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
|
||||
# Unschedule
|
||||
from ..services.scheduler import unschedule_action
|
||||
await unschedule_action(action.id)
|
||||
|
||||
# Bulk delete rules and executions
|
||||
from sqlalchemy import delete
|
||||
await session.exec(delete(ActionRule).where(ActionRule.action_id == action_id))
|
||||
await session.exec(delete(ActionExecution).where(ActionExecution.action_id == action_id))
|
||||
|
||||
await session.delete(action)
|
||||
await session.commit()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Execute / Dry-run
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@router.post("/{action_id}/execute")
|
||||
async def execute_action(
|
||||
action_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
|
||||
from ..services.action_runner import run_action
|
||||
result = await run_action(action_id, trigger="manual")
|
||||
return result.to_dict()
|
||||
|
||||
|
||||
@router.post("/{action_id}/dry-run")
|
||||
async def dry_run_action(
|
||||
action_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
|
||||
from ..services.action_runner import dry_run_action as _dry_run
|
||||
result = await _dry_run(action_id)
|
||||
return result.to_dict()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Execution history
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@router.get("/{action_id}/executions")
|
||||
async def list_executions(
|
||||
action_id: int,
|
||||
limit: int = Query(default=20, le=100),
|
||||
offset: int = Query(default=0, ge=0),
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
action = await session.get(Action, action_id)
|
||||
if not action or action.user_id != user.id:
|
||||
raise HTTPException(status_code=404, detail="Action not found")
|
||||
|
||||
result = await session.exec(
|
||||
select(ActionExecution)
|
||||
.where(ActionExecution.action_id == action_id)
|
||||
.order_by(ActionExecution.started_at.desc())
|
||||
.offset(offset)
|
||||
.limit(limit)
|
||||
)
|
||||
executions = result.all()
|
||||
return [
|
||||
{
|
||||
"id": e.id,
|
||||
"action_id": e.action_id,
|
||||
"started_at": e.started_at.isoformat() if e.started_at else None,
|
||||
"finished_at": e.finished_at.isoformat() if e.finished_at else None,
|
||||
"status": e.status,
|
||||
"rules_processed": e.rules_processed,
|
||||
"rules_succeeded": e.rules_succeeded,
|
||||
"rules_failed": e.rules_failed,
|
||||
"total_items_affected": e.total_items_affected,
|
||||
"summary": e.summary,
|
||||
"error": e.error,
|
||||
"trigger": e.trigger,
|
||||
}
|
||||
for e in executions
|
||||
]
|
||||
@@ -193,6 +193,7 @@ async def list_provider_capabilities():
|
||||
"commands": caps.commands,
|
||||
"supported_filters": caps.supported_filters,
|
||||
"webhook_based": caps.webhook_based,
|
||||
"action_types": caps.action_types,
|
||||
}
|
||||
return result
|
||||
|
||||
@@ -351,6 +352,29 @@ async def test_provider(
|
||||
return {"ok": False, "message": f"Unknown provider type: {provider.type}"}
|
||||
|
||||
|
||||
@router.get("/{provider_id}/people")
|
||||
async def list_people(
|
||||
provider_id: int,
|
||||
user: User = Depends(get_current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Fetch people from a service provider (Immich only)."""
|
||||
provider = await _get_user_provider(session, provider_id, user.id)
|
||||
|
||||
if provider.type == "immich":
|
||||
from notify_bridge_core.providers.immich.client import ImmichClient
|
||||
async with aiohttp.ClientSession() as http_session:
|
||||
client = ImmichClient(
|
||||
http_session,
|
||||
provider.config.get("url", ""),
|
||||
provider.config.get("api_key", ""),
|
||||
)
|
||||
people_dict = await client.get_people()
|
||||
return [{"id": pid, "name": name} for pid, name in people_dict.items()]
|
||||
|
||||
return []
|
||||
|
||||
|
||||
@router.get("/{provider_id}/collections")
|
||||
async def list_collections(
|
||||
provider_id: int,
|
||||
|
||||
Reference in New Issue
Block a user