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

package/templates/hedef-takibi/files/src/progress.test.ts.tpl

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { VALUE_MAX, directReports, goalProgress, keyResultProgress, parseValue, weightedProgress } from './progress.ts'
+
+describe('ilerleme kuralları', () => {
+  it('ölçülebilir sonuç: başlangıçtan hedefe oran, bir ondalık', () => {
+    expect(keyResultProgress(0, 200, 50)).toBe(25)
+    expect(keyResultProgress(10, 40, 20)).toBe(33.3)
+    // Azalan hedef: 40 → 10, şu an 25 → yarı yol.
+    expect(keyResultProgress(40, 10, 25)).toBe(50)
+  })
+
+  it('hedef aşılırsa %100, başlangıcın gerisine düşülürse %0 (sınırlanır)', () => {
+    expect(keyResultProgress(0, 100, 130)).toBe(100)
+    expect(keyResultProgress(0, 100, -20)).toBe(0)
+    expect(keyResultProgress(40, 10, 50)).toBe(0)
+    expect(keyResultProgress(40, 10, 0)).toBe(100)
+  })
+
+  it('başlangıç ile hedef aynıysa: hedefe eşitse %100, değilse %0', () => {
+    expect(keyResultProgress(0, 0, 0)).toBe(100)
+    expect(keyResultProgress(0, 0, 3)).toBe(0)
+    expect(keyResultProgress(5, 5, 4)).toBe(0)
+  })
+
+  it('hedef: ölçülebilir sonuçların ortalaması; sonucu olmayan hedef %0', () => {
+    expect(goalProgress([100, 50, 0])).toBe(50)
+    expect(goalProgress([])).toBe(0)
+  })
+
+  it('ekip/dönem: ağırlıklı ortalama', () => {
+    expect(weightedProgress([{ progress: 100, weight: 3 }, { progress: 0, weight: 1 }])).toBe(75)
+    expect(weightedProgress([])).toBe(0)
+  })
+
+  it('değer: sayı ya da "12,5"; en çok dört ondalık; tavan', () => {
+    expect(parseValue('12,5')).toEqual({ ok: true, value: 12.5 })
+    expect(parseValue(-3)).toEqual({ ok: true, value: -3 })
+    expect(parseValue(1.23456)).toMatchObject({ ok: false })
+    expect(parseValue(VALUE_MAX * 10)).toMatchObject({ ok: false })
+    expect(parseValue('on iki')).toMatchObject({ ok: false })
+  })
+
+  it('ekip: işlevsel ya da operasyonel yöneticisi bu kişi olanlar (yalnız doğrudan bağlılar)', () => {
+    const base = { userCode: null, companyId: '', workplaceId: '', departmentId: '', employeeTypeId: '', titleId: '', positionId: '', isEmployee: true, isActive: true }
+    const users = [
+      { ...base, id: 'A'.repeat(24), fullName: 'Yönetici', functionalManager: '', operationalManager: '' },
+      { ...base, id: 'b'.repeat(24), fullName: 'Çalışan 1', functionalManager: 'a'.repeat(24), operationalManager: '' },
+      { ...base, id: 'c'.repeat(24), fullName: 'Çalışan 2', functionalManager: '', operationalManager: 'a'.repeat(24) },
+      { ...base, id: 'd'.repeat(24), fullName: 'Alt kademe', functionalManager: 'b'.repeat(24), operationalManager: '' },
+    ]
+    expect([...directReports(users, 'a'.repeat(24))].sort()).toEqual(['b'.repeat(24), 'c'.repeat(24)])
+  })
+})

package/templates/hedef-takibi/files/src/progress.ts.tpl

