@nuxt-customer-portal/timesheets 0.3.0

package/server/api/timesheets/admin/projects/index.get.ts

@@ -0,0 +1,18 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { projectListQuerySchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+import { listProjectsPage } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-admin-listing'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsAdminProjectsGet',
+    summary: 'List timesheet projects',
+    description: 'List timesheet projects. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'manage')
+  return listProjectsPage(organizationId, projectListQuerySchema.parse(getQuery(event)))
+})

package/server/api/timesheets/admin/projects/index.post.ts

@@ -0,0 +1,19 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { createProject } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { projectCreateSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsAdminProjectsPost',
+    summary: 'Create a timesheet project',
+    description:
+      'Create a timesheet project. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'manage')
+  return createProject(organizationId, projectCreateSchema.parse(await readBody(event)))
+})

package/server/api/timesheets/admin/report.get.ts

@@ -0,0 +1,26 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { getReport, reportToCsv } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { reportQuerySchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsAdminReportGet',
+    summary: 'Get a timesheets report',
+    description: 'Get a timesheets report. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'report')
+  const rawQuery = getQuery(event)
+  const format = rawQuery.format
+  const report = await getReport(organizationId, reportQuerySchema.parse(rawQuery))
+  if (format === 'csv') {
+    setResponseHeader(event, 'content-type', 'text/csv; charset=utf-8')
+    setResponseHeader(event, 'content-disposition', 'attachment; filename="timesheets.csv"')
+    return reportToCsv(report)
+  }
+  return report
+})

package/server/api/timesheets/admin/settings.patch.ts

@@ -0,0 +1,19 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { updateSettings } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { settingsUpdateSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsAdminSettingsPatch',
+    summary: 'Update timesheets workspace settings',
+    description:
+      'Update timesheets workspace settings. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'manage')
+  return updateSettings(organizationId, settingsUpdateSchema.parse(await readBody(event)))
+})

package/server/api/timesheets/admin/tariffs/index.put.ts

@@ -0,0 +1,20 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { setTeamTariff } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { tariffUpdateSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsAdminTariffsPut',
+    summary: 'Update team billing rates',
+    description:
+      'Update team billing rates. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'manage')
+  const input = tariffUpdateSchema.parse(await readBody(event))
+  return setTeamTariff(organizationId, input.userId, input.hourlyRateMinor)
+})

package/server/api/timesheets/admin/team/[userId].put.ts

@@ -0,0 +1,24 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { updateTeamMemberSettings } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { teamMemberSettingsUpdateSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsAdminTeamMemberPut',
+    summary: 'Update a team member’s Timesheets settings',
+    description: 'Update time-entry eligibility and the default hourly rate for an organization member.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'manage')
+  const userId = getRouterParam(event, 'userId')
+  if (!userId) {
+    throw createError({ statusCode: 400, message: 'Team member is required' })
+  }
+  const input = teamMemberSettingsUpdateSchema.parse(await readBody(event))
+  await updateTeamMemberSettings(organizationId, userId, input)
+  return { updated: true }
+})

package/server/api/timesheets/bootstrap.get.ts

@@ -0,0 +1,24 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import {
+  getBootstrap,
+  requireTimesheetWorkspace
+} from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { weekQuerySchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsBootstrapGet',
+    summary: 'Get timesheets workspace data',
+    description:
+      'Get timesheets workspace data. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'read')
+  const query = weekQuerySchema.parse(getQuery(event))
+  await requireTimesheetWorkspace(organizationId)
+  return getBootstrap(organizationId, session.user.id, query.week)
+})

package/server/api/timesheets/capabilities.get.ts

