Webklar-Kundenbereich/test/funktionenTermine.test.js

import { test, after } from 'node:test'
import assert from 'node:assert/strict'
import { startAppwriteMock } from './support/appwriteMock.js'
import { startFakeStripe } from './support/fakeStripe.js'
import { useTestEnv } from './support/testEnv.js'
import { schemaKeys } from './support/schema.js'

// Terminplaner als zweite Funktion (Aufgabe 17): Team-Route /:customerId/:key, GET /api/funktionen mit Schalter,
// Kunde loeschen schaltet den Terminplaner ab und entfernt seine Entwuerfe (C6). News verhaelt sich wie bisher (test/funktionenRoutes.test.js).
const aw = await startAppwriteMock({
  schema: { portalFeatures: schemaKeys('portalFeatures'), subscriptions: schemaKeys('subscriptions'), termineConfig: schemaKeys('termineConfig'), termineBookings: schemaKeys('termineBookings') },
})
const st = await startFakeStripe()
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
const { config } = await import('../server/config.js')
const { startTestApp, get, rawGet, post } = await import('./support/testApp.js')
const { customerCookie, seedFixtures, subscriptionDoc, wartungDoc, hostingDoc } = await import('./support/fixtures.js')
const { default: funktionenRoutes } = await import('../server/routes/funktionen.js')
const { default: teamRoutes } = await import('../server/routes/team/index.js')
const sf = await import('../server/services/siteFeatures.js')
const { loeschTag } = await import('../server/services/termine/frist.js')
const { deleteCustomerWithPortalAccess } = await import('../server/services/customerAdmin.js')

const app = await startTestApp({ '/api/funktionen': funktionenRoutes, '/api/team': teamRoutes })
after(() => Promise.all([app.close(), aw.close(), st.close()]))
seedFixtures(aw)
aw.seed('employees', { $id: 'e_staff2', userId: 'u_staff2', displayName: 'Andrej', email: 'andrej@webklar.com' })
aw.seed('websiteProjects', { $id: 'pt1', customerId: 'c1', projectName: 'Salon' })
aw.seed('websiteProjects', { $id: 'pt2', customerId: 'c1', projectName: 'Studio' })
aw.seed('websiteProjects', { $id: 'pt3', customerId: 'c2', projectName: 'Fremder Salon' })

const STAFF = { headers: { Authorization: 'Bearer jwt-staff' } }
const cookie = customerCookie('c1')
const team = (customerId, key, body, opts = STAFF) => post(`/api/team/funktionen/${customerId}/${key}`, body, opts)
const featuresOf = (res, projectId) => res.body.projects.find((p) => p.projectId === projectId).features
const workorders = () => aw.docs('workorders').size
const docOf = (projectId, key) => sf.getFeatureDoc('c1', projectId, key)

test('Team aktiviert termine fuer ein Projekt, News bleibt unveraendert', async () => {
  const tickets = workorders()
  const res = await team('c1', 'termine', { projectId: 'pt1', action: 'activate', note: 'Pilot' })
  assert.equal(res.status, 200)
  assert.deepEqual(res.body.projects.map((p) => p.projectId), ['pt1'])
  const view = featuresOf(res, 'pt1')
  assert.equal(view.termine.state, 'active')
  assert.equal(view.termine.ticketWoid, null)
  assert.match(view.termine.siteKey, /^[a-z2-7]{16}$/)
  assert.match(view.termine.adminNote, /^\d{4}-\d\d-\d\dT[\d:.]+Z Andrej: activate – Pilot$/)
  assert.equal(view.termine.ticketMissing, false)
  assert.equal(view.news.state, 'off')
  assert.equal(view.news.adminNote, '')
  const doc = await docOf('pt1', 'termine')
  assert.deepEqual([doc.featureKey, doc.state, doc.enabled, doc.unlockedByPurchase], ['termine', 'active', true, false])
  assert.equal(await docOf('pt1', 'news'), null, 'kein News-Dokument entstanden')
  assert.equal(workorders(), tickets, 'kein Ticket')
  // das Projekt ohne Aktion bleibt aus
  const list = await get('/api/team/funktionen/c1', STAFF)
  assert.equal(list.projects.find((p) => p.projectId === 'pt2').features.termine.state, 'off')
})