@@ -0,0 +1,81 @@
+// İlerleme kuralları — SAF fonksiyonlar (veritabanı ve ağ yok). Sunucu her ilerlemeyi BURADA hesaplar; istemcinin
+// gönderdiği ilerleme değeri hiçbir uçta kabul edilmez. Kuralı değiştiren bu dosyayı ve `progress.test.ts`'i birlikte
+// değiştirir. ⚠️ Hedefin ilerlemesi veritabanında da aynı kuralla (ölçülebilir sonuçların ortalaması, bir ondalık)
+// yeniden hesaplanır (`app.ts` → `GOAL_PROGRESS_SQL`): biri değişirse öteki de değişir.
+import type { OrgUserWithManagers } from '@devoplus/one-sdk'
+
+/** Bir değerin mutlak tavanı (yanlış yazılan fazladan sıfırları yakalar). */
+export const VALUE_MAX = 1_000_000_000_000
+/** Değer en çok dört ondalık taşır. */
+export const VALUE_DECIMALS = 4
+
+export function round1(n: number): number {
+  return Math.round(n * 10) / 10
+}
+
+function clampPercent(n: number): number {
+  return Math.min(100, Math.max(0, n))
+}
+
+/**
+ * Ölçülebilir sonucun ilerlemesi (yüzde, 0-100, bir ondalık): `(güncel - başlangıç) / (hedef - başlangıç)`.
+ * - Hedef başlangıçtan KÜÇÜKSE (ör. "şikâyet sayısını 40'tan 10'a indir") aynı formül azalmayı ilerleme sayar.
+ * - Hedef aşılırsa %100, başlangıcın gerisine düşülürse %0 (sınırlanır; %130 ya da -%20 yazılmaz).
+ * - Başlangıç ile hedef AYNIYSA (ör. "hata sayısını 0'da tut") oran tanımsızdır: güncel değer hedefe eşitse %100,
+ *   değilse %0.
+ */
+export function keyResultProgress(start: number, target: number, current: number): number {
+  if (!Number.isFinite(start) || !Number.isFinite(target) || !Number.isFinite(current)) return 0
+  if (start === target) return current === target ? 100 : 0
+  return round1(clampPercent(((current - start) / (target - start)) * 100))
+}
+
+/** Hedefin ilerlemesi: ölçülebilir sonuçlarının ilerlemelerinin ortalaması; ölçülebilir sonucu olmayan hedef %0. */
+export function goalProgress(keyResults: readonly number[]): number {
+  if (keyResults.length === 0) return 0
+  return round1(keyResults.reduce((a, b) => a + b, 0) / keyResults.length)
+}
+
+/** Ekip ya da dönem ilerlemesi: hedeflerin AĞIRLIKLI ortalaması (ağırlık 1-100). Hedef yoksa %0. */
+export function weightedProgress(goals: ReadonlyArray<{ progress: number; weight: number }>): number {
+  return weightedProgressOf(
+    goals.reduce((a, g) => a + (g.weight > 0 ? g.weight : 0), 0),
+    goals.reduce((a, g) => a + (g.weight > 0 ? g.weight * g.progress : 0), 0),
+  )
+}
+
+/**
+ * Aynı kural, toplamlardan: `weightSum` = pozitif ağırlıkların toplamı, `weightedSum` = Σ ağırlık × ilerleme. Dönem panosu
+ * toplamları SQL'de alır (`queries.ts` → `periodSummary`) ve oranı buradan kurar; iki yol aynı sonucu verir.
+ */
+export function weightedProgressOf(weightSum: number, weightedSum: number): number {
+  if (!(weightSum > 0)) return 0
+  return round1(weightedSum / weightSum)
+}
+
+export type ValueCheck = { ok: true; value: number } | { ok: false; message: string }
+
+/** Ölçülebilir sonuç değeri: sayı (ya da "12,5" gibi metin), sonlu, tavanın içinde, en çok dört ondalık. */
+export function parseValue(raw: unknown): ValueCheck {
+  const value =
+    typeof raw === 'number' ? raw : typeof raw === 'string' && /^\s*-?\d+(?:[.,]\d+)?\s*$/.test(raw) ? Number(raw.trim().replace(',', '.')) : NaN
+  if (!Number.isFinite(value)) return { ok: false, message: 'Bir sayı girin.' }
+  if (Math.abs(value) > VALUE_MAX) return { ok: false, message: 'Değer çok büyük.' }
+  const scaled = value * 10 ** VALUE_DECIMALS
+  if (Math.abs(Math.round(scaled) - scaled) > 1e-6) return { ok: false, message: `Değer en çok ${VALUE_DECIMALS} ondalık olabilir.` }
+  return { ok: true, value }
+}
+
+/**
+ * Bir yöneticinin ekibi: organizasyon şemasında işlevsel YA DA operasyonel yöneticisi bu kişi olan çalışanlar
+ * (doğrudan bağlılar; alt kademeler dahil DEĞİL). Kimlikler org kimliğidir (oturum kimliği değil), küçük harfle.
+ */
+export function directReports(users: readonly OrgUserWithManagers[], managerOrgId: string): Set<string> {
+  const me = managerOrgId.toLowerCase()
+  const out = new Set<string>()
+  for (const u of users) {
+    if (u.id.toLowerCase() === me) continue
+    if ((u.functionalManager ?? '').toLowerCase() === me || (u.operationalManager ?? '').toLowerCase() === me) out.add(u.id.toLowerCase())
+  }
+  return out
+}

package/templates/hedef-takibi/files/src/queries.ts.tpl