@@ -0,0 +1,58 @@
+import { eq } from 'drizzle-orm'
+import { db, requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { workspaceSettings } from '@nuxt-customer-portal/timesheets/server/db/schema/timesheets'
+import {
+  canMemberEnterTime,
+  hasInternalApprovalAssignment,
+  listApprovalQueue,
+  listClientApprovals,
+  listClientReviewerSuppliers,
+  listClientWorkspaces
+} from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import type { TimesheetCapabilitiesDto } from '@nuxt-customer-portal/timesheets/shared/types/timesheet'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, organizationType, role } = await requireActiveOrganizationRole(event)
+  const isAdmin = role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  const [settings, clientWorkspaces, approvals, reviewerSuppliers, memberCanEnterTime] = await Promise.all([
+    db
+      .select({
+        workspaceEnabled: workspaceSettings.workspaceEnabled,
+        internalApprovalsEnabled: workspaceSettings.internalApprovalsEnabled
+      })
+      .from(workspaceSettings)
+      .where(eq(workspaceSettings.organizationId, organizationId))
+      .limit(1),
+    listClientWorkspaces(organizationId, session.user.id, isAdmin),
+    listClientApprovals(organizationId, session.user.id, isAdmin),
+    isAdmin ? listClientReviewerSuppliers(organizationId, session.user.id) : Promise.resolve([]),
+    canMemberEnterTime(organizationId, session.user.id)
+  ])
+  const reviewWorkspaces = clientWorkspaces.filter((item) => item.accessMode === 'REVIEW')
+  const workspaceEnabled = organizationType === 'PROVIDER' && (settings[0]?.workspaceEnabled ?? false)
+  const internalApprovals =
+    workspaceEnabled && (settings[0]?.internalApprovalsEnabled ?? true)
+      ? await listApprovalQueue(organizationId, session.user.id)
+      : []
+  const hasInternalApprovalAssignments =
+    workspaceEnabled &&
+    (settings[0]?.internalApprovalsEnabled ?? true) &&
+    (await hasInternalApprovalAssignment(organizationId, session.user.id))
+  return {
+    canEnterTime: workspaceEnabled && memberCanEnterTime,
+    canApproveInternalTimesheets: hasInternalApprovalAssignments,
+    hasInternalApprovalAssignments,
+    canManageTimesheets: organizationType === 'PROVIDER' && isAdmin && workspaceEnabled,
+    canReviewClientTimesheets:
+      reviewWorkspaces.length > 0 &&
+      (isAdmin || reviewWorkspaces.some((item) => item.canReview) || approvals.items.length > 0),
+    canViewSupplierTime: organizationType === 'CLIENT' && clientWorkspaces.some((item) => item.accessMode === 'VIEW'),
+    canAccessApprovals:
+      reviewWorkspaces.length > 0 &&
+      (isAdmin || reviewWorkspaces.some((item) => item.canReview) || approvals.items.length > 0),
+    canManageClientReviewers: isAdmin && reviewWorkspaces.length > 0,
+    pendingInternalApprovalCount: internalApprovals.filter((item) => item.status === 'SUBMITTED').length,
+    pendingClientApprovalCount: approvals.pendingCount,
+    unassignedClientReviewerSupplierCount: reviewerSuppliers.filter((item) => item.reviewerCount === 0).length
+  } satisfies TimesheetCapabilitiesDto
+})

package/server/api/timesheets/client/[workspaceClientId]/index.get.ts

@@ -0,0 +1,12 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { getClientTimesheets } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  return getClientTimesheets(
+    getRouterParam(event, 'workspaceClientId')!,
+    organizationId,
+    session.user.id,
+    role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  )
+})

package/server/api/timesheets/client/[workspaceClientId]/reviewers.get.ts

@@ -0,0 +1,10 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { listClientReviewers } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  if (role !== 'owner' && role !== 'admin' && session.user.role !== 'admin') {
+    throw createError({ statusCode: 403, message: 'Client organization admin access required' })
+  }
+  return listClientReviewers(getRouterParam(event, 'workspaceClientId')!, organizationId)
+})

package/server/api/timesheets/client/[workspaceClientId]/reviewers.put.ts

@@ -0,0 +1,18 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { setClientReviewer } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { clientReviewerUpdateSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  if (role !== 'owner' && role !== 'admin' && session.user.role !== 'admin') {
+    throw createError({ statusCode: 403, message: 'Client organization admin access required' })
+  }
+  const input = clientReviewerUpdateSchema.parse(await readBody(event))
+  return setClientReviewer(
+    getRouterParam(event, 'workspaceClientId')!,
+    organizationId,
+    session.user.id,
+    input.userId,
+    input.assigned
+  )
+})

package/server/api/timesheets/client/[workspaceClientId]/reviews/[submissionId].post.ts

@@ -0,0 +1,18 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { reviewClientTimesheet } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { clientReviewSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  const input = clientReviewSchema.parse(await readBody(event))
+  return reviewClientTimesheet(
+    getRouterParam(event, 'workspaceClientId')!,
+    organizationId,
+    session.user.id,
+    role === 'owner' || role === 'admin' || session.user.role === 'admin',
+    getRouterParam(event, 'submissionId')!,
+    input.action,
+    input.expectedVersion,
+    input.comment
+  )
+})

package/server/api/timesheets/client/approval-members.get.ts

