@ossy/timesheets 3.9.0 → 3.11.0

package/src/send-timesheet-reminder.task.js

@@ -0,0 +1,76 @@
+import { viewResource } from '@ossy/resources/server'
+import { TimesheetsSchema } from './schema-ids.js'
+import TimesheetReminderEmail, { subject as assignedSubject } from './timesheet-reminder.email.jsx'
+import {
+  formatPeriodLabel,
+  resolveTimesheetReminderRecipient,
+  shouldNotifyTimesheetCreated,
+  timesheetAssignedUrl,
+} from './timesheet-reminder.js'
+import { optionalReference } from './timesheet-refs.js'
+
+export const metadata = {
+  id: '@ossy/timesheets/tasks/send-reminder',
+  triggers: [
+    { type: TimesheetsSchema.timesheet, event: 'Created' },
+  ],
+}
+
+/**
+ * Email the linked employee when an auto-generated timesheet is created.
+ * Manual generate does not notify. Created fires once, so there is no daily cron.
+ */
+export async function run ({ event, log, integrations }) {
+  if (!shouldNotifyTimesheetCreated(event)) {
+    return { sent: 0, skipped: 1 }
+  }
+
+  const content = event.payload?.content ?? {}
+  const resourceId = event.resourceId
+  const timesheet = { id: resourceId, belongsTo: event.payload?.belongsTo, content }
+
+  const employeeId = optionalReference(content.employeeId)?.resourceId
+  const contractId = optionalReference(content.contractId)?.resourceId
+
+  const [employee, contract] = await Promise.all([
+    employeeId ? viewResource(employeeId).catch(() => null) : null,
+    contractId ? viewResource(contractId).catch(() => null) : null,
+  ])
+
+  const recipient = resolveTimesheetReminderRecipient(
+    employee ? [employee] : [],
+    timesheet,
+  )
+  if (!recipient) {
+    log?.warn(`[timesheets/tasks/send-reminder] no employee email for timesheet ${resourceId}`)
+    return { sent: 0, skipped: 1 }
+  }
+
+  const emailClient = integrations?.get?.('email')
+  if (!emailClient) {
+    log?.warn('[timesheets/tasks/send-reminder] No email integration available, skipping')
+    return { sent: 0, skipped: 1 }
+  }
+
+  const clientName = contract?.content?.clientName ?? null
+  const periodLabel = formatPeriodLabel(content.periodStart, content.periodEnd)
+  const timesheetsUrl = timesheetAssignedUrl(resourceId)
+
+  await emailClient.sendTemplate(
+    TimesheetReminderEmail,
+    {
+      employeeName: recipient.name,
+      clientName,
+      periodLabel,
+      timesheetsUrl,
+    },
+    {
+      to: recipient.email,
+      from: 'noreply@ossy.se',
+      subject: assignedSubject,
+    },
+  )
+
+  log?.info(`[timesheets/tasks/send-reminder] Assigned-timesheet email sent to ${recipient.email}`)
+  return { sent: 1, skipped: 0 }
+}

package/src/timesheet-dto.js

@@ -0,0 +1,26 @@
+import { optionalReference } from './timesheet-refs.js'
+
+export { optionalReference } from './timesheet-refs.js'
+
+/** Newest sheet for a period. Generate always creates a new resource; use get-by-id for a specific sheet. */
+export function findTimesheetForPeriod (resources, periodStart) {
+  const matches = (resources || []).filter((r) => r.content?.periodStart === periodStart)
+  if (matches.length === 0) return null
+  return [...matches].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0]
+}
+
+export function toTimesheetDto (resource) {
+  if (!resource) return null
+  return {
+    id: resource.id,
+    periodStart: resource.content?.periodStart,
+    periodEnd: resource.content?.periodEnd,
+    status: resource.content?.status ?? 'draft',
+    holidayLocale: resource.content?.holidayLocale ?? null,
+    employeeId: optionalReference(resource.content?.employeeId),
+    contractId: optionalReference(resource.content?.contractId),
+    lines: resource.content?.lines ?? [],
+    createdAt: resource.createdAt,
+    updatedAt: resource.updatedAt,
+  }
+}

