update cuz presentation

server/api/orders/[id].delete.ts

@@ -0,0 +1,17 @@
+/* global defineEventHandler, createError */
+import { ResultSetHeader } from "mysql2";
+
+import { database } from "~/server/utils/database";
+
+export default defineEventHandler(async (e) => {
+  const id = e.context.params?.id;
+
+  const [result] = await database.query(
+    "DELETE FROM `orders` WHERE `id` = ?",
+    [id],
+  ) as unknown as [ResultSetHeader];
+
+  if (result.affectedRows === 0) throw createError({ statusCode: 404 });
+
+  return null;
+});

server/api/orders/[id].get.ts

@@ -0,0 +1,108 @@
+/* global defineEventHandler, createError */
+
+import { offer as offerType, order } from "~/utils/types/database";
+import { database, data } from "~/server/utils/database";
+
+export async function orderExists(id: string) {
+  const [[exists]] = await database.query(
+    "SELECT EXISTS(*) AS `exists` FROM `orders` WHERE `id` = ?",
+    [id],
+  ) as data<{exists: 0 | 1}>;
+
+  return exists.exists === 1;
+}
+
+export async function getImportedProducts(id: string) {
+  const [importedProducts] = await database.query(
+    ["SELECT",
+      "CONVERT(`id`, CHAR) AS `id`,",
+      "`name`,",
+      "`link`,",
+      "`price`,",
+      "`price_imported`",
+      "FROM `imported_products`",
+      "WHERE `order` = ?",
+    ].join(" "),
+    [id],
+  ) as data<{
+    id: string,
+    name: string | null,
+    link: string,
+    price: string,
+    price_imported: string
+  }>;
+
+  return importedProducts;
+}
+
+export async function getWork(id: string) {
+  const [work] = await database.query(
+    ["SELECT",
+      "CONVERT(`id`, CHAR) AS `id`,",
+      "CONVERT(`offer`, CHAR) AS `offer`,",
+      "`price`,",
+      "`notes`,",
+      "`is_fulfilled`",
+      "FROM `work`",
+      "WHERE `order` = ?",
+    ].join(" "),
+    [id],
+  ) as data<{
+    id: string,
+    offer: offerType,
+    price: number,
+    notes: string | null,
+    is_fulfilled: 0 | 1,
+  }>;
+
+  const [offer] = await database.query(
+    ["SELECT",
+      "CONVERT(`offer`.`id`, CHAR) AS `id`,",
+      "`offer`.`name`,",
+      "`offer`.`description`,",
+      "`offer`.`recommended_price`",
+      "FROM",
+      "`work`",
+      "LEFT JOIN `offer` ON `work`.`offer` = `offer`.`id`",
+      "WHERE `work`.`order` = ?",
+    ].join(" "),
+    [id],
+  ) as data<offerType>;
+
+  // @ts-ignore i.offer is string, but it needs to be an offer object
+  for (const i of work) i.offer = offer.find(e => e.id === i.offer) as offerType;
+  return work;
+}
+
+export async function getOrder(id: string): Promise<order> {
+  const [[order]] = await database.query(
+    ["SELECT",
+      "CONVERT(`id`, CHAR) AS `id`,",
+      "CONVERT(`client`, CHAR) AS `client`,",
+      "CONVERT(`user`, CHAR) AS `user`, ",
+      "`is_draft`,",
+      "`value`",
+      "FROM `orderSummaries`",
+      "WHERE `id` = ?",
+    ].join(" "),
+    [id],
+  ) as data<{
+    id: string,
+    client: string,
+    user: string,
+    is_draft: 0 | 1,
+    value: number,
+  }>;
+
+  if (!order) throw createError({ statusCode: 404 });
+
+  const importedProducts = await getImportedProducts(id);
+  const work = await getWork(id);
+
+  return { ...order, imported_products: importedProducts, work };
+}
+
+export default defineEventHandler((e) => {
+  const key = e.context.params?.id;
+  return getOrder(key as string);
+});

server/api/orders/[id].patch.ts

@@ -0,0 +1,17 @@
+/* global defineEventHandler, readBody, createError */
+
+import { checkIsOrder } from "../orders.post";
+import { database as db } from "~/server/utils/database";
+
+export default defineEventHandler(async (e) => {
+  const body = await readBody(e);
+  const id = e.context.params?.id;
+
+  if (!checkIsOrder(e, true)) throw createError({ message: "Invalid body", statusCode: 400 });
+
+  const database = await db.new();
+  await database.beginTransaction();
+
+  for (const [k, v] of Object.entries(body))
+    database.query(`UPDATE TABLE \`orders\` SET \`${k}\` = ? WHERE \`id\` = ?`, [v, id]);
+});

