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

package/templates/egitim-sertifika/files/AGENT_GUIDE.md.tpl

@@ -0,0 +1,53 @@
+# {{nameTr}} — Devoplus yapay zekâsı için rehber
+
+Bu dosyayı **Devoplus yapay zekâsı** okur (uygulama adresinde `/.well-known/one-agent.md`). Bir aracı eklerken,
+değiştirirken ya da kaldırırken bu dosyayı AYNI değişiklikte güncelleyin; yayın kapısı dört başlığı ve her aracın adını
+arar.
+
+## Uygulama ne yapar
+
+{{nameTr}}, çalışanların eğitim ve sertifikalarını izler. Her kayıt bir kişiye ve bir sertifika türüne aittir; geçerlilik
+sonu, tamamlanma tarihi ve türün geçerlilik süresinden (ay) hesaplanır. Süresi 30 gün içinde dolacak ya da dolmuş
+sertifikalar için kişiye ve yöneticisine her sabah bir kez e-posta gider. Aynı kişiye aynı türden daha yeni bir kayıt
+girilince eski kayıt "yenilendi" sayılır. Kullanıcı "hangi sertifikaların süresi doluyor", "iş güvenliği eğitimi kaç ay
+geçerli" gibi şeyler sorduğunda bu uygulamaya başvurun. Kayıt girmek için araç yoktur.
+
+## Veri
+
+- **Sertifika türü** (`cert_types`): ad (tekil), geçerlilik süresi (ay; boşsa süresiz), açıklama, kullanımda mı.
+- **Kayıt** (`certificates`): kişinin adı, yöneticisinin adı (organizasyon şemasından), tür, tamamlanma tarihi,
+  geçerlilik sonu, belge numarası, isteğe bağlı belge dosyası.
+- **Günlük hatırlatma kontrolü** (`reminder_runs`): her sabah 08:00'de (Türkiye saati) kaç kaydın hatırlatılacağı ve kaç
+  e-posta gittiği.
+- Durumlar: `expired` (süresi doldu), `expiring` (30 gün içinde doluyor, bugün dahil), `valid` (geçerli), `renewed`
+  (yenilendi), `no-expiry` (süresiz). Tarihler `YYYY-AA-GG` biçimindedir; kullanıcıya `gg.aa.yyyy` olarak söyleyin.
+- Kayıtlar kişisel veridir: bütün kayıtları yalnız eğitim sorumlusu görür. Bir çalışan kendi kayıtlarını, yönetici
+  ekibininkileri uygulamanın ekranında görür.
+
+## Araçlar
+
+### `expiring-certificates` — süresi yaklaşan sertifikalar (salt okunur)
+
+- **Ne zaman:** eğitim sorumlusu süresi dolan ya da dolacak sertifikaları, yenilenmesi gereken eğitimleri sorduğunda.
+- **Kim:** yalnız eğitim sorumlusu izni olanlar. İzni olmayan kullanıcı için araç çağrılamaz; ona kendi kayıtlarını
+  uygulamanın Sertifikalarım sekmesinde görebileceğini söyleyin.
+- **Girdi:** `days` — bugünden itibaren kaç gün (0-365, varsayılan 30; dolmuş olanlar her zaman dahil); `limit` (1-50,
+  varsayılan 20).
+- **Çıktı:** `{ "today": "2026-10-20", "until": "2026-11-19", "count": 3, "items": [{ "person_name", "manager_name",
+  "type_name", "expires_on", "days_left", "status" }] }` — en acil olan önce; yenilenmiş kayıtlar yoktur; `count` tam
+  sayıdır. `days_left` eksiyse süre o kadar gün önce dolmuştur.
+
+### `certificate-types` — sertifika türleri (salt okunur)
+
+- **Ne zaman:** kullanıcı hangi eğitim ve sertifikaların izlendiğini ya da bir türün kaç ay geçerli olduğunu sorduğunda.
+- **Girdi:** yok.
+- **Çıktı:** `{ "items": [{ "name", "validity_months", "description" }] }` — `validity_months` `null` ise tür süresizdir.
+  Kişisel veri içermez.
+
+## Örnek istekler
+
+- "Önümüzdeki ay hangi sertifikaların süresi doluyor?" → `expiring-certificates` (`days: 30`)
+- "Süresi geçmiş sertifika var mı?" → `expiring-certificates` (`days: 0`) → `status: "expired"` olanlar
+- "Forklift operatörlüğü belgesi kaç yıl geçerli?" → `certificate-types` → `validity_months` (ay; yıla çevirin)
+- "Ahmet'in ilk yardım sertifikasını yeniledim, kaydet." → araç yok; kullanıcıyı uygulamanın Tüm kayıtlar sekmesine
+  yönlendirin.

