@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/sales-orders/_config/commands.tsx

@@ -0,0 +1,196 @@
+"use client";
+
+import { commandBuilder, ensureArray } from "@tulip-systems/commands";
+import {
+  ArchiveCommand,
+  CommandClick,
+  CommandDropdown,
+  CommandDropdownContent,
+  CommandDropdownItem,
+  CommandDropdownTrigger,
+  CommandLabel,
+  type CommandMutationMeta,
+  DeleteCommand,
+  RestoreCommand,
+} from "@tulip-systems/commands/client";
+import { toast } from "@tulip-systems/ui/sonner";
+import { BadgeEuroIcon, ClipboardPlusIcon, MailPlusIcon } from "lucide-react";
+import { Icons } from "@/components/icons";
+import { orpc } from "@/server/router/client";
+import {
+  CreateSalesOrderCommand,
+  CreateSalesOrderCommandTrigger,
+} from "../_components/create-command";
+import {
+  SalesOrderPDFDownloadCommand,
+  SalesOrderPdfViewerCommand,
+} from "../_components/pdf-commands";
+import type { SalesOrder } from "../_lib/validators";
+import { SalesOrderStatusField, salesOrderStatusConfig } from "./status";
+
+type SalesOrderCommandItem = Pick<SalesOrder, "id" | "status"> & {
+  isDeleted: boolean;
+  nextSalesOrder?: Pick<SalesOrder, "id"> | null;
+};
+
+type SalesOrderCreateAssociatedCommandItem = SalesOrderCommandItem & {
+  nextSalesOrder: Pick<SalesOrder, "id"> | null;
+};
+
+const bulkSalesOrderCommandBuilder = commandBuilder
+  .$type<SalesOrderCommandItem | SalesOrderCommandItem[]>()
+  .transform(ensureArray);
+
+export const salesOrderPreviewCommand = commandBuilder
+  .$type<{ id: string }>()
+  .render(({ data }) => {
+    return <SalesOrderPdfViewerCommand id={data.id} />;
+  });
+export const salesOrderDownloadCommand = commandBuilder
+  .$type<{ id: string }>()
+  .render(({ data }) => {
+    return <SalesOrderPDFDownloadCommand id={data.id} />;
+  });
+export const salesOrderStatusCommand = bulkSalesOrderCommandBuilder
+  .permission({ salesOrder: ["update"] })
+  .render(({ data }) => (
+    <CommandDropdown>
+      <CommandDropdownTrigger label="Status">
+        <Icons.edit className="w-4" />
+        <CommandLabel />
+      </CommandDropdownTrigger>
+
+      <CommandDropdownContent>
+        {salesOrderStatusConfig.flatMap((status) => (
+          <CommandDropdownItem
+            key={status.value}
+            variables={{ ids: data.map((item) => item.id), status: status.value }}
+            mutation={orpc.salesOrders.setStatus.mutationOptions({
+              onSuccess: () => {
+                toast.success(`Status is gewijzigd naar ${status.label.toLowerCase()}`);
+              },
+            })}
+          >
+            <SalesOrderStatusField status={status.value} />
+          </CommandDropdownItem>
+        ))}
+      </CommandDropdownContent>
+    </CommandDropdown>
+  ));
+export const salesOrderCreateEmailCommand = commandBuilder
+  .$type<{ id: string }>()
+
+  .permission({ email: ["create"] })
+  .render(({ data }) => (
+    <CommandClick
+      variables={{ salesOrderId: data.id }}
+      mutation={orpc.salesOrders.createEmail.mutationOptions({
+        onSuccess: (result, _vars, _mutationResult, context) => {
+          toast.success("Nieuwe e-mail is aangemaakt");
+
+          const meta = context.meta as CommandMutationMeta;
+          if (result.id) meta.router.push(`/admin/sales-orders/${data.id}/emails/${result.id}`);
+        },
+      })}
+      label="Nieuwe e-mail"
+    >
+      <MailPlusIcon />
+      <CommandLabel />
+    </CommandClick>
+  ));
+export const salesOrderCreateInvoiceCommand = commandBuilder
+  .$type<{ id: string }>()
+
+  .render(({ data }) => (
+    <CommandClick
+      variables={{ salesOrderId: data.id }}
+      mutation={orpc.salesInvoices.create.mutationOptions({
+        onSuccess: (result, _vars, _mutationResult, context) => {
+          toast.success("Factuur is aangemaakt");
+
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push(`/admin/sales-invoices/${result.id}`);
+        },
+      })}
+      label="Factuur aanmaken"
+    >
+      <BadgeEuroIcon />
+      <CommandLabel />
+    </CommandClick>
+  ));
+export const salesOrderCreateAssociatedCommand = commandBuilder
+  .$type<SalesOrderCreateAssociatedCommandItem>()
+
+  .visibleWhen(({ data }) => [data.status !== "draft", !data.isDeleted, !data.nextSalesOrder])
+  .render(({ data }) => (
+    <CommandClick
+      variables={{ salesOrderId: data.id }}
+      mutation={orpc.salesOrders.createAssociatedSalesOrder.mutationOptions({
+        onSuccess: (result, _vars, _mutationResult, context) => {
+          toast.success("Verkoopbon is toegewezen");
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push(`/admin/sales-orders/${result.id}`);
+        },
+      })}
+      label="Verkoopbon associeeren"
+    >
+      <ClipboardPlusIcon />
+      <CommandLabel />
+    </CommandClick>
+  ));
+export const salesOrderCreateCommand = commandBuilder
+
+  .permission({ salesOrder: ["update"] })
+  .render(() => (
+    <CreateSalesOrderCommand
+      variables={(values) => values}
+      mutation={orpc.salesOrders.create.mutationOptions({
+        onSuccess: (data, _vars, _result, context) => {
+          toast.success("Verkoopbon succesvol toegevoegd");
+          const meta = context.meta as CommandMutationMeta;
+          if (data.id) meta.router.push(`/admin/sales-orders/${data.id}`);
+        },
+      })}
+    >
+      <CreateSalesOrderCommandTrigger label="Toevoegen" hotkey="mod+i">
+        <Icons.add />
+        <CommandLabel />
+      </CreateSalesOrderCommandTrigger>
+    </CreateSalesOrderCommand>
+  ));
+export const salesOrderArchiveCommand = bulkSalesOrderCommandBuilder
+  .permission({ salesOrder: ["archive"] })
+  .visibleWhen(({ data }) => data.every((item) => !item.isDeleted))
+  .render(({ data }) => (
+    <ArchiveCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.salesOrders.archive.mutationOptions({
+        onSuccess: () => toast.success("Succesvol gearchiveerd"),
+      })}
+    />
+  ));
+export const salesOrderRestoreCommand = bulkSalesOrderCommandBuilder
+  .permission({ salesOrder: ["archive"] })
+  .visibleWhen(({ data }) => data.every((item) => item.isDeleted))
+  .render(({ data }) => (
+    <RestoreCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.salesOrders.restore.mutationOptions({
+        onSuccess: () => toast.success("Succesvol hersteld"),
+      })}
+    />
+  ));
+export const salesOrderDeleteCommand = bulkSalesOrderCommandBuilder
+  .permission({ salesOrder: ["delete"] })
+  .render(({ data }) => (
+    <DeleteCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.salesOrders.delete.mutationOptions({
+        onSuccess: (_result, _vars, _mutationResult, context) => {
+          toast.success("Succesvol verwijderd");
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push("/admin/sales-orders");
+        },
+      })}
+    />
+  ));