server/api/orders/[id]/imported_products.get.ts

@@ -0,0 +1,12 @@
+/* global defineEventHandler, createError */
+
+import { orderExists, getImportedProducts } from "../[id].get";
+
+export default defineEventHandler(async (e) => {
+  const id = e.context.params?.id as string;
+
+  if (!orderExists(id)) throw createError({ statusCode: 404 });
+
+  const importedProducts = await getImportedProducts(id);
+  return importedProducts;
+});

server/api/orders/[id]/imported_products.post.ts

@@ -0,0 +1,27 @@
+/* global defineEventHandler, readBody, createError, setResponseStatus */
+
+import { checkIsImportedProduct } from "../../orders.post";
+import { getImportedProducts, orderExists } from "../[id].get";
+import Snowflake from "~/utils/snowflake";
+import { database } from "~/server/utils/database";
+
+export default defineEventHandler(async (e) => {
+  const body = await readBody(e);
+  const idOrder = e.context.params?.id as string;
+  const idImportedProducts = new Snowflake().toString();
+
+  if (!orderExists(idOrder)) throw createError({ statusCode: 404 });
+  if (!checkIsImportedProduct(body, false)) throw createError({ message: "Invalid body", statusCode: 400 });
+
+  await database.query(
+    ["INSERT INTO",
+      "`imported_products`",
+      "VALUES",
+      "(?, ?, ?, ?, ?, ?)",
+    ].join(" "),
+    [idImportedProducts, idOrder, body.name, body.link, body.price_imported, body.price],
+  );
+
+  setResponseStatus(e, 201);
+  return getImportedProducts(idOrder);
+});

server/api/orders/[id]/work.get.ts

@@ -0,0 +1,12 @@
+/* global defineEventHandler, createError */
+
+import { orderExists, getWork } from "../[id].get";
+
+export default defineEventHandler(async (e) => {
+  const id = e.context.params?.id as string;
+
+  if (!orderExists(id)) throw createError({ statusCode: 404 });
+
+  const work = await getWork(id);
+  return work;
+});

server/api/orders/[id]/work.post.ts

@@ -0,0 +1,28 @@
+/* global defineEventHandler, readBody, createError, setResponseStatus */
+
+import { checkIsWork } from "../../orders.post";
+import { getWork, orderExists } from "../[id].get";
+import Snowflake from "~/utils/snowflake";
+import { database } from "~/server/utils/database";
+
+export default defineEventHandler(async (e) => {
+  const body = await readBody(e);
+  const idOrder = e.context.params?.id as string;
+  const idWork = new Snowflake().toString();
+
+  if (!orderExists(idOrder)) throw createError({ statusCode: 404 });
+  if (!checkIsWork(body, false)) throw createError({ message: "Invalid body", statusCode: 400 });
+
+  await database.query(
+    ["INSERT INTO",
+      "`work`",
+      "VALUES",
+      "(?, ?, ?, ?, ?, ?)",
+    ].join(" "),
+    [idWork, idOrder, body.offer, body.price, body.notes, body.is_fulfilled],
+  );
+
+  setResponseStatus(e, 201);
+
+  return getWork(idWork);
+});

server/api/orders/[id]/work/[idWork].delete.ts

@@ -0,0 +1,20 @@
+/* global defineEventHandler, createError */
+
+import { ResultSetHeader } from "mysql2";
+import { orderExists } from "../../[id].get";
+import { database } from "~/server/utils/database";
+
+export default defineEventHandler(async (e) => {
+  const idOrder = e.context.params?.id as string;
+  const idWork = e.context.params?.idWork as string;
+
+  if (!orderExists(idOrder)) throw createError({ statusCode: 404 });
+
+  const [response] = await database.query(
+    "DELETE FROM `work` WHERE `id` = ?",
+    [idWork],
+  ) as unknown as [ResultSetHeader];
+
+  if (response.affectedRows === 0) throw createError({ statusCode: 404 });
+  return null;
+});

server/api/orders/[id]/work/[idWork].get.ts

@@ -0,0 +1,11 @@
+/* global defineEventHandler, createError */
+
+import { orderExists, getWork } from "../../[id].get";
+
+export default defineEventHandler((e) => {
+  const idOrder = e.context.params?.id as string;
+  const idWork = e.context.params?.idWork as string;
+
+  if (!orderExists(idOrder)) throw createError({ statusCode: 404 });
+  return getWork(idWork);
+});