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

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

@@ -0,0 +1,163 @@
+// Eğitim ve sertifika kuralları — SAF fonksiyonlar (veritabanı ve ağ yok; `certificate.test.ts` sınar). Geçerlilik sonu
+// HER ZAMAN sunucuda hesaplanır: tamamlanma tarihi + türün geçerlilik süresi (ay). İstemciden gelen tarih yazılmaz.
+// Ekip de sunucuda, organizasyon şemasından çözülür; istemci "ekibim şunlar" diyemez.
+
+/** Geçerlilik sonuna kaç gün kala hatırlatılır (dolmuş ve yenilenmemiş sertifika da bir kez hatırlatılır). ⚠️ İş kuralıdır. */
+export const REMIND_DAYS = 30
+export const VALIDITY_MAX_MONTHS = 240
+export const EARLIEST_DATE = '2000-01-01'
+
+const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/
+const DAY_MS = 86_400_000
+
+export function isCalendarDate(value: unknown): value is string {
+  if (typeof value !== 'string') return false
+  const m = DATE_RE.exec(value)
+  if (!m) return false
+  return new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]))).toISOString().slice(0, 10) === value
+}
+
+/** İstanbul saatiyle bugünün tarihi (Türkiye'de yaz saati uygulaması yoktur: UTC+3). */
+export function todayKey(at: Date): string {
+  return new Date(at.getTime() + 3 * 3_600_000).toISOString().slice(0, 10)
+}
+
+export function addDays(date: string, days: number): string {
+  return new Date(Date.parse(`${date}T00:00:00Z`) + days * DAY_MS).toISOString().slice(0, 10)
+}
+
+export function daysBetween(from: string, to: string): number {
+  return Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / DAY_MS)
+}
+
+/**
+ * Takvim ayı ekler; hedef ayda o gün yoksa ayın SON günü alınır (31 Ocak + 1 ay = 28/29 Şubat). ⚠️ Bilinçli kural:
+ * taşma bir sonraki aya kaymaz, geçerlilik süresi kısalmaz-uzamaz.
+ */
+export function addMonths(date: string, months: number): string {
+  const m = DATE_RE.exec(date)
+  if (!m || !isCalendarDate(date)) throw new Error(`geçersiz tarih: ${date}`)
+  const total = Number(m[1]) * 12 + (Number(m[2]) - 1) + months
+  const year = Math.floor(total / 12)
+  const month = total - year * 12
+  const lastDay = new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
+  return new Date(Date.UTC(year, month, Math.min(Number(m[3]), lastDay))).toISOString().slice(0, 10)
+}
+
+/** Geçerlilik sonu: türün süresi yoksa sertifika süresizdir (`null`). */
+export function expiryDate(completedOn: string, validityMonths: number | null): string | null {
+  return validityMonths === null ? null : addMonths(completedOn, validityMonths)
+}
+
+export type Check<T> = { ok: true; value: T } | { ok: false; message: string }
+
+/** Geçerlilik süresi: boş = süresiz; aksi hâlde 1-240 arası tam ay. */
+export function checkValidity(raw: unknown): Check<number | null> {
+  if (raw === null || raw === undefined || raw === '') return { ok: true, value: null }
+  const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : NaN
+  if (!Number.isInteger(n) || n < 1 || n > VALIDITY_MAX_MONTHS) return { ok: false, message: `Geçerlilik süresi 1 ile ${VALIDITY_MAX_MONTHS} arasında tam ay olmalı (süresizse boş bırakın).` }
+  return { ok: true, value: n }
+}
+
+/** Tamamlanma tarihi: geçerli bir gün, bugünden ileri değil, `EARLIEST_DATE`'ten eski değil. */
+export function checkCompletionDate(raw: unknown, today: string): Check<string> {
+  if (!isCalendarDate(raw)) return { ok: false, message: 'Tarih YYYY-AA-GG biçiminde geçerli bir gün olmalı.' }
+  if (raw > today) return { ok: false, message: 'İleri tarihli tamamlanma girilemez.' }
+  if (raw < EARLIEST_DATE) return { ok: false, message: `Tarih ${EARLIEST_DATE} ya da daha yeni olmalı.` }
+  return { ok: true, value: raw }
+}
+
+export type CertStatus = 'renewed' | 'no-expiry' | 'expired' | 'expiring' | 'valid'
+
+/** Durum: aynı kişi ve türde daha yeni bir kayıt varsa "yenilendi"; süresizse "süresiz"; sonra tarih karşılaştırması. */
+export function certStatus(expiresOn: string | null, today: string, superseded: boolean, windowDays = REMIND_DAYS): CertStatus {
+  if (superseded) return 'renewed'
+  if (!expiresOn) return 'no-expiry'
+  if (expiresOn < today) return 'expired'
+  return daysBetween(today, expiresOn) <= windowDays ? 'expiring' : 'valid'
+}
+
+/** Organizasyon şemasındaki kişi (SDK `OrgUserWithManagers`'in burada kullanılan alanları). */
+export interface OrgPerson {
+  id: string
+  fullName: string | null
+  functionalManager: string
+  isActive: boolean
+}
+
+/**
+ * Ekip: işlevsel yöneticisi `managerOrgId` olan AKTİF kişiler (doğrudan bağlılar). ⚠️ İş kuralıdır — "ekibim" yalnız
+ * doğrudan bağlılar mı, alt kademeler de mi, keşif görüşmesinde netleştirin.
+ */
+export function teamOf(users: readonly OrgPerson[], managerOrgId: string): OrgPerson[] {
+  const me = managerOrgId.toLowerCase()
+  return users.filter((u) => u.isActive && typeof u.functionalManager === 'string' && u.functionalManager.toLowerCase() === me && u.id.toLowerCase() !== me)
+}
+
+/** Kişi `managerOrgId`'nin doğrudan bağlısı mı (ek dosyayı yöneticisi de indirebilsin diye). */
+export function isDirectReport(users: readonly OrgPerson[], managerOrgId: string, personOrgId: string): boolean {
+  return teamOf(users, managerOrgId).some((u) => u.id.toLowerCase() === personOrgId.toLowerCase())
+}
+
+/** Bir hatırlatma e-postasında listelenen en çok kayıt (kalanlar damgalanmaz, sonraki koşumda gider). */
+export const REMINDER_ITEMS_PER_MAIL = 20
+
+export interface DueCertificate {
+  id: string
+  person_org_id: string
+  person_name: string | null
+  manager_org_id: string | null
+  type_name: string | null
+  expires_on: string
+  /** Kişiye hatırlatılan geçerlilik sonu (`expires_on` ile aynıysa kişiye gitti). */
+  reminder_sent_for: string | null
+  /** Yöneticiye hatırlatılan geçerlilik sonu (`expires_on` ile aynıysa yöneticiye gitti). */
+  manager_reminder_sent_for: string | null
+}
+
+/** Hatırlatmanın kime gideceği: kişi ve kayıttaki yönetici AYRI izlenir (biri ulaşıp öteki ulaşmazsa yalnız o yeniden denenir). */
+export type ReminderSide = 'person' | 'manager'
+
+/** Kayıttaki yönetici (kişinin kendisiyse ya da boşsa yok). */
+export function managerOf(row: Pick<DueCertificate, 'person_org_id' | 'manager_org_id'>): string | null {
+  const raw = row.manager_org_id?.toLowerCase() || null
+  return raw && raw !== row.person_org_id.toLowerCase() ? raw : null
+}
+
+/** Bu kayıt için hatırlatmayı henüz ALMAMIŞ taraflar. */
+export function pendingSides(row: DueCertificate): ReminderSide[] {
+  const sides: ReminderSide[] = []
+  if (row.reminder_sent_for !== row.expires_on) sides.push('person')
+  if (managerOf(row) && row.manager_reminder_sent_for !== row.expires_on) sides.push('manager')
+  return sides
+}
+
+/**
+ * Hatırlatılacak sertifikaları (kişi, kayıttaki yönetici, henüz almamış taraflar) üçlüsüne göre gruplar: grup başına TEK
+ * e-posta, alıcılar YALNIZ o kayıtların hatırlatmasını henüz almamış taraflar. Yönetici değiştiyse eski ve yeni
+ * yöneticinin kayıtları ayrı e-postaya düşer; bir yönetici başka bir yöneticiyle ilişkili kaydın ayrıntısını görmez.
+ * Hatırlatmayı almış bir taraf aynı kaydı yeniden almaz. Bir koşumda en çok `maxGroups` grup; sıra en acil sertifikadır.
+ * Kalanlar damgalanmadığı için ertesi gün gider.
+ */
+export function groupByPerson(rows: readonly DueCertificate[], maxGroups: number, maxItems = REMINDER_ITEMS_PER_MAIL) {
+  const groups = new Map<string, { person: string; manager: string | null; sides: ReminderSide[]; items: DueCertificate[] }>()
+  const sorted = [...rows].sort((a, b) => (a.expires_on < b.expires_on ? -1 : a.expires_on > b.expires_on ? 1 : a.id < b.id ? -1 : 1))
+  for (const row of sorted) {
+    const sides = pendingSides(row)
+    if (sides.length === 0) continue
+    const person = row.person_org_id.toLowerCase()
+    const manager = managerOf(row)
+    const key = `${person}|${manager ?? ''}|${sides.join(',')}`
+    const group = groups.get(key)
+    if (group) {
+      if (group.items.length < maxItems) group.items.push(row)
+    } else if (groups.size < maxGroups) groups.set(key, { person, manager, sides, items: [row] })
+  }
+  return [...groups.values()].map(({ person, manager, sides, items }) => ({
+    person,
+    manager,
+    sides,
+    recipients: sides.map((side) => (side === 'person' ? person : manager!)),
+    items,
+  }))
+}

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

