394 lines
16 KiB
TypeScript
394 lines
16 KiB
TypeScript
import { FastifyInstance } from "fastify"
|
|
import {
|
|
eq,
|
|
ilike,
|
|
asc,
|
|
desc,
|
|
and,
|
|
count,
|
|
inArray,
|
|
or
|
|
} from "drizzle-orm"
|
|
|
|
import { resourceConfig } from "../../utils/resource.config";
|
|
import { useNextNumberRangeNumber } from "../../utils/functions";
|
|
import { recalculateServicePricesForTenant } from "../../modules/service-price-recalculation.service";
|
|
|
|
// -------------------------------------------------------------
|
|
// SQL Suche auf mehreren Feldern (Haupttabelle + Relationen)
|
|
// -------------------------------------------------------------
|
|
function buildSearchCondition(columns: any[], search: string) {
|
|
if (!search || !columns.length) return null
|
|
|
|
const term = `%${search.toLowerCase()}%`
|
|
|
|
const conditions = columns
|
|
.filter(Boolean)
|
|
.map((col) => ilike(col, term))
|
|
|
|
if (conditions.length === 0) return null
|
|
|
|
return or(...conditions)
|
|
}
|
|
|
|
export default async function resourceRoutes(server: FastifyInstance) {
|
|
|
|
// -------------------------------------------------------------
|
|
// LIST
|
|
// -------------------------------------------------------------
|
|
server.get("/resource/:resource", async (req, reply) => {
|
|
try {
|
|
const tenantId = req.user?.tenant_id
|
|
if (!tenantId)
|
|
return reply.code(400).send({ error: "No tenant selected" })
|
|
|
|
const { search, sort, asc: ascQuery } = req.query as {
|
|
search?: string
|
|
sort?: string
|
|
asc?: string
|
|
}
|
|
|
|
const { resource } = req.params as { resource: string }
|
|
const config = resourceConfig[resource]
|
|
const table = config.table
|
|
|
|
let whereCond: any = eq(table.tenant, tenantId)
|
|
let q = server.db.select().from(table).$dynamic()
|
|
|
|
const searchCols: any[] = (config.searchColumns || []).map(c => table[c])
|
|
|
|
if (config.mtoLoad) {
|
|
config.mtoLoad.forEach(rel => {
|
|
const relConfig = resourceConfig[rel + "s"] || resourceConfig[rel]
|
|
if (relConfig) {
|
|
const relTable = relConfig.table
|
|
|
|
// FIX: Nur joinen, wenn es keine Self-Reference ist (verhindert ERROR 42712)
|
|
if (relTable !== table) {
|
|
// @ts-ignore
|
|
q = q.leftJoin(relTable, eq(table[rel], relTable.id))
|
|
if (relConfig.searchColumns) {
|
|
relConfig.searchColumns.forEach(c => {
|
|
if (relTable[c]) searchCols.push(relTable[c])
|
|
})
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
if (search) {
|
|
const searchCond = buildSearchCondition(searchCols, search.trim())
|
|
if (searchCond) whereCond = and(whereCond, searchCond)
|
|
}
|
|
|
|
q = q.where(whereCond)
|
|
|
|
if (sort) {
|
|
const col = (table as any)[sort]
|
|
if (col) {
|
|
q = ascQuery === "true" ? q.orderBy(asc(col)) : q.orderBy(desc(col))
|
|
}
|
|
}
|
|
|
|
const queryData = await q
|
|
// Transformation: Falls Joins genutzt wurden, das Hauptobjekt extrahieren
|
|
const rows = queryData.map(r => r[resource] || r.table || r);
|
|
|
|
// RELATION LOADING
|
|
let data = [...rows]
|
|
if(config.mtoLoad) {
|
|
let ids: any = {}
|
|
let lists: any = {}
|
|
let maps: any = {}
|
|
config.mtoLoad.forEach(rel => {
|
|
ids[rel] = [...new Set(rows.map(r => r[rel]).filter(Boolean))];
|
|
})
|
|
for await (const rel of config.mtoLoad) {
|
|
const relConf = resourceConfig[rel + "s"] || resourceConfig[rel];
|
|
const relTab = relConf.table
|
|
lists[rel] = ids[rel].length ? await server.db.select().from(relTab).where(inArray(relTab.id, ids[rel])) : []
|
|
maps[rel] = Object.fromEntries(lists[rel].map((i: any) => [i.id, i]));
|
|
}
|
|
data = rows.map(row => {
|
|
let toReturn = { ...row }
|
|
config.mtoLoad.forEach(rel => {
|
|
toReturn[rel] = row[rel] ? maps[rel][row[rel]] : null
|
|
})
|
|
return toReturn
|
|
});
|
|
}
|
|
|
|
if(config.mtmListLoad) {
|
|
for await (const relation of config.mtmListLoad) {
|
|
const relTable = resourceConfig[relation].table
|
|
const parentKey = resource.substring(0, resource.length - 1)
|
|
const relationRows = await server.db.select().from(relTable).where(inArray(relTable[parentKey], data.map(i => i.id)))
|
|
data = data.map(row => ({
|
|
...row,
|
|
[relation]: relationRows.filter(i => i[parentKey] === row.id)
|
|
}))
|
|
}
|
|
}
|
|
|
|
return data
|
|
|
|
} catch (err) {
|
|
console.error("ERROR /resource/:resource", err)
|
|
return reply.code(500).send({ error: "Internal Server Error" })
|
|
}
|
|
})
|
|
|
|
// -------------------------------------------------------------
|
|
// PAGINATED LIST
|
|
// -------------------------------------------------------------
|
|
server.get("/resource/:resource/paginated", async (req, reply) => {
|
|
try {
|
|
const tenantId = req.user?.tenant_id;
|
|
if (!tenantId) return reply.code(400).send({ error: "No tenant selected" });
|
|
|
|
const { resource } = req.params as { resource: string };
|
|
const config = resourceConfig[resource];
|
|
const table = config.table;
|
|
|
|
const { queryConfig } = req;
|
|
const { pagination, sort, filters } = queryConfig;
|
|
const { search, distinctColumns } = req.query as { search?: string; distinctColumns?: string; };
|
|
|
|
let whereCond: any = eq(table.tenant, tenantId);
|
|
const searchCols: any[] = (config.searchColumns || []).map(c => table[c]);
|
|
|
|
let countQuery = server.db.select({ value: count(table.id) }).from(table).$dynamic();
|
|
let mainQuery = server.db.select().from(table).$dynamic();
|
|
|
|
if (config.mtoLoad) {
|
|
config.mtoLoad.forEach(rel => {
|
|
const relConfig = resourceConfig[rel + "s"] || resourceConfig[rel];
|
|
if (relConfig) {
|
|
const relTable = relConfig.table;
|
|
|
|
// FIX: Self-Reference Check
|
|
if (relTable !== table) {
|
|
countQuery = countQuery.leftJoin(relTable, eq(table[rel], relTable.id));
|
|
// @ts-ignore
|
|
mainQuery = mainQuery.leftJoin(relTable, eq(table[rel], relTable.id));
|
|
if (relConfig.searchColumns) {
|
|
relConfig.searchColumns.forEach(c => {
|
|
if (relTable[c]) searchCols.push(relTable[c]);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (search) {
|
|
const searchCond = buildSearchCondition(searchCols, search.trim());
|
|
if (searchCond) whereCond = and(whereCond, searchCond);
|
|
}
|
|
|
|
if (filters) {
|
|
for (const [key, val] of Object.entries(filters)) {
|
|
const col = (table as any)[key];
|
|
if (!col) continue;
|
|
whereCond = Array.isArray(val) ? and(whereCond, inArray(col, val)) : and(whereCond, eq(col, val as any));
|
|
}
|
|
}
|
|
|
|
const totalRes = await countQuery.where(whereCond);
|
|
const total = Number(totalRes[0]?.value ?? 0);
|
|
|
|
const offset = pagination?.offset ?? 0;
|
|
const limit = pagination?.limit ?? 100;
|
|
|
|
mainQuery = mainQuery.where(whereCond).offset(offset).limit(limit);
|
|
|
|
if (sort?.length > 0) {
|
|
const s = sort[0];
|
|
const col = (table as any)[s.field];
|
|
if (col) {
|
|
mainQuery = s.direction === "asc" ? mainQuery.orderBy(asc(col)) : mainQuery.orderBy(desc(col));
|
|
}
|
|
}
|
|
|
|
const rawRows = await mainQuery;
|
|
// Transformation für Drizzle Joins
|
|
let rows = rawRows.map(r => r[resource] || r.table || r);
|
|
|
|
const distinctValues: Record<string, any[]> = {};
|
|
if (distinctColumns) {
|
|
for (const colName of distinctColumns.split(",").map(c => c.trim())) {
|
|
const col = (table as any)[colName];
|
|
if (!col) continue;
|
|
const dRows = await server.db.select({ v: col }).from(table).where(eq(table.tenant, tenantId));
|
|
distinctValues[colName] = [...new Set(dRows.map(r => r.v).filter(v => v != null && v !== ""))].sort();
|
|
}
|
|
}
|
|
|
|
let data = [...rows];
|
|
if (config.mtoLoad) {
|
|
let ids: any = {};
|
|
let lists: any = {};
|
|
let maps: any = {};
|
|
config.mtoLoad.forEach(rel => {
|
|
ids[rel] = [...new Set(rows.map(r => r[rel]).filter(Boolean))];
|
|
});
|
|
for await (const rel of config.mtoLoad) {
|
|
const relConf = resourceConfig[rel + "s"] || resourceConfig[rel];
|
|
const relTab = relConf.table;
|
|
lists[rel] = ids[rel].length ? await server.db.select().from(relTab).where(inArray(relTab.id, ids[rel])) : [];
|
|
maps[rel] = Object.fromEntries(lists[rel].map((i: any) => [i.id, i]));
|
|
}
|
|
data = rows.map(row => {
|
|
let toReturn = { ...row };
|
|
config.mtoLoad.forEach(rel => {
|
|
toReturn[rel] = row[rel] ? maps[rel][row[rel]] : null;
|
|
});
|
|
return toReturn;
|
|
});
|
|
}
|
|
|
|
if (config.mtmListLoad) {
|
|
for await (const relation of config.mtmListLoad) {
|
|
const relTable = resourceConfig[relation].table;
|
|
const parentKey = resource.substring(0, resource.length - 1);
|
|
const relationRows = await server.db.select().from(relTable).where(inArray(relTable[parentKey], data.map(i => i.id)));
|
|
data = data.map(row => ({
|
|
...row,
|
|
[relation]: relationRows.filter(i => i[parentKey] === row.id)
|
|
}));
|
|
}
|
|
}
|
|
|
|
return {
|
|
data,
|
|
queryConfig: { ...queryConfig, total, totalPages: Math.ceil(total / limit), distinctValues }
|
|
};
|
|
|
|
} catch (err) {
|
|
console.error(`ERROR /resource/:resource/paginated:`, err);
|
|
return reply.code(500).send({ error: "Internal Server Error" });
|
|
}
|
|
});
|
|
|
|
// -------------------------------------------------------------
|
|
// DETAIL
|
|
// -------------------------------------------------------------
|
|
server.get("/resource/:resource/:id/:no_relations?", async (req, reply) => {
|
|
try {
|
|
const { id } = req.params as { id: string }
|
|
const tenantId = req.user?.tenant_id
|
|
if (!tenantId) return reply.code(400).send({ error: "No tenant selected" })
|
|
|
|
const { resource, no_relations } = req.params as { resource: string, no_relations?: boolean }
|
|
const table = resourceConfig[resource].table
|
|
|
|
const projRows = await server.db
|
|
.select()
|
|
.from(table)
|
|
.where(and(eq(table.id, id), eq(table.tenant, tenantId)))
|
|
.limit(1)
|
|
|
|
if (!projRows.length)
|
|
return reply.code(404).send({ error: "Resource not found" })
|
|
|
|
let data = { ...projRows[0] }
|
|
|
|
if (!no_relations) {
|
|
if (resourceConfig[resource].mtoLoad) {
|
|
for await (const relation of resourceConfig[resource].mtoLoad) {
|
|
if (data[relation]) {
|
|
const relConf = resourceConfig[relation + "s"] || resourceConfig[relation];
|
|
const relTable = relConf.table
|
|
const relData = await server.db.select().from(relTable).where(eq(relTable.id, data[relation]))
|
|
data[relation] = relData[0] || null
|
|
}
|
|
}
|
|
}
|
|
|
|
if (resourceConfig[resource].mtmLoad) {
|
|
for await (const relation of resourceConfig[resource].mtmLoad) {
|
|
const relTable = resourceConfig[relation].table
|
|
const parentKey = resource.substring(0, resource.length - 1)
|
|
data[relation] = await server.db.select().from(relTable).where(eq(relTable[parentKey], id))
|
|
}
|
|
}
|
|
}
|
|
|
|
return data
|
|
} catch (err) {
|
|
console.error("ERROR /resource/:resource/:id", err)
|
|
return reply.code(500).send({ error: "Internal Server Error" })
|
|
}
|
|
})
|
|
|
|
// Create
|
|
server.post("/resource/:resource", async (req, reply) => {
|
|
try {
|
|
if (!req.user?.tenant_id) return reply.code(400).send({ error: "No tenant selected" });
|
|
const { resource } = req.params as { resource: string };
|
|
const body = req.body as Record<string, any>;
|
|
const config = resourceConfig[resource];
|
|
const table = config.table;
|
|
|
|
let createData = { ...body, tenant: req.user.tenant_id, archived: false };
|
|
|
|
if (config.numberRangeHolder && !body[config.numberRangeHolder]) {
|
|
const result = await useNextNumberRangeNumber(server, req.user.tenant_id, resource)
|
|
createData[config.numberRangeHolder] = result.usedNumber
|
|
}
|
|
|
|
const normalizeDate = (val: any) => { const d = new Date(val); return isNaN(d.getTime()) ? null : d; }
|
|
Object.keys(createData).forEach((key) => {
|
|
if (key.toLowerCase().includes("date") && key !== "deliveryDateType") createData[key] = normalizeDate(createData[key])
|
|
})
|
|
|
|
const [created] = await server.db.insert(table).values(createData).returning()
|
|
|
|
if (["products", "services", "hourrates"].includes(resource)) {
|
|
await recalculateServicePricesForTenant(server, req.user.tenant_id, req.user?.user_id || null);
|
|
}
|
|
|
|
return created;
|
|
} catch (error) {
|
|
console.error(error);
|
|
reply.status(500);
|
|
}
|
|
});
|
|
|
|
// Update
|
|
server.put("/resource/:resource/:id", async (req, reply) => {
|
|
try {
|
|
const { resource, id } = req.params as { resource: string; id: string }
|
|
const body = req.body as Record<string, any>
|
|
const tenantId = req.user?.tenant_id
|
|
const userId = req.user?.user_id
|
|
|
|
if (!tenantId || !userId) return reply.code(401).send({ error: "Unauthorized" })
|
|
|
|
const table = resourceConfig[resource].table
|
|
const normalizeDate = (val: any) => { const d = new Date(val); return isNaN(d.getTime()) ? null : d; }
|
|
|
|
let data = { ...body, updated_at: new Date().toISOString(), updated_by: userId }
|
|
//@ts-ignore
|
|
delete data.updatedBy; delete data.updatedAt;
|
|
|
|
Object.keys(data).forEach((key) => {
|
|
if ((key.includes("_at") || key.includes("At") || key.toLowerCase().includes("date")) && key !== "deliveryDateType") {
|
|
data[key] = normalizeDate(data[key])
|
|
}
|
|
})
|
|
|
|
const [updated] = await server.db.update(table).set(data).where(and(eq(table.id, id), eq(table.tenant, tenantId))).returning()
|
|
|
|
if (["products", "services", "hourrates"].includes(resource)) {
|
|
await recalculateServicePricesForTenant(server, tenantId, userId);
|
|
}
|
|
|
|
return updated
|
|
} catch (err) {
|
|
console.error(err)
|
|
}
|
|
})
|
|
}
|