@nuxt-customer-portal/planning 0.4.0

package/server/api/planning/admin/jobs.get.ts

@@ -0,0 +1,199 @@
+import { defineEventHandler, getQuery } from 'h3'
+import { z } from 'zod'
+import { planningAdmin } from '@nuxt-customer-portal/planning/server/utils/access'
+import { getStore } from '@nuxt-customer-portal/products/server/utils/access'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+
+const querySchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  search: z.string().trim().max(200).default(''),
+  status: z.enum(['all', 'failed', 'queued', 'succeeded']).default('failed'),
+  kind: z.string().trim().max(50).default('all'),
+  sort: z.enum(['lastEvent', 'attempts', 'kind']).default('lastEvent'),
+  direction: z.enum(['asc', 'desc']).default('desc')
+})
+
+const scopedJobs = `WITH scoped AS (
+  SELECT j.id,j.kind,j.attempts,j.error,j.available_at,j.completed_at,j.payload->>'trigger' AS trigger,
+    j.payload->>'appointmentId' AS appointment_id,
+    COALESCE(j.completed_at,j.last_attempt_at,j.created_at) AS last_event_at,
+    COALESCE(
+      j.payload->>'storeId',
+      (SELECT a.store_id FROM planning.appointment a WHERE a.id::text=j.payload->>'appointmentId'),
+      (SELECT w.store_id FROM planning.availability w WHERE w.id::text=j.payload->>'id'),
+      (SELECT o.store_id FROM products.orders o WHERE o.id::text=j.payload->>'orderId')
+    ) AS store_id,
+    COALESCE(
+      (SELECT a.snapshot->>'title' FROM planning.appointment a WHERE a.id::text=j.payload->>'appointmentId'),
+      (SELECT u.name FROM public."user" u WHERE u.id=j.payload->>'userId'),
+      j.payload->>'orderId',j.payload->>'id'
+    ) AS subject
+  FROM planning.job j
+)`
+
+export default defineEventHandler(async (event) => {
+  await planningAdmin(event)
+  const store = await getStore()
+  const query = querySchema.parse(getQuery(event))
+  const pageSize = 20
+  const filters: string[] = ['store_id=$1']
+  const params: unknown[] = [store.organization_id]
+  if (query.search) {
+    params.push(`%${query.search}%`)
+    filters.push(
+      `(id ILIKE $${params.length} OR kind ILIKE $${params.length} OR COALESCE(error,'') ILIKE $${params.length} OR COALESCE(subject,'') ILIKE $${params.length})`
+    )
+  }
+  if (query.status !== 'all') {
+    filters.push(
+      {
+        failed: 'completed_at IS NULL AND error IS NOT NULL',
+        queued: 'completed_at IS NULL AND error IS NULL',
+        succeeded: 'completed_at IS NOT NULL'
+      }[query.status]
+    )
+  }
+  if (query.kind !== 'all') {
+    params.push(query.kind)
+    filters.push(`kind=$${params.length}`)
+  }
+  const order = { lastEvent: 'last_event_at', attempts: 'attempts', kind: 'kind' }[query.sort]
+  const direction = query.direction === 'asc' ? 'ASC' : 'DESC'
+  const where = filters.join(' AND ')
+  const [count] = await rows<{ total: number }>(
+    `${scopedJobs} SELECT count(*)::int AS total FROM scoped WHERE ${where}`,
+    params
+  )
+  params.push(pageSize, (query.page - 1) * pageSize)
+  const items = await rows<{
+    id: string
+    kind: string
+    attempts: number
+    error: string | null
+    subject: string | null
+    availableAt: Date
+    lastEventAt: Date
+    completedAt: Date | null
+    trigger: string | null
+    appointmentId: string | null
+    entity?: unknown
+  }>(
+    `${scopedJobs} SELECT id,kind,attempts,error,subject,trigger,appointment_id AS "appointmentId",available_at AS "availableAt",last_event_at AS "lastEventAt",completed_at AS "completedAt" FROM scoped WHERE ${where} ORDER BY ${order} ${direction},id ${direction} LIMIT $${params.length - 1} OFFSET $${params.length}`,
+    params
+  )
+  const appointmentIds = [...new Set(items.map((item) => item.appointmentId).filter(Boolean))] as string[]
+  if (appointmentIds.length) {
+    const entities = await rows<{
+      id: string
+      status: string
+      title: string
+      startAt: Date
+      endAt: Date
+      timezone: string
+      hostName: string
+      hostEmail: string
+      customerName: string
+      customerEmail: string
+      bookingReference: string
+      meetingId: string | null
+      meetingUrl: string | null
+    }>(
+      `SELECT a.id::text AS id,a.status,a.snapshot->>'title' AS title,a.start_at AS "startAt",a.end_at AS "endAt",
+        COALESCE(a.snapshot->>'timezone','UTC') AS timezone,u.name AS "hostName",u.email AS "hostEmail",
+        COALESCE(NULLIF(o.snapshot->'billing'->>'name',''),NULLIF(o.snapshot->'billing'->>'firstName',''),o.email) AS "customerName",
+        o.email AS "customerEmail",o.booking_reference AS "bookingReference",a.meeting_id AS "meetingId",a.meeting_url AS "meetingUrl"
+       FROM planning.appointment a
+       JOIN public."user" u ON u.id=a.user_id
+       JOIN products.orders o ON o.id=a.order_id
+       WHERE a.store_id=$1 AND a.id=ANY($2::uuid[])`,
+      [store.organization_id, appointmentIds]
+    )
+    const byId = new Map(entities.map((entity) => [entity.id, entity]))
+    for (const item of items) {
+      if (!item.appointmentId) {
+        continue
+      }
+      const entity = byId.get(item.appointmentId)
+      if (!entity) {
+        continue
+      }
+      item.subject = entity.title
+      item.entity = { type: 'appointment', ...entity }
+    }
+  }
+  const availabilityIds = items
+    .filter((item) => item.kind === 'availability' && item.subject)
+    .map((item) => item.subject as string)
+  if (availabilityIds.length) {
+    const entities = await rows<{
+      id: string
+      providerName: string
+      providerEmail: string
+      calendarId: string | null
+      data: {
+        date: string
+        endDate: string | null
+        startTime: string
+        endTime: string
+        timezone: string
+        recurring: boolean
+        productIds: string[] | null
+      }
+      productTitles: string[]
+    }>(
+      `SELECT a.id::text AS id,u.name AS "providerName",u.email AS "providerEmail",
+        p.write_calendar_id AS "calendarId",a.data,
+        COALESCE((
+          SELECT array_agg(COALESCE(NULLIF(product.data->'content'->'en'->>'title',''),product.data->'content'->'nl'->>'title',product.id) ORDER BY product.id)
+          FROM products.product product
+          WHERE product.store_id=a.store_id
+            AND product.id=ANY(
+              SELECT jsonb_array_elements_text(
+                CASE WHEN jsonb_typeof(a.data->'productIds')='array' THEN a.data->'productIds' ELSE '[]'::jsonb END
+              )
+            )
+        ),'{}') AS "productTitles"
+       FROM planning.availability a
+       JOIN public."user" u ON u.id=a.user_id
+       LEFT JOIN planning.provider p ON p.store_id=a.store_id AND p.user_id=a.user_id
+       WHERE a.store_id=$1 AND a.id=ANY($2::uuid[])`,
+      [store.organization_id, availabilityIds]
+    )
+    const byId = new Map(entities.map((entity) => [entity.id, entity]))
+    for (const item of items) {
+      if (item.kind !== 'availability' || !item.subject) {
+        continue
+      }
+      const entity = byId.get(item.subject)
+      if (!entity) {
+        continue
+      }
+      item.subject = entity.providerName
+      item.entity = {
+        type: 'availability',
+        id: entity.id,
+        providerName: entity.providerName,
+        providerEmail: entity.providerEmail,
+        calendarId: entity.calendarId,
+        date: entity.data.date,
+        endDate: entity.data.endDate,
+        startTime: entity.data.startTime,
+        endTime: entity.data.endTime,
+        timezone: entity.data.timezone,
+        recurring: entity.data.recurring,
+        allProducts: entity.data.productIds === null,
+        productTitles: entity.productTitles
+      }
+    }
+  }
+  const total = count?.total || 0
+  return {
+    items,
+    kinds: (
+      await rows<{ kind: string }>(`${scopedJobs} SELECT DISTINCT kind FROM scoped WHERE store_id=$1 ORDER BY kind`, [
+        store.organization_id
+      ])
+    ).map((row) => row.kind),
+    pagination: { total, page: query.page, pageSize, pageCount: Math.max(1, Math.ceil(total / pageSize)) }
+  }
+})

