Added basic implementation of media

src/Controllers/discipline.controller.ts

@@ -187,3 +187,61 @@ export const deleteDiscipline = async (req: Request<DeleteDisciplineQueryParams>
     throw e;
   }
 };
+
+interface visualParams {
+  disciplinePid: string;
+}
+
+interface visualBody {
+  mediaPid: string;
+}
+
+export const addVisual = async (req: Request<visualParams, {}, visualBody>, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { disciplinePid } = req.params;
+  
+  const discipline = await prisma.discipline.update({
+    where: { pid: disciplinePid },
+    data: {
+      visual: { connect: { pid: req.body.mediaPid } }
+    }
+  });
+
+  if (!discipline) {
+    throw new NotFoundError("discipline", disciplinePid);
+  }
+
+  return res.status(200).json({
+    type: "success",
+    payload: { discipline }
+  })
+};
+
+export const deleteVisual = async (req: Request<visualParams, {}, visualBody>, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { disciplinePid } = req.params;
+
+  try {
+    await prisma.discipline.update({ 
+      where: { 
+        pid: disciplinePid,
+       },
+      data: { 
+        visual: { disconnect: { pid: req.body.mediaPid } }
+       }
+    });
+    return res.status(204).end();
+  } catch (e) {
+    if (e instanceof PrismaClientKnownRequestError && e.code === "P2025") {
+      throw new NotFoundError("discipline", disciplinePid);
+    }
+
+    throw e;
+  }
+};

src/Controllers/event.controller.ts

@@ -2,13 +2,15 @@ import { Prisma } from "@prisma/client";
 import { PrismaClientKnownRequestError } from "@prisma/client/runtime";
 import { Request, Response } from "express";
 import prisma from "../lib/prisma";
