@ossy/timesheets 3.8.0 → 3.10.0

package/src/list.task.js

@@ -29,7 +29,11 @@ export async function run ({ payload, req, log }) {
 
   const sheets = resources
     .map(toTimesheetDto)
-    .sort((a, b) => (b.periodStart ?? 0) - (a.periodStart ?? 0))
+    .sort((a, b) => {
+      const period = (b.periodStart ?? 0) - (a.periodStart ?? 0)
+      if (period !== 0) return period
+      return (b.createdAt ?? 0) - (a.createdAt ?? 0)
+    })
 
   log?.info(`[timesheets/tasks/list] Found ${sheets.length} timesheet(s)`)
 

package/src/save.task.js

@@ -1,12 +1,12 @@
 import { ResourcesEvents, mutateResource, viewResource } from '@ossy/resources/server'
 import { TimesheetsSchema } from './schema-ids.js'
-import { toTimesheetDto } from './timesheet-resources.js'
+import { toTimesheetDto, optionalReference } from './timesheet-resources.js'
 
 export const metadata = { id: '@ossy/timesheets/tasks/save' }
 
 /**
  * Persist lines and set status to `saved`.
- * Payload: `{ timesheetId, lines }`
+ * Payload: `{ timesheetId, lines, employeeId?, contractId? }`
  */
 export async function run ({ payload, req, log }) {
   const workspaceId = req?.workspaceId
@@ -15,7 +15,7 @@ export async function run ({ payload, req, log }) {
     throw Object.assign(new Error('workspaceId is required'), { status: 400 })
   }
 
-  const { timesheetId, lines } = payload ?? {}
+  const { timesheetId, lines, employeeId: employeePayload, contractId: contractPayload } = payload ?? {}
 
   if (!timesheetId) {
     throw Object.assign(new Error('timesheetId is required'), { status: 400 })
@@ -42,12 +42,23 @@ export async function run ({ payload, req, log }) {
   }))
 
   const content = {
-    periodStart: resource.content?.periodStart,
-    periodEnd: resource.content?.periodEnd,
+    ...resource.content,
     status: 'saved',
     lines: normalizedLines,
   }
 
+  if ('employeeId' in (payload ?? {})) {
+    const employeeId = optionalReference(employeePayload)
+    if (employeeId) content.employeeId = employeeId
+    else delete content.employeeId
+  }
+
+  if ('contractId' in (payload ?? {})) {
+    const contractId = optionalReference(contractPayload)
+    if (contractId) content.contractId = contractId
+    else delete content.contractId
+  }
+
   log?.info(`[timesheets/tasks/save] Saving timesheet ${timesheetId}`)
 
   await mutateResource(

package/src/schema-ids.js

@@ -2,3 +2,9 @@
 export const TimesheetsSchema = Object.freeze({
   timesheet: '@ossy/timesheets/schema/timesheet',
 })
+
+/** Optional document links stored on a timesheet. */
+export const TimesheetRefs = Object.freeze({
+  employee: '@ossy/consultancy/schema/employee',
+  contract: '@ossy/consultancy/schema/contract',
+})

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/sv.translations.json

@@ -35,9 +35,15 @@
   "timesheets.createDescription": "Välj en månad och helgdagskalender för att generera en förifylld tidrapport.",
   "timesheets.period": "Period",
   "timesheets.holidayLocale": "Helgdagskalender",
+  "timesheets.employee": "Tilldelad",
+  "timesheets.employeeNone": "Ingen tilldelad",
+  "timesheets.contract": "Kontrakt",
+  "timesheets.contractNone": "Inget kontrakt",
+  "@ossy/timesheets/schema/timesheet.employeeId.label": "Tilldelad",
+  "@ossy/timesheets/schema/timesheet.employeeId.description": "Valfritt. Vem tidrapporten är tilldelad.",
+  "@ossy/timesheets/schema/timesheet.contractId.label": "Kontrakt",
+  "@ossy/timesheets/schema/timesheet.contractId.description": "Valfritt. Kontraktet tidrapporten tillhör.",
   "timesheets.generate": "Generera",
-  "timesheets.openExisting": "Öppna",
-  "timesheets.periodExistsHint": "Det finns redan en tidrapport för perioden — Öppna laddar den.",
   "timesheets.cancel": "Avbryt",
   "timesheets.save": "Spara",
   "timesheets.saving": "Sparar…",
@@ -52,13 +58,26 @@
   "timesheets.listTitle": "Dina tidrapporter",
   "timesheets.listEmpty": "Inga tidrapporter ännu. Klicka på Ny för att generera en för en månad.",
   "timesheets.open": "Öppna",
+  "timesheets.view": "Visa",
+  "timesheets.rowActions": "Åtgärder för tidrapport",
+  "timesheets.delete": "Ta bort",
+  "timesheets.deleteTitle": "Ta bort tidrapporten?",
+  "timesheets.deleteText": "Tidrapporten tas bort. Det går inte att ångra.",
   "timesheets.backToList": "← Alla tidrapporter",
+  "timesheets.closePanel": "Stäng",
   "timesheets.saved": "Tidrapport sparad.",
   "timesheets.unsaved": "Osparade ändringar",
   "timesheets.statusLabel": "Status: {status}",
   "timesheets.status.draft": "Utkast",
   "timesheets.status.saved": "Sparad",
   "timesheets.totalHours": "Totalt: {hours} h",
+  "timesheets.meta.status": "Status",
+  "timesheets.meta.hoursValue": "{hours} h",
+  "timesheets.meta.client": "Kund",
+  "timesheets.meta.hourlyRate": "Timarvode",
+  "timesheets.meta.totalCost": "Totalkostnad",
+  "timesheets.meta.perHour": "/h",
+  "timesheets.meta.dash": "—",
   "timesheets.weekday.mon": "Mån",
   "timesheets.weekday.tue": "Tis",
   "timesheets.weekday.wed": "Ons",
@@ -70,5 +89,6 @@
   "timesheets.errorNotFound": "Tidrapporten hittades inte.",
   "timesheets.errorGenerate": "Kunde inte generera tidrapporten.",
   "timesheets.errorSave": "Kunde inte spara tidrapporten.",
-  "timesheets.errorExport": "Kunde inte exportera tidrapporten."
+  "timesheets.errorExport": "Kunde inte exportera tidrapporten.",
+  "timesheets.errorDelete": "Kunde inte ta bort tidrapporten."
 }

package/src/timesheet-detail.page.jsx

@@ -1,15 +1,5 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react'
-import { Text, View, Button, Page, useLocale, Alert, Dropdown, ContextMenu } from '@ossy/design-system'
+import React, { useEffect } from 'react'
 import { useRouter } from '@ossy/router-react'
-import { useSdk } from '@ossy/sdk-react'
-import { Timesheet } from './Timesheet.jsx'
-import { TimesheetExportCard } from './TimesheetExportCard.jsx'
-import { downloadTimesheetCsv } from './download-timesheet-csv.js'
-import { downloadTimesheetImage } from './download-timesheet-image.js'
-import { downloadTimesheetPdf } from './download-timesheet-pdf.js'
-import { invokeErrorMessage } from './invoke-error-message.js'
-import { metadata as GetTimesheet } from './get.action.js'
-import { metadata as SaveTimesheet } from './save.action.js'
 
 export const metadata = {
   id: 'timesheets/detail',
@@ -20,190 +10,17 @@ export const metadata = {
 }
 
 export default function TimesheetDetailPage () {
-  const { t } = useLocale()
-  const sdk = useSdk()
   const router = useRouter()
   const timesheetId = router.params?.timesheetId
-  const captureRef = useRef(null)
-
-  const [timesheet, setTimesheet] = useState(null)
-  const [lines, setLines] = useState([])
-  const [loading, setLoading] = useState(true)
-  const [saving, setSaving] = useState(false)
-  const [exporting, setExporting] = useState(false)
-  const [error, setError] = useState(null)
-  const [message, setMessage] = useState(null)
-
-  const load = useCallback(async () => {
-    if (!timesheetId) return
-    setLoading(true)
-    setError(null)
-    try {
-      const data = await sdk.invoke(GetTimesheet, { timesheetId })
-      if (!data) {
-        setError(t('timesheets.errorNotFound'))
-        setTimesheet(null)
-        setLines([])
-        return
-      }
-      setTimesheet(data)
-      setLines(data.lines ?? [])
-    } catch (err) {
-      setError(await invokeErrorMessage(err, t('timesheets.errorLoad')))
-      setTimesheet(null)
-      setLines([])
-    } finally {
-      setLoading(false)
-    }
-  }, [sdk, t, timesheetId])
 
   useEffect(() => {
-    load()
-  }, [load])
-
-  const handleSave = async () => {
-    if (!timesheet?.id) return
-    setSaving(true)
-    setError(null)
-    setMessage(null)
-    try {
-      const data = await sdk.invoke(SaveTimesheet, {
-        timesheetId: timesheet.id,
-        lines,
-      })
-      setTimesheet(data)
-      setLines(data?.lines ?? lines)
-      setMessage(t('timesheets.saved'))
-    } catch (err) {
-      setError(await invokeErrorMessage(err, t('timesheets.errorSave')))
-    } finally {
-      setSaving(false)
-    }
-  }
-
-  const exportPayload = {
-    ...timesheet,
-    lines,
-    status: timesheet?.status,
-  }
-
-  const runExport = async (kind) => {
-    if (!lines.length) return
-    setExporting(true)
-    setError(null)
-    setMessage(null)
-    try {
-      if (kind === 'csv') {
-        downloadTimesheetCsv(exportPayload)
-      } else if (kind === 'png') {
-        await downloadTimesheetImage(captureRef.current, exportPayload)
-      } else if (kind === 'pdf') {
-        await downloadTimesheetPdf(captureRef.current, exportPayload)
-      }
-    } catch (err) {
-      setError(await invokeErrorMessage(err, t('timesheets.errorExport')))
-    } finally {
-      setExporting(false)
-    }
-  }
-
-  const homeHref = router.getHref({ id: 'timesheets/home' })
-  const exportDisabled = !lines.length || loading || exporting
-
-  return (
-    <Page
-      title={(
-        <View layout="row" gap="s" alignItems="center">
-          <Button
-            prefix="chevron-left"
-            variant="command"
-            href={homeHref || undefined}
-            aria-label="timesheets.backToList"
-            onClick={homeHref ? undefined : () => router.back()}
-          />
-          <Text variant="heading-default" as="h1" text="timesheets.detail.title" />
-        </View>
-      )}
-      description="timesheets.detail.description"
-      far={(
-        <View layout="row" gap="s" alignItems="center">
-          <Dropdown
-            trigger={(
-              <Button
-                variant="secondary"
-                prefix="software-download"
-                suffix="chevron-down"
-                disabled={exportDisabled}
-              >
-                {exporting ? t('timesheets.exporting') : t('timesheets.export')}
-              </Button>
-            )}
-          >
-            <ContextMenu roundness="s" surface="primary">
-              <ContextMenu.Item
-                prefix="list"
-                label="timesheets.exportCsv"
-                onClick={() => runExport('csv')}
-              />
-              <ContextMenu.Item
-                prefix="image"
-                label="timesheets.exportPng"
-                onClick={() => runExport('png')}
-              />
-              <ContextMenu.Item
-                prefix="file-document"
-                label="timesheets.exportPdf"
-                onClick={() => runExport('pdf')}
-              />
-            </ContextMenu>
-          </Dropdown>
-          <Button
-            id={SaveTimesheet.id}
-            variant="cta"
-            prefix="check"
-            disabled={!timesheet?.id || saving || loading}
-            onClick={handleSave}
-          >
-            {saving ? t('timesheets.saving') : t('timesheets.save')}
-          </Button>
-        </View>
-      )}
-    >
-      <View gap="m">
-        {error && <Alert variant="danger">{error}</Alert>}
-        {message && !error && <Alert variant="success">{message}</Alert>}
-
-        {loading ? (
-          <Text color="secondary" text="timesheets.loading" />
-        ) : timesheet ? (
-          <>
-            <Timesheet
-              lines={lines}
-              onChange={setLines}
-              disabled={loading || saving || exporting}
-              periodStart={timesheet.periodStart}
-            />
-            {/* Off-screen light-theme card for PNG/PDF capture (no inputs). */}
-            <div
-              aria-hidden
-              style={{
-                position: 'fixed',
-                left: 0,
-                top: 0,
-                transform: 'translateX(-200vw)',
-                pointerEvents: 'none',
-                zIndex: -1,
-              }}
-            >
-              <TimesheetExportCard
-                lines={lines}
-                periodStart={timesheet.periodStart}
-                captureRef={captureRef}
-              />
-            </div>
-          </>
-        ) : null}
-      </View>
-    </Page>
-  )
+    const home = router.getHref({ id: 'timesheets/home' }) || '/timesheets'
+    const sep = home.includes('?') ? '&' : '?'
+    const next = timesheetId
+      ? `${home}${sep}r=${encodeURIComponent(timesheetId)}`
+      : home
+    window.location.replace(next)
+  }, [router, timesheetId])
+
+  return null
 }

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-parties.js

