Merge branch 'dev' into feature/integrate-anchoring

next.config.js

@@ -13,6 +13,7 @@ const nextConfig = {
 		NEXT_PUBLIC_IDNOT_AUTHORIZE_ENDPOINT: process.env.NEXT_PUBLIC_IDNOT_AUTHORIZE_ENDPOINT,
 		NEXT_PUBLIC_IDNOT_CLIENT_ID: process.env.NEXT_PUBLIC_IDNOT_CLIENT_ID,
 		NEXT_PUBLIC_IDNOT_BASE_URL: process.env.NEXT_PUBLIC_IDNOT_BASE_URL,
+		NEXT_PUBLIC_DOCAPOSTE_API_URL: process.env.NEXT_PUBLIC_DOCAPOSTE_API_URL,
 	},
 	// webpack: config => {
 	// 	config.node = {

package.json

@@ -24,7 +24,7 @@
 		"eslint-config-next": "13.2.4",
 		"form-data": "^4.0.0",
 		"jwt-decode": "^3.1.2",
-		"le-coffre-resources": "git@github.com:smart-chain-fr/leCoffre-resources.git#v2.77",
+		"le-coffre-resources": "git@github.com:smart-chain-fr/leCoffre-resources.git#v2.82",
 		"next": "13.2.4",
 		"prettier": "^2.8.7",
 		"react": "18.2.0",

src/common/Api/LeCoffreApi/Admin/BaseAdmin.ts

@@ -0,0 +1,5 @@
+import BaseApiService from "@Front/Api/BaseApiService";
+
+export default abstract class BaseAdmin extends BaseApiService {
+	protected readonly namespaceUrl = this.getBaseUrl().concat("/admin");
+}

src/common/Api/LeCoffreApi/Admin/DeedTypes/DeedTypes.ts