test('/news bleibt gleichwertig und aendert den Terminplaner nicht', async () => {
  const res = await team('c1', 'news', { projectId: 'pt1', action: 'activate', note: 'Kulanz' })
  assert.equal(res.status, 200)
  const view = featuresOf(res, 'pt1')
  assert.equal(view.news.state, 'active')
  assert.match(view.news.adminNote, /Andrej: activate – Kulanz$/)
  assert.equal(view.termine.state, 'active')
  assert.doesNotMatch(view.termine.adminNote, /Kulanz/)
  assert.notEqual((await docOf('pt1', 'news')).siteKey, (await docOf('pt1', 'termine')).siteKey)
  assert.equal((await team('c1', 'news', { projectId: 'pt1', action: 'disable' })).status, 200)
  const after = await docOf('pt1', 'termine')
  assert.equal(after.state, 'active')
})

test('Abschalten setzt disabledAt und den Grund team, erneutes Aktivieren leert beides (R36)', async () => {
  const off = await team('c1', 'termine', { projectId: 'pt1', action: 'disable' })
  assert.equal(off.status, 200)
  assert.equal(featuresOf(off, 'pt1').termine.state, 'disabled')
  const doc = await docOf('pt1', 'termine')
  assert.equal(doc.enabled, false)
  assert.ok(Math.abs(Date.parse(doc.disabledAt) - Date.now()) < 5000)
  assert.equal(doc.disabledReason, 'team', 'das WOMS schaltet mit dem Vorgabegrund ab')
  // zweiter Klick (Doppelklick im WOMS): Beginn der 30 Tage, Grund und Notiz bleiben
  const nochmal = await team('c1', 'termine', { projectId: 'pt1', action: 'disable', note: 'zweiter Klick' })
  assert.equal(nochmal.status, 200)
  const gleich = await docOf('pt1', 'termine')
  assert.deepEqual([gleich.disabledAt, gleich.disabledReason, gleich.adminNote], [doc.disabledAt, 'team', doc.adminNote])
  const on = await team('c1', 'termine', { projectId: 'pt1', action: 'activate' })
  assert.equal(featuresOf(on, 'pt1').termine.state, 'active')
  const aktiv = await docOf('pt1', 'termine')
  assert.equal(aktiv.disabledAt, null)
  assert.equal(aktiv.disabledReason, null)
})

test('unbekannter Schluessel -> 404, auch /kalender; nichts wird angelegt', async () => {
  const docs = aw.docs('portalFeatures').size
  for (const key of ['kalender', 'analyse', 'Termine', 'termine2']) {
    const res = await team('c1', key, { projectId: 'pt2', action: 'activate' })
    assert.equal(res.status, 404, key)
    assert.equal(typeof res.body.error, 'string', key)
  }
  // der Schluessel wird vor dem Rumpf geprueft
  assert.equal((await team('c1', 'kalender', {})).status, 404)
  assert.equal(aw.docs('portalFeatures').size, docs)
  assert.equal(await docOf('pt2', 'termine'), null)
})

test('Meldungen sind je Funktion grammatisch', async () => {
  aw.seed('websiteProjects', { $id: 'pt4', customerId: 'c1', projectName: 'Ohne Dokument' })
  const termine = await team('c1', 'termine', { projectId: 'pt4', action: 'disable' })
  assert.equal(termine.status, 409)
  assert.equal(termine.body.error, 'Für dieses Projekt gibt es noch keinen Terminplaner')
  const news = await team('c1', 'news', { projectId: 'pt4', action: 'disable' })
  assert.equal(news.status, 409)
  assert.equal(news.body.error, 'Für dieses Projekt gibt es noch keine News-Pinnwand')
  assert.equal(await docOf('pt4', 'termine'), null)
})

test('Pruefungen wie bei News: Aktion, Projekt, fremdes Projekt, Kunde', async () => {
  assert.equal((await team('c1', 'termine', { projectId: 'pt1', action: 'loeschen' })).status, 400)
  assert.equal((await team('c1', 'termine', { action: 'activate' })).status, 400)
  assert.equal((await team('c1', 'termine', { projectId: 'pt3', action: 'activate' })).status, 403)
  assert.equal((await team('c1', 'termine', { projectId: 'gibtsnicht', action: 'activate' })).status, 403)
  assert.equal(await sf.getFeatureDoc('c2', 'pt3', 'termine'), null)
  const asCustomer = await team('c1', 'termine', { projectId: 'pt2', action: 'activate' }, { cookie })
  assert.ok(asCustomer.status === 401 || asCustomer.status === 403)
  assert.equal(await docOf('pt2', 'termine'), null)
})