package/templates/egitim-sertifika/files/one.data.json

@@ -0,0 +1,43 @@
+{
+  "version": 1,
+  "entities": {
+    "cert_types": {
+      "title": { "tr": "Sertifika türleri", "en": "Certificate types" },
+      "fields": {
+        "name": { "type": "text", "title": { "tr": "Ad", "en": "Name" }, "required": true, "unique": true, "maxLength": 120 },
+        "validity_months": { "type": "number", "title": { "tr": "Geçerlilik (ay)", "en": "Validity (months)" }, "min": 1, "max": 240 },
+        "description": { "type": "text", "title": { "tr": "Açıklama", "en": "Description" }, "maxLength": 300 },
+        "active": { "type": "boolean", "title": { "tr": "Kullanımda", "en": "In use" }, "required": true, "default": true }
+      }
+    },
+    "certificates": {
+      "title": { "tr": "Eğitim ve sertifika kayıtları", "en": "Training and certificate records" },
+      "fields": {
+        "person_org_id": { "type": "text", "title": { "tr": "Kişi (kimlik)", "en": "Person (id)" }, "required": true, "maxLength": 24, "index": true },
+        "person_name": { "type": "text", "title": { "tr": "Kişi", "en": "Person" }, "maxLength": 120 },
+        "manager_org_id": { "type": "text", "title": { "tr": "Yönetici (kimlik)", "en": "Manager (id)" }, "maxLength": 24, "index": true },
+        "manager_name": { "type": "text", "title": { "tr": "Yönetici", "en": "Manager" }, "maxLength": 120 },
+        "type_id": { "type": "text", "title": { "tr": "Tür", "en": "Type" }, "required": true, "maxLength": 36, "index": true },
+        "type_name": { "type": "text", "title": { "tr": "Sertifika", "en": "Certificate" }, "maxLength": 120 },
+        "completed_on": { "type": "date", "title": { "tr": "Tamamlanma tarihi", "en": "Completed on" }, "required": true, "index": true },
+        "expires_on": { "type": "date", "title": { "tr": "Geçerlilik sonu", "en": "Expires on" }, "index": true },
+        "certificate_no": { "type": "text", "title": { "tr": "Belge numarası", "en": "Certificate number" }, "maxLength": 60 },
+        "attachment": { "type": "file", "title": { "tr": "Belge", "en": "Document" } },
+        "attachment_name": { "type": "text", "title": { "tr": "Belge dosyası", "en": "Document file" }, "maxLength": 200 },
+        "reminder_sent_for": { "type": "date", "title": { "tr": "Hatırlatılan geçerlilik sonu", "en": "Reminded expiry" } },
+        "manager_reminder_sent_for": { "type": "date", "title": { "tr": "Yöneticiye hatırlatılan geçerlilik sonu", "en": "Expiry reminded to manager" } },
+        "reminder_failed_on": { "type": "date", "title": { "tr": "Hatırlatmanın ulaşmadığı son gün", "en": "Last undelivered reminder" } }
+      }
+    },
+    "reminder_runs": {
+      "title": { "tr": "Günlük hatırlatma kontrolleri", "en": "Daily reminder checks" },
+      "fields": {
+        "run_key": { "type": "text", "title": { "tr": "Kontrol günü", "en": "Check day" }, "required": true, "unique": true, "maxLength": 20 },
+        "due_count": { "type": "number", "title": { "tr": "Hatırlatılacak sertifika", "en": "Certificates to remind" }, "required": true, "default": 0, "min": 0 },
+        "sent_count": { "type": "number", "title": { "tr": "Gönderilen e-posta", "en": "E-mails sent" }, "required": true, "default": 0, "min": 0 },
+        "waiting_count": { "type": "number", "title": { "tr": "Gönderilemeyen e-posta", "en": "E-mails not sent" }, "required": true, "default": 0, "min": 0 },
+        "consent_needed": { "type": "boolean", "title": { "tr": "E-posta onayı bekleniyor", "en": "E-mail approval pending" }, "required": true, "default": false }
+      }
+    }
+  }
+}

package/templates/egitim-sertifika/files/src/agent.ts.tpl

