@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/technical-sheets/_lib/router.ts

@@ -0,0 +1,327 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { arrayMove } from "@tulip-systems/core";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { and, asc, desc, eq, inArray, isNotNull } from "drizzle-orm";
+import { after } from "next/server";
+import z from "zod";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { nodes, quotationItems } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import type { TechnicalSheetTableData } from "../_components/tables";
+import {
+  technicalSheetDatabaseFiltersCompiler,
+  technicalSheetFiltersInputSchema,
+  technicalSheetFiltersParser,
+} from "../_config/filters";
+import {
+  technicalSheetTableDatabaseSortsCompiler,
+  technicalSheetTableSortsParser,
+  technicalSheetTableSortsSchema,
+} from "../_config/sorting";
+import {
+  deleteTechnicalSheetDocument,
+  generateTechnicalSheetDocument,
+  getTechnicalSheetPDFData,
+} from "./helpers.server";
+import { technicalSheetSources, technicalSheets } from "./schema";
+import {
+  createTechnicalSheetSchema,
+  technicalSheetStatusSchema,
+  updateTechnicalSheetSchema,
+} from "./validators";
+
+export const technicalSheetsRouter = {
+  list: protectedProcedure
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: technicalSheetFiltersInputSchema,
+        sorts: technicalSheetTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = technicalSheetTableSortsParser.parse(input.sorts);
+      const orderBy = technicalSheetTableDatabaseSortsCompiler(technicalSheets).parse(parsedSorts);
+
+      const parsedFilters = technicalSheetFiltersParser.parse(input.filters);
+      const where = technicalSheetDatabaseFiltersCompiler(technicalSheets).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, technicalSheets, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: { project: true, sources: true, product: true },
+      });
+
+      return offsetPaginationResponse({
+        data: data as TechnicalSheetTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  getById: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.technicalSheets.findFirst({
+        where: eq(technicalSheets.id, input.id),
+        with: { project: true, product: true, sources: true },
+      });
+
+      return data ?? null;
+    }),
+  getPDFData: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => getTechnicalSheetPDFData(context, input)),
+  getDownloadData: protectedProcedure
+    .input(z.object({ ids: z.string().array() }))
+    .handler(async ({ context, input }) =>
+      context.db.query.technicalSheets.findMany({
+        where: and(
+          inArray(technicalSheets.id, input.ids),
+          isNotNull(technicalSheets.generatedNodeId),
+        ),
+        with: { generatedNode: true },
+      }),
+    ),
+  create: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["create"] }))
+    .input(createTechnicalSheetSchema)
+    .handler(async ({ context, input }) => {
+      const lastTechnicalSheet = await context.db
+        .select({ index: technicalSheets.index })
+        .from(technicalSheets)
+        .limit(1)
+        .where(eq(technicalSheets.projectId, input.projectId))
+        .orderBy(desc(technicalSheets.index));
+
+      const index = (lastTechnicalSheet[0]?.index ?? 0) + 1;
+
+      const [result] = await context.db
+        .insert(technicalSheets)
+        .values({ ...input, index })
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Technische fiche kon niet worden aangemaakt",
+        });
+      }
+    }),
+  importQuotationItems: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["create"] }))
+    .input(z.object({ projectId: z.string(), quotationItemIds: z.string().array() }))
+    .handler(async ({ context, input }) => {
+      const selectedQuotationItems = await context.db.query.quotationItems.findMany({
+        where: inArray(quotationItems.id, input.quotationItemIds),
+      });
+
+      await context.db.transaction(async (tx) =>
+        Promise.allSettled(
+          selectedQuotationItems.map((quotationItem) =>
+            tx.insert(technicalSheets).values({
+              articleNumber: quotationItem.articleNumber,
+              description: quotationItem.description,
+              index: quotationItem.index,
+              projectId: input.projectId,
+            }),
+          ),
+        ),
+      );
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateTechnicalSheetSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(technicalSheets)
+        .set(input.data)
+        .where(eq(technicalSheets.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Technische fiche kon niet worden aangemaakt",
+        });
+      }
+
+      after(async () => {
+        await generateTechnicalSheetDocument(context, { id: input.id });
+      });
+    }),
+  updateProduct: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(z.object({ id: z.string(), productId: z.string().nullable() }))
+    .output(z.void())
+    .handler(async ({ context, input: { id, productId } }) => {
+      // delete the old sources
+      await context.db.delete(technicalSheetSources).where(eq(technicalSheetSources.sheetId, id));
+
+      // update the product
+      const [result] = await context.db
+        .update(technicalSheets)
+        .set({ productId })
+        .where(eq(technicalSheets.id, id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Technische fiche kon niet worden bijgewerkt",
+        });
+      }
+
+      after(async () => {
+        await generateTechnicalSheetDocument(context, { id });
+      });
+    }),
+  addSource: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(z.object({ id: z.string(), nodeId: z.string() }))
+    .handler(async ({ context, input }) => {
+      // Delete all existing sources
+      await context.db
+        .delete(technicalSheetSources)
+        .where(eq(technicalSheetSources.sheetId, input.id));
+
+      // Add new source
+      await context.db.insert(technicalSheetSources).values({
+        sheetId: input.id,
+        nodeId: input.nodeId,
+      });
+
+      after(async () => {
+        await generateTechnicalSheetDocument(context, { id: input.id });
+      });
+    }),
+  addSources: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(z.object({ id: z.string(), nodeIds: z.array(z.string()) }))
+    .handler(async ({ context, input }) => {
+      const newSources = await context.db.query.nodes.findMany({
+        where: and(inArray(nodes.id, input.nodeIds), eq(nodes.contentType, "application/pdf")),
+        columns: { id: true },
+      });
+
+      if (newSources.length === 0) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Er zijn geen geldige bronnen om toe te voegen",
+        });
+      }
+
+      // Delete all existing sources
+      await context.db
+        .delete(technicalSheetSources)
+        .where(eq(technicalSheetSources.sheetId, input.id));
+
+      // Add new source
+      await context.db.insert(technicalSheetSources).values(
+        newSources.map(({ id }) => ({
+          sheetId: input.id,
+          nodeId: id,
+        })),
+      );
+
+      after(async () => {
+        await generateTechnicalSheetDocument(context, { id: input.id });
+      });
+    }),
+  generateDocument: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      const technicalSheetsToGenerate = await context.db.query.technicalSheets.findMany({
+        where: and(inArray(technicalSheets.id, input.ids), isNotNull(technicalSheets.productId)),
+        with: { sources: true },
+      });
+
+      const sheetIds = technicalSheetsToGenerate
+        .filter((sheet) => !!sheet.productId)
+        .filter((sheet) => sheet.sources.length > 0)
+        .map((sheet) => sheet.id);
+
+      const results = await Promise.allSettled(
+        sheetIds.map((id) => generateTechnicalSheetDocument(context, { id })),
+      );
+
+      const errors = results.filter((result) => result.status === "rejected");
+      if (errors.length > 0) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Document kon niet worden gegenereerd",
+        });
+      }
+
+      return results.filter((result) => result.status === "fulfilled");
+    }),
+  move: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(
+      z.object({
+        fromIndex: z.number(),
+        toIndex: z.number(),
+        projectId: z.string(),
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      /**
+       * Get all items
+       */
+      const items = await context.db
+        .select({ id: technicalSheets.id })
+        .from(technicalSheets)
+        .where(eq(technicalSheets.projectId, input.projectId))
+        .orderBy(asc(technicalSheets.index));
+      const newItems = arrayMove(items, input);
+
+      /**
+       * Update the index of the items by splicing the item to the new index.
+       */
+      await context.db.transaction(async (tx) =>
+        Promise.allSettled(
+          newItems.map((item, index) =>
+            tx.update(technicalSheets).set({ index }).where(eq(technicalSheets.id, item.id)),
+          ),
+        ),
+      );
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db.delete(technicalSheets).where(inArray(technicalSheets.id, input.ids));
+    }),
+  deleteDocuments: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await Promise.allSettled(
+        input.ids.map((generatedNodeId) =>
+          deleteTechnicalSheetDocument(context, { generatedNodeId }),
+        ),
+      );
+    }),
+  deleteSources: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .delete(technicalSheetSources)
+        .where(eq(technicalSheetSources.sheetId, input.id));
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ technicalSheet: ["update"] }))
+    .input(bulkActionSchema.extend({ status: technicalSheetStatusSchema }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(technicalSheets)
+        .set({ status: input.status })
+        .where(inArray(technicalSheets.id, input.ids))
+        .returning();
+    }),
+};

