@fayz-ai/plugin-agenda 0.1.3

package/src/bridges/create-financial-bridge.ts

@@ -0,0 +1,298 @@
+// ---------------------------------------------------------------------------
+// Bridge factory: adapts FinancialDataProvider → AgendaFinancialBridge
+// Consumer apps call this at plugin wiring time.
+// ---------------------------------------------------------------------------
+
+import type { FinancialDataProvider } from '@fayz-ai/plugin-financial'
+import type { AgendaFinancialBridge, BookingPaymentSummary, BookingPaymentDetail, BookingPaymentStatus } from '../financial-bridge'
+import { getSupabaseClientOptional } from '@fayz-ai/core'
+
+/**
+ * Pure commission math: percentage of a realized order total, rounded to cents.
+ * Exported for unit-testing and reuse; the bridge method below wraps the I/O.
+ * Returns 0 for a non-positive base or rate so callers can skip empty accruals.
+ */
+export function computeCommissionAmount(total: number, ratePercent: number): number {
+  const base = Number(total) || 0
+  const rate = Number(ratePercent) || 0
+  if (base <= 0 || rate <= 0) return 0
+  return Math.round(base * (rate / 100) * 100) / 100
+}
+
+function computeStatus(movements: Array<{ status: string }>): BookingPaymentStatus {
+  if (movements.length === 0) return 'none'
+  const allPaid = movements.every((m) => m.status === 'paid')
+  if (allPaid) return 'paid'
+  const allCancelled = movements.every((m) => m.status === 'cancelled')
+  if (allCancelled) return 'cancelled'
+  const anyOverdue = movements.some((m) => m.status === 'overdue')
+  if (anyOverdue) return 'overdue'
+  const anyPaid = movements.some((m) => m.status === 'paid' || m.status === 'partial')
+  if (anyPaid) return 'partial'
+  return 'pending'
+}
+
+/**
+ * Create an AgendaFinancialBridge backed by the financial plugin's data provider.
+ *
+ * @example
+ * const financialProvider = createSupabaseFinancialProvider()
+ * const agenda = createAgendaPlugin({
+ *   financialBridge: createFinancialBridge(financialProvider),
+ * })
+ */
+export function createFinancialBridge(provider: FinancialDataProvider): AgendaFinancialBridge {
+  return {
+    async resolvePaymentStatuses(orderIds: string[]): Promise<Map<string, BookingPaymentSummary>> {
+      const result = new Map<string, BookingPaymentSummary>()
+      if (orderIds.length === 0) return result
+
+      // Single batch query instead of N individual getInvoiceById calls
+      const supabase = getSupabaseClientOptional() as any
+      if (!supabase) return result
+
+      try {
+        const [{ data: orders }, { data: movements }] = await Promise.all([
+          supabase
+            .schema('saas_core')
+            .from('orders')
+            .select('id, kind, status, total, reference_number, metadata')
+            .in('id', orderIds),
+          supabase
+            .from('financial_movements')
+            .select('invoice_id, status, paid_amount')
+            .in('invoice_id', orderIds),
+        ])
+
+        const movementsByOrderId = new Map<string, Array<{ status: string; paid_amount: number }>>()
+        for (const movement of movements ?? []) {
+          const invoiceId = movement.invoice_id as string | undefined
+          if (!invoiceId) continue
+          movementsByOrderId.set(invoiceId, [...(movementsByOrderId.get(invoiceId) ?? []), movement])
+        }
+
+        for (const order of orders ?? []) {
+          const orderMovements = movementsByOrderId.get(order.id) ?? []
+          const meta = (order.metadata ?? {}) as Record<string, unknown>
+          const paidAmount = orderMovements.length > 0
+            ? orderMovements.reduce((sum, movement) => sum + (Number(movement.paid_amount) || 0), 0)
+            : Number(meta.paidAmount) || 0
+
+          result.set(order.id, {
+            invoiceId: order.id,
+            referenceNumber: order.reference_number as string | undefined,
+            status: orderMovements.length > 0 ? computeStatus(orderMovements) : mapInvoiceStatus(order.status as string),
+            totalAmount: Number(order.total) || 0,
+            paidAmount,
+          })
+        }
+      } catch { /* non-blocking */ }
+
+      return result
+    },
+
+    async getPaymentDetail(orderId: string): Promise<BookingPaymentDetail | null> {
+      const supabase = getSupabaseClientOptional() as any
+      if (!supabase) return null
+
+      // Single query: get order + movements in parallel
+      const [orderRes, movRes] = await Promise.all([
+        supabase.schema('saas_core').from('orders').select('id, status, total, reference_number, metadata').eq('id', orderId).single(),
+        supabase.from('financial_movements').select('*').eq('invoice_id', orderId).order('due_date'),
+      ])
+
+      const order = orderRes.data
+      if (!order) return null
+      const meta = (order.metadata ?? {}) as Record<string, unknown>
+
+      // Collect unique payment_method_type_ids to resolve names in one query
+      const typeIds = [...new Set((movRes.data ?? []).map((m: any) => m.payment_method_type_id).filter(Boolean))]
+      let typeNames: Record<string, string> = {}
+      if (typeIds.length > 0) {
+        const { data: types } = await supabase.from('payment_method_types').select('id, name').in('id', typeIds)
+        typeNames = Object.fromEntries((types ?? []).map((t: any) => [t.id, t.name]))
+      }
+
+      const movements = (movRes.data ?? []).map((m: Record<string, unknown>) => ({
+        id: String(m.id),
+        amount: Number(m.amount) || 0,
+        paidAmount: Number(m.paid_amount) || 0,
+        status: String(m.status ?? 'pending'),
+        dueDate: String(m.due_date ?? ''),
+        installmentNumber: m.installment_number != null ? Number(m.installment_number) : undefined,
+        paymentDate: m.payment_date ? String(m.payment_date) : undefined,
+        paymentMethodTypeName: m.payment_method_type_id ? typeNames[String(m.payment_method_type_id)] : undefined,
+        cardBrand: m.card_brand ? String(m.card_brand) : undefined,
+        cardInstallments: m.card_installments ? Number(m.card_installments) : undefined,
+      }))
+
+      return {
+        invoiceId: order.id,
+        referenceNumber: order.reference_number as string | undefined,
+        status: movements.length > 0 ? computeStatus(movements) : mapInvoiceStatus(order.status as string),
+        totalAmount: Number(order.total) || 0,
+        paidAmount: Number(meta.paidAmount) || 0,
+        movements,
+      }
+    },
+
+    async createInvoiceFromOrder(orderId: string, options?: {
+      installments?: number
+      dueDate?: string
+      paymentMethodTypeId?: string
+    }): Promise<string> {
+      // Promote the existing order to an invoice_receivable atomically via the
+      // shared DB function (ref + stage/direction + N installments, idempotent).
+      // status='invoiced' is valid for appointment/service_order (CHECK).
+      const supabase = getSupabaseClientOptional() as any
+      if (!supabase) throw new Error('Supabase not available')
+      const { error } = await supabase.rpc('fn_invoice_from_order', {
+        p_order_id: orderId,
+        p_due_date: options?.dueDate ?? null,
+        p_status: 'invoiced',
+        p_installments: options?.installments ?? 1,
+        p_direction: 'credit',
+      })
+      if (error) throw new Error(error.message)
+      return orderId
+    },
+
+    async payMovement(input) {
+      await provider.payMovement({
+        movementId: input.movementId,
+        amount: input.amount,
+        paymentDate: input.paymentDate,
+        paymentMethodTypeId: input.paymentMethodTypeId,
+        paymentMethodId: input.paymentMethodId,
+        bankAccountId: input.bankAccountId,
+        cardBrand: input.cardBrand,
+        cardInstallments: input.cardInstallments,
+      })
+    },
+
+    async createCommissionMovement(orderId, options) {
+      const supabase = getSupabaseClientOptional() as any
+      if (!supabase) return null
+
+      // Order carries the assigned professional (assignee_id) and realized total.
+      const { data: order } = await supabase
+        .schema('saas_core')
+        .from('orders')
+        .select('id, tenant_id, assignee_id, total')
+        .eq('id', orderId)
+        .single()
+      if (!order || !order.assignee_id) return null // no professional → no commission
+
+      // Per-professional rate lives on staff_members, surfaced via v_staff (id = person id).
+      const { data: staff } = await supabase
+        .from('v_staff')
+        .select('commission_rate')
+        .eq('id', order.assignee_id)
+        .single()
+
+      const rate = Number(staff?.commission_rate) || 0
+      const base = Number(order.total) || 0
+      const amount = computeCommissionAmount(base, rate)
+      if (amount <= 0) return null // nothing configured/realized to accrue
+
+      // Idempotent: one commission accrual per order. Reuse if already present.
+      const { data: existing } = await supabase
+        .from('financial_movements')
+        .select('id')
+        .eq('invoice_id', orderId)
+        .eq('movement_kind', 'commission')
+        .limit(1)
+      if (existing && existing.length > 0) return existing[0].id as string
+
+      const dueDate = options?.dueDate ?? new Date().toISOString().slice(0, 10)
+
+      const { data: inserted } = await supabase
+        .from('financial_movements')
+        .insert({
+          tenant_id: order.tenant_id,
+          invoice_id: orderId,
+          direction: 'debit', // payable to the professional
+          movement_kind: 'commission',
+          amount,
+          paid_amount: 0,
+          status: 'pending',
+          due_date: dueDate,
+          metadata: {
+            source: 'agenda',
+            kind: 'commission',
+            professionalId: order.assignee_id,
+            commissionRate: rate,
+            baseAmount: base,
+          },
+        })
+        .select('id')
+        .single()
+
+      return (inserted?.id as string | undefined) ?? null
+    },
+
+    async checkout(orderId, input) {
+      // 1. Create invoice (single installment, due today)
+      const today = new Date().toISOString().slice(0, 10)
+      const invoiceId = await this.createInvoiceFromOrder(orderId, { installments: 1, dueDate: today })
+
+      // 2. Get the created movement
+      const detail = await this.getPaymentDetail(invoiceId)
+      if (!detail || detail.movements.length === 0) throw new Error('No movement created')
+
+      const movement = detail.movements[0]
+
+      // 3. Pay it in full
+      await this.payMovement({
+        movementId: movement.id,
+        amount: movement.amount,
+        paymentDate: today,
+        paymentMethodTypeId: input.paymentMethodTypeId,
+        paymentMethodId: input.paymentMethodId,
+        bankAccountId: input.bankAccountId,
+        cardBrand: input.cardBrand,
+        cardInstallments: input.cardInstallments,
+      })
+
+      // 4. Return updated detail
+      return (await this.getPaymentDetail(invoiceId))!
+    },
+
+    async getPaymentMethodTypes() {
+      const types = await provider.getPaymentMethodTypes()
+      return types.map((t: any) => ({ id: t.id, name: t.name, transactionType: t.transactionType }))
+    },
+
+    async getBankAccounts() {
+      const accounts = await provider.getBankAccounts()
+      return accounts
+        .filter((a: any) => a.isActive)
+        .map((a: any) => ({ id: a.id, name: a.name, accountType: a.accountType }))
+    },
+
+    async getPaymentMethods(paymentMethodTypeId: string) {
+      const methods = await provider.getPaymentMethods()
+      return methods
+        .filter((m: any) => m.paymentMethodTypeId === paymentMethodTypeId && m.isActive)
+        .map((m: any) => ({ id: m.id, name: m.name }))
+    },
+  }
+}
+
+function mapInvoiceStatus(status: string): BookingPaymentStatus {
+  switch (status) {
+    case 'paid': return 'paid'
+    case 'partial': return 'partial'
+    case 'overdue': return 'overdue'
+    case 'cancelled': return 'cancelled'
+    case 'invoiced': return 'pending'
+    case 'pending': return 'pending'
+    case 'scheduled': return 'none'
+    case 'confirmed': return 'none'
+    case 'in_progress': return 'none'
+    case 'completed': return 'none'
+    case 'no_show': return 'none'
+    case 'booked': return 'none'
+    default: return 'pending'
+  }
+}

