amliq-dashboard 2.0.0

package/src/api/billing.ts

@@ -0,0 +1,54 @@
+import { api } from './client';
+import type { Product, Subscription, UsageRecord, Seat, Invoice } from '../types/billing';
+
+export async function getProducts(): Promise<Product[]> {
+  return api.get<Product[]>('/billing/products');
+}
+
+export async function getSubscriptions(): Promise<Subscription[]> {
+  return api.get<Subscription[]>('/billing/subscriptions');
+}
+
+export async function createCheckout(
+  product: string,
+  planId: string,
+  promoCode?: string,
+  billingPeriod: 'monthly' | 'annual' = 'monthly',
+): Promise<{ checkoutUrl: string }> {
+  return api.post('/billing/checkout', { product, planId, promoCode, billingPeriod });
+}
+
+export async function getSeats(): Promise<Seat[]> {
+  return api.get<Seat[]>('/billing/seats');
+}
+
+export async function addSeat(email: string, role: string): Promise<Seat> {
+  return api.post<Seat>('/billing/seats', { email, role });
+}
+
+export async function removeSeat(userId: string): Promise<void> {
+  return api.del(`/billing/seats/${userId}`);
+}
+
+export async function getUsage(product: string): Promise<UsageRecord | null> {
+  return api.get<UsageRecord | null>(`/billing/usage?product=${product}`);
+}
+
+export async function applyPromoCode(code: string): Promise<{ discountPercent: number; message: string }> {
+  return api.post('/billing/promo', { code });
+}
+
+export async function getInvoices(): Promise<Invoice[]> {
+  return api.get<Invoice[]>('/billing/invoices');
+}
+
+export interface BillingHealth {
+  status: string;
+  mode: string;
+  ls_configured: boolean;
+  webhook_enabled: boolean;
+}
+
+export async function getBillingHealth(): Promise<BillingHealth> {
+  return api.get<BillingHealth>('/billing/health');
+}

package/src/api/cases.ts

@@ -0,0 +1,48 @@
+import { api } from './client';
+
+export interface ComplianceCase {
+  id: string;
+  alert_id: string;
+  status: 'open' | 'assigned' | 'escalated' | 'resolved';
+  assigned_to: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CaseDetail extends ComplianceCase {
+  comments: CaseComment[];
+}
+
+export interface CaseComment {
+  id: string;
+  case_id: string;
+  author: string;
+  body: string;
+  created_at: string;
+}
+
+interface CaseListResponse {
+  data: ComplianceCase[];
+  total: number;
+}
+
+export const casesApi = {
+  list: (status?: string) => {
+    const qs = status ? `?status=${status}` : '';
+    return api.get<CaseListResponse>(`/cases${qs}`);
+  },
+  get: (id: string) =>
+    api.get<CaseDetail>(`/cases/${id}`),
+  assign: (id: string, userId: string) =>
+    api.put<ComplianceCase>(`/cases/${id}/assign`, { user_id: userId }),
+  escalate: (id: string, reason: string) =>
+    api.put<ComplianceCase>(`/cases/${id}/escalate`, { reason }),
+  resolve: (id: string, resolution: string, notes: string) =>
+    api.put<ComplianceCase>(`/cases/${id}/resolve`, { resolution, notes }),
+  review: (id: string, disposition: string, justification: string) =>
+    api.put<{ status: string; message: string }>(`/cases/${id}/review`, { disposition, justification }),
+  bulkResolve: (caseIds: string[], disposition: string, justification: string) =>
+    api.post<{ resolved: number; total: number }>('/cases/bulk-resolve', {
+      case_ids: caseIds, disposition, justification,
+    }),
+};

package/src/api/client.ts

@@ -0,0 +1,50 @@
+const API_BASE = import.meta.env.VITE_API_URL || 'http://localhost:8080';
+
+export class ApiError extends Error {
+  constructor(public code: string, message: string, public status: number) {
+    super(message);
+    this.name = 'ApiError';
+  }
+}
+
+function getAuthHeaders(): Record<string, string> {
+  const token = localStorage.getItem('amliq_token');
+  if (!token) return {};
+  return { Authorization: `Bearer ${token}` };
+}
+
+export async function fetchApi<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const url = `${API_BASE}/api/v1${endpoint}`;
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...getAuthHeaders(),
+    ...(options.headers as Record<string, string>),
+  };
+
+  const resp = await fetch(url, { ...options, headers });
+  if (resp.status === 401) {
+    localStorage.removeItem('amliq_token');
+    if (!endpoint.endsWith('/auth/me')) {
+      window.location.href = '/login';
+    }
+    throw new ApiError('UNAUTHORIZED', 'Session expired', 401);
+  }
+  if (!resp.ok) {
+    const body = await resp.json().catch(() => ({}));
+    throw new ApiError(body.code || 'ERROR', body.message || resp.statusText, resp.status);
+  }
+  const json = await resp.json();
+  return (json.data != null ? json.data : json) as T;
+}
+
+export const api = {
+  get: <T,>(ep: string) => fetchApi<T>(ep),
+  post: <T,>(ep: string, body: unknown) =>
+    fetchApi<T>(ep, { method: 'POST', body: JSON.stringify(body) }),
+  put: <T,>(ep: string, body: unknown) =>
+    fetchApi<T>(ep, { method: 'PUT', body: JSON.stringify(body) }),
+  del: <T,>(ep: string) => fetchApi<T>(ep, { method: 'DELETE' }),
+};

