@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/projects/_lib/router.ts

@@ -0,0 +1,376 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { and, asc, count, desc, eq, gte, inArray, isNotNull, lt, sql } from "drizzle-orm";
+import { after } from "next/server";
+import z from "zod";
+import { DRIVE_NAMESPACES } from "@/app/admin/drive/_config/namespaces";
+import { calculateNetAmount } from "@/lib/helpers/calculate";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import {
+  clients,
+  nodes,
+  purchaseOrderItems,
+  purchaseOrders,
+  quotations,
+  runs,
+} from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import { drive } from "../../drive/_lib/service.server";
+import { calculateOrderTotal } from "../../purchase-orders/_lib/helpers";
+import {
+  calculateTotalDuration,
+  calculateTotalDurationInHours,
+} from "../../registrations/_lib/helpers";
+import type { ProjectColumn } from "../_config/columns-data";
+import {
+  projectDatabaseFiltersCompiler,
+  projectFiltersParser,
+  projectFiltersSchema,
+} from "../_config/filters";
+import {
+  projectTableDatabaseSortsCompiler,
+  projectTableSortsParser,
+  projectTableSortsSchema,
+} from "../_config/sorting";
+import { ensureProjectDriveFolder, ensureProjectTechnicalSheetDriveFolder } from "./helpers.server";
+import { projects } from "./schema";
+import { createProjectSchema, projectStatusSchema, updateProjectSchema } from "./validators";
+
+export const projectsRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ project: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: projectFiltersSchema,
+        sorts: projectTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = projectTableSortsParser.parse(input.sorts);
+      const orderBy = projectTableDatabaseSortsCompiler(projects).parse(parsedSorts);
+
+      const parsedFilters = projectFiltersParser.parse(input.filters);
+      const where = projectDatabaseFiltersCompiler(projects).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, projects, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: { client: true },
+      });
+
+      return offsetPaginationResponse({
+        data: data as ProjectColumn[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  filterCustomers: protectedProcedure
+    .use(permissionMiddleware({ project: ["view"] }))
+    .input(z.object({ filters: projectFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parser = projectFiltersParser.omit({ clientId: true });
+      const parsedFilters = parser.parse(filters);
+      const where = projectDatabaseFiltersCompiler(projects).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: clients.id,
+          label: clients.name,
+          total: count(projects.id),
+        })
+        .from(clients)
+        .leftJoin(projects, and(eq(clients.id, projects.clientId), where))
+        .where(eq(clients.isDeleted, false))
+        .groupBy(clients.id)
+        .having(gte(sql<number>`count(${projects.id})`, 1))
+        .orderBy(clients.name);
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ project: ["view"] }))
+    .handler(async ({ context }) =>
+      context.db
+        .select()
+        .from(projects)
+        .orderBy(desc(projects.title))
+        .where(eq(projects.isDeleted, false)),
+    ),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ project: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [data] = await context.db.select().from(projects).where(eq(projects.id, input.id));
+
+      return data ?? null;
+    }),
+  getDrive: protectedProcedure
+    .use(permissionMiddleware({ project: ["view.drive"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const project = await context.db.query.projects.findFirst({
+        where: eq(projects.id, input.id),
+      });
+      if (!project) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gevonden",
+        });
+      }
+
+      const nodeId = await ensureProjectDriveFolder(context, project);
+
+      const [folder] = await context.db.select().from(nodes).where(eq(nodes.id, nodeId));
+
+      if (!folder) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Folder kon niet worden gevonden",
+        });
+      }
+
+      return folder;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ project: ["create"] }))
+    .input(createProjectSchema)
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db.insert(projects).values(input).returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden aangemaakt",
+        });
+      }
+
+      after(async () => {
+        const folderId = await ensureProjectDriveFolder(context, result);
+        await ensureProjectTechnicalSheetDriveFolder(context, result);
+
+        /**
+         * Create default folders
+         */
+        await drive.createFolder({
+          name: "Keuringsverslagen",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+
+        await drive.createFolder({
+          name: "Eigen plannen",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+
+        await drive.createFolder({
+          name: "Architect plannen",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+
+        await drive.createFolder({
+          name: "Andere",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+      });
+
+      return result;
+    }),
+  createFromQuotation: protectedProcedure
+    .use(permissionMiddleware({ project: ["create"] }))
+    .input(createProjectSchema)
+    .handler(async ({ context, input }) => {
+      if (!input.quotationId) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Offerte ID is vereist om een project aan te maken",
+        });
+      }
+
+      const quotation = await context.db.query.quotations.findFirst({
+        where: eq(quotations.id, input.quotationId),
+        with: { items: true },
+      });
+
+      if (!quotation) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Offerte kon niet worden gevonden",
+        });
+      }
+
+      const budget = calculateNetAmount(quotation.items).toNumber();
+
+      const [result] = await context.db
+        .insert(projects)
+        .values({ ...input, budget })
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Project kon niet worden aangemaakt",
+        });
+      }
+
+      after(async () => {
+        const folderId = await ensureProjectDriveFolder(context, result);
+        await ensureProjectTechnicalSheetDriveFolder(context, result);
+
+        /**
+         * Create default folders
+         */
+        await drive.createFolder({
+          name: "Keuringsverslagen",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+
+        await drive.createFolder({
+          name: "Eigen plannen",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+
+        await drive.createFolder({
+          name: "Architect plannen",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+
+        await drive.createFolder({
+          name: "Andere",
+          namespace: DRIVE_NAMESPACES.projects.namespace,
+          parentId: folderId,
+        });
+      });
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ project: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateProjectSchema.partial() }))
+    .handler(async ({ context, input }) =>
+      context.db.update(projects).set(input.data).where(eq(projects.id, input.id)),
+    ),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ project: ["update"] }))
+    .input(bulkActionSchema.extend({ status: projectStatusSchema }))
+    .handler(async ({ context, input }) =>
+      context.db
+        .update(projects)
+        .set({
+          status: input.status,
+          // Set the start date if the status is active and the start date is not set
+          startDate:
+            input.status === "active" ? sql`COALESCE(${projects.startDate}, NOW())` : undefined,
+          // Set the end date if the status is finished and the end date is not set
+          endDate:
+            input.status === "finished" ? sql`COALESCE(${projects.endDate}, NOW())` : undefined,
+        })
+        .where(inArray(projects.id, input.ids)),
+    ),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ project: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) =>
+      context.db.update(projects).set({ isDeleted: true }).where(inArray(projects.id, input.ids)),
+    ),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ project: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) =>
+      context.db.update(projects).set({ isDeleted: false }).where(inArray(projects.id, input.ids)),
+    ),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ project: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) =>
+      context.db.delete(projects).where(inArray(projects.id, input.ids)),
+    ),
+  getBudgetByMonth: protectedProcedure
+    .use(permissionMiddleware({ project: ["view.budget"] }))
+    .input(z.object({ year: z.number().optional() }).optional())
+    .handler(async ({ context, input }) => {
+      const year = input?.year ?? new Date().getFullYear();
+
+      const startOfYear = new Date(year, 0, 1);
+      const startOfNextYear = new Date(year + 1, 0, 1);
+
+      const budgetPerMonth = await context.db
+        .select({
+          month: sql<string>`to_char(date_trunc('month', ${projects.startDate}), 'Month')`,
+          budget: sql<number>`sum(${projects.budget})`,
+        })
+        .from(projects)
+        .where(
+          and(
+            gte(projects.startDate, startOfYear),
+            lt(projects.startDate, startOfNextYear),
+            eq(projects.isDeleted, false),
+            isNotNull(projects.budget),
+            isNotNull(projects.startDate),
+          ),
+        )
+        .groupBy(sql`date_trunc('month', ${projects.startDate})`)
+        .orderBy(sql`date_trunc('month', ${projects.startDate})`);
+
+      return budgetPerMonth;
+    }),
+  getBudgetStats: protectedProcedure
+    .use(permissionMiddleware({ project: ["view.stats"] }))
+    .input(z.object({ projectId: z.string(), clientId: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [client] = await context.db
+        .select({
+          clientName: clients.name,
+          clientType: clients.type,
+        })
+        .from(clients)
+        .where(and(eq(clients.isDeleted, false), eq(clients.id, input?.clientId)));
+
+      const projectRuns = await context.db.query.runs.findMany({
+        where: and(
+          eq(runs.isDeleted, false),
+          eq(runs.status, "finished"),
+          eq(runs.projectId, input.projectId),
+        ),
+        with: {
+          runsRegistrations: { with: { registration: true } },
+        },
+      });
+
+      const registrations = projectRuns
+        .flatMap((run) => run.runsRegistrations)
+        .flatMap((run) => run.registration);
+
+      const totalRegistrationDuration = calculateTotalDuration(registrations);
+      const totalRegistrationCost = calculateTotalDurationInHours(registrations) * 35;
+
+      const projectPurchaseOrders = await context.db.query.purchaseOrders.findMany({
+        where: and(
+          eq(purchaseOrders.isDeleted, false),
+          eq(purchaseOrders.projectId, input.projectId),
+        ),
+        with: {
+          items: { orderBy: asc(purchaseOrderItems.index) },
+        },
+      });
+
+      const purchaseOrdersItems = projectPurchaseOrders.flatMap((order) => order.items);
+      const totalOrderCost = calculateOrderTotal(purchaseOrdersItems);
+
+      const cost = totalRegistrationCost + totalOrderCost;
+
+      return {
+        client,
+        totalRegistrationDuration,
+        totalRegistrationCost,
+        totalOrderCost,
+        cost,
+      };
+    }),
+};

