create-devoplus-one-app 0.0.0-stage → 0.1.0-next.158

package/templates/uygunsuzluk-dof/files/src/app.ts.tpl

@@ -0,0 +1,431 @@
+// {{nameTr}} — uygunsuzluk ve düzeltici faaliyet kaydı. Uçlar (hepsi oturum ister; kimlik platformdan gelir):
+//   POST   /api/nonconformities                     uygunsuzluk bildir (herkes) { title, source, severity, description, location?, detected_on?, attachment? }
+//   GET    /api/my/nonconformities[?…]              bildirdiklerim — hazır liste
+//   GET    /api/nonconformities[?…]                 bütün kayıtlar (yönetici) — hazır liste + Excel
+//   PATCH  /api/nonconformities/{id}                kayıt bilgisi ve kök neden (yönetici; kapanmış kayıt değişmez)
+//   POST   /api/nonconformities/{id}/status         { status, note? } — durum akışı `src/capa.ts` (yönetici)
+//   GET    /api/nonconformities/{id}/detail         kayıt + faaliyetler (yönetici, bildiren ya da faaliyet sorumlusu)
+//   GET    /api/nonconformities/{id}/attachment     dosya eki (aynı kişiler)
+//   POST   /api/nonconformities/{id}/actions        { description, owner: { id, name }, due_date } — faaliyet ekle (yönetici)
+//   PATCH  /api/actions/{id} · DELETE /api/actions/{id}   faaliyeti değiştir / sil (yönetici; yalnız açık faaliyet)
+//   POST   /api/actions/{id}/complete               { note } — faaliyeti tamamla (sorumlusu ya da yönetici)
+//   GET    /api/my/actions[?…]                      faaliyetlerim (sorumlusu BEN) — hazır liste + Excel
+//   GET    /api/actions[?…]                         bütün faaliyetler (yönetici) — hazır liste + Excel
+//   GET    /api/summary                             sayılar, geciken faaliyetler, son hatırlatma turu (yönetici)
+//   POST   /api/files                               dosya yükleme (yalnız kendi ön ekinize)
+// Durum, kapanış ve tamamlanma bilgileri istemciden ALINMAZ: sunucu yazar. Kayıt ve faaliyet genel uçlardan yazılmaz.
+import {
+  OneError,
+  createCrudHandler,
+  foldSearchText,
+  getMyOrgContext,
+  hasPermission,
+  logAudit,
+  logError,
+  requirePermission,
+  requireUser,
+  systemNotice,
+  type BackendClient,
+  type OneFilesBinding,
+} from '@devoplus/one-sdk'
+import manifest from '../one.manifest.json' with { type: 'json' }
+import { agentTools } from './agent.ts'
+import { ACTION_NOTE_MAX, actionsEditable, checkDueDate, formatDay, isStatus, istanbulDay, transitionRequirement, type NcStatus } from './capa.ts'
+import { dataModel } from './data/types.ts'
+import { jobs } from './jobs.ts'
+import { fileResponse, uploadFile } from './lib/files.ts'
+import { fieldError, forward, matchId, nowIso, onlyFields, ownFileKey, personValue, readJsonObject, withQuery } from './lib/http.ts'
+import { and, applied, changedOne, insertWhen, recordWrite, refuseActingSession, removeWhen, sql, updateWhen } from './lib/record.ts'
+import { sendMailSafely } from './lib/mail.ts'
+import { createApp, json, type AppDefinition, type BaseEnv, type RouteInput } from './lib/server.ts'
+import { actionsOf, counts, findAction, findNc, lastReminderRun, overdueCount, type NcRow } from './queries.ts'
+import { renderShell, renderShellScript } from './shell.ts'
+
+export interface Env extends BaseEnv {
+  /** Bu kurulumun dosya deposu (manifest services.files) — uygunsuzluk ekleri. */
+  FILES: OneFilesBinding
+}
+
+export const APP_NAME = { tr: {{nameTrJs}}, en: {{nameEnJs}} }
+/** Yönetici izni (manifest `permissions`): kayıtları görür, kök nedeni yazar, faaliyet planlar, durumu ilerletir ve kapatır. */
+export const MANAGE_PERMISSION = '{{permissionPrefix}}Manage'
+
+/** Bildirdiklerim: herkes yalnız KENDİ bildirdiği kayıtları görür. */
+export const myReports = createCrudHandler({ model: dataModel, entity: 'nonconformities', records: 'own', basePath: '/api/my' })
+/** Bütün kayıtlar ve faaliyetler: yalnız yönetici; salt okunur (yazma uygulamanın kendi uçlarından). */
+export const records = createCrudHandler({ model: dataModel, entity: 'nonconformities', records: 'shared', canRead: MANAGE_PERMISSION })
+export const allActions = createCrudHandler({ model: dataModel, entity: 'actions', records: 'shared', canRead: MANAGE_PERMISSION })
+/** Faaliyetlerim: liste sunucuda "sorumlu = ben" süzgeciyle ZORLANIR (`myActions`). */
+const myActionsList = createCrudHandler({ model: dataModel, entity: 'actions', records: 'shared', basePath: '/api/my' })
+
+const REPORT_FIELDS = ['title', 'source', 'severity', 'description', 'location', 'detected_on', 'attachment'] as const
+const EDIT_FIELDS = ['title', 'source', 'severity', 'description', 'location', 'detected_on', 'root_cause'] as const
+const ACTION_FIELDS = ['description', 'owner', 'due_date'] as const
+const CONTROL_RE = /[\u0000-\u0008\u000b-\u001f\u007f]/
+
+async function myOrg(api: BackendClient): Promise<{ id: string; name: string } | null> {
+  const me = await getMyOrgContext(api)
+  return me ? { id: me.orgUserId.toLowerCase(), name: me.fullName ?? '' } : null
+}
+
+async function myName(input: RouteInput<Env>): Promise<string | null> {
+  try {
+    return (await myOrg(input.api()))?.name || null
+  } catch (error) {
+    // Ad bir kolaylıktır: okunamazsa kayıt yine yazılır (ad boş kalır).
+    logError(input.ctx, 'kişi adı okunamadı', error)
+    return null
+  }
+}
+
+function requiredText(raw: unknown, field: string, max: number, multiline: boolean): string {
+  if (typeof raw !== 'string' || raw.trim() === '') throw fieldError(field, 'Bu alan zorunlu.')
+  const value = raw.trim()
+  if ([...value].length > max) throw fieldError(field, `En çok ${max} karakter olabilir.`)
+  if (CONTROL_RE.test(value) || (!multiline && /[\r\n\t]/.test(value))) throw fieldError(field, 'Geçersiz karakter var.')
+  return value
+}
+
+const today = (): string => istanbulDay(new Date())
+
+/** Organizasyon şemasından gelen adı veri modelinin sınırına kırpar (boş ad `null`). */
+function clip(value: string | null | undefined, max: number): string | null {
+  const text = value?.trim() ?? ''
+  return text === '' ? null : [...text].slice(0, max).join('')
+}
+
+/** Kaydı görebilen: yönetici, bildiren ya da kayıtta faaliyeti olan kişi. Göremeyen için "yok" — kimlik yoklanamaz. */
+async function visibleNc(input: RouteInput<Env>, id: string): Promise<{ nc: NcRow; manager: boolean; me: { id: string; name: string } | null }> {
+  const { env, ctx } = input
+  const user = requireUser(ctx)
+  const nc = await findNc(env, id)
+  if (!nc) throw new OneError(404, 'APP-E-404', 'Kayıt bulunamadı.')
+  const manager = hasPermission(ctx, MANAGE_PERMISSION)
+  if (manager || nc.created_by === user.sub) return { nc, manager, me: null }
+  const me = await myOrg(input.api()).catch(() => null)
+  const owns = me
+    ? await env.DB.prepare('SELECT 1 AS x FROM "actions" WHERE nonconformity_id = ? AND owner_org_id = ? AND deleted_at IS NULL LIMIT 1').bind(id, me.id).first<{ x: number }>()
+    : null
+  if (!owns) throw new OneError(404, 'APP-E-404', 'Kayıt bulunamadı.')
+  return { nc, manager, me }
+}
+
+async function report(input: RouteInput<Env>): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireUser(ctx)
+  // ⛔ Durum, kök neden ve kapanış alanları bildirimde GÖNDERİLEMEZ (alan listesi dışındaki her ad 400).
+  const body = onlyFields(await readJsonObject(request), REPORT_FIELDS)
+  if (typeof body.detected_on === 'string' && body.detected_on > today()) throw fieldError('detected_on', 'Tespit tarihi ileri bir tarih olamaz.')
+  const attachment = ownFileKey(body.attachment, user.sub, 'attachment')
+  const attachmentName =
+    attachment && typeof body.attachment === 'object' && body.attachment !== null && typeof (body.attachment as { name?: unknown }).name === 'string'
+      ? (body.attachment as { name: string }).name.slice(0, 200)
+      : null
+  const record = { ...body, attachment, attachment_name: attachmentName, status: 'open', reporter_name: await myName(input) }
+  const res = (await myReports.handle(forward(request, myReports.path, 'POST', record), env.DB, ctx))!
+  if (res.status === 201) logAudit(ctx, 'nonconformity.report', ((await res.clone().json()) as { id: string }).id)
+  return res
+}
+
+async function edit(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  refuseActingSession(ctx)
+  // Durum bu uçtan değişmez (400): durum akışının ucu `/status`'tur.
+  const body = onlyFields(await readJsonObject(request), EDIT_FIELDS)
+  // Bildirimdeki kural düzenlemede de geçerlidir: tespit tarihi ileri bir tarih olamaz.
+  if (typeof body.detected_on === 'string' && body.detected_on > today()) throw fieldError('detected_on', 'Tespit tarihi ileri bir tarih olamaz.')
+  const write = recordWrite(dataModel, 'nonconformities', body, 'update')
+  const now = nowIso()
+  // ⛔ "Kapanmamış" koşulu yazımla AYNI ifadededir: durumu önce okuyup sonra yazmak, arada kapanan kaydı (kök neden,
+  // tespit bilgisi) değiştirirdi. Koşul tutmazsa hiçbir alan yazılmaz.
+  // Faaliyetler kaydın başlığının KOPYASINI taşır (Faaliyetlerim ve hatırlatma e-postası onu gösterir): başlık değişince
+  // kopyalar aynı toplu yazımda güncellenir. Faaliyet ekleme de başlığı kendi ifadesinde kaydın o anki başlığıyla
+  // karşılaştırır (bayat başlık yazılmaz).
+  const title = typeof body.title === 'string' ? (write.values[write.columns.indexOf('title')] as string) : null
+  const [updated] = await env.DB.batch([
+    updateWhen(env.DB, write, { id, actor: user.sub, now, when: sql(`"status" <> 'closed'`) }),
+    ...(title === null
+      ? []
+      : [
+          env.DB.prepare(
+            'UPDATE "actions" SET nonconformity_title = ?, nonconformity_title_fold = ? WHERE nonconformity_id = ? AND EXISTS (SELECT 1 FROM "nonconformities" n WHERE n.id = ? AND n.title = ?)',
+          ).bind(title, foldSearchText(title), id, id, title),
+        ]),
+  ])
+  if (!changedOne(updated)) {
+    if (!(await findNc(env, id))) throw new OneError(404, 'APP-E-404', 'Kayıt bulunamadı.')
+    throw new OneError(409, 'APP-E-020', 'Kapanmış kayıt değiştirilemez.')
+  }
+  return (await records.handle(forward(request, `${records.path}/${id}`, 'GET'), env.DB, ctx))!
+}
+
+/** Geçiş koşulu SQL'dedir (aynı ifadede): araya giren bir faaliyet değişikliği kapanışı geçersiz kılamaz. */
+async function changeStatus(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  refuseActingSession(ctx)
+  const body = onlyFields(await readJsonObject(request), ['status', 'note'])
+  if (!isStatus(body.status)) throw fieldError('status', 'Geçerli bir durum seçin.')
+  const to: NcStatus = body.status
+  const nc = await findNc(env, id)
+  if (!nc) throw new OneError(404, 'APP-E-404', 'Kayıt bulunamadı.')
+  const requirement = transitionRequirement(nc.status, to)
+  if (requirement === null) throw new OneError(409, 'APP-E-020', 'Kayıt bu durumdan seçilen duruma geçirilemez.')
+  if (body.note !== undefined && body.note !== '' && to !== 'closed') throw fieldError('note', 'Not yalnız kapatırken yazılır.')
+  const note = to === 'closed' && typeof body.note === 'string' && body.note.trim() ? requiredText(body.note, 'note', 2000, true) : null
+  const hasAction = 'EXISTS (SELECT 1 FROM "actions" WHERE nonconformity_id = "nonconformities".id AND deleted_at IS NULL)'
+  const noOpenAction = 'NOT EXISTS (SELECT 1 FROM "actions" WHERE nonconformity_id = "nonconformities".id AND status = \'open\' AND deleted_at IS NULL)'
+  // Doğrulamada etkisiz bulunan kayıt yeniden doğrulamaya, ancak o andan SONRA eklenmiş bir faaliyetle gider: eski
+  // faaliyetlerin hepsi zaten tamamlanmış olduğu için yalnız "hepsi tamamlandı" koşulu yeni faaliyeti atlatırdı.
+  const freshAction =
+    'EXISTS (SELECT 1 FROM "actions" WHERE nonconformity_id = "nonconformities".id AND deleted_at IS NULL AND created_at > "nonconformities".verification_failed_at)'
+  const guard =
+    requirement === 'root-cause-and-action'
+      ? ` AND trim(coalesce(root_cause, '')) <> '' AND ${hasAction}`
+      : requirement === 'all-actions-done'
+        ? ` AND ${hasAction} AND ${noOpenAction}` + (to === 'verification' ? ` AND (verification_failed_at IS NULL OR ${freshAction})` : '')
+        : ''
+  const now = nowIso()
+  const closing = to === 'closed'
+  const failedVerification = nc.status === 'verification' && to === 'planned'
+  const write = recordWrite(
+    dataModel,
+    'nonconformities',
+    { status: to, closed_at: closing ? now : null, closed_by_name: closing ? clip(await myName(input), 120) : null, closure_note: note },
+    'update',
+  )
+  // ⛔ Okunan durum ve geçişin koşulu yazımla AYNI ifadededir (aynı anda iki geçiş birbirini ezemez).
+  const statement = updateWhen(env.DB, write, {
+    id,
+    actor: user.sub,
+    now,
+    when: sql(`"status" = ?${guard}`, nc.status),
+    also: sql('"verification_failed_at" = CASE WHEN ? THEN ? ELSE "verification_failed_at" END', failedVerification ? 1 : 0, now),
+  })
+  if (!(await applied(write, statement))) throw new OneError(409, 'APP-E-021', await blockedReason(env, id, nc.status, requirement))
+  logAudit(ctx, 'nonconformity.status', id, { from: nc.status, to })
+  return json({ id, status: to })
+}
+
+async function blockedReason(env: Env, id: string, from: NcStatus, requirement: string): Promise<string> {
+  const now = await findNc(env, id)
+  if (!now || now.status !== from) return 'Kayıt bu arada değişti; sayfayı yenileyip yeniden deneyin.'
+  const actions = await actionsOf(env, id)
+  if (requirement === 'root-cause-and-action' && !(now.root_cause ?? '').trim()) return 'Önce kök nedeni yazın.'
+  if (actions.length === 0) return 'En az bir düzeltici faaliyet ekleyin.'
+  const open = actions.filter((a) => a.status === 'open').length
+  if (requirement === 'all-actions-done' && open > 0) return `${open} faaliyet henüz tamamlanmadı; bütün faaliyetler tamamlanınca devam edilir.`
+  const failedAt = now.verification_failed_at
+  if (from === 'planned' && failedAt && !actions.some((a) => a.created_at > failedAt))
+    return 'Kayıt doğrulamada etkisiz bulundu; yeniden doğrulamadan önce yeni bir düzeltici faaliyet ekleyip tamamlayın.'
+  return 'Kayıt bu arada değişti; sayfayı yenileyip yeniden deneyin.'
+}
+
+async function detail(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { nc, manager } = await visibleNc(input, id)
+  return json({ record: nc, actions: await actionsOf(input.env, id), manager })
+}
+
+async function attachment(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { nc } = await visibleNc(input, id)
+  if (!nc.attachment) throw new OneError(404, 'APP-E-404', 'Bu kayıtta dosya eki yok.')
+  return fileResponse(input.env.FILES, nc.attachment)
+}
+
+async function notifyOwner(input: RouteInput<Env>, owner: string, title: string, description: string, dueDate: string) {
+  return sendMailSafely(
+    input.ctx,
+    input.api(),
+    systemNotice({ appName: APP_NAME.tr, title: `Size bir düzeltici faaliyet atandı: ${title}`, message: `${description}\n\nTermin: ${formatDay(dueDate)}. Uygulamanın Faaliyetlerim sekmesinden tamamlayabilirsiniz.` }),
+    { toOrgUserIds: [owner] },
+  )
+}
+
+async function addAction(input: RouteInput<Env>, ncId: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  refuseActingSession(ctx)
+  const body = onlyFields(await readJsonObject(request), ACTION_FIELDS)
+  const nc = await findNc(env, ncId)
+  if (!nc) throw new OneError(404, 'APP-E-404', 'Kayıt bulunamadı.')
+  if (!actionsEditable(nc.status)) throw new OneError(409, 'APP-E-022', 'Bu durumdaki kayda faaliyet eklenemez.')
+  const description = requiredText(body.description, 'description', 2000, true)
+  const owner = personValue(body.owner, 'owner')
+  if (!owner) throw fieldError('owner', 'Faaliyetin sorumlusunu seçin.')
+  const due = checkDueDate(body.due_date, today())
+  if (!due.ok) throw fieldError('due_date', due.message)
+  const write = recordWrite(
+    dataModel,
+    'actions',
+    { nonconformity_id: ncId, nonconformity_title: nc.title, description, owner_org_id: owner.id, owner_name: clip(owner.name, 120), due_date: due.value, status: 'open' },
+    'create',
+  )
+  const id = crypto.randomUUID()
+  const now = nowIso()
+  // ⛔ Faaliyet yalnız kayıt HÂLÂ açık ya da planlandı durumundaysa ve başlığı okuduğumuz başlıksa eklenir (aynı ifadede):
+  // arada başlığı değişen kaydın faaliyetine eski başlık kopyalanmaz.
+  const when = sql(`EXISTS (SELECT 1 FROM "nonconformities" n WHERE n.id = ? AND n.status IN ('open', 'planned') AND n.deleted_at IS NULL AND n.title = ?)`, ncId, nc.title)
+  if (!(await applied(write, insertWhen(env.DB, write, { id, actor: user.sub, now, when })))) throw new OneError(409, 'APP-E-012', 'Kayıt bu arada değişti; sayfayı yenileyin.')
+  logAudit(ctx, 'action.create', id, { nonconformity: ncId })
+  const notification = await notifyOwner(input, owner.id, nc.title, description, due.value)
+  return json({ action: await findAction(env, id), notification }, 201)
+}
+
+/** Faaliyet açık ve kaydı açık ya da planlandı durumunda (yazılan `actions` satırı için). */
+const ACTION_OPEN = sql(
+  `"actions".status = 'open' AND EXISTS (SELECT 1 FROM "nonconformities" n WHERE n.id = "actions".nonconformity_id AND n.status IN ('open', 'planned') AND n.deleted_at IS NULL)`,
+)
+
+async function editAction(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  refuseActingSession(ctx)
+  const action = await findAction(env, id)
+  if (!action) throw new OneError(404, 'APP-E-404', 'Faaliyet bulunamadı.')
+  const now = nowIso()
+  if (method === 'DELETE') {
+    if (!changedOne(await removeWhen(env.DB, 'actions', { id, actor: user.sub, now, when: ACTION_OPEN }).run()))
+      throw new OneError(409, 'APP-E-022', 'Yalnız açık kayıttaki tamamlanmamış faaliyet silinebilir.')
+    logAudit(ctx, 'action.delete', id)
+    return new Response(null, { status: 204 })
+  }
+  const body = onlyFields(await readJsonObject(request), ACTION_FIELDS)
+  const record: Record<string, unknown> = {}
+  if ('description' in body) record.description = requiredText(body.description, 'description', 2000, true)
+  let owner: { id: string; name: string } | null = null
+  if ('owner' in body) {
+    owner = personValue(body.owner, 'owner')
+    if (!owner) throw fieldError('owner', 'Faaliyetin sorumlusunu seçin.')
+    Object.assign(record, { owner_org_id: owner.id, owner_name: clip(owner.name, 120) })
+  }
+  // Termin yalnız DEĞİŞTİYSE yeni termin kuralına tabidir: düzenleme formu termini her seferinde geri gönderir ve termini
+  // geçmiş (gecikmiş) bir faaliyetin açıklaması ya da sorumlusu, termini uzatmadan düzeltilebilmelidir.
+  const dueChanged = 'due_date' in body && body.due_date !== action.due_date
+  if (dueChanged) {
+    const due = checkDueDate(body.due_date, today())
+    if (!due.ok) throw fieldError('due_date', due.message)
+    record.due_date = due.value
+  }
+  if (Object.keys(record).length === 0) throw fieldError('', 'Değiştirilecek alan gönderilmedi.')
+  // Sorumlu ya da termin değişince hatırlatma damgası sıfırlanır (yeni termin geçerse yeniden hatırlatılır).
+  if ('owner' in body || dueChanged) record.reminded_on = null
+  const write = recordWrite(dataModel, 'actions', record, 'update')
+  // ⛔ Faaliyetin ve kaydın açık olması yazımla AYNI ifadededir. Termin "değişmedi" kararı okunan termine göre verilir ama
+  // o durumda termin YAZILMAZ: arada değişen termin olduğu gibi kalır (iki düzenlemenin bir sırayla yapılmasıyla aynı sonuç).
+  if (!(await applied(write, updateWhen(env.DB, write, { id, actor: user.sub, now, when: ACTION_OPEN }))))
+    throw new OneError(409, 'APP-E-022', 'Yalnız açık kayıttaki tamamlanmamış faaliyet değiştirilebilir.')
+  logAudit(ctx, 'action.update', id)
+  const after = (await findAction(env, id))!
+  const notification = owner && owner.id !== action.owner_org_id ? await notifyOwner(input, owner.id, action.nonconformity_title ?? '', after.description, after.due_date) : 'skipped'
+  return json({ action: after, notification })
+}
+
+async function complete(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireUser(ctx)
+  refuseActingSession(ctx)
+  const body = onlyFields(await readJsonObject(request), ['note'])
+  const action = await findAction(env, id)
+  const manager = hasPermission(ctx, MANAGE_PERMISSION)
+  let allowed = action !== null && manager
+  let me: { id: string; name: string } | null = null
+  if (action && !allowed) {
+    me = await myOrg(input.api()).catch(() => null)
+    allowed = me !== null && me.id === action.owner_org_id.toLowerCase()
+  }
+  // Başkasının faaliyeti ile hiç olmayan faaliyet aynı yanıtı alır.
+  if (!action || !allowed) throw new OneError(404, 'APP-E-404', 'Faaliyet bulunamadı.')
+  if (action.status === 'done') throw new OneError(409, 'APP-E-020', 'Faaliyet zaten tamamlandı.')
+  const note = requiredText(body.note, 'note', ACTION_NOTE_MAX, false)
+  const now = nowIso()
+  const write = recordWrite(dataModel, 'actions', { status: 'done', done_at: now, done_note: note, done_by_name: clip(me?.name || (await myName(input)), 120) }, 'update')
+  // ⛔ Yetki yazımla AYNI ifadededir: yönetici olmayan kişi faaliyeti yalnız HÂLÂ sorumlusuysa tamamlar (denetimden sonra
+  // faaliyet başkasına verildiyse yazım olmaz). Faaliyetin ve kaydın açık olması da aynı koşuldadır.
+  const owned = manager ? sql('') : sql('lower("actions".owner_org_id) = ?', me!.id)
+  if (!(await applied(write, updateWhen(env.DB, write, { id, actor: user.sub, now, when: and(ACTION_OPEN, owned) })))) {
+    const latest = await findAction(env, id)
+    if (!latest || (!manager && latest.owner_org_id.toLowerCase() !== me!.id)) throw new OneError(404, 'APP-E-404', 'Faaliyet bulunamadı.')
+    if (latest.status === 'done') throw new OneError(409, 'APP-E-020', 'Faaliyet zaten tamamlandı.')
+    throw new OneError(409, 'APP-E-022', 'Faaliyet bu durumdaki kayıtta tamamlanamaz.')
+  }
+  logAudit(ctx, 'action.complete', id)
+  return json({ action: await findAction(env, id) })
+}
+
+/** Faaliyetlerim: istemcinin gönderdiği sorumlu süzgeci YOK SAYILIR, sunucu kendi değerini yazar. */
+async function myActions(input: RouteInput<Env>): Promise<Response> {
+  const { request, env, ctx, url, method } = input
+  const rest = url.pathname.slice(myActionsList.path.length)
+  if (rest !== '' && rest !== '/export.xlsx' && rest !== '/export.csv' && rest !== '/report.html') throw new OneError(404, 'APP-E-404', 'Bulunamadı.')
+  if (method !== 'GET' && method !== 'HEAD') throw new OneError(405, 'APP-E-405', 'Bu liste yalnız okunur; faaliyeti tamamlamak için faaliyetin tamamlama ucunu kullanın.')
+  requireUser(ctx)
+  const me = await myOrg(input.api())
+  if (!me) throw new OneError(409, 'APP-E-010', 'Portalda kişi kaydınız bulunamadı; faaliyetleriniz gösterilemiyor.')
+  const scoped = withQuery(request, url.pathname, (params) => {
+    params.delete('owner_org_id')
+    params.set('owner_org_id', me.id)
+  })
+  return (await myActionsList.handle(scoped, env.DB, ctx))!
+}
+
+async function summary({ env, ctx }: RouteInput<Env>): Promise<Response> {
+  requirePermission(ctx, MANAGE_PERMISSION)
+  const [c, overdue, run] = await Promise.all([counts(env), overdueCount(env, today()), lastReminderRun(env)])
+  return json({ ...c, overdue, lastReminderRun: run ? { ...run, consent_needed: run.consent_needed === 1 } : null })
+}
+
+function readOnly(method: string, what: string): void {
+  if (method !== 'GET' && method !== 'HEAD') throw new OneError(405, 'APP-E-405', `${what} bu adresten değiştirilemez; uygulamanın işlem uçlarını kullanın.`)
+}
+
+async function routes(input: RouteInput<Env>): Promise<Response | null> {
+  const { url, method, env, ctx } = input
+  const path = url.pathname
+  if (path === '/api/files' && method === 'POST') return uploadFile(input.request, env.FILES, ctx)
+  if (path === '/api/summary' && method === 'GET') return summary(input)
+  if (path === myActionsList.path || path.startsWith(`${myActionsList.path}/`)) return myActions(input)
+  if (path === myReports.path || path.startsWith(`${myReports.path}/`)) {
+    readOnly(method, 'Kayıt')
+    return myReports.handle(input.request, env.DB, ctx)
+  }
+
+  if (path === records.path && method === 'POST') return report(input)
+  let id = matchId(path, records.path, 'status')
+  if (id && method === 'POST') return changeStatus(input, id)
+  id = matchId(path, records.path, 'detail')
+  if (id && method === 'GET') return detail(input, id)
+  id = matchId(path, records.path, 'attachment')
+  if (id && method === 'GET') return attachment(input, id)
+  id = matchId(path, records.path, 'actions')
+  if (id && method === 'POST') return addAction(input, id)
+  id = matchId(path, records.path)
+  if (id && method === 'PATCH') return edit(input, id)
+  if (path === records.path || path.startsWith(`${records.path}/`)) {
+    readOnly(method, 'Kayıt')
+    return records.handle(input.request, env.DB, ctx)
+  }
+
+  id = matchId(path, allActions.path, 'complete')
+  if (id && method === 'POST') return complete(input, id)
+  id = matchId(path, allActions.path)
+  if (id && (method === 'PATCH' || method === 'DELETE')) return editAction(input, id)
+  if (path === allActions.path || path.startsWith(`${allActions.path}/`)) {
+    readOnly(method, 'Faaliyet')
+    return allActions.handle(input.request, env.DB, ctx)
+  }
+  return null
+}
+
+export const definition: Omit<AppDefinition<Env>, 'guide'> = {
+  manifest,
+  tools: agentTools,
+  jobs,
+  page: renderShell,
+  script: renderShellScript,
+  routes,
+}
+
+export function buildApp(guide: string) {
+  return createApp<Env>({ ...definition, guide })
+}