package/src/api/config.ts

@@ -0,0 +1,30 @@
+import { api } from './client';
+
+export interface TenantConfigResponse {
+  country: string;
+  regulation_framework: string[];
+  enabled_lists: ListConfigItem[];
+  default_threshold: number;
+  match_weights: Record<string, number>;
+  auto_dismiss_below: number;
+  auto_escalate_above: number;
+  screening_mode: string;
+  batch_schedule: string;
+  max_batch_size: number;
+}
+
+export interface ListConfigItem {
+  list_id: string;
+  source_url: string;
+  custom_source_url: string;
+  parser_type: string;
+  sync_schedule: string;
+  sync_enabled: boolean;
+  threshold: number;
+}
+
+export const configApi = {
+  get: () => api.get<TenantConfigResponse>('/config'),
+  update: (data: Partial<TenantConfigResponse>) =>
+    api.put<TenantConfigResponse>('/config', data),
+};

package/src/api/edd.ts

@@ -0,0 +1,25 @@
+import { api } from './client';
+
+export interface EDDReport {
+  id: string;
+  entity_name: string;
+  entity_type: string;
+  status: 'pending' | 'in_progress' | 'completed';
+  risk_level: string;
+  findings: string;
+  created_at: string;
+  completed_at: string | null;
+}
+
+export interface CreateEDDPayload {
+  entity_name: string;
+  entity_type?: string;
+  reason: string;
+}
+
+export const eddApi = {
+  create: (payload: CreateEDDPayload) =>
+    api.post<EDDReport>('/edd', payload),
+  get: (id: string) =>
+    api.get<EDDReport>(`/edd/${id}`),
+};

package/src/api/enforcement.ts

@@ -0,0 +1,33 @@
+import { api } from './client';
+
+export interface EnforcementAction {
+  id: string;
+  entity_name: string;
+  regulator: string;
+  action_type: string;
+  amount?: number;
+  currency?: string;
+  date: string;
+  description: string;
+  url: string;
+  jurisdiction: string;
+}
+
+interface EnforcementSearchResponse {
+  query: string;
+  results: EnforcementAction[];
+  total: number;
+}
+
+interface EnforcementEntityResponse {
+  entity_id: string;
+  actions: EnforcementAction[];
+  total: number;
+}
+
+export const enforcementApi = {
+  search: (query: string) =>
+    api.get<EnforcementSearchResponse>(`/enforcement/search?q=${encodeURIComponent(query)}`),
+  getByEntity: (entityId: string) =>
+    api.get<EnforcementEntityResponse>(`/enforcement/entity/${entityId}`),
+};

package/src/api/lists.ts