package/dist/templates/spark/src/app/admin/sales-orders/_config/filters.ts

@@ -0,0 +1,82 @@
+import {
+  arrayFilter,
+  booleanFilter,
+  createFilteringParser,
+  defineFilters,
+  enumFilter,
+  resolveFiltersSchema,
+  stringFilter,
+} from "@tulip-systems/query";
+import { createDatabaseFiltersCompiler } from "@tulip-systems/query/drizzle";
+import type { z } from "zod";
+import { salesOrderStatusEnum } from "../_lib/schema-enums";
+
+export const salesOrdersFilters = defineFilters({
+  search: stringFilter.build((value) =>
+    value
+      ? {
+          or: [
+            { field: "number", operator: "ilike", value: `%${value}%` },
+            { field: "title", operator: "ilike", value: `%${value}%` },
+            { field: "notes", operator: "ilike", value: `%${value}%` },
+          ],
+        }
+      : null,
+  ),
+  clientId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "clientId", operator: "in", value } : null,
+  ),
+  status: arrayFilter(enumFilter(salesOrderStatusEnum.enumValues)).build((value) =>
+    value?.length ? { field: "status", operator: "in", value } : null,
+  ),
+  associatedId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "associationId", operator: "in", value } : null,
+  ),
+  assignmentId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "assignmentId", operator: "in", value } : null,
+  ),
+  isDeleted: booleanFilter.build((value) => ({
+    field: "isDeleted",
+    operator: "eq",
+    value: value ?? false,
+  })),
+});
+
+export const salesOrdersEmailsFilters = defineFilters({
+  search: stringFilter.build((value) =>
+    value
+      ? {
+          or: [
+            { field: "subject", operator: "ilike", value: `%${value}%` },
+            { field: "body", operator: "ilike", value: `%${value}%` },
+            { field: "to", operator: "ilike", value: `%${value}%` },
+            { field: "cc", operator: "ilike", value: `%${value}%` },
+            { field: "bcc", operator: "ilike", value: `%${value}%` },
+          ],
+        }
+      : null,
+  ),
+  salesOrderId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "salesOrderId", operator: "in", value } : null,
+  ),
+});
+
+/**
+ * Validators
+ */
+export const salesOrdersFiltersSchema = resolveFiltersSchema(salesOrdersFilters);
+export type SalesOrdersFilters = z.input<typeof salesOrdersFiltersSchema>;
+
+export const salesOrdersEmailsFiltersSchema = resolveFiltersSchema(salesOrdersEmailsFilters);
+export type SalesOrdersEmailsFiltersSchemaFiltersSchema = z.input<
+  typeof salesOrdersEmailsFiltersSchema
+>;
+
+/**
+ * Parser and compilers
+ */
+export const salesOrderFiltersParser = createFilteringParser(salesOrdersFilters);
+export const salesOrderDatabaseFiltersCompiler = createDatabaseFiltersCompiler(salesOrdersFilters);
+export const salesOrderEmailFiltersParser = createFilteringParser(salesOrdersEmailsFilters);
+export const salesOrderEmailDatabaseFiltersCompiler =
+  createDatabaseFiltersCompiler(salesOrdersEmailsFilters);

