L1 Stammdaten: Services, Dublettenprüfung, Server Actions und API v1
Kunden (Nummernkreis, Ansprechpartner, vorläufig bestätigen, Zusammenführen mit Bestätigung), Objekte inkl. Historie, Teams mit Mitgliedschaften, Dublettenlogik (lib + Service), API-Kontext/Antwortformat unter src/server/api und die Endpunkte /api/v1/customers, /api/v1/sites, /api/v1/sites/[id]/history. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5
@@ -0,0 +1,47 @@
|
||||
import { writeAuditLog } from "@/server/audit";
|
||||
import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
|
||||
import { customerScope } from "@/server/services/work-orders/visibility";
|
||||
import { contactSchema, type ContactInput } from "@/server/services/customers/schemas";
|
||||
|
||||
async function requireWritableCustomer(ctx: ServiceCtx, customerId: string) {
|
||||
const customer = await ctx.db.customer.findFirst({
|
||||
where: { AND: [{ id: customerId }, await customerScope(ctx), { status: { not: "merged" } }] },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!customer) throw new ServiceError("not_found", "customer not found");
|
||||
return customer;
|
||||
}
|
||||
|
||||
async function requireContact(ctx: ServiceCtx, contactId: string) {
|
||||
const contact = await ctx.db.contact.findFirst({
|
||||
where: { id: contactId, deletedAt: null, customer: { AND: [await customerScope(ctx), { status: { not: "merged" } }] } },
|
||||
});
|
||||
if (!contact) throw new ServiceError("not_found", "contact not found");
|
||||
return contact;
|
||||
}
|
||||
|
||||
export async function createContact(ctx: ServiceCtx, customerId: string, input: ContactInput) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const data = contactSchema.parse(input);
|
||||
await requireWritableCustomer(ctx, customerId);
|
||||
const contact = await ctx.db.contact.create({ data: { ...data, tenantId: ctx.tenantId, customerId } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "create", entity: "contact", entityId: contact.id, after: contact });
|
||||
return contact;
|
||||
}
|
||||
|
||||
export async function updateContact(ctx: ServiceCtx, contactId: string, input: ContactInput) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const data = contactSchema.parse(input);
|
||||
const before = await requireContact(ctx, contactId);
|
||||
const after = await ctx.db.contact.update({ where: { id: contactId }, data });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "update", entity: "contact", entityId: contactId, before, after });
|
||||
return after;
|
||||
}
|
||||
|
||||
export async function deleteContact(ctx: ServiceCtx, contactId: string) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const before = await requireContact(ctx, contactId);
|
||||
const after = await ctx.db.contact.update({ where: { id: contactId }, data: { deletedAt: new Date() } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "delete", entity: "contact", entityId: contactId, before, after });
|
||||
return after;
|
||||
}
|
||||
@@ -0,0 +1,239 @@
|
||||
import type { Prisma } from "@prisma/client";
|
||||
import { writeAuditLog } from "@/server/audit";
|
||||
import { nextNumber } from "@/server/services/numbering";
|
||||
import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
|
||||
import { customerScope, workOrderScope } from "@/server/services/work-orders/visibility";
|
||||
import { findDuplicateCustomers } from "@/server/services/customers/duplicates";
|
||||
import {
|
||||
customerCreateSchema,
|
||||
customerPatchSchema,
|
||||
type CustomerCreateInput,
|
||||
type CustomerPatchInput,
|
||||
} from "@/server/services/customers/schemas";
|
||||
|
||||
export const CUSTOMER_LIST_STATUSES = ["active", "inactive", "provisional", "merged"] as const;
|
||||
export type CustomerListStatus = (typeof CUSTOMER_LIST_STATUSES)[number];
|
||||
|
||||
const CLOSED_ORDER_STATUSES = ["billed", "cancelled"] as const;
|
||||
|
||||
function isUniqueViolation(err: unknown): boolean {
|
||||
return (err as { code?: string })?.code === "P2002";
|
||||
}
|
||||
|
||||
/** Customer ids are only visible within the user's scope; everything else is "not found". */
|
||||
async function findVisibleCustomer(ctx: ServiceCtx, id: string, extra: Prisma.CustomerWhereInput = {}) {
|
||||
return ctx.db.customer.findFirst({ where: { AND: [{ id }, await customerScope(ctx), extra] } });
|
||||
}
|
||||
|
||||
export async function listCustomers(
|
||||
ctx: ServiceCtx,
|
||||
opts: { q?: string; status?: CustomerListStatus | "all"; page?: number; pageSize?: number } = {},
|
||||
) {
|
||||
assertCan(ctx, "customer:read");
|
||||
const page = Math.max(1, opts.page ?? 1);
|
||||
const pageSize = Math.min(100, Math.max(1, opts.pageSize ?? 25));
|
||||
const q = opts.q?.trim();
|
||||
const statusFilter: Prisma.CustomerWhereInput =
|
||||
!opts.status || opts.status === "all" ? { status: { not: "merged" } } : { status: opts.status };
|
||||
const where: Prisma.CustomerWhereInput = {
|
||||
AND: [
|
||||
await customerScope(ctx),
|
||||
statusFilter,
|
||||
q
|
||||
? {
|
||||
OR: [
|
||||
{ customerNumber: { contains: q, mode: "insensitive" } },
|
||||
{ companyName: { contains: q, mode: "insensitive" } },
|
||||
{ firstName: { contains: q, mode: "insensitive" } },
|
||||
{ lastName: { contains: q, mode: "insensitive" } },
|
||||
{ city: { contains: q, mode: "insensitive" } },
|
||||
{ email: { contains: q, mode: "insensitive" } },
|
||||
],
|
||||
}
|
||||
: {},
|
||||
],
|
||||
};
|
||||
const [total, items] = await Promise.all([
|
||||
ctx.db.customer.count({ where }),
|
||||
ctx.db.customer.findMany({
|
||||
where,
|
||||
orderBy: [{ companyName: "asc" }, { lastName: "asc" }, { createdAt: "asc" }],
|
||||
skip: (page - 1) * pageSize,
|
||||
take: pageSize,
|
||||
select: {
|
||||
id: true,
|
||||
customerNumber: true,
|
||||
companyName: true,
|
||||
salutation: true,
|
||||
firstName: true,
|
||||
lastName: true,
|
||||
postalCode: true,
|
||||
city: true,
|
||||
phone: true,
|
||||
email: true,
|
||||
status: true,
|
||||
updatedAt: true,
|
||||
_count: { select: { sites: { where: { deletedAt: null } } } },
|
||||
},
|
||||
}),
|
||||
]);
|
||||
return { items, total, page, pageSize };
|
||||
}
|
||||
|
||||
export async function getCustomer(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "customer:read");
|
||||
const customer = await ctx.db.customer.findFirst({
|
||||
where: { AND: [{ id }, await customerScope(ctx)] },
|
||||
include: { contacts: { where: { deletedAt: null }, orderBy: { name: "asc" } } },
|
||||
});
|
||||
if (!customer) throw new ServiceError("not_found", "customer not found");
|
||||
return customer;
|
||||
}
|
||||
|
||||
/** Lightweight options for selects (sites form, merge target). */
|
||||
export async function customerOptions(ctx: ServiceCtx, opts: { take?: number } = {}) {
|
||||
assertCan(ctx, "customer:read");
|
||||
return ctx.db.customer.findMany({
|
||||
where: { AND: [await customerScope(ctx), { status: { in: ["active", "provisional"] } }] },
|
||||
select: { id: true, customerNumber: true, companyName: true, firstName: true, lastName: true, city: true },
|
||||
orderBy: [{ companyName: "asc" }, { lastName: "asc" }],
|
||||
take: opts.take ?? 500,
|
||||
});
|
||||
}
|
||||
|
||||
async function assertNumberFree(ctx: ServiceCtx, customerNumber: string, exceptId?: string) {
|
||||
const clash = await ctx.db.customer.findFirst({
|
||||
where: { customerNumber, ...(exceptId ? { id: { not: exceptId } } : {}) },
|
||||
select: { id: true },
|
||||
});
|
||||
if (clash) throw new ServiceError("conflict", "customer number taken", { field: "customerNumber", reason: "number_taken" });
|
||||
}
|
||||
|
||||
/** Next free sequence number; skips values already taken by manually entered numbers. */
|
||||
async function allocateCustomerNumber(ctx: ServiceCtx): Promise<string> {
|
||||
for (let i = 0; i < 20; i++) {
|
||||
const candidate = await nextNumber(ctx.db, ctx.tenantId, "customer");
|
||||
const taken = await ctx.db.customer.findFirst({ where: { customerNumber: candidate }, select: { id: true } });
|
||||
if (!taken) return candidate;
|
||||
}
|
||||
throw new ServiceError("conflict", "could not allocate customer number", { reason: "number_allocation" });
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a customer. Runs the duplicate check first; if possible duplicates exist and the caller
|
||||
* has not acknowledged them, throws `conflict` with `details.reason = "possible_duplicates"` and
|
||||
* `details.candidates` — the UI shows "Mögliche Dublette" and lets the user decide.
|
||||
*/
|
||||
export async function createCustomer(ctx: ServiceCtx, input: CustomerCreateInput, opts: { acknowledgeDuplicates?: boolean } = {}) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const data = customerCreateSchema.parse(input);
|
||||
|
||||
// a taken number is a hard conflict — acknowledging a duplicate hint could not resolve it
|
||||
if (data.customerNumber) await assertNumberFree(ctx, data.customerNumber);
|
||||
|
||||
if (!opts.acknowledgeDuplicates) {
|
||||
const candidates = await findDuplicateCustomers(ctx, data);
|
||||
if (candidates.length > 0) {
|
||||
throw new ServiceError("conflict", "possible duplicates", { reason: "possible_duplicates", candidates });
|
||||
}
|
||||
}
|
||||
|
||||
const customerNumber = data.customerNumber ?? (await allocateCustomerNumber(ctx));
|
||||
const status = data.status ?? "active";
|
||||
|
||||
let customer;
|
||||
try {
|
||||
customer = await ctx.db.customer.create({
|
||||
data: {
|
||||
...data,
|
||||
tenantId: ctx.tenantId,
|
||||
customerNumber,
|
||||
country: data.country ?? "DE",
|
||||
status,
|
||||
isProvisional: status === "provisional",
|
||||
createdById: ctx.userId,
|
||||
},
|
||||
});
|
||||
} catch (err) {
|
||||
if (isUniqueViolation(err)) throw new ServiceError("conflict", "customer number taken", { field: "customerNumber", reason: "number_taken" });
|
||||
throw err;
|
||||
}
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "create", entity: "customer", entityId: customer.id, after: customer });
|
||||
return customer;
|
||||
}
|
||||
|
||||
export async function updateCustomer(ctx: ServiceCtx, id: string, patch: CustomerPatchInput) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const data = customerPatchSchema.parse(patch);
|
||||
const before = await findVisibleCustomer(ctx, id, { status: { not: "merged" } });
|
||||
if (!before) throw new ServiceError("not_found", "customer not found");
|
||||
|
||||
const merged = { companyName: before.companyName, lastName: before.lastName, ...data };
|
||||
if (!merged.companyName && !merged.lastName) {
|
||||
throw new ServiceError("invalid", "name required", { field: "companyName", reason: "name_required" });
|
||||
}
|
||||
if (data.customerNumber === null) delete data.customerNumber; // the number can be changed, not removed
|
||||
if (data.customerNumber && data.customerNumber !== before.customerNumber) await assertNumberFree(ctx, data.customerNumber, id);
|
||||
|
||||
let after;
|
||||
try {
|
||||
after = await ctx.db.customer.update({
|
||||
where: { id },
|
||||
data: {
|
||||
...data,
|
||||
...(data.status ? { isProvisional: data.status === "provisional" } : {}),
|
||||
},
|
||||
});
|
||||
} catch (err) {
|
||||
if (isUniqueViolation(err)) throw new ServiceError("conflict", "customer number taken", { field: "customerNumber", reason: "number_taken" });
|
||||
throw err;
|
||||
}
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "update", entity: "customer", entityId: id, before, after });
|
||||
return after;
|
||||
}
|
||||
|
||||
/** Soft delete (spec §27.5). Blocked while open work orders reference the customer. */
|
||||
export async function deleteCustomer(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const before = await findVisibleCustomer(ctx, id);
|
||||
if (!before) throw new ServiceError("not_found", "customer not found");
|
||||
const open = await ctx.db.workOrder.count({
|
||||
where: { customerId: id, deletedAt: null, status: { notIn: [...CLOSED_ORDER_STATUSES] } },
|
||||
});
|
||||
if (open > 0) throw new ServiceError("blocked", "customer has open work orders", { reason: "open_work_orders", count: open });
|
||||
const after = await ctx.db.customer.update({ where: { id }, data: { deletedAt: new Date(), status: "inactive" } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "delete", entity: "customer", entityId: id, before, after });
|
||||
return after;
|
||||
}
|
||||
|
||||
/** provisional → active (used by the emergency lane's backoffice review). */
|
||||
export async function confirmProvisionalCustomer(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "customer:write");
|
||||
const before = await findVisibleCustomer(ctx, id);
|
||||
if (!before) throw new ServiceError("not_found", "customer not found");
|
||||
if (before.status !== "provisional") throw new ServiceError("conflict", "customer is not provisional", { reason: "not_provisional" });
|
||||
const after = await ctx.db.customer.update({ where: { id }, data: { status: "active", isProvisional: false } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "update", entity: "customer", entityId: id, before, after });
|
||||
return after;
|
||||
}
|
||||
|
||||
/** Read-only order list for the customer detail tab (work order scope applies). */
|
||||
export async function listCustomerWorkOrders(ctx: ServiceCtx, customerId: string, opts: { take?: number } = {}) {
|
||||
await getCustomer(ctx, customerId);
|
||||
return ctx.db.workOrder.findMany({
|
||||
where: { AND: [{ customerId }, await workOrderScope(ctx)] },
|
||||
orderBy: [{ plannedStart: "desc" }, { createdAt: "desc" }],
|
||||
take: opts.take ?? 100,
|
||||
select: {
|
||||
id: true,
|
||||
number: true,
|
||||
title: true,
|
||||
status: true,
|
||||
plannedStart: true,
|
||||
createdAt: true,
|
||||
site: { select: { id: true, name: true } },
|
||||
team: { select: { name: true } },
|
||||
orderType: { select: { name: true } },
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
import type { Prisma } from "@prisma/client";
|
||||
import { assertCan, type ServiceCtx } from "@/server/services/context";
|
||||
import { customerScope } from "@/server/services/work-orders/visibility";
|
||||
import {
|
||||
DUPLICATE_THRESHOLD,
|
||||
normalizeCompanyName,
|
||||
normalizePhone,
|
||||
normalizeText,
|
||||
scoreDuplicate,
|
||||
type DuplicateCandidateInput,
|
||||
type DuplicateReason,
|
||||
} from "@/lib/customers/duplicates";
|
||||
import { customerDisplayName } from "@/server/services/customers/format";
|
||||
|
||||
export type DuplicateCandidate = {
|
||||
customerId: string;
|
||||
score: number;
|
||||
reasons: DuplicateReason[];
|
||||
customerNumber: string | null;
|
||||
displayName: string;
|
||||
city: string | null;
|
||||
status: string;
|
||||
};
|
||||
|
||||
const PREFILTER_LIMIT = 200;
|
||||
|
||||
/** A raw (non-transliterated) significant word of the company name for a DB `contains` prefilter. */
|
||||
function rawNameTokens(companyName: string | null | undefined): string[] {
|
||||
const normalized = normalizeCompanyName(companyName);
|
||||
const raw = (companyName ?? "").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length >= 3);
|
||||
const norm = normalized.split(" ").filter((w) => w.length >= 3);
|
||||
const legal = new Set(["gmbh", "mbh", "kgaa", "ohg", "gbr", "und", "co"]);
|
||||
return [...new Set([...raw, ...norm])].filter((w) => !legal.has(normalizeText(w))).slice(0, 4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Possible duplicates of `candidate` among the tenant's customers (spec §7.3, US-003).
|
||||
* Returns candidates with score ≥ DUPLICATE_THRESHOLD, best first. Never merges.
|
||||
* Contract (ARCHITEKTUR §6, used by lane imports): `findDuplicateCustomers(ctx, candidate) → Candidate[]`.
|
||||
*/
|
||||
export async function findDuplicateCustomers(
|
||||
ctx: ServiceCtx,
|
||||
candidate: DuplicateCandidateInput,
|
||||
opts: { excludeId?: string; limit?: number } = {},
|
||||
): Promise<DuplicateCandidate[]> {
|
||||
assertCan(ctx, "customer:read");
|
||||
|
||||
const or: Prisma.CustomerWhereInput[] = [];
|
||||
const insensitive = "insensitive" as const;
|
||||
if (candidate.customerNumber?.trim()) or.push({ customerNumber: { equals: candidate.customerNumber.trim(), mode: insensitive } });
|
||||
if (candidate.email?.trim()) or.push({ email: { equals: candidate.email.trim(), mode: insensitive } });
|
||||
if (candidate.postalCode?.trim()) or.push({ postalCode: candidate.postalCode.replace(/\s+/g, "") });
|
||||
for (const token of rawNameTokens(candidate.companyName)) or.push({ companyName: { contains: token, mode: insensitive } });
|
||||
if (candidate.lastName?.trim()) or.push({ lastName: { equals: candidate.lastName.trim(), mode: insensitive } });
|
||||
const scope = await customerScope(ctx);
|
||||
const baseFilter: Prisma.CustomerWhereInput[] = [scope, { status: { not: "merged" } }, opts.excludeId ? { id: { not: opts.excludeId } } : {}];
|
||||
|
||||
// Stored phone numbers carry arbitrary formatting ("+49 40 123456-0"), so a SQL `contains` is
|
||||
// unreliable: compare normalized digits over the (narrow) phone columns in memory instead.
|
||||
const wantedPhones = new Set([normalizePhone(candidate.phone), normalizePhone(candidate.mobile)].filter(Boolean));
|
||||
if (wantedPhones.size) {
|
||||
const phoneRows = await ctx.db.customer.findMany({
|
||||
where: { AND: [...baseFilter, { OR: [{ phone: { not: null } }, { mobile: { not: null } }] }] },
|
||||
select: { id: true, phone: true, mobile: true },
|
||||
take: 10_000,
|
||||
});
|
||||
const ids = phoneRows.filter((r) => wantedPhones.has(normalizePhone(r.phone)) || wantedPhones.has(normalizePhone(r.mobile))).map((r) => r.id);
|
||||
if (ids.length) or.push({ id: { in: ids } });
|
||||
}
|
||||
if (or.length === 0) return [];
|
||||
|
||||
const rows = await ctx.db.customer.findMany({
|
||||
where: { AND: [...baseFilter, { OR: or }] },
|
||||
select: {
|
||||
id: true,
|
||||
customerNumber: true,
|
||||
companyName: true,
|
||||
firstName: true,
|
||||
lastName: true,
|
||||
street: true,
|
||||
houseNumber: true,
|
||||
postalCode: true,
|
||||
city: true,
|
||||
email: true,
|
||||
phone: true,
|
||||
mobile: true,
|
||||
status: true,
|
||||
},
|
||||
take: PREFILTER_LIMIT,
|
||||
});
|
||||
|
||||
return rows
|
||||
.map((r) => {
|
||||
const m = scoreDuplicate(candidate, r);
|
||||
return {
|
||||
customerId: r.id,
|
||||
score: m.score,
|
||||
reasons: m.reasons,
|
||||
customerNumber: r.customerNumber,
|
||||
displayName: customerDisplayName(r),
|
||||
city: r.city,
|
||||
status: r.status,
|
||||
};
|
||||
})
|
||||
.filter((c) => c.score >= DUPLICATE_THRESHOLD)
|
||||
.sort((a, b) => b.score - a.score)
|
||||
.slice(0, opts.limit ?? 10);
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
// Pure display helpers (no server imports) — usable from server and client components.
|
||||
|
||||
export type CustomerNameFields = {
|
||||
companyName?: string | null;
|
||||
salutation?: string | null;
|
||||
firstName?: string | null;
|
||||
lastName?: string | null;
|
||||
};
|
||||
|
||||
export function customerDisplayName(c: CustomerNameFields): string {
|
||||
if (c.companyName?.trim()) return c.companyName.trim();
|
||||
return [c.firstName, c.lastName].filter((s) => s && s.trim()).join(" ").trim();
|
||||
}
|
||||
|
||||
export type AddressFields = {
|
||||
street?: string | null;
|
||||
houseNumber?: string | null;
|
||||
postalCode?: string | null;
|
||||
city?: string | null;
|
||||
country?: string | null;
|
||||
};
|
||||
|
||||
export function formatAddress(a: AddressFields, opts: { withCountry?: boolean } = {}): string {
|
||||
const line1 = [a.street, a.houseNumber].filter(Boolean).join(" ");
|
||||
const line2 = [a.postalCode, a.city].filter(Boolean).join(" ");
|
||||
const parts = [line1, line2];
|
||||
if (opts.withCountry && a.country && a.country !== "DE") parts.push(a.country);
|
||||
return parts.filter(Boolean).join(", ");
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
import { writeAuditLog } from "@/server/audit";
|
||||
import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
|
||||
import { mergeSchema, type MergeInput } from "@/server/services/customers/schemas";
|
||||
|
||||
/**
|
||||
* Merge two customers (spec §7.3). Only with `customer:merge` and an explicit `confirm: true`.
|
||||
* Contacts, sites, work orders and documents of the source are moved to the target; the source
|
||||
* becomes status `merged` with `mergedIntoId`. Both records must belong to the caller's tenant
|
||||
* (dbForTenant) — ids of another tenant are "not found". Never triggered automatically.
|
||||
*/
|
||||
export async function mergeCustomers(ctx: ServiceCtx, input: MergeInput) {
|
||||
assertCan(ctx, "customer:merge");
|
||||
const { sourceId, targetId } = mergeSchema.parse(input);
|
||||
|
||||
const [source, target] = await Promise.all([
|
||||
ctx.db.customer.findFirst({ where: { id: sourceId, deletedAt: null } }),
|
||||
ctx.db.customer.findFirst({ where: { id: targetId, deletedAt: null } }),
|
||||
]);
|
||||
if (!source) throw new ServiceError("not_found", "source customer not found", { field: "sourceId", reason: "not_found" });
|
||||
if (!target) throw new ServiceError("not_found", "target customer not found", { field: "targetId", reason: "not_found" });
|
||||
if (source.status === "merged" || target.status === "merged") {
|
||||
throw new ServiceError("conflict", "customer already merged", { reason: "already_merged" });
|
||||
}
|
||||
|
||||
const [contacts, sites, workOrders, documents, mergedSource] = await ctx.db.$transaction([
|
||||
ctx.db.contact.updateMany({ where: { customerId: sourceId }, data: { customerId: targetId } }),
|
||||
ctx.db.site.updateMany({ where: { customerId: sourceId }, data: { customerId: targetId } }),
|
||||
// version bump: offline clients must not overwrite the re-parented order with stale data
|
||||
ctx.db.workOrder.updateMany({ where: { customerId: sourceId }, data: { customerId: targetId, version: { increment: 1 } } }),
|
||||
ctx.db.document.updateMany({ where: { customerId: sourceId }, data: { customerId: targetId } }),
|
||||
ctx.db.customer.update({
|
||||
where: { id: sourceId },
|
||||
data: { status: "merged", mergedIntoId: targetId, isProvisional: false },
|
||||
}),
|
||||
]);
|
||||
|
||||
const moved = { contacts: contacts.count, sites: sites.count, workOrders: workOrders.count, documents: documents.count };
|
||||
await writeAuditLog({
|
||||
tenantId: ctx.tenantId,
|
||||
actorId: ctx.userId,
|
||||
action: "update",
|
||||
entity: "customer",
|
||||
entityId: sourceId,
|
||||
before: source,
|
||||
after: { ...mergedSource, merge: { role: "source", targetId, moved } },
|
||||
});
|
||||
await writeAuditLog({
|
||||
tenantId: ctx.tenantId,
|
||||
actorId: ctx.userId,
|
||||
action: "update",
|
||||
entity: "customer",
|
||||
entityId: targetId,
|
||||
before: target,
|
||||
after: { merge: { role: "target", sourceId, moved } },
|
||||
});
|
||||
return { sourceId, targetId, moved };
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
import { z } from "zod";
|
||||
|
||||
/** Empty strings become null; strings are trimmed and length-limited. */
|
||||
export const optStr = (max: number) =>
|
||||
z.preprocess((v) => (typeof v === "string" && v.trim() === "" ? null : v), z.string().trim().max(max).nullable().optional());
|
||||
|
||||
export const optEmail = () =>
|
||||
z.preprocess(
|
||||
(v) => (typeof v === "string" && v.trim() === "" ? null : typeof v === "string" ? v.trim().toLowerCase() : v),
|
||||
z.string().max(200).email().nullable().optional(),
|
||||
);
|
||||
|
||||
export const CUSTOMER_EDITABLE_STATUSES = ["active", "inactive", "provisional"] as const;
|
||||
|
||||
const customerFields = {
|
||||
customerNumber: optStr(40),
|
||||
companyName: optStr(200),
|
||||
salutation: optStr(40),
|
||||
firstName: optStr(100),
|
||||
lastName: optStr(100),
|
||||
street: optStr(200),
|
||||
houseNumber: optStr(20),
|
||||
postalCode: optStr(12),
|
||||
city: optStr(100),
|
||||
country: z.preprocess(
|
||||
(v) => (typeof v === "string" && v.trim() === "" ? undefined : typeof v === "string" ? v.trim().toUpperCase() : v),
|
||||
z.string().regex(/^[A-Z]{2}$/).optional(),
|
||||
),
|
||||
phone: optStr(50),
|
||||
mobile: optStr(50),
|
||||
email: optEmail(),
|
||||
notes: optStr(5000),
|
||||
billingNotes: optStr(5000),
|
||||
status: z.enum(CUSTOMER_EDITABLE_STATUSES).optional(),
|
||||
};
|
||||
|
||||
const nameRequired = (v: { companyName?: string | null; lastName?: string | null }) => Boolean(v.companyName || v.lastName);
|
||||
|
||||
export const customerCreateSchema = z
|
||||
.object(customerFields)
|
||||
.refine(nameRequired, { message: "name_required", path: ["companyName"] });
|
||||
|
||||
/** PATCH semantics: absent = unchanged, null = cleared. */
|
||||
export const customerPatchSchema = z.object(customerFields).partial();
|
||||
|
||||
export type CustomerCreateInput = z.input<typeof customerCreateSchema>;
|
||||
export type CustomerPatchInput = z.input<typeof customerPatchSchema>;
|
||||
|
||||
export const CONTACT_CHANNELS = ["phone", "mobile", "email"] as const;
|
||||
|
||||
export const contactSchema = z.object({
|
||||
name: z.string().trim().min(1).max(200),
|
||||
role: optStr(100),
|
||||
phone: optStr(50),
|
||||
mobile: optStr(50),
|
||||
email: optEmail(),
|
||||
preferredChannel: z.preprocess((v) => (v === "" ? null : v), z.enum(CONTACT_CHANNELS).nullable().optional()),
|
||||
notes: optStr(2000),
|
||||
});
|
||||
|
||||
export type ContactInput = z.input<typeof contactSchema>;
|
||||
|
||||
export const mergeSchema = z
|
||||
.object({
|
||||
sourceId: z.string().min(1),
|
||||
targetId: z.string().min(1),
|
||||
// explicit confirmation is mandatory (spec §7.3: never merge without confirmation)
|
||||
confirm: z.literal(true),
|
||||
})
|
||||
.refine((v) => v.sourceId !== v.targetId, { message: "same_customer", path: ["targetId"] });
|
||||
|
||||
export type MergeInput = z.input<typeof mergeSchema>;
|
||||
@@ -0,0 +1,127 @@
|
||||
import type { Prisma, WorkOrderStatus } from "@prisma/client";
|
||||
import { assertCan, can, ServiceError, type ServiceCtx } from "@/server/services/context";
|
||||
import { siteScope } from "@/server/services/work-orders/visibility";
|
||||
|
||||
export type SiteHistoryEntry = {
|
||||
workOrderId: string;
|
||||
number: string;
|
||||
title: string;
|
||||
date: Date;
|
||||
status: WorkOrderStatus;
|
||||
isEmergency: boolean;
|
||||
orderType: string | null;
|
||||
team: string | null;
|
||||
/** Texts of ActivityNote kind work_done, oldest first. */
|
||||
workDone: string[];
|
||||
/** Short summary for list views (≤ 280 chars). */
|
||||
summary: string;
|
||||
materials: { name: string; unit: string; quantity: number }[];
|
||||
photoCount: number;
|
||||
approvedReports: { id: string; type: "daily" | "completion"; reportDate: Date; version: number }[];
|
||||
signed: boolean;
|
||||
followUps: string[];
|
||||
hasOpenFollowUp: boolean;
|
||||
};
|
||||
|
||||
const SUMMARY_MAX = 280;
|
||||
|
||||
/**
|
||||
* Chronological deployment history of a site (spec §8.3, US-005, US-011) — newest first.
|
||||
*
|
||||
* Access: the site itself must be visible (`siteScope`: backoffice all, field roles only via a
|
||||
* visible work order at the site — otherwise `not_found`).
|
||||
* Field roles (no `work_order:read_all`) ALWAYS get only released deployments — work orders with an
|
||||
* approved report — regardless of `onlyApproved` (US-011 "Liste aller freigegebenen Einsätze");
|
||||
* this is the history of the site, so released deployments of other teams are included (US-005).
|
||||
* Internal notes are never part of the result. Backoffice may pass `onlyApproved=false`.
|
||||
*/
|
||||
export async function getSiteHistory(
|
||||
ctx: ServiceCtx,
|
||||
siteId: string,
|
||||
opts: { onlyApproved?: boolean; page?: number; pageSize?: number } = {},
|
||||
): Promise<{ items: SiteHistoryEntry[]; total: number; page: number; pageSize: number; onlyApproved: boolean }> {
|
||||
assertCan(ctx, "site:read");
|
||||
const site = await ctx.db.site.findFirst({ where: { AND: [{ id: siteId }, await siteScope(ctx)] }, select: { id: true } });
|
||||
if (!site) throw new ServiceError("not_found", "site not found");
|
||||
|
||||
const onlyApproved = !can(ctx, "work_order:read_all") || opts.onlyApproved === true;
|
||||
const page = Math.max(1, opts.page ?? 1);
|
||||
const pageSize = Math.min(100, Math.max(1, opts.pageSize ?? 50));
|
||||
|
||||
const where: Prisma.WorkOrderWhereInput = {
|
||||
siteId,
|
||||
deletedAt: null,
|
||||
...(onlyApproved ? { reports: { some: { status: "approved" } } } : {}),
|
||||
};
|
||||
|
||||
const orders = await ctx.db.workOrder.findMany({
|
||||
where,
|
||||
take: 1000,
|
||||
select: {
|
||||
id: true,
|
||||
number: true,
|
||||
title: true,
|
||||
status: true,
|
||||
isEmergency: true,
|
||||
plannedStart: true,
|
||||
createdAt: true,
|
||||
followUpWork: true,
|
||||
orderType: { select: { name: true } },
|
||||
team: { select: { name: true } },
|
||||
workSessions: { select: { startedAt: true }, orderBy: { startedAt: "asc" }, take: 1 },
|
||||
notes: {
|
||||
where: { deletedAt: null, kind: { in: ["work_done", "follow_up"] } },
|
||||
select: { kind: true, text: true },
|
||||
orderBy: { createdAt: "asc" },
|
||||
},
|
||||
materialUsages: { where: { usageStatus: { not: "not_used" } }, select: { name: true, unit: true, actualQuantity: true } },
|
||||
_count: { select: { photos: true } },
|
||||
reports: {
|
||||
where: { status: { not: "superseded" } },
|
||||
select: { id: true, type: true, reportDate: true, version: true, status: true, signature: { select: { outcome: true } } },
|
||||
orderBy: { reportDate: "asc" },
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const entries: SiteHistoryEntry[] = orders.map((o) => {
|
||||
const workDone = o.notes.filter((n) => n.kind === "work_done").map((n) => n.text);
|
||||
const followUps = [
|
||||
...(o.followUpWork?.trim() ? [o.followUpWork.trim()] : []),
|
||||
...o.notes.filter((n) => n.kind === "follow_up").map((n) => n.text),
|
||||
];
|
||||
const materialMap = new Map<string, { name: string; unit: string; quantity: number }>();
|
||||
for (const m of o.materialUsages) {
|
||||
const key = `${m.name.trim().toLowerCase()}|${m.unit.trim().toLowerCase()}`;
|
||||
const entry = materialMap.get(key) ?? { name: m.name.trim(), unit: m.unit.trim(), quantity: 0 };
|
||||
entry.quantity = Math.round((entry.quantity + Number(m.actualQuantity.toString())) * 1000) / 1000;
|
||||
materialMap.set(key, entry);
|
||||
}
|
||||
const joined = workDone.join(" · ");
|
||||
const reports = onlyApproved ? o.reports.filter((r) => r.status === "approved") : o.reports;
|
||||
return {
|
||||
workOrderId: o.id,
|
||||
number: o.number,
|
||||
title: o.title,
|
||||
date: o.workSessions[0]?.startedAt ?? o.plannedStart ?? o.createdAt,
|
||||
status: o.status,
|
||||
isEmergency: o.isEmergency,
|
||||
orderType: o.orderType?.name ?? null,
|
||||
team: o.team?.name ?? null,
|
||||
workDone,
|
||||
summary: joined.length > SUMMARY_MAX ? `${joined.slice(0, SUMMARY_MAX - 1)}…` : joined,
|
||||
materials: [...materialMap.values()].sort((a, b) => a.name.localeCompare(b.name, "de")),
|
||||
photoCount: o._count.photos,
|
||||
approvedReports: o.reports
|
||||
.filter((r) => r.status === "approved")
|
||||
.map((r) => ({ id: r.id, type: r.type, reportDate: r.reportDate, version: r.version })),
|
||||
signed: reports.some((r) => r.signature?.outcome === "signed"),
|
||||
followUps,
|
||||
hasOpenFollowUp: followUps.length > 0,
|
||||
};
|
||||
});
|
||||
|
||||
entries.sort((a, b) => b.date.getTime() - a.date.getTime());
|
||||
const total = entries.length;
|
||||
return { items: entries.slice((page - 1) * pageSize, page * pageSize), total, page, pageSize, onlyApproved };
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// OpenStreetMap link for a site (spec §8.1) — plain URL, no embed (no third-party requests from the app).
|
||||
|
||||
export function siteMapUrl(site: {
|
||||
street?: string | null;
|
||||
houseNumber?: string | null;
|
||||
postalCode?: string | null;
|
||||
city?: string | null;
|
||||
country?: string | null;
|
||||
latitude?: number | null;
|
||||
longitude?: number | null;
|
||||
}): string | null {
|
||||
if (typeof site.latitude === "number" && typeof site.longitude === "number") {
|
||||
const lat = site.latitude.toFixed(6);
|
||||
const lon = site.longitude.toFixed(6);
|
||||
return `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}#map=18/${lat}/${lon}`;
|
||||
}
|
||||
const line = [[site.street, site.houseNumber].filter(Boolean).join(" "), [site.postalCode, site.city].filter(Boolean).join(" "), site.country]
|
||||
.filter((s) => s && String(s).trim())
|
||||
.join(", ");
|
||||
if (!site.city && !site.postalCode) return null;
|
||||
return `https://www.openstreetmap.org/search?query=${encodeURIComponent(line)}`;
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
import { z } from "zod";
|
||||
import type { Prisma } from "@prisma/client";
|
||||
import { writeAuditLog } from "@/server/audit";
|
||||
import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
|
||||
import { siteScope } from "@/server/services/work-orders/visibility";
|
||||
import { optStr } from "@/server/services/customers/schemas";
|
||||
|
||||
export const SITE_STATUSES = ["active", "inactive", "provisional"] as const;
|
||||
|
||||
const optCoord = (min: number, max: number) =>
|
||||
z.preprocess((v) => (v === "" || v === undefined ? undefined : v === null ? null : Number(String(v).replace(",", "."))), z.number().min(min).max(max).nullable().optional());
|
||||
|
||||
const siteFields = {
|
||||
customerId: z.string().min(1),
|
||||
name: z.string().trim().min(1).max(200),
|
||||
street: optStr(200),
|
||||
houseNumber: optStr(20),
|
||||
postalCode: optStr(12),
|
||||
city: optStr(100),
|
||||
country: z.preprocess(
|
||||
(v) => (typeof v === "string" && v.trim() === "" ? undefined : typeof v === "string" ? v.trim().toUpperCase() : v),
|
||||
z.string().regex(/^[A-Z]{2}$/).optional(),
|
||||
),
|
||||
contactId: optStr(64),
|
||||
onSiteContact: optStr(200),
|
||||
phone: optStr(50),
|
||||
accessNotes: optStr(5000),
|
||||
parkingNotes: optStr(5000),
|
||||
safetyNotes: optStr(5000),
|
||||
technicalNotes: optStr(5000),
|
||||
status: z.enum(SITE_STATUSES).optional(),
|
||||
latitude: optCoord(-90, 90),
|
||||
longitude: optCoord(-180, 180),
|
||||
};
|
||||
|
||||
export const siteCreateSchema = z.object(siteFields);
|
||||
export const sitePatchSchema = z.object(siteFields).partial();
|
||||
export type SiteCreateInput = z.input<typeof siteCreateSchema>;
|
||||
export type SitePatchInput = z.input<typeof sitePatchSchema>;
|
||||
|
||||
const CLOSED_ORDER_STATUSES = ["billed", "cancelled"] as const;
|
||||
|
||||
async function assertCustomerAndContact(ctx: ServiceCtx, customerId: string, contactId: string | null | undefined) {
|
||||
const customer = await ctx.db.customer.findFirst({
|
||||
where: { id: customerId, deletedAt: null, status: { not: "merged" } },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!customer) throw new ServiceError("invalid", "customer not found", { field: "customerId", reason: "customer_not_found" });
|
||||
if (contactId) {
|
||||
const contact = await ctx.db.contact.findFirst({ where: { id: contactId, customerId, deletedAt: null }, select: { id: true } });
|
||||
if (!contact) throw new ServiceError("invalid", "contact does not belong to customer", { field: "contactId", reason: "contact_mismatch" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function listSites(
|
||||
ctx: ServiceCtx,
|
||||
opts: { q?: string; customerId?: string; status?: (typeof SITE_STATUSES)[number] | "all"; page?: number; pageSize?: number } = {},
|
||||
) {
|
||||
assertCan(ctx, "site:read");
|
||||
const page = Math.max(1, opts.page ?? 1);
|
||||
const pageSize = Math.min(100, Math.max(1, opts.pageSize ?? 25));
|
||||
const q = opts.q?.trim();
|
||||
const where: Prisma.SiteWhereInput = {
|
||||
AND: [
|
||||
await siteScope(ctx),
|
||||
opts.status && opts.status !== "all" ? { status: opts.status } : {},
|
||||
opts.customerId ? { customerId: opts.customerId } : {},
|
||||
q
|
||||
? {
|
||||
OR: [
|
||||
{ name: { contains: q, mode: "insensitive" } },
|
||||
{ street: { contains: q, mode: "insensitive" } },
|
||||
{ city: { contains: q, mode: "insensitive" } },
|
||||
{ postalCode: { contains: q } },
|
||||
{ customer: { companyName: { contains: q, mode: "insensitive" } } },
|
||||
{ customer: { lastName: { contains: q, mode: "insensitive" } } },
|
||||
],
|
||||
}
|
||||
: {},
|
||||
],
|
||||
};
|
||||
const [total, items] = await Promise.all([
|
||||
ctx.db.site.count({ where }),
|
||||
ctx.db.site.findMany({
|
||||
where,
|
||||
orderBy: [{ name: "asc" }, { createdAt: "asc" }],
|
||||
skip: (page - 1) * pageSize,
|
||||
take: pageSize,
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
street: true,
|
||||
houseNumber: true,
|
||||
postalCode: true,
|
||||
city: true,
|
||||
status: true,
|
||||
customer: { select: { id: true, customerNumber: true, companyName: true, firstName: true, lastName: true } },
|
||||
_count: { select: { workOrders: { where: { deletedAt: null } } } },
|
||||
},
|
||||
}),
|
||||
]);
|
||||
return { items, total, page, pageSize };
|
||||
}
|
||||
|
||||
export async function getSite(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "site:read");
|
||||
const site = await ctx.db.site.findFirst({
|
||||
where: { AND: [{ id }, await siteScope(ctx)] },
|
||||
include: {
|
||||
customer: { select: { id: true, customerNumber: true, companyName: true, firstName: true, lastName: true, status: true } },
|
||||
contact: { select: { id: true, name: true, phone: true, mobile: true, email: true, preferredChannel: true } },
|
||||
},
|
||||
});
|
||||
if (!site) throw new ServiceError("not_found", "site not found");
|
||||
return site;
|
||||
}
|
||||
|
||||
export async function createSite(ctx: ServiceCtx, input: SiteCreateInput) {
|
||||
assertCan(ctx, "site:write");
|
||||
const data = siteCreateSchema.parse(input);
|
||||
await assertCustomerAndContact(ctx, data.customerId, data.contactId);
|
||||
const site = await ctx.db.site.create({ data: { ...data, tenantId: ctx.tenantId, country: data.country ?? "DE" } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "create", entity: "site", entityId: site.id, after: site });
|
||||
return site;
|
||||
}
|
||||
|
||||
export async function updateSite(ctx: ServiceCtx, id: string, patch: SitePatchInput) {
|
||||
assertCan(ctx, "site:write");
|
||||
const data = sitePatchSchema.parse(patch);
|
||||
const before = await ctx.db.site.findFirst({ where: { AND: [{ id }, await siteScope(ctx)] } });
|
||||
if (!before) throw new ServiceError("not_found", "site not found");
|
||||
const customerId = data.customerId ?? before.customerId;
|
||||
const contactId = data.contactId === undefined ? (data.customerId ? null : before.contactId) : data.contactId;
|
||||
await assertCustomerAndContact(ctx, customerId, contactId);
|
||||
const after = await ctx.db.site.update({ where: { id }, data: { ...data, contactId } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "update", entity: "site", entityId: id, before, after });
|
||||
return after;
|
||||
}
|
||||
|
||||
export async function deleteSite(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "site:write");
|
||||
const before = await ctx.db.site.findFirst({ where: { AND: [{ id }, await siteScope(ctx)] } });
|
||||
if (!before) throw new ServiceError("not_found", "site not found");
|
||||
const open = await ctx.db.workOrder.count({ where: { siteId: id, deletedAt: null, status: { notIn: [...CLOSED_ORDER_STATUSES] } } });
|
||||
if (open > 0) throw new ServiceError("blocked", "site has open work orders", { reason: "open_work_orders", count: open });
|
||||
const after = await ctx.db.site.update({ where: { id }, data: { deletedAt: new Date(), status: "inactive" } });
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "delete", entity: "site", entityId: id, before, after });
|
||||
return after;
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
import { z } from "zod";
|
||||
import { writeAuditLog } from "@/server/audit";
|
||||
import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
|
||||
import { optStr } from "@/server/services/customers/schemas";
|
||||
|
||||
export const TEAM_STATUSES = ["active", "inactive"] as const;
|
||||
|
||||
const dateInput = z.preprocess((v) => (v === "" || v === null || v === undefined ? undefined : v), z.coerce.date().optional());
|
||||
const optDate = z.preprocess((v) => (v === "" || v === undefined ? undefined : v), z.coerce.date().nullable().optional());
|
||||
|
||||
export const teamMemberSchema = z
|
||||
.object({
|
||||
userId: z.string().min(1),
|
||||
validFrom: dateInput,
|
||||
validTo: optDate,
|
||||
})
|
||||
.refine((m) => !m.validTo || !m.validFrom || m.validTo >= m.validFrom, { message: "valid_to_before_from", path: ["validTo"] });
|
||||
|
||||
export const teamSchema = z.object({
|
||||
name: z.string().trim().min(1).max(120),
|
||||
leaderUserId: optStr(64),
|
||||
status: z.enum(TEAM_STATUSES).optional(),
|
||||
phone: optStr(50),
|
||||
vehicle: optStr(120),
|
||||
area: optStr(200),
|
||||
notes: optStr(5000),
|
||||
members: z.array(teamMemberSchema).max(100).default([]),
|
||||
});
|
||||
|
||||
export type TeamInput = z.input<typeof teamSchema>;
|
||||
|
||||
const teamInclude = {
|
||||
leader: { select: { id: true, name: true } },
|
||||
members: { include: { user: { select: { id: true, name: true, email: true, status: true } } }, orderBy: { validFrom: "asc" as const } },
|
||||
};
|
||||
|
||||
export async function listTeams(ctx: ServiceCtx, opts: { includeInactive?: boolean } = {}) {
|
||||
assertCan(ctx, "team:read");
|
||||
return ctx.db.team.findMany({
|
||||
where: { deletedAt: null, ...(opts.includeInactive ? {} : { status: "active" }) },
|
||||
include: teamInclude,
|
||||
orderBy: { name: "asc" },
|
||||
});
|
||||
}
|
||||
|
||||
export async function getTeam(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "team:read");
|
||||
const team = await ctx.db.team.findFirst({ where: { id, deletedAt: null }, include: teamInclude });
|
||||
if (!team) throw new ServiceError("not_found", "team not found");
|
||||
return team;
|
||||
}
|
||||
|
||||
/** Active members of the tenant for leader/member selects. */
|
||||
export async function teamUserOptions(ctx: ServiceCtx) {
|
||||
assertCan(ctx, "team:manage");
|
||||
return ctx.db.user.findMany({ where: { status: "ACTIVE" }, select: { id: true, name: true, email: true }, orderBy: { name: "asc" } });
|
||||
}
|
||||
|
||||
type ParsedTeam = z.output<typeof teamSchema>;
|
||||
|
||||
async function validateTeam(ctx: ServiceCtx, data: ParsedTeam, exceptId?: string) {
|
||||
const memberIds = data.members.map((m) => m.userId);
|
||||
if (new Set(memberIds).size !== memberIds.length) {
|
||||
throw new ServiceError("invalid", "duplicate member", { field: "members", reason: "duplicate_member" });
|
||||
}
|
||||
const ids = [...new Set([...memberIds, ...(data.leaderUserId ? [data.leaderUserId] : [])])];
|
||||
if (ids.length) {
|
||||
// dbForTenant restricts to the tenant: users of other tenants are simply not found.
|
||||
const found = await ctx.db.user.count({ where: { id: { in: ids }, status: "ACTIVE" } });
|
||||
if (found !== ids.length) throw new ServiceError("invalid", "unknown or inactive user", { field: "members", reason: "inactive_user" });
|
||||
}
|
||||
const clash = await ctx.db.team.findFirst({ where: { name: data.name, ...(exceptId ? { id: { not: exceptId } } : {}) }, select: { id: true } });
|
||||
if (clash) throw new ServiceError("conflict", "team name taken", { field: "name", reason: "name_taken" });
|
||||
}
|
||||
|
||||
function memberRows(ctx: ServiceCtx, teamId: string, data: ParsedTeam) {
|
||||
const now = new Date();
|
||||
return data.members.map((m) => ({ tenantId: ctx.tenantId, teamId, userId: m.userId, validFrom: m.validFrom ?? now, validTo: m.validTo ?? null }));
|
||||
}
|
||||
|
||||
function snapshot(team: { members: { userId: string; validFrom: Date; validTo: Date | null }[] } & Record<string, unknown>) {
|
||||
const { members, ...rest } = team;
|
||||
return { ...rest, members: members.map((m) => ({ userId: m.userId, validFrom: m.validFrom, validTo: m.validTo })) };
|
||||
}
|
||||
|
||||
export async function createTeam(ctx: ServiceCtx, input: TeamInput) {
|
||||
assertCan(ctx, "team:manage");
|
||||
const data = teamSchema.parse(input);
|
||||
await validateTeam(ctx, data);
|
||||
const { members, ...fields } = data;
|
||||
void members;
|
||||
const team = await ctx.db.team.create({ data: { ...fields, tenantId: ctx.tenantId } });
|
||||
if (data.members.length) await ctx.db.teamMember.createMany({ data: memberRows(ctx, team.id, data) });
|
||||
const after = await getTeam(ctx, team.id);
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "create", entity: "team", entityId: team.id, after: snapshot(after) });
|
||||
return after;
|
||||
}
|
||||
|
||||
/** Full replace of team data and membership list (validity periods included). */
|
||||
export async function updateTeam(ctx: ServiceCtx, id: string, input: TeamInput) {
|
||||
assertCan(ctx, "team:manage");
|
||||
const data = teamSchema.parse(input);
|
||||
const before = await getTeam(ctx, id);
|
||||
await validateTeam(ctx, data, id);
|
||||
const { members, ...fields } = data;
|
||||
void members;
|
||||
await ctx.db.$transaction([
|
||||
ctx.db.team.update({ where: { id }, data: fields }),
|
||||
ctx.db.teamMember.deleteMany({ where: { teamId: id } }),
|
||||
ctx.db.teamMember.createMany({ data: memberRows(ctx, id, data) }),
|
||||
]);
|
||||
const after = await getTeam(ctx, id);
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "update", entity: "team", entityId: id, before: snapshot(before), after: snapshot(after) });
|
||||
return after;
|
||||
}
|
||||
|
||||
/** Soft delete; the unique name is released by suffixing it. Blocked while open orders are assigned. */
|
||||
export async function deleteTeam(ctx: ServiceCtx, id: string) {
|
||||
assertCan(ctx, "team:manage");
|
||||
const before = await getTeam(ctx, id);
|
||||
const open = await ctx.db.workOrder.count({ where: { assignedTeamId: id, deletedAt: null, status: { notIn: ["billed", "cancelled"] } } });
|
||||
if (open > 0) throw new ServiceError("blocked", "team has open work orders", { reason: "open_work_orders", count: open });
|
||||
const after = await ctx.db.team.update({
|
||||
where: { id },
|
||||
data: { deletedAt: new Date(), status: "inactive", name: `${before.name} · ${id.slice(-6)}` },
|
||||
});
|
||||
await writeAuditLog({ tenantId: ctx.tenantId, actorId: ctx.userId, action: "delete", entity: "team", entityId: id, before: snapshot(before), after });
|
||||
return after;
|
||||
}
|
||||
Reference in New Issue
Block a user