package/src/timesheet-refs.js

@@ -0,0 +1,16 @@
+/**
+ * Normalize an optional document reference to `{ resourceId }` or `null`.
+ * Accepts a stored object, a plain id string, or empty.
+ */
+export function optionalReference (value) {
+  if (value == null || value === '') return null
+  if (typeof value === 'string') {
+    const id = value.trim()
+    return id ? { resourceId: id } : null
+  }
+  if (typeof value === 'object' && typeof value.resourceId === 'string') {
+    const id = value.resourceId.trim()
+    return id ? { resourceId: id } : null
+  }
+  return null
+}

package/src/timesheet-reminder.email.jsx

@@ -0,0 +1,47 @@
+import React from 'react'
+import { EmailLayout, EmailButton, EmailText } from '@ossy/email'
+
+export const id = '@ossy/timesheets/emails/reminder'
+export const subject = 'En tidrapport har skapats åt dig'
+
+export default function TimesheetReminderEmail ({
+  employeeName,
+  clientName,
+  periodLabel,
+  timesheetsUrl,
+}) {
+  const greeting = employeeName ? `Hej ${employeeName},` : 'Hej,'
+
+  return (
+    <EmailLayout>
+      <h1 style={{ color: '#111111', fontSize: 24, fontWeight: 700, margin: '0 0 24px' }}>
+        Du har tilldelats en tidrapport
+      </h1>
+
+      <EmailText>{greeting}</EmailText>
+
+      <EmailText>
+        En tidrapport har skapats åt dig
+        {clientName ? (
+          <>
+            {' '}för uppdraget <strong>{clientName}</strong>
+          </>
+        ) : null}
+        {periodLabel ? (
+          <>
+            {' '}för perioden <strong>{periodLabel}</strong>
+          </>
+        ) : null}
+        . Kontrollera timmarna och spara när de stämmer.
+      </EmailText>
+
+      {timesheetsUrl ? (
+        <EmailButton href={timesheetsUrl}>Öppna tidrapporten</EmailButton>
+      ) : null}
+
+      <EmailText style={{ color: '#888888', fontSize: 13 }}>
+        Du får det här mejlet för att en tidrapport skapades automatiskt utifrån ditt avtal.
+      </EmailText>
+    </EmailLayout>
+  )
+}

package/src/timesheet-reminder.js

@@ -0,0 +1,62 @@
+import { isEmailLike } from '@ossy/schema'
+import { optionalReference } from './timesheet-refs.js'
+
+/**
+ * Whether a timesheet Created event should notify the assigned employee.
+ * Manual generate does not email; auto-generate does, once, on create.
+ *
+ * @param {{ payload?: { content?: object }, resourceId?: string } | null | undefined} event
+ */
+export function shouldNotifyTimesheetCreated (event) {
+  const content = event?.payload?.content ?? {}
+  return content.autoGenerated === true && Boolean(event?.resourceId)
+}
+
+/**
+ * Resolve reminder recipient from the linked employee resource.
+ *
+ * @param {Array<{ id: string, content?: { name?: string, email?: string } }>} employees
+ * @param {{ content?: { employeeId?: unknown } }} timesheet
+ * @returns {{ email: string, name: string | null } | null}
+ */
+export function resolveTimesheetReminderRecipient (employees, timesheet) {
+  const employeeId = optionalReference(timesheet?.content?.employeeId)?.resourceId
+  if (!employeeId) return null
+
+  const employee = (employees || []).find((e) => e.id === employeeId)
+  const email = employee?.content?.email?.trim?.() ?? employee?.content?.email
+  if (!isEmailLike(email)) return null
+
+  return {
+    email: String(email).trim(),
+    name: employee?.content?.name ?? null,
+  }
+}
+
+/**
+ * Public timesheets home URL, optionally opening a specific sheet (`?r=`).
+ * Swedish email copy uses `/tidrapporter`.
+ *
+ * @param {string} [resourceId]
+ * @param {string} [origin]
+ */
+export function timesheetAssignedUrl (resourceId, origin = process.env.WEB_CLIENT_DOMAIN) {
+  const base = String(origin || '').replace(/\/$/, '')
+  if (!base) return null
+  const path = '/tidrapporter'
+  if (!resourceId) return `${base}${path}`
+  return `${base}${path}?r=${encodeURIComponent(resourceId)}`
+}
+
+/**
+ * Format a period for email copy (local calendar dates).
+ * @param {number} periodStart
+ * @param {number} periodEnd
+ * @param {string} [locale]
+ */
+export function formatPeriodLabel (periodStart, periodEnd, locale = 'sv-SE') {
+  const start = new Date(periodStart)
+  const end = new Date(periodEnd)
+  const opts = { year: 'numeric', month: 'long', day: 'numeric' }
+  return `${start.toLocaleDateString(locale, opts)} – ${end.toLocaleDateString(locale, opts)}`
+}