@@ -0,0 +1,219 @@
+// Zamanlanmış görev (manifest `jobs`). Her sabah 08:00 (İstanbul): geçerlilik sonu `REMIND_DAYS` gün içinde olan ya da
+// geçmiş, YENİLENMEMİŞ sertifikaları kişiye VE kayıttaki yöneticisine e-postayla hatırlatır — (kişi, yönetici) başına TEK
+// e-posta; bir yönetici başka bir yöneticiyle ilişkili kaydın ayrıntısını görmez.
+//
+// ⛔ Zamanlanmış iş KULLANICISIZDIR: e-posta uygulamanın kendi kimliğiyle gider ve yalnız manifest `jobs.services`
+//    beyanı + kurulumda portal yöneticisinin onayıyla açılır. Onay yoksa iş e-posta göndermez, sonucu "onay bekleniyor"
+//    diye kaydeder ve damgayı geri alır (onay verilince ertesi sabah gider).
+// ⛔ Organizasyon şeması işte KULLANILAMAZ: yönetici, kayıt yazılırken sunucuda org şemasından çözülüp kayda yazılır
+//    (`manager_org_id`). Şemada yönetici değişirse eğitim sorumlusu "Yöneticileri yenile" ile kayıtları günceller.
+// ⛔ Aynı sertifika her gün yeniden hatırlatılmaz ve damga ALICI BAŞINADIR: kişiye `reminder_sent_for`, yöneticiye
+//    `manager_reminder_sent_for` (= hatırlatılan geçerlilik sonu), ikisi de gönderimden ÖNCE koşullu konur. Posta servisi
+//    alıcılardan birini atlarsa (pasif kişi, adres yok, sınır…) yalnız onun damgası geri alınır: ertesi gün yalnız o
+//    yeniden denenir, iletiyi almış olan aynı kaydı ikinci kez almaz. Sertifika yenilenince (daha yeni kayıt) eski kayıt
+//    hatırlatılmaz; yeni kaydın süresi dolarken o da hatırlatılır.
+// ⛔ Ulaşmayan hatırlatma sıranın SONUNA geçer (`reminder_failed_on`): hiç ulaşamayan bir alıcı (ör. ayrılmış bir
+//    yönetici) en acil kayda sahip olduğu için her sabah ilk sıraları alıp öteki kişileri hatırlatmasız bırakmaz.
+// ⚠️ Platform bir istekte en çok 10 dış çağrıya izin verir: bir koşumda en çok `MAILS_PER_RUN` e-posta; kalanlar ertesi sabah.
+import { BackendClient, defineJobs, logError, notify, systemNotice, type OneContext } from '@devoplus/one-sdk'
+import type { Env } from './app.ts'
+import { REMIND_DAYS, REMINDER_ITEMS_PER_MAIL, addDays, groupByPerson, todayKey, type DueCertificate, type ReminderSide } from './certificate.ts'
+import { APP_NAME } from './names.ts'
+import { SUPERSEDED_SQL } from './queries.ts'
+
+/** Sistemin yazdığı kayıtlarda `created_by` değeri (kişi kimliği değildir). */
+export const SYSTEM_ACTOR = 'system:daily-certificate-reminders'
+/** Bir koşumda en çok kaç kişi için e-posta gider. */
+export const MAILS_PER_RUN = 5
+const MAIL_SCOPE = 'mail.execute'
+
+/**
+ * İşte e-postanın sonucu. `sent`: en az bir alıcı kuyruğa alındı; `skipped` posta servisinin ATLADIĞI alıcılardır (küçük
+ * harf kişi kimliği) — onlara ileti gitmedi. `consent-needed`: servis beyanı/onayı yok. `failed`: hiçbir alıcıya gitmedi.
+ */
+export type JobMailResult = { outcome: 'sent'; skipped: ReadonlySet<string> } | { outcome: 'consent-needed' | 'failed' }
+
+/** İşte e-posta: servis beyanı/onayı yoksa `consent-needed` (gönderim denenmez ya da sunucu 403 döner). */
+export async function sendJobMail(ctx: OneContext, api: BackendClient, message: ReturnType<typeof systemNotice>, toOrgUserIds: string[]): Promise<JobMailResult> {
+  if (!(ctx.jobServices ?? []).includes(MAIL_SCOPE)) return { outcome: 'consent-needed' }
+  try {
+    const mail = (await notify(api, message, { toOrgUserIds, channels: ['mail'] })).mail
+    if (mail && 'error' in mail) {
+      if (mail.error.status === 403) return { outcome: 'consent-needed' }
+      logError(ctx, 'sertifika hatırlatması gönderilemedi', mail.error)
+      return { outcome: 'failed' }
+    }
+    const asked = new Set(toOrgUserIds.map((id) => id.toLowerCase()))
+    const skipped = new Set((mail?.skipped ?? []).map((s) => s.sub.toLowerCase()).filter((id) => asked.has(id)))
+    // Sunucu isteği kabul edip HİÇBİR alıcıyı kuyruğa almadıysa (pasif kişi, adres yok, sınır…) ileti kimseye gitmedi:
+    // "gönderildi" sayılmaz, damga geri alınır ve sonraki koşumda yeniden denenir.
+    if (!mail || mail.queued === 0 || skipped.size >= asked.size) {
+      logError(ctx, 'sertifika hatırlatması hiçbir alıcıya ulaşmadı', mail?.skipped ?? [])
+      return { outcome: 'failed' }
+    }
+    if (skipped.size > 0) logError(ctx, 'sertifika hatırlatması bazı alıcılara ulaşmadı', mail.skipped)
+    return { outcome: 'sent', skipped }
+  } catch (error) {
+    logError(ctx, 'sertifika hatırlatması gönderilemedi', error)
+    return { outcome: 'failed' }
+  }
+}
+
+function formatDay(day: string): string {
+  return `${day.slice(8, 10)}.${day.slice(5, 7)}.${day.slice(0, 4)}`
+}
+
+const AUDIENCE: Record<string, string> = {
+  'person,manager': 'Bu e-posta kişiye ve yöneticisine gönderildi.',
+  person: 'Bu e-posta kişiye gönderildi.',
+  manager: 'Bu e-posta kişinin yöneticisine gönderildi.',
+}
+
+function reminderMessage(items: readonly DueCertificate[], today: string, sides: readonly ReminderSide[], more = 0) {
+  const person = items[0]?.person_name || 'Çalışan'
+  const lines = items.map((i) => `- ${i.type_name || 'Sertifika'}: ${formatDay(i.expires_on)}${i.expires_on < today ? ' — SÜRESİ DOLDU' : ''}`)
+  // E-postaya sığmayan kayıtlar SÖYLENİR: damgalanmadıkları için sonraki sabahlarda ayrıca hatırlatılırlar.
+  if (more > 0) lines.push(`- ve ${more} kayıt daha (sonraki sabahlarda ayrıca hatırlatılır)`)
+  return systemNotice({
+    appName: APP_NAME.tr,
+    title: `Sertifika geçerliliği doluyor: ${person}`,
+    message: `${person} için aşağıdaki eğitim ve sertifikaların geçerlilik süresi doluyor ya da doldu:\n${lines.join('\n')}\n\nYenileme yapıldıktan sonra kaydın uygulamaya girilmesi gerekir. ${AUDIENCE[sides.join(',')] ?? ''}`.trimEnd(),
+  })
+}
+
+/** Tarafın damga kolonu. */
+const STAMP: Record<ReminderSide, 'reminder_sent_for' | 'manager_reminder_sent_for'> = { person: 'reminder_sent_for', manager: 'manager_reminder_sent_for' }
+
+export const jobs = defineJobs<Env>({
+  schedules: {
+    'daily-certificate-reminders': async (job, env, ctx) => {
+      const at = job.scheduledTime ? new Date(job.scheduledTime) : new Date()
+      const today = todayKey(at)
+      const now = at.toISOString()
+      const dueUntil = addDays(today, REMIND_DAYS)
+      // Grup anahtarı `groupByPerson` ile AYNI kuraldır: kişi + kayıttaki yönetici (kişinin kendisiyse yönetici yok sayılır)
+      // + hatırlatmayı henüz almamış taraflar (`pendingSides`).
+      const managerKey =
+        "CASE WHEN c.manager_org_id IS NULL OR c.manager_org_id = '' OR lower(c.manager_org_id) = lower(c.person_org_id) THEN '' ELSE lower(c.manager_org_id) END"
+      const personDue = 'CASE WHEN c.reminder_sent_for IS NULL OR c.reminder_sent_for <> c.expires_on THEN 1 ELSE 0 END'
+      const managerDue = `CASE WHEN ${managerKey} <> '' AND (c.manager_reminder_sent_for IS NULL OR c.manager_reminder_sent_for <> c.expires_on) THEN 1 ELSE 0 END`
+      const pending = `c.deleted_at IS NULL AND c.expires_on IS NOT NULL AND c.expires_on <= ? AND (${personDue} = 1 OR ${managerDue} = 1) AND NOT ${SUPERSEDED_SQL}`
+      const dueCount = Number((await env.DB.prepare(`SELECT COUNT(*) AS n FROM "certificates" c WHERE ${pending}`).bind(dueUntil).first<{ n: number }>())?.n ?? 0)
+      // Gruplar ÖNCE seçilir, kayıtlar SONRA grup başına sınırlanır: satırlar tek bir sınırla okunsaydı çok sayıda kaydı olan
+      // bir kişi bütün sınırı doldurur, öteki kişiler günlerce hatırlatma almazdı. Sıra: hatırlatması ulaşmamış
+      // gruplar önce (ulaşmayan sıranın sonuna geçer), sonra en acil sertifika.
+      const picked = await env.DB.prepare(
+        `SELECT lower(c.person_org_id) AS person, ${managerKey} AS manager, ${personDue} AS p, ${managerDue} AS m, MIN(c.expires_on) AS first_due, ` +
+          `MAX(coalesce(c.reminder_failed_on, '')) AS failed FROM "certificates" c WHERE ${pending} ` +
+          'GROUP BY person, manager, p, m ORDER BY failed, first_due, person, manager, p, m LIMIT ?',
+      )
+        .bind(dueUntil, MAILS_PER_RUN)
+        .all<{ person: string; manager: string; p: number; m: number }>()
+      const perGroup = picked.results.length
+        ? await env.DB.batch<DueCertificate>(
+            picked.results.map((g) =>
+              env.DB.prepare(
+                'SELECT c.id, c.person_org_id, c.person_name, c.manager_org_id, c.type_name, c.expires_on, c.reminder_sent_for, c.manager_reminder_sent_for FROM "certificates" c ' +
+                  `WHERE ${pending} AND lower(c.person_org_id) = ? AND ${managerKey} = ? AND ${personDue} = ? AND ${managerDue} = ? ORDER BY c.expires_on, c.id LIMIT ?`,
+              ).bind(dueUntil, g.person, g.manager, g.p, g.m, REMINDER_ITEMS_PER_MAIL),
+            ),
+          )
+        : []
+      // Grubun bekleyen kayıt SAYISI ayrı sayılır: e-postaya en çok REMINDER_ITEMS_PER_MAIL kayıt sığar, kalanı e-postada söylenir.
+      const sidesOf = (p: number, m: number) => [p ? 'person' : '', m ? 'manager' : ''].filter(Boolean).join(',')
+      const groupTotals = picked.results.length
+        ? await env.DB.batch<{ n: number }>(
+            picked.results.map((g) =>
+              env.DB.prepare(`SELECT COUNT(*) AS n FROM "certificates" c WHERE ${pending} AND lower(c.person_org_id) = ? AND ${managerKey} = ? AND ${personDue} = ? AND ${managerDue} = ?`).bind(
+                dueUntil,
+                g.person,
+                g.manager,
+                g.p,
+                g.m,
+              ),
+            ),
+          )
+        : []
+      const totals = new Map(picked.results.map((g, n) => [`${g.person}|${g.manager}|${sidesOf(g.p, g.m)}`, Number(groupTotals[n]?.results[0]?.n ?? 0)]))
+      const groups = groupByPerson(perGroup.flatMap((r) => r.results), MAILS_PER_RUN)
+      // ⛔ Damga TOPLU ve koşullu konur, taraf başına: yalnız bu koşum hâlâ hatırlatılmamış bulduğu tarafı damgalar. Kaydı
+      // seçen koşul da damgada yeniden istenir: okumadan sonra kayıt silinir ya da yenilenirse (daha yeni tarihli kayıt)
+      // damga konmaz ve kişiye "süresi doluyor" e-postası gitmez.
+      const live = `c.deleted_at IS NULL AND NOT ${SUPERSEDED_SQL}`
+      const claims = groups.flatMap((g) => g.items.flatMap((item) => g.sides.map((side) => ({ item, side, manager: g.manager }))))
+      const stamps = claims.length
+        ? await env.DB.batch(
+            claims.map(({ item, side, manager }) =>
+              side === 'person'
+                ? env.DB.prepare(
+                    `UPDATE "certificates" AS c SET reminder_sent_for = expires_on WHERE c.id = ? AND c.expires_on = ? AND ${live} AND (c.reminder_sent_for IS NULL OR c.reminder_sent_for <> c.expires_on)`,
+                  ).bind(item.id, item.expires_on)
+                : env.DB.prepare(
+                    `UPDATE "certificates" AS c SET manager_reminder_sent_for = expires_on WHERE c.id = ? AND c.expires_on = ? AND ${live} ` +
+                      `AND (c.manager_reminder_sent_for IS NULL OR c.manager_reminder_sent_for <> c.expires_on) AND ${managerKey} = ?`,
+                  ).bind(item.id, item.expires_on, manager),
+            ),
+          )
+        : []
+      const claimed = new Map<string, Set<ReminderSide>>()
+      claims.forEach(({ item, side }, n) => {
+        if (Number(stamps[n]?.meta.changes ?? 0) !== 1) return
+        const sides = claimed.get(item.id) ?? new Set<ReminderSide>()
+        sides.add(side)
+        claimed.set(item.id, sides)
+      })
+      const api = new BackendClient({ baseUrl: env.API_BASE, authorization: null })
+      /** Geri alınacak damgalar; `failed` = ileti o tarafa ULAŞMADI (sıranın sonuna geçer). */
+      const rollback: Array<{ item: DueCertificate; side: ReminderSide; failed: boolean }> = []
+      /** İletisi bütün taraflara ulaşan kayıtlar: önceki başarısız denemenin izi silinir (sıradaki yerine döner). */
+      const delivered: DueCertificate[] = []
+      let sent = 0
+      let waiting = 0
+      let consentNeeded = false
+      for (const group of groups) {
+        // Tarafların hepsini bu koşum damgalayabildiyse gönderilir; eşzamanlı bir koşum bir tarafı aldıysa kayıt bu
+        // e-postadan çıkar ve bu koşumun koyduğu damga geri alınır (öteki koşum kendi tarafını gönderir).
+        const items: DueCertificate[] = []
+        for (const item of group.items) {
+          const mine = claimed.get(item.id)
+          if (mine && group.sides.every((side) => mine.has(side))) items.push(item)
+          else for (const side of mine ?? []) rollback.push({ item, side, failed: false })
+        }
+        if (items.length === 0) continue
+        const more = Math.max(0, (totals.get(`${group.person}|${group.manager ?? ''}|${group.sides.join(',')}`) ?? 0) - group.items.length)
+        const result = await sendJobMail(ctx, api, reminderMessage(items, today, group.sides, more), group.recipients)
+        const missed =
+          result.outcome === 'sent' ? group.sides.filter((side, k) => result.skipped.has(group.recipients[k]!)) : group.sides
+        if (missed.length < group.sides.length) sent++
+        if (missed.length > 0) waiting++
+        consentNeeded ||= result.outcome === 'consent-needed'
+        for (const side of missed) for (const item of items) rollback.push({ item, side, failed: result.outcome !== 'consent-needed' })
+        if (missed.length === 0) delivered.push(...items)
+      }
+      // Gönderilemeyenlerin damgası geri alınır (yalnız bu koşumun koyduğu damga) ve günün kaydı yazılır — tek toplu yazım.
+      await env.DB.batch([
+        ...delivered.map((item) => env.DB.prepare('UPDATE "certificates" SET reminder_failed_on = NULL WHERE id = ? AND reminder_failed_on IS NOT NULL').bind(item.id)),
+        ...rollback.map(({ item, side, failed }) =>
+          env.DB.prepare(`UPDATE "certificates" SET ${STAMP[side]} = ?, reminder_failed_on = coalesce(?, reminder_failed_on) WHERE id = ? AND ${STAMP[side]} = ?`).bind(
+            item[STAMP[side]],
+            failed ? today : null,
+            item.id,
+            item.expires_on,
+          ),
+        ),
+        env.DB.prepare('UPDATE "reminder_runs" SET due_count = ?, sent_count = sent_count + ?, waiting_count = ?, consent_needed = ?, updated_at = ? WHERE run_key = ? AND deleted_at IS NULL').bind(
+          dueCount,
+          sent,
+          waiting,
+          consentNeeded ? 1 : 0,
+          now,
+          today,
+        ),
+        env.DB.prepare(
+          'INSERT INTO "reminder_runs" (id, created_at, created_by, updated_at, updated_by, run_key, due_count, sent_count, waiting_count, consent_needed) ' +
+            'SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM "reminder_runs" WHERE run_key = ? AND deleted_at IS NULL)',
+        ).bind(crypto.randomUUID(), now, SYSTEM_ACTOR, now, SYSTEM_ACTOR, today, dueCount, sent, waiting, consentNeeded ? 1 : 0, today),
+      ])
+    },
+  },
+})

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