@@ -0,0 +1,24 @@
+import { api } from './client';
+
+interface ListMeta {
+  id: string;
+  source_url: string;
+  custom_url: string;
+  parser_type: string;
+  entity_count: number;
+  last_synced: number;
+  sync_enabled: boolean;
+  threshold: number;
+}
+
+interface ListsResponse {
+  lists: ListMeta[];
+}
+
+export const listsApi = {
+  list: () => api.get<ListsResponse>('/lists'),
+  get: (id: string) => api.get<ListMeta>(`/lists/${id}`),
+  sync: (id: string) => api.post(`/lists/${id}/sync`, {}),
+};
+
+export type { ListMeta };

package/src/api/monitoring.ts

@@ -0,0 +1,82 @@
+import { api } from './client';
+
+export interface MonitorProfile {
+  id: string;
+  entity_name: string;
+  entity_type: string;
+  risk_level: 'low' | 'medium' | 'high' | 'critical';
+  lists_to_screen: string[];
+  frequency: 'realtime' | 'daily' | 'weekly';
+  status: 'active' | 'paused' | 'expired';
+  last_screened_at: string | null;
+  next_screen_at: string;
+  match_count: number;
+  created_at: string;
+}
+
+export interface MonitorAlert {
+  id: string;
+  profile_id: string;
+  alert_type: string;
+  match_score: number;
+  matched_entity: string;
+  severity: 'critical' | 'high' | 'medium' | 'low';
+  reviewed_by: string;
+  reviewed_at: string | null;
+  disposition: string;
+  created_at: string;
+}
+
+export interface MonitorDashboard {
+  active_profiles: number;
+  total_profiles: number;
+  pending_alerts: number;
+  total_alerts: number;
+  by_severity: Record<string, number>;
+}
+
+interface ProfileListResponse {
+  profiles: MonitorProfile[];
+  total: number;
+}
+
+interface AlertListResponse {
+  alerts: MonitorAlert[];
+  total: number;
+}
+
+interface CreateProfilePayload {
+  entity_name: string;
+  entity_type: string;
+  risk_level: string;
+  frequency?: string;
+  lists?: string[];
+}
+
+interface UpdateProfilePayload {
+  frequency?: string;
+  lists?: string[];
+  status?: 'active' | 'paused';
+}
+
+export const monitoringApi = {
+  listProfiles: () =>
+    api.get<ProfileListResponse>('/monitor'),
+  addProfile: (payload: CreateProfilePayload) =>
+    api.post<MonitorProfile>('/monitor', payload),
+  updateProfile: (id: string, payload: UpdateProfilePayload) =>
+    api.put<MonitorProfile>(`/monitor/${id}`, payload),
+  deleteProfile: (id: string) =>
+    api.del<{ status: string }>(`/monitor/${id}`),
+  listAlerts: (params?: { severity?: string; status?: string }) => {
+    const qs = new URLSearchParams(params as Record<string, string>).toString();
+    return api.get<AlertListResponse>(`/monitor/alerts${qs ? `?${qs}` : ''}`);
+  },
+  reviewAlert: (id: string, disposition: string, reviewedBy: string) =>
+    api.put<MonitorAlert>(`/monitor/alerts/${id}/review`, {
+      disposition,
+      reviewed_by: reviewedBy,
+    }),
+  getDashboard: () =>
+    api.get<MonitorDashboard>('/monitor/dashboard'),
+};

package/src/api/pep.ts

@@ -0,0 +1,30 @@
+import { api } from './client';
+
+export interface PEPProfile {
+  id: string;
+  name: string;
+  country: string;
+  position: string;
+  level: 'head_of_state' | 'senior_official' | 'regional' | 'family' | 'associate';
+  active: boolean;
+}
+
+export interface PEPScreenResult {
+  is_pep: boolean;
+  confidence: number;
+  matches: PEPProfile[];
+}
+
+interface PEPListResponse {
+  profiles: PEPProfile[];
+  total: number;
+}
+
+export const pepApi = {
+  screen: (name: string, country?: string) =>
+    api.post<PEPScreenResult>('/pep/screen', { name, country }),
+  listByCountry: (country?: string) => {
+    const qs = country ? `?country=${country}` : '';
+    return api.get<PEPListResponse>(`/pep${qs}`);
+  },
+};