@@ -0,0 +1,22 @@
+// Devoplus yapay zekâsının bu uygulamada çağırabileceği araçların İŞLEYİCİLERİ. Adı, açıklaması, girdi şeması,
+// salt-okunurluğu ve izni `one.manifest.json` → `agent.tools`'tadır; rehber `AGENT_GUIDE.md`'dir. Yeni araç = üçü birlikte.
+// Araçlar yalnız uygulamanın KENDİ veritabanını okur. ⛔ Kişisel veri döndüren `expiring-certificates` manifest'te
+// eğitim sorumlusu iznine (`…Manage`) bağlıdır: platform izni olmayan kişinin çağrısını araca ulaştırmaz. Kayıt YAZAN
+// araç bilinçli olarak yoktur.
+import { defineAgentTools } from '@devoplus/one-sdk'
+import type { Env } from './app.ts'
+import { todayKey } from './certificate.ts'
+import { activeTypes, expiring } from './queries.ts'
+
+export const agentTools = defineAgentTools<Env>({
+  'expiring-certificates': {
+    handler: async ({ input, env }) => {
+      const days = typeof input.days === 'number' ? input.days : 30
+      const limit = typeof input.limit === 'number' ? input.limit : 20
+      return expiring(env, todayKey(new Date()), days, limit)
+    },
+  },
+  'certificate-types': {
+    handler: async ({ env }) => activeTypes(env),
+  },
+})

package/templates/egitim-sertifika/files/src/app.ts.tpl