+import NotFoundError from "../Middleware/error/NotFoundError";
 import { createInsufficientPermissionsError, DataType, generateError, generateInvalidBodyError } from "./common";
 
 export const getAllEvents = async (req: Request, res: Response) => {
   const events = await prisma.event.findMany({
     select: {
       name: true,
-      description: true,
+      briefDescription: true,
+      fullDescription: true,
       date: true,
       pid: true,
       id: false,
@@ -41,7 +43,8 @@ export const getEvent = async (req: Request, res: Response) => {
       },
       select: {
         name: true,
-        description: true,
+        briefDescription: true,
+        fullDescription: true,
         date: true,
         pid: true,
         id: false,
@@ -102,14 +105,14 @@ export const addEvent = async (req: Request, res: Response) => {
     data: {
       name: req.body.name,
       date: req.body.date,
-      description: req.body.description,
+      briefDescription: req.body.description,
     },
     select: {
       name: true,
       date: true,
       pid: true,
       id: false,
-      description: true,
+      briefDescription: true,
     },
   });
 
@@ -145,3 +148,61 @@ export const deleteEvent = (req: Request<DeleteEventQueryParams>, res: Response)
     throw e;
   }
 };
+
+interface visualParams {
+  eventPid: string;
+}
+
+interface visualBody {
+  mediaPid: string;
+}
+
+export const addVisual = async (req: Request<visualParams, {}, visualBody>, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { eventPid } = req.params;
+  
+  const event = await prisma.event.update({
+    where: { pid: eventPid },
+    data: {
+      visual: { connect: { pid: req.body.mediaPid } }
+    }
+  });
+
+  if (!event) {
+    throw new NotFoundError("event", eventPid);
+  }
+
+  return res.status(200).json({
+    type: "success",
+    payload: { event }
+  })
+};
+
+export const deleteVisual = async (req: Request<visualParams, {}, visualBody>, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { eventPid } = req.params;
+
+  try {
+    await prisma.event.update({ 
+      where: { 
+        pid: eventPid,
+       },
+      data: { 
+        visual: { disconnect: { pid: req.body.mediaPid } }
+       }
+    });
+    return res.status(204).end();
+  } catch (e) {
+    if (e instanceof PrismaClientKnownRequestError && e.code === "P2025") {
+      throw new NotFoundError("discipline", eventPid);
+    }
+
+    throw e;
+  }
+};

src/Controllers/media.controller.ts

@@ -1,8 +1,16 @@
-import { Request, Response } from "express";
+import { Request, response, Response } from "express";
 import fs from "fs";
 import isSvg from "is-svg";
 import { fromBuffer as fileTypeFromBuffer } from "file-type";
 import { AUTH_ERROR, createError, createInsufficientPermissionsError } from "./common";
+import { Prisma } from "@prisma/client";
+import prisma from "../lib/prisma";
+import NotFoundError from "../Middleware/error/NotFoundError";
+import { PrismaClientKnownRequestError } from "@prisma/client/runtime";
+import { generateInvalidBodyError, DataType,  } from "./common";
+import { type } from "os";
+import {unlink} from "fs/promises"
+
 
 function createMediaLinks(fileName: string) {
   return [{ rel: "self", type: "GET", href: `/api/media/${fileName}` }];
@@ -31,6 +39,14 @@ export const uploadImage = async (req: Request, res: Response) => {
     });
   }
 
+  if ( typeof req.body.description !== "string") {
+    return res.status(400).json(
+      generateInvalidBodyError({
+        description: DataType.STRING
+      })
+    );
+  }
+
   const file = req.files.file;
 
   if (Array.isArray(file)) {
@@ -69,11 +85,80 @@ export const uploadImage = async (req: Request, res: Response) => {
 
   file.mv("media/" + fileName, console.error);
 
+  //generate record
+  const media = await prisma.media.create({
+    data: {
+      pid: fileName,
+      description: req.body.description,
+    },
+    select: {
+      pid: true,
+      description: true,
+    }
+  })
+
   return res.status(201).json({
     type: "success",
+    payload: { media }
+  })
+};
+
+export const getAllMedia = async (req: Request, res: Response) => {
+  const medias = await prisma.media.findMany({
+    select: {
+      description: true,
+      events: true,
+      disciplines: true,
+      roles: true,
+      pid: true,
+      id: false,
+    },
+  });
+
+  res.status(200).json({
+    type: "success",
     payload: {
-      message: "The file was uploaded and created on the server",
+      medias,
     },
-    _links: createMediaLinks(fileName),
   });
 };
+
+interface CreateMediaBody {
+  description?: string;
+  location?: string;
+
+  events?: string[];
+  disciplines?: string[];
+  roles?: string[];
+}
+
+interface MediaParams {
+  eventPid?: string;
+  disciplinePid?: string;
+  rolePid?: string;
+}
+
+export const deleteMedia = async (req: Request, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { pid } = req.params;
+
+  const location = "media/" + pid;
+
+  if (fs.existsSync(location)) {
+    await unlink(location);
+  }
+
+  try {
+    await prisma.discipline.delete({ where: { pid }});
+    return res.status(204).end();
+  } catch (e) {
+    if (e instanceof PrismaClientKnownRequestError && e.code === "P2025") {
+      throw new NotFoundError("discipline", pid);
+    }
+
+    throw e;
+  }
+};

src/Controllers/role_schema.controller.ts

@@ -123,3 +123,61 @@ export const createRoleSchema = async (
     throw e;
   }
 };
+
+interface visualParams {
+  schemaPid: string;
+}
+
+interface visualBody {
+  mediaPid: string;
+}
+
+export const addVisual = async (req: Request<visualParams, {}, visualBody>, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { schemaPid } = req.params;
+  
+  const schema = await prisma.roleSchema.update({
+    where: { pid: schemaPid },
+    data: {
+      visual: { connect: { pid: req.body.mediaPid } }
+    }
+  });
+
+  if (!schema) {
+    throw new NotFoundError("role_schema", schemaPid);
+  }
+
+  return res.status(200).json({
+    type: "success",
+    payload: { schema }
+  })
+};
+
+export const deleteVisual = async (req: Request<visualParams, {}, visualBody>, res: Response) => {
+  if (req.auth?.permission_level != "ELEVATED"){
+    res.status(403).json(createInsufficientPermissionsError());
+  }
+
+  const { schemaPid } = req.params;
+
+  try {
+    await prisma.roleSchema.update({ 
+      where: { 
+        pid: schemaPid,
+       },
+      data: { 
+        visual: { disconnect: { pid: req.body.mediaPid } }
+       }
+    });
+    return res.status(204).end();
+  } catch (e) {
+    if (e instanceof PrismaClientKnownRequestError && e.code === "P2025") {
+      throw new NotFoundError("role_schema", schemaPid);
+    }
+
+    throw e;
+  }
+};