@open-mercato/core 0.10.1-develop.7716.1.cefe7975df → 0.10.1-develop.7721.1.b5c4a00a68

package/src/modules/staff/lib/support/portalTickets.ts

@@ -0,0 +1,233 @@
+import { NextResponse } from 'next/server'
+import { sql } from 'kysely'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { CustomerAuthContext } from '@open-mercato/shared/modules/customer-auth'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CustomerEntity } from '@open-mercato/core/modules/customers/data/entities'
+import { StaffSupportTicket, StaffTimeTask } from '../../data/entities'
+import { PORTAL_SUPPORT_NOT_LINKED_CODE } from '../support-ui/portalSupport'
+
+const logger = createLogger('staff').child({ component: 'lib/support/portalTickets' })
+
+export const PORTAL_SUPPORT_TICKETS_VIEW_FEATURE = 'portal.support_tickets.view'
+export const PORTAL_SUPPORT_TICKETS_MANAGE_FEATURE = 'portal.support_tickets.manage'
+
+type AppContainer = Awaited<ReturnType<typeof createRequestContainer>>
+
+export type SupportPortalScope = {
+  auth: CustomerAuthContext
+  customerId: string
+  tenantId: string
+  organizationId: string
+  container: AppContainer
+  em: EntityManager
+  hasFeature: (feature: string) => Promise<boolean>
+}
+
+type CustomerFeatureGuard = (auth: CustomerAuthContext, features: string[], rbac: unknown) => Promise<void>
+
+/**
+ * The portal identity is resolved through `customer_accounts` with a dynamic import,
+ * exactly like the EP-50 time-reports routes, so `staff` keeps no static edge to the
+ * portal module: a deployment without it answers 401 instead of failing to load.
+ * A session with no `customerEntityId` is refused (403); a missing feature guard
+ * fails closed (403) so a revoked grant keeps working as a revocation.
+ */
+export async function resolveSupportPortalScope(
+  req: Request,
+  requiredFeature: string,
+): Promise<SupportPortalScope | Response> {
+  let auth: CustomerAuthContext | null = null
+  let requireFeature: CustomerFeatureGuard | null = null
+  try {
+    const customerAuth = await import('@open-mercato/core/modules/customer_accounts/lib/customerAuth')
+    auth = await customerAuth.getCustomerAuthFromRequest(req)
+    const guard: unknown = (customerAuth as { requireCustomerFeature?: unknown }).requireCustomerFeature
+    requireFeature = typeof guard === 'function' ? (guard as CustomerFeatureGuard) : null
+  } catch (err) {
+    logger.warn('staff portal support could not resolve customer auth', { err })
+    return NextResponse.json({ ok: false, error: 'staff.errors.unauthorized' }, { status: 401 })
+  }
+  if (!auth) return NextResponse.json({ ok: false, error: 'staff.errors.unauthorized' }, { status: 401 })
+  const customerId =
+    typeof auth.customerEntityId === 'string' && auth.customerEntityId.trim().length > 0
+      ? auth.customerEntityId.trim()
+      : null
+  if (!customerId) {
+    return NextResponse.json(
+      { ok: false, error: 'staff.errors.customerAccountNotLinked', code: PORTAL_SUPPORT_NOT_LINKED_CODE },
+      { status: 403 },
+    )
+  }
+  if (!requireFeature) {
+    logger.error('staff portal support could not resolve requireCustomerFeature; refusing the request', {
+      feature: requiredFeature,
+    })
+    return NextResponse.json({ ok: false, error: 'staff.errors.forbidden' }, { status: 403 })
+  }
+  const guard = requireFeature
+  const container = await createRequestContainer()
+  const resolvedAuth = auth
+  const hasFeature = async (feature: string): Promise<boolean> => {
+    try {
+      await guard(resolvedAuth, [feature], container.resolve('customerRbacService'))
+      return true
+    } catch {
+      return false
+    }
+  }
+  try {
+    await guard(auth, [requiredFeature], container.resolve('customerRbacService'))
+  } catch (response) {
+    if (response instanceof Response) return response
+    logger.warn('staff portal support feature check failed', { err: response })
+    return NextResponse.json({ ok: false, error: 'staff.errors.forbidden' }, { status: 403 })
+  }
+  return {
+    auth,
+    customerId,
+    tenantId: auth.tenantId,
+    organizationId: auth.orgId,
+    container,
+    em: (container.resolve('em') as EntityManager).fork(),
+    hasFeature,
+  }
+}
+
+/**
+ * THE ownership clause for every portal support read and write. Ownership comes from
+ * the task's own `customer_id` — never the project's — so tickets from many customers
+ * can share one project. Callers load WITH this clause rather than loading and
+ * checking afterwards, so a foreign id is never read even momentarily.
+ */
+export function portalOwnedTaskWhere(scope: Pick<SupportPortalScope, 'tenantId' | 'organizationId' | 'customerId'>) {
+  return {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    customerId: scope.customerId,
+    source: 'portal' as const,
+    deletedAt: null,
+  }
+}
+
+export async function loadPortalOwnedTicket(
+  scope: Pick<SupportPortalScope, 'tenantId' | 'organizationId' | 'customerId' | 'em'>,
+  taskId: string,
+): Promise<{ task: StaffTimeTask; ticket: StaffSupportTicket } | null> {
+  const task = await scope.em.findOne(StaffTimeTask, { id: taskId, ...portalOwnedTaskWhere(scope) })
+  if (!task) return null
+  const ticket = await findOneWithDecryption(
+    scope.em,
+    StaffSupportTicket,
+    { taskId: task.id, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    undefined,
+    { tenantId: scope.tenantId, organizationId: scope.organizationId },
+  )
+  if (!ticket) return null
+  return { task, ticket }
+}
+
+export async function resolveCustomerDisplay(
+  scope: Pick<SupportPortalScope, 'tenantId' | 'organizationId' | 'customerId' | 'em'>,
+): Promise<{ displayName: string | null; kind: string | null }> {
+  try {
+    const customer = await findOneWithDecryption(
+      scope.em,
+      CustomerEntity,
+      { id: scope.customerId, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+      undefined,
+      { tenantId: scope.tenantId, organizationId: scope.organizationId },
+    )
+    const displayName = typeof customer?.displayName === 'string' ? customer.displayName : null
+    const kind = typeof customer?.kind === 'string' ? customer.kind : null
+    return { displayName, kind }
+  } catch {
+    return { displayName: null, kind: null }
+  }
+}
+
+type PortalTicketActivityDb = {
+  staff_time_tasks: {
+    id: string
+    tenant_id: string
+    organization_id: string
+    customer_id: string | null
+    source: string
+    task_status_id: string
+    created_at: Date
+    deleted_at: Date | null
+  }
+  staff_time_task_comments: {
+    task_id: string
+    tenant_id: string
+    organization_id: string
+    visibility: string
+    created_at: Date
+    deleted_at: Date | null
+  }
+}
+
+export type PortalTicketPageRow = { id: string; lastActivityAt: Date }
+
+function toDate(value: unknown, fallback: Date): Date {
+  if (value instanceof Date) return value
+  if (typeof value === 'string' || typeof value === 'number') {
+    const parsed = new Date(value)
+    if (!Number.isNaN(parsed.getTime())) return parsed
+  }
+  return fallback
+}
+
+/**
+ * One page of the caller's tickets, newest customer-visible activity first. Activity
+ * is the latest of the ticket's filing time and its newest customer-visible comment
+ * (either side), so internal staff edits — which bump `updated_at` — never reorder the
+ * customer's list while a reply the customer can read always does. The ownership
+ * clause is the same as `portalOwnedTaskWhere`; the activity is computed per row by a
+ * correlated `max()` served by the comments `(organization_id, task_id, created_at)` index.
+ */
+export async function listPortalTicketPage(
+  scope: Pick<SupportPortalScope, 'tenantId' | 'organizationId' | 'customerId' | 'em'>,
+  options: { statusIds: readonly string[] | null; limit: number; offset: number },
+): Promise<{ rows: PortalTicketPageRow[]; total: number }> {
+  if (options.statusIds && options.statusIds.length === 0) return { rows: [], total: 0 }
+  const db = scope.em.getKysely<PortalTicketActivityDb>()
+  let owned = db
+    .selectFrom('staff_time_tasks as task')
+    .where('task.tenant_id', '=', scope.tenantId)
+    .where('task.organization_id', '=', scope.organizationId)
+    .where('task.customer_id', '=', scope.customerId)
+    .where('task.source', '=', 'portal')
+    .where('task.deleted_at', 'is', null)
+  if (options.statusIds) owned = owned.where('task.task_status_id', 'in', [...options.statusIds])
+  const lastActivity = sql<Date>`greatest(task.created_at, coalesce((
+    select max(visible_comment.created_at)
+    from staff_time_task_comments as visible_comment
+    where visible_comment.organization_id = task.organization_id
+      and visible_comment.task_id = task.id
+      and visible_comment.tenant_id = task.tenant_id
+      and visible_comment.visibility = 'customer'
+      and visible_comment.deleted_at is null
+  ), task.created_at))`
+  const [countRow, pageRows] = await Promise.all([
+    owned.select((builder) => builder.fn.countAll<string | number>().as('total')).executeTakeFirst(),
+    owned
+      .select(['task.id as id', 'task.created_at as created_at'])
+      .select(lastActivity.as('last_activity_at'))
+      .orderBy('last_activity_at', 'desc')
+      .orderBy('task.id', 'desc')
+      .limit(options.limit)
+      .offset(options.offset)
+      .execute(),
+  ])
+  const total = Number(countRow?.total ?? 0)
+  return {
+    total: Number.isFinite(total) ? total : 0,
+    rows: pageRows.map((row) => ({
+      id: row.id,
+      lastActivityAt: toDate(row.last_activity_at, toDate(row.created_at, new Date(0))),
+    })),
+  }
+}

package/src/modules/staff/lib/support/routing.ts

@@ -0,0 +1,117 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import {
+  StaffSupportRoutingRule,
+  StaffTimeProject,
+  StaffTimeTaskStatus,
+  type StaffSupportRoutedVia,
+} from '../../data/entities'
+
+export type SupportScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type SupportRoutingRuleView = {
+  id: string
+  categoryValue: string | null
+  timeProjectId: string
+  isActive: boolean
+  updatedAt?: Date | null
+}
+
+export type SupportRoute = {
+  timeProjectId: string
+  via: StaffSupportRoutedVia
+}
+
+export function resolveSupportRouteFromRules(
+  rules: SupportRoutingRuleView[],
+  categoryValue: string,
+  usableProjectIds: ReadonlySet<string>,
+): SupportRoute | null {
+  const categoryRule = rules.find((rule) => rule.categoryValue === categoryValue)
+  if (categoryRule && categoryRule.isActive && usableProjectIds.has(categoryRule.timeProjectId)) {
+    return { timeProjectId: categoryRule.timeProjectId, via: 'category' }
+  }
+  const fallbackRule = rules.find((rule) => rule.categoryValue === null)
+  if (fallbackRule && usableProjectIds.has(fallbackRule.timeProjectId)) {
+    return { timeProjectId: fallbackRule.timeProjectId, via: 'fallback' }
+  }
+  return null
+}
+
+export async function loadSupportRoutingRules(
+  em: EntityManager,
+  scope: SupportScope,
+): Promise<SupportRoutingRuleView[]> {
+  const rows = await em.find(StaffSupportRoutingRule, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    deletedAt: null,
+  })
+  return rows.map((row) => ({
+    id: row.id,
+    categoryValue: row.categoryValue ?? null,
+    timeProjectId: row.timeProjectId,
+    isActive: row.isActive,
+    updatedAt: row.updatedAt ?? null,
+  }))
+}
+
+export async function loadUsableSupportProjectIds(
+  em: EntityManager,
+  scope: SupportScope,
+  projectIds: string[],
+): Promise<Set<string>> {
+  const unique = Array.from(new Set(projectIds))
+  if (unique.length === 0) return new Set()
+  const projects = await em.find(
+    StaffTimeProject,
+    {
+      id: { $in: unique },
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      deletedAt: null,
+      status: { $in: ['active', 'on_hold'] },
+    },
+    { fields: ['id'] },
+  )
+  if (projects.length === 0) return new Set()
+  const defaults = await em.find(
+    StaffTimeTaskStatus,
+    {
+      timeProjectId: { $in: projects.map((project) => project.id) },
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      isDefault: true,
+      deletedAt: null,
+    },
+    { fields: ['timeProjectId'] },
+  )
+  return new Set(defaults.map((status) => status.timeProjectId))
+}
+
+export async function resolveSupportRoute(
+  em: EntityManager,
+  scope: SupportScope,
+  categoryValue: string,
+): Promise<SupportRoute | null> {
+  const rules = await loadSupportRoutingRules(em, scope)
+  const usable = await loadUsableSupportProjectIds(em, scope, rules.map((rule) => rule.timeProjectId))
+  return resolveSupportRouteFromRules(rules, categoryValue, usable)
+}
+
+export async function resolveRoutableCategoryValues(
+  em: EntityManager,
+  scope: SupportScope,
+  categoryValues: string[],
+): Promise<Map<string, SupportRoute>> {
+  const rules = await loadSupportRoutingRules(em, scope)
+  const usable = await loadUsableSupportProjectIds(em, scope, rules.map((rule) => rule.timeProjectId))
+  const routes = new Map<string, SupportRoute>()
+  for (const value of categoryValues) {
+    const route = resolveSupportRouteFromRules(rules, value, usable)
+    if (route) routes.set(value, route)
+  }
+  return routes
+}

package/src/modules/staff/lib/support/routingRuleDraft.ts

@@ -0,0 +1,45 @@
+export type RoutingRuleSnapshot = {
+  id: string
+  categoryValue: string | null
+  project: { id: string }
+  updatedAt?: string | null
+}
+
+export type RoutingRuleSnapshotSet = {
+  rules: RoutingRuleSnapshot[]
+}
+
+export type RoutingRuleDialogState =
+  | { mode: 'create'; categoryValue: string; timeProjectId: string }
+  | {
+      mode: 'edit'
+      ruleId: string
+      categoryValue: string
+      timeProjectId: string
+      expectedUpdatedAt: string | null
+    }
+
+export function routingRuleVersion(rule: { updatedAt?: string | null }): string | null {
+  return typeof rule.updatedAt === 'string' && rule.updatedAt.length > 0 ? rule.updatedAt : null
+}
+
+export function buildRoutingRuleEditDraft(rule: RoutingRuleSnapshot): RoutingRuleDialogState {
+  return {
+    mode: 'edit',
+    ruleId: rule.id,
+    categoryValue: rule.categoryValue ?? '',
+    timeProjectId: rule.project.id,
+    expectedUpdatedAt: routingRuleVersion(rule),
+  }
+}
+
+export function rebaseRoutingRuleDialog(
+  draft: RoutingRuleDialogState | null,
+  snapshot: RoutingRuleSnapshotSet,
+): RoutingRuleDialogState | null {
+  if (!draft || draft.mode === 'create') return draft
+  const current = snapshot.rules.find((rule) => rule.id === draft.ruleId)
+  if (!current) return null
+  if (routingRuleVersion(current) === draft.expectedUpdatedAt) return draft
+  return buildRoutingRuleEditDraft(current)
+}

package/src/modules/staff/lib/support/seedDefaults.ts

@@ -0,0 +1,151 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
+import { isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
+import { StaffSupportRoutingRule, StaffTimeProject, StaffTimeTaskStatus } from '../../data/entities'
+import { seedProjectTaskStatuses } from '../timesheets-tasks/seedProjectStatuses'
+import type { TaskStatusLabelTranslate } from '../timesheets-tasks/defaultStatusTemplate'
+import { deriveProjectCode } from '../time-tracking/projectCode'
+import { seedSupportTicketCategories } from './dictionaries'
+
+export const SUPPORT_FALLBACK_PROJECT_NAME = 'Customer support'
+
+type SupportScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type ProjectCodeGenerator = (name: string, taken: Set<string>) => string
+
+export type EnsureFallbackResult = {
+  ruleId: string
+  timeProjectId: string
+  created: boolean
+  /** Board columns seeded for a freshly created project; empty when nothing was created. */
+  taskStatusIds: string[]
+}
+
+type ProjectCodeResolverLike = { generate(name: string, taken: Set<string>): string }
+
+/**
+ * The `timeProjectCodeResolver` DI override (EP-39), so a seeded project gets the
+ * same code a project created through the UI would. `undefined` (built-in
+ * generator) when the container does not carry one.
+ */
+export function resolveContainerProjectCodeGenerator(
+  container: { resolve: (name: string) => unknown } | null | undefined,
+): ProjectCodeGenerator | undefined {
+  if (!container) return undefined
+  try {
+    const resolver = container.resolve('timeProjectCodeResolver') as ProjectCodeResolverLike | undefined
+    if (!resolver || typeof resolver.generate !== 'function') return undefined
+    return (name, taken) => resolver.generate(name, taken)
+  } catch {
+    return undefined
+  }
+}
+
+export async function seedSupportDefaults(
+  em: EntityManager,
+  scope: SupportScope,
+  options: { translate: TaskStatusLabelTranslate; generateCode?: ProjectCodeGenerator },
+): Promise<void> {
+  await seedSupportTicketCategories(em, scope)
+  await ensureFallbackProjectAndRule(em, scope, {
+    translate: options.translate,
+    generateCode: options.generateCode,
+    projectName: options.translate('staff.support.fallbackProject.name', SUPPORT_FALLBACK_PROJECT_NAME),
+  })
+}
+
+async function findFallbackRule(em: EntityManager, scope: SupportScope): Promise<StaffSupportRoutingRule | null> {
+  return em.findOne(StaffSupportRoutingRule, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    categoryValue: null,
+    deletedAt: null,
+  })
+}
+
+/**
+ * Idempotent: an existing fallback rule is returned untouched, and a call that
+ * loses a race to a concurrent one (unique index on the fallback rule or on the
+ * project code) re-reads the winner's rule and reports `created: false`.
+ */
+export async function ensureFallbackProjectAndRule(
+  em: EntityManager,
+  scope: SupportScope,
+  options: { translate: TaskStatusLabelTranslate; generateCode?: ProjectCodeGenerator; projectName?: string },
+): Promise<EnsureFallbackResult> {
+  const existingRule = await findFallbackRule(em, scope)
+  if (existingRule) {
+    return { ruleId: existingRule.id, timeProjectId: existingRule.timeProjectId, created: false, taskStatusIds: [] }
+  }
+  const takenRows = await em.find(
+    StaffTimeProject,
+    { tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    { fields: ['code'] },
+  )
+  const taken = new Set(takenRows.map((row) => row.code))
+  const name = options.projectName ?? SUPPORT_FALLBACK_PROJECT_NAME
+  const generate = options.generateCode ?? ((projectName: string, codes: Set<string>) => deriveProjectCode(projectName, codes))
+  const now = new Date()
+  const project = em.create(StaffTimeProject, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    name,
+    code: generate(name, taken),
+    customerId: null,
+    customerSnapshot: null,
+    projectType: 'internal',
+    status: 'active',
+    billableByDefault: false,
+    budgetKind: 'none',
+    createdAt: now,
+    updatedAt: now,
+    deletedAt: null,
+  })
+  let rule: StaffSupportRoutingRule | null = null
+  let statuses: StaffTimeTaskStatus[] = []
+  try {
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          em.persist(project)
+        },
+        () => {
+          statuses = seedProjectTaskStatuses(
+            em,
+            { tenantId: scope.tenantId, organizationId: scope.organizationId, timeProjectId: project.id },
+            options.translate,
+          )
+          rule = em.create(StaffSupportRoutingRule, {
+            tenantId: scope.tenantId,
+            organizationId: scope.organizationId,
+            categoryValue: null,
+            timeProjectId: project.id,
+            isActive: true,
+            createdAt: now,
+            updatedAt: now,
+            deletedAt: null,
+          })
+          em.persist(rule)
+        },
+      ],
+      { transaction: true, label: 'staff.support.ensure_fallback_project' },
+    )
+  } catch (err) {
+    if (!isUniqueViolation(err)) throw err
+    const winner = await findFallbackRule(em.fork(), scope)
+    if (!winner) throw err
+    return { ruleId: winner.id, timeProjectId: winner.timeProjectId, created: false, taskStatusIds: [] }
+  }
+  const created = rule as StaffSupportRoutingRule | null
+  if (!created) throw new Error('[internal] fallback routing rule was not created')
+  return {
+    ruleId: created.id,
+    timeProjectId: project.id,
+    created: true,
+    taskStatusIds: statuses.map((status) => status.id),
+  }
+}