package/server/api/planning/admin/policy.get.ts

@@ -0,0 +1,6 @@
+import { defineEventHandler } from 'h3'
+import { getPolicy } from '@nuxt-customer-portal/planning/server/utils/management'
+
+export default defineEventHandler(async (event) => {
+  return getPolicy(event)
+})

package/server/api/planning/admin/policy.put.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, readBody } from 'h3'
+import { savePolicy } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return savePolicy(event, await readBody(event))
+})

package/server/api/planning/admin/products/[id].put.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, getRouterParam, readBody } from 'h3'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+import { saveProductPlanning } from '@nuxt-customer-portal/planning/server/utils/management'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return saveProductPlanning(event, getRouterParam(event, 'id')!, await readBody(event))
+})

package/server/api/planning/admin/providers/[userId].patch.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, readBody, getRouterParam } from 'h3'
+import { setEnabled } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return setEnabled(event, getRouterParam(event, 'userId')!, await readBody(event))
+})

package/server/api/planning/admin/providers.get.ts

@@ -0,0 +1,6 @@
+import { defineEventHandler } from 'h3'
+import { listProviders } from '@nuxt-customer-portal/planning/server/utils/management'
+
+export default defineEventHandler(async (event) => {
+  return listProviders(event)
+})

package/server/api/planning/admin/retry.post.ts

