@open-mercato/core 0.5.1-develop.2672.g2128128275 → 0.5.1-develop.2681.c559bb2bc3

package/src/modules/customers/backend/customers/deals/[id]/hooks/useDealData.ts

@@ -0,0 +1,52 @@
+import * as React from 'react'
+import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type { DealDetailPayload } from './types'
+
+type UseDealDataResult = {
+  data: DealDetailPayload | null
+  setData: React.Dispatch<React.SetStateAction<DealDetailPayload | null>>
+  isLoading: boolean
+  error: string | null
+  loadData: () => Promise<void>
+}
+
+export function useDealData(id: string): UseDealDataResult {
+  const t = useT()
+  const [data, setData] = React.useState<DealDetailPayload | null>(null)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [error, setError] = React.useState<string | null>(null)
+  const initialLoadDoneRef = React.useRef(false)
+
+  const loadData = React.useCallback(async () => {
+    if (!id) {
+      setError(t('customers.deals.detail.error.notFound', 'Deal not found.'))
+      setIsLoading(false)
+      return
+    }
+    if (!initialLoadDoneRef.current) {
+      setIsLoading(true)
+    }
+    setError(null)
+    try {
+      const payload = await readApiResultOrThrow<DealDetailPayload>(
+        `/api/customers/deals/${encodeURIComponent(id)}?include=stages&view=lite`,
+        undefined,
+        { errorMessage: t('customers.deals.detail.error.load', 'Failed to load deal.') },
+      )
+      setData(payload)
+    } catch (loadError) {
+      const message =
+        loadError instanceof Error
+          ? loadError.message
+          : t('customers.deals.detail.error.load', 'Failed to load deal.')
+      setError(message)
+      if (!initialLoadDoneRef.current) setData(null)
+    } finally {
+      setIsLoading(false)
+      initialLoadDoneRef.current = true
+    }
+  }, [id, t])
+
+  return { data, setData, isLoading, error, loadData }
+}

package/src/modules/customers/backend/customers/deals/[id]/hooks/useDealFormHandlers.ts

@@ -0,0 +1,86 @@
+import * as React from 'react'
+import { useRouter } from 'next/navigation'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { deleteCrud, updateCrud } from '@open-mercato/ui/backend/utils/crud'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
+import type { DealFormSubmitPayload } from '../../../../../components/detail/DealForm'
+import type { DealDetailPayload, GuardedMutationRunner } from './types'
+
+type UseDealFormHandlersOptions = {
+  data: DealDetailPayload | null
+  currentDealId: string | null
+  loadData: () => Promise<void>
+  runMutationWithContext: GuardedMutationRunner
+  formWrapperRef: React.RefObject<HTMLDivElement | null>
+  confirm: ReturnType<typeof useConfirmDialog>['confirm']
+}
+
+type UseDealFormHandlersResult = {
+  isSaving: boolean
+  handleFormSubmit: (payload: DealFormSubmitPayload) => Promise<void>
+  handleDelete: () => Promise<void>
+  handleHeaderSave: () => void
+}
+
+export function useDealFormHandlers({
+  data,
+  currentDealId,
+  loadData,
+  runMutationWithContext,
+  formWrapperRef,
+  confirm,
+}: UseDealFormHandlersOptions): UseDealFormHandlersResult {
+  const t = useT()
+  const router = useRouter()
+  const [isSaving, setIsSaving] = React.useState(false)
+
+  const handleFormSubmit = React.useCallback(
+    async (payload: DealFormSubmitPayload) => {
+      if (!data) return
+      setIsSaving(true)
+      try {
+        await updateCrud('customers/deals', {
+          id: data.deal.id,
+          ...payload.base,
+          ...payload.custom,
+        })
+        flash(t('customers.deals.detail.updateSuccess', 'Deal updated.'), 'success')
+        await loadData()
+      } finally {
+        setIsSaving(false)
+      }
+    },
+    [data, loadData, t],
+  )
+
+  const handleDelete = React.useCallback(async () => {
+    if (!data || !currentDealId) return
+    const approved = await confirm({
+      title: t('customers.deals.detail.deleteConfirmTitle', 'Delete deal?'),
+      description: t('customers.deals.detail.deleteConfirmDescription', 'This action cannot be undone.'),
+      confirmText: t('customers.deals.detail.actions.delete', 'Delete'),
+      cancelText: t('customers.deals.detail.actions.cancel', 'Cancel'),
+      variant: 'destructive',
+    })
+    if (!approved) return
+    await runMutationWithContext(
+      () => deleteCrud('customers/deals', currentDealId),
+      { id: currentDealId, operation: 'deleteDeal' },
+    )
+    flash(t('customers.deals.detail.deleteSuccess', 'Deal deleted.'), 'success')
+    router.push('/backend/customers/deals')
+  }, [confirm, currentDealId, data, router, runMutationWithContext, t])
+
+  const handleHeaderSave = React.useCallback(() => {
+    const form = formWrapperRef.current?.querySelector('form')
+    if (form) form.requestSubmit()
+  }, [formWrapperRef])
+
+  return {
+    isSaving,
+    handleFormSubmit,
+    handleDelete,
+    handleHeaderSave,
+  }
+}