package/dist/templates/spark/src/app/admin/sales-orders/_config/ratio-type.tsx

@@ -0,0 +1,47 @@
+import type { ConfigWithIcon } from "@tulip-systems/core";
+import { createStatusVariants, StatusBadge, StatusField } from "@tulip-systems/ui/status";
+import { cva } from "class-variance-authority";
+import { HashIcon, PercentIcon } from "lucide-react";
+import type { SalesOrderRatioType } from "../_lib/validators";
+
+/**
+ * Ratio type
+ */
+export const salesOrderRatioTypeConfig: ConfigWithIcon<SalesOrderRatioType>[] = [
+  {
+    value: "fixed",
+    label: "Vast",
+    icon: HashIcon,
+    className: "",
+  },
+  {
+    value: "percentage",
+    label: "Percentage",
+    icon: PercentIcon,
+    className: "",
+  },
+];
+
+export const salesOrderRatioTypeVariants = cva("", {
+  variants: { status: createStatusVariants(salesOrderRatioTypeConfig) },
+});
+
+export function SalesOrderRatioTypeField(props: { ratioType: SalesOrderRatioType }) {
+  return (
+    <StatusField
+      config={salesOrderRatioTypeConfig}
+      variants={salesOrderRatioTypeVariants}
+      status={props.ratioType}
+    />
+  );
+}
+
+export function SalesOrderRatioTypeBadge(props: { ratioType: SalesOrderRatioType }) {
+  return (
+    <StatusBadge
+      config={salesOrderRatioTypeConfig}
+      variants={salesOrderRatioTypeVariants}
+      status={props.ratioType}
+    />
+  );
+}

package/dist/templates/spark/src/app/admin/sales-orders/_config/sorting.ts

@@ -0,0 +1,31 @@
+import {
+  createSortingParser,
+  defineSorting,
+  resolveSortingSchema,
+  sortOption,
+} from "@tulip-systems/query";
+import { createDatabaseSortingCompiler } from "@tulip-systems/query/drizzle";
+import { createLocalSortingCompiler } from "@tulip-systems/query/tanstack-db";
+
+export const salesOrderTableSorts = defineSorting({
+  number: sortOption((direction) => ({ field: "number", direction })),
+  title: sortOption((direction) => ({ field: "title", direction })),
+  createdAt: sortOption((direction) => ({ field: "createdAt", direction })),
+  status: sortOption((direction) => ({ field: "status", direction })),
+});
+
+/**
+ * Validators
+ */
+export const salesOrderTableSortsSchema = resolveSortingSchema(salesOrderTableSorts);
+
+/**
+ * Parsers
+ */
+export const salesOrderTableSortsParser = createSortingParser(salesOrderTableSorts, {
+  fallback: [{ key: "number", direction: "desc" }],
+});
+
+export const salesOrderTableLocalSortsCompiler = createLocalSortingCompiler(salesOrderTableSorts);
+export const salesOrderTableDatabaseSortsCompiler =
+  createDatabaseSortingCompiler(salesOrderTableSorts);