@@ -0,0 +1,31 @@
+import { defineEventHandler } from 'h3'
+import { planningAdmin, sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+import { runJobs } from '@nuxt-customer-portal/planning/server/utils/jobs'
+import { getStore } from '@nuxt-customer-portal/products/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  await planningAdmin(event)
+  const store = await getStore()
+  await rows(
+    `UPDATE planning.job j SET available_at=now() WHERE completed_at IS NULL AND COALESCE(
+      j.payload->>'storeId',
+      (SELECT a.store_id FROM planning.appointment a WHERE a.id::text=j.payload->>'appointmentId'),
+      (SELECT w.store_id FROM planning.availability w WHERE w.id::text=j.payload->>'id'),
+      (SELECT o.store_id FROM products.orders o WHERE o.id::text=j.payload->>'orderId')
+    )=$1`,
+    [store.organization_id]
+  )
+  let completed = 0,
+    failed = 0
+  for (let batch = 0; batch < 10; batch++) {
+    const result = await runJobs(20, store.organization_id)
+    completed += result.completed
+    failed += result.failed
+    if (result.completed + result.failed < 20) {
+      break
+    }
+  }
+  return { completed, failed }
+})

package/server/api/planning/appointments/[id]/availability.get.ts

@@ -0,0 +1,19 @@
+import { defineEventHandler, getRouterParam, getQuery } from 'h3'
+import { appointmentAccess } from '../../../../utils/access'
+import { available } from '../../../../utils/booking'
+import { canChange } from '../../../../../shared/availability'
+
+export default defineEventHandler(async (event) => {
+  const { appointment: a, staff, canManage } = await appointmentAccess(event, getRouterParam(event, 'id')!)
+  if (
+    !canManage ||
+    a.status !== 'confirmed' ||
+    (!staff && !canChange(a.start_at, new Date(), a.snapshot.policy.rescheduleCutoffMinutes))
+  ) {
+    return []
+  }
+  return available(a.product_id, getQuery(event), {
+    policy: staff ? { ...a.snapshot.policy, minimumNoticeMinutes: 0 } : a.snapshot.policy,
+    duration: a.snapshot.durationMinutes
+  })
+})