package/src/timesheet-reminder.spec.js

@@ -0,0 +1,75 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  formatPeriodLabel,
+  resolveTimesheetReminderRecipient,
+  shouldNotifyTimesheetCreated,
+  timesheetAssignedUrl,
+} from './timesheet-reminder.js'
+
+describe('shouldNotifyTimesheetCreated', () => {
+  it('notifies only auto-generated creates', () => {
+    expect(shouldNotifyTimesheetCreated({
+      resourceId: 'sheet-1',
+      payload: { content: { autoGenerated: true } },
+    })).toBe(true)
+
+    expect(shouldNotifyTimesheetCreated({
+      resourceId: 'sheet-2',
+      payload: { content: { autoGenerated: false } },
+    })).toBe(false)
+
+    expect(shouldNotifyTimesheetCreated({
+      resourceId: 'sheet-3',
+      payload: { content: {} },
+    })).toBe(false)
+
+    expect(shouldNotifyTimesheetCreated({
+      payload: { content: { autoGenerated: true } },
+    })).toBe(false)
+  })
+})
+
+describe('resolveTimesheetReminderRecipient', () => {
+  it('requires a linked employee with a valid email', () => {
+    const employees = [
+      { id: 'emp-1', content: { name: 'Ada', email: 'ada@example.com' } },
+      { id: 'emp-2', content: { name: 'Bob', email: 'not-an-email' } },
+    ]
+
+    expect(resolveTimesheetReminderRecipient(employees, {
+      content: { employeeId: 'emp-1' },
+    })).toEqual({ email: 'ada@example.com', name: 'Ada' })
+
+    expect(resolveTimesheetReminderRecipient(employees, {
+      content: { employeeId: 'emp-2' },
+    })).toBe(null)
+
+    expect(resolveTimesheetReminderRecipient(employees, {
+      content: {},
+    })).toBe(null)
+  })
+})
+
+describe('timesheetAssignedUrl', () => {
+  it('builds the Swedish home URL with an optional sheet query', () => {
+    expect(timesheetAssignedUrl(undefined, 'https://app.ossy.se/')).toBe(
+      'https://app.ossy.se/tidrapporter',
+    )
+    expect(timesheetAssignedUrl('sheet-1', 'https://app.ossy.se')).toBe(
+      'https://app.ossy.se/tidrapporter?r=sheet-1',
+    )
+    expect(timesheetAssignedUrl('sheet-1', '')).toBe(null)
+  })
+})
+
+describe('formatPeriodLabel', () => {
+  it('formats inclusive local dates', () => {
+    const label = formatPeriodLabel(
+      new Date(2026, 7, 1).getTime(),
+      new Date(2026, 7, 31).getTime(),
+      'en-US',
+    )
+    expect(label).toContain('2026')
+    expect(label).toContain('–')
+  })
+})

package/src/timesheet-resources.js

@@ -1,5 +1,11 @@
 import { ResourcesQueries } from '@ossy/resources/server'
 