@@ -0,0 +1,57 @@
+import { resourceIdOf } from '@ossy/calendar/holiday-locale'
+
+export { resourceIdOf }
+
+export function employeeLabel (resource) {
+  if (!resource) return ''
+  const name = typeof resource.content?.name === 'string' ? resource.content.name.trim() : ''
+  if (name) return name
+  const docName = typeof resource.name === 'string' ? resource.name.trim() : ''
+  return docName || resource.id || ''
+}
+
+export function contractLabel (resource) {
+  if (!resource) return ''
+  const client = typeof resource.content?.clientName === 'string' ? resource.content.clientName.trim() : ''
+  if (client) return client
+  const docName = typeof resource.name === 'string' ? resource.name.trim() : ''
+  return docName || resource.id || ''
+}
+
+export function labelForEmployee (employees, ref) {
+  const id = resourceIdOf(ref)
+  if (!id || !Array.isArray(employees)) return ''
+  const match = employees.find((resource) => resource.id === id)
+  return match ? employeeLabel(match) : ''
+}
+
+export function labelForContract (contracts, ref) {
+  const id = resourceIdOf(ref)
+  if (!id || !Array.isArray(contracts)) return ''
+  const match = contracts.find((resource) => resource.id === id)
+  return match ? contractLabel(match) : ''
+}
+
+/** Client name and hourly rate from a contract ref, for timesheet meta and exports. */
+export function contractBillingMeta (contracts, ref) {
+  const content = partyContent(findByRef(contracts, ref))
+  if (!content) return { clientName: '', hourlyRate: null }
+  const raw = content.hourlyCompensation
+  const rate = raw == null || raw === '' ? NaN : Number(raw)
+  const clientName = typeof content.clientName === 'string' ? content.clientName.trim() : ''
+  return {
+    clientName,
+    hourlyRate: Number.isFinite(rate) ? rate : null,
+  }
+}
+
+export function findByRef (resources, ref) {
+  const id = resourceIdOf(ref)
+  if (!id || !Array.isArray(resources)) return null
+  return resources.find((resource) => resource.id === id) ?? null
+}
+
+export function partyContent (resource) {
+  if (!resource) return null
+  return { id: resource.id, ...(resource.content || {}) }
+}