package/src/api/risk.ts

@@ -0,0 +1,26 @@
+import { api } from './client';
+
+export interface RiskScoreRequest {
+  entity_name: string;
+  entity_type?: string;
+  country?: string;
+  factors?: Record<string, unknown>;
+}
+
+export interface RiskScoreResult {
+  score: number;
+  level: 'low' | 'medium' | 'high' | 'critical';
+  factors: RiskFactor[];
+}
+
+export interface RiskFactor {
+  name: string;
+  weight: number;
+  contribution: number;
+  description: string;
+}
+
+export const riskApi = {
+  score: (payload: RiskScoreRequest) =>
+    api.post<RiskScoreResult>('/risk/score', payload),
+};

package/src/api/screening.ts

@@ -0,0 +1,37 @@
+import { api } from './client';
+import type { ScreenResponse } from '../types';
+
+export interface ScreenPayload {
+  entity_name: string;
+  entity_type?: string;
+  dob?: string;
+  nationality?: string;
+  lists?: string[];
+  threshold?: number;
+}
+
+export interface FastScreenResult {
+  match: boolean;
+  confidence: number;
+  matched_name?: string;
+  list_id?: string;
+}
+
+export interface ScreeningQuota {
+  used: number;
+  limit: number;
+  remaining: number;
+  plan_name: string;
+  has_subscription: boolean;
+}
+
+export const screeningApi = {
+  screen: (data: ScreenPayload) =>
+    api.post<ScreenResponse>('/screen', data),
+  screenFast: (name: string) =>
+    api.post<FastScreenResult>('/screen/fast', { name }),
+  getResult: (id: string) =>
+    api.get<ScreenResponse>(`/screen/${id}`),
+  getQuota: () =>
+    api.get<ScreeningQuota>('/screening/quota'),
+};

package/src/api/team.ts

@@ -0,0 +1,27 @@
+import { api } from './client';
+
+export interface TeamMember {
+  id: string;
+  email: string;
+  role: 'admin' | 'analyst' | 'auditor' | 'viewer';
+  status: 'active' | 'invited' | 'disabled';
+  joined_at: string;
+}
+
+interface TeamListResponse {
+  members: TeamMember[];
+}
+
+interface InvitePayload {
+  email: string;
+  role: TeamMember['role'];
+}
+
+export const teamApi = {
+  list: () =>
+    api.get<TeamListResponse>('/team'),
+  invite: (payload: InvitePayload) =>
+    api.post<TeamMember>('/team/invite', payload),
+  updateRole: (id: string, role: TeamMember['role']) =>
+    api.put<TeamMember>(`/team/${id}/role`, { role }),
+};

package/src/api/transactions.ts

@@ -0,0 +1,37 @@
+import { api } from './client';
+
+export interface Transaction {
+  id: string;
+  sender: string;
+  receiver: string;
+  amount: number;
+  currency: string;
+  submitted_at: string;
+}
+
+export interface TxnAlert {
+  id: string;
+  transaction_id: string;
+  rule: string;
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  created_at: string;
+}
+
+interface TxnAlertListResponse {
+  alerts: TxnAlert[];
+  total: number;
+}
+
+interface TxnAlertSummary {
+  total: number;
+  by_severity: Record<string, number>;
+}
+
+export const transactionsApi = {
+  submit: (txn: Omit<Transaction, 'id' | 'submitted_at'>) =>
+    api.post<Transaction>('/transactions', txn),
+  listAlerts: () =>
+    api.get<TxnAlertListResponse>('/transactions/alerts'),
+  alertSummary: () =>
+    api.get<TxnAlertSummary>('/transactions/alerts/summary'),
+};

package/src/components/admin/TenantCards.tsx