package/dist/templates/spark/src/app/admin/sales-orders/_config/status.tsx

@@ -0,0 +1,53 @@
+import type { ConfigWithIcon } from "@tulip-systems/core";
+import { createStatusVariants, StatusBadge, StatusField } from "@tulip-systems/ui/status";
+import { cva } from "class-variance-authority";
+import { BadgeEuroIcon, PencilRuler, SendHorizonalIcon } from "lucide-react";
+import type { SalesOrderStatus } from "../_lib/validators";
+
+/**
+ * Status
+ */
+export const salesOrderStatusConfig: ConfigWithIcon<SalesOrderStatus>[] = [
+  {
+    value: "draft",
+    label: "Concept",
+    icon: PencilRuler,
+    className: "stroke-foreground/50 text-foreground/50",
+  },
+  {
+    value: "sent",
+    label: "Verzonden",
+    icon: SendHorizonalIcon,
+    className: "stroke-yellow-500 text-yellow-500",
+  },
+  {
+    value: "invoiced",
+    label: "Gefactureerd",
+    icon: BadgeEuroIcon,
+    className: "stroke-green-500 text-green-500",
+  },
+];
+
+export const salesOrderStatusVariants = cva("", {
+  variants: { status: createStatusVariants(salesOrderStatusConfig) },
+});
+
+export function SalesOrderStatusField(props: { status: SalesOrderStatus }) {
+  return (
+    <StatusField
+      config={salesOrderStatusConfig}
+      variants={salesOrderStatusVariants}
+      status={props.status}
+    />
+  );
+}
+
+export function SalesOrderStatusBadge(props: { status: SalesOrderStatus }) {
+  return (
+    <StatusBadge
+      config={salesOrderStatusConfig}
+      variants={salesOrderStatusVariants}
+      status={props.status}
+    />
+  );
+}

package/dist/templates/spark/src/app/admin/sales-orders/_lib/constants.ts

@@ -0,0 +1,103 @@
+/**
+ * Quotation email default body
+ */
+export const salesOrderEmailDefaultBody = {
+  type: "doc",
+  content: [
+    {
+      type: "paragraph",
+      content: [
+        {
+          type: "text",
+          text: "Beste klant,",
+        },
+      ],
+    },
+    {
+      type: "paragraph",
+    },
+    {
+      type: "paragraph",
+      content: [
+        {
+          type: "text",
+          text: "In bijlage sturen we onze verkoopbon ter nazicht. ",
+        },
+      ],
+    },
+    {
+      type: "paragraph",
+      content: [
+        {
+          type: "text",
+          text: "Aarzel niet om ons te contacteren indien er vragen of opmerkingen zijn.",
+        },
+      ],
+    },
+    {
+      type: "paragraph",
+    },
+    {
+      type: "paragraph",
+      content: [
+        {
+          text: "Met vriendelijke groeten,",
+          type: "text",
+        },
+        {
+          type: "hardBreak",
+        },
+        {
+          text: "Murat Bayraktar",
+          type: "text",
+        },
+        {
+          type: "hardBreak",
+        },
+        {
+          text: "Sales Manager",
+          type: "text",
+        },
+      ],
+    },
+    {
+      type: "paragraph",
+      content: [
+        {
+          text: "-----------------------",
+          type: "text",
+        },
+      ],
+    },
+    {
+      type: "paragraph",
+      content: [
+        {
+          text: "Bay-tec BVBA",
+          type: "text",
+        },
+        {
+          type: "hardBreak",
+        },
+        {
+          text: "Bremstraat 34",
+          type: "text",
+        },
+        {
+          type: "hardBreak",
+        },
+        {
+          text: "3580 Beringen",
+          type: "text",
+        },
+        {
+          type: "hardBreak",
+        },
+        {
+          text: "BE0648821617",
+          type: "text",
+        },
+      ],
+    },
+  ],
+};