@@ -0,0 +1,312 @@
+// {{nameTr}} — eğitim ve sertifika takibi. Uçlar (hepsi oturum ister; kimlik platformdan gelir):
+//   GET    /api/my/certificates[/export.xlsx]          kendi kayıtlarım (herkes) — kişi oturumdan, SUNUCUDA çözülür
+//   GET    /api/team/certificates[/export.xlsx]        ekibimin kayıtları — ekip org şemasından SUNUCUDA çözülür
+//                                                      (işlevsel yöneticisi ben olan aktif kişiler); ekibi olmayana 403
+//   GET    /api/certificates[?…]                        bütün kayıtlar (eğitim sorumlusu) — hazır liste + Excel
+//   POST   /api/certificates · PATCH/DELETE /api/certificates/{id}   kayıt yazma (eğitim sorumlusu)
+//                                                      ⛔ geçerlilik sonu ve yönetici istemciden ALINMAZ
+//   POST   /api/certificates/refresh-managers           kayıtlardaki yöneticiyi org şemasından yeniler (eğitim sorumlusu)
+//   GET    /api/certificates/{id}/attachment            belge: kişinin kendisi, doğrudan yöneticisi ya da eğitim sorumlusu
+//   GET    /api/cert_types[?…] · POST/PATCH/DELETE      sertifika türleri (okuma herkes, yazma eğitim sorumlusu)
+//   POST   /api/files                                   dosya yükleme (eğitim sorumlusu; yalnız kendi ön ekine)
+//   GET    /api/summary                                 dolmuş / dolacak sayısı, son hatırlatma kontrolü (eğitim sorumlusu)
+import {
+  OneError,
+  approvalChainReport,
+  createCrudHandler,
+  exportResponse,
+  getMyOrgContext,
+  getOrgUsersWithManagers,
+  hasPermission,
+  logAudit,
+  requirePermission,
+  requireUser,
+  toXlsx,
+  type ExportColumn,
+  type MyOrgContext,
+  type OneFilesBinding,
+} from '@devoplus/one-sdk'
+import manifest from '../one.manifest.json' with { type: 'json' }
+import { agentTools } from './agent.ts'
+import { checkCompletionDate, checkValidity, expiryDate, isDirectReport, teamOf, todayKey } from './certificate.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 } from './lib/http.ts'
+import { createApp, json, type AppDefinition, type BaseEnv, type RouteInput } from './lib/server.ts'
+import { MANAGE_PERMISSION } from './names.ts'
+import { EXPORT_MAX, certificatesOf, counts, lastRun } from './queries.ts'
+import { renderShell, renderShellScript } from './shell.ts'
+
+export { APP_NAME, MANAGE_PERMISSION } from './names.ts'
+
+export interface Env extends BaseEnv {
+  /** Bu kurulumun dosya deposu (manifest services.files): sertifika belgeleri. */
+  FILES: OneFilesBinding
+}
+
+/** Bütün kayıtlar: yalnız eğitim sorumlusu okur ve yazar (kişisel veri). */
+export const certificates = createCrudHandler({ model: dataModel, entity: 'certificates', records: 'shared', canRead: MANAGE_PERMISSION, canWrite: MANAGE_PERMISSION })
+export const certTypes = createCrudHandler({ model: dataModel, entity: 'cert_types', records: 'shared', canWrite: MANAGE_PERMISSION })
+
+const MY_PATH = '/api/my/certificates'
+const TEAM_PATH = '/api/team/certificates'
+const TYPE_FIELDS = ['name', 'validity_months', 'description', 'active']
+
+const today = (): string => todayKey(new Date())
+
+async function me(input: RouteInput<Env>): Promise<MyOrgContext> {
+  const ctx = await getMyOrgContext(input.api())
+  if (!ctx) throw new OneError(409, 'APP-E-010', 'Portalda kişi kaydınız bulunamadı; sertifika kayıtlarınız gösterilemiyor. Portal yöneticinize başvurun.')
+  return ctx
+}
+
+function fileValue(raw: unknown, sub: string): { attachment: string | null; attachment_name: string | null } {
+  const attachment = ownFileKey(raw, sub, 'attachment')
+  const name =
+    attachment && typeof raw === 'object' && raw !== null && typeof (raw as { name?: unknown }).name === 'string' ? (raw as { name: string }).name.slice(0, 200) : null
+  return { attachment, attachment_name: name }
+}
+
+/**
+ * Sertifika türü. `active`: yeni kayıtta yalnız kullanımdaki (silinmemiş ve etkin) tür seçilebilir. `any`: var olan kaydın
+ * geçerlilik sonu yeniden hesaplanırken SİLİNMİŞ tür de okunur — tür silinse de geçerlilik süresi satırında durur; aksi
+ * hâlde süreli bir sertifika sessizce süresize dönerdi.
+ */
+async function typeOf(env: Env, id: unknown, mode: 'active' | 'any') {
+  if (typeof id !== 'string' || id === '') return null
+  return env.DB.prepare(`SELECT id, name, validity_months FROM "cert_types" WHERE id = ?${mode === 'active' ? ' AND deleted_at IS NULL AND active = 1' : ''}`)
+    .bind(id)
+    .first<{ id: string; name: string; validity_months: number | null }>()
+}
+
+async function createCertificate(input: RouteInput<Env>): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  const body = onlyFields(await readJsonObject(request), ['person', 'type_id', 'completed_on', 'certificate_no', 'attachment'])
+  const person = personValue(body.person, 'person')
+  if (!person) throw fieldError('person', 'Kişiyi seçin.')
+  const type = await typeOf(env, body.type_id, 'active')
+  if (!type) throw fieldError('type_id', 'Kullanımdaki bir sertifika türü seçin.')
+  const completed = checkCompletionDate(body.completed_on, today())
+  if (!completed.ok) throw fieldError('completed_on', completed.message)
+  // Kişi ve yöneticisi organizasyon şemasından SUNUCUDA çözülür (pasifler de gelir ki ayrılmış yönetici atlanabilsin).
+  const users = await getOrgUsersWithManagers(input.api(), { includeInactive: true })
+  const org = users.find((u) => u.id.toLowerCase() === person.id)
+  if (!org || !org.isActive) throw fieldError('person', 'Kişi bu portalın organizasyon şemasında bulunamadı.')
+  const manager = approvalChainReport(users, org.id, { maxDepth: 1 }).chain[0]?.toLowerCase() ?? null
+  const record = {
+    person_org_id: person.id,
+    person_name: org.fullName || person.name || null,
+    manager_org_id: manager,
+    manager_name: manager ? users.find((u) => u.id.toLowerCase() === manager)?.fullName || null : null,
+    type_id: type.id,
+    type_name: type.name,
+    completed_on: completed.value,
+    expires_on: expiryDate(completed.value, type.validity_months),
+    certificate_no: body.certificate_no ?? null,
+    ...fileValue(body.attachment, user.sub),
+  }
+  const res = (await certificates.handle(forward(request, certificates.path, 'POST', record), env.DB, ctx))!
+  if (res.status === 201) logAudit(ctx, 'certificate.create', person.id, { type: type.id })
+  return res
+}
+
+async function updateCertificate(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  if (method === 'DELETE') return (await certificates.handle(request, env.DB, ctx))!
+  // Kişi ve tür değiştirilmez (yanlışsa kayıt silinip yeniden girilir); geçerlilik sonu tamamlanma tarihinden hesaplanır.
+  const body = onlyFields(await readJsonObject(request), ['completed_on', 'certificate_no', 'attachment'])
+  const current = await env.DB.prepare('SELECT type_id, attachment FROM "certificates" WHERE id = ? AND deleted_at IS NULL').bind(id).first<{ type_id: string; attachment: string | null }>()
+  if (!current) throw new OneError(404, 'APP-E-404', 'Kayıt bulunamadı.')
+  const patch: Record<string, unknown> = {}
+  if ('certificate_no' in body) patch.certificate_no = body.certificate_no
+  // Kayıttaki belge olduğu gibi geri gönderildiyse dokunulmaz; YENİ belge yalnız güncelleyenin kendi ön ekinden olabilir.
+  const sentKey = typeof body.attachment === 'object' && body.attachment !== null ? (body.attachment as { key?: unknown }).key : body.attachment
+  if ('attachment' in body && !(current.attachment !== null && sentKey === current.attachment)) Object.assign(patch, fileValue(body.attachment, user.sub))
+  if ('completed_on' in body) {
+    const completed = checkCompletionDate(body.completed_on, today())
+    if (!completed.ok) throw fieldError('completed_on', completed.message)
+    const type = await typeOf(env, current.type_id, 'any')
+    // Tür kaydı hiç yoksa geçerlilik süresi bilinmez: "süresiz" saymak yerine düzenleme reddedilir.
+    if (!type) throw new OneError(409, 'APP-E-409', 'Kaydın sertifika türü bulunamadığı için geçerlilik sonu hesaplanamıyor; kaydı silip yeniden girin.')
+    patch.completed_on = completed.value
+    patch.expires_on = expiryDate(completed.value, type.validity_months)
+  }
+  return (await certificates.handle(forward(request, `${certificates.path}/${id}`, 'PATCH', patch), env.DB, ctx))!
+}
+
+/** Kayıtlardaki yöneticiyi org şemasından yeniler: hatırlatma e-postası kişinin BUGÜNKÜ yöneticisine gitsin. */
+async function refreshManagers(input: RouteInput<Env>): Promise<Response> {
+  const { env, ctx } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  const users = await getOrgUsersWithManagers(input.api(), { includeInactive: true })
+  const people = await env.DB.prepare('SELECT DISTINCT person_org_id AS id FROM "certificates" WHERE deleted_at IS NULL').all<{ id: string }>()
+  const now = nowIso()
+  const statements = people.results.map(({ id }) => {
+    const org = users.find((u) => u.id.toLowerCase() === id.toLowerCase())
+    const manager = org ? (approvalChainReport(users, org.id, { maxDepth: 1 }).chain[0]?.toLowerCase() ?? null) : null
+    const name = manager ? users.find((u) => u.id.toLowerCase() === manager)?.fullName || null : null
+    // Değişen metin alanlarının arama kolonu (`<alan>_fold`) NULL yapılır: arama boş kolonda metni kendisi katlar.
+    // Yönetici DEĞİŞTİYSE yöneticiye hatırlatma damgası sıfırlanır: eski yöneticiye gitmiş hatırlatma yenisine gitmiş
+    // sayılmaz (sağ taraftaki `manager_org_id` satırın güncellemeden önceki değeridir).
+    return env.DB.prepare(
+      'UPDATE "certificates" SET manager_org_id = ?, manager_name = ?, manager_org_id_fold = NULL, manager_name_fold = NULL, ' +
+        "manager_reminder_sent_for = CASE WHEN lower(coalesce(manager_org_id, '')) = lower(coalesce(?, '')) THEN manager_reminder_sent_for ELSE NULL END, updated_at = ?, updated_by = ? " +
+        'WHERE person_org_id = ? AND deleted_at IS NULL AND (manager_org_id IS NOT ? OR manager_name IS NOT ?)',
+    ).bind(manager, name, manager, now, user.sub, id, manager, name)
+  })
+  const results = statements.length ? await env.DB.batch(statements) : []
+  const updated = results.reduce((n, r) => n + Number(r.meta.changes ?? 0), 0)
+  logAudit(ctx, 'certificate.refresh-managers', 'all', { updated })
+  return json({ updated })
+}
+
+/** Belgeyi kişinin kendisi, doğrudan yöneticisi (org şemasından) ya da eğitim sorumlusu indirir; başkasına "yok" (404). */
+async function attachmentOf(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { env, ctx } = input
+  requireUser(ctx)
+  const row = await env.DB.prepare('SELECT person_org_id, attachment FROM "certificates" WHERE id = ? AND deleted_at IS NULL').bind(id).first<{ person_org_id: string; attachment: string | null }>()
+  let allowed = row !== null && hasPermission(ctx, MANAGE_PERMISSION)
+  if (row && !allowed) {
+    const self = await getMyOrgContext(input.api())
+    allowed =
+      self !== null &&
+      (self.orgUserId.toLowerCase() === row.person_org_id.toLowerCase() || isDirectReport(await getOrgUsersWithManagers(input.api()), self.orgUserId, row.person_org_id))
+  }
+  if (!row || !allowed || !row.attachment) throw new OneError(404, 'APP-E-404', 'Belge bulunamadı.')
+  return fileResponse(env.FILES, row.attachment)
+}
+
+const EXPORT_COLUMNS: ExportColumn[] = [
+  { key: 'person_name', title: { tr: 'Kişi', en: 'Person' } },
+  { key: 'type_name', title: { tr: 'Sertifika', en: 'Certificate' } },
+  { key: 'completed_on', title: { tr: 'Tamamlanma tarihi', en: 'Completed on' }, type: 'date' },
+  { key: 'expires_on', title: { tr: 'Geçerlilik sonu', en: 'Expires on' }, type: 'date' },
+  {
+    key: 'status',
+    title: { tr: 'Durum', en: 'Status' },
+    labels: {
+      valid: { tr: 'Geçerli', en: 'Valid' },
+      expiring: { tr: 'Süresi doluyor', en: 'Expiring' },
+      expired: { tr: 'Süresi doldu', en: 'Expired' },
+      renewed: { tr: 'Yenilendi', en: 'Renewed' },
+      'no-expiry': { tr: 'Süresiz', en: 'No expiry' },
+    },
+  },
+  { key: 'certificate_no', title: { tr: 'Belge numarası', en: 'Certificate number' } },
+]
+
+/**
+ * Liste ya da Excel. Kişi listesi `people` ile sunucuda çözülmüş gelir. Ekran en çok `LIST_MAX` kayıt gösterir ve kesildiyse
+ * `truncated: true` döner; Excel en çok `EXPORT_MAX` kayıt aktarır ve fazlası varsa EKSİK dosya üretmek yerine reddeder.
+ */
+async function listResponse(input: RouteInput<Env>, base: string, people: readonly string[], extra: Record<string, unknown>, fileName: string): Promise<Response> {
+  const rest = input.url.pathname.slice(base.length)
+  if (rest === '/export.xlsx') {
+    const { items, truncated } = await certificatesOf(input.env, people, today(), EXPORT_MAX)
+    if (truncated) throw new OneError(400, 'APP-E-400', `Aktarılacak kayıt sayısı ${EXPORT_MAX} sınırını aşıyor; eksik dosya üretilmedi.`)
+    const lang = input.url.searchParams.get('lang') === 'en' ? 'en' : 'tr'
+    return exportResponse(toXlsx(items.map((i) => ({ ...i })), EXPORT_COLUMNS, { lang, sheetName: fileName }), { fileName, format: 'xlsx' })
+  }
+  const { items, truncated } = await certificatesOf(input.env, people, today())
+  return json({ today: today(), items, truncated, ...extra })
+}
+
+/** Kendi kayıtlarım: kişi oturumdan çözülür; istemci başka bir kişi gönderemez. */
+async function myList(input: RouteInput<Env>): Promise<Response> {
+  requireUser(input.ctx)
+  const self = await me(input)
+  return listResponse(input, MY_PATH, [self.orgUserId], {}, 'Sertifikalarım')
+}
+
+/** Ekibimin kayıtları: ekip org şemasından sunucuda çözülür; ekibi olmayan kişiye görünüm kapalıdır (403). */
+async function teamList(input: RouteInput<Env>): Promise<Response> {
+  requireUser(input.ctx)
+  const self = await me(input)
+  const team = teamOf(await getOrgUsersWithManagers(input.api()), self.orgUserId)
+  if (team.length === 0) throw new OneError(403, 'APP-E-403', 'Bu görünüm, organizasyon şemasında kendisine bağlı çalışanı olan yöneticilere açıktır.')
+  return listResponse(
+    input,
+    TEAM_PATH,
+    team.map((u) => u.id),
+    { team: team.map((u) => ({ id: u.id.toLowerCase(), name: u.fullName })) },
+    'Ekibimin sertifikaları',
+  )
+}
+
+async function typeWrite(input: RouteInput<Env>, id: string | null): Promise<Response> {
+  const { request, env, ctx, method } = input
+  requirePermission(ctx, MANAGE_PERMISSION)
+  if (id && method === 'DELETE') return (await certTypes.handle(request, env.DB, ctx))!
+  const body = onlyFields(await readJsonObject(request), TYPE_FIELDS)
+  if ('validity_months' in body) {
+    const validity = checkValidity(body.validity_months)
+    if (!validity.ok) throw fieldError('validity_months', validity.message)
+    body.validity_months = validity.value
+  }
+  return (await certTypes.handle(forward(request, id ? `${certTypes.path}/${id}` : certTypes.path, id ? 'PATCH' : 'POST', body), env.DB, ctx))!
+}
+
+async function summary({ env, ctx }: RouteInput<Env>): Promise<Response> {
+  requirePermission(ctx, MANAGE_PERMISSION)
+  const day = today()
+  const [c, run] = await Promise.all([counts(env, day), lastRun(env)])
+  return json({ today: day, ...c, lastRun: run ? { ...run, consent_needed: run.consent_needed === 1 } : null })
+}
+
+function readOnly(input: RouteInput<Env>): void {
+  if (input.method !== 'GET' && input.method !== 'HEAD') throw new OneError(405, 'APP-E-405', 'Bu liste yalnız okunur.')
+}
+
+async function routes(input: RouteInput<Env>): Promise<Response | null> {
+  const { url, method, env, ctx } = input
+  const path = url.pathname
+  if (path === MY_PATH || path === `${MY_PATH}/export.xlsx`) {
+    readOnly(input)
+    return myList(input)
+  }
+  if (path === TEAM_PATH || path === `${TEAM_PATH}/export.xlsx`) {
+    readOnly(input)
+    return teamList(input)
+  }
+  if (path === '/api/summary' && method === 'GET') return summary(input)
+  if (path === '/api/files' && method === 'POST') {
+    requirePermission(ctx, MANAGE_PERMISSION)
+    return uploadFile(input.request, env.FILES, ctx)
+  }
+
+  if (path === `${certificates.path}/refresh-managers` && method === 'POST') return refreshManagers(input)
+  const attachmentId = matchId(path, certificates.path, 'attachment')
+  if (attachmentId && method === 'GET') return attachmentOf(input, attachmentId)
+  if (path === certificates.path && method === 'POST') return createCertificate(input)
+  const certificateId = matchId(path, certificates.path)
+  if (certificateId && (method === 'PATCH' || method === 'PUT' || method === 'DELETE')) {
+    if (method === 'PUT') throw new OneError(405, 'APP-E-405', 'Kayıt PATCH ile güncellenir.')
+    return updateCertificate(input, certificateId)
+  }
+  if (path === certificates.path || path.startsWith(`${certificates.path}/`)) return certificates.handle(input.request, env.DB, ctx)
+
+  if (path === certTypes.path && method === 'POST') return typeWrite(input, null)
+  const typeId = matchId(path, certTypes.path)
+  if (typeId && (method === 'PATCH' || method === 'PUT' || method === 'DELETE')) {
+    if (method === 'PUT') throw new OneError(405, 'APP-E-405', 'Tür PATCH ile güncellenir.')
+    return typeWrite(input, typeId)
+  }
+  if (path === certTypes.path || path.startsWith(`${certTypes.path}/`)) return certTypes.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/egitim-sertifika/files/src/certificate.test.ts.tpl

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest'
+import { addMonths, certStatus, checkCompletionDate, checkValidity, expiryDate, groupByPerson, isDirectReport, teamOf, todayKey, type OrgPerson } from './certificate.ts'
+
+describe('sertifika kuralları', () => {
+  it('geçerlilik sonu = tamamlanma + ay; ayın son günü korunur; süresiz türde yok', () => {
+    expect(addMonths('2026-01-31', 1)).toBe('2026-02-28')
+    expect(addMonths('2028-01-31', 1)).toBe('2028-02-29')
+    expect(addMonths('2026-03-15', 12)).toBe('2027-03-15')
+    expect(addMonths('2026-11-30', 3)).toBe('2027-02-28')
+    expect(expiryDate('2026-05-10', 24)).toBe('2028-05-10')
+    expect(expiryDate('2026-05-10', null)).toBeNull()
+  })
+
+  it('geçerlilik süresi: boş = süresiz; tam ay ve sınırlar içinde', () => {
+    expect(checkValidity('')).toEqual({ ok: true, value: null })
+    expect(checkValidity(null)).toEqual({ ok: true, value: null })
+    expect(checkValidity(12)).toEqual({ ok: true, value: 12 })
+    expect(checkValidity(1.5)).toMatchObject({ ok: false })
+    expect(checkValidity(0)).toMatchObject({ ok: false })
+    expect(checkValidity(241)).toMatchObject({ ok: false })
+  })
+
+  it('tamamlanma tarihi: geçerli gün, ileri tarih ve çok eski tarih reddedilir', () => {
+    expect(checkCompletionDate('2026-10-20', '2026-10-20')).toEqual({ ok: true, value: '2026-10-20' })
+    expect(checkCompletionDate('2026-10-21', '2026-10-20')).toMatchObject({ ok: false })
+    expect(checkCompletionDate('2026-02-30', '2026-10-20')).toMatchObject({ ok: false })
+    expect(checkCompletionDate('1999-01-01', '2026-10-20')).toMatchObject({ ok: false })
+  })
+
+  it('durum: yenilenen, süresiz, dolmuş, dolmak üzere (30 gün, bugün dahil), geçerli', () => {
+    expect(certStatus('2026-10-01', '2026-10-20', true)).toBe('renewed')
+    expect(certStatus(null, '2026-10-20', false)).toBe('no-expiry')
+    expect(certStatus('2026-10-19', '2026-10-20', false)).toBe('expired')
+    expect(certStatus('2026-10-20', '2026-10-20', false)).toBe('expiring')
+    expect(certStatus('2026-11-19', '2026-10-20', false)).toBe('expiring')
+    expect(certStatus('2026-11-20', '2026-10-20', false)).toBe('valid')
+  })
+
+  it('ekip: işlevsel yöneticisi ben olan AKTİF kişiler; büyük/küçük harf duyarsız', () => {
+    const p = (id: string, manager: string, isActive = true): OrgPerson => ({ id, fullName: id, functionalManager: manager, isActive })
+    const boss = 'a'.repeat(24)
+    const users = [p('b'.repeat(24), boss), p('c'.repeat(24), 'A'.repeat(24)), p('d'.repeat(24), boss, false), p('e'.repeat(24), 'f'.repeat(24))]
+    expect(teamOf(users, boss).map((u) => u.id)).toEqual(['b'.repeat(24), 'c'.repeat(24)])
+    expect(isDirectReport(users, boss, 'C'.repeat(24))).toBe(true)
+    expect(isDirectReport(users, boss, 'e'.repeat(24))).toBe(false)
+    expect(teamOf(users, 'e'.repeat(24))).toEqual([])
+  })
+
+  it('gruplama: (kişi, yönetici) başına tek e-posta; alıcılar kişi + o kayıtların yöneticisi; grup sınırı', () => {
+    const row = (id: string, person: string, manager: string | null, expires: string, sent: { person?: boolean; manager?: boolean } = {}) => ({
+      id,
+      person_org_id: person,
+      person_name: person,
+      manager_org_id: manager,
+      type_name: id,
+      expires_on: expires,
+      reminder_sent_for: sent.person ? expires : null,
+      manager_reminder_sent_for: sent.manager ? expires : null,
+    })
+    const groups = groupByPerson([row('x', 'p1', 'm1', '2026-11-01'), row('y', 'p2', null, '2026-10-25'), row('z', 'p1', 'm1', '2026-10-30'), row('w', 'p3', 'm3', '2026-12-01')], 2)
+    expect(groups.map((g) => [g.person, g.recipients, g.items.map((i) => i.id)])).toEqual([
+      ['p2', ['p2'], ['y']],
+      ['p1', ['p1', 'm1'], ['z', 'x']],
+    ])
+    // Kişinin kayıtları farklı yöneticilere bağlıysa ayrı e-posta: bir yönetici ötekinin kaydını görmez.
+    const split = groupByPerson([row('x', 'p1', 'm1', '2026-11-01'), row('y', 'p1', 'm2', '2026-11-02')], 5)
+    expect(split.map((g) => [g.recipients, g.items.map((i) => i.id)])).toEqual([
+      [['p1', 'm1'], ['x']],
+      [['p1', 'm2'], ['y']],
+    ])
+    // Hatırlatmayı almış taraf aynı kaydı yeniden almaz: kişiye gitmiş, yöneticiye gitmemiş kayıt yalnız yöneticiye gider.
+    const partial = groupByPerson([row('x', 'p1', 'm1', '2026-11-01', { person: true }), row('y', 'p1', 'm1', '2026-11-02'), row('z', 'p1', 'm1', '2026-11-03', { person: true, manager: true })], 5)
+    expect(partial.map((g) => [g.recipients, g.items.map((i) => i.id)])).toEqual([
+      [['m1'], ['x']],
+      [['p1', 'm1'], ['y']],
+    ])
+  })
+
+  it('bugün İstanbul saatine göre', () => {
+    expect(todayKey(new Date('2026-10-20T20:59:00Z'))).toBe('2026-10-20')
+    expect(todayKey(new Date('2026-10-20T21:00:00Z'))).toBe('2026-10-21')
+  })
+})