Get office membership + create user if not exist

src/app/api/admin/SubscriptionsController.ts

@@ -10,6 +10,8 @@ import SubscriptionsService from "@Services/admin/SubscriptionsService/Subscript
 import { Subscription } from "le-coffre-resources/dist/Admin";
 import { validateOrReject } from "class-validator";
 import ObjectHydrate from "@Common/helpers/ObjectHydrate";
+import roleHandler from "@App/middlewares/RolesHandler";
+import authHandler from "@App/middlewares/AuthHandler";
 
 @Controller()
 @Service()
@@ -21,7 +23,7 @@ export default class SubscriptionsController extends ApiController {
 	/**
 	 * @description Get all subscriptions
 	 */
-	@Get("/api/v1/admin/subscriptions")
+	@Get("/api/v1/admin/subscriptions", [authHandler, roleHandler])
 	protected async get(req: Request, response: Response) {
 		try {
 			//get query
@@ -51,7 +53,7 @@ export default class SubscriptionsController extends ApiController {
 	/**
 	 * @description Get a specific documentType by uid
 	 */
-	@Get("/api/v1/admin/subscriptions/:uid")
+	@Get("/api/v1/admin/subscriptions/:uid", [authHandler, roleHandler])
 	protected async getOneByUid(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];
@@ -81,7 +83,7 @@ export default class SubscriptionsController extends ApiController {
 	/**
 	 * @description Create a new documentType
 	 */
-	@Post("/api/v1/admin/subscriptions")
+	@Post("/api/v1/admin/subscriptions", [authHandler, roleHandler])
 	protected async post(req: Request, response: Response) {
 		try {
 			//init Subscription resource with request body values
@@ -105,7 +107,7 @@ export default class SubscriptionsController extends ApiController {
 	/**
 	 * @description Update a subscription
 	 */
-	@Put("/api/v1/admin/subscriptions/:uid")
+	@Put("/api/v1/admin/subscriptions/:uid", [authHandler, roleHandler])
 	protected async put(req: Request, response: Response) {
 		try {
 			const uid = req.params["uid"];

src/app/api/idnot/OfficeController.ts

@@ -3,15 +3,19 @@ import { Controller, Get } from "@ControllerPattern/index";
 import ApiController from "@Common/system/controller-pattern/ApiController";
 import { Service } from "typedi";
 import IdNotService from "@Services/common/IdNotService/IdNotService";
+import UsersService from "@Services/super-admin/UsersService/UsersService";
+import User from "le-coffre-resources/dist/Notary/User";
+import userHandler from "@App/middlewares/OfficeMembershipHandlers/UserHandler";
+import authHandler from "@App/middlewares/AuthHandler";
 
 @Controller()
 @Service()
 export default class UserController extends ApiController {
-	constructor (private idNotService: IdNotService) {
+	constructor (private idNotService: IdNotService, private userService: UsersService) {
 		super();
 	}
 
-	@Get("/api/v1/idnot/office/:uid/office-memberships")
+	@Get("/api/v1/idnot/office/:uid/office-memberships", [authHandler, userHandler])
 	protected async getOfficeMemberships(req: Request, response: Response) {
 		try {			
             const uid = req.params["uid"];
@@ -21,7 +25,14 @@ export default class UserController extends ApiController {
             }
 
 			const officeMemberships = await this.idNotService.getOfficeMemberships(uid);			
-			this.httpSuccess(response, officeMemberships);
+
+			await this.userService.getOrCreateUsers(uid, officeMemberships.result);
+
+			const usersEntities = await this.userService.get({ where: { office_uid: uid }, include: { contact: true}});
+
+			const users = User.hydrateArray<User>(usersEntities, { strategy: "excludeAll" });
+
+			this.httpSuccess(response, users);
 		} catch (error) {
 			console.log(error);
 			this.httpInternalError(response);

src/common/repositories/UsersRepository.ts

@@ -143,6 +143,45 @@ export default class UsersRepository extends BaseRepository {
 		return this.model.update({ ...updateArgs, include: { contact: true, office_membership: { include: { address: true } } } });
 	}
 
+	public async getOrCreate(usersToAdd: User[]) {
+		
+		let users: User[] = [];
+
+    await Promise.all(usersToAdd.map(async (user) => {
+        const upsertUser = await this.model.upsert({
+            where: {
+                idNot: user.idNot,
+            },
+            update: {},
+            create: {
+                idNot: user.idNot,
+                office_membership: {
+                    connect: {
+                        uid: user.office_membership!.uid,
+                    }
+                },
+                contact: {
+                    create: {
+                        first_name: user.contact!.first_name,
+                        last_name: user.contact!.last_name,
+                        email: user.contact!.email,
+                        civility: ECivility[user.contact?.civility as keyof typeof ECivility],
+                    },
+                },
+                role: {
+                    connect: {
+                        uid: user.role!.uid,
+                    },
+                },
+            },
+        });
+        users.push(upsertUser);
+    }));
+
+    return users;
+
+	}
+
 	/**
 	 * @description : Update check date of a user
 	 */

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

@@ -2,12 +2,13 @@ import BaseService from "@Services/BaseService";
 import "reflect-metadata";
 import { Service } from "typedi";
 import UsersRepository from "@Repositories/UsersRepository";
-import User from "le-coffre-resources/dist/SuperAdmin";
+import User from "le-coffre-resources/dist/Admin";
 import { Prisma, Users } from "@prisma/client";
+import RolesService from "@Services/admin/RolesService/RolesService";
 
 @Service()
 export default class UsersService extends BaseService {
-	constructor(private userRepository: UsersRepository) {
+	constructor(private userRepository: UsersRepository, private rolesService: RolesService) {
 		super();
 	}
 
@@ -91,4 +92,43 @@ export default class UsersService extends BaseService {
 		return this.userRepository.findManyToCheck();
 	}
 
+	public async getOrCreateUsers(officeId: string, usersToCreate: [{}]) {
+		let users : User[] = [];
+		const roleNotary = await this.rolesService.get({ where: { name: "notary" } });
+		
+		usersToCreate.forEach((user: any) => {
+			const userEntity: User = {
+				idNot: user.uid,
+				contact: {
+					first_name: user.prenom,
+					last_name: user.nomUsuel,
+					civility: user.civilite,
+					email: "",
+					created_at: new Date(), 
+					updated_at: new Date(), 
+				},
+				office_membership: {
+					uid: officeId,
+					name: "",
+					crpcen: "", 
+					created_at: new Date(), 
+					updated_at: new Date(), 
+				},
+				role: {
+					uid: roleNotary[0]?.uid,
+					name: "",
+					label: "",
+					created_at: new Date(), 
+					updated_at: new Date(), 
+				},
+				created_at: new Date(), 
+				updated_at: new Date(), 
+			};
+			users.push(userEntity);
+		});
+
+		return await this.userRepository.getOrCreate(users);
+	}
+
+
 }

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

@@ -6,10 +6,11 @@ import { PrismaClient } from "@prisma/client";
 import { user, userContact, userContact_, user_ } from "@Test/config/MockedData";
 import UsersRepository from "@Repositories/UsersRepository";
 import Container from "typedi";
+import RolesService from "@Services/admin/RolesService/RolesService";
 
 const prisma = new PrismaClient();
 
-const UsersServiceTest = new UsersService(Container.get(UsersRepository));
+const UsersServiceTest = new UsersService(Container.get(UsersRepository), Container.get(RolesService));
 
 afterAll(async () => {
 	/*