[GPJ-30] Adiciona pontos de api para processos

ProcessosBack/knex/querries/processes.ts

@@ -0,0 +1,85 @@
+import { Process } from "../../../common/process";
+import { db } from "../config/database";
+
+const getRandomJudgeId = async (): Promise<number | null> => {
+  try {
+    const query = await db("users").select("id").where({ role: "juiz" });
+    if (!query.length)
+      throw Error("Não foi possível encontrar um juiz para o processo");
+
+    const randomIndex = Math.floor(Math.random() * query.length);
+    return query[randomIndex].id;
+  } catch (err: any) {
+    console.log(err.message);
+  }
+
+  return null;
+};
+
+export const createProcess = async (process: any): Promise<number | null> => {
+  try {
+    const judgeId = (await getRandomJudgeId()) as any;
+    process.judgeId = judgeId;
+
+    const query = await db("processes").insert(process);
+    return query[0];
+  } catch (err: any) {
+    console.log(err.message);
+  }
+  return null;
+};
+
+export const getAllProcess = async (): Promise<Process[] | null> => {
+  try {
+    const query = await db("processes");
+    return query;
+  } catch (err: any) {
+    console.log(err.message);
+  }
+  return null;
+};
+
+export const deleteProcess = async (id: number): Promise<number | null> => {
+  try {
+    const query = await db("processes").where({ id: id }).del();
+    return query;
+  } catch (err: any) {
+    console.log(err.message);
+  }
+
+  return null;
+};
+
+export const getProcessesByLaywerId = async (
+  lawyerId: number
+): Promise<Process[] | null> => {
+  try {
+    const query = await db("processes").where({ lawyerId: lawyerId }).select();
+    return query.length ? query : null;
+  } catch (err: any) {
+    console.log(err.message);
+  }
+  return null;
+};
+
+export const getProcessesByJudgeId = async (
+  judgeId: number
+): Promise<Process[] | null> => {
+  try {
+    const query = await db("processes").where({ judgeId: judgeId }).select();
+    return query.length ? query : null;
+  } catch (err: any) {
+    console.log(err.message);
+  }
+  return null;
+};
+
+export const getProcessById = async (id: number): Promise<Process | null> => {
+  try {
+    const query = await db("processes").where({ id: id }).select();
+    return query.length ? query[0] : null;
+  } catch (err: any) {
+    console.log(err.message);
+  }
+  return null;
+};

ProcessosBack/server.ts

@@ -8,6 +8,15 @@ import {
 } from "./knex/querries/users";
 import { db } from "./knex/config/database";
 import { User } from "../common/user";
+import {
+  createProcess,
+  deleteProcess,
+  getAllProcess as getAllProcesses,
+  getProcessById,
+  getProcessesByJudgeId,
+  getProcessesByLaywerId,
+} from "./knex/querries/processes";
+import { Process } from "../common/process";
 
 const express = require("express");
 const bodyParser = require("body-parser");
@@ -49,7 +58,7 @@ app.get("/api/usuarios", async (req: Request, res: Response) => {
   }
 });
 
-app.delete("/api/apagar", async (req: Request, res: Response) => {
+app.delete("/api/apagar-usuario", async (req: Request, res: Response) => {
   const cpf: string = req.body.cpf;
   const success = await deleteUser(cpf);
 
@@ -75,6 +84,83 @@ app.get("/api/auth", async (req: Request, res: Response) => {
   }
 });
 
+app.post("/api/abrir-processo", async (req: Request, res: Response) => {
+  var process = req.body;
+  const processId = await createProcess(process);
+
+  if (processId) {
+    process = await getProcessById(processId);
+    console.log(
+      `[SERVIDOR] Processo ${process.name} foi registrado com id ${processId}`
+    );
+    res.send({ success: process });
+  } else {
+    res.send({ failure: "Processo não pode ser aberto" });
+  }
+});
+
+app.delete("/api/apagar-processo", async (req: Request, res: Response) => {
+  const id: number = req.body.id;
+  const success = await deleteProcess(id);
+
+  if (success) {
+    console.log(`[SERVIDOR] Processo id ${id} foi deletado da base de dados`);
+    res.send({ success: `Processo id ${id} deletado com sucesso` });
+  } else {
+    res.send({ failure: `Não pode deletar processo id: ${id}` });
+  }
+});
+
+app.get("/api/processos", async (req: Request, res: Response) => {
+  const lawyerId = req.query.lawyerId as string;
+  const judgeId = req.query.judgeId as string;
+
+  let processes: Process[] | null = null;
+
+  console.log(lawyerId, judgeId);
+
+  if (!lawyerId && !judgeId) {
+    processes = await getAllProcesses();
+    console.log(`[SERVIDOR] Buscando ${processes?.length} processos`);
+  } else if (lawyerId !== "") {
+    processes = await getProcessesByLaywerId(parseInt(lawyerId));
+    console.log(
+      `[SERVIDOR] Buscando ${processes?.length} processos de advogado id ${lawyerId}`
+    );
+  } else if (judgeId !== "") {
+    processes = await getProcessesByJudgeId(parseInt(judgeId));
+    console.log(
+      `[SERVIDOR] Buscando ${processes?.length} processos de juiz id ${judgeId}`
+    );
+  }
+
+  if (processes) {
+    res.send({ success: processes });
+  } else {
+    res.send({ failure: "Não pode buscar processos" });
+  }
+});
+
+app.get("/api/processo", async (req: Request, res: Response) => {
+  const id = req.query.id as string;
+
+  if (!id) {
+    res.send({
+      failure: "Por favor, ofereça uma forma de identificar o processo",
+    });
+    return;
+  }
+
+  const process = await getProcessById(parseInt(id));
+
+  if (process) {
+    console.log(`[SERVIDOR] Buscando processos ${id}`);
+    res.send({ success: process });
+  } else {
+    res.send({ failure: `Não pode encontrar processos com id ${id}` });
+  }
+});
+
 var server = app.listen(3000, async () => {
   console.log("[SERVIDOR] Servidor aberto na porta 3000");
   console.log("[SERVIDOR] Servidor conectado à base de dados");