package/server/api/planning/appointments/[id]/cancel.post.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { cancel } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return cancel(event, getRouterParam(event, 'id')!)
+})

package/server/api/planning/appointments/[id]/files/[assetId].get.ts

@@ -0,0 +1,17 @@
+import { getQuery, getRouterParam, setHeader } from 'h3'
+import { appointmentAccess } from '@nuxt-customer-portal/planning/server/utils/access'
+import { getOrder, hasAccess } from '@nuxt-customer-portal/products/server/utils/orders'
+import { sendAsset } from '@nuxt-customer-portal/products/server/utils/storage'
+
+export default defineEventHandler(async (event) => {
+  const { appointment } = await appointmentAccess(event, getRouterParam(event, 'id')!)
+  const assetId = getRouterParam(event, 'assetId')!
+  const order = await getOrder(appointment.order_id)
+  const line = order?.lines.find((item) => hasAccess(order, item) && item.snapshot.product.fileIds.includes(assetId))
+  if (!order || !line) {
+    throw createError({ statusCode: 404 })
+  }
+  const fileName = line.snapshot.product.fileNames?.[assetId]?.[order.snapshot.locale]
+  setHeader(event, 'Cache-Control', 'private, no-store')
+  return sendAsset(event, assetId, getQuery(event).download === '1', fileName)
+})

package/server/api/planning/appointments/[id]/files.get.ts

@@ -0,0 +1,28 @@
+import { getRouterParam } from 'h3'
+import { appointmentAccess } from '@nuxt-customer-portal/planning/server/utils/access'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+import { getOrder, hasAccess } from '@nuxt-customer-portal/products/server/utils/orders'
+
+export default defineEventHandler(async (event) => {
+  const { appointment } = await appointmentAccess(event, getRouterParam(event, 'id')!)
+  const order = await getOrder(appointment.order_id)
+  if (!order) {
+    throw createError({ statusCode: 404 })
+  }
+  const accessibleLines = order.lines.filter((line) => hasAccess(order, line))
+  const fileIds = [...new Set(accessibleLines.flatMap((line) => line.snapshot.product.fileIds))]
+  if (!fileIds.length) {
+    return []
+  }
+  const assets = await rows<{ id: string; name: string; content_type: string; size: number }>(
+    'SELECT id,name,content_type,size FROM products.asset WHERE ready AND id=ANY($1::text[])',
+    [fileIds]
+  )
+  return assets.map((asset) => ({
+    ...asset,
+    name:
+      accessibleLines.find((line) => line.snapshot.product.fileIds.includes(asset.id))?.snapshot.product.fileNames?.[
+        asset.id
+      ]?.[order.snapshot.locale] || asset.name
+  }))
+})

package/server/api/planning/appointments/[id]/pending.delete.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { abandonChange } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return abandonChange(event, getRouterParam(event, 'id')!)
+})

package/server/api/planning/appointments/[id]/reschedule.put.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, getRouterParam, readBody } from 'h3'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+import { staffReschedule } from '@nuxt-customer-portal/planning/server/utils/staff-appointments'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return staffReschedule(event, getRouterParam(event, 'id')!, await readBody(event))
+})

package/server/api/planning/appointments/[id].get.ts

@@ -0,0 +1,6 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { appointmentDetails } from '@nuxt-customer-portal/planning/server/utils/management'
+
+export default defineEventHandler(async (event) => {
+  return appointmentDetails(event, getRouterParam(event, 'id')!)
+})

package/server/api/planning/appointments.get.ts

@@ -0,0 +1,4 @@
+import { defineEventHandler, getQuery } from 'h3'
+import { listAppointments } from '@nuxt-customer-portal/planning/server/utils/appointments'
+
+export default defineEventHandler((event) => listAppointments(event, getQuery(event)))

package/server/api/planning/availability/[id].delete.ts

