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

package/templates/bakim-takvimi/files/AGENT_GUIDE.md.tpl

@@ -0,0 +1,52 @@
+# {{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}}, kurumdaki cihaz ve ekipmanların periyodik bakımını izleyen bir bakım takvimidir. Her ekipmanın bir bakım
+aralığı (gün) ve son bakım tarihi vardır; sıradaki bakım tarihi bunlardan hesaplanır. Bakım yapıldığında ekipmanın
+sorumlusu ya da bakım sorumlusu kaydı girer ve sıradaki tarih ilerler. Sıradaki bakımı 7 gün içinde olan ya da geçmiş
+ekipmanların sorumlusuna her sabah bir kez e-posta gider. Kullanıcı "bu hafta hangi bakımlar var", "geciken bakım var
+mı", "kompresörün son bakımı ne zaman yapıldı" gibi şeyler sorduğunda bu uygulamaya başvurun. Bakım kaydetmek için araç
+yoktur.
+
+## Veri
+
+- **Ekipman** (`equipment`): ekipman kodu (tekil), ad, tür, konum, sorumlu kişinin adı, bakım aralığı (gün), son bakım
+  tarihi, sıradaki bakım tarihi, kullanımda mı.
+- **Bakım kaydı** (`maintenance_records`): ekipman, bakım tarihi, yapılan iş, isteğe bağlı fotoğraf ya da belge,
+  kaydeden kişi, kayıtla birlikte hesaplanan sonraki bakım tarihi. Kayıt değiştirilmez.
+- **Günlük hatırlatma kontrolü** (`reminder_runs`): her sabah 08:00'de (Türkiye saati) kaç bakımın hatırlatılacağı ve
+  kaç e-posta gittiği.
+- Durumlar: `overdue` (gecikti — sıradaki tarih bugünden önce), `due-soon` (7 gün içinde, bugün dahil), `scheduled`
+  (planlı). Tarihler `YYYY-AA-GG` biçimindedir; kullanıcıya `gg.aa.yyyy` olarak söyleyin.
+
+## Araçlar
+
+### `upcoming-maintenance` — yaklaşan bakımlar (salt okunur)
+
+- **Ne zaman:** kullanıcı yaklaşan, bu haftaki ya da geciken bakımları sorduğunda.
+- **Girdi:** `days` — bugünden itibaren kaç gün (0-90, varsayılan 14; geciken bakımlar her zaman dahildir);
+  `limit` (1-50, varsayılan 20).
+- **Çıktı:** `{ "today": "2026-10-20", "until": "2026-11-03", "count": 4, "items": [{ "code", "name", "location",
+  "responsible_name", "last_maintenance_date", "next_due_date", "days_left", "status" }] }` — en acil olan önce;
+  `count` tam sayıdır, `items` en çok `limit` kadar. `days_left` eksiyse bakım o kadar gün gecikmiştir.
+
+### `search-equipment` — ekipman ara (salt okunur)
+
+- **Ne zaman:** kullanıcı belirli bir ekipmanın son ya da sıradaki bakımını, sorumlusunu ya da yerini sorduğunda.
+- **Girdi:** `query` — ekipman kodunda, adında ya da konumunda geçen ifade; `limit` (1-50, varsayılan 10).
+- **Çıktı:** `{ "items": [{ "code", "name", "location", "responsible_name", "last_maintenance_date",
+  "next_due_date", "days_left", "status" }] }`.
+- **Dikkat:** büyük/küçük harf eşleşmesi yalnız Latin harflerde yok sayılır; Türkçe harfli bir aramada sonuç çıkmazsa
+  ifadeyi küçük harfle yeniden deneyin.
+
+## Örnek istekler
+
+- "Bu hafta hangi bakımlar var?" → `upcoming-maintenance` (`days: 7`)
+- "Geciken bakım var mı?" → `upcoming-maintenance` (`days: 0`) → `status: "overdue"` olanlar
+- "Kompresörün son bakımı ne zaman yapıldı?" → `search-equipment` (`query: "kompresör"`) → `last_maintenance_date`
+- "Klimanın bakımını yaptım, kaydet." → araç yok; kullanıcıyı uygulamanın Bakım kayıtları sekmesine yönlendirin.

package/templates/bakim-takvimi/files/one.data.json