test('Die Ansicht des Teams liest die Funktionsdokumente des Kunden einmal', async (t) => {
  const echt = globalThis.fetch
  const abfragen = []
  globalThis.fetch = async (url, optionen) => {
    if (/\/collections\/portalFeatures\/documents/.test(String(url))) abfragen.push(`${optionen?.method ?? 'GET'} ${String(url).replace(/\?.*/, '')}`)
    return echt(url, optionen)
  }
  t.after(() => (globalThis.fetch = echt))
  const list = await get('/api/team/funktionen/c1', STAFF)
  assert.ok(list.projects.length >= 3)
  assert.equal(abfragen.length, 1, abfragen.join(' | '))
  assert.match(abfragen[0], /^GET .*\/collections\/portalFeatures\/documents$/)
})

// ------------------------------------------------------------- Kundenliste ---
const MODUS = { mode: config.termine.mode, pilotEmails: [...config.termine.pilotEmails] }
const termineMit = (mode, pilotEmails = []) => {
  config.termine.mode = mode
  config.termine.pilotEmails = pilotEmails
}
after(() => termineMit(MODUS.mode, MODUS.pilotEmails))
const verfuegbar = async (c = cookie) => (await get('/api/funktionen', { cookie: c })).termine

test('GET /api/funktionen: termine.verfuegbar je Modus und Pilot-E-Mail', async () => {
  termineMit('off')
  assert.deepEqual(await verfuegbar(), { verfuegbar: false })
  termineMit('pilot', ['k@example.invalid'])
  assert.deepEqual(await verfuegbar(), { verfuegbar: true })
  assert.deepEqual(await verfuegbar(customerCookie('c2')), { verfuegbar: false }, 'Kunde nicht in der Pilotliste')
  termineMit('pilot', [])
  assert.deepEqual(await verfuegbar(), { verfuegbar: false })
  termineMit('pilot', ['*'])
  assert.deepEqual(await verfuegbar(customerCookie('c2')), { verfuegbar: true })
  termineMit('on')
  assert.deepEqual(await verfuegbar(customerCookie('c2')), { verfuegbar: true })
})

test('GET /api/funktionen: Projekte tragen features.termine und News wie bisher', async () => {
  termineMit('pilot', ['*'])
  const body = await get('/api/funktionen', { cookie })
  assert.equal(body.setupEstimate, 'meist innerhalb von 1–2 Wochen')
  const pt1 = body.projects.find((p) => p.projectId === 'pt1')
  assert.equal(pt1.features.termine.state, 'active')
  assert.equal(pt1.features.news.state, 'disabled')
  const pt2 = body.projects.find((p) => p.projectId === 'pt2')
  assert.deepEqual([pt2.features.termine.state, pt2.features.news.state], ['off', 'off'])
  assert.deepEqual(Object.keys(pt2.features), ['news', 'termine'])
  // Abschaltgrund und Loeschfrist (E2, R105): News ist hier vom Team abgeschaltet: Grund und Zeitpunkt ja, ein Loeschdatum nein
  // (der 30-Tage-Loeschlauf loescht nur Terminplaner-Daten); der aktive Terminplaner und das leere Projekt haben nichts
  const aus = pt1.features.news
  assert.equal(aus.disabledReason, 'team')
  assert.match(aus.disabledAt, /^\d{4}-\d\d-\d\dT[\d:.]+Z$/)
  assert.equal(aus.loeschungAm, null)
  for (const view of [pt1.features.termine, pt2.features.news, pt2.features.termine]) {
    assert.deepEqual([view.disabledReason, view.disabledAt, view.loeschungAm], [null, null, null])
  }
  // ohne Sitzung wie bisher gesperrt
  assert.equal((await rawGet('/api/funktionen')).status, 401)
})

