718 lines
24 KiB
TypeScript
718 lines
24 KiB
TypeScript
import type { TRPCContext } from "../../trpc.js";
|
|
import {
|
|
CreateHolidayCalendarEntrySchema,
|
|
CreateHolidayCalendarSchema,
|
|
PreviewResolvedHolidaysSchema,
|
|
UpdateHolidayCalendarEntrySchema,
|
|
UpdateHolidayCalendarSchema,
|
|
} from "@capakraken/shared";
|
|
import { z } from "zod";
|
|
import type { ToolContext, ToolDef, ToolExecutor } from "./shared.js";
|
|
|
|
type AssistantToolErrorResult = { error: string };
|
|
|
|
type ResolvedResource = {
|
|
id: string;
|
|
};
|
|
|
|
type HolidayCalendarEntryRecord = {
|
|
id: string;
|
|
date: Date;
|
|
name: string;
|
|
isRecurringAnnual?: boolean | null;
|
|
source?: string | null;
|
|
};
|
|
|
|
type HolidayCalendarRecord = {
|
|
id: string;
|
|
name: string;
|
|
scopeType: string;
|
|
stateCode?: string | null;
|
|
isActive?: boolean | null;
|
|
priority?: number | null;
|
|
country?: { id: string; code: string; name: string } | null;
|
|
metroCity?: { id: string; name: string } | null;
|
|
_count?: { entries?: number | null } | null;
|
|
entries?: HolidayCalendarEntryRecord[] | null;
|
|
};
|
|
|
|
type VacationHolidayDeps = {
|
|
createEntitlementCaller: (ctx: TRPCContext) => {
|
|
getBalanceDetail: (params: { resourceId: string; year: number }) => Promise<unknown>;
|
|
};
|
|
createVacationCaller: (ctx: TRPCContext) => {
|
|
list: (params: {
|
|
status: "APPROVED";
|
|
startDate: Date;
|
|
endDate: Date;
|
|
limit: number;
|
|
}) => Promise<Array<{
|
|
type: string;
|
|
startDate: Date;
|
|
endDate: Date;
|
|
isHalfDay?: boolean | null;
|
|
halfDayPart?: string | null;
|
|
resource: {
|
|
displayName: string;
|
|
eid: string;
|
|
chapter?: string | null;
|
|
};
|
|
}>>;
|
|
};
|
|
createHolidayCalendarCaller: (ctx: TRPCContext) => {
|
|
resolveHolidaysDetail: (params: {
|
|
periodStart: Date;
|
|
periodEnd: Date;
|
|
countryCode: string;
|
|
stateCode?: string;
|
|
metroCityName?: string;
|
|
}) => Promise<{
|
|
locationContext: unknown;
|
|
periodStart: string;
|
|
periodEnd: string;
|
|
count: number;
|
|
summary: unknown;
|
|
holidays: unknown[];
|
|
}>;
|
|
resolveResourceHolidaysDetail: (params: {
|
|
resourceId: string;
|
|
periodStart: Date;
|
|
periodEnd: Date;
|
|
}) => Promise<{
|
|
resource: unknown;
|
|
periodStart: string;
|
|
periodEnd: string;
|
|
count: number;
|
|
summary: unknown;
|
|
holidays: unknown[];
|
|
}>;
|
|
listCalendarsDetail: (params: {
|
|
includeInactive?: boolean;
|
|
countryCode?: string;
|
|
scopeType?: "COUNTRY" | "STATE" | "CITY";
|
|
stateCode?: string;
|
|
metroCity?: string;
|
|
}) => Promise<unknown>;
|
|
getCalendarByIdentifierDetail: (params: { identifier: string }) => Promise<unknown>;
|
|
previewResolvedHolidaysDetail: (
|
|
params: z.input<typeof PreviewResolvedHolidaysSchema>,
|
|
) => Promise<unknown>;
|
|
createCalendar: (
|
|
params: z.input<typeof CreateHolidayCalendarSchema>,
|
|
) => Promise<HolidayCalendarRecord>;
|
|
updateCalendar: (params: {
|
|
id: string;
|
|
data: z.input<typeof UpdateHolidayCalendarSchema>;
|
|
}) => Promise<HolidayCalendarRecord>;
|
|
deleteCalendar: (params: { id: string }) => Promise<{ name: string }>;
|
|
createEntry: (
|
|
params: z.input<typeof CreateHolidayCalendarEntrySchema>,
|
|
) => Promise<HolidayCalendarEntryRecord>;
|
|
updateEntry: (params: {
|
|
id: string;
|
|
data: z.input<typeof UpdateHolidayCalendarEntrySchema>;
|
|
}) => Promise<HolidayCalendarEntryRecord>;
|
|
deleteEntry: (params: { id: string }) => Promise<{ name: string }>;
|
|
};
|
|
createScopedCallerContext: (ctx: ToolContext) => TRPCContext;
|
|
resolveResourceIdentifier: (
|
|
ctx: ToolContext,
|
|
identifier: string,
|
|
) => Promise<ResolvedResource | AssistantToolErrorResult>;
|
|
resolveHolidayPeriod: (input: {
|
|
year?: number;
|
|
periodStart?: string;
|
|
periodEnd?: string;
|
|
}) => { year: number | null; periodStart: Date; periodEnd: Date };
|
|
resolveEntityOrAssistantError: <T>(
|
|
resolve: () => Promise<T>,
|
|
notFoundMessage: string,
|
|
) => Promise<T | AssistantToolErrorResult>;
|
|
assertAdminRole: (ctx: ToolContext) => void;
|
|
fmtDate: (value: Date | null | undefined) => string | null;
|
|
formatHolidayCalendar: (calendar: HolidayCalendarRecord) => unknown;
|
|
formatHolidayCalendarEntry: (entry: HolidayCalendarEntryRecord) => unknown;
|
|
toAssistantHolidayCalendarMutationError: (
|
|
error: unknown,
|
|
) => AssistantToolErrorResult | null;
|
|
toAssistantHolidayCalendarNotFoundError: (
|
|
error: unknown,
|
|
) => AssistantToolErrorResult | null;
|
|
toAssistantHolidayEntryMutationError: (
|
|
error: unknown,
|
|
) => AssistantToolErrorResult | null;
|
|
toAssistantHolidayEntryNotFoundError: (
|
|
error: unknown,
|
|
) => AssistantToolErrorResult | null;
|
|
};
|
|
|
|
export const vacationHolidayReadToolDefinitions: ToolDef[] = [
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "get_vacation_balance",
|
|
description: "Get the holiday-aware vacation balance for a resource via the real entitlement workflow. Authenticated users can read their own balance; manager/admin/controller can read broader balances.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
resourceId: { type: "string", description: "Resource ID, EID, or display name" },
|
|
year: { type: "integer", description: "Year. Default: current year" },
|
|
},
|
|
required: ["resourceId"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "list_vacations_upcoming",
|
|
description: "List upcoming vacations across all resources, or for a specific resource/team. Shows who is off when.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
resourceName: { type: "string", description: "Filter by resource name (partial match)" },
|
|
chapter: { type: "string", description: "Filter by chapter/team" },
|
|
daysAhead: { type: "integer", description: "How many days ahead to look. Default: 30" },
|
|
limit: { type: "integer", description: "Max results. Default: 30" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "list_holidays_by_region",
|
|
description: "List resolved public holidays for a country, federal state, and optionally a city in a given year or date range. Use this to compare regions such as Bayern vs Hamburg.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
countryCode: { type: "string", description: "Country code such as DE, ES, US, IN." },
|
|
federalState: { type: "string", description: "Federal state / region code, e.g. BY, HH, NRW." },
|
|
metroCity: { type: "string", description: "Optional city name for local city-specific holidays, e.g. Augsburg." },
|
|
year: { type: "integer", description: "Full year, e.g. 2026. Default: current year." },
|
|
periodStart: { type: "string", description: "Optional start date in YYYY-MM-DD. Requires periodEnd." },
|
|
periodEnd: { type: "string", description: "Optional end date in YYYY-MM-DD. Requires periodStart." },
|
|
},
|
|
required: ["countryCode"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "get_resource_holidays",
|
|
description: "List resolved public holidays for a specific resource based on that person's country, federal state, and city context.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
identifier: { type: "string", description: "Resource ID, EID, or display name." },
|
|
year: { type: "integer", description: "Full year, e.g. 2026. Default: current year." },
|
|
periodStart: { type: "string", description: "Optional start date in YYYY-MM-DD. Requires periodEnd." },
|
|
periodEnd: { type: "string", description: "Optional end date in YYYY-MM-DD. Requires periodStart." },
|
|
},
|
|
required: ["identifier"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "list_holiday_calendars",
|
|
description: "List holiday calendars including scope, assignment, active flag, priority, and entry count. Useful to inspect the calendar-editor configuration context.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
includeInactive: { type: "boolean", description: "Include inactive calendars. Default: false." },
|
|
countryCode: { type: "string", description: "Optional country code filter such as DE or ES." },
|
|
scopeType: { type: "string", description: "Optional scope filter: COUNTRY, STATE, CITY." },
|
|
stateCode: { type: "string", description: "Optional state/region code filter such as BY or NRW." },
|
|
metroCity: { type: "string", description: "Optional city-name filter." },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "get_holiday_calendar",
|
|
description: "Get a single holiday calendar including all entries. Accepts either the calendar ID or its name.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
identifier: { type: "string", description: "Holiday calendar ID or name." },
|
|
},
|
|
required: ["identifier"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "preview_resolved_holiday_calendar",
|
|
description: "Preview the resolved holiday result for a country/state/city scope and year, including which calendar each holiday comes from.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
countryId: { type: "string", description: "Country ID." },
|
|
stateCode: { type: "string", description: "Optional state/region code." },
|
|
metroCityId: { type: "string", description: "Optional metro city ID for city-specific preview." },
|
|
year: { type: "integer", description: "Full year, e.g. 2026." },
|
|
},
|
|
required: ["countryId", "year"],
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
export const vacationHolidayMutationToolDefinitions: ToolDef[] = [
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "create_holiday_calendar",
|
|
description: "Create a holiday calendar for a country, state, or city scope. Admin role required. Always confirm first.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
name: { type: "string", description: "Calendar name." },
|
|
scopeType: { type: "string", description: "COUNTRY, STATE, or CITY." },
|
|
countryId: { type: "string", description: "Country ID." },
|
|
stateCode: { type: "string", description: "Required for STATE calendars." },
|
|
metroCityId: { type: "string", description: "Required for CITY calendars." },
|
|
isActive: { type: "boolean", description: "Whether the calendar is active. Default: true." },
|
|
priority: { type: "integer", description: "Priority used during calendar resolution. Default: 0." },
|
|
},
|
|
required: ["name", "scopeType", "countryId"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "update_holiday_calendar",
|
|
description: "Update an existing holiday calendar. Admin role required. Always confirm first.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
id: { type: "string", description: "Holiday calendar ID." },
|
|
data: {
|
|
type: "object",
|
|
properties: {
|
|
name: { type: "string" },
|
|
stateCode: { type: "string" },
|
|
metroCityId: { type: "string" },
|
|
isActive: { type: "boolean" },
|
|
priority: { type: "integer" },
|
|
},
|
|
},
|
|
},
|
|
required: ["id", "data"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "delete_holiday_calendar",
|
|
description: "Delete a holiday calendar and all of its entries. Admin role required. Always confirm first.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
id: { type: "string", description: "Holiday calendar ID." },
|
|
},
|
|
required: ["id"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "create_holiday_calendar_entry",
|
|
description: "Create a holiday entry in an existing calendar. Admin role required. Always confirm first.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
holidayCalendarId: { type: "string", description: "Holiday calendar ID." },
|
|
date: { type: "string", description: "Date in YYYY-MM-DD format." },
|
|
name: { type: "string", description: "Holiday name." },
|
|
isRecurringAnnual: { type: "boolean", description: "Whether the holiday repeats every year." },
|
|
source: { type: "string", description: "Optional source or legal basis." },
|
|
},
|
|
required: ["holidayCalendarId", "date", "name"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "update_holiday_calendar_entry",
|
|
description: "Update an existing holiday calendar entry. Admin role required. Always confirm first.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
id: { type: "string", description: "Holiday calendar entry ID." },
|
|
data: {
|
|
type: "object",
|
|
properties: {
|
|
date: { type: "string", description: "Date in YYYY-MM-DD format." },
|
|
name: { type: "string" },
|
|
isRecurringAnnual: { type: "boolean" },
|
|
source: { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
required: ["id", "data"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "delete_holiday_calendar_entry",
|
|
description: "Delete a holiday calendar entry. Admin role required. Always confirm first.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
id: { type: "string", description: "Holiday calendar entry ID." },
|
|
},
|
|
required: ["id"],
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
export function createVacationHolidayExecutors(
|
|
deps: VacationHolidayDeps,
|
|
): Record<string, ToolExecutor> {
|
|
return {
|
|
async get_vacation_balance(params: { resourceId: string; year?: number }, ctx: ToolContext) {
|
|
const year = params.year ?? new Date().getFullYear();
|
|
const resource = await deps.resolveResourceIdentifier(ctx, params.resourceId);
|
|
if ("error" in resource) {
|
|
return resource;
|
|
}
|
|
|
|
const caller = deps.createEntitlementCaller(deps.createScopedCallerContext(ctx));
|
|
return caller.getBalanceDetail({ resourceId: resource.id, year });
|
|
},
|
|
|
|
async list_vacations_upcoming(params: {
|
|
resourceName?: string;
|
|
chapter?: string;
|
|
daysAhead?: number;
|
|
limit?: number;
|
|
}, ctx: ToolContext) {
|
|
const daysAhead = params.daysAhead ?? 30;
|
|
const limit = Math.min(params.limit ?? 30, 50);
|
|
const caller = deps.createVacationCaller(deps.createScopedCallerContext(ctx));
|
|
const now = new Date();
|
|
const until = new Date(now.getTime() + daysAhead * 24 * 60 * 60 * 1000);
|
|
|
|
const vacations = await caller.list({
|
|
status: "APPROVED",
|
|
startDate: now,
|
|
endDate: until,
|
|
limit,
|
|
});
|
|
|
|
return vacations
|
|
.filter((vacation) => {
|
|
if (params.resourceName) {
|
|
const resourceName = vacation.resource.displayName.toLowerCase();
|
|
if (!resourceName.includes(params.resourceName.toLowerCase())) {
|
|
return false;
|
|
}
|
|
}
|
|
if (params.chapter) {
|
|
const chapter = vacation.resource.chapter?.toLowerCase() ?? "";
|
|
if (!chapter.includes(params.chapter.toLowerCase())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
})
|
|
.slice(0, limit)
|
|
.map((vacation) => ({
|
|
resource: vacation.resource.displayName,
|
|
eid: vacation.resource.eid,
|
|
chapter: vacation.resource.chapter ?? null,
|
|
type: vacation.type,
|
|
start: deps.fmtDate(vacation.startDate),
|
|
end: deps.fmtDate(vacation.endDate),
|
|
isHalfDay: vacation.isHalfDay,
|
|
halfDayPart: vacation.halfDayPart,
|
|
}));
|
|
},
|
|
|
|
async list_holidays_by_region(params: {
|
|
countryCode: string;
|
|
federalState?: string;
|
|
metroCity?: string;
|
|
year?: number;
|
|
periodStart?: string;
|
|
periodEnd?: string;
|
|
}, ctx: ToolContext) {
|
|
const { year, periodStart, periodEnd } = deps.resolveHolidayPeriod(params);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
const resolved = await caller.resolveHolidaysDetail({
|
|
periodStart,
|
|
periodEnd,
|
|
countryCode: params.countryCode.trim().toUpperCase(),
|
|
...(params.federalState ? { stateCode: params.federalState } : {}),
|
|
...(params.metroCity ? { metroCityName: params.metroCity } : {}),
|
|
});
|
|
|
|
return {
|
|
locationContext: resolved.locationContext,
|
|
year,
|
|
periodStart: resolved.periodStart,
|
|
periodEnd: resolved.periodEnd,
|
|
count: resolved.count,
|
|
summary: resolved.summary,
|
|
holidays: resolved.holidays,
|
|
};
|
|
},
|
|
|
|
async get_resource_holidays(params: {
|
|
identifier: string;
|
|
year?: number;
|
|
periodStart?: string;
|
|
periodEnd?: string;
|
|
}, ctx: ToolContext) {
|
|
const resource = await deps.resolveResourceIdentifier(ctx, params.identifier);
|
|
if ("error" in resource) {
|
|
return resource;
|
|
}
|
|
|
|
const { year, periodStart, periodEnd } = deps.resolveHolidayPeriod(params);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
const resolved = await caller.resolveResourceHolidaysDetail({
|
|
resourceId: resource.id,
|
|
periodStart,
|
|
periodEnd,
|
|
});
|
|
|
|
return {
|
|
resource: resolved.resource,
|
|
year,
|
|
periodStart: resolved.periodStart,
|
|
periodEnd: resolved.periodEnd,
|
|
count: resolved.count,
|
|
summary: resolved.summary,
|
|
holidays: resolved.holidays,
|
|
};
|
|
},
|
|
|
|
async list_holiday_calendars(params: {
|
|
includeInactive?: boolean;
|
|
countryCode?: string;
|
|
scopeType?: "COUNTRY" | "STATE" | "CITY";
|
|
stateCode?: string;
|
|
metroCity?: string;
|
|
}, ctx: ToolContext) {
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
return caller.listCalendarsDetail(params);
|
|
},
|
|
|
|
async get_holiday_calendar(params: { identifier: string }, ctx: ToolContext) {
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
const identifier = params.identifier.trim();
|
|
return deps.resolveEntityOrAssistantError(
|
|
() => caller.getCalendarByIdentifierDetail({ identifier }),
|
|
`Holiday calendar not found: ${identifier}`,
|
|
);
|
|
},
|
|
|
|
async preview_resolved_holiday_calendar(params: {
|
|
countryId: string;
|
|
stateCode?: string;
|
|
metroCityId?: string;
|
|
year: number;
|
|
}, ctx: ToolContext) {
|
|
const input = PreviewResolvedHolidaysSchema.parse(params);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
return caller.previewResolvedHolidaysDetail(input);
|
|
},
|
|
|
|
async create_holiday_calendar(params: {
|
|
name: string;
|
|
scopeType: "COUNTRY" | "STATE" | "CITY";
|
|
countryId: string;
|
|
stateCode?: string;
|
|
metroCityId?: string;
|
|
isActive?: boolean;
|
|
priority?: number;
|
|
}, ctx: ToolContext) {
|
|
deps.assertAdminRole(ctx);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
|
|
let created;
|
|
try {
|
|
created = await caller.createCalendar(CreateHolidayCalendarSchema.parse(params));
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantHolidayCalendarMutationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate" as const,
|
|
scope: ["holidayCalendar", "vacation"],
|
|
success: true,
|
|
calendar: deps.formatHolidayCalendar(created),
|
|
message: `Created holiday calendar: ${created.name}`,
|
|
};
|
|
},
|
|
|
|
async update_holiday_calendar(params: {
|
|
id: string;
|
|
data: {
|
|
name?: string;
|
|
stateCode?: string | null;
|
|
metroCityId?: string | null;
|
|
isActive?: boolean;
|
|
priority?: number;
|
|
};
|
|
}, ctx: ToolContext) {
|
|
deps.assertAdminRole(ctx);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
const input = {
|
|
id: params.id,
|
|
data: UpdateHolidayCalendarSchema.parse(params.data),
|
|
};
|
|
|
|
let updated;
|
|
try {
|
|
updated = await caller.updateCalendar(input);
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantHolidayCalendarMutationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate" as const,
|
|
scope: ["holidayCalendar", "vacation"],
|
|
success: true,
|
|
calendar: deps.formatHolidayCalendar(updated),
|
|
message: `Updated holiday calendar: ${updated.name}`,
|
|
};
|
|
},
|
|
|
|
async delete_holiday_calendar(params: { id: string }, ctx: ToolContext) {
|
|
deps.assertAdminRole(ctx);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
|
|
let deleted;
|
|
try {
|
|
deleted = await caller.deleteCalendar({ id: params.id });
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantHolidayCalendarNotFoundError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate" as const,
|
|
scope: ["holidayCalendar", "vacation"],
|
|
success: true,
|
|
message: `Deleted holiday calendar: ${deleted.name}`,
|
|
};
|
|
},
|
|
|
|
async create_holiday_calendar_entry(params: {
|
|
holidayCalendarId: string;
|
|
date: string;
|
|
name: string;
|
|
isRecurringAnnual?: boolean;
|
|
source?: string;
|
|
}, ctx: ToolContext) {
|
|
deps.assertAdminRole(ctx);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
|
|
let created;
|
|
try {
|
|
created = await caller.createEntry(CreateHolidayCalendarEntrySchema.parse(params));
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantHolidayEntryMutationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate" as const,
|
|
scope: ["holidayCalendar", "vacation"],
|
|
success: true,
|
|
entry: deps.formatHolidayCalendarEntry(created),
|
|
message: `Created holiday entry: ${created.name}`,
|
|
};
|
|
},
|
|
|
|
async update_holiday_calendar_entry(params: {
|
|
id: string;
|
|
data: {
|
|
date?: string;
|
|
name?: string;
|
|
isRecurringAnnual?: boolean;
|
|
source?: string | null;
|
|
};
|
|
}, ctx: ToolContext) {
|
|
deps.assertAdminRole(ctx);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
const input = {
|
|
id: params.id,
|
|
data: UpdateHolidayCalendarEntrySchema.parse(params.data),
|
|
};
|
|
|
|
let updated;
|
|
try {
|
|
updated = await caller.updateEntry(input);
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantHolidayEntryMutationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate" as const,
|
|
scope: ["holidayCalendar", "vacation"],
|
|
success: true,
|
|
entry: deps.formatHolidayCalendarEntry(updated),
|
|
message: `Updated holiday entry: ${updated.name}`,
|
|
};
|
|
},
|
|
|
|
async delete_holiday_calendar_entry(params: { id: string }, ctx: ToolContext) {
|
|
deps.assertAdminRole(ctx);
|
|
const caller = deps.createHolidayCalendarCaller(deps.createScopedCallerContext(ctx));
|
|
|
|
let deleted;
|
|
try {
|
|
deleted = await caller.deleteEntry({ id: params.id });
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantHolidayEntryNotFoundError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate" as const,
|
|
scope: ["holidayCalendar", "vacation"],
|
|
success: true,
|
|
message: `Deleted holiday entry: ${deleted.name}`,
|
|
};
|
|
},
|
|
};
|
|
}
|