@@ -0,0 +1,83 @@
+// Veritabanı okumaları — ekran, dönem panosu ve Devoplus yapay zekâsı aracı aynı sorguları kullanır. Görünürlük
+// kararı ÇAĞIRANDADIR: `owners` verilirse yalnız o kişilerin hedefleri okunur (`null` = hepsi; yalnız hedef yöneticisi).
+// Kişi listesi tek bağlı parametre olarak JSON dizisiyle verilir (`json_each`): kişi sayısı parametre sınırına takılmaz.
+import type { BaseEnv } from './lib/server.ts'
+import { round1, weightedProgressOf } from './progress.ts'
+
+export interface PeriodRow {
+  id: string
+  code: string
+  name: string
+  status: string
+  start_date: string
+  end_date: string
+}
+
+/** Dönem: kimlikle, kodla ya da (ikisi de yoksa) başlangıcı en yeni olan. */
+export async function findPeriod(env: BaseEnv, by: { id?: string | null; code?: string | null }): Promise<PeriodRow | null> {
+  const cols = 'id, code, name, status, start_date, end_date'
+  if (by.id) return env.DB.prepare(`SELECT ${cols} FROM "periods" WHERE id = ? AND deleted_at IS NULL`).bind(by.id).first<PeriodRow>()
+  if (by.code) return env.DB.prepare(`SELECT ${cols} FROM "periods" WHERE code = ? AND deleted_at IS NULL`).bind(by.code).first<PeriodRow>()
+  return env.DB.prepare(`SELECT ${cols} FROM "periods" WHERE deleted_at IS NULL ORDER BY start_date DESC, created_at DESC LIMIT 1`).first<PeriodRow>()
+}
+
+/** Görünürlük koşulu: `owners` null ise koşul yok, boş dizi ise hiçbir satır. */
+export function ownerClause(owners: readonly string[] | null): { sql: string; params: string[] } {
+  if (owners === null) return { sql: '', params: [] }
+  return { sql: ' AND g.owner_org_id IN (SELECT value FROM json_each(?))', params: [JSON.stringify(owners)] }
+}
+
+export interface TeamSummary {
+  team_id: string | null
+  team_name: string | null
+  goals: number
+  progress: number
+}
+
+export interface PeriodSummary {
+  overall: number
+  goalCount: number
+  teams: TeamSummary[]
+}
+
+/**
+ * Dönem özeti: ekip başına hedef sayısı ve ağırlıklı ilerleme + dönemin genel ilerlemesi. Sayım ve ağırlıklı toplam
+ * SQL'de yapılır, yani satır sınırı yoktur: dönemde kaç hedef olursa olsun özet hepsini kapsar (eskiden ilk 5.000 hedef
+ * okunuyor ve kalanı sessizce atılıyordu). Ağırlıklı ortalamanın kuralı `progress.ts` → `weightedProgressOf`'tadır.
+ */
+export async function periodSummary(env: BaseEnv, periodId: string, owners: readonly string[] | null): Promise<PeriodSummary> {
+  if (owners !== null && owners.length === 0) return { overall: 0, goalCount: 0, teams: [] }
+  const where = ownerClause(owners)
+  const rows = await env.DB.prepare(
+    'SELECT g.team_id, MIN(g.team_name) AS team_name, COUNT(*) AS goals, ' +
+      'SUM(CASE WHEN g.weight > 0 THEN g.weight ELSE 0 END) AS weight_sum, ' +
+      'SUM(CASE WHEN g.weight > 0 THEN g.weight * g.progress ELSE 0 END) AS weighted_sum ' +
+      `FROM "goals" g WHERE g.deleted_at IS NULL AND g.period_id = ?${where.sql} GROUP BY g.team_id`,
+  )
+    .bind(periodId, ...where.params)
+    .all<{ team_id: string | null; team_name: string | null; goals: number; weight_sum: number | null; weighted_sum: number | null }>()
+  const teams = rows.results
+    .map((r) => ({
+      team_id: r.team_id,
+      team_name: r.team_name,
+      goals: Number(r.goals),
+      progress: weightedProgressOf(Number(r.weight_sum ?? 0), Number(r.weighted_sum ?? 0)),
+    }))
+    .sort((a, b) => (a.team_name ?? '').localeCompare(b.team_name ?? '', 'tr'))
+  const weightSum = rows.results.reduce((a, r) => a + Number(r.weight_sum ?? 0), 0)
+  const weightedSum = rows.results.reduce((a, r) => a + Number(r.weighted_sum ?? 0), 0)
+  return { overall: weightedProgressOf(weightSum, weightedSum), goalCount: teams.reduce((a, t) => a + t.goals, 0), teams }
+}
+
+/** En geride kalan hedefler (ilerlemesi en düşük önce); sıralama ve sınır SQL'de, dönemin bütün hedefleri arasından. */
+export async function lowestGoals(env: BaseEnv, periodId: string, owners: readonly string[] | null, limit: number) {
+  if (owners !== null && owners.length === 0) return []
+  const where = ownerClause(owners)
+  const rows = await env.DB.prepare(
+    'SELECT g.title, g.owner_name, g.team_name, g.progress FROM "goals" g ' +
+      `WHERE g.deleted_at IS NULL AND g.period_id = ?${where.sql} ORDER BY g.progress ASC, g.title ASC LIMIT ?`,
+  )
+    .bind(periodId, ...where.params, limit)
+    .all<{ title: string; owner_name: string | null; team_name: string | null; progress: number }>()
+  return rows.results.map((g) => ({ title: g.title, owner: g.owner_name, team: g.team_name, progress: round1(g.progress) }))
+}