package/dist/templates/spark/src/app/admin/projects/_lib/schema.ts

@@ -0,0 +1,56 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { clients, nodes, subprojects, tasks, technicalSheets } from "@/server/db/schema";
+import { quotations } from "../../quotations/_lib/schema";
+
+export const projectEnum = pgEnum("project_status_enum", ["draft", "active", "finished"]);
+
+/**
+ * Project table
+ */
+export const projects = pgTable("projects", (t) => ({
+  ...baseColumns,
+  title: t.varchar().notNull(),
+  status: projectEnum().default("draft").notNull(),
+  notes: t.jsonb(),
+  budget: t.doublePrecision(),
+  expectedCost: t.doublePrecision(),
+  startDate: t.timestamp(),
+  endDate: t.timestamp(),
+  deadline: t.timestamp(),
+  architect: t.varchar(),
+  owner: t.varchar(),
+  isDeleted: t.boolean().default(false).notNull(),
+  clientId: t
+    .uuid()
+    .notNull()
+    .references(() => clients.id, { onDelete: "restrict" }),
+  quotationId: t
+    .uuid()
+    .unique()
+    .references(() => quotations.id, { onDelete: "set default" }),
+  nodeId: t.uuid().references(() => nodes.id, { onDelete: "set default" }),
+  technicalSheetsNodeId: t.uuid().references(() => nodes.id, { onDelete: "set default" }),
+}));
+
+/**
+ * Relations
+ */
+export const projectsRelations = relations(projects, ({ many, one }) => ({
+  subprojects: many(subprojects),
+  tasks: many(tasks),
+  client: one(clients, {
+    fields: [projects.clientId],
+    references: [clients.id],
+  }),
+  quotation: one(quotations, {
+    fields: [projects.quotationId],
+    references: [quotations.id],
+  }),
+  node: one(nodes, {
+    fields: [projects.nodeId],
+    references: [nodes.id],
+  }),
+  technicalSheets: many(technicalSheets),
+}));