@@ -0,0 +1,12 @@
+import { defineEventHandler, getQuery, getRouterParam } from 'h3'
+import { deleteWindow } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return deleteWindow(
+    event,
+    getRouterParam(event, 'id')!,
+    typeof getQuery(event).occurrence === 'string' ? String(getQuery(event).occurrence) : undefined
+  )
+})

package/server/api/planning/availability/[id].put.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, readBody, getRouterParam } from 'h3'
+import { saveWindow } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return saveWindow(event, await readBody(event), getRouterParam(event, 'id')!)
+})

package/server/api/planning/availability.get.ts

@@ -0,0 +1,6 @@
+import { defineEventHandler } from 'h3'
+import { windows } from '@nuxt-customer-portal/planning/server/utils/management'
+
+export default defineEventHandler(async (event) => {
+  return windows(event)
+})

package/server/api/planning/availability.post.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, readBody } from 'h3'
+import { saveWindow } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return saveWindow(event, await readBody(event))
+})

package/server/api/planning/calendar-busy.get.ts

@@ -0,0 +1,29 @@
+import { defineEventHandler, getQuery } from 'h3'
+import { z } from 'zod'
+import { parseInput } from '@nuxt-customer-portal/products/server/utils/validation'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+import { providerAccess } from '@nuxt-customer-portal/planning/server/utils/access'
+import { externalBusyDetails } from '@nuxt-customer-portal/planning/server/utils/adapters'
+
+const querySchema = z
+  .object({ from: z.iso.datetime({ offset: true }), to: z.iso.datetime({ offset: true }) })
+  .refine(
+    ({ from, to }) => Date.parse(to) > Date.parse(from) && Date.parse(to) - Date.parse(from) <= 14 * 86400000,
+    'Choose a range of at most 14 days'
+  )
+
+export default defineEventHandler(async (event) => {
+  const { storeId, userId } = await providerAccess(event)
+  const query = parseInput(querySchema, getQuery(event))
+  const [provider] = await rows<{ busy_calendar_ids: string[]; write_calendar_id: string | null }>(
+    'SELECT busy_calendar_ids,write_calendar_id FROM planning.provider WHERE store_id=$1 AND user_id=$2',
+    [storeId, userId]
+  )
+  const calendarIds = [
+    ...new Set([...(provider?.busy_calendar_ids || []), provider?.write_calendar_id].filter(Boolean))
+  ] as string[]
+  if (!calendarIds.length) {
+    return []
+  }
+  return externalBusyDetails(storeId, userId, calendarIds, new Date(query.from), new Date(query.to))
+})

package/server/api/planning/calendars.get.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler } from 'h3'
+import { providerAccess } from '@nuxt-customer-portal/planning/server/utils/access'
+import { calendarAdapter } from '@nuxt-customer-portal/planning/server/utils/adapters'
+
+export default defineEventHandler(async (event) => {
+  const { storeId, userId } = await providerAccess(event)
+  return calendarAdapter().calendars(storeId, userId)
+})

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