package/src/timesheet-parties.spec.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  contractBillingMeta,
+  contractLabel,
+  employeeLabel,
+  findByRef,
+  labelForContract,
+  labelForEmployee,
+} from './timesheet-parties.js'
+
+describe('timesheet party labels', () => {
+  it('prefers content name, then document name', () => {
+    expect(employeeLabel({ id: 'e1', name: 'file.json', content: { name: 'Oskar' } })).toBe('Oskar')
+    expect(employeeLabel({ id: 'e1', name: 'file.json', content: {} })).toBe('file.json')
+    expect(contractLabel({ id: 'c1', content: { clientName: 'Fortnox' } })).toBe('Fortnox')
+  })
+
+  it('resolves labels from a reference', () => {
+    const employees = [{ id: 'e1', content: { name: 'Oskar' } }]
+    const contracts = [{ id: 'c1', content: { clientName: 'Fortnox' } }]
+    expect(labelForEmployee(employees, { resourceId: 'e1' })).toBe('Oskar')
+    expect(labelForContract(contracts, 'c1')).toBe('Fortnox')
+    expect(labelForEmployee(employees, 'missing')).toBe('')
+    expect(findByRef(employees, { resourceId: 'e1' })?.id).toBe('e1')
+  })
+})
+
+describe('contractBillingMeta', () => {
+  it('reads client name and hourly rate', () => {
+    const contracts = [{ id: 'c1', content: { clientName: 'Fortnox', hourlyCompensation: 700 } }]
+    expect(contractBillingMeta(contracts, 'c1')).toEqual({
+      clientName: 'Fortnox',
+      hourlyRate: 700,
+    })
+    expect(contractBillingMeta(contracts, 'missing')).toEqual({
+      clientName: '',
+      hourlyRate: null,
+    })
+  })
+})

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)}`
+}