package/src/modules/customers/backend/customers/deals/[id]/hooks/useDealInjectedTabs.tsx

@@ -0,0 +1,60 @@
+import * as React from 'react'
+import { useInjectionWidgets } from '@open-mercato/ui/backend/injection/InjectionSpot'
+import type { DealDetailPayload } from './types'
+
+type InjectedTab = {
+  id: string
+  label: string
+  priority: number
+  render: () => React.ReactNode
+}
+
+type UseDealInjectedTabsOptions = {
+  injectionContext: unknown
+  data: DealDetailPayload | null
+  setData: React.Dispatch<React.SetStateAction<DealDetailPayload | null>>
+}
+
+type UseDealInjectedTabsResult = {
+  injectedTabs: InjectedTab[]
+  injectedTabMap: Map<string, () => React.ReactNode>
+}
+
+export function useDealInjectedTabs({
+  injectionContext,
+  data,
+  setData,
+}: UseDealInjectedTabsOptions): UseDealInjectedTabsResult {
+  const { widgets: injectedTabWidgets } = useInjectionWidgets('detail:customers.deal:tabs', {
+    context: injectionContext,
+    triggerOnLoad: true,
+  })
+
+  const injectedTabs = React.useMemo<InjectedTab[]>(
+    () =>
+      (injectedTabWidgets ?? [])
+        .filter((widget) => (widget.placement?.kind ?? 'tab') === 'tab')
+        .map((widget) => {
+          const tabId = widget.placement?.groupId ?? widget.widgetId
+          const label = widget.placement?.groupLabel ?? widget.module.metadata.title ?? tabId
+          const priority = typeof widget.placement?.priority === 'number' ? widget.placement.priority : 0
+          const render = () => (
+            <widget.module.Widget
+              context={injectionContext}
+              data={data}
+              onDataChange={(next: unknown) => setData(next as DealDetailPayload)}
+            />
+          )
+          return { id: tabId, label, priority, render }
+        })
+        .sort((left, right) => right.priority - left.priority),
+    [data, injectedTabWidgets, injectionContext, setData],
+  )
+
+  const injectedTabMap = React.useMemo(
+    () => new Map(injectedTabs.map((tab) => [tab.id, tab.render])),
+    [injectedTabs],
+  )
+
+  return { injectedTabs, injectedTabMap }
+}

package/src/modules/customers/backend/customers/deals/[id]/hooks/useDealMutationContext.ts

@@ -0,0 +1,76 @@
+import * as React from 'react'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type { DealDetailPayload, GuardedMutationRunner } from './types'
+
+type InjectionContext = {
+  formId: string
+  dealId: string | null | undefined
+  resourceKind: string
+  resourceId: string | undefined
+  data: DealDetailPayload | null
+  retryLastMutation: () => Promise<boolean>
+}
+
+type UseDealMutationContextOptions = {
+  currentDealId: string | null
+  fallbackId: string
+  data: DealDetailPayload | null
+}
+
+type UseDealMutationContextResult = {
+  mutationContextId: string
+  injectionContext: InjectionContext
+  runMutationWithContext: GuardedMutationRunner
+  retryLastMutation: () => Promise<boolean>
+}
+
+export function useDealMutationContext({
+  currentDealId,
+  fallbackId,
+  data,
+}: UseDealMutationContextOptions): UseDealMutationContextResult {
+  const t = useT()
+  const mutationContextId = React.useMemo(
+    () =>
+      currentDealId
+        ? `customer-deal:${currentDealId}`
+        : `customer-deal:${fallbackId || 'pending'}`,
+    [currentDealId, fallbackId],
+  )
+
+  const { runMutation, retryLastMutation } = useGuardedMutation<InjectionContext>({
+    contextId: mutationContextId,
+    blockedMessage: t('ui.forms.flash.saveBlocked', 'Save blocked by validation'),
+  })
+
+  const injectionContext = React.useMemo<InjectionContext>(
+    () => ({
+      formId: mutationContextId,
+      dealId: currentDealId,
+      resourceKind: 'customers.deal',
+      resourceId: currentDealId ?? undefined,
+      data,
+      retryLastMutation,
+    }),
+    [currentDealId, data, mutationContextId, retryLastMutation],
+  )
+
+  const runMutationWithContext = React.useCallback<GuardedMutationRunner>(
+    async (operation, mutationPayload) => {
+      return runMutation({
+        operation,
+        mutationPayload,
+        context: injectionContext,
+      })
+    },
+    [injectionContext, runMutation],
+  )
+
+  return {
+    mutationContextId,
+    injectionContext,
+    runMutationWithContext,
+    retryLastMutation,
+  }
+}

