@open-mercato/core 0.6.8-develop.6998.1.d2bc46c56c → 0.6.8-develop.7001.1.03608ab252

package/src/modules/warranty_claims/lib/assigneeNames.ts

@@ -0,0 +1,184 @@
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
+import { E } from '#generated/entities.ids.generated'
+import { readSafeDecryptedString } from './decryptionSafety'
+
+export const ASSIGNEE_NAME_LOOKUP_LIMIT = 100
+
+export type AssigneeNameLookupDeps = {
+  container: { resolve: (name: string) => unknown }
+  tenantId: string | null
+  organizationId: string | null
+  organizationIds?: readonly string[] | null
+}
+
+const assigneeOrganizationId = Symbol('warranty_claims.assigneeOrganizationId')
+
+function toRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null
+}
+
+function resolveAuthUserEntityId(): EntityId | null {
+  const registry = E as unknown as Record<string, Record<string, string> | undefined>
+  const value = registry.auth?.user
+  return typeof value === 'string' ? (value as EntityId) : null
+}
+
+function resolveStaffMemberEntityId(): EntityId | null {
+  const registry = E as unknown as Record<string, Record<string, string> | undefined>
+  const value = registry.staff?.staff_team_member
+  return typeof value === 'string' ? (value as EntityId) : null
+}
+
+function toDisplayName(record: Record<string, unknown>): string | null {
+  return readSafeDecryptedString(record.name) ?? readSafeDecryptedString(record.email)
+}
+
+function readOrganizationId(record: Record<string, unknown>): string | null {
+  const hidden = (record as Record<PropertyKey, unknown>)[assigneeOrganizationId]
+  if (typeof hidden === 'string' && hidden.length) return hidden
+  const value = record.organizationId ?? record.organization_id
+  return typeof value === 'string' && value.length ? value : null
+}
+
+function organizationFilter(deps: AssigneeNameLookupDeps): string | { $in: string[] } | null {
+  if (deps.organizationId) return deps.organizationId
+  if (!Array.isArray(deps.organizationIds)) return null
+  const organizationIds = Array.from(new Set(deps.organizationIds.filter((id) => typeof id === 'string' && id.length)))
+  return organizationIds.length ? { $in: organizationIds } : null
+}
+
+async function queryAssigneeRecords(
+  deps: AssigneeNameLookupDeps,
+  userIds: string[],
+  entityId: EntityId | null,
+): Promise<Record<string, unknown>[]> {
+  const organizationScope = organizationFilter(deps)
+  if (!deps.tenantId || !userIds.length || !entityId) return []
+  if (!deps.organizationId && !organizationScope) return []
+  const queryEngine = deps.container.resolve('queryEngine') as QueryEngine
+  const result = await queryEngine.query<Record<string, unknown>>(entityId, {
+    tenantId: deps.tenantId,
+    filters: {
+      id: { $in: userIds.slice(0, ASSIGNEE_NAME_LOOKUP_LIMIT) },
+      ...(organizationScope ? { organization_id: organizationScope } : {}),
+      deleted_at: null,
+      is_confirmed: true,
+    },
+    fields: ['id', 'name', 'email', 'tenant_id', 'organization_id', 'is_confirmed'],
+    page: { page: 1, pageSize: ASSIGNEE_NAME_LOOKUP_LIMIT },
+  })
+  return (result.items ?? []).map(toRecord).filter((record): record is Record<string, unknown> => record !== null)
+}
+
+export function attachAssigneeOrganizationId<T extends Record<string, unknown>>(record: T, organizationId: string | null): T {
+  Object.defineProperty(record, assigneeOrganizationId, { value: organizationId, enumerable: false })
+  return record
+}
+
+export function collectAssigneeUserIds(items: readonly unknown[]): string[] {
+  const ids = new Set<string>()
+  for (const item of items) {
+    const record = toRecord(item)
+    if (!record) continue
+    const value = record.assigneeUserId
+    if (typeof value === 'string' && value.length) ids.add(value)
+    if (ids.size >= ASSIGNEE_NAME_LOOKUP_LIMIT) break
+  }
+  return [...ids]
+}
+
+export async function resolveAssigneeDisplayNames(
+  deps: AssigneeNameLookupDeps,
+  userIds: string[],
+  entityId: EntityId | null = resolveAuthUserEntityId(),
+): Promise<Map<string, string>> {
+  const names = new Map<string, string>()
+  try {
+    const records = await queryAssigneeRecords(deps, userIds, entityId)
+    for (const record of records) {
+      const id = record.id
+      if (typeof id !== 'string' || !id.length) continue
+      const displayName = toDisplayName(record)
+      if (displayName) names.set(id, displayName)
+    }
+  } catch {
+    return names
+  }
+  return names
+}
+
+export async function isAssignableStaffUser(
+  deps: AssigneeNameLookupDeps,
+  userId: string,
+  entityId: EntityId | null = resolveStaffMemberEntityId(),
+): Promise<boolean> {
+  if (!deps.tenantId || !deps.organizationId || !userId || !entityId) return false
+  try {
+    const queryEngine = deps.container.resolve('queryEngine') as QueryEngine
+    const result = await queryEngine.query<Record<string, unknown>>(entityId, {
+      tenantId: deps.tenantId,
+      filters: {
+        user_id: userId,
+        organization_id: deps.organizationId,
+        deleted_at: null,
+        is_active: true,
+      },
+      fields: ['id', 'user_id', 'organization_id', 'is_active'],
+      page: { page: 1, pageSize: 1 },
+    })
+    if (!result.items?.length) return false
+    const names = await resolveAssigneeDisplayNames(deps, [userId])
+    return names.has(userId)
+  } catch {
+    return false
+  }
+}
+
+export async function decorateItemsWithAssigneeNames(
+  items: readonly unknown[],
+  deps: AssigneeNameLookupDeps,
+): Promise<void> {
+  const records = items.map(toRecord).filter((record): record is Record<string, unknown> => record !== null)
+  if (!records.length) return
+  for (const record of records) {
+    if (!('assigneeName' in record)) record.assigneeName = null
+  }
+  const userIds = collectAssigneeUserIds(records)
+  if (!userIds.length) return
+  if (deps.organizationId) {
+    const names = await resolveAssigneeDisplayNames(deps, userIds)
+    if (!names.size) return
+    for (const record of records) {
+      const assigneeUserId = record.assigneeUserId
+      if (typeof assigneeUserId === 'string' && names.has(assigneeUserId)) {
+        record.assigneeName = names.get(assigneeUserId) ?? null
+      }
+    }
+    return
+  }
+  try {
+    const recordOrganizationIds = Array.from(new Set(records.map(readOrganizationId).filter((id): id is string => id !== null)))
+    const lookupDeps = deps.organizationIds === null
+      ? { ...deps, organizationIds: recordOrganizationIds }
+      : deps
+    const assignees = await queryAssigneeRecords(lookupDeps, userIds, resolveAuthUserEntityId())
+    const namesByOrganizationAndUser = new Map<string, string>()
+    for (const assignee of assignees) {
+      const userId = assignee.id
+      const organizationId = readOrganizationId(assignee)
+      const displayName = toDisplayName(assignee)
+      if (typeof userId === 'string' && organizationId && displayName) {
+        namesByOrganizationAndUser.set(`${organizationId}:${userId}`, displayName)
+      }
+    }
+    for (const record of records) {
+      const userId = record.assigneeUserId
+      const organizationId = readOrganizationId(record)
+      if (typeof userId !== 'string' || !organizationId) continue
+      record.assigneeName = namesByOrganizationAndUser.get(`${organizationId}:${userId}`) ?? null
+    }
+  } catch {
+    return
+  }
+}