@@ -0,0 +1,11 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { listClientApprovals } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  const isAdmin = role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  const approvals = await listClientApprovals(organizationId, session.user.id, isAdmin)
+  return [
+    ...new Map(approvals.items.map((item) => [item.userId, { id: item.userId, name: item.person }])).values()
+  ].sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))
+})

package/server/api/timesheets/client/approval-suppliers.get.ts

@@ -0,0 +1,8 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { listClientApprovalSuppliers } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  const isAdmin = role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  return listClientApprovalSuppliers(organizationId, session.user.id, isAdmin)
+})

package/server/api/timesheets/client/approvals.get.ts

@@ -0,0 +1,14 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { clientApprovalListQuerySchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+import { listClientApprovalsPage } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-admin-listing'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  const isAdmin = role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  return listClientApprovalsPage(
+    organizationId,
+    session.user.id,
+    isAdmin,
+    clientApprovalListQuerySchema.parse(getQuery(event))
+  )
+})

package/server/api/timesheets/client/reviewer-suppliers.get.ts

@@ -0,0 +1,10 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { listClientReviewerSuppliers } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  if (role !== 'owner' && role !== 'admin' && session.user.role !== 'admin') {
+    throw createError({ statusCode: 403, message: 'Client organization admin access required' })
+  }
+  return listClientReviewerSuppliers(organizationId, session.user.id)
+})

package/server/api/timesheets/client/supplier-options.get.ts

@@ -0,0 +1,14 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { listClientSupplierOptions } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, organizationType, role } = await requireActiveOrganizationRole(event)
+  if (organizationType !== 'CLIENT') {
+    throw createError({ statusCode: 403, message: 'Supplier timesheets are only available to client organizations' })
+  }
+  return listClientSupplierOptions(
+    organizationId,
+    session.user.id,
+    role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  )
+})

package/server/api/timesheets/client/supplier-timesheets.get.ts

@@ -0,0 +1,17 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { clientSupplierTimesheetListQuerySchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+import { listClientSupplierTimesheetsPage } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-admin-listing'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, organizationType, role } = await requireActiveOrganizationRole(event)
+  if (organizationType !== 'CLIENT') {
+    throw createError({ statusCode: 403, message: 'Supplier timesheets are only available to client organizations' })
+  }
+  const isAdmin = role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  return listClientSupplierTimesheetsPage(
+    organizationId,
+    session.user.id,
+    isAdmin,
+    clientSupplierTimesheetListQuerySchema.parse(getQuery(event))
+  )
+})

package/server/api/timesheets/client/workspaces.get.ts

@@ -0,0 +1,11 @@
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { listClientWorkspaces } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  return listClientWorkspaces(
+    organizationId,
+    session.user.id,
+    role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  )
+})

package/server/api/timesheets/client-approvals.get.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import { requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import { internalApprovalListQuerySchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+import { listProviderClientApprovalsPage } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-admin-listing'
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId, role } = await requireActiveOrganizationRole(event)
+  if (!['owner', 'admin'].includes(role)) {
+    throw createError({ statusCode: 403, message: 'Workspace administrator access required' })
+  }
+  const query = internalApprovalListQuerySchema
+    .extend({
+      clientOrganizationId: z.string().min(1).optional(),
+      status: z.enum(['PENDING', 'APPROVED', 'DISPUTED', 'AUTO_APPROVED']).optional()
+    })
+    .parse(getQuery(event))
+  return listProviderClientApprovalsPage(organizationId, session.user.id, query)
+})

package/server/api/timesheets/dashboard.get.ts