package/dist/templates/spark/src/app/admin/projects/_lib/validators.ts

@@ -0,0 +1,36 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type { ProjectFilters } from "../_config/filters";
+export { projectFiltersSchema } from "../_config/filters";
+
+import { projectEnum, projects } from "./schema";
+
+/**
+ * Contact type
+ */
+export type Project = typeof projects.$inferSelect;
+
+export const selectProjectSchema = createSelectSchema(projects);
+export type SelectProjectSchema = z.infer<typeof selectProjectSchema>;
+
+/**
+ * Issue status
+ */
+export const projectStatusSchema = z.enum(projectEnum.enumValues);
+export type ProjectStatus = z.infer<typeof projectStatusSchema>;
+
+/**
+ * Schema
+ */
+export const createProjectSchema = createInsertSchema(projects);
+export const updateProjectSchema = createUpdateSchema(projects);
+
+/**
+ * Create project schema
+ */
+export type CreateProjectInput = z.input<typeof createProjectSchema>;
+export type CreateProjectSchema = z.infer<typeof createProjectSchema>;
+
+export type UpdateProjectInput = z.input<typeof updateProjectSchema>;
+export type UpdateProjectSchema = z.infer<typeof updateProjectSchema>;

package/dist/templates/spark/src/app/admin/projects/drive/(root)/layout.tsx