test('GET /api/funktionen: abgeschalteter Terminplaner nennt Grund, Zeitpunkt und Berliner Loeschtag; Altbestand ohne Grund', async () => {
  const projekte = [
    ['pe2_aboende', { state: 'disabled', enabled: false, disabledReason: 'abo_ende', disabledAt: '2026-10-04T23:30:00.000Z' }],
    ['pe2_team', { state: 'disabled', enabled: false, disabledReason: 'team', disabledAt: '2026-10-01T10:00:00.000Z' }],
    ['pe2_alt', { state: 'disabled', enabled: false, disabledAt: '2026-10-01T10:00:00.000Z' }],
    ['pe2_aktiv', { state: 'active', enabled: true }],
  ]
  for (const [id, felder] of projekte) {
    aw.seed('websiteProjects', { $id: id, customerId: 'ce2', projectName: id })
    aw.seed('portalFeatures', { $id: `f_${id}_termine`, customerId: 'ce2', projectId: id, featureKey: 'termine', siteKey: 'abcdefghijklmnop', ...felder })
  }
  const body = await get('/api/funktionen', { cookie: customerCookie('ce2') })
  const termine = (id) => body.projects.find((p) => p.projectId === id).features.termine
  const felder = (id) => ({ disabledReason: termine(id).disabledReason, disabledAt: termine(id).disabledAt, loeschungAm: termine(id).loeschungAm })
  assert.deepEqual(felder('pe2_aboende'), { disabledReason: 'abo_ende', disabledAt: '2026-10-04T23:30:00.000Z', loeschungAm: '2026-11-04' }, 'Berliner Tag, nicht der UTC-Tag 2026-11-03')
  assert.deepEqual(felder('pe2_team'), { disabledReason: 'team', disabledAt: '2026-10-01T10:00:00.000Z', loeschungAm: '2026-10-31' })
  assert.deepEqual(felder('pe2_alt'), { disabledReason: null, disabledAt: '2026-10-01T10:00:00.000Z', loeschungAm: '2026-10-31' }, 'Altbestand ohne Grund')
  assert.deepEqual(felder('pe2_aktiv'), { disabledReason: null, disabledAt: null, loeschungAm: null })
  assert.equal(termine('pe2_aboende').state, 'disabled')
})

test('Abgeschaltetes News hat Grund und Zeitpunkt, aber kein Loeschdatum; die Teamansicht nennt es fuer den Terminplaner (R105)', async () => {
  const lange_her = '2026-01-15T10:00:00.000Z'
  aw.seed('websiteProjects', { $id: 'pe3_p', customerId: 'ce3', projectName: 'Alt abgeschaltet' })
  aw.seed('portalFeatures', { $id: 'f_pe3_news', customerId: 'ce3', projectId: 'pe3_p', featureKey: 'news', siteKey: 'abcdefghijklmnop', state: 'disabled', enabled: false, disabledReason: 'team', disabledAt: lange_her })
  aw.seed('portalFeatures', { $id: 'f_pe3_termine', customerId: 'ce3', projectId: 'pe3_p', featureKey: 'termine', siteKey: 'bcdefghijklmnopq', state: 'disabled', enabled: false, disabledReason: 'abo_ende', disabledAt: lange_her })
  // Kundenansicht
  const kunde = (await get('/api/funktionen', { cookie: customerCookie('ce3') })).projects.find((p) => p.projectId === 'pe3_p').features
  assert.deepEqual([kunde.news.state, kunde.news.disabledReason, kunde.news.disabledAt, kunde.news.loeschungAm], ['disabled', 'team', lange_her, null])
  assert.deepEqual([kunde.termine.disabledReason, kunde.termine.disabledAt, kunde.termine.loeschungAm], ['abo_ende', lange_her, '2026-02-14'])
  // Teamansicht (adminView, GET /api/team/funktionen/:customerId): dieselben Felder, die WOMS-Anzeige (E12) liest loeschungAm
  const team_ansicht = (await get('/api/team/funktionen/ce3', STAFF)).projects.find((p) => p.projectId === 'pe3_p').features
  assert.deepEqual([team_ansicht.termine.state, team_ansicht.termine.disabledReason, team_ansicht.termine.disabledAt], ['disabled', 'abo_ende', lange_her])
  assert.equal(team_ansicht.termine.loeschungAm, '2026-02-14', 'abgeschalteter Terminplaner traegt loeschungAm (Berliner Tag, 30 x 24 h spaeter)')
  assert.equal(team_ansicht.termine.loeschungAm, loeschTag(lange_her))
  assert.deepEqual([team_ansicht.news.disabledReason, team_ansicht.news.disabledAt, team_ansicht.news.loeschungAm], ['team', lange_her, null])
})