package/src/modules/warranty_claims/lib/attachmentVisibility.ts

@@ -0,0 +1,5 @@
+export const CUSTOMER_VISIBLE_ATTACHMENT_TAG = 'customer-visible'
+
+export function isCustomerVisibleAttachment(metadataTags: string[] | undefined): boolean {
+  return Array.isArray(metadataTags) && metadataTags.includes(CUSTOMER_VISIBLE_ATTACHMENT_TAG)
+}

package/src/modules/warranty_claims/lib/bulkFeedback.ts

@@ -0,0 +1,6 @@
+import type { TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+
+export function appendSkippedBulkCount(summary: string, skipped: number, t: TranslateFn): string {
+  if (skipped <= 0) return summary
+  return `${summary} ${t('warranty_claims.bulk.skipped', '{skipped} skipped.', { skipped })}`
+}

package/src/modules/warranty_claims/lib/businessHours.ts

@@ -0,0 +1,333 @@
+const DAY_MS = 24 * 60 * 60 * 1000
+const MINUTE_MS = 60 * 1000
+const DAY_MINUTES = 24 * 60
+
+const WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'] as const
+
+export type BusinessWeekday = (typeof WEEKDAYS)[number]
+
+export type BusinessHoursInterval = {
+  start: string
+  end: string
+}
+
+export type BusinessHoursConfig = Record<string, unknown> & {
+  timezone?: string
+  week?: Partial<Record<BusinessWeekday, BusinessHoursInterval[]>>
+  holidays?: string[]
+}
+
+type TimeInterval = {
+  startMinutes: number
+  endMinutes: number
+}
+
+type LocalParts = {
+  year: number
+  month: number
+  day: number
+  hour: number
+  minute: number
+  second: number
+  millisecond: number
+}
+
+type NormalizedCalendar = {
+  timezone: string
+  holidays: Set<string>
+  week: Map<BusinessWeekday, TimeInterval[]>
+}
+
+function toRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null
+}
+
+function wallClockMillisBetween(start: Date, end: Date): number {
+  return Math.max(0, end.getTime() - start.getTime())
+}
+
+function resolveTimezone(value: unknown): string {
+  if (typeof value !== 'string' || value.trim().length === 0) return 'UTC'
+  const timezone = value.trim()
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: timezone }).format(new Date())
+    return timezone
+  } catch {
+    return 'UTC'
+  }
+}
+
+function formatterFor(timezone: string): Intl.DateTimeFormat {
+  return new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hourCycle: 'h23',
+  })
+}
+
+function datePartsInTimezone(date: Date, timezone: string): LocalParts {
+  const parts = formatterFor(timezone).formatToParts(date)
+  const getPart = (type: Intl.DateTimeFormatPartTypes): number => {
+    const value = parts.find((part) => part.type === type)?.value
+    return value ? Number(value) : 0
+  }
+  return {
+    year: getPart('year'),
+    month: getPart('month'),
+    day: getPart('day'),
+    hour: getPart('hour'),
+    minute: getPart('minute'),
+    second: getPart('second'),
+    millisecond: date.getUTCMilliseconds(),
+  }
+}
+
+function timezoneOffsetMs(date: Date, timezone: string): number {
+  const parts = datePartsInTimezone(date, timezone)
+  const localAsUtc = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second,
+    parts.millisecond,
+  )
+  return localAsUtc - date.getTime()
+}
+
+function zonedLocalToUtc(parts: LocalParts, timezone: string): Date {
+  const localAsUtc = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second,
+    parts.millisecond,
+  )
+  const firstOffset = timezoneOffsetMs(new Date(localAsUtc), timezone)
+  const firstCandidate = localAsUtc - firstOffset
+  const secondOffset = timezoneOffsetMs(new Date(firstCandidate), timezone)
+  return new Date(localAsUtc - secondOffset)
+}
+
+function dateKeyFromParts(parts: Pick<LocalParts, 'year' | 'month' | 'day'>): string {
+  return [
+    String(parts.year).padStart(4, '0'),
+    String(parts.month).padStart(2, '0'),
+    String(parts.day).padStart(2, '0'),
+  ].join('-')
+}
+
+function dateKeyFromDayStamp(dayStamp: number): string {
+  const date = new Date(dayStamp)
+  return dateKeyFromParts({
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate(),
+  })
+}
+
+function weekdayFromDayStamp(dayStamp: number): BusinessWeekday {
+  return WEEKDAYS[new Date(dayStamp).getUTCDay()]
+}
+
+function localDayStamp(date: Date, timezone: string): number {
+  const parts = datePartsInTimezone(date, timezone)
+  return Date.UTC(parts.year, parts.month - 1, parts.day)
+}
+
+function parseTime(value: unknown): number | null {
+  if (typeof value !== 'string') return null
+  const match = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(value.trim())
+  if (!match) return null
+  const hour = Number(match[1])
+  const minute = Number(match[2])
+  const second = match[3] ? Number(match[3]) : 0
+  if (!Number.isInteger(hour) || !Number.isInteger(minute) || !Number.isInteger(second)) return null
+  if (minute < 0 || minute > 59 || second !== 0) return null
+  if (hour === 24 && minute === 0 && second === 0) return DAY_MINUTES
+  if (hour < 0 || hour > 23) return null
+  return hour * 60 + minute
+}
+
+function parseIntervals(value: unknown): TimeInterval[] {
+  if (!Array.isArray(value)) return []
+  const intervals: TimeInterval[] = []
+  for (const rawInterval of value) {
+    const interval = toRecord(rawInterval)
+    if (!interval) continue
+    const startMinutes = parseTime(interval.start)
+    const endMinutes = parseTime(interval.end)
+    if (startMinutes === null || endMinutes === null || endMinutes <= startMinutes) continue
+    intervals.push({ startMinutes, endMinutes })
+  }
+  const sorted = intervals.sort((left, right) => left.startMinutes - right.startMinutes)
+  const merged: TimeInterval[] = []
+  for (const interval of sorted) {
+    const previous = merged[merged.length - 1]
+    if (!previous || interval.startMinutes > previous.endMinutes) {
+      merged.push({ ...interval })
+      continue
+    }
+    previous.endMinutes = Math.max(previous.endMinutes, interval.endMinutes)
+  }
+  return merged
+}
+
+function parseHolidays(value: unknown): Set<string> {
+  if (!Array.isArray(value)) return new Set()
+  return new Set(
+    value.filter((item): item is string => typeof item === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(item)),
+  )
+}
+
+function allDayWeek(): Map<BusinessWeekday, TimeInterval[]> {
+  return new Map(WEEKDAYS.map((weekday) => [weekday, [{ startMinutes: 0, endMinutes: DAY_MINUTES }]]))
+}
+
+function hasAnyInterval(week: Map<BusinessWeekday, TimeInterval[]>): boolean {
+  for (const intervals of week.values()) {
+    if (intervals.length > 0) return true
+  }
+  return false
+}
+
+function normalizeCalendar(config: BusinessHoursConfig | null | undefined): NormalizedCalendar | null {
+  const record = toRecord(config)
+  if (!record) return null
+
+  const timezone = resolveTimezone(record.timezone)
+  const holidays = parseHolidays(record.holidays)
+  const rawWeek = toRecord(record.week)
+  const week = new Map<BusinessWeekday, TimeInterval[]>()
+  if (rawWeek) {
+    for (const weekday of WEEKDAYS) {
+      week.set(weekday, parseIntervals(rawWeek[weekday]))
+    }
+    if (!hasAnyInterval(week)) return null
+  } else if (holidays.size > 0) {
+    return { timezone, holidays, week: allDayWeek() }
+  } else {
+    return null
+  }
+
+  return { timezone, holidays, week }
+}
+
+function localDateTimeForDay(dayStamp: number, minuteOfDay: number, timezone: string): Date {
+  const dayOffset = Math.floor(minuteOfDay / DAY_MINUTES)
+  const minutes = minuteOfDay % DAY_MINUTES
+  const date = new Date(dayStamp + dayOffset * DAY_MS)
+  return zonedLocalToUtc({
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate(),
+    hour: Math.floor(minutes / 60),
+    minute: minutes % 60,
+    second: 0,
+    millisecond: 0,
+  }, timezone)
+}
+
+export function businessMillisBetween(
+  start: Date,
+  end: Date,
+  config: BusinessHoursConfig | null | undefined,
+): number {
+  if (!(start instanceof Date) || !(end instanceof Date)) return 0
+  if (!Number.isFinite(start.getTime()) || !Number.isFinite(end.getTime())) return 0
+  if (end.getTime() <= start.getTime()) return 0
+
+  const calendar = normalizeCalendar(config)
+  if (!calendar) return wallClockMillisBetween(start, end)
+
+  const firstDay = localDayStamp(start, calendar.timezone)
+  const lastDay = localDayStamp(end, calendar.timezone)
+  let elapsed = 0
+
+  for (let dayStamp = firstDay; dayStamp <= lastDay; dayStamp += DAY_MS) {
+    const dateKey = dateKeyFromDayStamp(dayStamp)
+    if (calendar.holidays.has(dateKey)) continue
+
+    const intervals = calendar.week.get(weekdayFromDayStamp(dayStamp)) ?? []
+    for (const interval of intervals) {
+      const intervalStart = localDateTimeForDay(dayStamp, interval.startMinutes, calendar.timezone)
+      const intervalEnd = localDateTimeForDay(dayStamp, interval.endMinutes, calendar.timezone)
+      const overlapStart = Math.max(start.getTime(), intervalStart.getTime())
+      const overlapEnd = Math.min(end.getTime(), intervalEnd.getTime())
+      if (overlapEnd > overlapStart) elapsed += overlapEnd - overlapStart
+    }
+  }
+
+  return elapsed
+}
+
+export function slaProgressPct(
+  submittedAt: Date,
+  now: Date,
+  slaHours: number,
+  config: BusinessHoursConfig | null | undefined,
+): number {
+  if (!Number.isFinite(slaHours) || slaHours <= 0) return 0
+  const elapsed = businessMillisBetween(submittedAt, now, config)
+  return (elapsed / (slaHours * 60 * 60 * 1000)) * 100
+}
+
+const ADD_BUSINESS_MILLIS_HORIZON_DAYS = 3660
+
+export function addBusinessMillis(
+  start: Date,
+  durationMillis: number,
+  config: BusinessHoursConfig | null | undefined,
+): Date {
+  if (!(start instanceof Date) || !Number.isFinite(start.getTime())) return start
+  if (!Number.isFinite(durationMillis) || durationMillis <= 0) return new Date(start.getTime())
+
+  const calendar = normalizeCalendar(config)
+  if (!calendar) return new Date(start.getTime() + durationMillis)
+
+  let remaining = durationMillis
+  let dayStamp = localDayStamp(start, calendar.timezone)
+  const startMs = start.getTime()
+
+  for (let dayIndex = 0; dayIndex < ADD_BUSINESS_MILLIS_HORIZON_DAYS; dayIndex += 1, dayStamp += DAY_MS) {
+    const dateKey = dateKeyFromDayStamp(dayStamp)
+    if (calendar.holidays.has(dateKey)) continue
+
+    const intervals = calendar.week.get(weekdayFromDayStamp(dayStamp)) ?? []
+    for (const interval of intervals) {
+      const intervalStart = localDateTimeForDay(dayStamp, interval.startMinutes, calendar.timezone).getTime()
+      const intervalEnd = localDateTimeForDay(dayStamp, interval.endMinutes, calendar.timezone).getTime()
+      const usableStart = Math.max(startMs, intervalStart)
+      if (intervalEnd <= usableStart) continue
+      const available = intervalEnd - usableStart
+      if (available >= remaining) return new Date(usableStart + remaining)
+      remaining -= available
+    }
+  }
+
+  // Degenerate calendar (e.g. every future day marked as a holiday) — fall back
+  // to wall clock past the horizon instead of looping forever.
+  return new Date(startMs + durationMillis)
+}
+
+export function slaProgressPctFromDue(
+  now: Date,
+  slaDueAt: Date,
+  slaHours: number,
+  config: BusinessHoursConfig | null | undefined,
+): number {
+  if (!Number.isFinite(slaHours) || slaHours <= 0) return 0
+  const totalMillis = slaHours * 60 * 60 * 1000
+  if (now.getTime() >= slaDueAt.getTime()) {
+    return 100 + (businessMillisBetween(slaDueAt, now, config) / totalMillis) * 100
+  }
+  return Math.max(0, 100 - (businessMillisBetween(now, slaDueAt, config) / totalMillis) * 100)
+}