@@ -0,0 +1,3 @@
+import Layout from "../folders/[id]/layout";
+
+export default Layout;

package/dist/templates/spark/src/app/admin/projects/drive/(root)/loading.tsx

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

package/dist/templates/spark/src/app/admin/projects/drive/(root)/page.tsx

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

package/dist/templates/spark/src/app/admin/projects/drive/folders/[id]/layout.tsx

@@ -0,0 +1,26 @@
+import { LocalDriveContent } from "@tulip-systems/drive-local/client";
+import type { PropsWithChildren } from "react";
+import { DriveHeader } from "@/app/admin/drive/_components/header.client";
+import { DriveProvider } from "@/app/admin/drive/_components/provider.client";
+import { DRIVE_NAMESPACES } from "@/app/admin/drive/_config/namespaces";
+
+const { namespace, permission } = DRIVE_NAMESPACES.projects;
+
+export default async function DriveGridLayoutPage(
+  props: PropsWithChildren<{ params: Promise<{ id?: string }> }>,
+) {
+  const { id } = await props.params;
+
+  return (
+    <DriveProvider
+      namespace={namespace}
+      permission={permission}
+      parentId={id ?? null}
+      navigation={{ rootHref: "/admin/projects/drive" }}
+    >
+      <DriveHeader breadcrumbs={[{ label: "Projecten", href: "/admin/projects" }]} />
+
+      <LocalDriveContent>{props.children}</LocalDriveContent>
+    </DriveProvider>
+  );
+}

package/dist/templates/spark/src/app/admin/projects/drive/folders/[id]/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/projects/drive/folders/[id]/page.tsx

@@ -0,0 +1,5 @@
+import { DriveView } from "@/app/admin/drive/_components/view.client";
+
+export default function Page() {
+  return <DriveView className="p-content" />;
+}

package/dist/templates/spark/src/app/admin/purchase-order-items/_components/tables.tsx