// --------------------------------------------------------- Kunde loeschen ---
/** Entwurf: Terminplaner im Zustand off samt Einstellung (termineConfig), nie bestellt. */
function legeEntwurf(customerId, projectId) {
  const id = `f_${projectId}_termine`
  aw.seed('portalFeatures', { $id: id, customerId, projectId, featureKey: 'termine', siteKey: 'abcdefghijklmnop', state: 'off', enabled: false })
  aw.seed('termineConfig', { $id: id, customerId, projectId, einstellung: '{}', version: 1, updatedBy: 'kunde' })
}

test('Kunde loeschen schaltet seine Terminplaner ab (Notiz Kunde geloescht, Grund kunde_geloescht), nur seine', async () => {
  aw.seed('customers', { $id: 'kt1', name: 'Weg Salon', email: 'weg@example.invalid' })
  aw.seed('websiteProjects', { $id: 'ktp1', customerId: 'kt1', projectName: 'Weg Eins' })
  aw.seed('websiteProjects', { $id: 'ktp2', customerId: 'kt1', projectName: 'Weg Zwei' })
  aw.seed('websiteProjects', { $id: 'ktp3', customerId: 'kt1', projectName: 'Weg Drei' })
  await sf.adminActivate('kt1', 'ktp1', 'termine', { by: 'test' })
  await sf.adminActivate('kt1', 'ktp1', 'news', { by: 'test' })
  await sf.adminActivate('kt1', 'ktp2', 'termine', { by: 'test' })
  const schonAus = await sf.adminActivate('kt1', 'ktp3', 'termine', { by: 'test' })
  const frueher = (await sf.disable(schonAus.$id, { by: 'test' })).disabledAt
  const fremd = await sf.getFeatureDoc('c1', 'pt1', 'termine')
  // Entwuerfe (off): der des Kunden samt Einstellung geht mit ihm, der eines anderen Kunden bleibt
  aw.seed('websiteProjects', { $id: 'ktp5', customerId: 'kt1', projectName: 'Weg Fuenf' })
  legeEntwurf('kt1', 'ktp5')
  legeEntwurf('kt9', 'ktp9')

  await deleteCustomerWithPortalAccess('kt1')

  assert.equal(aw.docs('portalFeatures').has('f_ktp5_termine'), false, 'Entwurf des Kunden: Funktionsdokument weg')
  assert.equal(aw.docs('termineConfig').has('f_ktp5_termine'), false, 'Entwurf des Kunden: Einstellung weg')
  assert.equal(aw.docs('portalFeatures').has('f_ktp9_termine'), true, 'Entwurf eines anderen Kunden bleibt')
  assert.equal(aw.docs('termineConfig').has('f_ktp9_termine'), true)

  assert.equal(aw.docs('customers').has('kt1'), false)
  for (const projekt of ['ktp1', 'ktp2']) {
    const doc = await sf.getFeatureDoc('kt1', projekt, 'termine')
    assert.deepEqual([doc.state, doc.enabled, doc.adminNote, doc.disabledReason], ['disabled', false, 'Kunde gelöscht', 'kunde_geloescht'], projekt)
    assert.ok(Math.abs(Date.parse(doc.disabledAt) - Date.now()) < 5000, projekt)
  }
  const schonAusNachher = await sf.getFeatureDoc('kt1', 'ktp3', 'termine')
  assert.equal(schonAusNachher.disabledAt, frueher, 'Beginn der 30 Tage bleibt')
  assert.equal(schonAusNachher.disabledReason, 'team', 'ein schon abgeschalteter Terminplaner behaelt seinen Grund')
  assert.equal((await sf.getFeatureDoc('kt1', 'ktp1', 'news')).state, 'active', 'News ist nicht Sache des Terminplaners')
  assert.equal((await sf.getFeatureDoc('c1', 'pt1', 'termine')).state, fremd.state, 'anderer Kunde')
})