package/templates/uygunsuzluk-dof/files/src/capa.test.ts.tpl

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { STATUSES, actionsEditable, checkDueDate, daysOverdue, formatDay, isOverdue, isStatus, istanbulDay, nextStatuses, reminderMessage, transitionRequirement } from './capa.ts'
+
+describe('durum akışı', () => {
+  it('yalnız tanımlı geçişler; her geçişin koşulu', () => {
+    expect(transitionRequirement('open', 'planned')).toBe('root-cause-and-action')
+    expect(transitionRequirement('planned', 'verification')).toBe('all-actions-done')
+    expect(transitionRequirement('verification', 'closed')).toBe('all-actions-done')
+    expect(transitionRequirement('verification', 'planned')).toBe('none')
+    // Atlama ve geri dönüş yok; kapanmış kayıt açılmaz.
+    expect(transitionRequirement('open', 'closed')).toBeNull()
+    expect(transitionRequirement('open', 'verification')).toBeNull()
+    expect(transitionRequirement('planned', 'open')).toBeNull()
+    for (const s of STATUSES) expect(transitionRequirement('closed', s)).toBeNull()
+    expect(nextStatuses('verification')).toEqual(['planned', 'closed'])
+    expect(nextStatuses('closed')).toEqual([])
+  })
+
+  it('faaliyetler yalnız açık ve planlandı durumunda değişir', () => {
+    expect(actionsEditable('open')).toBe(true)
+    expect(actionsEditable('planned')).toBe(true)
+    expect(actionsEditable('verification')).toBe(false)
+    expect(actionsEditable('closed')).toBe(false)
+    expect(isStatus('planned')).toBe(true)
+    expect(isStatus('kapali')).toBe(false)
+  })
+})
+
+describe('termin ve gecikme', () => {
+  it('termin: geçerli gün, bugün ya da sonrası, iki yıldan uzak değil', () => {
+    expect(checkDueDate('2026-10-20', '2026-10-20')).toEqual({ ok: true, value: '2026-10-20' })
+    expect(checkDueDate('2026-10-19', '2026-10-20')).toMatchObject({ ok: false })
+    expect(checkDueDate('2026-02-30', '2026-01-01')).toMatchObject({ ok: false })
+    expect(checkDueDate('2030-01-01', '2026-10-20')).toMatchObject({ ok: false })
+    expect(checkDueDate(20261020, '2026-10-20')).toMatchObject({ ok: false })
+  })
+
+  it('gecikme terminden SONRAKİ gün başlar; gün İstanbul saatine göredir', () => {
+    expect(isOverdue('2026-10-20', '2026-10-20')).toBe(false)
+    expect(isOverdue('2026-10-19', '2026-10-20')).toBe(true)
+    expect(daysOverdue('2026-10-15', '2026-10-20')).toBe(5)
+    expect(istanbulDay(new Date('2026-10-20T20:59:00Z'))).toBe('2026-10-20')
+    expect(istanbulDay(new Date('2026-10-20T21:00:00Z'))).toBe('2026-10-21')
+    expect(formatDay('2026-10-05')).toBe('05.10.2026')
+  })
+
+  it('hatırlatma metni faaliyeti, kaydı, termini ve gecikmeyi yazar', () => {
+    const m = reminderMessage([{ description: 'Yangın tüpünü yenile', nonconformity_title: 'Depo denetimi', due_date: '2026-10-15' }], '2026-10-20', 2)
+    expect(m.title).toBe('Termini geçmiş 3 düzeltici faaliyetiniz var')
+    expect(m.message).toContain('- Yangın tüpünü yenile (Depo denetimi): termin 15.10.2026, 5 gün gecikti')
+    expect(m.message).toContain('ve 2 faaliyet daha')
+  })
+})