+export {
+  optionalReference,
+  findTimesheetForPeriod,
+  toTimesheetDto,
+} from './timesheet-dto.js'
+
 /**
  * List timesheet resources by schema id (and optional workspace).
  */
@@ -8,43 +14,3 @@ export function getTimesheetResources ({ schemaId, belongsTo } = {}) {
   if (belongsTo) query.belongsTo = belongsTo
   return ResourcesQueries.GetResources(query)
 }
-
-/** Newest sheet for a period. Generate always creates a new resource; use get-by-id for a specific sheet. */
-export function findTimesheetForPeriod (resources, periodStart) {
-  const matches = (resources || []).filter((r) => r.content?.periodStart === periodStart)
-  if (matches.length === 0) return null
-  return [...matches].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0]
-}
-
-/**
- * Normalize an optional document reference to `{ resourceId }` or `null`.
- * Accepts a stored object, a plain id string, or empty.
- */
-export function optionalReference (value) {
-  if (value == null || value === '') return null
-  if (typeof value === 'string') {
-    const id = value.trim()
-    return id ? { resourceId: id } : null
-  }
-  if (typeof value === 'object' && typeof value.resourceId === 'string') {
-    const id = value.resourceId.trim()
-    return id ? { resourceId: id } : null
-  }
-  return null
-}
-
-export function toTimesheetDto (resource) {
-  if (!resource) return null
-  return {
-    id: resource.id,
-    periodStart: resource.content?.periodStart,
-    periodEnd: resource.content?.periodEnd,
-    status: resource.content?.status ?? 'draft',
-    holidayLocale: resource.content?.holidayLocale ?? null,
-    employeeId: optionalReference(resource.content?.employeeId),
-    contractId: optionalReference(resource.content?.contractId),
-    lines: resource.content?.lines ?? [],
-    createdAt: resource.createdAt,
-    updatedAt: resource.updatedAt,
-  }
-}

package/src/timesheet-resources.spec.js

@@ -3,7 +3,7 @@ import {
   findTimesheetForPeriod,
   optionalReference,
   toTimesheetDto,
-} from './timesheet-resources.js'
+} from './timesheet-dto.js'
 
 describe('optionalReference', () => {
   it('normalizes ids, objects, and empty values', () => {

package/src/timesheet.schema.js

@@ -38,6 +38,11 @@ export default {
       of: TimesheetRefs.contract,
       description: 'Optional contract this timesheet belongs to',
     },
+    {
+      name: 'autoGenerated',
+      type: 'boolean',
+      description: 'Set when the daily auto-generate cron created this sheet',
+    },
     // `lines` is stored in content (array of day rows) — same nested-content pattern as booking availability.
   ],
 }

package/src/timesheets.page.jsx

@@ -20,11 +20,12 @@ export default function TimesheetsHomePage () {
   const app = useApp()
   const router = useRouter()
   const { workspace: shellWorkspace } = useShellWorkspace()
-  const { read, invoke, invalidate } = useSdk()
+  const { read, invoke } = useSdk()
   const isAuthenticated = !!app?.isAuthenticated
   const {
     data: workspaceFromSdk,
     status: workspaceStatus,
+    refetch: refetchWorkspace,
   } = read(GetWorkspace, undefined, { enabled: isAuthenticated })
   const autoEnableStarted = useRef(false)
 
@@ -52,10 +53,12 @@ export default function TimesheetsHomePage () {
     && workspaceStatus !== AsyncStatus.Error
     && app?.workspaceServices == null
 
+  // Shared GetWorkspace cache with useShellWorkspace — refetch (not bare invalidate)
+  // awaits the post-enable read so home can switch sales → product reliably.
   const enableService = useCallback(() => {
     return invoke(EnableService, { service: TIMESHEETS_SERVICE })
-      .then(() => invalidate(cacheKey(GetWorkspace)))
-  }, [invoke, invalidate])
+      .then(() => refetchWorkspace())
+  }, [invoke, refetchWorkspace])
 
   useEffect(() => {
     if (!isAuthenticated || !enableRequested || autoEnableStarted.current) return