package/src/modules/staff/lib/support/supportActivity.ts

@@ -0,0 +1,39 @@
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
+import type { StaffSupportTicket, StaffTimeTask } from '../../data/entities'
+import { emitStaffEvent } from '../../events'
+
+const logger = createLogger('staff').child({ component: 'lib/support/supportActivity' })
+
+export type SupportAttachmentActivityKind = 'attachment_added' | 'attachment_removed'
+
+/**
+ * Tells open backoffice screens that a customer changed the files on a ticket.
+ * Ids only, like every `activity_recorded` broadcast. The attachment id keeps
+ * two quick changes of the same kind distinct for the browser bridge's 500 ms
+ * duplicate filter. A failed publish is reported and never fails the upload or
+ * deletion that already happened.
+ */
+export function emitSupportAttachmentActivity(
+  task: Pick<StaffTimeTask, 'id' | 'tenantId' | 'organizationId' | 'timeProjectId'>,
+  ticket: Pick<StaffSupportTicket, 'id'>,
+  kind: SupportAttachmentActivityKind,
+  attachmentId: string,
+): void {
+  void emitStaffEvent(
+    'staff.support_ticket.activity_recorded',
+    {
+      id: ticket.id,
+      tenantId: task.tenantId,
+      organizationId: task.organizationId,
+      taskId: task.id,
+      projectId: task.timeProjectId,
+      kind,
+      attachmentId,
+    },
+    { persistent: true },
+  ).catch((err) => {
+    logger.error('staff support attachment activity emit failed', { err, taskId: task.id })
+    getTelemetryRuntime()?.reportError(err, { module: 'staff', code: 'staff.support_activity_emit_failed' })
+  })
+}

package/src/modules/staff/lib/support-ui/PortalSupportNotLinked.tsx

@@ -0,0 +1,20 @@
+"use client"
+
+import * as React from 'react'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { EmptyState } from '@open-mercato/ui/primitives/empty-state'
+
+export function PortalSupportNotLinked({ size = 'lg' }: { size?: 'sm' | 'lg' }) {
+  const t = useT()
+  return (
+    <EmptyState
+      variant="subtle"
+      size={size}
+      title={t('staff.portal.support.notLinked.title', 'Support tickets are not available for your account')}
+      description={t(
+        'staff.portal.support.notLinked.description',
+        'Your portal account is not linked to a company, so there are no tickets to show. Ask your account administrator to link it.',
+      )}
+    />
+  )
+}