494 lines
14 KiB
TypeScript
494 lines
14 KiB
TypeScript
import { and, eq, ilike, isNull, or, sql, inArray } from "drizzle-orm";
|
|
import { Hono } from "hono";
|
|
import { questions } from "../../drizzle/schema/questions";
|
|
import { z } from "zod";
|
|
import db from "../../drizzle";
|
|
import { aspects } from "../../drizzle/schema/aspects";
|
|
import { subAspects } from "../../drizzle/schema/subAspects";
|
|
import HonoEnv from "../../types/HonoEnv";
|
|
import requestValidator from "../../utils/requestValidator";
|
|
import authInfo from "../../middlewares/authInfo";
|
|
import checkPermission from "../../middlewares/checkPermission";
|
|
import { forbidden } from "../../errors/DashboardError";
|
|
import { notFound } from "../../errors/DashboardError";
|
|
|
|
// Schema for creating and updating aspects
|
|
export const aspectFormSchema = z.object({
|
|
name: z.string().min(1).max(50),
|
|
subAspects: z
|
|
.string()
|
|
.refine(
|
|
(data) => {
|
|
try {
|
|
const parsed = JSON.parse(data);
|
|
return Array.isArray(parsed);
|
|
} catch {
|
|
return false;
|
|
}
|
|
},
|
|
{
|
|
message: "Sub Aspects must be an array",
|
|
}
|
|
)
|
|
.optional(),
|
|
});
|
|
|
|
// Schema for creating and updating subAspects
|
|
export const subAspectFormSchema = z.object({
|
|
id: z.string(),
|
|
name: z.string().min(1).max(50),
|
|
aspectId: z.string().optional(),
|
|
});
|
|
|
|
export const aspectUpdateSchema = z.object({
|
|
name: z.string(),
|
|
subAspects: z.array(subAspectFormSchema),
|
|
});
|
|
|
|
export const subAspectUpdateSchema = subAspectFormSchema.extend({});
|
|
|
|
const managementAspectRoute = new Hono<HonoEnv>()
|
|
.use(authInfo)
|
|
/**
|
|
* Get All Aspects (With Metadata)
|
|
*
|
|
* Query params:
|
|
* - includeTrashed: boolean (default: false)
|
|
* - withMetadata: boolean
|
|
*/
|
|
|
|
// Get all aspects
|
|
.get(
|
|
"/",
|
|
checkPermission("managementAspect.readAll"),
|
|
requestValidator(
|
|
"query",
|
|
z.object({
|
|
includeTrashed: z
|
|
.string()
|
|
.optional()
|
|
.transform((v) => v?.toLowerCase() === "true"),
|
|
withMetadata: z
|
|
.string()
|
|
.optional()
|
|
.transform((v) => v?.toLowerCase() === "true"),
|
|
page: z.coerce.number().int().min(0).default(0),
|
|
limit: z.coerce.number().int().min(1).max(1000).default(10),
|
|
q: z.string().default(""),
|
|
})
|
|
),
|
|
async (c) => {
|
|
const { includeTrashed, page, limit, q } = c.req.valid("query");
|
|
|
|
const totalCountQuery = includeTrashed
|
|
? sql<number>`(SELECT count(DISTINCT ${aspects.id}) FROM ${aspects})`
|
|
: sql<number>`(SELECT count(DISTINCT ${aspects.id}) FROM ${aspects} WHERE ${aspects.deletedAt} IS NULL)`;
|
|
|
|
const aspectIdsQuery = await db
|
|
.select({
|
|
id: aspects.id,
|
|
})
|
|
.from(aspects)
|
|
.where(
|
|
and(
|
|
includeTrashed ? undefined : isNull(aspects.deletedAt),
|
|
q ? or(ilike(aspects.name, q), eq(aspects.id, q)) : undefined
|
|
)
|
|
)
|
|
.offset(page * limit)
|
|
.limit(limit);
|
|
|
|
const aspectIds = aspectIdsQuery.map(a => a.id);
|
|
|
|
if (aspectIds.length === 0) {
|
|
return c.json({
|
|
data: [],
|
|
_metadata: {
|
|
currentPage: page,
|
|
totalPages: 0,
|
|
totalItems: 0,
|
|
perPage: limit,
|
|
},
|
|
});
|
|
}
|
|
|
|
// Main query to get aspects, sub-aspects, and number of questions
|
|
const result = await db
|
|
.select({
|
|
id: aspects.id,
|
|
name: aspects.name,
|
|
createdAt: aspects.createdAt,
|
|
updatedAt: aspects.updatedAt,
|
|
...(includeTrashed ? { deletedAt: aspects.deletedAt } : {}),
|
|
subAspectId: subAspects.id,
|
|
subAspectName: subAspects.name,
|
|
// Increase the number of questions related to sub aspects
|
|
questionCount: sql<number>`(
|
|
SELECT count(*)
|
|
FROM ${questions}
|
|
WHERE ${questions.subAspectId} = ${subAspects.id}
|
|
)`.as('questionCount'),
|
|
fullCount: totalCountQuery,
|
|
})
|
|
.from(aspects)
|
|
.leftJoin(subAspects, eq(subAspects.aspectId, aspects.id))
|
|
.where(inArray(aspects.id, aspectIds));
|
|
|
|
// Grouping sub aspects by aspect ID
|
|
const groupedResult = result.reduce((acc, curr) => {
|
|
const aspectId = curr.id;
|
|
|
|
if (!acc[aspectId]) {
|
|
acc[aspectId] = {
|
|
id: curr.id,
|
|
name: curr.name,
|
|
createdAt: curr.createdAt ? new Date(curr.createdAt).toISOString() : null,
|
|
updatedAt: curr.updatedAt ? new Date(curr.updatedAt).toISOString() : null,
|
|
subAspects: curr.subAspectName
|
|
? [{ id: curr.subAspectId!, name: curr.subAspectName, questionCount: curr.questionCount }]
|
|
: [],
|
|
};
|
|
} else {
|
|
if (curr.subAspectName) {
|
|
const exists = acc[aspectId].subAspects.some(sub => sub.id === curr.subAspectId);
|
|
if (!exists) {
|
|
acc[aspectId].subAspects.push({
|
|
id: curr.subAspectId!,
|
|
name: curr.subAspectName,
|
|
questionCount: curr.questionCount,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return acc;
|
|
}, {} as Record<string, {
|
|
id: string;
|
|
name: string;
|
|
createdAt: string | null;
|
|
updatedAt: string | null;
|
|
subAspects: { id: string; name: string; questionCount: number }[];
|
|
}>);
|
|
|
|
const groupedArray = Object.values(groupedResult);
|
|
|
|
return c.json({
|
|
data: groupedArray,
|
|
_metadata: {
|
|
currentPage: page,
|
|
totalPages: Math.ceil((Number(result[0]?.fullCount) ?? 0) / limit),
|
|
totalItems: Number(result[0]?.fullCount) ?? 0,
|
|
perPage: limit,
|
|
},
|
|
});
|
|
}
|
|
)
|
|
|
|
// Get aspect by id
|
|
.get(
|
|
"/:id",
|
|
checkPermission("managementAspect.readAll"),
|
|
requestValidator(
|
|
"query",
|
|
z.object({
|
|
includeTrashed: z.string().default("false"),
|
|
})
|
|
),
|
|
async (c) => {
|
|
const aspectId = c.req.param("id");
|
|
|
|
if (!aspectId)
|
|
throw notFound({
|
|
message: "Missing id",
|
|
});
|
|
|
|
const includeTrashed = c.req.query("includeTrashed")?.toLowerCase() === "true";
|
|
|
|
const queryResult = await db
|
|
.select({
|
|
id: aspects.id,
|
|
name: aspects.name,
|
|
createdAt: aspects.createdAt,
|
|
updatedAt: aspects.updatedAt,
|
|
...(includeTrashed ? { deletedAt: aspects.deletedAt } : {}),
|
|
subAspect: {
|
|
name: subAspects.name,
|
|
id: subAspects.id,
|
|
questionCount: sql`COUNT(${questions.id})`.as("questionCount"),
|
|
},
|
|
})
|
|
.from(aspects)
|
|
.leftJoin(subAspects, eq(aspects.id, subAspects.aspectId))
|
|
.leftJoin(questions, eq(subAspects.id, questions.subAspectId))
|
|
.where(and(eq(aspects.id, aspectId), !includeTrashed ? isNull(aspects.deletedAt) : undefined))
|
|
.groupBy(aspects.id, aspects.name, aspects.createdAt, aspects.updatedAt, subAspects.id, subAspects.name);
|
|
|
|
if (!queryResult.length)
|
|
throw notFound({
|
|
message: "The aspect does not exist",
|
|
});
|
|
|
|
const subAspectsList = queryResult.reduce((prev, curr) => {
|
|
if (!curr.subAspect) return prev;
|
|
prev.set(curr.subAspect.id, {
|
|
name: curr.subAspect.name,
|
|
questionCount: Number(curr.subAspect.questionCount),
|
|
});
|
|
return prev;
|
|
}, new Map<string, { name: string; questionCount: number }>());
|
|
|
|
const aspectData = {
|
|
...queryResult[0],
|
|
subAspect: undefined,
|
|
subAspects: Array.from(subAspectsList, ([id, { name, questionCount }]) => ({ id, name, questionCount })),
|
|
};
|
|
|
|
return c.json(aspectData);
|
|
}
|
|
)
|
|
|
|
// Create aspect
|
|
.post("/",
|
|
checkPermission("managementAspect.create"),
|
|
requestValidator("json", aspectFormSchema),
|
|
async (c) => {
|
|
const aspectData = c.req.valid("json");
|
|
|
|
// Check if aspect name already exists and is not deleted
|
|
const existingAspect = await db
|
|
.select()
|
|
.from(aspects)
|
|
.where(
|
|
and(
|
|
eq(aspects.name, aspectData.name),
|
|
isNull(aspects.deletedAt)
|
|
)
|
|
);
|
|
|
|
if (existingAspect.length > 0) {
|
|
// Return an error if the aspect name already exists
|
|
return c.json(
|
|
{ message: "Aspect name already exists" },
|
|
400 // Bad Request
|
|
);
|
|
}
|
|
|
|
// If it doesn't exist, create a new aspect
|
|
const aspect = await db
|
|
.insert(aspects)
|
|
.values({
|
|
name: aspectData.name,
|
|
})
|
|
.returning();
|
|
|
|
const aspectId = aspect[0].id;
|
|
|
|
// If there is sub aspect data, parse and insert into the database.
|
|
if (aspectData.subAspects) {
|
|
const subAspectsArray = JSON.parse(aspectData.subAspects) as string[];
|
|
|
|
// Insert new sub aspects into the database without checking for sub aspect duplication
|
|
if (subAspectsArray.length) {
|
|
await db.insert(subAspects).values(
|
|
subAspectsArray.map((subAspect) => ({
|
|
aspectId,
|
|
name: subAspect,
|
|
}))
|
|
);
|
|
}
|
|
}
|
|
|
|
return c.json(
|
|
{
|
|
message: "Aspect and sub aspects created successfully",
|
|
},
|
|
201
|
|
);
|
|
}
|
|
)
|
|
|
|
// Update aspect
|
|
.patch(
|
|
"/:id",
|
|
checkPermission("managementAspect.update"),
|
|
requestValidator("json", aspectUpdateSchema),
|
|
async (c) => {
|
|
const aspectId = c.req.param("id");
|
|
const aspectData = c.req.valid("json");
|
|
|
|
// Check if new aspect name already exists
|
|
const existingAspect = await db
|
|
.select()
|
|
.from(aspects)
|
|
.where(
|
|
and(
|
|
eq(aspects.name, aspectData.name),
|
|
isNull(aspects.deletedAt),
|
|
sql`${aspects.id} <> ${aspectId}`
|
|
)
|
|
);
|
|
|
|
if (existingAspect.length > 0) {
|
|
throw notFound({
|
|
message: "Aspect name already exists",
|
|
});
|
|
}
|
|
|
|
// Check if the aspect in question exists
|
|
const aspect = await db
|
|
.select()
|
|
.from(aspects)
|
|
.where(and(eq(aspects.id, aspectId), isNull(aspects.deletedAt)));
|
|
|
|
if (!aspect[0]) throw notFound();
|
|
|
|
// Update aspect name
|
|
await db
|
|
.update(aspects)
|
|
.set({
|
|
name: aspectData.name,
|
|
updatedAt: new Date(),
|
|
})
|
|
.where(eq(aspects.id, aspectId));
|
|
|
|
// Get new sub aspect data from request
|
|
const newSubAspects = aspectData.subAspects || [];
|
|
|
|
// Take the existing sub aspects
|
|
const currentSubAspects = await db
|
|
.select({ id: subAspects.id, name: subAspects.name })
|
|
.from(subAspects)
|
|
.where(eq(subAspects.aspectId, aspectId));
|
|
|
|
const currentSubAspectMap = new Map(currentSubAspects.map(sub => [sub.id, sub.name]));
|
|
|
|
// Sub aspects to be removed
|
|
const subAspectsToDelete = currentSubAspects
|
|
.filter(sub => !newSubAspects.some(newSub => newSub.id === sub.id))
|
|
.map(sub => sub.id);
|
|
|
|
// Delete sub aspects that do not exist in the new data
|
|
if (subAspectsToDelete.length) {
|
|
await db
|
|
.delete(subAspects)
|
|
.where(
|
|
and(
|
|
eq(subAspects.aspectId, aspectId),
|
|
inArray(subAspects.id, subAspectsToDelete)
|
|
)
|
|
);
|
|
}
|
|
|
|
// Update or add new sub aspects
|
|
for (const subAspect of newSubAspects) {
|
|
const existingSubAspect = currentSubAspectMap.has(subAspect.id);
|
|
|
|
if (existingSubAspect) {
|
|
// Update if sub aspect already exists
|
|
await db
|
|
.update(subAspects)
|
|
.set({
|
|
name: subAspect.name,
|
|
updatedAt: new Date(),
|
|
})
|
|
.where(
|
|
and(
|
|
eq(subAspects.id, subAspect.id),
|
|
eq(subAspects.aspectId, aspectId)
|
|
)
|
|
);
|
|
} else {
|
|
// Add if new sub aspect
|
|
await db
|
|
.insert(subAspects)
|
|
.values({
|
|
id: subAspect.id,
|
|
aspectId,
|
|
name: subAspect.name,
|
|
createdAt: new Date(),
|
|
});
|
|
}
|
|
}
|
|
|
|
return c.json({
|
|
message: "Aspect and sub aspects updated successfully",
|
|
});
|
|
}
|
|
)
|
|
|
|
// Delete aspect
|
|
.delete(
|
|
"/:id",
|
|
checkPermission("managementAspect.delete"),
|
|
async (c) => {
|
|
const aspectId = c.req.param("id");
|
|
|
|
// Check if aspect exists before deleting
|
|
const aspect = await db
|
|
.select()
|
|
.from(aspects)
|
|
.where(and(eq(aspects.id, aspectId), isNull(aspects.deletedAt)));
|
|
|
|
if (!aspect[0])
|
|
throw notFound({
|
|
message: "The aspect is not found",
|
|
});
|
|
|
|
// Update deletedAt column on aspect (soft delete)
|
|
await db
|
|
.update(aspects)
|
|
.set({
|
|
deletedAt: new Date(),
|
|
})
|
|
.where(eq(aspects.id, aspectId));
|
|
|
|
// Soft delete related sub aspects (update deletedAt on the sub-aspect)
|
|
await db
|
|
.update(subAspects)
|
|
.set({
|
|
deletedAt: new Date(),
|
|
})
|
|
.where(eq(subAspects.aspectId, aspectId));
|
|
|
|
return c.json({
|
|
message: "Aspect and sub aspects soft deleted successfully",
|
|
});
|
|
}
|
|
)
|
|
|
|
// Undo delete
|
|
.patch(
|
|
"/restore/:id",
|
|
checkPermission("managementAspect.restore"),
|
|
async (c) => {
|
|
const aspectId = c.req.param("id");
|
|
|
|
// Check if the desired aspects are present
|
|
const aspect = (await db.select().from(aspects).where(eq(aspects.id, aspectId)))[0];
|
|
|
|
if (!aspect) {
|
|
throw notFound({
|
|
message: "The aspect is not found",
|
|
});
|
|
}
|
|
|
|
// Make sure the aspect has been deleted (there is deletedAt)
|
|
if (!aspect.deletedAt) {
|
|
throw notFound({
|
|
message: "The aspect is not deleted",
|
|
});
|
|
}
|
|
|
|
// Restore aspects (remove deletedAt mark)
|
|
await db.update(aspects).set({ deletedAt: null }).where(eq(aspects.id, aspectId));
|
|
|
|
// Restore all related sub aspects that have also been deleted (if any)
|
|
await db.update(subAspects).set({ deletedAt: null }).where(eq(subAspects.aspectId, aspectId));
|
|
|
|
return c.json({
|
|
message: "Aspect and sub aspects restored successfully",
|
|
});
|
|
}
|
|
)
|
|
|
|
export default managementAspectRoute; |