flfeders/FEDEO
2
1
Fork 0
Code Issues 63 Pull Requests Actions Packages Projects 21 Releases Wiki Activity

Redone Search to inluce more Columns #36

Browse Source 
TODO: Spalten nachpflegen
This commit is contained in:
florianfederspiel
2026-01-15 18:05:14 +01:00
parent 53349fae83
commit 769d2059ca
2 changed files with 180 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

538
backend/src/routes/resources/main.ts
View File

@@ -10,30 +10,23 @@ import {
or or
} from "drizzle-orm" } from "drizzle-orm"
import { resourceConfig } from "../../utils/resource.config";
import { useNextNumberRangeNumber } from "../../utils/functions";
import {resourceConfig} from "../../utils/resource.config";
import {useNextNumberRangeNumber} from "../../utils/functions";
import {stafftimeentries} from "../../../db/schema";
// ------------------------------------------------------------- // -------------------------------------------------------------
// SQL Volltextsuche auf mehreren Feldern // SQL Suche auf mehreren Feldern (Haupttabelle + Relationen)
// ------------------------------------------------------------- // -------------------------------------------------------------
function buildSearchCondition(columns: any[], search: string) {
function buildSearchCondition(table: any, columns: string[], search: string) {
if (!search || !columns.length) return null if (!search || !columns.length) return null
const term = `%${search.toLowerCase()}%` const term = `%${search.toLowerCase()}%`
const conditions = columns const conditions = columns
.map((colName) => table[colName])
.filter(Boolean) .filter(Boolean)
.map((col) => ilike(col, term)) .map((col) => ilike(col, term))
if (conditions.length === 0) return null if (conditions.length === 0) return null
// @ts-ignore
return or(...conditions) return or(...conditions)
} }
@@ -54,96 +47,85 @@ export default async function resourceRoutes(server: FastifyInstance) {
asc?: string asc?: string
} }
const {resource} = req.params as {resource: string} const { resource } = req.params as { resource: string }
const table = resourceConfig[resource].table const config = resourceConfig[resource]
const table = config.table
// WHERE-Basis
let whereCond: any = eq(table.tenant, tenantId) let whereCond: any = eq(table.tenant, tenantId)
let q = server.db.select().from(table).$dynamic()
// 🔍 SQL Search const searchCols: any[] = (config.searchColumns || []).map(c => table[c])
if(search) {
const searchCond = buildSearchCondition(
table,
resourceConfig[resource].searchColumns,
search.trim()
)
if (searchCond) { if (config.mtoLoad) {
whereCond = and(whereCond, searchCond) 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) {
q = q.leftJoin(relTable, eq(table[rel], relTable.id))
if (relConfig.searchColumns) {
relConfig.searchColumns.forEach(c => {
if (relTable[c]) searchCols.push(relTable[c])
})
}
}
}
})
} }
// Base Query if (search) {
let q = server.db.select().from(table).where(whereCond) const searchCond = buildSearchCondition(searchCols, search.trim())
if (searchCond) whereCond = and(whereCond, searchCond)
}
q = q.where(whereCond)
// Sortierung
if (sort) { if (sort) {
const col = (table as any)[sort] const col = (table as any)[sort]
if (col) { if (col) {
//@ts-ignore q = ascQuery === "true" ? q.orderBy(asc(col)) : q.orderBy(desc(col))
q = ascQuery === "true"
? q.orderBy(asc(col))
: q.orderBy(desc(col))
} }
} }
const queryData = await q const queryData = await q
// Transformation: Falls Joins genutzt wurden, das Hauptobjekt extrahieren
const rows = queryData.map(r => r[resource] || r.table || r);
// RELATION LOADING (MANY-TO-ONE) // RELATION LOADING
let data = [...rows]
let ids = {} if(config.mtoLoad) {
let lists = {} let ids: any = {}
let maps = {} let lists: any = {}
let data = [...queryData] let maps: any = {}
config.mtoLoad.forEach(rel => {
if(resourceConfig[resource].mtoLoad) { ids[rel] = [...new Set(rows.map(r => r[rel]).filter(Boolean))];
resourceConfig[resource].mtoLoad.forEach(relation => {
ids[relation] = [...new Set(queryData.map(r => r[relation]).filter(Boolean))];
}) })
for await (const rel of config.mtoLoad) {
for await (const relation of resourceConfig[resource].mtoLoad ) { const relConf = resourceConfig[rel + "s"] || resourceConfig[rel];
console.log(relation) const relTab = relConf.table
lists[relation] = ids[relation].length ? await server.db.select().from(resourceConfig[relation + "s"].table).where(inArray(resourceConfig[relation + "s"].table.id, ids[relation])) : [] 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 => {
resourceConfig[resource].mtoLoad.forEach(relation => { let toReturn = { ...row }
maps[relation] = Object.fromEntries(lists[relation].map(i => [i.id, i])); config.mtoLoad.forEach(rel => {
}) toReturn[rel] = row[rel] ? maps[rel][row[rel]] : null
data = queryData.map(row => {
let toReturn = {
...row
}
resourceConfig[resource].mtoLoad.forEach(relation => {
toReturn[relation] = row[relation] ? maps[relation][row[relation]] : null
}) })
return toReturn return toReturn
}); });
} }
if(resourceConfig[resource].mtmListLoad) { if(config.mtmListLoad) {
for await (const relation of resourceConfig[resource].mtmListLoad) { for await (const relation of config.mtmListLoad) {
console.log(relation) const relTable = resourceConfig[relation].table
console.log(resource.substring(0,resource.length-1)) 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)))
const relationRows = await server.db.select().from(resourceConfig[relation].table).where(inArray(resourceConfig[relation].table[resource.substring(0,resource.length-1)],data.map(i => i.id))) data = data.map(row => ({
...row,
console.log(relationRows.length) [relation]: relationRows.filter(i => i[parentKey] === row.id)
}))
data = data.map(row => {
let toReturn = {
...row
}
toReturn[relation] = relationRows.filter(i => i[resource.substring(0,resource.length-1)] === row.id)
return toReturn
})
} }
} }
@@ -155,212 +137,129 @@ export default async function resourceRoutes(server: FastifyInstance) {
} }
}) })
// ------------------------------------------------------------- // -------------------------------------------------------------
// PAGINATED LIST // PAGINATED LIST
// ------------------------------------------------------------- // -------------------------------------------------------------
server.get("/resource/:resource/paginated", async (req, reply) => { server.get("/resource/:resource/paginated", async (req, reply) => {
try { try {
const tenantId = req.user?.tenant_id; const tenantId = req.user?.tenant_id;
if (!tenantId) { if (!tenantId) return reply.code(400).send({ error: "No tenant selected" });
return reply.code(400).send({ error: "No tenant selected" });
}
const {resource} = req.params as {resource: string}; const { resource } = req.params as { resource: string };
const config = resourceConfig[resource];
const {queryConfig} = req; const table = config.table;
const {
pagination,
sort,
filters,
paginationDisabled
} = queryConfig;
const { search, distinctColumns } = req.query as {
search?: string;
distinctColumns?: string;
};
let table = resourceConfig[resource].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); 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(search) { if (config.mtoLoad) {
const searchCond = buildSearchCondition( config.mtoLoad.forEach(rel => {
table, const relConfig = resourceConfig[rel + "s"] || resourceConfig[rel];
resourceConfig[resource].searchColumns, if (relConfig) {
search.trim() const relTable = relConfig.table;
)
if (searchCond) { // FIX: Self-Reference Check
whereCond = and(whereCond, searchCond) if (relTable !== table) {
} countQuery = countQuery.leftJoin(relTable, eq(table[rel], relTable.id));
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) { if (filters) {
for (const [key, val] of Object.entries(filters)) { for (const [key, val] of Object.entries(filters)) {
const col = (table as any)[key]; const col = (table as any)[key];
if (!col) continue; if (!col) continue;
whereCond = Array.isArray(val) ? and(whereCond, inArray(col, val)) : and(whereCond, eq(col, val as any));
if (Array.isArray(val)) {
whereCond = and(whereCond, inArray(col, val));
} else {
whereCond = and(whereCond, eq(col, val as any));
}
} }
} }
// ----------------------------------------------- const totalRes = await countQuery.where(whereCond);
// COUNT (for pagination)
// -----------------------------------------------
const totalRes = await server.db
.select({ value: count(table.id) })
.from(table)
.where(whereCond);
const total = Number(totalRes[0]?.value ?? 0); const total = Number(totalRes[0]?.value ?? 0);
// -----------------------------------------------
// DISTINCT VALUES (regardless of pagination)
// -----------------------------------------------
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 rows = await server.db
.select({ v: col })
.from(table)
.where(eq(table.tenant, tenantId));
const values = rows
.map(r => r.v)
.filter(v => v != null && v !== "");
distinctValues[colName] = [...new Set(values)].sort();
}
}
// PAGINATION
const offset = pagination?.offset ?? 0; const offset = pagination?.offset ?? 0;
const limit = pagination?.limit ?? 100; const limit = pagination?.limit ?? 100;
// SORTING mainQuery = mainQuery.where(whereCond).offset(offset).limit(limit);
let orderField: any = null;
let direction: "asc" | "desc" = "asc";
if (sort?.length > 0) { if (sort?.length > 0) {
const s = sort[0]; const s = sort[0];
const col = (table as any)[s.field]; const col = (table as any)[s.field];
if (col) { if (col) {
orderField = col; mainQuery = s.direction === "asc" ? mainQuery.orderBy(asc(col)) : mainQuery.orderBy(desc(col));
direction = s.direction === "asc" ? "asc" : "desc";
} }
} }
// MAIN QUERY (Paginated) const rawRows = await mainQuery;
let q = server.db // Transformation für Drizzle Joins
.select() let rows = rawRows.map(r => r[resource] || r.table || r);
.from(table)
.where(whereCond)
.offset(offset)
.limit(limit);
if (orderField) {
//@ts-ignore
q = direction === "asc"
? q.orderBy(asc(orderField))
: q.orderBy(desc(orderField));
}
const rows = await q;
if (!rows.length) {
return {
data: [],
queryConfig: {
...queryConfig,
total,
totalPages: 0,
distinctValues
}
};
}
let data = [...rows]
//Many to One
if(resourceConfig[resource].mtoLoad) {
let ids = {}
let lists = {}
let maps = {}
resourceConfig[resource].mtoLoad.forEach(relation => {
ids[relation] = [...new Set(rows.map(r => r[relation]).filter(Boolean))];
})
for await (const relation of resourceConfig[resource].mtoLoad ) {
lists[relation] = ids[relation].length ? await server.db.select().from(resourceConfig[relation + "s"].table).where(inArray(resourceConfig[relation + "s"].table.id, ids[relation])) : []
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();
} }
}
resourceConfig[resource].mtoLoad.forEach(relation => { let data = [...rows];
maps[relation] = Object.fromEntries(lists[relation].map(i => [i.id, i])); 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 => { data = rows.map(row => {
let toReturn = { let toReturn = { ...row };
...row config.mtoLoad.forEach(rel => {
} toReturn[rel] = row[rel] ? maps[rel][row[rel]] : null;
});
resourceConfig[resource].mtoLoad.forEach(relation => { return toReturn;
toReturn[relation] = row[relation] ? maps[relation][row[relation]] : null
})
return toReturn
}); });
} }
if(resourceConfig[resource].mtmListLoad) { if (config.mtmListLoad) {
for await (const relation of resourceConfig[resource].mtmListLoad) { for await (const relation of config.mtmListLoad) {
console.log(relation) const relTable = resourceConfig[relation].table;
const parentKey = resource.substring(0, resource.length - 1);
const relationRows = await server.db.select().from(resourceConfig[relation].table).where(inArray(resourceConfig[relation].table[resource.substring(0,resource.length-1)],data.map(i => i.id))) const relationRows = await server.db.select().from(relTable).where(inArray(relTable[parentKey], data.map(i => i.id)));
data = data.map(row => ({
console.log(relationRows) ...row,
[relation]: relationRows.filter(i => i[parentKey] === row.id)
data = data.map(row => { }));
let toReturn = {
...row
}
toReturn[relation] = relationRows.filter(i => i[resource.substring(0,resource.length-1)] === row.id)
return toReturn
})
} }
} }
// -----------------------------------------------
// RETURN DATA
// -----------------------------------------------
return { return {
data, data,
queryConfig: { queryConfig: { ...queryConfig, total, totalPages: Math.ceil(total / limit), distinctValues }
...queryConfig,
total,
totalPages: Math.ceil(total / limit),
distinctValues
}
}; };
} catch (err) { } catch (err) {
@@ -369,9 +268,8 @@ export default async function resourceRoutes(server: FastifyInstance) {
} }
}); });
// ------------------------------------------------------------- // -------------------------------------------------------------
// DETAIL (mit JOINS) // DETAIL
// ------------------------------------------------------------- // -------------------------------------------------------------
server.get("/resource/:resource/:id/:no_relations?", async (req, reply) => { server.get("/resource/:resource/:id/:no_relations?", async (req, reply) => {
try { try {
@@ -379,7 +277,7 @@ export default async function resourceRoutes(server: FastifyInstance) {
const tenantId = req.user?.tenant_id const tenantId = req.user?.tenant_id
if (!tenantId) return reply.code(400).send({ error: "No tenant selected" }) if (!tenantId) return reply.code(400).send({ error: "No tenant selected" })
const {resource, no_relations} = req.params as { resource: string, no_relations?: boolean } const { resource, no_relations } = req.params as { resource: string, no_relations?: boolean }
const table = resourceConfig[resource].table const table = resourceConfig[resource].table
const projRows = await server.db const projRows = await server.db
@@ -391,40 +289,32 @@ export default async function resourceRoutes(server: FastifyInstance) {
if (!projRows.length) if (!projRows.length)
return reply.code(404).send({ error: "Resource not found" }) return reply.code(404).send({ error: "Resource not found" })
// ------------------------------------ let data = { ...projRows[0] }
// LOAD RELATIONS
// ------------------------------------
let ids = {} if (!no_relations) {
let lists = {} if (resourceConfig[resource].mtoLoad) {
let maps = {} for await (const relation of resourceConfig[resource].mtoLoad) {
let data = { if (data[relation]) {
...projRows[0] 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]))
if(!no_relations) { data[relation] = relData[0] || null
if(resourceConfig[resource].mtoLoad) {
for await (const relation of resourceConfig[resource].mtoLoad ) {
if(data[relation]) {
data[relation] = (await server.db.select().from(resourceConfig[relation + "s"].table).where(eq(resourceConfig[relation + "s"].table.id, data[relation])))[0]
} }
} }
} }
if(resourceConfig[resource].mtmLoad) { if (resourceConfig[resource].mtmLoad) {
for await (const relation of resourceConfig[resource].mtmLoad ) { for await (const relation of resourceConfig[resource].mtmLoad) {
console.log(relation) const relTable = resourceConfig[relation].table
data[relation] = await server.db.select().from(resourceConfig[relation].table).where(eq(resourceConfig[relation].table[resource.substring(0,resource.length - 1)],id)) const parentKey = resource.substring(0, resource.length - 1)
data[relation] = await server.db.select().from(relTable).where(eq(relTable[parentKey], id))
} }
} }
} }
return data return data
} catch (err) { } catch (err) {
console.error("ERROR /resource/projects/:id", err) console.error("ERROR /resource/:resource/:id", err)
return reply.code(500).send({ error: "Internal Server Error" }) return reply.code(500).send({ error: "Internal Server Error" })
} }
}) })
@@ -432,132 +322,58 @@ export default async function resourceRoutes(server: FastifyInstance) {
// Create // Create
server.post("/resource/:resource", async (req, reply) => { server.post("/resource/:resource", async (req, reply) => {
try { try {
if (!req.user?.tenant_id) { if (!req.user?.tenant_id) return reply.code(400).send({ error: "No tenant selected" });
return reply.code(400).send({error: "No tenant selected"}); const { resource } = req.params as { resource: string };
}
const {resource} = req.params as { resource: string };
const body = req.body as Record<string, any>; const body = req.body as Record<string, any>;
const config = resourceConfig[resource];
const table = config.table;
const table = resourceConfig[resource].table let createData = { ...body, tenant: req.user.tenant_id, archived: false };
let createData = { if (config.numberRangeHolder && !body[config.numberRangeHolder]) {
...body,
tenant: req.user.tenant_id,
archived: false, // Standardwert
}
console.log(resourceConfig[resource].numberRangeHolder)
if (resourceConfig[resource].numberRangeHolder && !body[resourceConfig[resource]]) {
const result = await useNextNumberRangeNumber(server, req.user.tenant_id, resource) const result = await useNextNumberRangeNumber(server, req.user.tenant_id, resource)
console.log(result) createData[config.numberRangeHolder] = result.usedNumber
createData[resourceConfig[resource].numberRangeHolder] = result.usedNumber
}
const normalizeDate = (val: any) => {
const d = new Date(val)
return isNaN(d.getTime()) ? null : d
} }
const normalizeDate = (val: any) => { const d = new Date(val); return isNaN(d.getTime()) ? null : d; }
Object.keys(createData).forEach((key) => { Object.keys(createData).forEach((key) => {
if(key.toLowerCase().includes("date") && key !== "deliveryDateType") createData[key] = normalizeDate(createData[key]) if (key.toLowerCase().includes("date") && key !== "deliveryDateType") createData[key] = normalizeDate(createData[key])
}) })
const [created] = await server.db const [created] = await server.db.insert(table).values(createData).returning()
.insert(table)
.values(createData)
.returning()
/*await insertHistoryItem(server, {
entity: resource,
entityId: data.id,
action: "created",
created_by: req.user.user_id,
tenant_id: req.user.tenant_id,
oldVal: null,
newVal: data,
text: `${dataType.labelSingle} erstellt`,
});*/
return created; return created;
} catch (error) { } catch (error) {
console.log(error) console.error(error);
reply.status(500) reply.status(500);
} }
}); });
// UPDATE (inkl. Soft-Delete/Archive) // Update
server.put("/resource/:resource/:id", async (req, reply) => { server.put("/resource/:resource/:id", async (req, reply) => {
try { try {
const {resource, id} = req.params as { resource: string; id: string } const { resource, id } = req.params as { resource: string; id: string }
const body = req.body as Record<string, any> const body = req.body as Record<string, any>
const tenantId = req.user?.tenant_id
const userId = req.user?.user_id
const tenantId = (req.user as any)?.tenant_id if (!tenantId || !userId) return reply.code(401).send({ error: "Unauthorized" })
const userId = (req.user as any)?.user_id
if (!tenantId || !userId) {
return reply.code(401).send({error: "Unauthorized"})
}
const table = resourceConfig[resource].table const table = resourceConfig[resource].table
const normalizeDate = (val: any) => { const d = new Date(val); return isNaN(d.getTime()) ? null : d; }
//TODO: HISTORY let data = { ...body, updated_at: new Date().toISOString(), updated_by: userId }
delete data.updatedBy; delete data.updatedAt;
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
//@ts-ignore
delete data.updatedAt
console.log(data)
Object.keys(data).forEach((key) => { Object.keys(data).forEach((key) => {
console.log(key) if ((key.includes("_at") || key.includes("At") || key.toLowerCase().includes("date")) && key !== "deliveryDateType") {
if((key.includes("_at") || key.includes("At") || key.toLowerCase().includes("date") ) && key !=="deliveryDateType") {
data[key] = normalizeDate(data[key]) data[key] = normalizeDate(data[key])
} }
}) })
console.log(data) const [updated] = await server.db.update(table).set(data).where(and(eq(table.id, id), eq(table.tenant, tenantId))).returning()
const [updated] = await server.db
.update(table)
.set(data)
.where(and(
eq(table.id, id),
eq(table.tenant, tenantId)))
.returning()
//const diffs = diffObjects(oldItem, newItem);
/*for (const d of diffs) {
await insertHistoryItem(server, {
entity: resource,
entityId: id,
action: d.type,
created_by: userId,
tenant_id: tenantId,
oldVal: d.oldValue ? String(d.oldValue) : null,
newVal: d.newValue ? String(d.newValue) : null,
text: `Feld "${d.label}" ${d.typeLabel}: ${d.oldValue ?? ""} → ${d.newValue ?? ""}`,
});
}*/
return updated return updated
} catch (err) { } catch (err) {
console.log("ERROR /resource/projects/:id", err) console.error(err)
} }
}) })
} }

3
backend/src/utils/resource.config.ts
View File

@@ -36,7 +36,7 @@ import {
export const resourceConfig = { export const resourceConfig = {
projects: { projects: {
searchColumns: ["name"], searchColumns: ["name","customerRef","projectNumber","notes"],
mtoLoad: ["customer","plant","contract","projecttype"], mtoLoad: ["customer","plant","contract","projecttype"],
mtmLoad: ["tasks", "files","createddocuments"], mtmLoad: ["tasks", "files","createddocuments"],
table: projects, table: projects,
@@ -61,6 +61,7 @@ export const resourceConfig = {
}, },
plants: { plants: {
table: plants, table: plants,
searchColumns: ["name"],
mtoLoad: ["customer"], mtoLoad: ["customer"],
mtmLoad: ["projects","tasks","files"], mtmLoad: ["projects","tasks","files"],
}, },