@@ -0,0 +1,5 @@
+// Uygulamanın adı ve izin kodları — sunucu, zamanlanmış iş ve sayfa aynı değerleri kullanır (döngüsel içe aktarma olmasın
+// diye ayrı dosyada).
+export const APP_NAME = { tr: {{nameTrJs}}, en: {{nameEnJs}} }
+/** Eğitim sorumlusu izni (manifest `permissions`): türleri tanımlar, herkesin kaydını görür ve yazar. */
+export const MANAGE_PERMISSION = '{{permissionPrefix}}Manage'

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

@@ -0,0 +1,115 @@
+// Veritabanı okumaları — ekran, zamanlanmış iş ve Devoplus yapay zekâsı araçları aynı sorguları kullanır.
+import { addDays, certStatus, daysBetween, REMIND_DAYS } from './certificate.ts'
+import type { BaseEnv } from './lib/server.ts'
+
+/**
+ * Aynı kişide aynı türün daha yeni (daha geç tamamlanmış) bir kaydı var mı — varsa eski kayıt "yenilendi" sayılır,
+ * hatırlatılmaz ve süresi dolmuş gösterilmez. `c` dış sorgudaki kaydın takma adıdır.
+ */
+export const SUPERSEDED_SQL =
+  'EXISTS (SELECT 1 FROM "certificates" n WHERE n.person_org_id = c.person_org_id AND n.type_id = c.type_id AND n.deleted_at IS NULL AND n.completed_on > c.completed_on)'
+
+export interface CertificateRow {
+  id: string
+  person_org_id: string
+  person_name: string | null
+  manager_name: string | null
+  type_id: string
+  type_name: string | null
+  completed_on: string
+  expires_on: string | null
+  certificate_no: string | null
+  attachment_name: string | null
+  has_attachment: number
+  superseded: number
+}
+
+export interface CertificateView extends Omit<CertificateRow, 'has_attachment' | 'superseded'> {
+  has_attachment: boolean
+  status: ReturnType<typeof certStatus>
+  days_left: number | null
+}
+
+const SELECT =
+  'SELECT c.id, c.person_org_id, c.person_name, c.manager_name, c.type_id, c.type_name, c.completed_on, c.expires_on, c.certificate_no, c.attachment_name, ' +
+  `(c.attachment IS NOT NULL) AS has_attachment, ${SUPERSEDED_SQL} AS superseded FROM "certificates" c`
+
+function view(today: string) {
+  return ({ has_attachment, superseded, ...r }: CertificateRow): CertificateView => ({
+    ...r,
+    has_attachment: has_attachment === 1,
+    status: certStatus(r.expires_on, today, superseded === 1),
+    days_left: r.expires_on ? daysBetween(today, r.expires_on) : null,
+  })
+}
+
+/** Ekranda en çok kaç kayıt listelenir (kişinin ya da ekibin kayıtları); fazlası varsa yanıt `truncated: true` taşır. */
+export const LIST_MAX = 1000
+/** Excel'e en çok kaç kayıt aktarılır; fazlası varsa aktarım açık bir hatayla REDDEDİLİR (eksik dosya üretilmez). */
+export const EXPORT_MAX = 10_000
+
+/**
+ * Verilen kişilerin kayıtları — kişi listesi SUNUCUDA çözülür (oturumdaki kişi ya da org şemasındaki ekibi), istemciden
+ * gelmez. Kimlikler tek bağlı parametreyle (JSON dizisi) verilir: ekip ne kadar büyük olursa olsun sorgu aynıdır.
+ * Bir fazla satır okunur: `truncated` listenin kesildiğini SÖYLER, sessizce eksik liste dönmez.
+ */
+export async function certificatesOf(
+  env: BaseEnv,
+  personOrgIds: readonly string[],
+  today: string,
+  max: number = LIST_MAX,
+): Promise<{ items: CertificateView[]; truncated: boolean }> {
+  if (personOrgIds.length === 0) return { items: [], truncated: false }
+  const rows = await env.DB.prepare(`${SELECT} WHERE c.deleted_at IS NULL AND c.person_org_id IN (SELECT value FROM json_each(?)) ORDER BY c.person_name, c.type_name, c.completed_on DESC LIMIT ?`)
+    .bind(JSON.stringify(personOrgIds.map((id) => id.toLowerCase())), max + 1)
+    .all<CertificateRow>()
+  const truncated = rows.results.length > max
+  return { items: rows.results.slice(0, max).map(view(today)), truncated }
+}
+
+/** Süresi `days` gün içinde dolacak ya da dolmuş, YENİLENMEMİŞ kayıtlar — en acil önce (portal geneli). */
+export async function expiring(env: BaseEnv, today: string, days: number, limit: number) {
+  const until = addDays(today, days)
+  const where = `c.deleted_at IS NULL AND c.expires_on IS NOT NULL AND c.expires_on <= ? AND NOT ${SUPERSEDED_SQL}`
+  const [count, rows] = await Promise.all([
+    env.DB.prepare(`SELECT COUNT(*) AS n FROM "certificates" c WHERE ${where}`).bind(until).first<{ n: number }>(),
+    env.DB.prepare(`${SELECT} WHERE ${where} ORDER BY c.expires_on, c.person_name LIMIT ?`).bind(until, limit).all<CertificateRow>(),
+  ])
+  return {
+    today,
+    until,
+    count: count?.n ?? 0,
+    items: rows.results.map(view(today)).map(({ person_name, manager_name, type_name, expires_on, days_left, status }) => ({ person_name, manager_name, type_name, expires_on, days_left, status })),
+  }
+}
+
+/** Özet (eğitim sorumlusu): dolmuş ve `REMIND_DAYS` içinde dolacak, yenilenmemiş kayıt sayısı. */
+export async function counts(env: BaseEnv, today: string) {
+  const row = await env.DB.prepare(
+    `SELECT SUM(CASE WHEN c.expires_on < ? THEN 1 ELSE 0 END) AS expired, SUM(CASE WHEN c.expires_on >= ? AND c.expires_on <= ? THEN 1 ELSE 0 END) AS expiring ` +
+      `FROM "certificates" c WHERE c.deleted_at IS NULL AND c.expires_on IS NOT NULL AND NOT ${SUPERSEDED_SQL}`,
+  )
+    .bind(today, today, addDays(today, REMIND_DAYS))
+    .first<{ expired: number | null; expiring: number | null }>()
+  return { expired: row?.expired ?? 0, expiring: row?.expiring ?? 0 }
+}
+
+/** Yapay zekâ aracının tür listesi en çok bu kadar kayıt taşır; fazlası varsa `truncated: true` (liste kesildiğini SÖYLER). */
+export const TYPES_MAX = 200
+
+export async function activeTypes(env: BaseEnv): Promise<{ items: Array<{ name: string; validity_months: number | null; description: string | null }>; truncated: boolean }> {
+  const rows = await env.DB.prepare('SELECT name, validity_months, description FROM "cert_types" WHERE active = 1 AND deleted_at IS NULL ORDER BY name LIMIT ?')
+    .bind(TYPES_MAX + 1)
+    .all<{ name: string; validity_months: number | null; description: string | null }>()
+  return { items: rows.results.slice(0, TYPES_MAX), truncated: rows.results.length > TYPES_MAX }
+}
+
+export async function lastRun(env: BaseEnv) {
+  return env.DB.prepare('SELECT run_key, due_count, sent_count, waiting_count, consent_needed FROM "reminder_runs" WHERE deleted_at IS NULL ORDER BY run_key DESC LIMIT 1').first<{
+    run_key: string
+    due_count: number
+    sent_count: number
+    waiting_count: number
+    consent_needed: number
+  }>()
+}