test('Kunde loeschen gelingt auch, wenn das Abschalten scheitert (Fehler im Log)', async (t) => {
  const log = t.mock.method(console, 'error', () => {})
  aw.seed('customers', { $id: 'kt2', name: 'Weg Zwei', email: 'weg2@example.invalid' })
  aw.seed('websiteProjects', { $id: 'ktp4', customerId: 'kt2', projectName: 'Weg Vier' })
  await sf.adminActivate('kt2', 'ktp4', 'termine', { by: 'test' })
  aw.failNext({ collection: 'portalFeatures', method: 'PATCH', status: 500, message: 'kaputt' })
  await deleteCustomerWithPortalAccess('kt2')
  assert.equal(aw.docs('customers').has('kt2'), false)
  assert.ok(log.mock.calls.some((c) => /Terminplaner von Kunde kt2 nicht abgeschaltet/.test(String(c.arguments[0]))))
})

test('Kunde loeschen gelingt auch, wenn das Loeschen der Entwuerfe scheitert (Fehler im Log, die uebrigen Entwuerfe gehen trotzdem)', async (t) => {
  const log = t.mock.method(console, 'error', () => {})
  aw.seed('customers', { $id: 'kt3', name: 'Weg Drei', email: 'weg3@example.invalid' })
  aw.seed('websiteProjects', { $id: 'ktp6', customerId: 'kt3', projectName: 'Weg Sechs' })
  aw.seed('websiteProjects', { $id: 'ktp7', customerId: 'kt3', projectName: 'Weg Sieben' })
  legeEntwurf('kt3', 'ktp6')
  legeEntwurf('kt3', 'ktp7')
  aw.failNext({ collection: 'termineConfig', method: 'DELETE', status: 500, message: 'kaputt' })
  await deleteCustomerWithPortalAccess('kt3')
  assert.equal(aw.docs('customers').has('kt3'), false, 'der Kunde ist geloescht')
  assert.ok(log.mock.calls.some((c) => /Entwürfe von Kunde kt3 nicht gelöscht/.test(String(c.arguments[0]))), 'Logzeile')
  assert.equal(aw.docs('portalFeatures').has('f_ktp6_termine'), true, 'der Entwurf mit Fehler bleibt (ein spaeterer Lauf nach 90 Tagen holt ihn nach)')
  assert.equal(aw.docs('portalFeatures').has('f_ktp7_termine'), false, 'der andere Entwurf ist weg')
  assert.equal(aw.docs('termineConfig').has('f_ktp7_termine'), false)
})

test('Kunde loeschen laesst Terminplaner, die nicht off sind, den Abschaltweg gehen (Frist von 30 Tagen) und loescht ihre Einstellung nicht', async () => {
  aw.seed('customers', { $id: 'kt4', name: 'Weg Vier', email: 'weg4@example.invalid' })
  aw.seed('websiteProjects', { $id: 'ktp8', customerId: 'kt4', projectName: 'Weg Acht' })
  await sf.adminActivate('kt4', 'ktp8', 'termine', { by: 'test' })
  aw.seed('termineConfig', { $id: 'f_ktp8_termine', customerId: 'kt4', projectId: 'ktp8', einstellung: '{}', version: 1, updatedBy: 'kunde' })
  await deleteCustomerWithPortalAccess('kt4')
  const doc = await sf.getFeatureDoc('kt4', 'ktp8', 'termine')
  assert.equal(doc.state, 'disabled')
  assert.equal(aw.docs('termineConfig').has('f_ktp8_termine'), true, 'die Einstellung eines aktiven Betriebs loescht erst der Tageslauf nach 30 Tagen')
})