package/dist/templates/spark/src/app/admin/technical-sheets/_lib/schema.ts

@@ -0,0 +1,85 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { index, pgEnum, pgTable } from "drizzle-orm/pg-core";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { baseColumns } from "@/server/db/helpers";
+import { nodes, products } from "@/server/db/schema";
+
+export const technicalSheetStatusEnum = pgEnum("technical_sheet_status_enum", [
+  "draft",
+  "sent",
+  "accepted",
+  "rejected",
+  "expired",
+]);
+
+/**
+ * Table
+ */
+export const technicalSheets = pgTable(
+  "technical_sheets",
+  (t) => ({
+    ...baseColumns,
+    articleNumber: t.varchar(),
+    description: t.jsonb().$type<EditorJSONContent>().notNull(),
+    status: technicalSheetStatusEnum().default("draft").notNull(),
+    type: t.varchar(),
+    notes: t.jsonb().$type<EditorJSONContent>(),
+    index: t.integer().notNull(),
+    projectId: t
+      .uuid()
+      .notNull()
+      .references(() => projects.id, { onDelete: "cascade" }),
+    productId: t.uuid().references(() => products.id, { onDelete: "restrict" }),
+    generatedNodeId: t.uuid().references(() => nodes.id, { onDelete: "set null" }),
+  }),
+  (table) => [index("technical_sheets_index_idx").on(table.index)],
+);
+
+/**
+ * Relations
+ */
+export const technicalSheetsRelations = relations(technicalSheets, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [technicalSheets.projectId],
+    references: [projects.id],
+  }),
+  product: one(products, {
+    fields: [technicalSheets.productId],
+    references: [products.id],
+  }),
+  generatedNode: one(nodes, {
+    fields: [technicalSheets.generatedNodeId],
+    references: [nodes.id],
+  }),
+  sources: many(technicalSheetSources),
+}));
+
+/**
+ * Table
+ */
+export const technicalSheetSources = pgTable("technical_sheets_sources", (t) => ({
+  ...baseColumns,
+  sheetId: t
+    .uuid()
+    .notNull()
+    .references(() => technicalSheets.id, { onDelete: "cascade" }),
+  nodeId: t
+    .uuid()
+    .notNull()
+    .references(() => nodes.id, { onDelete: "restrict" }),
+}));
+
+/**
+ * Relations
+ */
+export const technicalSheetSourcesRelations = relations(technicalSheetSources, ({ one }) => ({
+  technicalSheet: one(technicalSheets, {
+    fields: [technicalSheetSources.sheetId],
+    references: [technicalSheets.id],
+  }),
+  node: one(nodes, {
+    fields: [technicalSheetSources.nodeId],
+    references: [nodes.id],
+  }),
+}));