@@ -0,0 +1,51 @@
+import { TFunction } from 'i18next'
+
+interface ScreeningSectionProps {
+  label: string
+  count: number
+  t: TFunction
+}
+
+export function ScreeningSection({ label, count, t }: ScreeningSectionProps) {
+  return (
+    <div className="card-vibrancy p-xl">
+      <h2 className="sf-headline mb-md">{label}</h2>
+      <p className="sf-body">
+        {t('tenant_detail.total_screenings', { count })}
+      </p>
+    </div>
+  )
+}
+
+interface ConfigSectionProps {
+  threshold: string
+  setThreshold: (v: string) => void
+  onSave: () => void
+  t: TFunction
+}
+
+export function ConfigSection({
+  threshold, setThreshold, onSave, t,
+}: ConfigSectionProps) {
+  return (
+    <div className="card-vibrancy p-xl">
+      <h2 className="sf-headline mb-md">
+        {t('tenant_detail.config_override')}
+      </h2>
+      <div className="flex items-center gap-md">
+        <label htmlFor="threshold-input" className="sf-body">
+          {t('tenant_detail.match_threshold')}
+        </label>
+        <input id="threshold-input" type="number" min="50" max="99"
+          value={threshold}
+          aria-label={t('tenant_detail.match_threshold')}
+          onChange={e => setThreshold(e.target.value)}
+          className="input-field w-20" />
+        <button onClick={onSave} className="button-primary"
+          aria-label={t('tenant_detail.save')}>
+          {t('tenant_detail.save')}
+        </button>
+      </div>
+    </div>
+  )
+}

package/src/components/alerts/AlertActions.test.tsx

@@ -0,0 +1,80 @@
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { describe, it, expect, vi } from 'vitest'
+import { AlertActions } from './AlertActions'
+
+describe('AlertActions', () => {
+  it('renders actions card title', () => {
+    render(<AlertActions />)
+    expect(screen.getByText('Actions')).toBeInTheDocument()
+  })
+
+  it('renders confirm button', () => {
+    render(<AlertActions />)
+    const buttons = screen.getAllByRole('button')
+    expect(buttons.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('calls onConfirm when confirm button clicked', async () => {
+    const handler = vi.fn()
+    render(<AlertActions onConfirm={handler} />)
+    const buttons = screen.getAllByRole('button')
+    await userEvent.click(buttons[0])
+    expect(handler).toHaveBeenCalledOnce()
+  })
+
+  it('calls onFalsePositive when false positive button clicked', async () => {
+    const handler = vi.fn()
+    render(<AlertActions onFalsePositive={handler} />)
+    const buttons = screen.getAllByRole('button')
+    await userEvent.click(buttons[1])
+    expect(handler).toHaveBeenCalledOnce()
+  })
+
+  it('calls onEscalate when escalate button clicked', async () => {
+    const handler = vi.fn()
+    render(<AlertActions onEscalate={handler} />)
+    const buttons = screen.getAllByRole('button')
+    await userEvent.click(buttons[2])
+    expect(handler).toHaveBeenCalledOnce()
+  })
+
+  it('calls onDraftAI when AI draft button clicked', async () => {
+    const handler = vi.fn()
+    render(<AlertActions onDraftAI={handler} />)
+    const buttons = screen.getAllByRole('button')
+    await userEvent.click(buttons[3])
+    expect(handler).toHaveBeenCalledOnce()
+  })
+
+  it('disables all buttons when disabled prop is true', () => {
+    render(<AlertActions disabled={true} />)
+    const buttons = screen.getAllByRole('button')
+    buttons.forEach(btn => {
+      expect(btn).toBeDisabled()
+    })
+  })
+
+  it('renders 4 action buttons', () => {
+    render(<AlertActions />)
+    const buttons = screen.getAllByRole('button')
+    expect(buttons.length).toBe(4)
+  })
+
+  it('only disables buttons when disabled true and handlers exist', async () => {
+    const handler = vi.fn()
+    render(
+      <AlertActions
+        onConfirm={handler}
+        onFalsePositive={handler}
+        onEscalate={handler}
+        onDraftAI={handler}
+        disabled={false}
+      />
+    )
+    const buttons = screen.getAllByRole('button')
+    buttons.forEach(btn => {
+      expect(btn).not.toBeDisabled()
+    })
+  })
+})