// ------------------------------------------------ Team-Aktivierung nur mit laufendem Abo (E9) ---
// Ein bezahlter Terminplaner (unlockedByPurchase) darf das Team nur einschalten, solange das Wartungs-Abo laeuft: sonst nimmt der
// naechste Abgleichslauf die Kulanz zurueck und K22 ginge ein zweites Mal. Pilot und Kulanz ohne Kauf sowie News sind nicht betroffen.
const KEIN_ABO = 'Das Wartungs-Abo des Kunden läuft nicht. Der Terminplaner kann erst wieder freigeschaltet werden, wenn es läuft.'
let kaNr = 0
/** Kunde mit Projekt und Funktionsdokument (key, over); abo: 'wartung' | 'hosting' | null (kein Abo). Liefert { customerId, projectId, docId }. */
function legeKunde({ abo = null, aboOver = {}, key = 'termine', over = {} } = {}) {
  kaNr += 1
  const customerId = `ka${kaNr}`
  const projectId = `kap${kaNr}`
  const docId = `f_${projectId}_${key}`
  aw.seed('websiteProjects', { $id: projectId, customerId, projectName: `Salon ${kaNr}` })
  if (abo) aw.seed('subscriptions', subscriptionDoc(`sub_ka${kaNr}`, { ...(abo === 'wartung' ? wartungDoc : hostingDoc), customerId, ...aboOver }))
  aw.seed('portalFeatures', {
    $id: docId, customerId, projectId, featureKey: key, siteKey: 'abcdefghijklmnop', state: 'disabled', enabled: false,
    unlockedByPurchase: true, purchaseStatus: 'paid', disabledReason: 'abo_ende', disabledAt: '2026-10-01T10:00:00.000Z',
    aboEndeMailAt: '2026-10-01T10:05:00.000Z', adminNote: 'Abgeschaltet: Wartungs-Abo beendet', ...over,
  })
  return { customerId, projectId, docId }
}
const docById = (id) => aw.docs('portalFeatures').get(id)
const aktivieren = (k, key = 'termine') => team(k.customerId, key, { projectId: k.projectId, action: 'activate', note: 'Kulanz' })

test('Team aktiviert einen bezahlten, abgeschalteten Terminplaner ohne laufendes Abo nicht: 409 mit Text, Zustand unveraendert', async () => {
  for (const abo of [null, 'hosting']) {
    const k = legeKunde({ abo })
    const vorher = { ...docById(k.docId) }
    const res = await aktivieren(k)
    assert.equal(res.status, 409, `abo ${abo}`)
    assert.equal(res.body.error, KEIN_ABO)
    assert.deepEqual(docById(k.docId), vorher, 'kein Schreibzugriff: Zustand, Grund, Frist und Notiz bleiben')
  }
  // auch ein bezahlter Terminplaner, den das Team abgeschaltet hat, und ein ausgebliebenes Abo nach Kuendigung (canceled)
  const team_aus = legeKunde({ over: { disabledReason: 'team', aboEndeMailAt: null } })
  assert.equal((await aktivieren(team_aus)).status, 409)
  assert.equal(docById(team_aus.docId).state, 'disabled')
  const beendet = legeKunde({ abo: 'wartung', aboOver: { status: 'canceled', endedAt: '2026-10-01T10:00:00.000Z' } })
  assert.equal((await aktivieren(beendet)).status, 409)
  assert.equal(docById(beendet.docId).state, 'disabled')
})

test('Bezahlter Terminplaner in Einrichtung (setup) ohne Abo: das Team kann ihn auch nicht von Hand freischalten', async () => {
  const k = legeKunde({ over: { state: 'setup', disabledReason: null, disabledAt: null, aboEndeMailAt: null, adminNote: '' } })
  const res = await aktivieren(k)
  assert.equal(res.status, 409)
  assert.equal(res.body.error, KEIN_ABO)
  assert.equal(docById(k.docId).state, 'setup')
})

test('Mit laufendem Wartungs-Abo aktiviert das Team den bezahlten Terminplaner: active, Grund und Frist leer, Marker leer', async () => {
  const k = legeKunde({ abo: 'wartung' })
  const res = await aktivieren(k)
  assert.equal(res.status, 200, JSON.stringify(res.body))
  const doc = docById(k.docId)
  assert.deepEqual([doc.state, doc.enabled, doc.disabledReason, doc.disabledAt, doc.aboEndeMailAt], ['active', true, null, null, null])
  assert.equal(doc.unlockedByPurchase, true, 'der Kauf bleibt vermerkt')
  assert.equal(featuresOf(res, k.projectId).termine.state, 'active')
  // eine vorgemerkte Kuendigung laesst das Abo bis zum Ende laufen
  const gekuendigt = legeKunde({ abo: 'wartung', aboOver: { cancelAtPeriodEnd: true } })
  assert.equal((await aktivieren(gekuendigt)).status, 200)
  assert.equal(docById(gekuendigt.docId).state, 'active')
})