package/dist/templates/spark/src/app/admin/technical-sheets/_lib/validators.ts

@@ -0,0 +1,50 @@
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type { TechnicalSheetFiltersInputSchema as TechnicalSheetFiltersInput } from "../_config/filters";
+export { technicalSheetFiltersInputSchema } from "../_config/filters";
+
+import { technicalSheetSources, technicalSheetStatusEnum, technicalSheets } from "./schema";
+
+/**
+ * TechnicalSheet type
+ */
+export type TechnicalSheet = typeof technicalSheets.$inferSelect;
+
+export type TechnicalSheetSource = typeof technicalSheetSources.$inferSelect;
+
+export const selectTechnicalSheetSchema = createSelectSchema(technicalSheets);
+export type SelectTechnicalSheetSchema = z.infer<typeof selectTechnicalSheetSchema>;
+
+export const selectTechnicalSheetSourceSchema = createSelectSchema(technicalSheetSources);
+export type SelectTechnicalSheetSourceSchema = z.infer<typeof selectTechnicalSheetSourceSchema>;
+
+/**
+ * TechnicalSheet status
+ */
+export const technicalSheetStatusSchema = z.enum(technicalSheetStatusEnum.enumValues);
+export type TechnicalSheetStatus = z.infer<typeof technicalSheetStatusSchema>;
+
+/**
+ * Schema
+ */
+export const createTechnicalSheetSchema = createInsertSchema(technicalSheets).omit({ index: true });
+export const updateTechnicalSheetSchema = createInsertSchema(technicalSheets);
+
+/**
+ * Create project schema
+ */
+export type CreateTechnicalSheetInput = z.input<typeof createTechnicalSheetSchema>;
+export type CreateTechnicalSheetSchema = z.infer<typeof createTechnicalSheetSchema>;
+
+export type UpdateTechnicalSheetInput = z.input<typeof updateTechnicalSheetSchema>;
+export type UpdateTechnicalSheetSchema = z.infer<typeof updateTechnicalSheetSchema>;
+
+/**
+ * Create inline technicalSheet schema
+ */
+export const createInlineTechnicalSheetSchema = createInsertSchema(technicalSheets)
+  .omit({ id: true })
+  .extend({ id: z.string() });
+
+export type CreateInlineTechnicalSheetSchema = z.infer<typeof createInlineTechnicalSheetSchema>;

