feat: project cover art with AI generation, branding rename, RBAC fix, computation graph
- Add DALL-E cover art generation for projects (Azure OpenAI + standard OpenAI)
- CoverArtSection component with generate/upload/remove/focus-point controls
- Client-side image compression (10MB input → WebP/JPEG, max 1920px)
- DALL-E settings in admin panel (deployment, endpoint, API key)
- MCP assistant tools for cover art (generate_project_cover, remove_project_cover)
- Rename "Planarchy" → "plANARCHY" across all UI-facing text (13 files)
- Fix hardcoded canEdit={true} on project detail page — now checks user role
- Computation graph visualization (2D/3D) for calculation rules
- OG image and OpenGraph metadata
Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -1,6 +1,6 @@
|
||||
/**
|
||||
* AI Assistant router — provides a chat endpoint that uses OpenAI Function Calling
|
||||
* to answer questions about Planarchy data and modify resources/projects.
|
||||
* to answer questions about plANARCHY data and modify resources/projects.
|
||||
*/
|
||||
|
||||
import { z } from "zod";
|
||||
@@ -12,13 +12,19 @@ import { TOOL_DEFINITIONS, executeTool, type ToolContext, type ToolAction } from
|
||||
|
||||
const MAX_TOOL_ITERATIONS = 8;
|
||||
|
||||
const SYSTEM_PROMPT = `Du bist der Planarchy-Assistent — ein hilfreicher AI-Assistent für Ressourcenplanung und Projektmanagement in einer 3D-Produktionsumgebung.
|
||||
const SYSTEM_PROMPT = `Du bist der plANARCHY-Assistent — ein hilfreicher AI-Assistent für Ressourcenplanung und Projektmanagement in einer 3D-Produktionsumgebung.
|
||||
|
||||
Deine Fähigkeiten:
|
||||
- Fragen über Ressourcen, Projekte, Allokationen, Budget, Urlaub, Estimates, Org-Struktur beantworten
|
||||
- Chargeability-Analysen, Urlaubsübersichten, Budget-Analysen
|
||||
- Ressourcen/Projekte aktualisieren, Allokationen erstellen/stornieren (nur mit Berechtigung + expliziter Bestätigung)
|
||||
- Fragen über Ressourcen, Projekte, Allokationen, Budget, Urlaub, Estimates, Org-Struktur, Rollen, Blueprints, Rate Cards beantworten
|
||||
- Chargeability-Analysen, Urlaubsübersichten, Budget-Analysen, Staffing-Vorschläge, Kapazitätssuche
|
||||
- Ressourcen erstellen/aktualisieren/deaktivieren, Projekte erstellen/aktualisieren/löschen
|
||||
- Allokationen erstellen/stornieren, Demands erstellen/besetzen, Staffing-Vorschläge abrufen
|
||||
- Urlaub erstellen/genehmigen/ablehnen/stornieren, Ansprüche verwalten
|
||||
- Rollen, Clients, Org-Units erstellen/aktualisieren/löschen
|
||||
- Estimates erstellen, Rate Cards abrufen, Blueprints anzeigen
|
||||
- Notifications anzeigen, Dashboard-Details abrufen
|
||||
- Den User zu relevanten Seiten navigieren (Timeline, Dashboard, etc. mit Filtern)
|
||||
- Verfügbarkeit von Ressourcen prüfen, Kapazitäten suchen
|
||||
|
||||
Wichtige Regeln:
|
||||
- Antworte in der Sprache des Users (Deutsch oder Englisch)
|
||||
@@ -39,15 +45,40 @@ Datenmodell:
|
||||
|
||||
/** Map tool names to the permission required to use them */
|
||||
const TOOL_PERMISSION_MAP: Record<string, string> = {
|
||||
// Resource management
|
||||
update_resource: "manageResources",
|
||||
create_resource: "manageResources",
|
||||
deactivate_resource: "manageResources",
|
||||
create_role: "manageResources",
|
||||
update_role: "manageResources",
|
||||
delete_role: "manageResources",
|
||||
create_org_unit: "manageResources",
|
||||
update_org_unit: "manageResources",
|
||||
// Project management
|
||||
update_project: "manageProjects",
|
||||
create_project: "manageProjects",
|
||||
delete_project: "manageProjects",
|
||||
create_client: "manageProjects",
|
||||
update_client: "manageProjects",
|
||||
create_estimate: "manageProjects",
|
||||
generate_project_cover: "manageProjects",
|
||||
remove_project_cover: "manageProjects",
|
||||
// Allocation management
|
||||
create_allocation: "manageAllocations",
|
||||
cancel_allocation: "manageAllocations",
|
||||
update_allocation_status: "manageAllocations",
|
||||
create_demand: "manageAllocations",
|
||||
fill_demand: "manageAllocations",
|
||||
// Vacation management
|
||||
create_vacation: "manageVacations",
|
||||
approve_vacation: "manageVacations",
|
||||
reject_vacation: "manageVacations",
|
||||
cancel_vacation: "manageVacations",
|
||||
set_entitlement: "manageVacations",
|
||||
};
|
||||
|
||||
/** Tools that require cost visibility */
|
||||
const COST_TOOLS = new Set(["get_budget_status", "get_chargeability"]);
|
||||
const COST_TOOLS = new Set(["get_budget_status", "get_chargeability", "resolve_rate", "list_rate_cards", "get_estimate_detail"]);
|
||||
|
||||
export const assistantRouter = createTRPCRouter({
|
||||
chat: protectedProcedure
|
||||
|
||||
@@ -0,0 +1,619 @@
|
||||
import {
|
||||
calculateSAH,
|
||||
calculateAllocation,
|
||||
deriveResourceForecast,
|
||||
computeBudgetStatus,
|
||||
getMonthRange,
|
||||
countWorkingDaysInOverlap,
|
||||
DEFAULT_CALCULATION_RULES,
|
||||
type AssignmentSlice,
|
||||
} from "@planarchy/engine";
|
||||
import type { CalculationRule, AbsenceDay, SpainScheduleRule, WeekdayAvailability } from "@planarchy/shared";
|
||||
import { VacationStatus } from "@planarchy/db";
|
||||
import { z } from "zod";
|
||||
import { createTRPCRouter, controllerProcedure } from "../trpc.js";
|
||||
|
||||
// ─── Graph Types (mirrored from client for API response) ────────────────────
|
||||
|
||||
type Domain =
|
||||
| "INPUT" | "SAH" | "ALLOCATION" | "RULES" | "CHARGEABILITY" | "BUDGET"
|
||||
| "ESTIMATE" | "COMMERCIAL" | "EXPERIENCE" | "EFFORT" | "SPREAD";
|
||||
|
||||
export interface GraphNode {
|
||||
id: string;
|
||||
label: string;
|
||||
value: number | string;
|
||||
unit: string;
|
||||
domain: Domain;
|
||||
description: string;
|
||||
formula?: string;
|
||||
level: number;
|
||||
}
|
||||
|
||||
export interface GraphLink {
|
||||
source: string;
|
||||
target: string;
|
||||
formula: string;
|
||||
weight: number;
|
||||
}
|
||||
|
||||
// ─── Helpers ────────────────────────────────────────────────────────────────
|
||||
|
||||
function n(
|
||||
id: string, label: string, value: number | string, unit: string,
|
||||
domain: Domain, description: string, level: number, formula?: string,
|
||||
): GraphNode {
|
||||
return { id, label, value, unit, domain, description, level, ...(formula ? { formula } : {}) };
|
||||
}
|
||||
|
||||
function l(source: string, target: string, formula: string, weight = 1): GraphLink {
|
||||
return { source, target, formula, weight };
|
||||
}
|
||||
|
||||
function fmtEur(cents: number): string {
|
||||
return `${(cents / 100).toLocaleString("de-DE", { minimumFractionDigits: 2 })} EUR`;
|
||||
}
|
||||
|
||||
function fmtPct(ratio: number): string {
|
||||
return `${(ratio * 100).toFixed(1)}%`;
|
||||
}
|
||||
|
||||
function fmtNum(v: number, decimals = 1): string {
|
||||
return v.toFixed(decimals);
|
||||
}
|
||||
|
||||
// ─── Router ─────────────────────────────────────────────────────────────────
|
||||
|
||||
export const computationGraphRouter = createTRPCRouter({
|
||||
/**
|
||||
* Resource View: SAH, Allocation, Rules, Chargeability, Budget
|
||||
* for a single resource in a single month.
|
||||
*/
|
||||
getResourceData: controllerProcedure
|
||||
.input(z.object({
|
||||
resourceId: z.string(),
|
||||
month: z.string().regex(/^\d{4}-\d{2}$/),
|
||||
}))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const [year, month] = input.month.split("-").map(Number) as [number, number];
|
||||
const { start: monthStart, end: monthEnd } = getMonthRange(year, month);
|
||||
|
||||
// ── 1. Load resource ──
|
||||
const resource = await ctx.db.resource.findUniqueOrThrow({
|
||||
where: { id: input.resourceId },
|
||||
select: {
|
||||
id: true,
|
||||
displayName: true,
|
||||
eid: true,
|
||||
fte: true,
|
||||
lcrCents: true,
|
||||
chargeabilityTarget: true,
|
||||
availability: true,
|
||||
country: { select: { id: true, code: true, dailyWorkingHours: true, scheduleRules: true } },
|
||||
managementLevelGroup: { select: { id: true, name: true, targetPercentage: true } },
|
||||
},
|
||||
});
|
||||
|
||||
const dailyHours = resource.country?.dailyWorkingHours ?? 8;
|
||||
const scheduleRules = resource.country?.scheduleRules as SpainScheduleRule | null;
|
||||
const targetPct = resource.managementLevelGroup?.targetPercentage ?? (resource.chargeabilityTarget / 100);
|
||||
|
||||
// Resource weekly availability (per-day hours)
|
||||
const avail = resource.availability as WeekdayAvailability | null;
|
||||
const weeklyAvailability: WeekdayAvailability = avail ?? {
|
||||
monday: dailyHours, tuesday: dailyHours, wednesday: dailyHours,
|
||||
thursday: dailyHours, friday: dailyHours, saturday: 0, sunday: 0,
|
||||
};
|
||||
|
||||
// ── 2. Load assignments in month ──
|
||||
const assignments = await ctx.db.assignment.findMany({
|
||||
where: {
|
||||
resourceId: input.resourceId,
|
||||
startDate: { lte: monthEnd },
|
||||
endDate: { gte: monthStart },
|
||||
status: { in: ["CONFIRMED", "ACTIVE", "PROPOSED"] },
|
||||
},
|
||||
select: {
|
||||
id: true,
|
||||
hoursPerDay: true,
|
||||
startDate: true,
|
||||
endDate: true,
|
||||
dailyCostCents: true,
|
||||
status: true,
|
||||
project: {
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
shortCode: true,
|
||||
budgetCents: true,
|
||||
winProbability: true,
|
||||
utilizationCategory: { select: { code: true } },
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
// ── 3. Load absences ──
|
||||
const vacations = await ctx.db.vacation.findMany({
|
||||
where: {
|
||||
resourceId: input.resourceId,
|
||||
status: VacationStatus.APPROVED,
|
||||
startDate: { lte: monthEnd },
|
||||
endDate: { gte: monthStart },
|
||||
},
|
||||
select: { startDate: true, endDate: true, type: true, isHalfDay: true },
|
||||
});
|
||||
|
||||
// Build absence dates for SAH (ISO strings)
|
||||
const absenceDateStrings: string[] = [];
|
||||
const absenceDays: AbsenceDay[] = [];
|
||||
for (const v of vacations) {
|
||||
const vStart = new Date(Math.max(v.startDate.getTime(), monthStart.getTime()));
|
||||
const vEnd = new Date(Math.min(v.endDate.getTime(), monthEnd.getTime()));
|
||||
if (vStart > vEnd) continue;
|
||||
const cursor = new Date(vStart);
|
||||
cursor.setUTCHours(0, 0, 0, 0);
|
||||
const endNorm = new Date(vEnd);
|
||||
endNorm.setUTCHours(0, 0, 0, 0);
|
||||
const triggerType = v.type === "SICK" ? "SICK" as const
|
||||
: v.type === "PUBLIC_HOLIDAY" ? "PUBLIC_HOLIDAY" as const
|
||||
: "VACATION" as const;
|
||||
while (cursor <= endNorm) {
|
||||
absenceDateStrings.push(cursor.toISOString().slice(0, 10));
|
||||
absenceDays.push({
|
||||
date: new Date(cursor),
|
||||
type: triggerType,
|
||||
...(v.isHalfDay ? { isHalfDay: true } : {}),
|
||||
});
|
||||
cursor.setUTCDate(cursor.getUTCDate() + 1);
|
||||
}
|
||||
}
|
||||
|
||||
// ── 4. Load calculation rules ──
|
||||
let calcRules: CalculationRule[] = DEFAULT_CALCULATION_RULES;
|
||||
try {
|
||||
const dbRules = await ctx.db.calculationRule.findMany({
|
||||
where: { isActive: true },
|
||||
orderBy: [{ priority: "desc" }],
|
||||
});
|
||||
if (dbRules.length > 0) {
|
||||
calcRules = dbRules as unknown as CalculationRule[];
|
||||
}
|
||||
} catch {
|
||||
// table may not exist yet
|
||||
}
|
||||
|
||||
// ── 5. Calculate SAH ──
|
||||
const sahResult = calculateSAH({
|
||||
dailyWorkingHours: dailyHours,
|
||||
scheduleRules,
|
||||
fte: resource.fte,
|
||||
periodStart: monthStart,
|
||||
periodEnd: monthEnd,
|
||||
publicHolidays: [],
|
||||
absenceDays: absenceDateStrings,
|
||||
});
|
||||
|
||||
// ── 6. Calculate allocations + chargeability slices ──
|
||||
const slices: AssignmentSlice[] = [];
|
||||
let totalAllocHours = 0;
|
||||
let totalAllocCostCents = 0;
|
||||
let totalChargeableHours = 0;
|
||||
let totalProjectCostCents = 0;
|
||||
let hasRulesEffect = false;
|
||||
|
||||
for (const a of assignments) {
|
||||
const workingDays = countWorkingDaysInOverlap(monthStart, monthEnd, a.startDate, a.endDate);
|
||||
if (workingDays <= 0) continue;
|
||||
|
||||
const overlapStart = new Date(Math.max(monthStart.getTime(), a.startDate.getTime()));
|
||||
const overlapEnd = new Date(Math.min(monthEnd.getTime(), a.endDate.getTime()));
|
||||
const categoryCode = a.project.utilizationCategory?.code ?? "Chg";
|
||||
|
||||
const calcResult = calculateAllocation({
|
||||
lcrCents: resource.lcrCents,
|
||||
hoursPerDay: a.hoursPerDay,
|
||||
startDate: overlapStart,
|
||||
endDate: overlapEnd,
|
||||
availability: weeklyAvailability,
|
||||
absenceDays,
|
||||
calculationRules: calcRules,
|
||||
});
|
||||
|
||||
totalAllocHours += calcResult.totalHours;
|
||||
totalAllocCostCents += calcResult.totalCostCents;
|
||||
if (calcResult.totalChargeableHours !== undefined) {
|
||||
totalChargeableHours += calcResult.totalChargeableHours;
|
||||
totalProjectCostCents += calcResult.totalProjectCostCents ?? calcResult.totalCostCents;
|
||||
hasRulesEffect = true;
|
||||
} else {
|
||||
totalChargeableHours += calcResult.totalHours;
|
||||
totalProjectCostCents += calcResult.totalCostCents;
|
||||
}
|
||||
|
||||
slices.push({
|
||||
hoursPerDay: a.hoursPerDay,
|
||||
workingDays,
|
||||
categoryCode,
|
||||
...(calcResult.totalChargeableHours !== undefined
|
||||
? { totalChargeableHours: calcResult.totalChargeableHours }
|
||||
: {}),
|
||||
});
|
||||
}
|
||||
|
||||
// ── 7. Calculate chargeability forecast ──
|
||||
const forecast = deriveResourceForecast({
|
||||
fte: resource.fte,
|
||||
targetPercentage: targetPct,
|
||||
assignments: slices,
|
||||
sah: sahResult.standardAvailableHours,
|
||||
});
|
||||
|
||||
// ── 8. Build budget status for first project with budget ──
|
||||
const budgetProject = assignments.find((a) => a.project.budgetCents != null && a.project.budgetCents > 0)?.project;
|
||||
let budgetNodes: GraphNode[] = [];
|
||||
let budgetLinks: GraphLink[] = [];
|
||||
if (budgetProject && budgetProject.budgetCents != null) {
|
||||
// Load all allocations for this project to compute budget
|
||||
const projectAllocs = await ctx.db.assignment.findMany({
|
||||
where: { projectId: budgetProject.id },
|
||||
select: { status: true, dailyCostCents: true, startDate: true, endDate: true, hoursPerDay: true },
|
||||
});
|
||||
const budgetStatus = computeBudgetStatus(
|
||||
budgetProject.budgetCents,
|
||||
budgetProject.winProbability,
|
||||
projectAllocs.map((pa) => ({
|
||||
status: pa.status as unknown as string,
|
||||
dailyCostCents: pa.dailyCostCents,
|
||||
startDate: pa.startDate,
|
||||
endDate: pa.endDate,
|
||||
hoursPerDay: pa.hoursPerDay,
|
||||
})) as Parameters<typeof computeBudgetStatus>[2],
|
||||
monthStart,
|
||||
monthEnd,
|
||||
);
|
||||
|
||||
budgetNodes = [
|
||||
n("input.budgetCents", "Project Budget", fmtEur(budgetProject.budgetCents), "EUR", "INPUT", `Budget for ${budgetProject.name}`, 0),
|
||||
n("input.winProbability", "Win Probability", `${budgetProject.winProbability}%`, "%", "INPUT", "Project win probability", 0),
|
||||
n("budget.confirmedCents", "Confirmed", fmtEur(budgetStatus.confirmedCents), "EUR", "BUDGET", "Sum of CONFIRMED/ACTIVE allocation costs", 2, "Σ(confirmed allocs)"),
|
||||
n("budget.proposedCents", "Proposed", fmtEur(budgetStatus.proposedCents), "EUR", "BUDGET", "Sum of PROPOSED allocation costs", 2, "Σ(proposed allocs)"),
|
||||
n("budget.allocatedCents", "Allocated", fmtEur(budgetStatus.allocatedCents), "EUR", "BUDGET", "Total allocated budget", 2, "confirmed + proposed"),
|
||||
n("budget.remainingCents", "Remaining", fmtEur(budgetStatus.remainingCents), "EUR", "BUDGET", "Remaining budget", 3, "budget - allocated"),
|
||||
n("budget.utilizationPct", "Utilization", `${budgetStatus.utilizationPercent.toFixed(1)}%`, "%", "BUDGET", "Budget utilization percentage", 3, "allocated / budget × 100"),
|
||||
n("budget.weightedCents", "Win-Weighted", fmtEur(budgetStatus.winProbabilityWeightedCents), "EUR", "BUDGET", "Win-probability-weighted cost", 3, "allocated × winProb / 100"),
|
||||
];
|
||||
budgetLinks = [
|
||||
l("alloc.totalCostCents", "budget.confirmedCents", "per assignment", 1),
|
||||
l("budget.confirmedCents", "budget.allocatedCents", "+", 2),
|
||||
l("budget.proposedCents", "budget.allocatedCents", "+", 2),
|
||||
l("input.budgetCents", "budget.remainingCents", "−", 2),
|
||||
l("budget.allocatedCents", "budget.remainingCents", "−", 2),
|
||||
l("budget.allocatedCents", "budget.utilizationPct", "÷ budget × 100", 2),
|
||||
l("input.budgetCents", "budget.utilizationPct", "÷", 1),
|
||||
l("budget.allocatedCents", "budget.weightedCents", "× winProb / 100", 1),
|
||||
l("input.winProbability", "budget.weightedCents", "×", 1),
|
||||
];
|
||||
}
|
||||
|
||||
// ── 9. Build graph nodes + links ──
|
||||
|
||||
const dailyCostCents = assignments.length > 0
|
||||
? Math.round(assignments[0]!.hoursPerDay * resource.lcrCents)
|
||||
: 0;
|
||||
const avgHoursPerDay = assignments.length > 0
|
||||
? assignments.reduce((sum, a) => sum + a.hoursPerDay, 0) / assignments.length
|
||||
: 0;
|
||||
|
||||
// Format weekly availability for display
|
||||
const weekdayLabels = ["Mo", "Tu", "We", "Th", "Fr"];
|
||||
const weekdayValues = [weeklyAvailability.monday, weeklyAvailability.tuesday, weeklyAvailability.wednesday, weeklyAvailability.thursday, weeklyAvailability.friday];
|
||||
const weeklyTotalHours = weekdayValues.reduce((s, v) => s + v, 0);
|
||||
const allSame = weekdayValues.every((v) => v === weekdayValues[0]);
|
||||
const availabilityLabel = allSame
|
||||
? `${weekdayValues[0]}h/day`
|
||||
: weekdayLabels.map((d, i) => `${d}:${weekdayValues[i]}`).join(" ");
|
||||
|
||||
const nodes: GraphNode[] = [
|
||||
// INPUT
|
||||
n("input.fte", "FTE", fmtNum(resource.fte, 2), "ratio", "INPUT", `Resource FTE factor`, 0),
|
||||
n("input.dailyHours", "Country Hours", `${dailyHours} h`, "hours", "INPUT", `Base daily working hours (${resource.country?.code ?? "?"})`, 0),
|
||||
n("input.weeklyAvail", "Weekly Avail.", `${weeklyTotalHours}h`, "h/week", "INPUT", `Resource availability: ${availabilityLabel}`, 0),
|
||||
n("input.lcrCents", "LCR", fmtEur(resource.lcrCents), "cents/h", "INPUT", "Loaded Cost Rate per hour", 0),
|
||||
n("input.hoursPerDay", "Hours/Day", fmtNum(avgHoursPerDay), "hours", "INPUT", "Average hours/day across assignments", 0),
|
||||
n("input.absences", "Absences", `${absenceDays.length}`, "count", "INPUT", `Absence days in ${input.month}`, 0),
|
||||
n("input.calcRules", "Active Rules", `${calcRules.length}`, "count", "INPUT", "Active calculation rules", 0),
|
||||
n("input.targetPct", "Target", fmtPct(targetPct), "%", "INPUT", `Chargeability target (${resource.managementLevelGroup?.name ?? "legacy"})`, 0),
|
||||
|
||||
// SAH
|
||||
n("sah.calendarDays", "Calendar Days", `${sahResult.calendarDays}`, "days", "SAH", "Total calendar days in period", 1),
|
||||
n("sah.weekendDays", "Weekend Days", `${sahResult.weekendDays}`, "days", "SAH", "Saturday + Sunday count", 1),
|
||||
n("sah.grossWorkingDays", "Gross Work Days", `${sahResult.grossWorkingDays}`, "days", "SAH", "Calendar days minus weekends", 1, "calendarDays - weekendDays"),
|
||||
n("sah.absenceDays", "Absence Ded.", `${sahResult.absenceDays}`, "days", "SAH", "Absences falling on working days", 1),
|
||||
n("sah.netWorkingDays", "Net Work Days", `${sahResult.netWorkingDays}`, "days", "SAH", "Working days after deductions", 2, "gross - absences"),
|
||||
n("sah.effectiveHoursPerDay", "Eff. Hrs/Day", fmtNum(sahResult.effectiveHoursPerDay), "hours", "SAH", "Average effective hours per net working day", 2, "Σ(dailyHours × FTE) / netDays"),
|
||||
n("sah.sah", "SAH", fmtNum(sahResult.standardAvailableHours), "hours", "SAH", "Standard Available Hours — chargeability denominator", 2, "Σ(dailyHours × FTE) per net day"),
|
||||
|
||||
// ALLOCATION
|
||||
n("alloc.totalHours", "Total Hours", fmtNum(totalAllocHours), "hours", "ALLOCATION", "Sum of effective hours across assignments", 2, "Σ(effectiveHours/day)"),
|
||||
n("alloc.dailyCostCents", "Daily Cost", fmtEur(dailyCostCents), "EUR", "ALLOCATION", "Cost per working day", 1, "hoursPerDay × LCR"),
|
||||
n("alloc.totalCostCents", "Total Cost", fmtEur(totalAllocCostCents), "EUR", "ALLOCATION", "Sum of daily costs", 2, "Σ(dailyCost)"),
|
||||
...(hasRulesEffect ? [
|
||||
n("alloc.chargeableHours", "Chargeable Hrs", fmtNum(totalChargeableHours), "hours", "ALLOCATION", "Rules-adjusted chargeable hours", 2, "rules-adjusted"),
|
||||
n("alloc.projectCostCents", "Project Cost", fmtEur(totalProjectCostCents), "EUR", "ALLOCATION", "Rules-adjusted project cost", 2, "rules-adjusted"),
|
||||
] : []),
|
||||
|
||||
// RULES (only if absences exist)
|
||||
...(absenceDays.length > 0 ? [
|
||||
n("rules.activeRules", "Matched Rules", `${calcRules.length} rules`, "—", "RULES", "Rules evaluated for absence days", 1),
|
||||
n("rules.costEffect", "Cost Effect", hasRulesEffect ? "ZERO" : "—", "—", "RULES", "How absent days affect project cost", 1, "CHARGE / ZERO / REDUCE"),
|
||||
n("rules.chgEffect", "Chg Effect", hasRulesEffect ? "COUNT" : "—", "—", "RULES", "How absent days affect chargeability", 1, "COUNT / SKIP"),
|
||||
] : []),
|
||||
|
||||
// CHARGEABILITY
|
||||
n("chg.chgHours", "Chg Hours", fmtNum(forecast.chg * sahResult.standardAvailableHours), "hours", "CHARGEABILITY", "Total chargeable hours", 2, "Σ(Chg-category slices)"),
|
||||
n("chg.chg", "Chargeability", fmtPct(forecast.chg), "%", "CHARGEABILITY", "Chargeability ratio", 3, "chgHours / SAH"),
|
||||
n("chg.unassigned", "Unassigned", fmtPct(forecast.unassigned), "%", "CHARGEABILITY", `${fmtNum(forecast.unassigned * sahResult.standardAvailableHours)}h of ${fmtNum(sahResult.standardAvailableHours)}h SAH not assigned`, 3, "max(0, SAH - assigned) / SAH"),
|
||||
n("chg.target", "Target", fmtPct(targetPct), "%", "CHARGEABILITY", "Chargeability target from management level", 3),
|
||||
n("chg.gap", "Gap to Target", `${forecast.chg - targetPct >= 0 ? "+" : ""}${((forecast.chg - targetPct) * 100).toFixed(1)} pp`, "pp", "CHARGEABILITY", `Chargeability (${fmtPct(forecast.chg)}) vs. target (${fmtPct(targetPct)})`, 3, "chargeability − target"),
|
||||
|
||||
// Budget nodes (conditionally added above)
|
||||
...budgetNodes,
|
||||
];
|
||||
|
||||
const links: GraphLink[] = [
|
||||
// INPUT → SAH
|
||||
l("input.dailyHours", "sah.grossWorkingDays", "base hours", 1),
|
||||
l("sah.calendarDays", "sah.grossWorkingDays", "− weekends", 2),
|
||||
l("sah.weekendDays", "sah.grossWorkingDays", "−", 1),
|
||||
l("input.absences", "sah.absenceDays", "∩ workdays", 1),
|
||||
l("sah.grossWorkingDays", "sah.netWorkingDays", "−", 2),
|
||||
l("sah.absenceDays", "sah.netWorkingDays", "−", 1),
|
||||
l("input.dailyHours", "sah.effectiveHoursPerDay", "×", 1),
|
||||
l("input.fte", "sah.effectiveHoursPerDay", "× FTE", 2),
|
||||
l("sah.netWorkingDays", "sah.effectiveHoursPerDay", "÷", 1),
|
||||
l("sah.effectiveHoursPerDay", "sah.sah", "× netDays", 2),
|
||||
l("sah.netWorkingDays", "sah.sah", "×", 2),
|
||||
|
||||
// INPUT → ALLOCATION
|
||||
l("input.weeklyAvail", "alloc.totalHours", "caps h/day", 2),
|
||||
l("input.hoursPerDay", "alloc.dailyCostCents", "×", 1),
|
||||
l("input.lcrCents", "alloc.dailyCostCents", "× LCR", 2),
|
||||
l("input.hoursPerDay", "alloc.totalHours", "× workdays", 1),
|
||||
l("alloc.dailyCostCents", "alloc.totalCostCents", "Σ", 2),
|
||||
|
||||
// RULES → ALLOCATION (if absences)
|
||||
...(absenceDays.length > 0 ? [
|
||||
l("input.calcRules", "rules.activeRules", "filter active", 1),
|
||||
l("input.absences", "rules.activeRules", "match trigger", 1),
|
||||
l("rules.activeRules", "rules.costEffect", "→ effect", 1),
|
||||
l("rules.activeRules", "rules.chgEffect", "→ effect", 1),
|
||||
] : []),
|
||||
|
||||
...(hasRulesEffect ? [
|
||||
l("rules.costEffect", "alloc.projectCostCents", "apply", 2),
|
||||
l("alloc.totalCostCents", "alloc.projectCostCents", "adjust", 1),
|
||||
l("rules.chgEffect", "alloc.chargeableHours", "apply", 2),
|
||||
l("alloc.totalHours", "alloc.chargeableHours", "adjust", 1),
|
||||
] : []),
|
||||
|
||||
// ALLOCATION + SAH → CHARGEABILITY
|
||||
l(hasRulesEffect ? "alloc.chargeableHours" : "alloc.totalHours", "chg.chgHours", "Σ Chg", 2),
|
||||
l("chg.chgHours", "chg.chg", "÷ SAH", 2),
|
||||
l("sah.sah", "chg.chg", "÷", 2),
|
||||
l("sah.sah", "chg.unassigned", "− assigned ÷ SAH", 1),
|
||||
l("chg.chgHours", "chg.unassigned", "SAH − Σ", 1),
|
||||
l("input.targetPct", "chg.target", "=", 1),
|
||||
l("chg.chg", "chg.gap", "−", 2),
|
||||
l("chg.target", "chg.gap", "−", 1),
|
||||
|
||||
// Budget links (conditionally added above)
|
||||
...budgetLinks,
|
||||
];
|
||||
|
||||
return {
|
||||
nodes,
|
||||
links,
|
||||
meta: {
|
||||
resourceName: resource.displayName,
|
||||
resourceEid: resource.eid,
|
||||
month: input.month,
|
||||
assignmentCount: assignments.length,
|
||||
},
|
||||
};
|
||||
}),
|
||||
|
||||
/**
|
||||
* Project View: Estimate, Commercial, Budget
|
||||
*/
|
||||
getProjectData: controllerProcedure
|
||||
.input(z.object({
|
||||
projectId: z.string(),
|
||||
}))
|
||||
.query(async ({ ctx, input }) => {
|
||||
const project = await ctx.db.project.findUniqueOrThrow({
|
||||
where: { id: input.projectId },
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
shortCode: true,
|
||||
budgetCents: true,
|
||||
winProbability: true,
|
||||
startDate: true,
|
||||
endDate: true,
|
||||
},
|
||||
});
|
||||
|
||||
// Load latest estimate version with demand lines
|
||||
const estimate = await ctx.db.estimate.findFirst({
|
||||
where: { projectId: input.projectId },
|
||||
select: {
|
||||
id: true,
|
||||
versions: {
|
||||
orderBy: { versionNumber: "desc" },
|
||||
take: 1,
|
||||
select: {
|
||||
id: true,
|
||||
commercialTerms: true,
|
||||
demandLines: {
|
||||
select: {
|
||||
hours: true,
|
||||
costRateCents: true,
|
||||
billRateCents: true,
|
||||
costTotalCents: true,
|
||||
priceTotalCents: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
orderBy: { updatedAt: "desc" },
|
||||
});
|
||||
const latestVersion = estimate?.versions[0];
|
||||
|
||||
const nodes: GraphNode[] = [];
|
||||
const links: GraphLink[] = [];
|
||||
|
||||
// Budget inputs
|
||||
const hasBudget = project.budgetCents > 0;
|
||||
nodes.push(
|
||||
n("input.budgetCents", "Project Budget", hasBudget ? fmtEur(project.budgetCents) : "Not set", hasBudget ? "EUR" : "—", "INPUT", hasBudget ? `Budget for ${project.name}` : `No budget defined for ${project.name}`, 0),
|
||||
n("input.winProbability", "Win Probability", `${project.winProbability}%`, "%", "INPUT", "Project win probability", 0),
|
||||
);
|
||||
|
||||
|
||||
if (latestVersion && latestVersion.demandLines.length > 0) {
|
||||
const lines = latestVersion.demandLines;
|
||||
const totalHours = lines.reduce((s, dl) => s + dl.hours, 0);
|
||||
const totalCostCents = lines.reduce((s, dl) => s + dl.costTotalCents, 0);
|
||||
const totalPriceCents = lines.reduce((s, dl) => s + dl.priceTotalCents, 0);
|
||||
const marginCents = totalPriceCents - totalCostCents;
|
||||
const marginPct = totalPriceCents > 0 ? (marginCents / totalPriceCents) * 100 : 0;
|
||||
|
||||
// Average rates
|
||||
const avgCostRate = totalHours > 0 ? Math.round(totalCostCents / totalHours) : 0;
|
||||
const avgBillRate = totalHours > 0 ? Math.round(totalPriceCents / totalHours) : 0;
|
||||
|
||||
nodes.push(
|
||||
n("input.estLines", "Demand Lines", `${lines.length}`, "count", "INPUT", "Estimate demand line count", 0),
|
||||
n("input.avgCostRate", "Avg Cost Rate", fmtEur(avgCostRate), "cents/h", "INPUT", "Average cost rate across demand lines", 0),
|
||||
n("input.avgBillRate", "Avg Bill Rate", fmtEur(avgBillRate), "cents/h", "INPUT", "Average bill rate across demand lines", 0),
|
||||
n("est.totalHours", "Est. Hours", fmtNum(totalHours), "hours", "ESTIMATE", "Total estimated hours", 2, "Σ(line.hours)"),
|
||||
n("est.totalCostCents", "Est. Cost", fmtEur(totalCostCents), "EUR", "ESTIMATE", "Total estimated cost", 2, "Σ(hours × costRate)"),
|
||||
n("est.totalPriceCents", "Est. Price", fmtEur(totalPriceCents), "EUR", "ESTIMATE", "Total estimated price", 2, "Σ(hours × billRate)"),
|
||||
n("est.marginCents", "Margin", fmtEur(marginCents), "EUR", "ESTIMATE", "Price minus cost", 3, "price - cost"),
|
||||
n("est.marginPercent", "Margin %", `${marginPct.toFixed(1)}%`, "%", "ESTIMATE", "Margin as percentage of price", 3, "margin / price × 100"),
|
||||
);
|
||||
|
||||
links.push(
|
||||
l("input.estLines", "est.totalHours", "Σ hours", 1),
|
||||
l("input.avgCostRate", "est.totalCostCents", "× hours", 2),
|
||||
l("est.totalHours", "est.totalCostCents", "× costRate", 2),
|
||||
l("input.avgBillRate", "est.totalPriceCents", "× hours", 2),
|
||||
l("est.totalHours", "est.totalPriceCents", "× billRate", 2),
|
||||
l("est.totalPriceCents", "est.marginCents", "−", 2),
|
||||
l("est.totalCostCents", "est.marginCents", "−", 2),
|
||||
l("est.marginCents", "est.marginPercent", "÷ price × 100", 2),
|
||||
l("est.totalPriceCents", "est.marginPercent", "÷", 1),
|
||||
);
|
||||
|
||||
// Commercial terms
|
||||
const terms = latestVersion.commercialTerms as { contingencyPercent?: number; discountPercent?: number } | null;
|
||||
if (terms && (terms.contingencyPercent || terms.discountPercent)) {
|
||||
const contingencyPct = terms.contingencyPercent ?? 0;
|
||||
const discountPct = terms.discountPercent ?? 0;
|
||||
const contingencyCents = Math.round(totalCostCents * contingencyPct / 100);
|
||||
const discountCents = Math.round(totalPriceCents * discountPct / 100);
|
||||
const adjCost = totalCostCents + contingencyCents;
|
||||
const adjPrice = totalPriceCents - discountCents;
|
||||
const adjMargin = adjPrice - adjCost;
|
||||
const adjMarginPct = adjPrice > 0 ? (adjMargin / adjPrice) * 100 : 0;
|
||||
|
||||
nodes.push(
|
||||
n("input.contingencyPct", "Contingency %", `${contingencyPct}%`, "%", "INPUT", "Contingency percentage", 0),
|
||||
n("input.discountPct", "Discount %", `${discountPct}%`, "%", "INPUT", "Discount percentage", 0),
|
||||
n("comm.contingencyCents", "Contingency", fmtEur(contingencyCents), "EUR", "COMMERCIAL", "Contingency surcharge", 2, "baseCost × contingency%"),
|
||||
n("comm.discountCents", "Discount", fmtEur(discountCents), "EUR", "COMMERCIAL", "Discount deduction", 2, "basePrice × discount%"),
|
||||
n("comm.adjustedCost", "Adj. Cost", fmtEur(adjCost), "EUR", "COMMERCIAL", "Cost plus contingency", 3, "baseCost + contingency"),
|
||||
n("comm.adjustedPrice", "Adj. Price", fmtEur(adjPrice), "EUR", "COMMERCIAL", "Price minus discount", 3, "basePrice - discount"),
|
||||
n("comm.adjustedMargin", "Adj. Margin", fmtEur(adjMargin), "EUR", "COMMERCIAL", "Adjusted margin", 3, "adjPrice - adjCost"),
|
||||
n("comm.adjustedMarginPct", "Adj. Margin %", `${adjMarginPct.toFixed(1)}%`, "%", "COMMERCIAL", "Adjusted margin percentage", 3, "adjMargin / adjPrice × 100"),
|
||||
);
|
||||
|
||||
links.push(
|
||||
l("est.totalCostCents", "comm.contingencyCents", "×", 1),
|
||||
l("input.contingencyPct", "comm.contingencyCents", "× %", 1),
|
||||
l("est.totalPriceCents", "comm.discountCents", "×", 1),
|
||||
l("input.discountPct", "comm.discountCents", "× %", 1),
|
||||
l("est.totalCostCents", "comm.adjustedCost", "+", 2),
|
||||
l("comm.contingencyCents", "comm.adjustedCost", "+", 2),
|
||||
l("est.totalPriceCents", "comm.adjustedPrice", "−", 2),
|
||||
l("comm.discountCents", "comm.adjustedPrice", "−", 2),
|
||||
l("comm.adjustedPrice", "comm.adjustedMargin", "−", 2),
|
||||
l("comm.adjustedCost", "comm.adjustedMargin", "−", 2),
|
||||
l("comm.adjustedMargin", "comm.adjustedMarginPct", "÷ price × 100", 2),
|
||||
l("comm.adjustedPrice", "comm.adjustedMarginPct", "÷", 1),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Budget status — always show allocation totals; remaining/utilization only when budget > 0
|
||||
const projectAllocs = await ctx.db.assignment.findMany({
|
||||
where: { projectId: input.projectId },
|
||||
select: { status: true, dailyCostCents: true, startDate: true, endDate: true, hoursPerDay: true },
|
||||
});
|
||||
|
||||
if (projectAllocs.length > 0) {
|
||||
const budgetStatus = computeBudgetStatus(
|
||||
project.budgetCents,
|
||||
project.winProbability,
|
||||
projectAllocs.map((pa) => ({
|
||||
status: pa.status as unknown as string,
|
||||
dailyCostCents: pa.dailyCostCents,
|
||||
startDate: pa.startDate,
|
||||
endDate: pa.endDate,
|
||||
hoursPerDay: pa.hoursPerDay,
|
||||
})) as Parameters<typeof computeBudgetStatus>[2],
|
||||
project.startDate ?? new Date(),
|
||||
project.endDate ?? new Date(),
|
||||
);
|
||||
|
||||
nodes.push(
|
||||
n("budget.confirmedCents", "Confirmed", fmtEur(budgetStatus.confirmedCents), "EUR", "BUDGET", "Confirmed allocation costs", 2, "Σ(CONFIRMED allocs)"),
|
||||
n("budget.proposedCents", "Proposed", fmtEur(budgetStatus.proposedCents), "EUR", "BUDGET", "Proposed allocation costs", 2, "Σ(PROPOSED allocs)"),
|
||||
n("budget.allocatedCents", "Allocated", fmtEur(budgetStatus.allocatedCents), "EUR", "BUDGET", "Total allocated", 2, "confirmed + proposed"),
|
||||
n("budget.remainingCents", "Remaining",
|
||||
hasBudget ? fmtEur(budgetStatus.remainingCents) : "N/A",
|
||||
hasBudget ? "EUR" : "—", "BUDGET",
|
||||
hasBudget ? "Remaining budget" : "Cannot compute — no budget set",
|
||||
3, hasBudget ? "budget - allocated" : "needs budget"),
|
||||
n("budget.utilizationPct", "Utilization",
|
||||
hasBudget ? `${budgetStatus.utilizationPercent.toFixed(1)}%` : "N/A",
|
||||
hasBudget ? "%" : "—", "BUDGET",
|
||||
hasBudget ? "Budget utilization" : "Cannot compute — no budget set",
|
||||
3, hasBudget ? "allocated / budget × 100" : "needs budget"),
|
||||
n("budget.weightedCents", "Win-Weighted", fmtEur(budgetStatus.winProbabilityWeightedCents), "EUR", "BUDGET", "Win-weighted cost", 3, "allocated × winProb / 100"),
|
||||
);
|
||||
|
||||
links.push(
|
||||
l("budget.confirmedCents", "budget.allocatedCents", "+", 2),
|
||||
l("budget.proposedCents", "budget.allocatedCents", "+", 2),
|
||||
l("input.budgetCents", "budget.remainingCents", "−", 2),
|
||||
l("budget.allocatedCents", "budget.remainingCents", "−", 2),
|
||||
l("budget.allocatedCents", "budget.utilizationPct", "÷ budget × 100", 2),
|
||||
l("input.budgetCents", "budget.utilizationPct", "÷", 1),
|
||||
l("budget.allocatedCents", "budget.weightedCents", "× winProb / 100", 1),
|
||||
l("input.winProbability", "budget.weightedCents", "×", 1),
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
nodes,
|
||||
links,
|
||||
meta: {
|
||||
projectName: project.name,
|
||||
projectCode: project.shortCode,
|
||||
},
|
||||
};
|
||||
}),
|
||||
});
|
||||
@@ -11,6 +11,9 @@ import { assertBlueprintDynamicFields } from "./blueprint-validation.js";
|
||||
import { buildDynamicFieldWhereClauses } from "./custom-field-filters.js";
|
||||
import { loadProjectPlanningReadModel } from "./project-planning-read-model.js";
|
||||
import { adminProcedure, controllerProcedure, createTRPCRouter, managerProcedure, protectedProcedure, requirePermission } from "../trpc.js";
|
||||
import { createDalleClient, isDalleConfigured, parseAiError } from "../ai-client.js";
|
||||
|
||||
const MAX_COVER_SIZE = 4 * 1024 * 1024; // 4 MB base64 string length limit (client compresses before upload)
|
||||
|
||||
export const projectRouter = createTRPCRouter({
|
||||
list: protectedProcedure
|
||||
@@ -348,4 +351,152 @@ export const projectRouter = createTRPCRouter({
|
||||
|
||||
return { id: input.id, name: project.name };
|
||||
}),
|
||||
|
||||
// ─── Cover Art ──────────────────────────────────────────────────────────────
|
||||
|
||||
generateCover: managerProcedure
|
||||
.input(z.object({
|
||||
projectId: z.string(),
|
||||
prompt: z.string().max(500).optional(),
|
||||
}))
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
requirePermission(ctx, PermissionKey.MANAGE_PROJECTS);
|
||||
|
||||
const project = await findUniqueOrThrow(
|
||||
ctx.db.project.findUnique({
|
||||
where: { id: input.projectId },
|
||||
include: { client: { select: { name: true } } },
|
||||
}),
|
||||
"Project",
|
||||
);
|
||||
|
||||
const settings = await ctx.db.systemSettings.findUnique({
|
||||
where: { id: "singleton" },
|
||||
});
|
||||
|
||||
if (!isDalleConfigured(settings)) {
|
||||
throw new TRPCError({
|
||||
code: "PRECONDITION_FAILED",
|
||||
message: "DALL-E is not configured. Set up the DALL-E deployment in Admin → Settings.",
|
||||
});
|
||||
}
|
||||
|
||||
const clientName = project.client?.name ? ` for ${project.client.name}` : "";
|
||||
const basePrompt = `Professional cover art for a 3D automotive visualization project: "${project.name}"${clientName}. Style: cinematic, modern, photorealistic CGI rendering, dramatic lighting, studio environment. No text or typography in the image.`;
|
||||
const finalPrompt = input.prompt
|
||||
? `${basePrompt} Additional direction: ${input.prompt}`
|
||||
: basePrompt;
|
||||
|
||||
const dalleClient = createDalleClient(settings!);
|
||||
const model = settings!.aiProvider === "azure" ? settings!.azureDalleDeployment! : "dall-e-3";
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
let response: any;
|
||||
try {
|
||||
response = await dalleClient.images.generate({
|
||||
model,
|
||||
prompt: finalPrompt,
|
||||
size: "1024x1024",
|
||||
n: 1,
|
||||
response_format: "b64_json",
|
||||
});
|
||||
} catch (err) {
|
||||
throw new TRPCError({
|
||||
code: "INTERNAL_SERVER_ERROR",
|
||||
message: `DALL-E error: ${parseAiError(err)}`,
|
||||
});
|
||||
}
|
||||
|
||||
const b64 = response.data?.[0]?.b64_json;
|
||||
if (!b64) {
|
||||
throw new TRPCError({
|
||||
code: "INTERNAL_SERVER_ERROR",
|
||||
message: "No image data returned from DALL-E",
|
||||
});
|
||||
}
|
||||
|
||||
const coverImageUrl = `data:image/png;base64,${b64}`;
|
||||
|
||||
await ctx.db.project.update({
|
||||
where: { id: input.projectId },
|
||||
data: { coverImageUrl },
|
||||
});
|
||||
|
||||
return { coverImageUrl };
|
||||
}),
|
||||
|
||||
uploadCover: managerProcedure
|
||||
.input(z.object({
|
||||
projectId: z.string(),
|
||||
imageDataUrl: z.string(),
|
||||
}))
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
requirePermission(ctx, PermissionKey.MANAGE_PROJECTS);
|
||||
|
||||
if (!input.imageDataUrl.startsWith("data:image/")) {
|
||||
throw new TRPCError({
|
||||
code: "BAD_REQUEST",
|
||||
message: "Invalid image format. Must be a data URL starting with 'data:image/'.",
|
||||
});
|
||||
}
|
||||
|
||||
if (input.imageDataUrl.length > MAX_COVER_SIZE) {
|
||||
throw new TRPCError({
|
||||
code: "BAD_REQUEST",
|
||||
message: "Image too large. Maximum compressed size is 4 MB.",
|
||||
});
|
||||
}
|
||||
|
||||
await findUniqueOrThrow(
|
||||
ctx.db.project.findUnique({ where: { id: input.projectId } }),
|
||||
"Project",
|
||||
);
|
||||
|
||||
await ctx.db.project.update({
|
||||
where: { id: input.projectId },
|
||||
data: { coverImageUrl: input.imageDataUrl },
|
||||
});
|
||||
|
||||
return { coverImageUrl: input.imageDataUrl };
|
||||
}),
|
||||
|
||||
removeCover: managerProcedure
|
||||
.input(z.object({ projectId: z.string() }))
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
requirePermission(ctx, PermissionKey.MANAGE_PROJECTS);
|
||||
|
||||
await findUniqueOrThrow(
|
||||
ctx.db.project.findUnique({ where: { id: input.projectId } }),
|
||||
"Project",
|
||||
);
|
||||
|
||||
await ctx.db.project.update({
|
||||
where: { id: input.projectId },
|
||||
data: { coverImageUrl: null },
|
||||
});
|
||||
|
||||
return { ok: true };
|
||||
}),
|
||||
|
||||
updateCoverFocus: managerProcedure
|
||||
.input(z.object({
|
||||
projectId: z.string(),
|
||||
coverFocusY: z.number().int().min(0).max(100),
|
||||
}))
|
||||
.mutation(async ({ ctx, input }) => {
|
||||
requirePermission(ctx, PermissionKey.MANAGE_PROJECTS);
|
||||
await ctx.db.project.update({
|
||||
where: { id: input.projectId },
|
||||
data: { coverFocusY: input.coverFocusY },
|
||||
});
|
||||
return { ok: true };
|
||||
}),
|
||||
|
||||
isDalleConfigured: protectedProcedure
|
||||
.query(async ({ ctx }) => {
|
||||
const settings = await ctx.db.systemSettings.findUnique({
|
||||
where: { id: "singleton" },
|
||||
});
|
||||
return { configured: isDalleConfigured(settings) };
|
||||
}),
|
||||
});
|
||||
|
||||
@@ -42,6 +42,10 @@ export const settingsRouter = createTRPCRouter({
|
||||
anonymizationEnabled: settings?.anonymizationEnabled ?? false,
|
||||
anonymizationDomain: settings?.anonymizationDomain ?? "superhartmut.de",
|
||||
anonymizationMode: settings?.anonymizationMode ?? "global",
|
||||
// DALL-E
|
||||
azureDalleDeployment: settings?.azureDalleDeployment ?? null,
|
||||
azureDalleEndpoint: settings?.azureDalleEndpoint ?? null,
|
||||
hasDalleApiKey: !!settings?.azureDalleApiKey,
|
||||
// Vacation defaults
|
||||
vacationDefaultDays: settings?.vacationDefaultDays ?? 28,
|
||||
};
|
||||
@@ -84,6 +88,10 @@ export const settingsRouter = createTRPCRouter({
|
||||
anonymizationDomain: z.string().trim().min(1).optional(),
|
||||
anonymizationSeed: z.string().trim().min(1).optional().or(z.literal("")),
|
||||
anonymizationMode: z.enum(["global"]).optional(),
|
||||
// DALL-E image generation
|
||||
azureDalleDeployment: z.string().optional(),
|
||||
azureDalleEndpoint: z.string().url().optional().or(z.literal("")),
|
||||
azureDalleApiKey: z.string().optional(),
|
||||
// Vacation
|
||||
vacationDefaultDays: z.number().int().min(0).max(365).optional(),
|
||||
}),
|
||||
@@ -127,6 +135,13 @@ export const settingsRouter = createTRPCRouter({
|
||||
data.anonymizationMode = input.anonymizationMode;
|
||||
data.anonymizationAliases = null;
|
||||
}
|
||||
// DALL-E
|
||||
if (input.azureDalleDeployment !== undefined)
|
||||
data.azureDalleDeployment = input.azureDalleDeployment || null;
|
||||
if (input.azureDalleEndpoint !== undefined)
|
||||
data.azureDalleEndpoint = input.azureDalleEndpoint || null;
|
||||
if (input.azureDalleApiKey !== undefined)
|
||||
data.azureDalleApiKey = input.azureDalleApiKey || null;
|
||||
// Vacation
|
||||
if (input.vacationDefaultDays !== undefined) data.vacationDefaultDays = input.vacationDefaultDays;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user