test('Wechsel widerrufen (Spiegel steht noch auf Wartung): 409, denn das Wartungs-Abo laeuft nicht', async () => {
  const k = legeKunde({ abo: 'wartung' })
  aw.seed('contractEvents', {
    $id: `ev_${k.customerId}`, customerId: k.customerId, subscriptionId: `sub_ka${kaNr}`, type: 'wechsel', productKey: 'wartung', details: '{}', status: 'widerrufen',
  })
  const res = await aktivieren(k)
  assert.equal(res.status, 409)
  assert.equal(res.body.error, KEIN_ABO)
  assert.equal(docById(k.docId).state, 'disabled')
})

test('Ohne Kauf (unlockedByPurchase false: Pilot, Kulanz) braucht die Aktivierung kein Abo und liest es nicht', async () => {
  for (const unlockedByPurchase of [false, undefined]) {
    const k = legeKunde({ over: { unlockedByPurchase, purchaseStatus: '', disabledReason: 'team', aboEndeMailAt: null } })
    const vorher = aw.listCalls('subscriptions').length
    const res = await aktivieren(k)
    assert.equal(res.status, 200, JSON.stringify(res.body))
    assert.equal(docById(k.docId).state, 'active')
    assert.equal(aw.listCalls('subscriptions').length, vorher, 'keine Abo-Abfrage')
  }
  // kein Dokument bisher (ensureFeatureDoc legt es an): ebenfalls frei
  aw.seed('websiteProjects', { $id: 'kap_neu', customerId: 'ka_neu', projectName: 'Neu' })
  const neu = await team('ka_neu', 'termine', { projectId: 'kap_neu', action: 'activate' })
  assert.equal(neu.status, 200)
})

test('News ist nicht betroffen: auch mit unlockedByPurchase und ohne Abo aktiviert das Team', async () => {
  const k = legeKunde({ key: 'news', over: { disabledReason: 'team', aboEndeMailAt: null } })
  const res = await aktivieren(k, 'news')
  assert.equal(res.status, 200, JSON.stringify(res.body))
  assert.equal(docById(k.docId).state, 'active')
})

test('Abo nicht lesbar: Fehler (5xx), nicht aktiviert; danach geht es mit lesbarem Abo', async (t) => {
  const log = t.mock.method(console, 'error', () => {})
  const k = legeKunde({ abo: 'wartung' })
  const vorher = { ...docById(k.docId) }
  aw.failNext({ collection: 'subscriptions', method: 'GET', status: 500, message: 'kaputt' })
  const res = await aktivieren(k)
  assert.ok(res.status >= 500 && res.status < 600, `Status ${res.status}`)
  assert.equal(typeof res.body.error, 'string')
  assert.deepEqual(docById(k.docId), vorher, 'nicht aktiviert')
  assert.ok(log.mock.calls.length >= 1, 'der Fehler steht im Log')
  assert.equal((await aktivieren(k)).status, 200)
  assert.equal(docById(k.docId).state, 'active')
})

test('Ereignisse nicht lesbar (Wechsel-Regel): Fehler, nicht aktiviert', async (t) => {
  t.mock.method(console, 'error', () => {})
  const k = legeKunde({ abo: 'wartung' })
  aw.failNext({ collection: 'contractEvents', method: 'GET', status: 500 })
  const res = await aktivieren(k)
  assert.ok(res.status >= 500 && res.status < 600, `Status ${res.status}`)
  assert.equal(docById(k.docId).state, 'disabled')
})

test('adminActivate (Dienst): bezahlter Terminplaner ohne Abo => Fehler 409, bei laufendem Abo und fuer Dokumente ohne Kauf aktiv', async () => {
  const k = legeKunde()
  await assert.rejects(() => sf.adminActivate(k.customerId, k.projectId, 'termine', { by: 'test' }), { status: 409, message: KEIN_ABO })
  assert.equal(docById(k.docId).state, 'disabled')
  const mit = legeKunde({ abo: 'wartung' })
  assert.equal((await sf.adminActivate(mit.customerId, mit.projectId, 'termine', { by: 'test' })).state, 'active')
  const pilot = legeKunde({ over: { unlockedByPurchase: false } })
  assert.equal((await sf.adminActivate(pilot.customerId, pilot.projectId, 'termine', { by: 'test' })).state, 'active')
})