package/dist/templates/spark/src/app/admin/technical-sheets/import/[id]/drive/(root)/loading.tsx

@@ -0,0 +1,3 @@
+import Loading from "../folders/[folderId]/loading";
+
+export default Loading;

package/dist/templates/spark/src/app/admin/technical-sheets/import/[id]/drive/(root)/page.tsx

@@ -0,0 +1,3 @@
+import Page from "../folders/[folderId]/page";
+
+export default Page;

package/dist/templates/spark/src/app/admin/technical-sheets/import/[id]/drive/folders/[folderId]/loading.tsx

@@ -0,0 +1,5 @@
+import { LocalDriveViewLoading } from "@tulip-systems/drive-local/client";
+
+export default function Loading() {
+  return <LocalDriveViewLoading className="p-content" />;
+}

package/dist/templates/spark/src/app/admin/technical-sheets/import/[id]/drive/folders/[folderId]/page.tsx

@@ -0,0 +1,117 @@
+"use client";
+
+import { useMutation, useSuspenseQuery } from "@tanstack/react-query";
+import type { RowSelectionState } from "@tanstack/react-table";
+import { EmptyPageDescription } from "@tulip-systems/app/components";
+import { LocalDriveContent } from "@tulip-systems/drive-local/client";
+import { Button } from "@tulip-systems/ui/button";
+import { EmptyPage, EmptyPageTitle } from "@tulip-systems/ui/empty";
+import { toast } from "@tulip-systems/ui/sonner";
+import { notFound, useRouter } from "next/navigation";
+import { use, useState } from "react";
+import { DriveToolbar } from "@/app/admin/drive/_components/header.client";
+import { DriveProvider } from "@/app/admin/drive/_components/provider.client";
+import { DriveView } from "@/app/admin/drive/_components/view.client";
+import { DRIVE_NAMESPACES } from "@/app/admin/drive/_config/namespaces";
+import { Icons } from "@/components/icons";
+import { orpc } from "@/server/router/client";
+
+export default function Page(props: { params: Promise<{ id: string; folderId?: string }> }) {
+  const router = useRouter();
+
+  const params = use(props.params);
+  const id = params.id?.toString();
+  const folderId = params.folderId?.toString();
+  if (!id) notFound();
+
+  const [rowSelection, setRowSelection] = useState<RowSelectionState>({});
+
+  const { data } = useSuspenseQuery(orpc.technicalSheets.getById.queryOptions({ input: { id } }));
+  if (!data) notFound();
+
+  const { mutate, status } = useMutation(
+    orpc.technicalSheets.addSources.mutationOptions({
+      onSuccess: () => {
+        setRowSelection({});
+        toast.success("Bestanden succesvol geïmporteerd");
+        router.push(`/admin/technical-sheets/${id}`);
+      },
+      onError: (err) => {
+        toast.error("Importeren mislukt", { description: err.message });
+      },
+    }),
+  );
+
+  if (!data.productId) {
+    return (
+      <div className="p-content">
+        <EmptyPage className="min-h-[80dvh]">
+          <EmptyPageTitle>Product niet gekoppeld</EmptyPageTitle>
+          <EmptyPageDescription>
+            Deze technische sheet is niet gekoppeld aan een product, waardoor importeren vanuit
+            Drive niet mogelijk is.
+          </EmptyPageDescription>
+          <Button onClick={() => router.push(`/admin/technical-sheets/${id}`)}>Ga terug</Button>
+        </EmptyPage>
+      </div>
+    );
+  }
+
+  if (!data.product?.nodeId) {
+    return (
+      <div className="p-content">
+        <EmptyPage className="min-h-[80dvh]">
+          <EmptyPageTitle>Geen drive folder gevonden</EmptyPageTitle>
+          <EmptyPageDescription>
+            Het product dat gekoppeld is aan deze technische sheet heeft geen Drive folder, waardoor
+            importeren vanuit Drive niet mogelijk is.
+          </EmptyPageDescription>
+          <Button onClick={() => router.push(`/admin/technical-sheets/${id}`)}>Ga terug</Button>
+        </EmptyPage>
+      </div>
+    );
+  }
+
+  return (
+    <>
+      <DriveProvider
+        namespace={DRIVE_NAMESPACES.products.namespace}
+        parentId={folderId ?? data.product.nodeId}
+        navigation={{ rootHref: `/admin/technical-sheets/import/${id}/drive` }}
+        selection={{ rowSelection, setRowSelection }}
+        // where={{ contentTypes: ["application/pdf"] }}
+      >
+        <LocalDriveContent>
+          <DriveToolbar className="px-content" />
+          <DriveView className="px-content" />
+        </LocalDriveContent>
+      </DriveProvider>
+
+      <div className="absolute right-0 bottom-0 left-0 overflow-auto border-t bg-background text-end">
+        <div className="flex w-max flex-row justify-end gap-10 px-10 py-6 md:w-full">
+          <Button
+            variant="ghost"
+            type="button"
+            onClick={() => {
+              setRowSelection({});
+              router.push(`/admin/technical-sheets/${id}`);
+            }}
+          >
+            Annuleren
+          </Button>
+
+          <Button
+            type="button"
+            disabled={Object.keys(rowSelection).length === 0 || status === "pending"}
+            onClick={() => {
+              mutate({ id, nodeIds: Object.keys(rowSelection) });
+            }}
+          >
+            {status === "pending" && <Icons.spinner className="mr-2 h-4 w-4 animate-spin" />}
+            Importeren
+          </Button>
+        </div>
+      </div>
+    </>
+  );
+}