package/dist/templates/spark/src/app/admin/sales-orders/_lib/helpers.server.tsx

@@ -0,0 +1,123 @@
+import "server-cli-only";
+
+import { format } from "date-fns";
+import Decimal from "decimal.js";
+import { and, asc, desc, eq, inArray, like, notInArray, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { generatePDFDocument } from "@/components/pdf/helpers.server";
+import { generateSequentialNumber } from "@/lib/helpers/sequential-number";
+import { salesOrderExecutions } from "@/server/db/schema";
+import type { DatabaseSchema } from "@/server/db/types";
+import { salesOrderItems } from "../../sales-order-items/_lib/schema";
+import type { SalesOrderItem } from "../../sales-order-items/_lib/validators";
+import { SalesOrderPdf, type SalesOrderPdfProps } from "../_components/pdf-document";
+import { salesOrders } from "./schema";
+
+/**
+ * Generate a random order number
+ * @returns {Promise<string>}
+ */
+export async function generateSalesOrderNumber(context: {
+  db: NodePgDatabase<DatabaseSchema>;
+}): Promise<string> {
+  const year = format(new Date(), "yyyy");
+  const prefix = `VB-${year}`;
+
+  const [lastSalesOrder] = await context.db
+    .select({ number: salesOrders.number })
+    .from(salesOrders)
+    .where(like(salesOrders.number, `${prefix}%`))
+    .limit(1)
+    .orderBy(desc(salesOrders.number));
+
+  const lastDigit = lastSalesOrder?.number?.split("-")?.[2];
+
+  const lastNumber = lastDigit ? Number(lastDigit) : 80;
+  return generateSequentialNumber({ lastNumber, prefix });
+}
+
+/**
+ * Generate a PDF document for a quotation
+ * @param {SalesOrderPdfProps["data"]} data
+ * @returns {Promise<Buffer>}
+ */
+export function generateSalesOrderDocument(data: SalesOrderPdfProps["data"]) {
+  return generatePDFDocument(<SalesOrderPdf data={data} />);
+}
+
+/**
+ * Get sales order PDF data
+ */
+export async function getSalesOrderPDFData(
+  context: { db: NodePgDatabase<DatabaseSchema> },
+  input: { id: string },
+) {
+  const data = await context.db.query.salesOrders.findFirst({
+    where: eq(salesOrders.id, input.id),
+    with: {
+      items: { orderBy: asc(salesOrderItems.index) },
+      executions: { orderBy: asc(salesOrderExecutions.index), with: { execution: true } },
+      client: {
+        with: {
+          companyDetails: true,
+          clientsAddresses: { with: { address: true } },
+          clientsContacts: { with: { contact: true } },
+        },
+      },
+    },
+  });
+
+  if (!data) return null;
+
+  /*
+   * Get associated ids
+   */
+  const ids = Array.from(new Set(data.items.map((item) => item.id)));
+  const associatedId = Array.from(new Set(data.items.map((item) => item.associationId)));
+
+  /*
+   * Get associated items
+   */
+  const associated = await context.db
+    .select({
+      associationId: salesOrderItems.associationId,
+      items: sql<SalesOrderItem[]>`json_agg(${salesOrderItems})`.as("items"),
+      previousRatio: sql<string>`sum(${salesOrderItems.ratio})`.as("previousRatio"),
+      remainingRatio:
+        sql<string>`max(${salesOrderItems.maxRatio}) - sum(${salesOrderItems.ratio})`.as(
+          "remainingRatio",
+        ),
+    })
+    .from(salesOrderItems)
+    .where(
+      and(
+        notInArray(salesOrderItems.id, ids),
+        inArray(salesOrderItems.associationId, associatedId),
+      ),
+    )
+    .groupBy(salesOrderItems.associationId);
+
+  /*
+   * Add associated items to data
+   */
+  const items = data.items.map((item) => {
+    const group = associated.find((a) => a.associationId === item.associationId);
+
+    return {
+      ...item,
+      previousRatio: group?.previousRatio,
+      remainingRatio:
+        group?.remainingRatio != null
+          ? Decimal(group.remainingRatio)
+              .sub(item.ratio ?? 0)
+              .toFixed(3)
+          : null,
+      associated: group?.items ?? [],
+    };
+  });
+
+  /**
+   * Return data
+   */
+  return { ...data, items };
+}