package/src/calendar-styles.css

@@ -0,0 +1,245 @@
+/* Dark mode content background — uses the content token */
+.dark .agenda-calendar,
+.dark .agenda-calendar .fc,
+.dark .agenda-calendar .fc-view-harness,
+.dark .agenda-calendar .fc-timegrid,
+.dark .agenda-calendar .fc-scrollgrid,
+.dark .agenda-calendar .fc-timegrid-col,
+.dark .agenda-calendar .fc-daygrid-body,
+.dark .agenda-calendar .fc-timegrid-slot-lane {
+  background-color: hsl(var(--content));
+}
+
+/* FullCalendar — Google Calendar inspired theme */
+
+.agenda-calendar {
+  --fc-border-color: hsl(var(--border));
+  --fc-today-bg-color: transparent;
+  --fc-now-indicator-color: hsl(var(--destructive));
+  --fc-highlight-color: hsl(var(--primary) / 0.06);
+  --fc-non-business-color: hsl(var(--muted) / 0.15);
+  --fc-neutral-bg-color: transparent;
+  --fc-page-bg-color: transparent;
+  --fc-event-border-color: transparent;
+}
+
+.agenda-calendar .fc {
+  font-family: inherit;
+  background: transparent;
+}
+
+.agenda-calendar .fc .fc-view-harness {
+  background: transparent;
+}
+
+/* ── Column headers ── */
+.agenda-calendar .fc-col-header-cell {
+  background: transparent;
+  border-bottom: 1px solid var(--fc-border-color);
+  border-left: none;
+  border-right: none;
+  border-top: none;
+}
+
+.agenda-calendar .fc-col-header-cell-cushion {
+  padding: 8px 4px;
+  font-weight: 400;
+  font-size: 0.7rem;
+  color: hsl(var(--muted-foreground));
+  text-decoration: none;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+}
+
+/* Today's column header */
+.agenda-calendar .fc-day-today .fc-col-header-cell-cushion {
+  color: hsl(var(--primary));
+  font-weight: 600;
+}
+
+/* Resource header (professional columns) */
+.agenda-calendar .fc .fc-resource-header {
+  background: transparent;
+  border-bottom: 1px solid var(--fc-border-color);
+}
+
+/* ── Time slots — compact ── */
+.agenda-calendar .fc-timegrid-slot {
+  height: 1.5rem;
+  border-bottom: 1px solid hsl(var(--border) / 0.4);
+}
+
+.agenda-calendar .fc-timegrid-slot-label {
+  vertical-align: top;
+  border: none;
+}
+
+.agenda-calendar .fc-timegrid-slot-label-cushion {
+  font-size: 0.65rem;
+  color: hsl(var(--muted-foreground) / 0.7);
+  padding: 1px 8px 0 0;
+}
+
+/* Half-hour lines lighter */
+.agenda-calendar .fc-timegrid-slot-minor {
+  border-bottom-style: none;
+}
+
+/* Column dividers */
+.agenda-calendar .fc-timegrid-col {
+  border-right: 1px solid hsl(var(--border) / 0.5);
+}
+
+/* ── Events ── */
+.agenda-calendar .fc-event {
+  border-radius: 4px;
+  border-width: 0;
+  border-left: 4px solid;
+  cursor: pointer;
+  transition: opacity 0.15s, box-shadow 0.15s;
+  font-size: 0.7rem;
+  line-height: 1.3;
+  margin: 0 2px;
+  overflow: hidden;
+}
+
+.agenda-calendar .fc-event:not(.fc-bg-event):hover {
+  opacity: 0.85;
+  box-shadow: 0 2px 6px rgba(0,0,0,0.12);
+}
+
+.agenda-calendar .fc-bg-event {
+  pointer-events: none;
+}
+
+/* ── Now indicator ── */
+.agenda-calendar .fc-timegrid-now-indicator-line {
+  border-color: hsl(var(--destructive));
+  border-width: 2px;
+}
+
+.agenda-calendar .fc-timegrid-now-indicator-arrow {
+  border-top-color: hsl(var(--destructive));
+}
+
+/* ── Month view ── */
+.agenda-calendar .fc-daygrid-day-number {
+  font-size: 0.8rem;
+  padding: 4px 8px;
+  text-decoration: none;
+  color: hsl(var(--foreground));
+}
+
+.agenda-calendar .fc-daygrid-day.fc-day-today .fc-daygrid-day-number {
+  background-color: hsl(var(--primary));
+  color: hsl(var(--primary-foreground));
+  border-radius: 50%;
+  width: 1.5rem;
+  height: 1.5rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 0.75rem;
+}
+
+/* ── Selection ── */
+.agenda-calendar .fc-highlight {
+  background: hsl(var(--primary) / 0.08);
+}
+
+/* ── Links ── */
+.agenda-calendar .fc a {
+  text-decoration: none;
+  color: inherit;
+}
+
+/* ── Scrollbar ── */
+.agenda-calendar .fc-scroller {
+  scrollbar-width: thin;
+  scrollbar-color: hsl(var(--muted-foreground) / 0.12) transparent;
+}
+
+.agenda-calendar .fc-scroller::-webkit-scrollbar {
+  width: 6px;
+}
+
+.agenda-calendar .fc-scroller::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.agenda-calendar .fc-scroller::-webkit-scrollbar-thumb {
+  background: hsl(var(--muted-foreground) / 0.12);
+  border-radius: 3px;
+}
+
+/* ── Clean up borders ── */
+.agenda-calendar .fc .fc-timegrid {
+  border: none;
+}
+
+.agenda-calendar .fc-scrollgrid {
+  border: none !important;
+}
+
+.agenda-calendar .fc-scrollgrid td:last-child {
+  border-right: none;
+}
+
+/* ── Unavailable time background — opaque/disabled feel ── */
+.agenda-calendar .fc-unavailable-bg {
+  background: hsl(var(--muted-foreground) / 0.08) !important;
+  background-image: repeating-linear-gradient(
+    45deg,
+    transparent,
+    transparent 4px,
+    hsl(var(--muted-foreground) / 0.04) 4px,
+    hsl(var(--muted-foreground) / 0.04) 8px
+  ) !important;
+  border-radius: 0;
+  border-left: none !important;
+}
+
+/* ── Location label on schedule blocks ── */
+.agenda-calendar .fc-location-label {
+  background: transparent !important;
+  border: none !important;
+  border-left-width: 0 !important;
+  cursor: default !important;
+  pointer-events: none;
+  box-shadow: none !important;
+  z-index: 1 !important;
+  margin: 0 4px !important;
+  font-weight: 500 !important;
+}
+
+.agenda-calendar .fc-location-label .fc-event-main {
+  padding: 0 !important;
+}
+
+/* Week view day header with date */
+.agenda-calendar .fc-timegrid .fc-col-header-cell {
+  padding: 4px 0;
+}
+
+/* ── Alternating resource column backgrounds ── */
+.agenda-calendar .fc-resource-alt {
+  background-color: hsl(var(--muted) / 0.4) !important;
+}
+
+.dark .agenda-calendar .fc-resource-alt {
+  background-color: hsl(var(--muted-foreground) / 0.08) !important;
+}
+
+/* Resource group header separator — stronger border between professionals */
+.agenda-calendar .fc-resource-group {
+  border-left: 2px solid hsl(var(--border));
+}
+
+/* Also stripe the resource header label for the alt group */
+.agenda-calendar th.fc-resource-alt {
+  background-color: hsl(var(--muted) / 0.4) !important;
+}
+
+.dark .agenda-calendar th.fc-resource-alt {
+  background-color: hsl(var(--muted-foreground) / 0.06) !important;
+}