Skip to content

Open-source personal finance manager. Self-hosted, privacy-first.

Add categorization rules import/export (#338)

Romulo Gatto272b7d3d7d76
diff --git a/backend/app/api/rules.py b/backend/app/api/rules.py
index 18924a92..f0fafc6f 100644
--- a/backend/app/api/rules.py
+++ b/backend/app/api/rules.py
@@ -1,6 +1,7 @@
import uuid
from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.database import get_async_session
@@ -9,7 +10,14 @@ from app.core.workspace_context import (
current_workspace,
current_writable_workspace,
)
-from app.schemas.rule import RuleCreate, RuleCreateResponse, RuleRead, RuleUpdate
+from app.schemas.rule import (
+ RuleCreate,
+ RuleCreateResponse,
+ RuleImportRequest,
+ RuleImportResponse,
+ RuleRead,
+ RuleUpdate,
+)
from app.services import rule_service
from app.services.rule_service import DuplicateRuleError
@@ -45,6 +53,41 @@ async def create_rule(
return response
+async def export_rules(
+ ctx: WorkspaceContext = Depends(current_workspace),
+ session: AsyncSession = Depends(get_async_session),
+):
+ payload = await rule_service.export_rules(session, ctx.workspace.id)
+ return JSONResponse(
+ content=payload.model_dump(mode="json"),
+ headers={
+ "Content-Disposition": 'attachment; filename="securo-categorization-rules.json"',
+ },
+ )
+
+
[email protected]("/import", response_model=RuleImportResponse)
+async def import_rules(
+ data: RuleImportRequest,
+ ctx: WorkspaceContext = Depends(current_writable_workspace),
+ session: AsyncSession = Depends(get_async_session),
+):
+ try:
+ return await rule_service.import_rules(
+ session,
+ ctx.workspace.id,
+ ctx.user_id,
+ data.payload,
+ overwrite=data.overwrite,
+ )
+ except DuplicateRuleError:
+ raise HTTPException(
+ status_code=status.HTTP_409_CONFLICT,
+ detail="Import would overwrite existing rules. Confirm overwrite to continue.",
+ )
+
+
@router.patch("/{rule_id}", response_model=RuleRead)
async def update_rule(
rule_id: uuid.UUID,
diff --git a/backend/app/schemas/rule.py b/backend/app/schemas/rule.py
index 1404ae72..dab995a2 100644
--- a/backend/app/schemas/rule.py
+++ b/backend/app/schemas/rule.py
@@ -51,3 +51,29 @@ class RuleCreateResponse(RuleRead):
"""A created rule plus how many existing transactions it just affected."""
applied_count: int = 0
+
+
+class RuleExportItem(BaseModel):
+ name: str
+ conditions_op: str = "and"
+ conditions: list[RuleCondition]
+ actions: list[RuleAction]
+ priority: int = 0
+ is_active: bool = True
+
+
+class RuleExportPayload(BaseModel):
+ format: str = "securo-categorization-rules"
+ version: int = 1
+ rules: list[RuleExportItem]
+
+
+class RuleImportRequest(BaseModel):
+ payload: RuleExportPayload
+ overwrite: bool = False
+
+
+class RuleImportResponse(BaseModel):
+ imported: int
+ skipped: int
+ overwritten: int
diff --git a/backend/app/services/rule_service.py b/backend/app/services/rule_service.py
index 77a0bf44..d8624205 100644
--- a/backend/app/services/rule_service.py
+++ b/backend/app/services/rule_service.py
@@ -2,13 +2,13 @@
import uuid
from typing import Optional
-from sqlalchemy import select
+from sqlalchemy import delete, select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.rule import Rule
from app.models.category import Category
from app.models.transaction import Transaction
-from app.schemas.rule import RuleCreate, RuleUpdate
+from app.schemas.rule import RuleCreate, RuleExportPayload, RuleImportResponse, RuleUpdate
from app.services.rule_engine import evaluate_conditions, apply_rule_actions
from app.services.category_service import DEFAULT_CATEGORIES_I18N
@@ -757,6 +757,113 @@ async def get_rules(session: AsyncSession, workspace_id: uuid.UUID) -> list[Rule
return list(result.scalars().all())
+
+
+async def export_rules(session: AsyncSession, workspace_id: uuid.UUID) -> RuleExportPayload:
+ """Return a portable JSON export of rules for a workspace.
+
+ Category actions are serialized by category name rather than UUID so the
+ file can be imported into another instance/workspace that has equivalent
+ category names but different database IDs.
+ """
+ rules = await get_rules(session, workspace_id)
+ category_result = await session.execute(
+ select(Category).where(Category.workspace_id == workspace_id)
+ )
+ category_names = {str(cat.id): cat.name for cat in category_result.scalars().all()}
+
+ exported_rules = []
+ for rule in rules:
+ actions = []
+ for action in rule.actions or []:
+ if action.get("op") == "set_category":
+ category_name = category_names.get(str(action.get("value")))
+ if not category_name:
+ continue
+ actions.append({**action, "value": category_name})
+ else:
+ actions.append(action)
+ exported_rules.append({
+ "name": rule.name,
+ "conditions_op": rule.conditions_op,
+ "conditions": rule.conditions or [],
+ "actions": actions,
+ "priority": rule.priority,
+ "is_active": rule.is_active,
+ })
+ return RuleExportPayload(rules=exported_rules)
+
+
+async def import_rules(
+ session: AsyncSession,
+ workspace_id: uuid.UUID,
+ user_id: uuid.UUID,
+ payload: RuleExportPayload,
+ overwrite: bool = False,
+) -> RuleImportResponse:
+ """Import a portable rules payload into a workspace.
+
+ Existing rules are only replaced when the caller explicitly passes
+ `overwrite=True`. Rules whose `set_category` target cannot be matched by
+ category name are skipped.
+ """
+ existing = await get_rules(session, workspace_id)
+ if existing and not overwrite:
+ raise DuplicateRuleError("Import would overwrite existing rules")
+
+ category_result = await session.execute(
+ select(Category).where(Category.workspace_id == workspace_id)
+ )
+ categories_by_name = {cat.name: str(cat.id) for cat in category_result.scalars().all()}
+
+ imported = 0
+ skipped = 0
+ rules_to_create: list[Rule] = []
+ seen_names: set[str] = set()
+
+ for incoming in payload.rules:
+ if incoming.name in seen_names:
+ skipped += 1
+ continue
+ seen_names.add(incoming.name)
+ resolved_actions = []
+ missing_required_reference = False
+ for action in incoming.actions:
+ action_data = action.model_dump()
+ if action_data["op"] == "set_category":
+ category_id = categories_by_name.get(str(action_data["value"]))
+ if not category_id:
+ missing_required_reference = True
+ break
+ action_data["value"] = category_id
+ resolved_actions.append(action_data)
+ if missing_required_reference:
+ skipped += 1
+ continue
+ rules_to_create.append(Rule(
+ user_id=user_id,
+ workspace_id=workspace_id,
+ name=incoming.name,
+ conditions_op=incoming.conditions_op,
+ conditions=[condition.model_dump() for condition in incoming.conditions],
+ actions=resolved_actions,
+ priority=incoming.priority,
+ is_active=incoming.is_active,
+ ))
+
+ overwritten = 0
+ if overwrite and existing and rules_to_create:
+ overwritten = len(existing)
+ await session.execute(delete(Rule).where(Rule.workspace_id == workspace_id))
+
+ for rule in rules_to_create:
+ session.add(rule)
+ imported += 1
+
+ await session.commit()
+ return RuleImportResponse(imported=imported, skipped=skipped, overwritten=overwritten)
+
+
async def get_rule(session: AsyncSession, rule_id: uuid.UUID, workspace_id: uuid.UUID) -> Optional[Rule]:
result = await session.execute(
select(Rule).where(Rule.id == rule_id, Rule.workspace_id == workspace_id)
diff --git a/backend/tests/test_new_rules_api.py b/backend/tests/test_new_rules_api.py
index 7b7665a9..9357a4ed 100644
--- a/backend/tests/test_new_rules_api.py
+++ b/backend/tests/test_new_rules_api.py
@@ -396,3 +396,121 @@ async def test_rule_user_isolation(
items = response.json()["items"]
# Verify user1 still has transactions
assert len(items) >= 5
+
+
+async def test_export_rules_serializes_category_actions_by_name(client: AsyncClient, auth_headers, test_rules, test_categories):
+ response = await client.get("/api/rules/export", headers=auth_headers)
+
+ assert response.status_code == 200
+ assert response.headers["content-type"].startswith("application/json")
+ assert response.headers["content-disposition"].startswith("attachment;")
+ payload = response.json()
+ assert payload["format"] == "securo-categorization-rules"
+ assert payload["version"] == 1
+ exported = {rule["name"]: rule for rule in payload["rules"]}
+ assert set(exported) == {"UBER rule", "IFOOD rule", "SALARIO rule"}
+ uber_action = exported["UBER rule"]["actions"][0]
+ assert uber_action == {"op": "set_category", "value": "Transporte"}
+ assert "id" not in exported["UBER rule"]
+ assert "user_id" not in exported["UBER rule"]
+
+
+async def test_import_rules_requires_overwrite_confirmation_when_rules_exist(
+ client: AsyncClient, auth_headers, test_rules, test_categories
+):
+ payload = {
+ "format": "securo-categorization-rules",
+ "version": 1,
+ "rules": [
+ {
+ "name": "Imported Netflix",
+ "conditions_op": "and",
+ "conditions": [{"field": "description", "op": "contains", "value": "NETFLIX"}],
+ "actions": [{"op": "set_category", "value": "Alimentação"}],
+ "priority": 7,
+ "is_active": True,
+ }
+ ],
+ }
+
+ response = await client.post("/api/rules/import", json={"payload": payload}, headers=auth_headers)
+
+ assert response.status_code == 409
+ assert "overwrite" in response.json()["detail"].lower()
+
+
+async def test_import_rules_overwrites_existing_rules_and_maps_categories_by_name(
+ client: AsyncClient, auth_headers, test_rules, test_categories
+):
+ payload = {
+ "format": "securo-categorization-rules",
+ "version": 1,
+ "rules": [
+ {
+ "name": "Imported Netflix",
+ "conditions_op": "and",
+ "conditions": [{"field": "description", "op": "contains", "value": "NETFLIX"}],
+ "actions": [{"op": "set_category", "value": "Alimentação"}],
+ "priority": 7,
+ "is_active": True,
+ },
+ {
+ "name": "Missing category rule",
+ "conditions_op": "and",
+ "conditions": [{"field": "description", "op": "contains", "value": "UNKNOWN"}],
+ "actions": [{"op": "set_category", "value": "Does Not Exist"}],
+ "priority": 8,
+ "is_active": True,
+ },
+ ],
+ }
+
+ response = await client.post(
+ "/api/rules/import",
+ json={"payload": payload, "overwrite": True},
+ headers=auth_headers,
+ )
+
+ assert response.status_code == 200
+ assert response.json() == {"imported": 1, "skipped": 1, "overwritten": 3}
+ rules_response = await client.get("/api/rules", headers=auth_headers)
+ rules = rules_response.json()
+ assert [r["name"] for r in rules] == ["Imported Netflix"]
+ assert rules[0]["actions"] == [{"op": "set_category", "value": str(test_categories[0].id)}]
+
+
+async def test_import_rules_with_overwrite_preserves_existing_when_every_rule_is_skipped(
+ client: AsyncClient, auth_headers, test_rules
+):
+ payload = {
+ "format": "securo-categorization-rules",
+ "version": 1,
+ "rules": [
+ {
+ "name": "External groceries rule",
+ "conditions_op": "and",
+ "conditions": [{"field": "description", "op": "contains", "value": "MARKET"}],
+ "actions": [{"op": "set_category", "value": "Groceries"}],
+ "priority": 7,
+ "is_active": True,
+ }
+ ],
+ }
+
+ before_response = await client.get("/api/rules", headers=auth_headers)
+ before_names = [rule["name"] for rule in before_response.json()]
+
+ response = await client.post(
+ "/api/rules/import",
+ json={"payload": payload, "overwrite": True},
+ headers=auth_headers,
+ )
+
+ assert response.status_code == 200
+ assert response.json() == {"imported": 0, "skipped": 1, "overwritten": 0}
+ after_response = await client.get("/api/rules", headers=auth_headers)
+ assert [rule["name"] for rule in after_response.json()] == before_names
diff --git a/docs/rules-export-import-toolbar.png b/docs/rules-export-import-toolbar.png
new file mode 100644
index 00000000..3b49120e
Binary files /dev/null and b/docs/rules-export-import-toolbar.png differ
diff --git a/docs/rules-import-overwrite-confirmation.png b/docs/rules-import-overwrite-confirmation.png
new file mode 100644
index 00000000..e6999e1d
Binary files /dev/null and b/docs/rules-import-overwrite-confirmation.png differ
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index c967fe85..a6785a84 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -23,6 +23,8 @@ import type {
Budget,
BudgetVsActual,
Rule,
+ RuleExportPayload,
+ RuleImportResponse,
ImportLog,
ImportPreviewTransaction,
Workspace,
@@ -803,6 +805,22 @@ export const rules = {
const { data } = await api.post('/rules/apply-all')
return data
},
+ exportFile: async (): Promise<void> => {
+ const { data } = await api.get('/rules/export', { responseType: 'blob' })
+ const blob = new Blob([data], { type: 'application/json;charset=utf-8;' })
+ const url = URL.createObjectURL(blob)
+ const a = document.createElement('a')
+ a.href = url
+ a.download = `securo-categorization-rules-${new Date().toISOString().slice(0, 10)}.json`
+ document.body.appendChild(a)
+ a.click()
+ document.body.removeChild(a)
+ URL.revokeObjectURL(url)
+ },
+ importFile: async (payload: RuleExportPayload, overwrite = false): Promise<RuleImportResponse> => {
+ const { data } = await api.post('/rules/import', { payload, overwrite })
+ return data
+ },
packs: async (): Promise<{ code: string; name: string; flag: string; rule_count: number; installed: boolean }[]> => {
const { data } = await api.get('/rules/packs')
return data
diff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.json
index c7dba952..76082a79 100644
--- a/frontend/src/locales/en.json
+++ b/frontend/src/locales/en.json
@@ -789,7 +789,16 @@
"sortLabel": "Sort by",
"sortBy_priority": "Priority",
"sortBy_name": "Name",
- "sortBy_category": "Category"
+ "sortBy_category": "Category",
+ "export": "Export",
+ "import": "Import",
+ "exported": "Rules export downloaded",
+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",
+ "invalidImportFile": "Invalid rules import file",
+ "importConfirmTitle": "Import categorization rules?",
+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",
+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",
+ "confirmOverwriteImport": "Overwrite and import"
},
"categories": {
"title": "Categories",
diff --git a/frontend/src/locales/es.json b/frontend/src/locales/es.json
index 0946e547..5fe4afeb 100644
--- a/frontend/src/locales/es.json
+++ b/frontend/src/locales/es.json
@@ -789,7 +789,16 @@
"sortLabel": "Ordenar por",
"sortBy_priority": "Prioridad",
"sortBy_name": "Nombre",
- "sortBy_category": "Categoría"
+ "sortBy_category": "Categoría",
+ "export": "Export",
+ "import": "Import",
+ "exported": "Rules export downloaded",
+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",
+ "invalidImportFile": "Invalid rules import file",
+ "importConfirmTitle": "Import categorization rules?",
+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",
+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",
+ "confirmOverwriteImport": "Overwrite and import"
},
"categories": {
"title": "Categorías",
diff --git a/frontend/src/locales/it.json b/frontend/src/locales/it.json
index fdadb4dd..7595712b 100644
--- a/frontend/src/locales/it.json
+++ b/frontend/src/locales/it.json
@@ -789,7 +789,16 @@
"sortLabel": "Ordina per",
"sortBy_priority": "Priorità",
"sortBy_name": "Nome",
- "sortBy_category": "Categoria"
+ "sortBy_category": "Categoria",
+ "export": "Export",
+ "import": "Import",
+ "exported": "Rules export downloaded",
+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",
+ "invalidImportFile": "Invalid rules import file",
+ "importConfirmTitle": "Import categorization rules?",
+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",
+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",
+ "confirmOverwriteImport": "Overwrite and import"
},
"categories": {
"title": "Categorie",
diff --git a/frontend/src/locales/pl.json b/frontend/src/locales/pl.json
index 99d18ac9..db185d23 100644
--- a/frontend/src/locales/pl.json
+++ b/frontend/src/locales/pl.json
@@ -843,7 +843,16 @@
"sortLabel": "Sortuj wg",
"sortBy_priority": "Priorytet",
"sortBy_name": "Nazwa",
- "sortBy_category": "Kategoria"
+ "sortBy_category": "Kategoria",
+ "export": "Export",
+ "import": "Import",
+ "exported": "Rules export downloaded",
+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",
+ "invalidImportFile": "Invalid rules import file",
+ "importConfirmTitle": "Import categorization rules?",
+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",
+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",
+ "confirmOverwriteImport": "Overwrite and import"
},
"categories": {
"title": "Kategorie",
diff --git a/frontend/src/locales/pt-BR.json b/frontend/src/locales/pt-BR.json
index febe008a..f792047c 100644
--- a/frontend/src/locales/pt-BR.json
+++ b/frontend/src/locales/pt-BR.json
@@ -789,7 +789,16 @@
"sortLabel": "Ordenar por",
"sortBy_priority": "Prioridade",
"sortBy_name": "Nome",
- "sortBy_category": "Categoria"
+ "sortBy_category": "Categoria",
+ "export": "Export",
+ "import": "Import",
+ "exported": "Rules export downloaded",
+ "imported": "Imported {{imported}} rules ({{skipped}} skipped)",
+ "invalidImportFile": "Invalid rules import file",
+ "importConfirmTitle": "Import categorization rules?",
+ "importConfirmDescription": "File {{file}} contains {{count}} rules.",
+ "importOverwriteWarning": "Importing will overwrite your current categorization rules. This cannot be undone.",
+ "confirmOverwriteImport": "Overwrite and import"
},
"categories": {
"title": "Categorias",
diff --git a/frontend/src/pages/rules.tsx b/frontend/src/pages/rules.tsx
index 41a6637b..59389bd9 100644
--- a/frontend/src/pages/rules.tsx
+++ b/frontend/src/pages/rules.tsx
@@ -1,4 +1,4 @@
-import { useState, useMemo } from 'react'
+import { useRef, useState, useMemo } from 'react'
import { useTranslation } from 'react-i18next'
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { categories as categoriesApi, categoryGroups as categoryGroupsApi, rules as rulesApi, accounts as accountsApi, payees as payeesApi } from '@/lib/api'
@@ -12,8 +12,8 @@ import {
DialogHeader,
DialogTitle,
} from '@/components/ui/dialog'
-import type { Category, Payee, Rule, RuleAction, RuleCondition } from '@/types'
-import { Trash2, Plus, RefreshCw, Package, Check, ArrowUpDown, ArrowUp, ArrowDown } from 'lucide-react'
+import type { Category, Payee, Rule, RuleAction, RuleCondition, RuleExportPayload } from '@/types'
+import { Trash2, Plus, RefreshCw, Package, Check, ArrowUpDown, ArrowUp, ArrowDown, Download, Upload } from 'lucide-react'
import { cn } from '@/lib/utils'
import { PageHeader } from '@/components/page-header'
import { useWorkspace } from '@/contexts/workspace-context'
@@ -116,6 +116,10 @@ export default function RulesPage() {
const { canWrite } = useWorkspace()
const [dialogOpen, setDialogOpen] = useState(false)
const [packsDialogOpen, setPacksDialogOpen] = useState(false)
+ const [importDialogOpen, setImportDialogOpen] = useState(false)
+ const [pendingImport, setPendingImport] = useState<RuleExportPayload | null>(null)
+ const [pendingImportName, setPendingImportName] = useState('')
+ const importInputRef = useRef<HTMLInputElement | null>(null)
const [editing, setEditing] = useState<Rule | null>(null)
// Bumped on every open so the dialog remounts with fresh state instead of
// retaining the previously entered rule (issue #306).
@@ -221,8 +225,44 @@ export default function RulesPage() {
onError: () => toast.error(t('common.error')),
})
- const categories = categoriesList ?? []
- const payees = payeesList ?? []
+ const exportMutation = useMutation({
+ mutationFn: () => rulesApi.exportFile(),
+ onSuccess: () => toast.success(t('rules.exported')),
+ onError: () => toast.error(t('common.error')),
+ })
+
+ const importMutation = useMutation({
+ mutationFn: (payload: RuleExportPayload) => rulesApi.importFile(payload, true),
+ onSuccess: (data) => {
+ queryClient.invalidateQueries({ queryKey: ['rules'] })
+ queryClient.invalidateQueries({ queryKey: ['rule-packs'] })
+ setImportDialogOpen(false)
+ setPendingImport(null)
+ setPendingImportName('')
+ toast.success(t('rules.imported', { imported: data.imported, skipped: data.skipped }))
+ },
+ onError: () => toast.error(t('common.error')),
+ })
+
+ async function handleImportFile(file: File) {
+ try {
+ const parsed = JSON.parse(await file.text()) as RuleExportPayload
+ if (parsed.format !== 'securo-categorization-rules' || !Array.isArray(parsed.rules)) {
+ toast.error(t('rules.invalidImportFile'))
+ return
+ }
+ setPendingImport(parsed)
+ setPendingImportName(file.name)
+ setImportDialogOpen(true)
+ } catch {
+ toast.error(t('rules.invalidImportFile'))
+ } finally {
+ if (importInputRef.current) importInputRef.current.value = ''
+ }
+ }
+
+ const categories = useMemo(() => categoriesList ?? [], [categoriesList])
+ const payees = useMemo(() => payeesList ?? [], [payeesList])
const [sortBy, setSortBy] = useState<'priority' | 'name' | 'category'>('priority')
const [sortDir, setSortDir] = useState<'asc' | 'desc'>('asc')
@@ -255,6 +295,36 @@ export default function RulesPage() {
action={
canWrite ? (
<div className="flex gap-2">
+ <input
+ ref={importInputRef}
+ type="file"
+ accept="application/json,.json"
+ className="hidden"
+ onChange={(event) => {
+ const file = event.target.files?.[0]
+ if (file) void handleImportFile(file)
+ }}
+ />
+ <Button
+ variant="outline"
+ size="sm"
+ className="gap-1.5 h-8"
+ onClick={() => exportMutation.mutate()}
+ disabled={exportMutation.isPending}
+ >
+ <Download size={12} />
+ <span className="hidden sm:inline">{t('rules.export')}</span>
+ </Button>
+ <Button
+ variant="outline"
+ size="sm"
+ className="gap-1.5 h-8"
+ onClick={() => importInputRef.current?.click()}
+ disabled={importMutation.isPending}
+ >
+ <Upload size={12} />
+ <span className="hidden sm:inline">{t('rules.import')}</span>
+ </Button>
<Button
variant="outline"
size="sm"
@@ -360,6 +430,36 @@ export default function RulesPage() {
onClose={() => setPacksDialogOpen(false)}
/>
+ <Dialog open={importDialogOpen} onOpenChange={setImportDialogOpen}>
+ <DialogContent className="max-w-md">
+ <DialogHeader>
+ <DialogTitle>{t('rules.importConfirmTitle')}</DialogTitle>
+ </DialogHeader>
+ <div className="space-y-3 text-sm text-muted-foreground">
+ <p>{t('rules.importConfirmDescription', { count: pendingImport?.rules.length ?? 0, file: pendingImportName })}</p>
+ <p className="font-medium text-amber-600">{t('rules.importOverwriteWarning')}</p>
+ </div>
+ <div className="flex justify-end gap-2 pt-2">
+ <Button
+ type="button"
+ variant="outline"
+ onClick={() => { setImportDialogOpen(false); setPendingImport(null); setPendingImportName('') }}
+ disabled={importMutation.isPending}
+ >
+ {t('common.cancel')}
+ </Button>
+ <Button
+ type="button"
+ variant="destructive"
+ onClick={() => { if (pendingImport) importMutation.mutate(pendingImport) }}
+ disabled={!pendingImport || importMutation.isPending}
+ >
+ {t('rules.confirmOverwriteImport')}
+ </Button>
+ </div>
+ </DialogContent>
+ </Dialog>
+
<RuleDialog
key={dialogInstance}
open={dialogOpen}
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 8b7b1125..8ca083c0 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -356,6 +356,27 @@ export interface Rule {
is_active: boolean
}
+export interface RuleExportItem {
+ name: string
+ conditions_op: 'and' | 'or'
+ conditions: RuleCondition[]
+ actions: RuleAction[]
+ priority: number
+ is_active: boolean
+}
+
+export interface RuleExportPayload {
+ format: 'securo-categorization-rules'
+ version: number
+ rules: RuleExportItem[]
+}
+
+export interface RuleImportResponse {
+ imported: number
+ skipped: number
+ overwritten: number
+}
+
export interface ImportLog {
id: string
user_id: string