@@ -0,0 +1,36 @@
+import { defineEventHandler } from 'h3'
+import { appointmentScope } from '@nuxt-customer-portal/planning/server/utils/access'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+import type { PlanningDashboardAppointment, PlanningDashboardDto } from '@nuxt-customer-portal/planning/shared/types'
+
+export default defineEventHandler(async (event): Promise<PlanningDashboardDto> => {
+  const scope = await appointmentScope(event)
+  const values = [scope.storeId, scope.staff, scope.userId]
+  const audience = 'a.store_id=$1 AND ($2::boolean AND a.user_id=$3 OR NOT $2::boolean AND o.buyer_id=$3)'
+  const from =
+    'FROM planning.appointment a JOIN products.orders o ON o.id=a.order_id JOIN public."user" u ON u.id=a.user_id LEFT JOIN planning.provider p ON p.store_id=a.store_id AND p.user_id=a.user_id'
+  const [summary] = await rows<{ upcomingCount: number; todayCount: number; conflictCount: number }>(
+    `SELECT
+       count(*) FILTER (WHERE a.status='confirmed' AND a.end_at>=now())::int AS "upcomingCount",
+       count(*) FILTER (WHERE a.status='confirmed' AND a.start_at>=date_trunc('day',now()) AND a.start_at<date_trunc('day',now())+interval '1 day')::int AS "todayCount",
+       count(*) FILTER (WHERE a.status='confirmed' AND a.end_at>=now() AND a.conflict)::int AS "conflictCount"
+     ${from} WHERE ${audience}`,
+    values
+  )
+  const appointments = await rows<PlanningDashboardAppointment>(
+    `SELECT a.id,a.start_at AS start,a.end_at AS end,a.snapshot->>'title' AS title,
+      a.snapshot->>'meetingProvider' AS "meetingProvider",a.meeting_url AS "meetingUrl",a.conflict,
+      u.name AS "providerName",COALESCE(a.snapshot->>'timezone',p.timezone,u.timezone,'Europe/Amsterdam') AS "providerTimezone",
+      o.snapshot->'billing'->>'name' AS "customerName",a.snapshot->>'customerTimezone' AS "customerTimezone"
+     ${from} WHERE ${audience} AND a.status='confirmed' AND a.end_at>=now()
+     ORDER BY a.start_at,a.id LIMIT 3`,
+    values
+  )
+  return {
+    access: { staff: scope.staff, canManage: scope.canManage },
+    upcomingCount: summary?.upcomingCount ?? 0,
+    todayCount: summary?.todayCount ?? 0,
+    conflictCount: scope.staff ? (summary?.conflictCount ?? 0) : 0,
+    appointments
+  }
+})

package/server/api/planning/google/notifications.post.ts

@@ -0,0 +1,24 @@
+import { defineEventHandler, getHeader, setResponseStatus } from 'h3'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+import { pool } from '@nuxt-customer-portal/core/server/utils/db'
+import { digest } from '../../../utils/crypto'
+import { enqueue } from '../../../utils/booking'
+
+export default defineEventHandler(async (event) => {
+  const [watch] = await rows<{ store_id: string; user_id: string }>(
+    'SELECT store_id,user_id FROM planning.watch WHERE id::text=$1 AND token_hash=$2 AND (resource_id IS NULL OR resource_id=$3) AND expires_at>now()',
+    [
+      getHeader(event, 'x-goog-channel-id') || '',
+      digest(getHeader(event, 'x-goog-channel-token') || ''),
+      getHeader(event, 'x-goog-resource-id') || ''
+    ]
+  )
+  if (watch) {
+    await enqueue(pool, `sync:${watch.store_id}:${watch.user_id}:${Math.floor(Date.now() / 1000)}`, 'sync', {
+      storeId: watch.store_id,
+      userId: watch.user_id,
+      trigger: 'notification'
+    })
+  }
+  setResponseStatus(event, 204)
+})

package/server/api/planning/oauth/[provider]/callback.get.ts

@@ -0,0 +1,18 @@
+import { defineEventHandler, getRouterParam, getQuery, sendRedirect } from 'h3'
+import { finishOAuth, oauthProvider } from '../../../../utils/oauth'
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+  try {
+    await finishOAuth(
+      event,
+      oauthProvider(getRouterParam(event, 'provider')),
+      String(query.state || ''),
+      String(query.code || '')
+    )
+    return sendRedirect(event, '/planning/settings?tab=meeting&connection=connected', 303)
+  } catch (error) {
+    console.error('Planning OAuth callback failed', error)
+    return sendRedirect(event, '/planning/settings?tab=meeting&connection=error', 303)
+  }
+})

package/server/api/planning/oauth/[provider]/start.post.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { startOAuth, oauthProvider } from '../../../../utils/oauth'
+import { sameOrigin } from '../../../../utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return startOAuth(event, oauthProvider(getRouterParam(event, 'provider')))
+})

package/server/api/planning/oauth/[provider].delete.ts

