Bug/template and sandbox (#589)

* Enhance booking template functionality and add sandbox extraction checks

* Implement Recapt integration for feedback submission and user identification

* Add Recapt identification component and bank sync status chip; update crontab entries

* Update .gitignore to ignore the entire scripts directory

* Refactor Recapt integration: add loader component, update privacy policy, and enhance bank sync status messages

* Fix .gitignore to correctly ignore the scripts directory

lib/support/__tests__/submit-feedback.test.ts

@@ -11,19 +11,30 @@ describe('submitFeedback', () => {
     vi.unstubAllGlobals()
   })
 
+  function stubRecapt(impl: (...args: unknown[]) => void) {
+    vi.stubGlobal('window', { recapt: impl })
+  }
+
+  function stubNoRecapt() {
+    vi.stubGlobal('window', {})
+  }
+
   function stubFetchOk() {
     const fetchSpy = vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) })
     vi.stubGlobal('fetch', fetchSpy)
     return fetchSpy
   }
 
-  it('posts subject and message to the contact endpoint', async () => {
+  it('sends to both Recapt and email when SDK is present', async () => {
+    const recapt = vi.fn()
+    stubRecapt(recapt)
     const fetchSpy = stubFetchOk()
 
     const result = await submitFeedback({ subject: 'Hjälpsida', message: 'Hjälp tack' })
 
     expect(result.ok).toBe(true)
-    expect(result.channels).toEqual(['email'])
+    expect(result.channels.sort()).toEqual(['email', 'recapt'])
+    expect(recapt).toHaveBeenCalledWith('feedback', { message: '[Hjälpsida]\n\nHjälp tack' })
     expect(fetchSpy).toHaveBeenCalledWith(
       '/api/support/contact',
       expect.objectContaining({
@@ -33,21 +44,57 @@ describe('submitFeedback', () => {
     )
   })
 
-  it('omits subject when not provided', async () => {
-    const fetchSpy = stubFetchOk()
+  it('omits subject prefix in Recapt payload when subject not provided', async () => {
+    const recapt = vi.fn()
+    stubRecapt(recapt)
+    stubFetchOk()
 
-    const result = await submitFeedback({ message: 'plain' })
+    await submitFeedback({ message: 'plain' })
 
-    expect(result.ok).toBe(true)
-    expect(fetchSpy).toHaveBeenCalledWith(
-      '/api/support/contact',
-      expect.objectContaining({
-        body: JSON.stringify({ message: 'plain' }),
-      })
-    )
+    expect(recapt).toHaveBeenCalledWith('feedback', { message: 'plain' })
   })
 
-  it('returns failure with server error message when the endpoint rejects', async () => {
+  it('still reports success via email when Recapt throws', async () => {
+    stubRecapt(() => {
+      throw new Error('boom')
+    })
+    stubFetchOk()
+
+    const result = await submitFeedback({ subject: 'X', message: 'msg' })
+
+    expect(result.ok).toBe(true)
+    expect(result.channels).toEqual(['email'])
+  })
+
+  it('uses email only when Recapt SDK is absent', async () => {
+    stubNoRecapt()
+    const fetchSpy = stubFetchOk()
+
+    const result = await submitFeedback({ message: 'msg' })
+
+    expect(result.ok).toBe(true)
+    expect(result.channels).toEqual(['email'])
+    expect(fetchSpy).toHaveBeenCalledOnce()
+  })
+
+  it('reports success when Recapt succeeds even if email fails', async () => {
+    const recapt = vi.fn()
+    stubRecapt(recapt)
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue({ ok: false, json: async () => ({ error: 'down' }) })
+    )
+
+    const result = await submitFeedback({ message: 'msg' })
+
+    expect(result.ok).toBe(true)
+    expect(result.channels).toEqual(['recapt'])
+  })
+
+  it('returns failure with email error when both channels fail', async () => {
+    stubRecapt(() => {
+      throw new Error('boom')
+    })
     vi.stubGlobal(
       'fetch',
       vi.fn().mockResolvedValue({
@@ -63,7 +110,8 @@ describe('submitFeedback', () => {
     expect(result.error).toBe('Mailtjänsten är inte konfigurerad')
   })
 
-  it('returns failure when fetch itself throws', async () => {
+  it('returns failure when fetch itself throws and Recapt is absent', async () => {
+    stubNoRecapt()
     vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network down')))
 
     const result = await submitFeedback({ message: 'msg' })

lib/support/submit-feedback.ts

@@ -3,7 +3,7 @@ export interface SubmitFeedbackInput {
   subject?: string
 }
 
-export type SupportChannel = 'email'
+export type SupportChannel = 'recapt' | 'email'
 
 export interface SubmitFeedbackResult {
   ok: boolean
@@ -11,23 +11,58 @@ export interface SubmitFeedbackResult {
   error?: string
 }
 
-export async function submitFeedback(input: SubmitFeedbackInput): Promise<SubmitFeedbackResult> {
+function composeMessage({ message, subject }: SubmitFeedbackInput): string {
+  if (!subject) return message
+  return `[${subject}]\n\n${message}`
+}
+
+async function submitViaEmail(
+  { message, subject }: SubmitFeedbackInput
+): Promise<{ ok: true } | { ok: false; error: string }> {
   try {
     const res = await fetch('/api/support/contact', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ subject: input.subject, message: input.message }),
+      body: JSON.stringify({ subject, message }),
     })
     if (!res.ok) {
       const data = await res.json().catch(() => ({}))
-      return { ok: false, channels: [], error: data.error || 'Kunde inte skicka meddelandet' }
+      return { ok: false, error: data.error || 'Kunde inte skicka meddelandet' }
     }
-    return { ok: true, channels: ['email'] }
+    return { ok: true }
   } catch (err) {
-    return {
-      ok: false,
-      channels: [],
-      error: err instanceof Error ? err.message : 'Nätverksfel',
-    }
+    return { ok: false, error: err instanceof Error ? err.message : 'Nätverksfel' }
+  }
+}
+
+function submitViaRecapt(
+  input: SubmitFeedbackInput
+): { ok: true } | { ok: false; error: string } | null {
+  const recapt = typeof window !== 'undefined' ? window.recapt : undefined
+  if (typeof recapt !== 'function') return null
+  try {
+    recapt('feedback', { message: composeMessage(input) })
+    return { ok: true }
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : 'Recapt-fel' }
+  }
+}
+
+export async function submitFeedback(input: SubmitFeedbackInput): Promise<SubmitFeedbackResult> {
+  const recaptResult = submitViaRecapt(input)
+  const emailResult = await submitViaEmail(input)
+
+  const channels: SupportChannel[] = []
+  if (recaptResult?.ok) channels.push('recapt')
+  if (emailResult.ok) channels.push('email')
+
+  if (channels.length > 0) {
+    return { ok: true, channels }
+  }
+
+  return {
+    ok: false,
+    channels: [],
+    error: emailResult.ok ? undefined : emailResult.error,
   }
 }