package/src/modules/customers/backend/customers/deals/[id]/hooks/useDealPipeline.ts

@@ -0,0 +1,56 @@
+import * as React from 'react'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { updateCrud } from '@open-mercato/ui/backend/utils/crud'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type { DealDetailPayload, GuardedMutationRunner } from './types'
+
+type UseDealPipelineOptions = {
+  currentDealId: string | null
+  data: DealDetailPayload | null
+  runMutationWithContext: GuardedMutationRunner
+  confirmDiscardIfDirty: () => Promise<boolean>
+  onStageChanged: () => Promise<void>
+}
+
+type UseDealPipelineResult = {
+  isStageSaving: boolean
+  handleStageChange: (nextStageId: string) => Promise<void>
+}
+
+export function useDealPipeline({
+  currentDealId,
+  data,
+  runMutationWithContext,
+  confirmDiscardIfDirty,
+  onStageChanged,
+}: UseDealPipelineOptions): UseDealPipelineResult {
+  const t = useT()
+  const [isStageSaving, setIsStageSaving] = React.useState(false)
+
+  const handleStageChange = React.useCallback(
+    async (nextStageId: string) => {
+      if (!currentDealId || !data) return
+      if (nextStageId === data.deal.pipelineStageId) return
+      if (!(await confirmDiscardIfDirty())) return
+      setIsStageSaving(true)
+      try {
+        await runMutationWithContext(
+          () => updateCrud('customers/deals', { id: currentDealId, pipelineStageId: nextStageId }),
+          { id: currentDealId, pipelineStageId: nextStageId, operation: 'updateDealStage' },
+        )
+        flash(t('customers.deals.detail.stageUpdateSuccess', 'Deal stage updated.'), 'success')
+        await onStageChanged()
+      } catch {
+        flash(t('customers.deals.detail.stageUpdateError', 'Failed to update deal stage.'), 'error')
+      } finally {
+        setIsStageSaving(false)
+      }
+    },
+    [confirmDiscardIfDirty, currentDealId, data, onStageChanged, runMutationWithContext, t],
+  )
+
+  return {
+    isStageSaving,
+    handleStageChange,
+  }
+}

package/src/modules/customers/backend/customers/deals/[id]/hooks/useScheduleDialog.ts

@@ -0,0 +1,38 @@
+import * as React from 'react'
+import type { ScheduleActivityEditData } from '../../../../../components/detail/ScheduleActivityDialog'
+
+type UseScheduleDialogResult = {
+  scheduleDialogOpen: boolean
+  scheduleEditData: ScheduleActivityEditData | null
+  openSchedule: () => void
+  openEdit: (data: ScheduleActivityEditData) => void
+  closeSchedule: () => void
+}
+
+export function useScheduleDialog(): UseScheduleDialogResult {
+  const [scheduleDialogOpen, setScheduleDialogOpen] = React.useState(false)
+  const [scheduleEditData, setScheduleEditData] = React.useState<ScheduleActivityEditData | null>(null)
+
+  const openSchedule = React.useCallback(() => {
+    setScheduleEditData(null)
+    setScheduleDialogOpen(true)
+  }, [])
+
+  const openEdit = React.useCallback((data: ScheduleActivityEditData) => {
+    setScheduleEditData(data)
+    setScheduleDialogOpen(true)
+  }, [])
+
+  const closeSchedule = React.useCallback(() => {
+    setScheduleDialogOpen(false)
+    setScheduleEditData(null)
+  }, [])
+
+  return {
+    scheduleDialogOpen,
+    scheduleEditData,
+    openSchedule,
+    openEdit,
+    closeSchedule,
+  }
+}