@@ -0,0 +1,15 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { providerAccess, sameOrigin } from '../../../utils/access'
+import { oauthProvider } from '../../../utils/oauth'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  const { storeId, userId } = await providerAccess(event)
+  await rows('DELETE FROM planning.connection WHERE store_id=$1 AND user_id=$2 AND provider=$3', [
+    storeId,
+    userId,
+    oauthProvider(getRouterParam(event, 'provider'))
+  ])
+  return { success: true }
+})

package/server/api/planning/products.get.ts

@@ -0,0 +1,11 @@
+import { defineEventHandler } from 'h3'
+import { appointmentScope } from '@nuxt-customer-portal/planning/server/utils/access'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+
+export default defineEventHandler(async (event) => {
+  const scope = await appointmentScope(event)
+  return rows(
+    `SELECT slug,COALESCE(NULLIF(data->'content'->'en'->>'title',''),data->'content'->'nl'->>'title') AS title FROM products.product WHERE store_id=$1 AND data->>'status'='published' AND data->>'type'='service' AND data->'planning'->>'enabled'='true' ORDER BY title,id`,
+    [scope.storeId]
+  )
+})

package/server/api/planning/provider-appointments.get.ts

@@ -0,0 +1,11 @@
+import { defineEventHandler } from 'h3'
+import { providerAccess } from '@nuxt-customer-portal/planning/server/utils/access'
+import { rows } from '@nuxt-customer-portal/products/server/utils/database'
+
+export default defineEventHandler(async (event) => {
+  const { storeId, userId } = await providerAccess(event)
+  return rows(
+    `SELECT a.id,a.start_at AS start,a.end_at AS end,a.status,a.snapshot->>'title' AS title,a.snapshot->>'meetingProvider' AS "meetingProvider",a.meeting_url AS "meetingUrl",a.user_id AS "providerUserId",u.name AS "providerName",u.email AS "providerEmail",a.snapshot->>'timezone' AS "providerTimezone",a.snapshot->>'customerTimezone' AS "customerTimezone",a.conflict,a.effects_error AS "effectsError",o.email,o.snapshot->'billing'->>'name' AS "customerName",o.snapshot->'billing'->>'country' AS country FROM planning.appointment a JOIN products.orders o ON o.id=a.order_id JOIN public."user" u ON u.id=a.user_id WHERE a.store_id=$1 AND a.user_id=$2 AND a.end_at>now()-interval '7 days' ORDER BY start_at LIMIT 200`,
+    [storeId, userId]
+  )
+})

package/server/api/planning/provider.get.ts

@@ -0,0 +1,6 @@
+import { defineEventHandler } from 'h3'
+import { ownSettings } from '@nuxt-customer-portal/planning/server/utils/management'
+
+export default defineEventHandler(async (event) => {
+  return ownSettings(event)
+})

package/server/api/planning/provider.put.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, readBody } from 'h3'
+import { saveOwnSettings } from '@nuxt-customer-portal/planning/server/utils/management'
+import { sameOrigin } from '@nuxt-customer-portal/planning/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  sameOrigin(event)
+  return saveOwnSettings(event, await readBody(event))
+})

package/server/api/store/planning/[productId]/availability.get.ts

@@ -0,0 +1,8 @@
+import { defineEventHandler, getQuery, getRouterParam } from 'h3'
+import { available } from '@nuxt-customer-portal/planning/server/utils/booking'
+import { publicLimit } from '@nuxt-customer-portal/products/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  await publicLimit(event)
+  return available(getRouterParam(event, 'productId')!, getQuery(event))
+})

package/server/api/store/planning/hold.delete.ts

@@ -0,0 +1,11 @@
+import { defineEventHandler, readBody } from 'h3'
+import { releaseHold } from '../../../utils/booking'
+import { sameOrigin } from '../../../utils/access'
+import { publicLimit } from '@nuxt-customer-portal/products/server/utils/access'
+
+export default defineEventHandler(async (event) => {
+  await publicLimit(event)
+  sameOrigin(event)
+  await releaseHold(event, await readBody(event))
+  return { released: true }
+})