@@ -0,0 +1,191 @@
+import { selectClientDashboardApprovals } from '@nuxt-customer-portal/timesheets/shared/client-approval-dashboard'
+import { and, desc, eq, inArray, sql } from 'drizzle-orm'
+import { db, requireActiveOrganizationRole } from '@nuxt-customer-portal/core/server/portal'
+import {
+  workspaceSettings,
+  timesheetSubmission,
+  weeklyTimesheet,
+  timeEntry
+} from '@nuxt-customer-portal/timesheets/server/db/schema/timesheets'
+import {
+  canMemberEnterTime,
+  getBootstrap,
+  hasInternalApprovalAssignment,
+  listApprovalQueue,
+  listClientApprovals,
+  listClientReviewerSuppliers,
+  listClientSupplierTimesheets,
+  listClientWorkspaces
+} from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import type { TimesheetsDashboardDto } from '@nuxt-customer-portal/timesheets/shared/types/timesheet'
+
+export default defineEventHandler(async (event): Promise<TimesheetsDashboardDto> => {
+  const { session, organizationId, organizationType, role } = await requireActiveOrganizationRole(event)
+  const isAdmin = role === 'owner' || role === 'admin' || session.user.role === 'admin'
+  const [settingsRow, clientWorkspaces, memberCanEnterTime] = await Promise.all([
+    db
+      .select({
+        workspaceEnabled: workspaceSettings.workspaceEnabled,
+        internalApprovalsEnabled: workspaceSettings.internalApprovalsEnabled,
+        currency: workspaceSettings.currency
+      })
+      .from(workspaceSettings)
+      .where(eq(workspaceSettings.organizationId, organizationId))
+      .limit(1),
+    listClientWorkspaces(organizationId, session.user.id, isAdmin),
+    canMemberEnterTime(organizationId, session.user.id)
+  ])
+  const settings = settingsRow[0]
+  const workspaceEnabled = settings?.workspaceEnabled ?? false
+  const canEnterTime = workspaceEnabled && memberCanEnterTime
+  const reviewWorkspaces = clientWorkspaces.filter((item) => item.accessMode === 'REVIEW')
+  const canViewSupplierTime =
+    organizationType === 'CLIENT' && clientWorkspaces.some((item) => item.accessMode === 'VIEW')
+  const hasInternalApprovals =
+    workspaceEnabled &&
+    (settings?.internalApprovalsEnabled ?? true) &&
+    (await hasInternalApprovalAssignment(organizationId, session.user.id))
+
+  const [bootstrap, approvalQueue, clientApprovals, reviewerSuppliers, supplierTimesheets] = await Promise.all([
+    canEnterTime ? getBootstrap(organizationId, session.user.id) : Promise.resolve(null),
+    hasInternalApprovals ? listApprovalQueue(organizationId, session.user.id) : Promise.resolve([]),
+    reviewWorkspaces.length ? listClientApprovals(organizationId, session.user.id, isAdmin) : Promise.resolve(null),
+    isAdmin && reviewWorkspaces.length
+      ? listClientReviewerSuppliers(organizationId, session.user.id)
+      : Promise.resolve([]),
+    canViewSupplierTime ? listClientSupplierTimesheets(organizationId, session.user.id, isAdmin) : Promise.resolve([])
+  ])
+
+  const pendingInternal = approvalQueue.filter((item) => item.status === 'SUBMITTED')
+  const clientDashboard = selectClientDashboardApprovals(clientApprovals?.items ?? [], session.user.id)
+  const unsubmittedEntries = bootstrap?.week.entries.filter((entry) => !entry.submissionId) ?? []
+  const unsubmittedDates = unsubmittedEntries.map((entry) => entry.entryDate).sort()
+
+  const previousSubmissions = bootstrap
+    ? await db
+        .select({
+          id: timesheetSubmission.id,
+          weekStartsOn: weeklyTimesheet.weekStartsOn,
+          periodStartsOn: timesheetSubmission.periodStartsOn,
+          periodEndsOn: timesheetSubmission.periodEndsOn,
+          status: timesheetSubmission.status,
+          totalMinutes: sql<number>`coalesce(sum(${timeEntry.durationMinutes}), 0)`.mapWith(Number)
+        })
+        .from(timesheetSubmission)
+        .innerJoin(weeklyTimesheet, eq(weeklyTimesheet.id, timesheetSubmission.weeklyTimesheetId))
+        .leftJoin(timeEntry, eq(timeEntry.submissionId, timesheetSubmission.id))
+        .where(
+          and(
+            eq(timesheetSubmission.organizationId, organizationId),
+            eq(timesheetSubmission.userId, session.user.id),
+            inArray(timesheetSubmission.status, ['SUBMITTED', 'REJECTED', 'APPROVED'])
+          )
+        )
+        .groupBy(timesheetSubmission.id, weeklyTimesheet.weekStartsOn)
+        .orderBy(
+          desc(weeklyTimesheet.weekStartsOn),
+          desc(timesheetSubmission.periodEndsOn),
+          desc(timesheetSubmission.id)
+        )
+        .limit(5)
+    : []
+
+  return {
+    ...(bootstrap && {
+      myWeek: {
+        previousSubmissions,
+        projects: [...new Set(bootstrap.week.entries.map((entry) => entry.projectId))].map((id) => {
+          const project = bootstrap.projects.find((item) => item.id === id)!
+          return {
+            id,
+            name: project.name,
+            clientName: project.clientName,
+            totalMinutes: bootstrap.week.entries
+              .filter((entry) => entry.projectId === id)
+              .reduce((sum, entry) => sum + entry.durationMinutes, 0)
+          }
+        }),
+        weekStartsOn: bootstrap.week.weekStartsOn,
+        status: bootstrap.week.submissions.some((item) => item.status === 'REJECTED')
+          ? ('REJECTED' as const)
+          : bootstrap.week.submissions.some((item) => item.status === 'SUBMITTED')
+            ? ('SUBMITTED' as const)
+            : bootstrap.week.entries.length > 0 &&
+                bootstrap.week.entries.every((item) => item.submissionStatus === 'APPROVED')
+              ? ('APPROVED' as const)
+              : ('DRAFT' as const),
+        totalMinutes: bootstrap.week.entries.reduce((sum, entry) => sum + entry.durationMinutes, 0),
+        rejectionComment:
+          bootstrap.week.submissions.find((item) => item.status === 'REJECTED')?.rejectionComment ?? null,
+        hasRunningTimer: bootstrap.week.entries.some((entry) => Boolean(entry.timerStartedAt)),
+        batches: bootstrap.week.submissions.map((submission) => ({
+          id: submission.id,
+          status: submission.status,
+          totalMinutes: bootstrap.week.entries
+            .filter((entry) => entry.submissionId === submission.id)
+            .reduce((sum, entry) => sum + entry.durationMinutes, 0),
+          periodStartsOn: submission.periodStartsOn,
+          periodEndsOn: submission.periodEndsOn
+        })),
+        unsubmitted: unsubmittedEntries.length
+          ? {
+              totalMinutes: unsubmittedEntries.reduce((sum, entry) => sum + entry.durationMinutes, 0),
+              periodStartsOn: unsubmittedDates[0]!,
+              periodEndsOn: unsubmittedDates.at(-1)!
+            }
+          : null
+      }
+    }),
+    ...(hasInternalApprovals && {
+      internalApprovals: {
+        pendingCount: pendingInternal.length,
+        items: approvalQueue
+          .slice(0, 5)
+          .map(({ id, userName, weekStartsOn, periodStartsOn, periodEndsOn, totalMinutes, submittedAt, status }) => ({
+            id,
+            userName,
+            weekStartsOn,
+            periodStartsOn,
+            periodEndsOn,
+            totalMinutes,
+            submittedAt,
+            status
+          }))
+      }
+    }),
+    ...(reviewWorkspaces.length && {
+      clientApprovals: {
+        pendingCount: clientDashboard.pendingCount,
+        hasHistory: clientDashboard.hasHistory,
+        unassignedSupplierCount: reviewerSuppliers.filter((item) => item.reviewerCount === 0).length,
+        items: clientDashboard.items.map(
+          ({ id, supplierName, person, weekStartsOn, periodStartsOn, periodEndsOn, totalMinutes, status }) => ({
+            status,
+            id,
+            supplierName,
+            person,
+            weekStartsOn,
+            periodStartsOn,
+            periodEndsOn,
+            totalMinutes
+          })
+        )
+      }
+    }),
+    ...(canViewSupplierTime && {
+      supplierTimesheets: {
+        items: supplierTimesheets
+          .slice(0, 5)
+          .map(({ id, supplierName, person, weekStartsOn, periodStartsOn, periodEndsOn, totalMinutes }) => ({
+            id,
+            supplierName,
+            person,
+            weekStartsOn,
+            periodStartsOn,
+            periodEndsOn,
+            totalMinutes
+          }))
+      }
+    })
+  }
+})

package/server/api/timesheets/entries/[id].delete.ts

@@ -0,0 +1,18 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { deleteEntry } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsEntriesByIdDelete',
+    summary: 'Delete a time entry',
+    description: 'Delete a time entry. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'update')
+  await deleteEntry(organizationId, session.user.id, getRouterParam(event, 'id')!)
+  return { success: true }
+})

package/server/api/timesheets/entries/[id].patch.ts

@@ -0,0 +1,23 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { timesheetsFeature } from '@nuxt-customer-portal/timesheets/shared/feature'
+import { updateEntry } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { entryUpdateSchema } from '@nuxt-customer-portal/timesheets/server/utils/timesheet-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Timesheets'],
+    operationId: 'timesheetsEntriesByIdPatch',
+    summary: 'Update a time entry',
+    description: 'Update a time entry. Scoped to the active organization and the applicable Timesheets permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { session, organizationId } = await requireFeatureAccess(event, timesheetsFeature.policy, 'update')
+  return updateEntry(
+    organizationId,
+    session.user.id,
+    getRouterParam(event, 'id')!,
+    entryUpdateSchema.parse(await readBody(event))
+  )
+})