@@ -0,0 +1,148 @@
+"use client";
+import { useSuspenseInfiniteQuery, useSuspenseQuery } from "@tanstack/react-query";
+import type { VisibilityState } from "@tanstack/react-table";
+import type { CommandFor } from "@tulip-systems/commands";
+import type { TableColumnDef } from "@tulip-systems/data-tables";
+import {
+  createTableConfig,
+  TableConfigProvider,
+  useInfiniteStrategy,
+  usePaginationStrategy,
+} from "@tulip-systems/data-tables/client";
+import { offsetPagination } from "@tulip-systems/query";
+import {
+  type UseFiltersOptions,
+  useFilters,
+  usePagination,
+  useSorting,
+} from "@tulip-systems/query/client";
+import { type PropsWithChildren, useDeferredValue, useMemo } from "react";
+import { orpc } from "@/server/router/client";
+import type { PurchaseOrderItemColumn } from "../_config/columns-data";
+import { purchaseOrderItemsFilters } from "../_config/filters";
+import { purchaseOrderItemTableSorts } from "../_config/sorting";
+
+/**
+ * Client data table
+ */
+type PurchaseOrderItemTableProviderProps<TData extends PurchaseOrderItemColumn> = {
+  columns: TableColumnDef<TData>[];
+  commands?: CommandFor<TData[]>[];
+  filterOptions?: UseFiltersOptions<typeof purchaseOrderItemsFilters>;
+  columnVisibility?: VisibilityState;
+};
+
+export function PurchaseOrderItemInfiniteTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+
+  children,
+}: PropsWithChildren<PurchaseOrderItemTableProviderProps<PurchaseOrderItemColumn>>) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(purchaseOrderItemsFilters, filterOptions);
+  const sorting = useSorting(purchaseOrderItemTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseInfiniteQuery(
+    orpc.purchaseOrderItems.list.infiniteOptions({
+      initialPageParam: 0,
+      input: (page: number | undefined) => ({
+        ...input,
+        pagination: { ...input.pagination, page: page ?? input.pagination.page },
+      }),
+      getNextPageParam: ({ pagination }) => pagination.nextPage,
+      getPreviousPageParam: ({ pagination }) => pagination.previousPage,
+    }),
+  );
+
+  const { total } = response.data.pages.at(-1)?.pagination ?? {};
+
+  /**
+   * Strategy
+   */
+  const strategy = useInfiniteStrategy({
+    pagination,
+    total,
+    fetchNextPage: response.fetchNextPage,
+    isFetching: response.isFetching,
+    isFetchingNextPage: response.isFetchingNextPage,
+  });
+
+  const queryData = useMemo(
+    () => response.data.pages.flatMap(({ data }) => data) ?? [],
+    [response.data],
+  );
+
+  /**
+   * Table
+   */
+  const config = createTableConfig<PurchaseOrderItemColumn>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    filtering,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}
+
+export function PurchaseOrderItemPaginationTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+
+  children,
+}: PropsWithChildren<PurchaseOrderItemTableProviderProps<PurchaseOrderItemColumn>>) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(purchaseOrderItemsFilters, filterOptions);
+  const sorting = useSorting(purchaseOrderItemTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseQuery(orpc.purchaseOrderItems.list.queryOptions({ input }));
+
+  const queryData = useMemo(() => response.data.data ?? [], [response.data.data]);
+  const { total } = response.data.pagination;
+
+  /**
+   * Strategy
+   */
+  const strategy = usePaginationStrategy({ pagination, total });
+
+  /**
+   * Table
+   */
+  const config = createTableConfig<PurchaseOrderItemColumn>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}

package/dist/templates/spark/src/app/admin/purchase-order-items/_components/toolbars.tsx

@@ -0,0 +1,24 @@
+"use client";
+
+import { TableToolbar, TableToolbarList } from "@tulip-systems/data-tables";
+import { resolveFilterDescriptors } from "@tulip-systems/query";
+import { FilterSearch } from "@tulip-systems/query/client";
+import type { PropsWithChildren } from "react";
+import { purchaseOrderItemsFilters } from "../_config/filters";
+
+const purchaseOrderItemsFiltersDescriptors = resolveFilterDescriptors(purchaseOrderItemsFilters);
+
+export function PurchaseOrderItemTableToolbar({ children }: PropsWithChildren) {
+  return (
+    <TableToolbar>
+      <TableToolbarList>
+        <FilterSearch
+          placeholder="Zoeken..."
+          filter={purchaseOrderItemsFiltersDescriptors.search}
+        />
+      </TableToolbarList>
+
+      <TableToolbarList>{children}</TableToolbarList>
+    </TableToolbar>
+  );
+}