package/templates/uygunsuzluk-dof/files/src/capa.ts.tpl

@@ -0,0 +1,114 @@
+// Uygunsuzluk ve düzeltici faaliyet kuralları — SAF fonksiyonlar (veritabanı ve ağ yok; `capa.test.ts` sınar). Durum
+// akışı YALNIZ sunucuda yürür; istemci durumu doğrudan yazamaz. Kuralı değiştiren bu dosyayı ve testini birlikte değiştirir.
+//
+//   açık ──► faaliyet planlandı ──► doğrulama ──► kapandı
+//                     ▲                  │
+//                     └──────────────────┘  (doğrulamada etkisiz bulundu: yeni faaliyet eklenecek)
+//
+//   açık → faaliyet planlandı   kök neden yazılmış ve en az bir faaliyet eklenmiş olmalı
+//   planlandı → doğrulama       bütün faaliyetler tamamlanmış olmalı; kayıt daha önce doğrulamada etkisiz bulunduysa o
+//                               andan SONRA eklenmiş en az bir faaliyet de olmalı (koşul `app.ts` → `changeStatus`'ta, SQL'de)
+//   doğrulama → kapandı         bütün faaliyetler tamamlanmış olmalı (kapanış notu isteğe bağlı)
+// Bütün geçişler yönetici (`…Manage`) işidir. Faaliyet yalnız "açık" ve "faaliyet planlandı" durumunda eklenir, değişir,
+// silinir ve tamamlanır.
+//
+// ⚠️ İş kuralıdır — keşif görüşmesinde kullanıcıyla netleştirin ("Kaydı kim kapatır?", "Doğrulama kim yapar?").
+export const STATUSES = ['open', 'planned', 'verification', 'closed'] as const
+export type NcStatus = (typeof STATUSES)[number]
+export type Requirement = 'root-cause-and-action' | 'all-actions-done' | 'none'
+
+const TRANSITIONS: Record<NcStatus, Partial<Record<NcStatus, Requirement>>> = {
+  open: { planned: 'root-cause-and-action' },
+  planned: { verification: 'all-actions-done' },
+  verification: { closed: 'all-actions-done', planned: 'none' },
+  closed: {},
+}
+
+/** Geciken faaliyet hatırlatmasında bir koşumda en çok kaç kişiye e-posta gider (kalanlar sonraki güne kalır). */
+export const REMINDER_OWNERS_PER_RUN = 8
+/** Bir hatırlatma e-postasında listelenen en çok faaliyet. */
+export const REMINDER_ACTIONS_PER_MAIL = 20
+/** Termin bugünden en çok bu kadar gün ileride olabilir (yanlış yazılan yılı yakalar). */
+export const DUE_DATE_MAX_DAYS = 730
+export const ACTION_NOTE_MAX = 500
+
+export function isStatus(value: unknown): value is NcStatus {
+  return typeof value === 'string' && (STATUSES as readonly string[]).includes(value)
+}
+
+/** Geçişin koşulu; geçiş yoksa `null`. */
+export function transitionRequirement(from: NcStatus, to: NcStatus): Requirement | null {
+  return TRANSITIONS[from][to] ?? null
+}
+
+/** Gidilebilecek durumlar (arayüz düğmeleri için). */
+export function nextStatuses(from: NcStatus): NcStatus[] {
+  return STATUSES.filter((to) => transitionRequirement(from, to) !== null)
+}
+
+/** Faaliyet eklenebilir / değiştirilebilir / tamamlanabilir mi? */
+export function actionsEditable(status: NcStatus): boolean {
+  return status === 'open' || status === 'planned'
+}
+
+/** İstanbul saatiyle gün (YYYY-AA-GG) — termin karşılaştırması ve "günde bir hatırlatma" anahtarı. */
+export function istanbulDay(at: Date): string {
+  return new Date(at.getTime() + 3 * 3_600_000).toISOString().slice(0, 10)
+}
+
+function isCalendarDay(value: string): boolean {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false
+  const d = new Date(`${value}T00:00:00Z`)
+  return !Number.isNaN(d.getTime()) && d.toISOString().slice(0, 10) === value
+}
+
+function addDays(day: string, days: number): string {
+  return new Date(Date.parse(`${day}T00:00:00Z`) + days * 86_400_000).toISOString().slice(0, 10)
+}
+
+export type DueDateCheck = { ok: true; value: string } | { ok: false; message: string }
+
+/** Termin: geçerli bir gün, bugün ya da sonrası, en çok DUE_DATE_MAX_DAYS gün ileride. */
+export function checkDueDate(raw: unknown, today: string): DueDateCheck {
+  if (typeof raw !== 'string' || !isCalendarDay(raw)) return { ok: false, message: 'Termin YYYY-AA-GG biçiminde geçerli bir tarih olmalı.' }
+  if (raw < today) return { ok: false, message: 'Termin geçmiş bir tarih olamaz.' }
+  if (raw > addDays(today, DUE_DATE_MAX_DAYS)) return { ok: false, message: `Termin en çok ${DUE_DATE_MAX_DAYS} gün ileride olabilir.` }
+  return { ok: true, value: raw }
+}
+
+/** Termin bugünden önceyse faaliyet gecikmiştir (terminin günü gecikme sayılmaz). */
+export function isOverdue(dueDate: string, today: string): boolean {
+  return dueDate < today
+}
+
+export function daysOverdue(dueDate: string, today: string): number {
+  return Math.max(0, Math.round((Date.parse(`${today}T00:00:00Z`) - Date.parse(`${dueDate}T00:00:00Z`)) / 86_400_000))
+}
+
+/** YYYY-AA-GG → gg.aa.yyyy */
+export function formatDay(day: string): string {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(day)
+  return m ? `${m[3]}.${m[2]}.${m[1]}` : day
+}
+
+export interface OverdueItem {
+  description: string
+  nonconformity_title: string | null
+  due_date: string
+}
+
+/** Hatırlatma e-postasının metni (düz metin; sunucu markalı şablona sarar). */
+export function reminderMessage(items: readonly OverdueItem[], today: string, more = 0): { title: string; message: string } {
+  const lines = items.map((item) => {
+    const text = item.description.replace(/\s+/g, ' ').trim()
+    const clipped = [...text].length > 160 ? `${[...text].slice(0, 159).join('')}…` : text
+    const where = item.nonconformity_title ? ` (${item.nonconformity_title})` : ''
+    return `- ${clipped}${where}: termin ${formatDay(item.due_date)}, ${daysOverdue(item.due_date, today)} gün gecikti`
+  })
+  if (more > 0) lines.push(`- ve ${more} faaliyet daha`)
+  const total = items.length + more
+  return {
+    title: `Termini geçmiş ${total} düzeltici faaliyetiniz var`,
+    message: ['Size atanan şu düzeltici faaliyetlerin termini geçti:', '', ...lines, '', 'Uygulamanın Faaliyetlerim sekmesinden tamamlayabilirsiniz.'].join('\n'),
+  }
+}