package/dist/templates/spark/src/app/admin/technical-sheets/import/[id]/drive/layout.tsx

@@ -0,0 +1,15 @@
+import { Header, Topbar, TopbarTitle } from "@tulip-systems/app/components/client";
+
+export default function Page(props: LayoutProps<"/admin/technical-sheets/import/[id]/drive">) {
+  return (
+    <>
+      <Header>
+        <Topbar>
+          <TopbarTitle breadcrumbs={[{ label: "Drive importeren" }]} />
+        </Topbar>
+      </Header>
+
+      {props.children}
+    </>
+  );
+}

package/dist/templates/spark/src/app/admin/technical-sheets/import/quotation-items/layout.tsx

@@ -0,0 +1,16 @@
+import { Header, Topbar, TopbarTitle } from "@tulip-systems/app/components/client";
+import { TableLayout } from "@tulip-systems/data-tables";
+
+export default function Page(props: LayoutProps<"/admin/technical-sheets/import/quotation-items">) {
+  return (
+    <>
+      <Header>
+        <Topbar>
+          <TopbarTitle breadcrumbs={[{ label: "Offerte importeren" }]} />
+        </Topbar>
+      </Header>
+
+      <TableLayout className="p-10 pb-40">{props.children}</TableLayout>
+    </>
+  );
+}

package/dist/templates/spark/src/app/admin/technical-sheets/import/quotation-items/loading.tsx

@@ -0,0 +1,5 @@
+import { TableSkeleton } from "@tulip-systems/data-tables";
+
+export default function Loading() {
+  return <TableSkeleton />;
+}