@@ -0,0 +1,94 @@
+import { DeedType } from "le-coffre-resources/dist/Admin";
+
+import BaseAdmin from "../BaseAdmin";
+
+export type IPutDeedTypesParams = {
+	uid?: DeedType["uid"];
+	name?: DeedType["name"];
+	description?: DeedType["description"];
+	deed?: DeedType["deed"];
+	office?: DeedType["office"];
+	archived_at?: DeedType["archived_at"];
+	document_types?: DeedType["document_types"];
+};
+
+export type IPostDeedTypesParams = {
+	name?: DeedType["name"];
+	description?: DeedType["description"];
+};
+
+export type IGetDeedTypesParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export default class DeedTypes extends BaseAdmin {
+	private static instance: DeedTypes;
+	private readonly baseURl = this.namespaceUrl.concat("/deed-types");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new DeedTypes();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDeedTypesParams): Promise<DeedType[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DeedType[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<DeedType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DeedType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDeedTypesParams) {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<DeedType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async post(body: IPostDeedTypesParams) {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<DeedType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async delete(uid: string) {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.deleteRequest<DeedType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/Deeds/Deeds.ts

@@ -0,0 +1,49 @@
+import { Deed } from "le-coffre-resources/dist/Admin";
+
+import BaseAdmin from "../BaseAdmin";
+
+export type IGetDeedsParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export default class Deeds extends BaseAdmin {
+	private static instance: Deeds;
+	private readonly baseURl = this.namespaceUrl.concat("/deeds");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new Deeds();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDeedsParams): Promise<Deed[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Deed[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Deed> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Deed>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/DocumentTypes/DocumentTypes.ts

@@ -0,0 +1,86 @@
+import { DocumentType } from "le-coffre-resources/dist/Admin";
+
+import BaseAdmin from "../BaseAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentTypesparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentTypesParams = {};
+
+export interface IPostDocumentTypesParams {
+	name: string;
+	public_description: string;
+	private_description: string;
+	office: {
+		uid: string;
+	};
+}
+
+export default class DocumentTypes extends BaseAdmin {
+	private static instance: DocumentTypes;
+	private readonly baseURl = this.namespaceUrl.concat("/document-types");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDocumentTypesparams): Promise<DocumentType[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DocumentType[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: DocumentType): Promise<DocumentType> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<DocumentType>(url, body as any);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<DocumentType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DocumentType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentTypesParams): Promise<DocumentType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<DocumentType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/Documents/Documents.ts

@@ -0,0 +1,93 @@
+import { EDocumentStatus } from "le-coffre-resources/dist/Customer/Document";
+import { Document } from "le-coffre-resources/dist/SuperAdmin";
+
+import BaseAdmin from "../BaseAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentsparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentsParams = {
+	document_status?: EDocumentStatus;
+	refused_reason?: string;
+};
+
+export interface IPostDocumentsParams {}
+
+export default class Documents extends BaseAdmin {
+	private static instance: Documents;
+	private readonly baseURl = this.namespaceUrl.concat("/documents");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDocumentsparams): Promise<Document[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: any): Promise<Document> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentsParams): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async delete(uid: string): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.deleteRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/OfficeRoles/OfficeRoles.ts

@@ -0,0 +1,81 @@
+import { OfficeRole } from "le-coffre-resources/dist/Admin";
+
+import BaseAdmin from "../BaseAdmin";
+
+export type IGetRolesParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export type IPutRoleParams = {
+	uid: OfficeRole["uid"];
+	rules: OfficeRole["rules"];
+};
+
+export type IPostRoleParams = {
+	name: OfficeRole["name"];
+	office: OfficeRole["office"];
+};
+
+export default class OfficeRoles extends BaseAdmin {
+	private static instance: OfficeRoles;
+	private readonly baseURl = this.namespaceUrl.concat("/office-roles");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new OfficeRoles();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetRolesParams): Promise<OfficeRole[]> {
+		const url = new URL(this.baseURl);
+		if (q) {
+			const query = { q };
+			Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			return await this.getRequest<OfficeRole[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<OfficeRole> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeRole>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutRoleParams): Promise<OfficeRole> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<OfficeRole>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async post(body: IPostRoleParams) {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<OfficeRole>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/Roles/Roles.ts

@@ -0,0 +1,96 @@
+import { Role } from "le-coffre-resources/dist/Admin";
+
+import BaseAdmin from "../BaseAdmin";
+
+export type IGetRolesParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export type IPutRoleParams = {
+	uid: Role["uid"];
+	rules: Role["rules"];
+};
+
+export type IPostRoleParams = {
+	name: Role["name"];
+};
+export default class Roles extends BaseAdmin {
+	private static instance: Roles;
+	private readonly baseURl = this.namespaceUrl.concat("/roles");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new Roles();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetRolesParams): Promise<Role[]> {
+		const url = new URL(this.baseURl);
+		if (q) {
+			const query = { q };
+			Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			return await this.getRequest<Role[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async post(body: IPostRoleParams) {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Role>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getOne(q?: IGetRolesParams): Promise<Role | null> {
+		const url = new URL(this.baseURl);
+		if (q) {
+			const query = { q };
+			Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			const res = await this.getRequest<Role[]>(url);
+			if (!res) return null;
+			if (res.length > 1) throw new Error("More than one role found");
+			return res[0] ? res[0] : null;
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Role> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Role>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutRoleParams): Promise<Role> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Role>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/Rules/Rules.ts

@@ -0,0 +1,49 @@
+import { Rule } from "le-coffre-resources/dist/Admin";
+
+import BaseAdmin from "../BaseAdmin";
+
+export type IGetRulesParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export default class Rules extends BaseAdmin {
+	private static instance: Rules;
+	private readonly baseURl = this.namespaceUrl.concat("/rules");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new Rules();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetRulesParams): Promise<Rule[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Rule[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Rule> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Rule>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Admin/Users/Users.ts

@@ -0,0 +1,91 @@
+import User from "le-coffre-resources/dist/SuperAdmin";
+import BaseAdmin from "../BaseAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetUsersparams {
+	where?: {};
+	include?: {};
+	select?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutUsersParams = {
+	uid?: User["uid"];
+	idNot?: User["idNot"];
+	contact?: User["contact"];
+	office_membership?: User["office_membership"];
+	documents?: User["documents"];
+};
+
+export default class Users extends BaseAdmin {
+	private static instance: Users;
+	private readonly baseURl = this.namespaceUrl.concat("/users");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all Users
+	 */
+	public async get(q: IGetUsersparams): Promise<User[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<User[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<User> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<User>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a User
+	 */
+	// public async post(body: IPostDeedsParams): Promise<OfficeFolder> {
+	// 	const url = new URL(this.baseURl);
+	// 	try {
+	// 		return await this.postRequest<OfficeFolder>(url, body);
+	// 	} catch (err) {
+	// 		this.onError(err);
+	// 		return Promise.reject(err);
+	// 	}
+	// }
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: IPutUsersParams): Promise<User> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<User>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Customer/BaseCustomer.ts

@@ -0,0 +1,5 @@
+import BaseApiService from "@Front/Api/BaseApiService";
+
+export default abstract class BaseNotary extends BaseApiService {
+	protected readonly namespaceUrl = this.getBaseUrl().concat("/customer");
+}

src/common/Api/LeCoffreApi/Customer/Customers/Customers.ts

@@ -0,0 +1,67 @@
+import Customer, { Contact } from "le-coffre-resources/dist/Customer";
+
+import BaseCustomer from "../BaseCustomer";
+import { ECivility } from "le-coffre-resources/dist/Customer/Contact";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetCustomersparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutCustomersParams = {
+	uid?: Customer["uid"];
+	contact?: Customer["contact"];
+};
+
+export interface IPostCustomersParams {
+	first_name: string;
+	last_name: string;
+	email: string;
+	cell_phone_number: string;
+	civility: ECivility;
+	address?: Contact["address"];
+}
+
+export default class Customers extends BaseCustomer {
+	private static instance: Customers;
+	private readonly baseURl = this.namespaceUrl.concat("/customers");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetCustomersparams): Promise<Customer[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Customer[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Customer> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Customer>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Customer/Documents/Documents.ts

@@ -0,0 +1,93 @@
+import { Document } from "le-coffre-resources/dist/Customer";
+
+import BaseCustomer from "../BaseCustomer";
+import { EDocumentStatus } from "le-coffre-resources/dist/Customer/Document";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentsparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentsParams = {
+	document_status?: EDocumentStatus;
+	refused_reason?: string;
+};
+
+export interface IPostDocumentsParams {}
+
+export default class Documents extends BaseCustomer {
+	private static instance: Documents;
+	private readonly baseURl = this.namespaceUrl.concat("/documents");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDocumentsparams): Promise<Document[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: any): Promise<Document> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentsParams): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async delete(uid: string): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.deleteRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Customer/Files/Files.ts

@@ -0,0 +1,93 @@
+import { File } from "le-coffre-resources/dist/Customer";
+import BaseCustomer from "../BaseCustomer";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetFilesparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutFilesParams = {};
+
+export interface IPostFilesParams {}
+
+export default class Files extends BaseCustomer {
+	private static instance: Files;
+	private readonly baseURl = this.namespaceUrl.concat("/files");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		return (this.instance ??= new this());
+	}
+
+	public async get(q: IGetFilesparams): Promise<File[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			const files = await this.getRequest<File[]>(url);
+			return files;
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a File
+	 */
+	public async post(body: any): Promise<File> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequestFormData<File>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public getUploadLink(uid: string): string {
+		return this.baseURl.concat(`/download/${uid}`);
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<File> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			const file = await this.getRequest<File>(url);
+			return file;
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutFilesParams): Promise<File> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<File>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Delete a folder only if the folder don't contains customers
+	 */
+	public async delete(uid: string): Promise<File> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.deleteRequest<File>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Customer/Folders/Folders.ts

@@ -0,0 +1,57 @@
+import { type OfficeFolder } from "le-coffre-resources/dist/Customer";
+
+import BaseCustomer from "../BaseCustomer";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetFoldersParams {
+	q?: {
+		select?: {};
+		where?: {};
+		include?: {};
+	};
+}
+
+export default class Folders extends BaseCustomer {
+	private static instance: Folders;
+	private readonly baseURl = this.namespaceUrl.concat("/folders");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all folders
+	 */
+	public async get(q: IGetFoldersParams): Promise<OfficeFolder[]> {
+		const url = new URL(this.baseURl);
+		Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeFolder[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeFolder>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Customer/Users/Users.ts

@@ -0,0 +1,49 @@
+import BaseNotary from "../BaseCustomer";
+import User from "le-coffre-resources/dist/Notary";
+
+export default class Users extends BaseNotary {
+	private static instance: Users;
+	private readonly baseURl = this.namespaceUrl.concat("/Users");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new Users();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(): Promise<User[]> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.getRequest<User[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getOne(uid: string): Promise<User> {
+		const url = new URL(this.baseURl.concat("/").concat(uid));
+		try {
+			return await this.getRequest<User>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	// public async post(params: User): Promise<User> {
+	// 	const url = new URL(this.baseURl);
+	// 	try {
+	// 		return await this.postRequest<User>(url, params);
+	// 	} catch (err) {
+	// 		this.onError(err);
+	// 		return Promise.reject(err);
+	// 	}
+	// }
+}

src/common/Api/LeCoffreApi/Notary/BaseNotary.ts

@@ -0,0 +1,5 @@
+import BaseApiService from "@Front/Api/BaseApiService";
+
+export default abstract class BaseNotary extends BaseApiService {
+	protected readonly namespaceUrl = this.getBaseUrl().concat("/notary");
+}

src/common/Api/LeCoffreApi/Notary/Customers/Customers.ts

@@ -0,0 +1,90 @@
+import { Contact, Customer } from "le-coffre-resources/dist/Notary";
+
+import BaseNotary from "../BaseNotary";
+import { ECivility } from "le-coffre-resources/dist/Customer/Contact";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetCustomersparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutCustomersParams = {
+	uid?: Customer["uid"];
+	contact?: Customer["contact"];
+};
+
+export interface IPostCustomersParams {
+	first_name: string;
+	last_name: string;
+	email: string;
+	cell_phone_number: string;
+	civility: ECivility;
+	address?: Contact["address"];
+}
+
+export default class Customers extends BaseNotary {
+	private static instance: Customers;
+	private readonly baseURl = this.namespaceUrl.concat("/customers");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetCustomersparams): Promise<Customer[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Customer[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Customer
+	 */
+	public async post(body: any): Promise<Customer> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Customer>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Customer> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Customer>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutCustomersParams): Promise<Customer> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Customer>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Notary/DeedTypes/DeedTypes.ts

@@ -0,0 +1,84 @@
+import { DeedType } from "le-coffre-resources/dist/Notary";
+
+import BaseNotary from "../BaseNotary";
+
+export type IPutDeedTypesParams = {
+	uid?: DeedType["uid"];
+	name?: DeedType["name"];
+	description?: DeedType["description"];
+	deed?: DeedType["deed"];
+	office?: DeedType["office"];
+	archived_at?: DeedType["archived_at"];
+	document_types?: DeedType["document_types"];
+};
+
+export type IPostDeedTypesParams = {
+	name?: DeedType["name"];
+	description?: DeedType["description"];
+};
+
+export type IGetDeedTypesParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export default class DeedTypes extends BaseNotary {
+	private static instance: DeedTypes;
+	private readonly baseURl = this.namespaceUrl.concat("/deed-types");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new DeedTypes();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetDeedTypesParams): Promise<DeedType[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DeedType[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<DeedType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DeedType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDeedTypesParams) {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<DeedType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async post(body: IPostDeedTypesParams) {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<DeedType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Notary/Deeds/Deeds.ts

@@ -0,0 +1,72 @@
+import { Deed, OfficeFolder } from "le-coffre-resources/dist/Notary";
+
+import BaseAdmin from "../BaseNotary";
+
+export type IGetDeedsParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export type IPutDeedsParams = {
+	uid?: OfficeFolder["uid"];
+	folder_number?: OfficeFolder["folder_number"];
+	name?: OfficeFolder["name"];
+	description?: OfficeFolder["description"];
+	archived_description?: OfficeFolder["archived_description"];
+	status?: OfficeFolder["status"];
+	document_types?: Deed["document_types"];
+};
+
+export default class Deeds extends BaseAdmin {
+	private static instance: Deeds;
+	private readonly baseURl = this.namespaceUrl.concat("/deeds");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new Deeds();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDeedsParams): Promise<Deed[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Deed[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Deed> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Deed>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: IPutDeedsParams): Promise<Deed> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Deed>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Notary/DocumentTypes/DocumentTypes.ts

@@ -0,0 +1,86 @@
+import { DocumentType } from "le-coffre-resources/dist/Notary";
+
+import BaseNotary from "../BaseNotary";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentTypesparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentTypesParams = {};
+
+export interface IPostDocumentTypesParams {
+	name: string;
+	public_description: string;
+	private_description: string | null;
+	office?: {
+		uid?: string;
+	};
+}
+
+export default class DocumentTypes extends BaseNotary {
+	private static instance: DocumentTypes;
+	private readonly baseURl = this.namespaceUrl.concat("/document-types");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDocumentTypesparams): Promise<DocumentType[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DocumentType[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: IPostDocumentTypesParams): Promise<DocumentType> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<DocumentType>(url, body as any);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<DocumentType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DocumentType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentTypesParams): Promise<DocumentType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<DocumentType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Notary/Documents/Documents.ts

@@ -0,0 +1,93 @@
+import { EDocumentStatus } from "le-coffre-resources/dist/Customer/Document";
+import { Document } from "le-coffre-resources/dist/Notary";
+
+import BaseNotary from "../BaseNotary";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentsparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentsParams = {
+	document_status?: EDocumentStatus;
+	refused_reason?: string;
+};
+
+export interface IPostDocumentsParams {}
+
+export default class Documents extends BaseNotary {
+	private static instance: Documents;
+	private readonly baseURl = this.namespaceUrl.concat("/documents");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDocumentsparams): Promise<Document[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: any): Promise<Document> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentsParams): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async delete(uid: string): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.deleteRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Notary/Folders/Folders.ts

@@ -0,0 +1,119 @@
+import { type OfficeFolder } from "le-coffre-resources/dist/Notary";
+
+import BaseNotary from "../BaseNotary";
+import EFolderStatus from "le-coffre-resources/dist/Customer/EFolderStatus";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetFoldersParams {
+	q?: {
+		select?: {};
+		where?: {};
+		include?: {};
+	};
+}
+
+export default class Folders extends BaseNotary {
+	private static instance: Folders;
+	private readonly baseURl = this.namespaceUrl.concat("/folders");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all folders
+	 */
+	public async get(q: IGetFoldersParams): Promise<OfficeFolder[]> {
+		const url = new URL(this.baseURl);
+		Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeFolder[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeFolder>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a folder
+	 */
+	public async post(officeFolder: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest(url, officeFolder);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Delete a folder only if the folder don't contains customers
+	 */
+	public async delete(uid: string): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const targetedFolder = await this.getByUid(uid);
+		if (targetedFolder.customers) return Promise.reject(`The folder ${uid} contains customers`);
+		try {
+			return await this.deleteRequest(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async archive(uid: string, body: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		body.status = EFolderStatus.ARCHIVED;
+		try {
+			return await this.put(uid, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async restore(uid: string, body: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		body.status = EFolderStatus.LIVE;
+		try {
+			return await this.put(uid, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/Notary/Users/Users.ts

@@ -0,0 +1,48 @@
+import BaseNotary from "../BaseNotary";
+import User from "le-coffre-resources/dist/Notary";
+
+export type IGetUsersParams = {
+	where?: {};
+	include?: {};
+	select?: {};
+};
+
+export default class Users extends BaseNotary {
+	private static instance: Users;
+	private readonly baseURl = this.namespaceUrl.concat("/users");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new Users();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetUsersParams): Promise<User[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<User[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<User> {
+		const url = new URL(this.baseURl.concat("/").concat(uid));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<User>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/BaseSuperAdmin.ts

@@ -0,0 +1,5 @@
+import BaseApiService from "@Front/Api/BaseApiService";
+
+export default abstract class BaseSuperAdmin extends BaseApiService {
+	protected readonly namespaceUrl = this.getBaseUrl().concat("/super-admin");
+}

src/common/Api/LeCoffreApi/SuperAdmin/Customers/Customers.ts

@@ -0,0 +1,90 @@
+import { Contact, Customer } from "le-coffre-resources/dist/SuperAdmin";
+
+import BaseSuperAdmin from "../BaseSuperAdmin";
+import { ECivility } from "le-coffre-resources/dist/Customer/Contact";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetCustomersparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutCustomersParams = {
+	uid?: Customer["uid"];
+	contact?: Customer["contact"];
+};
+
+export interface IPostCustomersParams {
+	first_name: string;
+	last_name: string;
+	email: string;
+	cell_phone_number: string;
+	civility: ECivility;
+	address?: Contact["address"];
+}
+
+export default class Customers extends BaseSuperAdmin {
+	private static instance: Customers;
+	private readonly baseURl = this.namespaceUrl.concat("/customers");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetCustomersparams): Promise<Customer[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Customer[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Customer
+	 */
+	public async post(body: any): Promise<Customer> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Customer>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Customer> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Customer>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutCustomersParams): Promise<Customer> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Customer>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/DeedTypes/DeedTypes.ts

@@ -0,0 +1,92 @@
+import { DeedType } from "le-coffre-resources/dist/Notary";
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDeedTypesParams {
+	q?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDeedTypesParams = {
+	uid?: DeedType["uid"];
+	name?: DeedType["name"];
+	description?: DeedType["description"];
+	deed?: DeedType["deed"];
+	office?: DeedType["office"];
+	archived_at?: DeedType["archived_at"];
+	document_types?: DeedType["document_types"];
+};
+
+export default class DeedTypes extends BaseSuperAdmin {
+	private static instance: DeedTypes;
+	private readonly baseURl = this.namespaceUrl.concat("/deed-types");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all DeedTypes
+	 */
+	public async get(q?: IGetDeedTypesParams): Promise<DeedType[]> {
+		const url = new URL(this.baseURl);
+		if(q){
+			Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			return await this.getRequest<DeedType[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<DeedType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DeedType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a deed
+	 */
+	// public async post(body: IPostDeedTypesParams): Promise<OfficeFolder> {
+	// 	const url = new URL(this.baseURl);
+	// 	try {
+	// 		return await this.postRequest<OfficeFolder>(url, body);
+	// 	} catch (err) {
+	// 		this.onError(err);
+	// 		return Promise.reject(err);
+	// 	}
+	// }
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: IPutDeedTypesParams): Promise<DeedType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<DeedType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Deeds/Deeds.ts

@@ -0,0 +1,90 @@
+import { Deed, OfficeFolder } from "le-coffre-resources/dist/Notary";
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDeedsParams {
+	q?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDeedsParams = {
+	uid?: OfficeFolder["uid"];
+	folder_number?: OfficeFolder["folder_number"];
+	name?: OfficeFolder["name"];
+	description?: OfficeFolder["description"];
+	archived_description?: OfficeFolder["archived_description"];
+	status?: OfficeFolder["status"];
+	document_types?: Deed["document_types"];
+};
+
+export default class Deeds extends BaseSuperAdmin {
+	private static instance: Deeds;
+	private readonly baseURl = this.namespaceUrl.concat("/deeds");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all deeds
+	 */
+	public async get(q: IGetDeedsParams): Promise<Deed[]> {
+		const url = new URL(this.baseURl);
+		Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Deed[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<Deed> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Deed>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a deed
+	 */
+	// public async post(body: IPostDeedsParams): Promise<OfficeFolder> {
+	// 	const url = new URL(this.baseURl);
+	// 	try {
+	// 		return await this.postRequest<OfficeFolder>(url, body);
+	// 	} catch (err) {
+	// 		this.onError(err);
+	// 		return Promise.reject(err);
+	// 	}
+	// }
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: IPutDeedsParams): Promise<Deed> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Deed>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/DocumentTypes/DocumentTypes.ts

@@ -0,0 +1,88 @@
+import { DocumentType } from "le-coffre-resources/dist/SuperAdmin";
+
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentTypesparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentTypesParams = {};
+
+export interface IPostDocumentTypesParams {
+	name: string;
+	public_description: string;
+	private_description: string;
+	office: {
+		uid: string;
+	};
+}
+
+export default class DocumentTypes extends BaseSuperAdmin {
+	private static instance: DocumentTypes;
+	private readonly baseURl = this.namespaceUrl.concat("/document-types");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetDocumentTypesparams): Promise<DocumentType[]> {
+		const url = new URL(this.baseURl);
+		if (q) {
+			const query = { q };
+			if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			return await this.getRequest<DocumentType[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: IPostDocumentTypesParams): Promise<DocumentType> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<DocumentType>(url, body as any);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<DocumentType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<DocumentType>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentTypesParams): Promise<DocumentType> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<DocumentType>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Documents/Documents.ts

@@ -0,0 +1,93 @@
+import { Document } from "le-coffre-resources/dist/SuperAdmin";
+
+import BaseSuperAdmin from "../BaseSuperAdmin";
+import { EDocumentStatus } from "le-coffre-resources/dist/Customer/Document";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetDocumentsparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutDocumentsParams = {
+	document_status?: EDocumentStatus;
+	refused_reason?: string;
+};
+
+export interface IPostDocumentsParams {}
+
+export default class Documents extends BaseSuperAdmin {
+	private static instance: Documents;
+	private readonly baseURl = this.namespaceUrl.concat("/documents");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q: IGetDocumentsparams): Promise<Document[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a Document
+	 */
+	public async post(body: any): Promise<Document> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutDocumentsParams): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<Document>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async delete(uid: string): Promise<Document> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.deleteRequest<Document>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Files/Files.ts

@@ -0,0 +1,93 @@
+import { File } from "le-coffre-resources/dist/SuperAdmin";
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetFilesparams {
+	where?: {};
+	include?: {};
+}
+
+// TODO Type getbyuid query params
+
+export type IPutFilesParams = {};
+
+export interface IPostFilesParams {}
+
+export default class Files extends BaseSuperAdmin {
+	private static instance: Files;
+	private readonly baseURl = this.namespaceUrl.concat("/files");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		return (this.instance ??= new this());
+	}
+
+	public async get(q: IGetFilesparams): Promise<File[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			const files = await this.getRequest<File[]>(url);
+			return files;
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a File
+	 */
+	public async post(body: any): Promise<File> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequestFormData<File>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public getUploadLink(uid: string): string {
+		return this.baseURl.concat(`/download/${uid}`);
+	}
+
+	public async getByUid(uid: string, q?: any): Promise<File> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const query = { q };
+		if (q) Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			const file = await this.getRequest<File>(url);
+			return file;
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutFilesParams): Promise<File> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<File>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Delete a folder only if the folder don't contains customers
+	 */
+	public async delete(uid: string): Promise<File> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.deleteRequest<File>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Folders/Folders.ts

@@ -0,0 +1,119 @@
+import { type OfficeFolder } from "le-coffre-resources/dist/Notary";
+
+import BaseSuperAdmin from "../BaseSuperAdmin";
+import EFolderStatus from "le-coffre-resources/dist/Customer/EFolderStatus";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetFoldersParams {
+	q?: {
+		select?: {};
+		where?: {};
+		include?: {};
+	};
+}
+
+export default class Folders extends BaseSuperAdmin {
+	private static instance: Folders;
+	private readonly baseURl = this.namespaceUrl.concat("/folders");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all folders
+	 */
+	public async get(q: IGetFoldersParams): Promise<OfficeFolder[]> {
+		const url = new URL(this.baseURl);
+		Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeFolder[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<OfficeFolder>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a folder
+	 */
+	public async post(officeFolder: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest(url, officeFolder);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Delete a folder only if the folder don't contains customers
+	 */
+	public async delete(uid: string): Promise<OfficeFolder> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		const targetedFolder = await this.getByUid(uid);
+		if (targetedFolder.customers) return Promise.reject(`The folder ${uid} contains customers`);
+		try {
+			return await this.deleteRequest(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async archive(uid: string, body: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		body.status = EFolderStatus.ARCHIVED;
+		try {
+			return await this.put(uid, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async restore(uid: string, body: Partial<OfficeFolder>): Promise<OfficeFolder> {
+		body.status = EFolderStatus.LIVE;
+		try {
+			return await this.put(uid, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/LiveVotes/LiveVotes.ts

@@ -0,0 +1,49 @@
+import { Appointment } from "le-coffre-resources/dist/SuperAdmin";
+
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetLiveVotessparams {
+	where?: {};
+	include?: {};
+	select?: {};
+}
+
+export type IPostLiveVotesParams = {
+	appointment: Appointment;
+};
+
+export type LiveVote = {
+	uid: string;
+	appointment: Appointment;
+};
+
+export default class LiveVotes extends BaseSuperAdmin {
+	private static instance: LiveVotes;
+	private readonly baseURl = this.namespaceUrl.concat("/live-votes");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Create a LiveVotes
+	 */
+	public async post(body: IPostLiveVotesParams): Promise<LiveVote> {
+		const url = new URL(this.baseURl);
+		try {
+			return await this.postRequest<LiveVote>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Offices/Offices.ts

@@ -0,0 +1,53 @@
+import { Office } from "le-coffre-resources/dist/SuperAdmin";
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+export interface IGetOfficesparams {
+	where?: {};
+	include?: {};
+	select?: {};
+}
+
+export default class Offices extends BaseSuperAdmin {
+	private static instance: Offices;
+	private readonly baseURl = this.namespaceUrl.concat("/offices");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetOfficesparams): Promise<Office[]> {
+		const url = new URL(this.baseURl);
+		if (q) {
+			const query = { q };
+			Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			return await this.getRequest<Office[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<Office> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<Office>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Users/Users.ts

@@ -0,0 +1,91 @@
+import User from "le-coffre-resources/dist/SuperAdmin";
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetUsersparams {
+	where?:{},
+	include?:{},
+	select?:{},
+}
+
+// TODO Type getbyuid query params
+
+export type IPutUsersParams = {
+	uid?: User["uid"];
+	idNot?: User["idNot"];
+	contact?: User["contact"];
+	office_membership?: User["office_membership"];
+	documents?: User["documents"];
+};
+
+export default class Users extends BaseSuperAdmin {
+	private static instance: Users;
+	private readonly baseURl = this.namespaceUrl.concat("/users");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Get all Users
+	 */
+	public async get(q: IGetUsersparams): Promise<User[]> {
+		const url = new URL(this.baseURl);
+		const query = { q };
+		Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<User[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Get a folder by uid
+	 */
+	public async getByUid(uid: string, q?: any): Promise<User> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		if (q) Object.entries(q).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		try {
+			return await this.getRequest<User>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * @description : Create a User
+	 */
+	// public async post(body: IPostDeedsParams): Promise<OfficeFolder> {
+	// 	const url = new URL(this.baseURl);
+	// 	try {
+	// 		return await this.postRequest<OfficeFolder>(url, body);
+	// 	} catch (err) {
+	// 		this.onError(err);
+	// 		return Promise.reject(err);
+	// 	}
+	// }
+
+	/**
+	 * @description : Update the folder description
+	 */
+	public async put(uid: string, body: IPutUsersParams): Promise<User> {
+		const url = new URL(this.baseURl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<User>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/common/Api/LeCoffreApi/SuperAdmin/Votes/Votes.ts

@@ -0,0 +1,44 @@
+import { Vote } from "le-coffre-resources/dist/SuperAdmin";
+
+import BaseSuperAdmin from "../BaseSuperAdmin";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetVotessparams {
+	where?: {};
+	include?: {};
+	select?: {};
+}
+
+export type IDeleteVotesParams = {
+	uid: Vote["uid"];
+};
+
+export default class Votes extends BaseSuperAdmin {
+	private static instance: Votes;
+	private readonly baseURl = this.namespaceUrl.concat("/votes");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	/**
+	 * @description : Create a Votes
+	 */
+	public async delete(body: IDeleteVotesParams): Promise<Vote> {
+		const url = new URL(this.baseURl + "/" + body.uid);
+		try {
+			return await this.deleteRequest<Vote>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/front/Api/LeCoffreApi/Id360/BaseId360.ts

@@ -0,0 +1,5 @@
+import BaseApiService from "@Front/Api/BaseApiService";
+
+export default abstract class BaseNotary extends BaseApiService {
+	protected readonly namespaceUrl = this.getBaseUrl().concat("/id360");
+}

src/front/Api/LeCoffreApi/Id360/Customers/Customers.ts

@@ -0,0 +1,45 @@
+import BaseId360 from "../BaseId360";
+
+export interface IConnectionUrlResponse {
+	enrollment: {
+		franceConnectUrl: string;
+		processId: string;
+	}
+}
+
+export default class Customers extends BaseId360 {
+	private static instance: Customers;
+	private readonly baseURl = this.namespaceUrl.concat("/customers");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async login(): Promise<IConnectionUrlResponse> {
+		const url = new URL(this.baseURl.concat(`/login`));
+		try {
+			return await this.postRequest<IConnectionUrlResponse>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async loginCallback(callbackToken: string | string[]): Promise<any> {
+		const url = new URL(this.baseURl.concat(`/login-callback/${callbackToken}`));
+		try {
+			return await this.postRequest<any>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/front/Api/LeCoffreApi/Notifications/Notifications.ts

@@ -0,0 +1,54 @@
+import BaseApiService from "@Front/Api/BaseApiService";
+import { UserNotification } from "le-coffre-resources/dist/Notary";
+
+// TODO Type get query params -> Where + inclue + orderby
+export interface IGetNotificationsParams {
+	where?: {};
+	include?: {};
+	select?: {};
+}
+
+export type IPutNotificationsParams = {
+	read?: boolean;
+};
+
+export default class Notifications extends BaseApiService {
+	private static instance: Notifications;
+	private baseUrl = this.getBaseUrl().concat("/notifications");
+
+	private constructor() {
+		super();
+	}
+
+	public static getInstance() {
+		if (!this.instance) {
+			return new this();
+		} else {
+			return this.instance;
+		}
+	}
+
+	public async get(q?: IGetNotificationsParams): Promise<UserNotification[]> {
+		const url = new URL(this.baseUrl);
+		if (q) {
+			const query = { q };
+			Object.entries(query).forEach(([key, value]) => url.searchParams.set(key, JSON.stringify(value)));
+		}
+		try {
+			return await this.getRequest<UserNotification[]>(url);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+
+	public async put(uid: string, body: IPutNotificationsParams): Promise<UserNotification> {
+		const url = new URL(this.baseUrl.concat(`/${uid}`));
+		try {
+			return await this.putRequest<UserNotification>(url, body);
+		} catch (err) {
+			this.onError(err);
+			return Promise.reject(err);
+		}
+	}
+}

src/front/Assets/Icons/check.svg

@@ -1,3 +1,3 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<svg width="22" height="22" viewBox="0 0 22 22" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M13.2251 3.36088C13.4893 3.59571 13.5131 4.00024 13.2783 4.26442L6.4516 11.9444C6.33015 12.0811 6.15607 12.1592 5.97326 12.1592C5.79045 12.1592 5.61637 12.0811 5.49492 11.9444L2.08159 8.10442C1.84676 7.84024 1.87055 7.43571 2.13474 7.20088C2.39892 6.96606 2.80344 6.98985 3.03827 7.25403L5.97326 10.5559L12.3216 3.41403C12.5564 3.14985 12.9609 3.12606 13.2251 3.36088Z" fill="white"/>
+<path d="M18 6L8.375 16L4 11.4545" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>

src/front/Components/DesignSystem/Header/Navigation/index.tsx

@@ -1,16 +1,36 @@
 import Module from "@Front/Config/Module";
-import React from "react";
+import React, { useCallback, useEffect } from "react";
 
 import HeaderLink from "../HeaderLink";
 import classes from "./classes.module.scss";
 import Rules, { RulesMode } from "@Front/Components/Elements/Rules";
 import { AppRuleActions, AppRuleNames } from "@Front/Api/Entities/rule";
+import { usePathname } from "next/navigation";
+import Notifications from "@Front/Api/LeCoffreApi/Notifications/Notifications";
+import Toasts from "@Front/Stores/Toasts";
+export default function Navigation() {
+	const pathname = usePathname();
 
-type IProps = {};
+	const getNotifications = useCallback(async () => {
-type IState = {};
+		const notifications = await Notifications.getInstance().get({
+			where: {
+				read: false,
+			},
+		});
+		notifications.forEach((notification) => {
+			Toasts.getInstance().open({
+				title: notification.notification.message,
+				uid: notification.uid,
+				redirectUrl: notification.notification.redirection_url,
+			});
+		});
+		console.log(notifications);
+	}, []);
+
+	useEffect(() => {
+		getNotifications();
+	}, [pathname, getNotifications]);
 
-export default class Navigation extends React.Component<IProps, IState> {
-	public override render(): JSX.Element {
 	return (
 		<div className={classes["root"]}>
 			<HeaderLink
@@ -43,4 +63,3 @@ export default class Navigation extends React.Component<IProps, IState> {
 		</div>
 	);
 }
-}

src/front/Components/DesignSystem/Toasts/ToastsContainer/ToastElement/classes.module.scss

@@ -26,7 +26,7 @@
 	pointer-events: all;
 	position: relative;
 	padding: 24px;
-	background: $orange-soft;
+	background: var(--orange-soft);
 	box-shadow: 0px 6px 12px rgba(0, 0, 0, 0.11);
 	border-radius: 5px;
 
@@ -42,6 +42,13 @@
 		animation-fill-mode: forwards;
 	}
 
+	&[data-clickable="true"] {
+		cursor: pointer;
+		&:hover {
+			background: var(--orange-soft-hover);
+		}
+	}
+
 	.loadbar {
 		position: absolute;
 		top: 0;

src/front/Components/DesignSystem/Toasts/ToastsContainer/ToastElement/index.tsx

@@ -8,18 +8,25 @@ import React from "react";
 import classes from "./classes.module.scss";
 import Toasts, { IToast } from "@Front/Stores/Toasts";
 import Typography, { ITypo, ITypoColor } from "@Front/Components/DesignSystem/Typography";
+import CheckIcon from "@Assets/Icons/check.svg";
+import Image from "next/image";
+import { NextRouter, useRouter } from "next/router";
 
 type IProps = {
 	toast: IToast;
 };
 
+type IPropsClass = IProps & {
+	router: NextRouter;
+};
+
 type IState = {
 	willClose: boolean;
 };
 
-export default class ToastElement extends React.Component<IProps, IState> {
+class ToastElementClass extends React.Component<IPropsClass, IState> {
 	private closeTimeout = 0;
-	constructor(props: IProps) {
+	constructor(props: IPropsClass) {
 		super(props);
 
 		this.state = {
@@ -27,6 +34,7 @@ export default class ToastElement extends React.Component<IProps, IState> {
 		};
 
 		this.onClose = this.onClose.bind(this);
+		this.handleClick = this.handleClick.bind(this);
 	}
 
 	public override render(): JSX.Element {
@@ -35,7 +43,11 @@ export default class ToastElement extends React.Component<IProps, IState> {
 			"--data-duration": `${toast.time}ms`,
 		} as React.CSSProperties;
 		return (
-			<div className={classes["root"]} data-will-close={this.state.willClose}>
+			<div
+				className={classes["root"]}
+				data-will-close={this.state.willClose}
+				data-clickable={toast.redirectUrl ? true : false}
+				onClick={this.handleClick}>
 				{toast.time !== 0 && <div className={classes["loadbar"]} style={style} />}
 				<div className={classes["header"]}>
 					<div className={classes["text-icon_row"]}>
@@ -45,7 +57,7 @@ export default class ToastElement extends React.Component<IProps, IState> {
 							{this.getToastText(toast.text)}
 						</div>
 					</div>
-					{/* {toast.closable && <Cross className={classes["cross"]} onClick={this.onClose} />} */}
+					{toast.closable && <Image src={CheckIcon} alt="Document check" className={classes["cross"]} onClick={this.onClose} />}
 				</div>
 				{toast.button}
 			</div>
@@ -95,4 +107,16 @@ export default class ToastElement extends React.Component<IProps, IState> {
 			Toasts.getInstance().close(this.props.toast);
 		}, 200);
 	}
+
+	private handleClick(e: React.MouseEvent) {
+		if (this.props.toast.redirectUrl) {
+			this.props.router.push(this.props.toast.redirectUrl);
+			this.onClose(e);
+		}
+	}
+}
+
+export default function ToastElement(props: IProps) {
+	const router = useRouter();
+	return <ToastElementClass {...props} router={router} />;
 }

src/front/Components/Layouts/Folder/FolderInformation/index.tsx

@@ -174,7 +174,7 @@ class FolderInformationClass extends BasePage<IPropsClass, IState> {
 					header={
 						this.state.hasValidateAnchoring
 							? "Dossier en cours de certification"
-							: "Êtes-vous sûr de vouloir ancrer et certifier ?"
+							: "Êtes-vous sûr de vouloir ancrer et certifier ce dossier ?"
 					}
 					cancelText={"Annuler"}
 					confirmText={"Confirmer"}
@@ -182,8 +182,9 @@ class FolderInformationClass extends BasePage<IPropsClass, IState> {
 					<div className={classes["validate-document-container"]}>
 						{!this.state.hasValidateAnchoring && (
 							<Typography typo={ITypo.P_16} color={ITypoColor.BLACK} className={classes["validate-text"]}>
-								Afin de certifier les documents associés au dossier, cliquez sur “Ancrez et certifier” et les documents
+								Les documents du dossier seront certifiés sur la blockchain. Pensez à bien télécharger l'ensemble des
-								seront certifiés sur la blockchain.
+								documents du dossier ainsi que le fichier de preuve d'ancrage pour les mettre dans la GED de votre logiciel
+								de rédaction d'actes.
 							</Typography>
 						)}
 						{this.state.hasValidateAnchoring && (

src/front/Components/Layouts/Login/index.tsx

@@ -3,9 +3,6 @@ import idNoteLogo from "@Assets/Icons/id-note-logo.svg";
 import Button, { EButtonVariant } from "@Front/Components/DesignSystem/Button";
 import Typography, { ITypo } from "@Front/Components/DesignSystem/Typography";
 import DefaultDoubleSidePage from "@Front/Components/LayoutTemplates/DefaultDoubleSidePage";
-import Module from "@Front/Config/Module";
-import JwtService from "@Front/Services/JwtService/JwtService";
-import UserStore from "@Front/Stores/UserStore";
 import Image from "next/image";
 import { useRouter } from "next/router";
 import { useCallback } from "react";
@@ -26,20 +23,6 @@ export default function Login() {
 		);
 	}, [router]);
 
-	const redirectCustomerOnConnection = useCallback(() => {
-		async function getCustomer() {
-			try {
-				await UserStore.instance.connectCustomer("antoine.bernard@outlook.com");
-				await JwtService.getInstance().checkJwt();
-				router.push(Module.getInstance().get().modules.pages.Folder.pages.Select.props.path);
-			} catch (e) {
-				console.error(e);
-			}
-		}
-
-		getCustomer();
-	}, [router]);
-
 	return (
 		<DefaultDoubleSidePage title={"Login"} image={LandingImage}>
 			<div className={classes["root"]}>
@@ -48,10 +31,7 @@ export default function Login() {
 					<div className={classes["title"]}>Connexion espace professionnel</div>
 				</Typography>
 				<Button onClick={redirectUserOnConnection} icon={idNoteLogo} iconposition={"left"}>
-					S'identifier avec ID.not !
+					S'identifier avec ID.not
-				</Button>
-				<Button onClick={redirectCustomerOnConnection} icon={idNoteLogo} iconposition={"left"}>
-					S'identifier en tant que customer
 				</Button>
 				<Typography typo={ITypo.P_18}>
 					<div className={classes["forget-password"]}>Vous n'arrivez pas à vous connecter ?</div>

src/front/Components/Layouts/LoginCallbackCustomer/classes.module.scss

@@ -0,0 +1,29 @@
+@import "@Themes/constants.scss";
+
+.root {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	flex-direction: column;
+	height: 100%;
+	max-width: 530px;
+	margin: auto;
+
+	.title {
+		margin: 32px 0;
+		text-align: center;
+		@media (max-width: $screen-s) {
+			font-family: 48px;
+		}
+	}
+
+	.loader {
+		width: 32px;
+		height: 32px;
+	}
+
+	.forget-password {
+		margin-top: 32px;
+		margin-bottom: 8px;
+	}
+}

src/front/Components/Layouts/LoginCallbackCustomer/index.tsx

@@ -0,0 +1,55 @@
+import LandingImage from "../Login/landing-connect.jpeg";
+import Image from "next/image";
+import CoffreIcon from "@Assets/Icons/coffre.svg";
+import { useRouter } from "next/router";
+import React, { useEffect } from "react";
+import classes from "./classes.module.scss";
+//import Module from "@Front/Config/Module";
+//import Auth from "@Front/Api/Auth/IdNot";
+import DefaultDoubleSidePage from "@Front/Components/LayoutTemplates/DefaultDoubleSidePage";
+import Typography, { ITypo } from "@Front/Components/DesignSystem/Typography";
+import Button, { EButtonVariant } from "@Front/Components/DesignSystem/Button";
+import Loader from "@Front/Components/DesignSystem/Loader";
+// import { FrontendVariables } from "@Front/Config/VariablesFront";
+// import CustomerStore from "@Front/Stores/CustomerStore";
+import Customers from "@Front/Api/LeCoffreApi/Id360/Customers/Customers";
+import CustomerStore from "@Front/Stores/CustomerStore";
+import Module from "@Front/Config/Module";
+
+
+export default function LoginCallBack() {
+	const router = useRouter();
+
+	useEffect(() => {
+		const getReport = async() => {
+			const tokenid360 = router.query["token"];
+			if (!tokenid360) return;
+			// const variables = FrontendVariables.getInstance();
+			// console.log(`${variables.DOCAPOST_API_URL}/enrollment/status/${tokenid360}/`)
+			// const reportRes = await fetch(`${variables.DOCAPOST_API_URL}/enrollment/status/${tokenid360}`, { method: "GET"});
+			// const report = await reportRes.json() as id360ProcessResponse;
+			const token = await Customers.getInstance().loginCallback(tokenid360);
+			CustomerStore.instance.connect(token.accessToken, token.refreshToken);
+			router.push(Module.getInstance().get().modules.pages.Folder.pages.Select.props.path);
+		}
+		getReport();
+	}),[router];
+
+	return (
+		<DefaultDoubleSidePage title={"Login"} image={LandingImage}>
+			<div className={classes["root"]}>
+				<Image alt="coffre" src={CoffreIcon} />
+				<Typography typo={ITypo.H1}>
+					<div className={classes["title"]}>Connexion espace client</div>
+				</Typography>
+				<div className={classes["loader"]}>
+					<Loader />
+				</div>
+				<Typography typo={ITypo.P_18}>
+					<div className={classes["forget-password"]}>Vous n'arrivez pas à vous connecter ?</div>
+				</Typography>
+				<Button variant={EButtonVariant.LINE}>Contacter l'administrateur</Button>
+			</div>
+		</DefaultDoubleSidePage>
+	);
+}

src/front/Components/Layouts/LoginCustomer/classes.module.scss

@@ -1,35 +1,29 @@
+@import "@Themes/constants.scss";
+
 .root {
 	display: flex;
+	align-items: center;
 	justify-content: center;
 	flex-direction: column;
 	height: 100%;
+	max-width: 530px;
 	margin: auto;
-	max-width: 80%;
 
-	.text {
+	.title {
 		margin: 32px 0;
+		text-align: center;
 
+		@media (max-width: $screen-s) {
+			font-family: 48px;
+		}
 	}
 
-	.france-connect-button {
+	.forget-password {
+		margin-top: 32px;
+		margin-bottom: 8px;
+	}
+
+	.logo {
 		cursor: pointer;
 	}
-
-	.what-is-france-connect {
-		font-family: "Inter", sans-serif;
-		margin-top: 12px;
-		font-style: normal;
-		font-weight: 400;
-		font-size: 14px;
-		line-height: 24px;
-		border-bottom: 0.88px solid black;
-		width: fit-content;
-		display: flex;
-		align-items: center;
-		cursor: pointer;
-
-		div {
-			margin-right: 8px;
-		}
-	}
 }

src/front/Components/Layouts/LoginCustomer/index.tsx

@@ -1,50 +1,43 @@
+import CoffreIcon from "@Assets/Icons/coffre.svg";
+import franceConnectLogo from "./france-connect.svg";
+import Button, { EButtonVariant } from "@Front/Components/DesignSystem/Button";
 import Typography, { ITypo } from "@Front/Components/DesignSystem/Typography";
-import BasePage from "../Base";
-import classes from "./classes.module.scss";
-import LandingImage from "../Login/landing-connect.jpeg";
-import Image from "next/image";
 import DefaultDoubleSidePage from "@Front/Components/LayoutTemplates/DefaultDoubleSidePage";
-import FranceConnectIcon from "./france-connect.svg";
+import Image from "next/image";
-import ExportIcon from "@Assets/Icons/export.svg";
+import { useRouter } from "next/router";
-import { FrontendVariables } from "@Front/Config/VariablesFront";
+import { useCallback } from "react";
-import cryptoRandomString from "crypto-random-string";
+import Customers from "@Front/Api/LeCoffreApi/Id360/Customers/Customers";
+import classes from "./classes.module.scss";
+import LandingImage from "./landing-connect.jpeg";
+
+export default function Login() {
+	const router = useRouter();
+
+	const redirectCustomerOnConnection = useCallback(() => {
+		async function getCustomer() {
+			try {
+				const loginRes = await Customers.getInstance().login();
+				router.push(loginRes.enrollment.franceConnectUrl);
+			} catch (e) {
+				console.error(e);
+			}
+		}
+		getCustomer();
+	}, [router]);
 
-export default class LoginCustomer extends BasePage {
-	public override render(): JSX.Element {
 	return (
 		<DefaultDoubleSidePage title={"Login"} image={LandingImage}>
 			<div className={classes["root"]}>
+				<Image alt="coffre" src={CoffreIcon} />
 				<Typography typo={ITypo.H1}>
-						<div className={classes["title"]}>Identifiez-vous</div>
+					<div className={classes["title"]}>Connexion espace client</div>
 				</Typography>
-					<Typography typo={ITypo.P_16}>
+				<Image alt="france-connect" src={franceConnectLogo} onClick={redirectCustomerOnConnection} className={classes["logo"]} />
-						<div className={classes["text"]}>
+				<Typography typo={ITypo.P_18}>
-							Pour accéder à votre espace de dépôt des documents, veuillez vous identifier avec FranceConnect.
+					<div className={classes["forget-password"]}>Vous n'arrivez pas à vous connecter ?</div>
-						</div>
 				</Typography>
-					<Image
+				<Button variant={EButtonVariant.LINE}>Contacter l'administrateur</Button>
-						alt="france connect"
-						src={FranceConnectIcon}
-						onClick={this.redirectUserOnConnection}
-						className={classes["france-connect-button"]}></Image>
-					<div className={classes["what-is-france-connect"]}>
-						<div>Qu’est-ce que FranceConnect ?</div>
-						<Image alt="export" src={ExportIcon}></Image>
-					</div>
 			</div>
 		</DefaultDoubleSidePage>
 	);
 }
-
-	private redirectUserOnConnection() {
-		const variables = FrontendVariables.getInstance();
-		// const baseFronturl =
-		// 	variables.BACK_API_PROTOCOL + variables.FRONT_APP_HOST + (variables.FRONT_APP_PORT ? ":" + variables.FRONT_APP_PORT : "");
-		const authorizeEndPoint = variables.FC_AUTHORIZE_ENDPOINT;
-		const clientId = variables.FC_CLIENT_ID;
-		const url = `${authorizeEndPoint}?client_id=${clientId}&redirect_uri=http://localhost:8080/login-callback&scope=openid&response_type=code&state=${cryptoRandomString(
-			{ length: 64 },
-		)}&nonce=${cryptoRandomString({ length: 64 })}&acr_values=eidas1`;
-		window.location.assign(url);
-	}
-}

src/front/Config/VariablesFront.ts

@@ -17,6 +17,8 @@ export class FrontendVariables {
 
 	public IDNOT_CLIENT_ID!: string;
 
+	public DOCAPOST_API_URL!: string;
+
 	public KEY_DATA!: string;
 
 	public FC_AUTHORIZE_ENDPOINT!: string;

src/front/Stores/CustomerStore.ts

@@ -0,0 +1,77 @@
+"use client";
+
+import Customer from "@Front/Api/Auth/franceConnect/Customer";
+import CookieService from "@Front/Services/CookieService/CookieService";
+import EventEmitter from "@Front/Services/EventEmitter";
+import JwtService from "@Front/Services/JwtService/JwtService";
+
+export default class UserStore {
+	public static readonly instance = new this();
+	protected readonly event = new EventEmitter();
+	public accessToken: string | null = null;
+	public refreshToken: string | null = null;
+
+	private constructor() {}
+
+	public isConnected(): boolean {
+		return !!this.accessToken;
+	}
+
+	public getRole(): string | undefined {
+		const decodedPayload = JwtService.getInstance().decodeJwt();
+		return decodedPayload?.role;
+	}
+
+	public async connect(accessToken: string, refreshToken: string) {
+		try {
+			//Save tokens in cookies
+			CookieService.getInstance().setCookie("leCoffreAccessToken", accessToken);
+			CookieService.getInstance().setCookie("leCoffreRefreshToken", refreshToken);
+
+			this.event.emit("connection", this.accessToken);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+		return true;
+	}
+
+	public async connectCustomer(email: string) {
+		try {
+			//call connection function
+			const customer: any = await Customer.getInstance().login(email);
+
+			//Save tokens in cookies
+			CookieService.getInstance().setCookie("leCoffreAccessToken", customer.accessToken);
+			CookieService.getInstance().setCookie("leCoffreRefreshToken", customer.refreshToken);
+
+			this.event.emit("connection", this.accessToken);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+		return true;
+	}
+
+	public async disconnect() {
+		try {
+			//Remove tokens from cookies
+			CookieService.getInstance().deleteCookie("leCoffreAccessToken");
+			CookieService.getInstance().deleteCookie("leCoffreRefreshToken");
+
+			this.event.emit("disconnection", this.accessToken);
+		} catch (error) {
+			console.error(error);
+		}
+	}
+
+	public onDisconnect(callback: (userAddress: string) => void): () => void {
+		this.event.on("disconnection", callback);
+		return () => this.event.off("disconnection", callback);
+	}
+
+	public onConnect(callback: (userAddress: string) => void): () => void {
+		this.event.on("connection", callback);
+		return () => this.event.off("connection", callback);
+	}
+}

src/front/Stores/Toasts.tsx

@@ -1,3 +1,4 @@
+import Notifications from "@Front/Api/LeCoffreApi/Notifications/Notifications";
 import EventEmitter from "@Front/Services/EventEmitter";
 // import I18n from "Components/Elements/I18n";
 
@@ -7,6 +8,8 @@ export enum EToastPriority {
 }
 
 export interface IToast {
+	uid?: string;
+	redirectUrl?: string;
 	id?: number;
 	title: string | React.ReactNode;
 	icon?: React.ReactNode;
@@ -23,7 +26,7 @@ export default class Toasts {
 	private toastList: IToast[] = [];
 	private uid: number = 0;
 
-	private defaultTime: IToast["time"] = 10000;
+	private defaultTime: IToast["time"] = 0;
 	private defaultClosable: IToast["closable"] = true;
 	private defaultPriority: IToast["priority"] = EToastPriority.LOW;
 
@@ -49,6 +52,8 @@ export default class Toasts {
 	}
 
 	public open(toast: IToast): () => void {
+		const toastExists = this.toastList.find((t) => t.uid === toast.uid);
+		if (toastExists) return () => {};
 		const index = this.toastList.indexOf(toast);
 		if (index !== -1) return () => this.close(toast);
 
@@ -84,6 +89,11 @@ export default class Toasts {
 		const index = this.toastList.indexOf(toast);
 		if (index === -1) return;
 		this.toastList.splice(index, 1);
+
+		if (toast.uid)
+			Notifications.getInstance().put(toast.uid, {
+				read: true,
+			});
 		this.event.emit("change", this.toastList);
 	}
 

src/front/Themes/constants.scss

@@ -33,6 +33,7 @@ $orange-soft: #ffdc99;
 $red-soft: #f08771;
 $pink-soft: #f8b9df;
 
+$orange-soft-hover: #ffd078;
 $grey: #939393;
 $grey-medium: #e7e7e7;
 $grey-soft: #f9f9f9;

src/front/Themes/variables.scss

@@ -23,6 +23,7 @@
 	--turquoise-soft: #{$turquoise-soft};
 	--purple-soft: #{$purple-soft};
 	--orange-soft: #{$orange-soft};
+	--orange-soft-hover: #{$orange-soft-hover};
 	--red-soft: #{$red-soft};
 	--pink-soft: #{$pink-soft};
 

src/middleware.ts

@@ -17,8 +17,11 @@ export async function middleware(request: NextRequest) {
 
 	// If JWT expired, redirect to login page
 	const token = userDecodedToken ?? customerDecodedToken;
-	const now = Math.floor(Date.now() / 1000);
+	const currentDate = new Date();
+	const time = currentDate.getTime();
+	const now = Math.floor(time / 1000);
 	if (token.exp < now) {
+		console.log("token expired");
 		return NextResponse.redirect(new URL("/login", request.url));
 	}
 

src/pages/_app.tsx

@@ -22,6 +22,7 @@ type AppPropsWithLayout = AppProps & {
 	idNotClientId: string;
 	fcAuthorizeEndpoint: string;
 	fcClientId: string;
+	docaposteApiUrl: string;
 };
 
 const MyApp = (({
@@ -36,7 +37,8 @@ const MyApp = (({
 	idNotAuthorizeEndpoint,
 	idNotClientId,
 	fcAuthorizeEndpoint,
-	fcClientId
+	fcClientId,
+	docaposteApiUrl
 }: AppPropsWithLayout) => {
 	const getLayout = Component.getLayout ?? ((page) => <DefaultLayout children={page}></DefaultLayout>);
 
@@ -51,6 +53,7 @@ const MyApp = (({
 	instance.IDNOT_CLIENT_ID = idNotClientId ?? "4501646203F3EF67";
 	instance.FC_AUTHORIZE_ENDPOINT= fcAuthorizeEndpoint ?? "https://fcp.integ01.dev-franceconnect.fr/api/v1/authorize";
 	instance.FC_CLIENT_ID = fcClientId ?? "211286433e39cce01db448d80181bdfd005554b19cd51b3fe7943f6b3b86ab6e";
+	instance.DOCAPOST_API_URL = docaposteApiUrl;
 
 	return getLayout(<Component {...pageProps} />);
 }) as AppType;
@@ -67,7 +70,8 @@ MyApp.getInitialProps = async () => {
 		idNotAuthorizeEndpoint: process.env["NEXT_PUBLIC_IDNOT_AUTHORIZE_ENDPOINT"],
 		idNotClientId: process.env["NEXT_PUBLIC_IDNOT_CLIENT_ID"],
 		fcAuthorizeEndpoint: process.env["NEXT_PUBLIC_FC_AUTHORIZE_ENDPOINT"],
-		fcClientId: process.env["NEXT_PUBLIC_FC_CLIENT_ID"]
+		fcClientId: process.env["NEXT_PUBLIC_FC_CLIENT_ID"],
+		docaposteApiUrl: process.env["NEXT_PUBLIC_DOCAPOST_API_URL"],
 	};
 };
 

src/pages/id360/customer-callback.tsx

@@ -0,0 +1,5 @@
+import LoginCallBackCustomer from "@Front/Components/Layouts/LoginCallbackCustomer";
+
+export default function Route() {
+	return <LoginCallBackCustomer />;
+}

src/pages/login-customer.tsx

@@ -0,0 +1,5 @@
+import LoginCustomer from "@Front/Components/Layouts/LoginCustomer";
+
+export default function Route() {
+	return <LoginCustomer />;
+}