feat: add office membership control on services (#48)

solve this ticket:
https://app.ora.pm/p/fb56ed95daa7456b888d266a050b9afa?v=86662&s=29352&t=k&c=54838982e3184e9da6c457f7e37b5dd5

- add office membership control on deed, deed types, documents, document
types, files, folders, office roles and users

src/app/api/idnot/UserController.ts

@@ -24,13 +24,13 @@ export default class UserController extends ApiController {
 		try {
 			const code = req.params["code"];
 			if (!code) throw new Error("code is required");
-			const token = await fetch('https://qual-connexion.idnot.fr/IdPOAuth2/token/idnot_idp_v1', {method: 'POST'});
+			const token = await fetch("https://qual-connexion.idnot.fr/IdPOAuth2/token/idnot_idp_v1", { method: "POST" });
 			console.log(token);
 			//const user = await this.authService.getUserFromIdNotTokens(code!);
 			//success
 			this.httpSuccess(response);
 		} catch (error) {
-			console.log(error)
+			console.log(error);
 			this.httpInternalError(response);
 			return;
 		}

src/app/api/super-admin/DeedTypesController.ts

@@ -3,11 +3,12 @@ import { Controller, Get, Post, Put } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import { Service } from "typedi";
 import DeedTypesService from "@Services/super-admin/DeedTypesService/DeedTypesService";
-import { DeedTypes } from "@prisma/client";
+import { DeedTypes, Prisma } from "@prisma/client";
 import { DeedType } from "le-coffre-resources/dist/SuperAdmin";
 import { validateOrReject } from "class-validator";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import deedTypeHandler from "@App/middlewares/OfficeMembershipHandlers/DeedTypeHandler";
 
 @Controller()
 @Service()
@@ -25,6 +26,10 @@ export default class DeedTypesController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.DeedTypesWhereInput = { office: { uid: officeId } };
+			query.where = officeWhereInput;
+
 			//call service to get prisma entity
 			const deedTypeEntities: DeedTypes[] = await this.deedTypesService.get(query);
 
@@ -43,7 +48,7 @@ export default class DeedTypesController extends ApiController {
 	 * @description Create a new deedtype
 	 * @returns Deedtype created
 	 */
-	@Post("/api/v1/super-admin/deed-types", [authHandler,ruleHandler])
+	@Post("/api/v1/super-admin/deed-types", [authHandler, ruleHandler, deedTypeHandler])
 	protected async post(req: Request, response: Response) {
 		try {
 			//init DeedType resource with request body values
@@ -72,7 +77,7 @@ export default class DeedTypesController extends ApiController {
 	 * @description Modify a specific deedtype by uid
 	 * @returns Deedtype modified
 	 */
-	@Put("/api/v1/super-admin/deed-types/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/deed-types/:uid", [authHandler, ruleHandler, deedTypeHandler])
 	protected async put(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -114,7 +119,7 @@ export default class DeedTypesController extends ApiController {
 	 * @description Get a specific deedtype by uid
 	 * @returns IDeedtype
 	 */
-	@Get("/api/v1/super-admin/deed-types/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/deed-types/:uid", [authHandler, ruleHandler, deedTypeHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/super-admin/DeedsController.ts

@@ -3,11 +3,12 @@ import { Controller, Get, Put } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import DeedsService from "@Services/super-admin/DeedsService/DeedsService";
 import { Service } from "typedi";
-import { Deeds } from "@prisma/client";
+import { Deeds, Prisma } from "@prisma/client";
 import { Deed } from "le-coffre-resources/dist/SuperAdmin";
 import { validateOrReject } from "class-validator";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import deedHandler from "@App/middlewares/OfficeMembershipHandlers/DeedHandler";
 
 @Controller()
 @Service()
@@ -25,6 +26,10 @@ export default class DeedsController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.DeedsWhereInput = { deed_type: { office: { uid: officeId } } };
+			query.where = officeWhereInput;
+
 			//call service to get prisma entity
 			const deedEntities: Deeds[] = await this.deedsService.get(query);
 
@@ -43,7 +48,7 @@ export default class DeedsController extends ApiController {
 	 * @description Get a specific deed by uid
 	 * @returns Deed
 	 */
-	@Get("/api/v1/super-admin/deeds/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/deeds/:uid", [authHandler, ruleHandler, deedHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -81,7 +86,7 @@ export default class DeedsController extends ApiController {
 	/**
 	 * @description Modify a specific deed by uid
 	 */
-	@Put("/api/v1/super-admin/deeds/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/deeds/:uid", [authHandler, ruleHandler, deedHandler])
 	protected async put(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/super-admin/DocumentTypesController.ts

@@ -3,12 +3,13 @@ import { Controller, Get, Post, Put } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import { Service } from "typedi";
 import DocumentTypesService from "@Services/super-admin/DocumentTypesService/DocumentTypesService";
-import { DocumentTypes } from "@prisma/client";
+import { DocumentTypes, Prisma } from "@prisma/client";
 import ObjectHydrate from "@Common/helpers/ObjectHydrate";
 import { DocumentType } from "le-coffre-resources/dist/SuperAdmin";
 import { validateOrReject } from "class-validator";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import documentTypeHandler from "@App/middlewares/OfficeMembershipHandlers/DocumentTypeHandler";
 
 @Controller()
 @Service()
@@ -25,6 +26,9 @@ export default class DocumentTypesController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.DocumentTypesWhereInput = { office: { uid: officeId } };
+			query.where = officeWhereInput;
 
 			//call service to get prisma entity
 			const documentTypeEntities: DocumentTypes[] = await this.documentTypesService.get(query);
@@ -45,7 +49,7 @@ export default class DocumentTypesController extends ApiController {
 	/**
 	 * @description Create a new documentType
 	 */
-	@Post("/api/v1/super-admin/document-types", [authHandler,ruleHandler])
+	@Post("/api/v1/super-admin/document-types", [authHandler, ruleHandler, documentTypeHandler])
 	protected async post(req: Request, response: Response) {
 		try {
 			//init DocumentType resource with request body values
@@ -69,7 +73,7 @@ export default class DocumentTypesController extends ApiController {
 	/**
 	 * @description Modify a specific documentType by uid
 	 */
-	@Put("/api/v1/super-admin/document-types/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/document-types/:uid", [authHandler, ruleHandler, documentTypeHandler])
 	protected async put(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -88,7 +92,7 @@ export default class DocumentTypesController extends ApiController {
 			const documentTypeEntity = DocumentType.hydrate<DocumentType>(req.body);
 
 			//validate user
-			await validateOrReject(documentTypeEntity, { groups: ["update"] });
+			await validateOrReject(documentTypeEntity, { groups: ["updateDocumentType"] });
 
 			//call service to get prisma entity
 			const documentTypeEntityUpdated = await this.documentTypesService.update(uid, documentTypeEntity);
@@ -109,7 +113,7 @@ export default class DocumentTypesController extends ApiController {
 	/**
 	 * @description Get a specific documentType by uid
 	 */
-	@Get("/api/v1/super-admin/document-types/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/document-types/:uid", [authHandler, ruleHandler, documentTypeHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -128,13 +132,8 @@ export default class DocumentTypesController extends ApiController {
 				documentTypeEntity = await this.documentTypesService.getByUid(uid);
 			}
 
-			if (!documentTypeEntity) {
-				this.httpNotFoundRequest(response, "document not found");
-				return;
-			}
-
 			//Hydrate ressource with prisma entity
-			const user = ObjectHydrate.hydrate<DocumentType>(new DocumentType(), documentTypeEntity, { strategy: "excludeAll" });
+			const user = ObjectHydrate.hydrate<DocumentType>(new DocumentType(), documentTypeEntity!, { strategy: "excludeAll" });
 
 			//success
 			this.httpSuccess(response, user);

src/app/api/super-admin/DocumentsController.ts

@@ -3,11 +3,12 @@ import { Controller, Delete, Get, Post, Put } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import { Service } from "typedi";
 import DocumentsService from "@Services/super-admin/DocumentsService/DocumentsService";
-import { Documents } from "@prisma/client";
+import { Documents, Prisma } from "@prisma/client";
 import { Document } from "le-coffre-resources/dist/SuperAdmin";
 import { validateOrReject } from "class-validator";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import documentHandler from "@App/middlewares/OfficeMembershipHandlers/DocumentHandler";
 
 @Controller()
 @Service()
@@ -25,9 +26,12 @@ export default class DocumentsController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.DocumentsWhereInput = { document_type: { office: { uid: officeId } } };
+			query.where = officeWhereInput;
 
 			//call service to get prisma entity
-			const documentEntities: Documents[] = await this.documentsService.get(query);
+			const documentEntities = await this.documentsService.get(query);
 
 			//Hydrate ressource with prisma entity
 			const documents = Document.hydrateArray<Document>(documentEntities, { strategy: "excludeAll" });
@@ -44,7 +48,7 @@ export default class DocumentsController extends ApiController {
 	 * @description Create a new document
 	 * @returns IDocument created
 	 */
-	@Post("/api/v1/super-admin/documents", [authHandler,ruleHandler])
+	@Post("/api/v1/super-admin/documents", [authHandler, ruleHandler, documentHandler])
 	protected async post(req: Request, response: Response) {
 		try {
 			//init Document resource with request body values
@@ -72,7 +76,7 @@ export default class DocumentsController extends ApiController {
 	/**
 	 * @description Update a specific document
 	 */
-	@Put("/api/v1/super-admin/documents/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/documents/:uid", [authHandler, ruleHandler, documentHandler])
 	protected async update(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -111,7 +115,7 @@ export default class DocumentsController extends ApiController {
 	/**
 	 * @description Delete a specific document
 	 */
-	@Delete("/api/v1/super-admin/documents/:uid", [authHandler,ruleHandler])
+	@Delete("/api/v1/super-admin/documents/:uid", [authHandler, ruleHandler, documentHandler])
 	protected async delete(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -144,7 +148,7 @@ export default class DocumentsController extends ApiController {
 	/**
 	 * @description Get a specific document by uid
 	 */
-	@Get("/api/v1/super-admin/documents/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/documents/:uid", [authHandler, ruleHandler, documentHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/super-admin/FilesController.ts

@@ -3,12 +3,13 @@ import { Controller, Delete, Get, Post, Put } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import { Service } from "typedi";
 import FilesService from "@Services/common/FilesService/FilesService";
-import { Files } from "@prisma/client";
+import { Files, Prisma } from "@prisma/client";
 import { File } from "le-coffre-resources/dist/SuperAdmin";
 import { validateOrReject } from "class-validator";
 import DocumentsService from "@Services/super-admin/DocumentsService/DocumentsService";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import fileHandler from "@App/middlewares/OfficeMembershipHandlers/FileHandler";
 
 @Controller()
 @Service()
@@ -26,7 +27,9 @@ export default class FilesController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
-
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.FilesWhereInput = { document: { folder: { office: { uid: officeId } } } };
+			query.where = officeWhereInput;
 			//call service to get prisma entity
 			const fileEntities = await this.filesService.get(query);
 
@@ -44,7 +47,7 @@ export default class FilesController extends ApiController {
 	/**
 	 * @description Get a specific File by uid
 	 */
-	@Get("/api/v1/super-admin/files/download/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/files/download/:uid", [authHandler, ruleHandler, fileHandler])
 	protected async download(req: Request, response: Response) {
 		const uid = req.params["uid"];
 		if (!uid) {
@@ -73,7 +76,7 @@ export default class FilesController extends ApiController {
 	 * @description Create a new File
 	 * @returns File created
 	 */
-	@Post("/api/v1/super-admin/files", [authHandler,ruleHandler])
+	@Post("/api/v1/super-admin/files", [authHandler, ruleHandler, fileHandler])
 	protected async post(req: Request, response: Response) {
 		try {
 			//get file
@@ -90,13 +93,8 @@ export default class FilesController extends ApiController {
 
 			const document = await this.documentService.getByUid(fileEntity.document!.uid!);
 
-			if(!document){
-				this.httpNotFoundRequest(response, "document not found");
-				return;
-			}
-			
-			document.document_status = "DEPOSITED";
-			await this.documentService.update(document.uid!, document);
+			document!.document_status = "DEPOSITED";
+			await this.documentService.update(document!.uid!, document!);
 
 			//Hydrate ressource with prisma entity
 			const fileEntityHydrated = File.hydrate<File>(fileEntityCreated, {
@@ -114,7 +112,7 @@ export default class FilesController extends ApiController {
 	/**
 	 * @description Update a specific file
 	 */
-	@Put("/api/v1/super-admin/files/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/files/:uid", [authHandler, ruleHandler, fileHandler])
 	protected async update(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -152,7 +150,7 @@ export default class FilesController extends ApiController {
 	/**
 	 * @description Delete a specific File
 	 */
-	@Delete("/api/v1/super-admin/files/:uid", [authHandler,ruleHandler])
+	@Delete("/api/v1/super-admin/files/:uid", [authHandler, ruleHandler, fileHandler])
 	protected async delete(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -190,7 +188,7 @@ export default class FilesController extends ApiController {
 	/**
 	 * @description Get a specific File by uid
 	 */
-	@Get("/api/v1/super-admin/files/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/files/:uid", [authHandler, ruleHandler, fileHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/super-admin/OfficeFoldersController.ts

@@ -3,11 +3,12 @@ import { Controller, Delete, Get, Post, Put } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import OfficeFoldersService from "@Services/super-admin/OfficeFoldersService/OfficeFoldersService";
 import { Service } from "typedi";
-import { OfficeFolders } from "@prisma/client";
+import { OfficeFolders, Prisma } from "@prisma/client";
 import { OfficeFolder } from "le-coffre-resources/dist/SuperAdmin";
 import { validateOrReject } from "class-validator";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import folderHandler from "@App/middlewares/OfficeMembershipHandlers/FolderHandler";
 
 @Controller()
 @Service()
@@ -24,7 +25,9 @@ export default class OfficeFoldersController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
-			
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.OfficeFoldersWhereInput = { office: { uid: officeId } };
+			query.where = officeWhereInput;
 			//call service to get prisma entity
 			const officeFolderEntities: OfficeFolders[] = await this.officeFoldersService.get(query);
 
@@ -43,26 +46,13 @@ export default class OfficeFoldersController extends ApiController {
 	/**
 	 * @description Create a new folder
 	 */
-	@Post("/api/v1/super-admin/folders", [authHandler,ruleHandler])
+	@Post("/api/v1/super-admin/folders", [authHandler, ruleHandler, folderHandler])
 	protected async post(req: Request, response: Response) {
 		try {
 			//init OfficeFolder resource with request body values
 			const officeFolderRessource = OfficeFolder.hydrate<OfficeFolder>(req.body);
 			await officeFolderRessource.validateOrReject?.({ groups: ["createFolder"], forbidUnknownValues: false });
 
-			const officeFolderNumberExist = await this.officeFoldersService.get({where: {folder_number: officeFolderRessource.folder_number}});
-			
-
-			if (officeFolderNumberExist.length > 0) {
-				this.httpValidationError(response, [{
-					property: "folder_number",
-					constraints: {
-						unique: "folder_number must be unique",
-					},
-				}]);
-				return;
-			}
-
 			//call service to get prisma entity
 			const officeFolderEntity = await this.officeFoldersService.create(officeFolderRessource);
 			//Hydrate ressource with prisma entity
@@ -80,7 +70,7 @@ export default class OfficeFoldersController extends ApiController {
 	/**
 	 * @description Modify a specific folder by uid
 	 */
-	@Put("/api/v1/super-admin/folders/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/folders/:uid", [authHandler, ruleHandler, folderHandler])
 	protected async put(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -122,7 +112,7 @@ export default class OfficeFoldersController extends ApiController {
 	 * @description Get a specific folder by uid
 	 * @returns IFolder
 	 */
-	@Get("/api/v1/super-admin/folders/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/folders/:uid", [authHandler, ruleHandler, folderHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -161,7 +151,7 @@ export default class OfficeFoldersController extends ApiController {
 	/**
 	 * @description Delete a specific folder
 	 */
-	@Delete("/api/v1/super-admin/folders/:uid", [authHandler,ruleHandler])
+	@Delete("/api/v1/super-admin/folders/:uid", [authHandler, ruleHandler, folderHandler])
 	protected async delete(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/super-admin/OfficeRolesController.ts

@@ -5,9 +5,10 @@ import OfficeRolesService from "@Services/super-admin/OfficeRolesService/OfficeR
 import { Service } from "typedi";
 import { validateOrReject } from "class-validator";
 import { OfficeRole } from "le-coffre-resources/dist/Notary";
-import { OfficeRoles } from "@prisma/client";
+import { OfficeRoles, Prisma } from "@prisma/client";
 import authHandler from "@App/middlewares/AuthHandler";
 import ruleHandler from "@App/middlewares/RulesHandler";
+import officeRoleHandler from "@App/middlewares/OfficeMembershipHandlers/OfficeRoleHandler";
 
 @Controller()
 @Service()
@@ -24,6 +25,9 @@ export default class OfficeRolesController extends ApiController {
 		try {
 			//get query
 			const query = JSON.parse(req.query["q"] as string);
+			const officeId: string = req.body.user.office_Id;
+			const officeWhereInput: Prisma.OfficeRolesWhereInput = { office: { uid: officeId } };
+			query.where = officeWhereInput;
 
 			//call service to get prisma entity
 			const officeRolesEntities = await this.officeRolesService.get(query);
@@ -42,7 +46,7 @@ export default class OfficeRolesController extends ApiController {
 	/**
 	 * @description Create a new officeRole
 	 */
-	@Post("/api/v1/super-admin/office-roles", [authHandler,ruleHandler])
+	@Post("/api/v1/super-admin/office-roles", [authHandler, ruleHandler, officeRoleHandler])
 	protected async getAddresses(req: Request, response: Response) {
 		try {
 			//init IOfficeRole resource with request body values
@@ -70,7 +74,7 @@ export default class OfficeRolesController extends ApiController {
 	/**
 	 * @description Modify a specific officeRole by uid
 	 */
-	@Put("/api/v1/super-admin/office-roles/:uid", [authHandler,ruleHandler])
+	@Put("/api/v1/super-admin/office-roles/:uid", [authHandler, ruleHandler, officeRoleHandler])
 	protected async put(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -111,7 +115,7 @@ export default class OfficeRolesController extends ApiController {
 	/**
 	 * @description Get a specific officeRole by uid
 	 */
-	@Get("/api/v1/super-admin/office-roles/:uid", [authHandler,ruleHandler])
+	@Get("/api/v1/super-admin/office-roles/:uid", [authHandler, ruleHandler, officeRoleHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/super-admin/UsersController.ts

@@ -43,7 +43,7 @@ export default class UsersController extends ApiController {
 	 * @description Create a new user
 	 */
 	@Post("/api/v1/super-admin/users", [authHandler, ruleHandler])
-	protected async getAddresses(req: Request, response: Response) {
+	protected async create(req: Request, response: Response) {
 		try {
 			//init IUser resource with request body values
 			const userEntity = User.hydrate<User>(req.body);

src/app/index.ts

@@ -14,7 +14,6 @@ import FilesController from "./api/super-admin/FilesController";
 import RulesController from "./api/super-admin/RulesController";
 import RolesController from "./api/super-admin/RolesController";
 
-
 /**
  * @description This allow to declare all controllers used in the application
  */

src/app/middlewares/AuthHandler.ts

@@ -4,11 +4,11 @@ import { NextFunction, Request, Response } from "express";
 import Container from "typedi";
 
 export default function authHandler(req: Request, response: Response, next: NextFunction) {
-	const authHeader = req.headers['authorization'];
-  const token = authHeader && authHeader.split(' ')[1];
+	const authHeader = req.headers["authorization"];
+	const token = authHeader && authHeader.split(" ")[1];
 
 	if (!token) {
-    response.sendStatus(HttpCodes.UNAUTHORIZED)
+		response.sendStatus(HttpCodes.UNAUTHORIZED);
 		return;
 	}
 
@@ -18,8 +18,7 @@ export default function authHandler(req: Request, response: Response, next: Next
 			response.sendStatus(HttpCodes.UNAUTHORIZED);
 			return;
 		}
-    req.body.user = userPayload
+		req.body.user = userPayload;
 		next();
 	});
 }
-

src/app/middlewares/FileHandler.ts

@@ -1,22 +0,0 @@
-import { NextFunction, Request, Response } from "express";
-import multer from "multer";
-
-export default function fileHandler(req: Request, response: Response, next: NextFunction) {
-	const storage =  multer.memoryStorage()
-	const upload = multer({storage:storage}).single('file');
-
-  // Here call the upload middleware of multer
-  upload(req, response, function (err) {
-     if (err instanceof multer.MulterError) {
-       // A Multer error occurred when uploading.
-       const err = new Error('Multer error');
-       return next(err)
-       } else if (err) {
-       // An unknown error occurred when uploading.
-       const err = new Error('Server Error')
-       return next(err)
-     }
-    next()
-  })
-}
-

src/app/middlewares/OfficeMembershipHandlers/DeedHandler.ts

@@ -0,0 +1,44 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import DeedsService from "@Services/super-admin/DeedsService/DeedsService";
+import { DocumentType } from "le-coffre-resources/dist/SuperAdmin";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import DocumentTypesService from "@Services/super-admin/DocumentTypesService/DocumentTypesService";
+
+export default async function deedHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const documentTypes: DocumentType[] = req.body.document_types;
+
+	if (uid) {
+		const deedService = Container.get(DeedsService);
+		const deed = await deedService.getOneByUidWithOffice(uid);
+
+		if (!deed) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (deed.deed_type.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	if (documentTypes) {
+		const documentTypeService = Container.get(DocumentTypesService);
+		documentTypes.forEach(async (documentType) => {
+			const deedTypeWithOffice = await documentTypeService.getByUidWithOffice(documentType.uid!);
+			if (!deedTypeWithOffice) {
+				response.sendStatus(HttpCodes.NOT_FOUND);
+				return;
+			}
+			if (deedTypeWithOffice.office?.uid != officeId) {
+				response.sendStatus(HttpCodes.UNAUTHORIZED);
+				return;
+			}
+		});
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/DeedTypeHandler.ts

@@ -0,0 +1,50 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import DeedTypesService from "@Services/super-admin/DeedTypesService/DeedTypesService";
+import { DocumentType } from "le-coffre-resources/dist/SuperAdmin";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import DocumentTypesService from "@Services/super-admin/DocumentTypesService/DocumentTypesService";
+
+export default async function deedTypeHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const documentTypes: DocumentType[] = req.body.document_types;
+	const office = req.body.office;
+
+	if (office && office.uid != officeId) {
+		response.sendStatus(HttpCodes.UNAUTHORIZED);
+		return;
+	}
+
+	if (uid) {
+		const deedTypeService = Container.get(DeedTypesService);
+		const deedType = await deedTypeService.getByUidWithOffice(uid!);
+
+		if (!deedType) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (deedType.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	if (documentTypes) {
+		const documentTypeService = Container.get(DocumentTypesService);
+		documentTypes.forEach(async (documentType) => {
+			const documentTypeWithOffice = await documentTypeService.getByUidWithOffice(documentType.uid!);
+			if (!documentTypeWithOffice) {
+				response.sendStatus(HttpCodes.NOT_FOUND);
+				return;
+			}
+			if (documentTypeWithOffice.office?.uid != officeId) {
+				response.sendStatus(HttpCodes.UNAUTHORIZED);
+				return;
+			}
+		});
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/DocumentHandler.ts

@@ -0,0 +1,58 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import { DocumentType } from "le-coffre-resources/dist/SuperAdmin";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import { OfficeFolder } from "le-coffre-resources/dist/SuperAdmin";
+import DocumentsService from "@Services/super-admin/DocumentsService/DocumentsService";
+import DocumentTypesService from "@Services/super-admin/DocumentTypesService/DocumentTypesService";
+import OfficeFoldersService from "@Services/super-admin/OfficeFoldersService/OfficeFoldersService";
+
+export default async function documentHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const documentType: DocumentType = req.body.document_type;
+	const folder: OfficeFolder = req.body.folder;
+
+	if (folder) {
+		const officeFolderService = Container.get(OfficeFoldersService);
+		const officeFolderWithOffice = await officeFolderService.getByUidWithOffice(folder.uid!);
+		if (!officeFolderWithOffice) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+		if (officeFolderWithOffice.office?.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	if (documentType) {
+		const documentTypeService = Container.get(DocumentTypesService);
+		const documentTypeWithOffice = await documentTypeService.getByUidWithOffice(documentType.uid!);
+		if (!documentTypeWithOffice) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+		if (documentTypeWithOffice.office?.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	if (uid) {
+		const documentService = Container.get(DocumentsService);
+		const document = await documentService.getByUidWithOffice(uid!);
+
+		if (!document) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (document.document_type.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/DocumentTypeHandler.ts

@@ -0,0 +1,32 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import DocumentTypesService from "@Services/super-admin/DocumentTypesService/DocumentTypesService";
+
+export default async function documentTypeHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const office = req.body.office;
+
+	if (office && office.uid != officeId) {
+		response.sendStatus(HttpCodes.UNAUTHORIZED);
+		return;
+	}
+
+	if (uid) {
+		const documentTypeService = Container.get(DocumentTypesService);
+		const documentType = await documentTypeService.getByUidWithOffice(uid!);
+
+		if (!documentType) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (documentType.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/FileHandler.ts

@@ -0,0 +1,42 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import FilesService from "@Services/common/FilesService/FilesService";
+import DocumentsService from "@Services/super-admin/DocumentsService/DocumentsService";
+
+export default async function fileHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	let uid = req.path && req.path.split("/")[5];
+	const document = req.body.document;
+
+	if (document) {
+		const documentService = Container.get(DocumentsService);
+		const documentWithOffice = await documentService.getByUidWithOffice(document.uid!);
+		if (!documentWithOffice) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+		if (documentWithOffice.folder.office?.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	if (uid === "download") uid = req.path && req.path.split("/")[6];
+
+	if (uid) {
+		const fileService = Container.get(FilesService);
+		const file = await fileService.getByUidWithOffice(uid!);
+
+		if (!file) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+		if (file.document.folder.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/FolderHandler.ts

@@ -0,0 +1,59 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import OfficeFoldersService from "@Services/super-admin/OfficeFoldersService/OfficeFoldersService";
+import DeedTypesService from "@Services/super-admin/DeedTypesService/DeedTypesService";
+
+export default async function folderHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const office = req.body.office;
+	const officeFolderNumber = req.body.folder_number;
+	const deedType = req.body.deed.deed_type;
+
+	if (office && office.uid != officeId) {
+		response.sendStatus(HttpCodes.UNAUTHORIZED);
+		return;
+	}
+
+	if (deedType) {
+		const deedTypeService = Container.get(DeedTypesService);
+		const deedTypeWithOffice = await deedTypeService.getByUidWithOffice(deedType.uid!);
+		if (!deedTypeWithOffice) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+		if (deedTypeWithOffice.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	const officeFolderService = Container.get(OfficeFoldersService);
+
+	if (officeFolderNumber) {
+		const officeFoldersWithSameNumber = await officeFolderService.get({
+			where: { folder_number: officeFolderNumber, office: { uid: officeId } },
+		});
+		if (officeFoldersWithSameNumber.length) {
+			response.sendStatus(HttpCodes.BAD_REQUEST);
+			return;
+		}
+	}
+
+	if (uid) {
+		const officeFolder = await officeFolderService.getByUidWithOffice(uid!);
+
+		if (!officeFolder) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (officeFolder.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/OfficeRoleHandler.ts

@@ -0,0 +1,32 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import OfficeRolesService from "@Services/super-admin/OfficeRolesService/OfficeRolesService";
+
+export default async function officeRoleHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const office = req.body.office;
+
+	if (office && office.uid != officeId) {
+		response.sendStatus(HttpCodes.UNAUTHORIZED);
+		return;
+	}
+
+	if (uid) {
+		const officeRoleService = Container.get(OfficeRolesService);
+		const officeRole = await officeRoleService.getByUidWithOffice(uid!);
+
+		if (!officeRole) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (officeRole.office.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	next();
+}

src/app/middlewares/OfficeMembershipHandlers/UserHandler.ts

@@ -0,0 +1,32 @@
+import HttpCodes from "@Common/system/controller-pattern/HttpCodes";
+import { NextFunction, Request, Response } from "express";
+import Container from "typedi";
+import UsersService from "@Services/super-admin/UsersService/UsersService";
+
+export default async function userHandler(req: Request, response: Response, next: NextFunction) {
+	const officeId = req.body.user.office_Id;
+	const uid = req.path && req.path.split("/")[5];
+	const office = req.body.office_membership;
+
+	if (office && office.uid != officeId) {
+		response.sendStatus(HttpCodes.UNAUTHORIZED);
+		return;
+	}
+
+	if (uid) {
+		const userService = Container.get(UsersService);
+		const user = await userService.getByUidWithOffice(uid!);
+
+		if (!user) {
+			response.sendStatus(HttpCodes.NOT_FOUND);
+			return;
+		}
+
+		if (user.office_membership.uid != officeId) {
+			response.sendStatus(HttpCodes.UNAUTHORIZED);
+			return;
+		}
+	}
+
+	next();
+}

src/app/middlewares/RulesHandler.ts

@@ -3,20 +3,19 @@ import { NextFunction, Request, Response } from "express";
 
 export default async function ruleHandler(req: Request, response: Response, next: NextFunction) {
 	const rules = req.body.user.rules;
-  const service = req.path && req.path.split('/')[4];
-  const namespace = req.path && req.path.split('/')[3];
+	const service = req.path && req.path.split("/")[4];
+	const namespace = req.path && req.path.split("/")[3];
 	const role = req.body.user.role;
 
-  if(namespace != 'notary' && role != namespace) {
+	if (namespace != "notary" && role != namespace) {
 		response.sendStatus(HttpCodes.UNAUTHORIZED);
 		return;
 	}
 
-  if(!rules.includes(req.method + ' ' + service)) {
+	if (!rules.includes(req.method + " " + service)) {
 		response.sendStatus(HttpCodes.UNAUTHORIZED);
 		return;
 	}
 
 	next();
 }
-

src/common/config/variables/Variables.ts

@@ -86,8 +86,7 @@ export class BackendVariables {
 
 		try {
 			await validateOrReject(this, validationOptions);
-		}
-		catch(error) {
+		} catch (error) {
 			if (process.env["NODE_ENV"] === "development") {
 				throw error;
 			}

src/common/databases/migrations/20230703120600_v9/migration.sql

@@ -0,0 +1,23 @@
+-- DropForeignKey
+ALTER TABLE "users" DROP CONSTRAINT "users_contact_uid_fkey";
+
+-- DropForeignKey
+ALTER TABLE "users" DROP CONSTRAINT "users_office_role_uid_fkey";
+
+-- DropForeignKey
+ALTER TABLE "users" DROP CONSTRAINT "users_office_uid_fkey";
+
+-- DropForeignKey
+ALTER TABLE "users" DROP CONSTRAINT "users_roles_uid_fkey";
+
+-- AddForeignKey
+ALTER TABLE "users" ADD CONSTRAINT "users_contact_uid_fkey" FOREIGN KEY ("contact_uid") REFERENCES "contacts"("uid") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "users" ADD CONSTRAINT "users_roles_uid_fkey" FOREIGN KEY ("roles_uid") REFERENCES "roles"("uid") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "users" ADD CONSTRAINT "users_office_role_uid_fkey" FOREIGN KEY ("office_role_uid") REFERENCES "office_roles"("uid") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "users" ADD CONSTRAINT "users_office_uid_fkey" FOREIGN KEY ("office_uid") REFERENCES "offices"("uid") ON DELETE RESTRICT ON UPDATE CASCADE;

src/common/databases/migrations/20230703122557_v10/migration.sql

@@ -0,0 +1,15 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[idNot,uid]` on the table `users` will be added. If there are existing duplicate values, this will fail.
+  - A unique constraint covering the columns `[contact_uid,uid]` on the table `users` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- DropIndex
+DROP INDEX "users_idNot_key";
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_idNot_uid_key" ON "users"("idNot", "uid");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_contact_uid_uid_key" ON "users"("contact_uid", "uid");

src/common/databases/migrations/20230703123246_v11/migration.sql

@@ -0,0 +1,14 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[idNot]` on the table `users` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- DropIndex
+DROP INDEX "users_contact_uid_uid_key";
+
+-- DropIndex
+DROP INDEX "users_idNot_uid_key";
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_idNot_key" ON "users"("idNot");

src/common/databases/seeders/seeder.ts

@@ -1,4 +1,4 @@
-import 'module-alias/register';
+import "module-alias/register";
 import { EFolderStatus, EOfficeStatus, ECivility, ECustomerStatus, PrismaClient, Prisma } from "@prisma/client";
 import User, {
 	Address,
@@ -17,7 +17,6 @@ import User, {
 export default async function main() {
 	const prisma = new PrismaClient();
 
-
 	const randomString = () => {
 		const chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 		let result = "";
@@ -824,7 +823,6 @@ export default async function main() {
 			created_at: new Date(),
 			updated_at: new Date(),
 		},
-		
 	];
 
 	const roles: Role[] = [
@@ -851,7 +849,7 @@ export default async function main() {
 			created_at: new Date(),
 			updated_at: new Date(),
 			rules: rules.slice(0, 11),
-		}
+		},
 	];
 
 	const officeRoles: OfficeRole[] = [
@@ -882,7 +880,7 @@ export default async function main() {
 			updated_at: new Date(),
 			office: offices[0]!,
 			rules: rules.slice(0, 11),
-		}
+		},
 	];
 
 	const users: User[] = [
@@ -1385,12 +1383,12 @@ export default async function main() {
 				office_status: EOfficeStatus.DESACTIVATED,
 			},
 		});
-;		office.uid = officeCreated.uid;
+		office.uid = officeCreated.uid;
 	}
 	for (const rule of rules) {
 		const ruleCreated = await prisma.rules.create({
 			data: {
-				name: rule.name
+				name: rule.name,
 			},
 		});
 		rule.uid = ruleCreated.uid;
@@ -1607,8 +1605,8 @@ export default async function main() {
 					connect: officeFolder.stakeholders?.map((stakeholder) => ({
 						uid: stakeholder.uid!,
 					})),
-				}
-			}
+				},
+			},
 		});
 		officeFolder.uid = officeFolderCreated.uid;
 	}

src/common/repositories/DeedTypesRepository.ts

@@ -69,8 +69,8 @@ export default class DeedTypesRepository extends BaseRepository {
 				document_types: {
 					set: deedType.document_types?.map((documentType) => ({
 						uid: documentType.uid!,
-					}))
-				}
+					})),
+				},
 			},
 		};
 
@@ -88,4 +88,16 @@ export default class DeedTypesRepository extends BaseRepository {
 			include: query,
 		});
 	}
+
+	/**
+	 * @description : Find unique deed type with relations
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { office: true },
+		});
+	}
 }

src/common/repositories/DeedsRepository.ts

@@ -90,4 +90,19 @@ export default class DeedsRepository extends BaseRepository {
 			include: query,
 		});
 	}
+
+	/**
+	 * @description : Find unique deed
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: {
+				deed_type: { include: { office: true } },
+				document_types: { include: { office: true } },
+			},
+		});
+	}
 }

src/common/repositories/DocumentTypesRepository.ts

@@ -61,7 +61,7 @@ export default class DocumentTypesRepository extends BaseRepository {
 						uid: documentType.office!.uid,
 					},
 				},
-			}
+			},
 		};
 
 		return this.model.update(updateArgs);
@@ -78,4 +78,16 @@ export default class DocumentTypesRepository extends BaseRepository {
 			include: query,
 		});
 	}
+
+	/**
+	 * @description : Find unique document type with relations
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { office: true },
+		});
+	}
 }

src/common/repositories/DocumentsRepository.ts

@@ -78,7 +78,7 @@ export default class DocumentsRepository extends BaseRepository {
 
 		const batchPayload = await this.model.createMany(createArgs);
 
-		const documentsCreated = await this.model.findMany({orderBy: {created_at: 'desc'}, take: batchPayload.count});
+		const documentsCreated = await this.model.findMany({ orderBy: { created_at: "desc" }, take: batchPayload.count });
 
 		const createHistoryArgs: Prisma.DocumentHistoryCreateManyArgs = {
 			data: documentsCreated.map((document) => ({
@@ -106,7 +106,7 @@ export default class DocumentsRepository extends BaseRepository {
 						document_status: EDocumentStatus[document.document_status as keyof typeof EDocumentStatus],
 						refused_reason: refusedReason,
 					},
-				}
+				},
 			},
 		});
 	}
@@ -133,4 +133,16 @@ export default class DocumentsRepository extends BaseRepository {
 			include: query,
 		});
 	}
+
+	/**
+	 * @description : Find unique document with relations
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { folder: { include: { office: true } }, document_type: { include: { office: true } } },
+		});
+	}
 }

src/common/repositories/FilesRepository.ts

@@ -39,8 +39,8 @@ export default class FilesRepository extends BaseRepository {
 				file_path: file.file_path,
 				mimetype: file.mimetype,
 				size: file.size,
-				key: key
-			}
+				key: key,
+			},
 		};
 		return this.model.create({ ...createArgs, include: { document: true } });
 	}
@@ -58,8 +58,8 @@ export default class FilesRepository extends BaseRepository {
 				file_path: file.file_path,
 				mimetype: file.mimetype,
 				size: file.size,
-				key: key
-			}
+				key: key,
+			},
 		};
 		return this.model.update({ ...updateArgs, include: { document: true } });
 	}
@@ -74,8 +74,8 @@ export default class FilesRepository extends BaseRepository {
 			},
 			data: {
 				key: null,
-				archived_at: new Date(Date.now())
-			}
+				archived_at: new Date(Date.now()),
+			},
 		};
 		return this.model.update({ ...updateArgs, include: { document: true } });
 	}
@@ -91,4 +91,16 @@ export default class FilesRepository extends BaseRepository {
 			include: query,
 		});
 	}
+
+	/**
+	 * @description : Find unique file with office
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { document: { include: { folder: { include: { office: true } } } } },
+		});
+	}
 }

src/common/repositories/OfficeFoldersRepository.ts

@@ -48,8 +48,8 @@ export default class OfficeFoldersRepository extends BaseRepository {
 					connect: officeFolder.stakeholders?.map((stakeholder) => ({
 						uid: stakeholder.uid!,
 					})),
-				}
-			}
+				},
+			},
 		};
 
 		return this.model.create({ ...createArgs, include: { stakeholders: true } });
@@ -112,6 +112,18 @@ export default class OfficeFoldersRepository extends BaseRepository {
 		});
 	}
 
+	/**
+	 * @description : Find one office folder
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { office: true },
+		});
+	}
+
 	/**
 	 * @description : Delete a folder
 	 */

src/common/repositories/OfficeRolesRepository.ts

@@ -80,6 +80,18 @@ export default class OfficeRolesRepository extends BaseRepository {
 		});
 	}
 
+	/**
+	 * @description : Find one officeRole with office
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { office: true },
+		});
+	}
+
 	/**
 	 * @description : Delete a officeRole
 	 */

src/common/repositories/RulesRepository.ts

@@ -30,7 +30,7 @@ export default class RulesRepository extends BaseRepository {
 	public async create(rule: Rule): Promise<Rules> {
 		const createArgs: Prisma.RulesCreateArgs = {
 			data: {
-				name: rule.name
+				name: rule.name,
 			},
 		};
 
@@ -46,7 +46,7 @@ export default class RulesRepository extends BaseRepository {
 				uid: rule.uid,
 			},
 			data: {
-				name: rule.name
+				name: rule.name,
 			},
 		};
 

src/common/repositories/UsersRepository.ts

@@ -55,10 +55,9 @@ export default class UsersRepository extends BaseRepository {
 						first_name: user.contact!.first_name,
 						last_name: user.contact!.last_name,
 						email: user.contact!.email,
-						phone_number: user.contact!.phone_number,
+						phone_number: user.contact?.phone_number,
 						cell_phone_number: user.contact!.cell_phone_number,
-						civility: ECivility[user.contact!.civility as keyof typeof ECivility],
-						address: {},
+						civility: ECivility[user.contact?.civility as keyof typeof ECivility],
 					},
 				},
 				role: {
@@ -82,7 +81,7 @@ export default class UsersRepository extends BaseRepository {
 				},
 			};
 		}
-		return this.model.create({ ...createArgs, include: { contact: true, office_membership: { include: { address: true } } } });
+		return this.model.create(createArgs);
 	}
 
 	/**
@@ -129,19 +128,18 @@ export default class UsersRepository extends BaseRepository {
 						first_name: user.contact!.first_name,
 						last_name: user.contact!.last_name,
 						email: user.contact!.email,
-						phone_number: user.contact!.phone_number,
-						cell_phone_number: user.contact!.cell_phone_number,
-						civility: ECivility[user.contact!.civility as keyof typeof ECivility],
-						address: {},
+						phone_number: user.contact?.phone_number,
+						cell_phone_number: user.contact?.cell_phone_number,
+						civility: ECivility[user.contact?.civility as keyof typeof ECivility],
 					},
 				},
 			},
 		};
-		if (user.contact!.address) {
+		if (user.contact?.address) {
 			updateArgs.data.contact!.update!.address!.update = {
-				address: user.contact!.address!.address,
-				zip_code: user.contact!.address!.zip_code,
-				city: user.contact!.address!.city,
+				address: user.contact?.address?.address,
+				zip_code: user.contact?.address?.zip_code,
+				city: user.contact?.address?.city,
 			};
 		}
 		if (user.office_role) {
@@ -166,6 +164,18 @@ export default class UsersRepository extends BaseRepository {
 		});
 	}
 
+	/**
+	 * @description : Find one user with office
+	 */
+	public async findOneByUidWithOffice(uid: string) {
+		return this.model.findUnique({
+			where: {
+				uid: uid,
+			},
+			include: { office_membership: true },
+		});
+	}
+
 	/**
 	 * @description : Find one user
 	 */

src/common/system/OpenIdInterface.ts

@@ -21,10 +21,10 @@ export type OpenIdConfig = {
 	scopes_supported: string[];
 	issuer: string;
 	jwks_uri: string;
-}
+};
 
 export default interface OpenIdInterface {
-	getOpenIdConfig(): Promise<OpenIdConfig>
+	getOpenIdConfig(): Promise<OpenIdConfig>;
 	verifyIdToken(signingKey: string): Promise<Payload>;
 	getSigningKeys(jwksUri: string): Promise<string[]>;
 }

src/entries/App.ts

@@ -9,7 +9,6 @@ import errorHandler from "@App/middlewares/ErrorHandler";
 import { BackendVariables } from "@Common/config/variables/Variables";
 import multer from "multer";
 
-
 const storage = multer.memoryStorage();
 
 (async () => {
@@ -24,7 +23,12 @@ const storage =  multer.memoryStorage();
 			label,
 			port: parseInt(port),
 			rootUrl,
-			middlwares: [cors({ origin: "*" }), multer({storage:storage}).single('file'), bodyParser.urlencoded({ extended: true }), bodyParser.json()],
+			middlwares: [
+				cors({ origin: "*" }),
+				multer({ storage: storage }).single("file"),
+				bodyParser.urlencoded({ extended: true }),
+				bodyParser.json(),
+			],
 			errorHandler,
 		});
 

src/services/common/AuthService/AuthService.ts

@@ -14,7 +14,7 @@ interface IJwtPayload {
 		providerName: PROVIDER_OPENID;
 		userId: string | number;
 	};
-	office_IdNot_Id: string;
+	office_Id: string;
 	role: string;
 	rules: string[];
 }
@@ -38,7 +38,7 @@ export default class AuthService extends BaseService {
 			return {
 				userId: user.uid,
 				openId: { providerName: providerName, userId: user.idNot },
-				office_IdNot_Id: user.office_membership.idNot,
+				office_Id: user.office_membership.uid,
 				role: user.role.name,
 				rules: rules,
 			};
@@ -50,7 +50,7 @@ export default class AuthService extends BaseService {
 		return {
 			userId: user.uid,
 			openId: { providerName: providerName, userId: user.idNot },
-			office_IdNot_Id: user.office_membership.idNot,
+			office_Id: user.office_membership.uid,
 			role: user.role.name,
 			rules: rules,
 		};

src/services/common/CryptoService/CryptoService.ts

@@ -5,7 +5,6 @@ import crypto from "crypto";
 
 @Service()
 export default class CryptoService extends BaseService {
-
 	private static readonly CRYPTO_ALGORITHM = "aes-256-ctr";
 
 	constructor(protected variables: BackendVariables) {
@@ -13,7 +12,7 @@ export default class CryptoService extends BaseService {
 	}
 
 	private getKey(key: string) {
-		return crypto.createHash('sha256').update(String(key)).digest('base64').slice(0, 32);
+		return crypto.createHash("sha256").update(String(key)).digest("base64").slice(0, 32);
 	}
 
 	/**

src/services/common/FilesService/FilesService.ts

@@ -7,10 +7,9 @@ import IpfsService from "../IpfsService/IpfsService";
 import { BackendVariables } from "@Common/config/variables/Variables";
 import { Readable } from "stream";
 import { v4 } from "uuid";
-import { Files } from "@prisma/client";
+import { Files, Prisma } from "@prisma/client";
 import fetch from "node-fetch";
 
-
 @Service()
 export default class FilesService extends BaseService {
 	constructor(
@@ -26,7 +25,7 @@ export default class FilesService extends BaseService {
 	 * @description : Get all files
 	 * @throws {Error} If files cannot be ge
 	 */
-	public async get(query: any): Promise<Files[]>  {
+	public async get(query: Prisma.FilesFindManyArgs) {
 		return this.filesRepository.findMany(query);
 	}
 
@@ -34,8 +33,16 @@ export default class FilesService extends BaseService {
 	 * @description : Get a file by uid
 	 * @throws {Error} If project cannot be created
 	 */
-	public async getByUid(uid: string): Promise<Files | null>  {
-		return this.filesRepository.findOneByUid(uid);
+	public async getByUid(uid: string, query?: Prisma.FilesInclude) {
+		return this.filesRepository.findOneByUid(uid, query);
+	}
+
+	/**
+	 * @description : Get a file by uid with office
+	 * @throws {Error} If project cannot be created
+	 */
+	public async getByUidWithOffice(uid: string) {
+		return this.filesRepository.findOneByUidWithOffice(uid);
 	}
 
 	/**
@@ -58,11 +65,12 @@ export default class FilesService extends BaseService {
 		const key = v4();
 		const encryptedFile = await this.cryptoService.encrypt(fileData.buffer, key);
 		const upload = await this.ipfsService.pinFile(Readable.from(encryptedFile), fileData.originalname);
-		const fileToCreate: File = file;
+		let fileToCreate: File = file;
 		fileToCreate.file_name = fileData.originalname;
 		fileToCreate.file_path = this.variables.PINATA_GATEWAY.concat(upload.IpfsHash);
 		fileToCreate.mimetype = fileData.mimetype;
 		fileToCreate.size = fileData.size;
+		fileToCreate.archived_at = null;
 
 		return this.filesRepository.create(fileToCreate, key);
 	}

src/services/common/IpfsService/IpfsService.ts

@@ -9,7 +9,7 @@ export default class FilesService extends BaseService {
 	private ipfsClient: pinataSDK;
 	constructor(protected variables: BackendVariables) {
 		super();
-		this.ipfsClient = new pinataSDK({ pinataApiKey: variables.PINATA_API_KEY, pinataSecretApiKey: variables.PINATA_API_SECRET })
+		this.ipfsClient = new pinataSDK({ pinataApiKey: variables.PINATA_API_KEY, pinataSecretApiKey: variables.PINATA_API_SECRET });
 	}
 
 	/**

src/services/common/OpenIdService/OpenIdService.ts

@@ -20,7 +20,7 @@ export type OpenIdConfig = {
 	scopes_supported: string[];
 	issuer: string;
 	jwks_uri: string;
-}
+};
 
 @Service()
 export default class OpenIdService extends BaseService {

src/services/super-admin/DeedTypesService/DeedTypesService.ts

@@ -1,4 +1,4 @@
-import { DeedTypes } from "@prisma/client";
+import { DeedTypes, Prisma } from "@prisma/client";
 import DeedTypesRepository from "@Repositories/DeedTypesRepository";
 import BaseService from "@Services/BaseService";
 import { DeedType } from "le-coffre-resources/dist/SuperAdmin";
@@ -6,9 +6,7 @@ import { Service } from "typedi";
 
 @Service()
 export default class DeedTypesService extends BaseService {
-	constructor(
-		private deedTypeRepository: DeedTypesRepository,
-	) {
+	constructor(private deedTypeRepository: DeedTypesRepository) {
 		super();
 	}
 
@@ -16,7 +14,7 @@ export default class DeedTypesService extends BaseService {
 	 * @description : Get all deed-types
 	 * @throws {Error} If deed-types cannot be get
 	 */
-	public async get(query: any): Promise<DeedTypes[]> {
+	public async get(query: Prisma.DeedTypesFindManyArgs) {
 		return this.deedTypeRepository.findMany(query);
 	}
 
@@ -40,7 +38,15 @@ export default class DeedTypesService extends BaseService {
 	 * @description : Get a deedtype by uid
 	 * @throws {Error} If deed-type cannot be get by uid
 	 */
-	public async getByUid(uid: string, query?: any): Promise<DeedTypes | null> {
+	public async getByUid(uid: string, query?: Prisma.DeedTypesInclude): Promise<DeedTypes | null> {
 		return this.deedTypeRepository.findOneByUid(uid, query);
 	}
+
+	/**
+	 * @description : Get a deedtype by uid
+	 * @throws {Error} If deed-type cannot be get by uid
+	 */
+	public async getByUidWithOffice(uid: string) {
+		return this.deedTypeRepository.findOneByUidWithOffice(uid);
+	}
 }

src/services/super-admin/DeedsService/DeedsService.ts

@@ -1,4 +1,4 @@
-import { Deeds } from "@prisma/client";
+import { Deeds, Prisma } from "@prisma/client";
 import DeedsRepository from "@Repositories/DeedsRepository";
 import BaseService from "@Services/BaseService";
 import { Deed } from "le-coffre-resources/dist/SuperAdmin";
@@ -14,7 +14,7 @@ export default class DeedsService extends BaseService {
 	 * @description : Get all deeds
 	 * @throws {Error} If deeds cannot be get
 	 */
-	public async get(query: any) {
+	public async get(query: Prisma.DeedsFindManyArgs) {
 		return this.deedRepository.findMany(query);
 	}
 
@@ -38,7 +38,11 @@ export default class DeedsService extends BaseService {
 	 * @description : Get a deed by uid
 	 * @throws {Error} If deed-type cannot be get by uid
 	 */
-	public async getByUid(uid: string, query?: any): Promise<Deeds | null> {
+	public async getByUid(uid: string, query?: Prisma.DeedsInclude) {
 		return this.deedRepository.findOneByUid(uid, query);
 	}
+
+	public async getOneByUidWithOffice(uid: string) {
+		return this.deedRepository.findOneByUidWithOffice(uid);
+	}
 }

src/services/super-admin/DocumentTypesService/DocumentTypesService.ts

@@ -1,4 +1,4 @@
-import { DocumentTypes } from "@prisma/client";
+import { DocumentTypes, Prisma } from "@prisma/client";
 import DocumentTypesRepository from "@Repositories/DocumentTypesRepository";
 import BaseService from "@Services/BaseService";
 import { DocumentType } from "le-coffre-resources/dist/SuperAdmin";
@@ -14,7 +14,7 @@ export default class DocumentTypesService extends BaseService {
 	 * @description : Get all document-types
 	 * @throws {Error} If document-types cannot be get
 	 */
-	public async get(query: any): Promise<DocumentTypes[]> {
+	public async get(query: Prisma.DocumentTypesFindManyArgs) {
 		return this.documentTypeRepository.findMany(query);
 	}
 
@@ -38,7 +38,15 @@ export default class DocumentTypesService extends BaseService {
 	 * @description : Get a document-type by uid
 	 * @throws {Error} If document-type is not found
 	 */
-	public async getByUid(uid: string, query?: any): Promise<DocumentTypes | null>  {
+	public async getByUid(uid: string, query?: Prisma.DocumentTypesInclude): Promise<DocumentTypes | null> {
 		return this.documentTypeRepository.findOneByUid(uid, query);
 	}
+
+	/**
+	 * @description : Get a document-type by uid with relations
+	 * @throws {Error} If document-type is not found
+	 */
+	public async getByUidWithOffice(uid: string) {
+		return this.documentTypeRepository.findOneByUidWithOffice(uid);
+	}
 }

src/services/super-admin/DocumentsService/DocumentsService.ts

@@ -1,4 +1,4 @@
-import { Documents } from "@prisma/client";
+import { Documents, Prisma } from "@prisma/client";
 import { Document } from "le-coffre-resources/dist/SuperAdmin";
 import DocumentsRepository from "@Repositories/DocumentsRepository";
 import BaseService from "@Services/BaseService";
@@ -14,7 +14,7 @@ export default class DocumentsService extends BaseService {
 	 * @description : Get all documents
 	 * @throws {Error} If documents cannot be get
 	 */
-	public async get(query: any) {
+	public async get(query: Prisma.DocumentsFindManyArgs) {
 		return this.documentsRepository.findMany(query);
 	}
 
@@ -61,7 +61,15 @@ export default class DocumentsService extends BaseService {
 	 * @description : Get a document by uid
 	 * @throws {Error} If document cannot be get by uid
 	 */
-	public async getByUid(uid: string, query?: any): Promise<Documents | null> {
+	public async getByUid(uid: string, query?: Prisma.DocumentsInclude) {
 		return this.documentsRepository.findOneByUid(uid, query);
 	}
+
+	/**
+	 * @description : Get a document by uid
+	 * @throws {Error} If document cannot be get by uid
+	 */
+	public async getByUidWithOffice(uid: string) {
+		return this.documentsRepository.findOneByUidWithOffice(uid);
+	}
 }

src/services/super-admin/OfficeFoldersService/OfficeFoldersService.ts

@@ -5,14 +5,14 @@ import { OfficeFolder } from "le-coffre-resources/dist/SuperAdmin";
 import { Service } from "typedi";
 import DeedTypesService from "../DeedTypesService/DeedTypesService";
 import DeedsRepository from "@Repositories/DeedsRepository";
-
+import { Prisma } from "@prisma/client";
 
 @Service()
 export default class OfficeFoldersService extends BaseService {
 	constructor(
 		private officeFoldersRepository: OfficeFoldersRepository,
 		private deedTypeService: DeedTypesService,
-		private deedRepository: DeedsRepository
+		private deedRepository: DeedsRepository,
 	) {
 		super();
 	}
@@ -21,7 +21,7 @@ export default class OfficeFoldersService extends BaseService {
 	 * @description : Get all folders
 	 * @throws {Error} If folders cannot be get
 	 */
-	public async get(query: any): Promise<OfficeFolders[]>  {		
+	public async get(query: Prisma.OfficeFoldersFindManyArgs) {
 		return this.officeFoldersRepository.findMany(query);
 	}
 
@@ -31,8 +31,8 @@ export default class OfficeFoldersService extends BaseService {
 	 */
 	public async create(officeFolderEntity: OfficeFolder): Promise<OfficeFolders> {
 		const deedType = await this.deedTypeService.getByUid(officeFolderEntity.deed!.deed_type!.uid!);
-		if(!deedType) throw new Error('deed type not found');
-		if(deedType.archived_at) throw new Error('deed type is archived');
+		if (!deedType) throw new Error("deed type not found");
+		if (deedType.archived_at) throw new Error("deed type is archived");
 		const deed = await this.deedRepository.create(officeFolderEntity.deed!);
 		officeFolderEntity.deed!.uid = deed.uid;
 		return this.officeFoldersRepository.create(officeFolderEntity);
@@ -50,17 +50,25 @@ export default class OfficeFoldersService extends BaseService {
 	 * @description : Get a folder by uid
 	 * @throws {Error} If folder cannot be get by uid
 	 */
-	public async getByUid(uid: string, query?: any): Promise<OfficeFolders | null> {
+	public async getByUid(uid: string, query?: Prisma.OfficeFoldersInclude) {
 		return this.officeFoldersRepository.findOneByUid(uid, query);
 	}
 
+	/**
+	 * @description : Get a folder by uid
+	 * @throws {Error} If folder cannot be get by uid
+	 */
+	public async getByUidWithOffice(uid: string) {
+		return this.officeFoldersRepository.findOneByUidWithOffice(uid);
+	}
+
 	/**
 	 * @description : Delete a folder
 	 * @throws {Error} If document cannot be deleted
 	 */
 	public async delete(uid: string): Promise<OfficeFolders> {
 		const officeFolderEntity = await this.officeFoldersRepository.findOneByUid(uid, { customers: true });
-		if(!officeFolderEntity) throw new Error('office folder not found');
+		if (!officeFolderEntity) throw new Error("office folder not found");
 		const officeFolder = OfficeFolder.hydrate<OfficeFolder>(officeFolderEntity, { strategy: "excludeAll" });
 
 		if (officeFolder.customers?.length) {

src/services/super-admin/OfficeRolesService/OfficeRolesService.ts

@@ -14,7 +14,7 @@ export default class OfficeRolesService extends BaseService {
 	 * @description : Get all officeRoles
 	 * @throws {Error} If officeRoles cannot be get
 	 */
-	public get(query: Prisma.OfficeRolesFindManyArgs): Promise<OfficeRoles[]> {
+	public get(query: Prisma.OfficeRolesFindManyArgs) {
 		return this.officeRoleRepository.findMany(query);
 	}
 
@@ -38,7 +38,15 @@ export default class OfficeRolesService extends BaseService {
 	 * @description : Get a officeRole by uid
 	 * @throws {Error} If officeRole cannot be get by uid
 	 */
-	public getByUid(uid: string, query?: any): Promise<OfficeRoles | null> {
+	public getByUid(uid: string, query?: Prisma.OfficeRolesInclude) {
 		return this.officeRoleRepository.findOneByUid(uid, query);
 	}
+
+	/**
+	 * @description : Get a officeRole by uid
+	 * @throws {Error} If officeRole cannot be get by uid
+	 */
+	public getByUidWithOffice(uid: string) {
+		return this.officeRoleRepository.findOneByUidWithOffice(uid);
+	}
 }

src/services/super-admin/UsersService/UsersService.ts

@@ -39,10 +39,18 @@ export default class UsersService extends BaseService {
 	 * @description : Get a user by uid
 	 * @throws {Error} If user cannot be get by uid
 	 */
-	public getByUid(uid: string, query?: any): Promise<Users | null> {
+	public getByUid(uid: string, query?: Prisma.UsersInclude) {
 		return this.userRepository.findOneByUid(uid, query);
 	}
 
+	/**
+	 * @description : Get a user by uid with office
+	 * @throws {Error} If user cannot be get by uid
+	 */
+	public getByUidWithOffice(uid: string) {
+		return this.userRepository.findOneByUidWithOffice(uid);
+	}
+
 	/**
 	 * @description : Get a user by uid
 	 * @throws {Error} If user cannot be get by uid

src/test/services/super-admin/CustomersService.test.ts

@@ -151,7 +151,7 @@ describe("test update function", () => {
 
 describe("test get function", () => {
 	it("should return an array of Customers", async () => {
-		const req = {}
+		const req = {};
 		const customers = await CustomersServiceTest.get(req);
 
 		// verify result typing

src/test/services/super-admin/DeedTypesService.test.ts

@@ -279,7 +279,10 @@ describe("test get function", () => {
 		expect(deedTypesForFirstOffice[0]?.archived_at).toBeNull();
 		expect(deedTypesForFirstOffice[0]?.office_uid).toEqual(office.uid);
 
-		const deedTypesForSecondOffice = await DeedTypeServiceTest.get({ where: { office: {uid: office_.uid} }, orderBy: { name: "asc" } });
+		const deedTypesForSecondOffice = await DeedTypeServiceTest.get({
+			where: { office: { uid: office_.uid } },
+			orderBy: { name: "asc" },
+		});
 
 		expect(deedTypesForSecondOffice.length).toEqual(2);
 

src/test/services/super-admin/DocumentTypesService.test.ts

@@ -241,7 +241,10 @@ describe("test get function", () => {
 	});
 
 	it("should return an array of DocumentTypes per offices", async () => {
-		const documentTypesForFirstOffice = await DocumentTypesServiceTest.get({ where: { office: {uid : office.uid }}, orderBy: { name: "asc" } });
+		const documentTypesForFirstOffice = await DocumentTypesServiceTest.get({
+			where: { office: { uid: office.uid } },
+			orderBy: { name: "asc" },
+		});
 
 		expect(documentTypesForFirstOffice.length).toEqual(1);
 
@@ -252,7 +255,10 @@ describe("test get function", () => {
 		expect(documentTypesForFirstOffice[0]?.archived_at).toBeNull();
 		expect(documentTypesForFirstOffice[0]?.office_uid).toEqual(office.uid);
 
-		const documentTypesForSecondOffice = await DocumentTypesServiceTest.get({ where: { office: {uid : office_.uid }}, orderBy: { name: "asc" } });
+		const documentTypesForSecondOffice = await DocumentTypesServiceTest.get({
+			where: { office: { uid: office_.uid } },
+			orderBy: { name: "asc" },
+		});
 
 		expect(documentTypesForSecondOffice.length).toEqual(2);
 

src/test/services/super-admin/OfficeFolderService.test.ts

@@ -1,7 +1,18 @@
 import "module-alias/register";
 import "reflect-metadata";
 import { PrismaClient } from "prisma/prisma-client";
-import { customer, customer_, deedType, documentType, documentType_, office, officeFolder, officeFolder_, user, user_ } from "@Test/config/MockedData";
+import {
+	customer,
+	customer_,
+	deedType,
+	documentType,
+	documentType_,
+	office,
+	officeFolder,
+	officeFolder_,
+	user,
+	user_,
+} from "@Test/config/MockedData";
 import Container from "typedi";
 import OfficeFoldersRepository from "@Repositories/OfficeFoldersRepository";
 import OfficeFolderService from "@Services/super-admin/OfficeFoldersService/OfficeFoldersService";
@@ -12,7 +23,11 @@ import DeedsRepository from "@Repositories/DeedsRepository";
 
 const prisma = new PrismaClient();
 
-const OfficeFolderServiceTest = new OfficeFolderService(Container.get(OfficeFoldersRepository), Container.get(DeedTypesService), Container.get(DeedsRepository));
+const OfficeFolderServiceTest = new OfficeFolderService(
+	Container.get(OfficeFoldersRepository),
+	Container.get(DeedTypesService),
+	Container.get(DeedsRepository),
+);
 
 beforeAll(async () => {
 	office.uid = (await initOffice(office)).uid;