@@ -0,0 +1,45 @@
+{
+  "version": 1,
+  "entities": {
+    "equipment": {
+      "title": { "tr": "Ekipmanlar", "en": "Equipment" },
+      "fields": {
+        "code": { "type": "text", "title": { "tr": "Ekipman kodu", "en": "Equipment code" }, "required": true, "unique": true, "maxLength": 40 },
+        "name": { "type": "text", "title": { "tr": "Ad", "en": "Name" }, "required": true, "maxLength": 120 },
+        "category": { "type": "text", "title": { "tr": "Tür", "en": "Type" }, "maxLength": 60, "index": true },
+        "location": { "type": "text", "title": { "tr": "Konum", "en": "Location" }, "maxLength": 120, "index": true },
+        "responsible_org_id": { "type": "text", "title": { "tr": "Sorumlu (kimlik)", "en": "Responsible (id)" }, "maxLength": 24, "index": true },
+        "responsible_name": { "type": "text", "title": { "tr": "Sorumlu", "en": "Responsible" }, "maxLength": 120 },
+        "period_days": { "type": "number", "title": { "tr": "Bakım aralığı (gün)", "en": "Interval (days)" }, "required": true, "default": 30, "min": 1, "max": 3650 },
+        "last_maintenance_date": { "type": "date", "title": { "tr": "Son bakım", "en": "Last maintenance" }, "required": true },
+        "next_due_date": { "type": "date", "title": { "tr": "Sıradaki bakım", "en": "Next due" }, "index": true },
+        "reminder_sent_for": { "type": "date", "title": { "tr": "Hatırlatılan bakım tarihi", "en": "Reminded due date" } },
+        "reminder_failed_on": { "type": "date", "title": { "tr": "Hatırlatmanın ulaşmadığı son gün", "en": "Last undelivered reminder" } },
+        "active": { "type": "boolean", "title": { "tr": "Kullanımda", "en": "In use" }, "required": true, "default": true }
+      }
+    },
+    "maintenance_records": {
+      "title": { "tr": "Bakım kayıtları", "en": "Maintenance records" },
+      "fields": {
+        "equipment_id": { "type": "text", "title": { "tr": "Ekipman", "en": "Equipment" }, "required": true, "maxLength": 36, "index": true },
+        "equipment_name": { "type": "text", "title": { "tr": "Ekipman adı", "en": "Equipment name" }, "maxLength": 120 },
+        "performed_on": { "type": "date", "title": { "tr": "Bakım tarihi", "en": "Maintenance date" }, "required": true, "index": true },
+        "note": { "type": "longText", "title": { "tr": "Yapılan iş", "en": "Work done" }, "maxLength": 2000 },
+        "attachment": { "type": "file", "title": { "tr": "Fotoğraf ya da belge", "en": "Photo or document" } },
+        "attachment_name": { "type": "text", "title": { "tr": "Ek dosya adı", "en": "Attachment name" }, "maxLength": 200 },
+        "performer_name": { "type": "text", "title": { "tr": "Kaydeden", "en": "Recorded by" }, "maxLength": 120 },
+        "next_due_date": { "type": "date", "title": { "tr": "Sonraki bakım", "en": "Next due" } }
+      }
+    },
+    "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 bakım", "en": "Maintenance 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/bakim-takvimi/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. Bakım KAYDEDEN araç bilinçli olarak yoktur.
+import { defineAgentTools } from '@devoplus/one-sdk'
+import type { Env } from './app.ts'
+import { searchEquipment, upcoming } from './queries.ts'
+import { todayKey } from './schedule.ts'
+
+export const agentTools = defineAgentTools<Env>({
+  'upcoming-maintenance': {
+    handler: async ({ input, env }) => {
+      const days = typeof input.days === 'number' ? input.days : 14
+      const limit = typeof input.limit === 'number' ? input.limit : 20
+      return upcoming(env, todayKey(new Date()), days, limit)
+    },
+  },
+  'search-equipment': {
+    handler: async ({ input, env }) => ({
+      items: await searchEquipment(env, todayKey(new Date()), String(input.query), typeof input.limit === 'number' ? input.limit : 10),
+    }),
+  },
+})

package/templates/bakim-takvimi/files/src/app.ts.tpl

@@ -0,0 +1,259 @@
+// {{nameTr}} — bakım takvimi. Uçlar (hepsi oturum ister; kimlik platformdan gelir):
+//   GET    /api/equipment[?…]                      ekipmanlar (herkes) — sıradaki bakıma göre sıralı; hazır liste + Excel
+//   POST   /api/equipment · PATCH/DELETE /api/equipment/{id}   ekipman tanımı (bakım sorumlusu izni)
+//                                                  ⛔ sıradaki bakım tarihi istemciden ALINMAZ; son bakım yalnız kayıtla değişir
+//   POST   /api/equipment/{id}/maintenance          { performed_on, note?, attachment? } — bakım kaydı (bakım sorumlusu izni
+//                                                  ya da ekipmanın sorumlusu): kayıt + son/sıradaki tarih TEK toplu yazım
+//   GET    /api/overdue/equipment[?…]               geciken bakımlar (herkes) — süzgeci SUNUCU koyar; hazır liste + Excel
+//   GET    /api/maintenance_records[?…]             bakım kayıtları (herkes) — değiştirilemez ve silinemez
+//   GET    /api/maintenance_records/{id}/attachment kaydın fotoğrafı ya da belgesi
+//   POST   /api/files                               dosya yükleme (yalnız kendi ön ekinize)
+//   GET    /api/summary                             geciken / yaklaşan sayısı, son hatırlatma kontrolü
+import {
+  OneError,
+  createCrudHandler,
+  foldSearchText,
+  getMyOrgContext,
+  hasPermission,
+  logAudit,
+  logError,
+  requirePermission,
+  requireUser,
+  type MyOrgContext,
+  type OneFilesBinding,
+} from '@devoplus/one-sdk'
+import manifest from '../one.manifest.json' with { type: 'json' }
+import { agentTools } from './agent.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 { refuseActingSession } from './lib/record.ts'
+import { createApp, json, type AppDefinition, type BaseEnv, type RouteInput } from './lib/server.ts'
+import { MANAGE_PERMISSION } from './names.ts'
+import { NEXT_DUE_SQL, counts, lastRun } from './queries.ts'
+import { REMIND_DAYS, addDays, checkMaintenanceDate, checkPeriod, nextDueDate, todayKey } from './schedule.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): bakım fotoğrafları ve belgeleri. */
+  FILES: OneFilesBinding
+}
+
+export const equipment = createCrudHandler({ model: dataModel, entity: 'equipment', records: 'shared', canWrite: MANAGE_PERMISSION })
+/** Gecikenler: aynı kayıtlar, süzgeci sunucu koyar (salt okunur). */
+export const overdue = createCrudHandler({ model: dataModel, entity: 'equipment', records: 'shared', basePath: '/api/overdue' })
+export const records = createCrudHandler({ model: dataModel, entity: 'maintenance_records', records: 'shared' })
+
+const CREATE_FIELDS = ['code', 'name', 'category', 'location', 'responsible', 'period_days', 'last_maintenance_date', 'active']
+/** Güncellemede son bakım tarihi YOKTUR: o yalnız bakım kaydıyla değişir. */
+const UPDATE_FIELDS = ['code', 'name', 'category', 'location', 'responsible', 'period_days', 'active']
+const NOTE_MAX = 2000
+const CONTROL_RE = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/
+
+const today = (): string => todayKey(new Date())
+
+async function myOrg(input: RouteInput<Env>): Promise<MyOrgContext | null> {
+  try {
+    return await getMyOrgContext(input.api())
+  } catch (error) {
+    logError(input.ctx, 'kişi bilgisi okunamadı', error)
+    return null
+  }
+}
+
+/** Kişi seçicinin değeri iki kolona ayrılır. */
+function withResponsible(body: Record<string, unknown>): Record<string, unknown> {
+  const { responsible, ...rest } = body
+  if (!('responsible' in body)) return rest
+  const person = personValue(responsible, 'responsible')
+  return { ...rest, responsible_org_id: person?.id ?? null, responsible_name: person?.name ?? null }
+}
+
+async function createEquipment(input: RouteInput<Env>): Promise<Response> {
+  const { request, env, ctx } = input
+  requirePermission(ctx, MANAGE_PERMISSION)
+  const body = onlyFields(await readJsonObject(request), CREATE_FIELDS)
+  const period = checkPeriod(body.period_days)
+  if (!period.ok) throw fieldError('period_days', period.message)
+  const last = checkMaintenanceDate(body.last_maintenance_date, today())
+  if (!last.ok) throw fieldError('last_maintenance_date', last.message)
+  // ⛔ Sıradaki bakım SUNUCUDA hesaplanır; gövdede gelirse yukarıdaki alan denetimi zaten reddeder (400).
+  const record = { ...withResponsible(body), period_days: period.value, last_maintenance_date: last.value, next_due_date: nextDueDate(last.value, period.value) }
+  return (await equipment.handle(forward(request, equipment.path, 'POST', record), env.DB, ctx))!
+}
+
+async function updateEquipment(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requirePermission(ctx, MANAGE_PERMISSION)
+  if (method === 'DELETE') return (await equipment.handle(request, env.DB, ctx))!
+  const body = onlyFields(await readJsonObject(request), UPDATE_FIELDS)
+  if ('period_days' in body) {
+    const period = checkPeriod(body.period_days)
+    if (!period.ok) throw fieldError('period_days', period.message)
+    body.period_days = period.value
+  }
+  const res = (await equipment.handle(forward(request, `${equipment.path}/${id}`, 'PATCH', withResponsible(body)), env.DB, ctx))!
+  if (!res.ok) return res
+  // Aralık değiştiyse sıradaki tarih son bakımdan yeniden hesaplanır (kural tek SQL ifadesindedir; iş de onarır).
+  await env.DB.prepare(`UPDATE "equipment" SET next_due_date = ${NEXT_DUE_SQL}, updated_by = ? WHERE id = ? AND next_due_date IS NOT ${NEXT_DUE_SQL}`).bind(user.sub, id).run()
+  const saved = (await res.json()) as Record<string, unknown>
+  const fresh = await env.DB.prepare('SELECT next_due_date FROM "equipment" WHERE id = ?').bind(id).first<{ next_due_date: string | null }>()
+  return json({ ...saved, next_due_date: fresh?.next_due_date ?? null })
+}
+
+async function recordMaintenance(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireUser(ctx)
+  refuseActingSession(ctx)
+  const body = onlyFields(await readJsonObject(request), ['performed_on', 'note', 'attachment'])
+  const item = await env.DB.prepare('SELECT id, name, active, responsible_org_id FROM "equipment" WHERE id = ? AND deleted_at IS NULL')
+    .bind(id)
+    .first<{ id: string; name: string; active: number; responsible_org_id: string | null }>()
+  if (!item) throw new OneError(404, 'APP-E-404', 'Ekipman bulunamadı.')
+  // Bakımı bakım sorumlusu (izin) ya da ekipmanın kendi sorumlusu kaydeder. Kişi bilgisi okunamazsa kapı KAPALI kalır.
+  const me = await myOrg(input)
+  const manager = hasPermission(ctx, MANAGE_PERMISSION)
+  const isResponsible = me !== null && item.responsible_org_id !== null && me.orgUserId.toLowerCase() === item.responsible_org_id.toLowerCase()
+  if (!manager && !isResponsible)
+    throw new OneError(403, 'APP-E-403', 'Bu ekipmanın bakımını yalnız sorumlusu ya da bakım sorumlusu izni olan kişi kaydedebilir.')
+  if (item.active !== 1) throw new OneError(409, 'APP-E-021', 'Kullanımda olmayan ekipmana bakım kaydı girilmez.')
+  const date = checkMaintenanceDate(body.performed_on, today())
+  if (!date.ok) throw fieldError('performed_on', date.message)
+  const note = typeof body.note === 'string' ? body.note.trim() : ''
+  if ([...note].length > NOTE_MAX || CONTROL_RE.test(note)) throw fieldError('note', `Açıklama en çok ${NOTE_MAX} karakter olmalı.`)
+  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 now = nowIso()
+  const recordId = crypto.randomUUID()
+  const performer = me?.fullName?.trim() ? [...me.fullName.trim()].slice(0, 120).join('') : null
+  // ⛔ Bakım kaydı ve ekipmanın tarihleri TEK toplu yazımdır (ikisi birlikte yazılır ya da hiçbiri):
+  //   1. Kayıt yalnız ekipman kullanımdaysa ve yazan kişi HÂLÂ yetkiliyse eklenir: bakım sorumlusu izni olmayan kişi için
+  //      ekipmanın sorumlusu olması aynı ifadededir (denetimden sonra sorumlu değişirse kayıt yazılmaz). Sonraki bakım
+  //      tarihi aynı ifadede, veritabanındaki aralıkla hesaplanır.
+  //   2. Ekipmanın son ve sıradaki bakım tarihi yalnız BU kayıt eklendiyse değişir. Geriye dönük (eski tarihli) kayıt
+  //      son bakım tarihini geri götürmez: `max(son bakım, kayıt tarihi)`.
+  const nextFromRecord = `date(max(e.last_maintenance_date, ?), '+' || CAST(e.period_days AS INTEGER) || ' days')`
+  const responsibleOnly = manager ? '' : ' AND lower(e.responsible_org_id) = ?'
+  const fold = (text: string | null) => (text === null ? null : foldSearchText(text))
+  const insert = env.DB.prepare(
+    'INSERT INTO "maintenance_records" (id, created_at, created_by, updated_at, updated_by, equipment_id, equipment_name, equipment_name_fold, performed_on, note, note_fold, ' +
+      'attachment, attachment_name, attachment_name_fold, performer_name, performer_name_fold, next_due_date) ' +
+      `SELECT ?, ?, ?, ?, ?, e.id, e.name, e.name_fold, ?, ?, ?, ?, ?, ?, ?, ?, ${nextFromRecord} FROM "equipment" e WHERE e.id = ? AND e.active = 1 AND e.deleted_at IS NULL${responsibleOnly}`,
+  ).bind(
+    recordId,
+    now,
+    user.sub,
+    now,
+    user.sub,
+    date.value,
+    note || null,
+    fold(note || null),
+    attachment,
+    attachmentName,
+    fold(attachmentName),
+    performer,
+    fold(performer),
+    date.value,
+    id,
+    ...(manager ? [] : [me!.orgUserId.toLowerCase()]),
+  )
+  const update = env.DB.prepare(
+    `UPDATE "equipment" SET last_maintenance_date = max(last_maintenance_date, ?), next_due_date = date(max(last_maintenance_date, ?), '+' || CAST(period_days AS INTEGER) || ' days'), ` +
+      'updated_at = ?, updated_by = ? WHERE id = ? AND EXISTS (SELECT 1 FROM "maintenance_records" WHERE id = ?)',
+  ).bind(date.value, date.value, now, user.sub, id, recordId)
+  const [inserted, changed] = await env.DB.batch([insert, update])
+  if (Number(inserted?.meta.changes ?? 0) !== 1 || Number(changed?.meta.changes ?? 0) !== 1) {
+    const latest = await env.DB.prepare('SELECT responsible_org_id FROM "equipment" WHERE id = ? AND deleted_at IS NULL').bind(id).first<{ responsible_org_id: string | null }>()
+    if (!latest) throw new OneError(404, 'APP-E-404', 'Ekipman bulunamadı.')
+    if (!manager && (latest.responsible_org_id ?? '').toLowerCase() !== me!.orgUserId.toLowerCase())
+      throw new OneError(403, 'APP-E-403', 'Bu ekipmanın bakımını yalnız sorumlusu ya da bakım sorumlusu izni olan kişi kaydedebilir.')
+    throw new OneError(409, 'APP-E-021', 'Ekipman bu arada değişti; sayfayı yenileyip yeniden deneyin.')
+  }
+  logAudit(ctx, 'maintenance.record', id, { performedOn: date.value })
+  const after = await env.DB.prepare('SELECT last_maintenance_date, next_due_date FROM "equipment" WHERE id = ?').bind(id).first<{ last_maintenance_date: string; next_due_date: string }>()
+  return json({ id: recordId, equipment: { id, ...after } }, 201)
+}
+
+/** Liste varsayılan olarak sıradaki bakıma göre sıralanır (istemci başka bir sıralama isterse o geçerlidir). */
+function sortedByDue(input: RouteInput<Env>): Request {
+  const params = input.url.searchParams
+  if (params.has('sort') || params.has('_sort')) return input.request
+  return withQuery(input.request, input.url.pathname, (p) => p.set('_sort', 'next_due_date'))
+}
+
+/** Gecikenler: istemcinin gönderdiği tarih ve durum süzgeci YOK SAYILIR; sunucu "dünden eski ve kullanımda" koyar. */
+async function overdueList(input: RouteInput<Env>): Promise<Response | null> {
+  const { env, ctx, url } = input
+  const rest = url.pathname.slice(overdue.path.length)
+  if (rest !== '' && rest !== '/export.xlsx' && rest !== '/export.csv' && rest !== '/report.html') throw new OneError(404, 'APP-E-404', 'Bulunamadı.')
+  if (input.method !== 'GET' && input.method !== 'HEAD') throw new OneError(405, 'APP-E-405', 'Geciken bakımlar yalnız okunur.')
+  requireUser(ctx)
+  const scoped = withQuery(input.request, url.pathname, (p) => {
+    for (const key of ['next_due_date', 'next_due_date.from', 'next_due_date.to', 'next_due_dateFrom', 'next_due_dateTo', 'active']) p.delete(key)
+    p.set('next_due_date.to', addDays(today(), -1))
+    p.set('active', 'true')
+    if (!p.has('sort') && !p.has('_sort')) p.set('_sort', 'next_due_date')
+  })
+  return overdue.handle(scoped, env.DB, ctx)
+}
+
+async function attachmentOf(input: RouteInput<Env>, id: string): Promise<Response> {
+  requireUser(input.ctx)
+  const row = await input.env.DB.prepare('SELECT attachment FROM "maintenance_records" WHERE id = ? AND deleted_at IS NULL').bind(id).first<{ attachment: string | null }>()
+  if (!row?.attachment) throw new OneError(404, 'APP-E-404', 'Bu kayıtta dosya yok.')
+  return fileResponse(input.env.FILES, row.attachment)
+}
+
+async function summary({ env, ctx }: RouteInput<Env>): Promise<Response> {
+  requireUser(ctx)
+  const day = today()
+  const [c, run] = await Promise.all([counts(env, day, REMIND_DAYS), lastRun(env)])
+  return json({ today: day, remindDays: REMIND_DAYS, ...c, lastRun: run ? { ...run, consent_needed: run.consent_needed === 1 } : null })
+}
+
+async function routes(input: RouteInput<Env>): Promise<Response | null> {
+  const { url, method, env, ctx } = input
+  const path = url.pathname
+  if (path === '/api/summary' && method === 'GET') return summary(input)
+  if (path === '/api/files' && method === 'POST') return uploadFile(input.request, env.FILES, ctx)
+  if (path === overdue.path || path.startsWith(`${overdue.path}/`)) return overdueList(input)
+
+  const maintenanceId = matchId(path, equipment.path, 'maintenance')
+  if (maintenanceId && method === 'POST') return recordMaintenance(input, maintenanceId)
+  if (path === equipment.path && method === 'POST') return createEquipment(input)
+  const equipmentId = matchId(path, equipment.path)
+  if (equipmentId && (method === 'PATCH' || method === 'PUT' || method === 'DELETE')) {
+    if (method === 'PUT') throw new OneError(405, 'APP-E-405', 'Ekipman PATCH ile güncellenir.')
+    return updateEquipment(input, equipmentId)
+  }
+  if (path === equipment.path || path === `${equipment.path}/export.xlsx` || path === `${equipment.path}/export.csv` || path === `${equipment.path}/report.html`)
+    return equipment.handle(sortedByDue(input), env.DB, ctx)
+  if (path.startsWith(`${equipment.path}/`)) return equipment.handle(input.request, env.DB, ctx)
+
+  const attachmentId = matchId(path, records.path, 'attachment')
+  if (attachmentId && method === 'GET') return attachmentOf(input, attachmentId)
+  if (path === records.path || path.startsWith(`${records.path}/`)) {
+    if (method !== 'GET' && method !== 'HEAD') throw new OneError(405, 'APP-E-405', 'Bakım kaydı değiştirilemez ve silinemez; düzeltme için yeni bir kayıt girin.')
+    return records.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/bakim-takvimi/files/src/jobs.ts.tpl

@@ -0,0 +1,170 @@
+// Zamanlanmış görev (manifest `jobs`). Her sabah 08:00 (İstanbul): sıradaki bakımı `REMIND_DAYS` gün içinde olan ya da
+// geçmiş (geciken) ekipmanların sorumlusuna e-postayla hatırlatır — kişi başına TEK e-posta.
+//
+// ⛔ 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:
+//    alıcı, ekipman kaydındaki sorumlunun kişi kimliğidir (`responsible_org_id`, kayıt yazılırken sunucuda doğrulanır).
+// ⛔ Aynı bakım her gün yeniden hatırlatılmaz: gönderimden ÖNCE koşullu damga konur (`reminder_sent_for` = hatırlatılan
+//    bakım tarihi). Damgayı yalnız bir koşum koyabilir (eşzamanlı iki koşum aynı e-postayı göndermez); gönderilemezse geri
+//    alınır. Bakım kaydedilince sıradaki tarih değişir ve damga kendiliğinden eskir: bir sonraki bakım yine hatırlatılır.
+// ⛔ Ulaşmayan hatırlatma sıranın SONUNA geçer (`reminder_failed_on`): hiç ulaşamayan bir sorumlu (ör. ayrılmış bir
+//    çalışan) en acil bakıma sahip olduğu için her sabah ilk sıraları alıp öteki sorumluları 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` kişiye yazılır; kalanlar
+//    damgalanmadığı için ertesi sabah gider.
+import { BackendClient, defineJobs, logError, notify, systemNotice, type OneContext } from '@devoplus/one-sdk'
+import type { Env } from './app.ts'
+import { APP_NAME } from './names.ts'
+import { NEXT_DUE_SQL } from './queries.ts'
+import { REMIND_DAYS, REMINDER_ITEMS_PER_MAIL, addDays, groupByResponsible, todayKey, type DueRow } from './schedule.ts'
+
+/** Sistemin yazdığı kayıtlarda `created_by` değeri (kişi kimliği değildir). */
+export const SYSTEM_ACTOR = 'system:daily-maintenance-reminders'
+/** Bir koşumda en çok kaç kişiye e-posta gider. */
+export const MAILS_PER_RUN = 5
+const MAIL_SCOPE = 'mail.execute'
+
+export type JobMailOutcome = 'sent' | '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<JobMailOutcome> {
+  if (!(ctx.jobServices ?? []).includes(MAIL_SCOPE)) return 'consent-needed'
+  try {
+    const mail = (await notify(api, message, { toOrgUserIds, channels: ['mail'] })).mail
+    if (mail && 'error' in mail) {
+      if (mail.error.status === 403) return 'consent-needed'
+      logError(ctx, 'bakım hatırlatması gönderilemedi', mail.error)
+      return 'failed'
+    }
+    // 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) {
+      logError(ctx, 'bakım hatırlatması hiçbir alıcıya ulaşmadı', mail?.skipped ?? [])
+      return 'failed'
+    }
+    return 'sent'
+  } catch (error) {
+    logError(ctx, 'bakım hatırlatması gönderilemedi', error)
+    return 'failed'
+  }
+}
+
+function formatDay(day: string): string {
+  return `${day.slice(8, 10)}.${day.slice(5, 7)}.${day.slice(0, 4)}`
+}
+
+function reminderMessage(items: readonly DueRow[], today: string, more = 0) {
+  const lines = items.map((i) => `- ${i.code} ${i.name}${i.location ? ` (${i.location})` : ''}: ${formatDay(i.next_due_date)}${i.next_due_date < today ? ' — GECİKTİ' : ''}`)
+  // E-postaya sığmayan ekipmanlar SÖYLENİR: damgalanmadıkları için sonraki sabahlarda ayrıca hatırlatılırlar.
+  if (more > 0) lines.push(`- ve ${more} ekipman daha (sonraki sabahlarda ayrıca hatırlatılır)`)
+  return systemNotice({
+    appName: APP_NAME.tr,
+    title: items.length === 1 ? `Bakım zamanı: ${items[0]!.name}` : `${items.length} ekipmanın bakım zamanı geldi`,
+    message: `Sorumlusu olduğunuz ekipmanların sıradaki bakım tarihleri:\n${lines.join('\n')}\n\nBakımı yaptıktan sonra uygulamanın Bakım kayıtları sekmesinden kaydedin.`,
+  })
+}
+
+export const jobs = defineJobs<Env>({
+  schedules: {
+    'daily-maintenance-reminders': async (job, env, ctx) => {
+      const at = job.scheduledTime ? new Date(job.scheduledTime) : new Date()
+      const today = todayKey(at)
+      const now = at.toISOString()
+      // Kendini onarma: sıradaki tarih her zaman son bakım + aralıktır (yarım kalmış bir güncellemeden sonra da).
+      await env.DB.prepare(`UPDATE "equipment" SET next_due_date = ${NEXT_DUE_SQL} WHERE deleted_at IS NULL AND next_due_date IS NOT ${NEXT_DUE_SQL}`).run()
+      const dueUntil = addDays(today, REMIND_DAYS)
+      const pending =
+        'active = 1 AND deleted_at IS NULL AND responsible_org_id IS NOT NULL AND next_due_date <= ? ' +
+        'AND (reminder_sent_for IS NULL OR reminder_sent_for <> next_due_date)'
+      const dueCount = Number((await env.DB.prepare(`SELECT COUNT(*) AS n FROM "equipment" WHERE ${pending}`).bind(dueUntil).first<{ n: number }>())?.n ?? 0)
+      // Alıcılar ÖNCE seçilir (en acil bakımı olan MAILS_PER_RUN kişi), kalemler SONRA kişi başına sınırlanır: satırlar
+      // tek bir sınırla okunsaydı çok sayıda ekipmanı olan bir sorumlu bütün sınırı doldurur, öteki sorumlular günlerce
+      // hatırlatma almazdı. Hatırlatması ulaşmamış sorumlular sıranın sonundadır (en eski başarısız deneme önce).
+      const recipients = await env.DB.prepare(
+        `SELECT lower(responsible_org_id) AS responsible, MIN(next_due_date) AS first_due, MAX(coalesce(reminder_failed_on, '')) AS failed FROM "equipment" WHERE ${pending} ` +
+          'GROUP BY lower(responsible_org_id) ORDER BY failed, first_due, responsible LIMIT ?',
+      )
+        .bind(dueUntil, MAILS_PER_RUN)
+        .all<{ responsible: string }>()
+      const perRecipient = recipients.results.length
+        ? await env.DB.batch<DueRow>(
+            recipients.results.map((r) =>
+              env.DB.prepare(
+                'SELECT id, code, name, location, next_due_date, responsible_org_id, reminder_sent_for FROM "equipment" ' +
+                  `WHERE ${pending} AND lower(responsible_org_id) = ? ORDER BY next_due_date, code LIMIT ?`,
+              ).bind(dueUntil, r.responsible, REMINDER_ITEMS_PER_MAIL),
+            ),
+          )
+        : []
+      // Sorumlunun bekleyen ekipman SAYISI ayrı sayılır: e-postaya en çok REMINDER_ITEMS_PER_MAIL kalem sığar, kalanı söylenir.
+      const recipientTotals = recipients.results.length
+        ? await env.DB.batch<{ n: number }>(
+            recipients.results.map((r) => env.DB.prepare(`SELECT COUNT(*) AS n FROM "equipment" WHERE ${pending} AND lower(responsible_org_id) = ?`).bind(dueUntil, r.responsible)),
+          )
+        : []
+      const totals = new Map(recipients.results.map((r, n) => [r.responsible, Number(recipientTotals[n]?.results[0]?.n ?? 0)]))
+      const groups = groupByResponsible(perRecipient.flatMap((r) => r.results), MAILS_PER_RUN)
+      const chosen = groups.flatMap((g) => g.items)
+      // ⛔ Damga TOPLU ve koşullu konur ve satırı seçen koşulun TAMAMINI yeniden ister: yalnız bu koşum hâlâ hatırlatılmamış
+      // bulduğu satırı damgalar; okumadan sonra bakım kaydedilir, ekipman kullanımdan kalkar ya da sorumlusu değişirse satır
+      // damgalanmaz ve eski sorumluya giden e-postada yer almaz (yeni sorumlunun hatırlatması da bastırılmaz).
+      const stamps = chosen.length
+        ? await env.DB.batch(
+            chosen.map((i) =>
+              env.DB.prepare(
+                'UPDATE "equipment" SET reminder_sent_for = next_due_date WHERE id = ? AND next_due_date = ? AND active = 1 AND deleted_at IS NULL ' +
+                  'AND lower(responsible_org_id) = ? AND (reminder_sent_for IS NULL OR reminder_sent_for <> next_due_date)',
+              ).bind(i.id, i.next_due_date, (i.responsible_org_id ?? '').toLowerCase()),
+            ),
+          )
+        : []
+      const claimed = new Set(chosen.filter((_, n) => Number(stamps[n]?.meta.changes ?? 0) === 1).map((i) => i.id))
+      const api = new BackendClient({ baseUrl: env.API_BASE, authorization: null })
+      /** Geri alınacak damgalar; `failed` = ileti sorumluya ULAŞMADI (sıranın sonuna geçer). */
+      const rollback: Array<{ item: DueRow; failed: boolean }> = []
+      /** İletisi ulaşan kalemler: önceki başarısız denemenin izi silinir (sıradaki yerine döner). */
+      const delivered: DueRow[] = []
+      let sent = 0
+      let waiting = 0
+      let consentNeeded = false
+      for (const group of groups) {
+        const items = group.items.filter((i) => claimed.has(i.id))
+        if (items.length === 0) continue
+        const more = Math.max(0, (totals.get(group.responsible) ?? 0) - group.items.length)
+        const outcome = await sendJobMail(ctx, api, reminderMessage(items, today, more), [group.responsible])
+        if (outcome === 'sent') {
+          sent++
+          delivered.push(...items)
+        } else {
+          waiting++
+          consentNeeded ||= outcome === 'consent-needed'
+          rollback.push(...items.map((item) => ({ item, failed: outcome === 'failed' })))
+        }
+      }
+      // 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 "equipment" SET reminder_failed_on = NULL WHERE id = ? AND reminder_failed_on IS NOT NULL').bind(item.id)),
+        ...rollback.map(({ item, failed }) =>
+          env.DB.prepare('UPDATE "equipment" SET reminder_sent_for = ?, reminder_failed_on = coalesce(?, reminder_failed_on) WHERE id = ? AND reminder_sent_for = ?').bind(
+            item.reminder_sent_for,
+            failed ? today : null,
+            item.id,
+            item.next_due_date,
+          ),
+        ),
+        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/bakim-takvimi/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}} }
+/** Bakım sorumlusu izni (manifest `permissions`): ekipman tanımlar, her ekipmanın bakımını kaydeder. */
+export const MANAGE_PERMISSION = '{{permissionPrefix}}Manage'

package/templates/bakim-takvimi/files/src/queries.ts.tpl

@@ -0,0 +1,71 @@
+// Veritabanı okumaları — ekran, zamanlanmış iş ve Devoplus yapay zekâsı araçları aynı sorguları kullanır.
+import type { BaseEnv } from './lib/server.ts'
+import { addDays, daysBetween, dueStatus } from './schedule.ts'
+
+/**
+ * Sıradaki bakımın SQL karşılığı: son bakım + aralık (gün). ⛔ `schedule.ts` → `nextDueDate` ile AYNI kural; ikisi
+ * birlikte değişir (iş kuralı testi ikisinin aynı sonucu verdiğini sınar).
+ */
+export const NEXT_DUE_SQL = `date(last_maintenance_date, '+' || CAST(period_days AS INTEGER) || ' days')`
+
+const ACTIVE = 'active = 1 AND deleted_at IS NULL'
+
+export interface ScheduleRow {
+  code: string
+  name: string
+  location: string | null
+  responsible_name: string | null
+  last_maintenance_date: string
+  next_due_date: string
+}
+
+function withStatus(today: string) {
+  return (r: ScheduleRow) => ({ ...r, days_left: daysBetween(today, r.next_due_date), status: dueStatus(r.next_due_date, today) })
+}
+
+/** Sıradaki bakımı `until` gününe kadar (dahil) olan ya da geçmiş kullanımdaki ekipmanlar — en acil önce. */
+export async function upcoming(env: BaseEnv, today: string, days: number, limit: number) {
+  const until = addDays(today, days)
+  const [count, rows] = await Promise.all([
+    env.DB.prepare(`SELECT COUNT(*) AS n FROM "equipment" WHERE ${ACTIVE} AND next_due_date <= ?`).bind(until).first<{ n: number }>(),
+    env.DB.prepare(
+      `SELECT code, name, location, responsible_name, last_maintenance_date, next_due_date FROM "equipment" WHERE ${ACTIVE} AND next_due_date <= ? ORDER BY next_due_date, code LIMIT ?`,
+    )
+      .bind(until, limit)
+      .all<ScheduleRow>(),
+  ])
+  return { today, until, count: count?.n ?? 0, items: rows.results.map(withStatus(today)) }
+}
+
+/** Ekipman arama: kod, ad ya da konum içinde geçen (büyük/küçük harf yalnız Latin harflerde yok sayılır). */
+export async function searchEquipment(env: BaseEnv, today: string, query: string, limit: number) {
+  const q = query.trim().toLowerCase()
+  const rows = await env.DB.prepare(
+    `SELECT code, name, location, responsible_name, last_maintenance_date, next_due_date FROM "equipment" WHERE ${ACTIVE} ` +
+      `AND (instr(lower(code), ?) > 0 OR instr(lower(name), ?) > 0 OR instr(lower(coalesce(location, '')), ?) > 0) ORDER BY name LIMIT ?`,
+  )
+    .bind(q, q, q, limit)
+    .all<ScheduleRow>()
+  return rows.results.map(withStatus(today))
+}
+
+/** Özet: geciken ve `windowDays` içinde yaklaşan bakım sayısı (sayılar sunucuda hesaplanır). */
+export async function counts(env: BaseEnv, today: string, windowDays: number) {
+  const row = await env.DB.prepare(
+    `SELECT SUM(CASE WHEN next_due_date < ? THEN 1 ELSE 0 END) AS overdue, ` +
+      `SUM(CASE WHEN next_due_date >= ? AND next_due_date <= ? THEN 1 ELSE 0 END) AS due_soon, COUNT(*) AS total FROM "equipment" WHERE ${ACTIVE}`,
+  )
+    .bind(today, today, addDays(today, windowDays))
+    .first<{ overdue: number | null; due_soon: number | null; total: number }>()
+  return { overdue: row?.overdue ?? 0, dueSoon: row?.due_soon ?? 0, total: row?.total ?? 0 }
+}
+
+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
+  }>()
+}