Anthony Janin
87976783a3
All checks were successful
Build and Push to Registry / build-and-push (push) Successful in 3m59s
317 lines
10 KiB
TypeScript
317 lines
10 KiB
TypeScript
import { v4 as uuidv4 } from 'uuid';
|
|
|
|
import User from 'src/sdk/User';
|
|
|
|
import AbstractService from './AbstractService';
|
|
|
|
import OfficeService from './OfficeService';
|
|
import RoleService from './RoleService';
|
|
import OfficeRoleService from './OfficeRoleService';
|
|
|
|
export default class CollaboratorService extends AbstractService {
|
|
|
|
private constructor() {
|
|
super();
|
|
}
|
|
|
|
public static createCollaborator(collaboratorData: any, validatorId: string): Promise<any> {
|
|
const ownerId: string = User.getInstance().getPairingId()!;
|
|
|
|
const processData: any = {
|
|
uid: uuidv4(),
|
|
utype: 'collaborator',
|
|
isDeleted: 'false',
|
|
created_at: new Date().toISOString(),
|
|
updated_at: new Date().toISOString(),
|
|
...collaboratorData
|
|
};
|
|
|
|
const privateFields: string[] = Object.keys(processData);
|
|
privateFields.splice(privateFields.indexOf('uid'), 1);
|
|
privateFields.splice(privateFields.indexOf('utype'), 1);
|
|
privateFields.splice(privateFields.indexOf('isDeleted'), 1);
|
|
|
|
const roles: any = {
|
|
demiurge: {
|
|
members: [...[ownerId], validatorId],
|
|
validation_rules: [],
|
|
storages: []
|
|
},
|
|
owner: {
|
|
members: [ownerId],
|
|
validation_rules: [
|
|
{
|
|
quorum: 0.5,
|
|
fields: [...privateFields, 'roles', 'uid', 'utype'],
|
|
min_sig_member: 1,
|
|
},
|
|
],
|
|
storages: []
|
|
},
|
|
validator: {
|
|
members: [validatorId],
|
|
validation_rules: [
|
|
{
|
|
quorum: 0.5,
|
|
fields: ['idCertified', 'roles'],
|
|
min_sig_member: 1,
|
|
},
|
|
{
|
|
quorum: 0.0,
|
|
fields: [...privateFields],
|
|
min_sig_member: 0,
|
|
},
|
|
],
|
|
storages: []
|
|
},
|
|
apophis: {
|
|
members: [ownerId],
|
|
validation_rules: [],
|
|
storages: []
|
|
}
|
|
};
|
|
|
|
return new Promise<any>((resolve: (processCreated: any) => void, reject: (error: string) => void) => {
|
|
this.messageBus.createProcess(processData, privateFields, roles).then((processCreated: any) => {
|
|
this.messageBus.notifyUpdate(processCreated.processId, processCreated.process.states[0].state_id).then(() => {
|
|
this.messageBus.validateState(processCreated.processId, processCreated.process.states[0].state_id).then((_stateValidated: any) => {
|
|
this.getCollaboratorByUid(processCreated.processData.uid).then(resolve).catch(reject);
|
|
}).catch(reject);
|
|
}).catch(reject);
|
|
}).catch(reject);
|
|
});
|
|
}
|
|
|
|
public static getCollaborators(callback: (processes: any[]) => void, waitForAll: boolean = false): void {
|
|
// Check if we have valid cache
|
|
const items: any[] = this.getItems('_collaborators_');
|
|
if (items.length > 0 && !waitForAll) {
|
|
setTimeout(() => callback([...items]), 0);
|
|
}
|
|
|
|
this.messageBus.getProcessesDecoded((publicValues: any) =>
|
|
publicValues['uid'] &&
|
|
publicValues['utype'] &&
|
|
publicValues['utype'] === 'collaborator' &&
|
|
publicValues['isDeleted'] &&
|
|
publicValues['isDeleted'] === 'false' &&
|
|
!items.map((item: any) => item.processData.uid).includes(publicValues['uid'])
|
|
).then(async (processes: any[]) => {
|
|
if (processes.length === 0) {
|
|
if (waitForAll) {
|
|
callback([...items]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
const updatedItems: any[] = [...items];
|
|
|
|
for (let processIndex = 0; processIndex < processes.length; processIndex++) {
|
|
let process = processes[processIndex];
|
|
|
|
if (!waitForAll) {
|
|
process = await this.completeCollaborator(process, (processInProgress: any) => {
|
|
const currentItems: any[] = [...updatedItems];
|
|
|
|
const existingIndex: number = currentItems.findIndex(item => item.processData?.uid === processInProgress.processData?.uid);
|
|
if (existingIndex >= 0) {
|
|
currentItems[existingIndex] = processInProgress;
|
|
} else {
|
|
currentItems.push(processInProgress);
|
|
}
|
|
|
|
callback(currentItems);
|
|
});
|
|
} else {
|
|
process = await this.completeCollaborator(process);
|
|
}
|
|
|
|
// Update cache
|
|
this.setItem('_collaborators_', process);
|
|
|
|
const existingIndex: number = updatedItems.findIndex(item => item.processData?.uid === process.processData?.uid);
|
|
if (existingIndex >= 0) {
|
|
updatedItems[existingIndex] = process;
|
|
} else {
|
|
updatedItems.push(process);
|
|
}
|
|
|
|
if (!waitForAll) {
|
|
callback([...updatedItems]);
|
|
}
|
|
}
|
|
|
|
if (waitForAll) {
|
|
callback([...updatedItems]);
|
|
}
|
|
});
|
|
}
|
|
|
|
public static getCollaboratorsBy(whereClause: { [path: string]: any }): Promise<any[]> {
|
|
return new Promise<any[]>((resolve: (collaborators: any[]) => void) => {
|
|
this.getCollaborators((processes: any[]) => {
|
|
if (processes.length === 0) {
|
|
resolve([]);
|
|
} else {
|
|
resolve(processes.filter((process: any) => {
|
|
const collaborator: any = process.processData;
|
|
|
|
for (const path in whereClause) {
|
|
const paths: string[] = path.split('.');
|
|
|
|
let value: any = collaborator;
|
|
for (let i = 0; i < paths.length; i++) {
|
|
const currentPath = paths[i];
|
|
if (!currentPath || value === undefined || value === null) {
|
|
break;
|
|
}
|
|
value = value[currentPath];
|
|
}
|
|
|
|
if (value !== whereClause[path]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}));
|
|
}
|
|
}, true);
|
|
});
|
|
}
|
|
|
|
public static getCollaboratorBy(whereClause: { [path: string]: any }): Promise<any | null> {
|
|
return new Promise<any | null>((resolve: (collaborator: any | null) => void) => {
|
|
this.getCollaborators((processes: any[]) => {
|
|
if (processes.length === 0) {
|
|
resolve(null);
|
|
} else {
|
|
resolve(processes.find((process: any) => {
|
|
const collaborator: any = process.processData;
|
|
|
|
for (const path in whereClause) {
|
|
const paths: string[] = path.split('.');
|
|
|
|
let value: any = collaborator;
|
|
for (let i = 0; i < paths.length; i++) {
|
|
const currentPath = paths[i];
|
|
if (!currentPath || value === undefined || value === null) {
|
|
break;
|
|
}
|
|
value = value[currentPath];
|
|
}
|
|
|
|
if (value !== whereClause[path]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}));
|
|
}
|
|
}, true);
|
|
});
|
|
}
|
|
|
|
public static getCollaboratorByUid(uid: string, forceRefresh: boolean = false): Promise<any> {
|
|
// Check if we have valid cache
|
|
const item: any = this.getItem('_collaborators_', uid);
|
|
if (item && !forceRefresh) {
|
|
return Promise.resolve(item);
|
|
}
|
|
|
|
return new Promise<any>((resolve: (process: any) => void, reject: (error: string) => void) => {
|
|
this.messageBus.getProcessesDecoded((publicValues: any) =>
|
|
publicValues['uid'] &&
|
|
publicValues['uid'] === uid &&
|
|
publicValues['utype'] &&
|
|
publicValues['utype'] === 'collaborator' &&
|
|
publicValues['isDeleted'] &&
|
|
publicValues['isDeleted'] === 'false'
|
|
).then(async (processes: any[]) => {
|
|
if (processes.length === 0) {
|
|
resolve(null);
|
|
} else {
|
|
let process: any = processes[0];
|
|
process = await this.completeCollaborator(process);
|
|
|
|
// Update cache
|
|
this.setItem('_collaborators_', process);
|
|
|
|
resolve(process);
|
|
}
|
|
}).catch(reject);
|
|
});
|
|
}
|
|
|
|
public static updateCollaborator(process: any, newData: any): Promise<void> {
|
|
return new Promise<void>((resolve: () => void, reject: (error: string) => void) => {
|
|
this.messageBus.updateProcess(process.processId, { updated_at: new Date().toISOString(), ...newData }, [], null).then((processUpdated: any) => {
|
|
const newStateId: string = processUpdated.diffs[0]?.state_id;
|
|
this.messageBus.notifyUpdate(process.processId, newStateId).then(() => {
|
|
this.messageBus.validateState(process.processId, newStateId).then((_stateValidated) => {
|
|
const collaboratorUid: string = process.processData.uid;
|
|
this.removeItem('_collaborators_', collaboratorUid);
|
|
|
|
this.getCollaboratorByUid(collaboratorUid, true).then(resolve).catch(reject);
|
|
}).catch(reject);
|
|
}).catch(reject);
|
|
}).catch(reject);
|
|
});
|
|
}
|
|
|
|
private static async completeCollaborator(process: any, progressCallback?: (processInProgress: any) => void): Promise<any> {
|
|
const progressiveProcess: any = JSON.parse(JSON.stringify(process));
|
|
|
|
if (process.processData.office) {
|
|
const office: any = (await OfficeService.getOfficeByUid(process.processData.office.uid)).processData;
|
|
process.processData.office = {
|
|
uid: office.uid,
|
|
idNot: office.idNot,
|
|
crpcen: office.crpcen,
|
|
name: office.name,
|
|
office_status: office.office_status
|
|
};
|
|
|
|
if (progressCallback) {
|
|
progressiveProcess.processData.office = process.processData.office;
|
|
progressCallback(JSON.parse(JSON.stringify(progressiveProcess)));
|
|
}
|
|
}
|
|
|
|
if (process.processData.role) {
|
|
const role: any = (await RoleService.getRoleByUid(process.processData.role.uid)).processData;
|
|
process.processData.role = {
|
|
uid: role.uid,
|
|
name: role.name
|
|
};
|
|
|
|
if (progressCallback) {
|
|
progressiveProcess.processData.role = process.processData.role;
|
|
progressCallback(JSON.parse(JSON.stringify(progressiveProcess)));
|
|
}
|
|
}
|
|
|
|
if (process.processData.office_role) {
|
|
const officeRole: any = (await OfficeRoleService.getOfficeRoleByUid(process.processData.office_role.uid)).processData;
|
|
process.processData.office_role = {
|
|
uid: officeRole.uid,
|
|
name: officeRole.name,
|
|
rules: officeRole.rules?.map((rule: any) => {
|
|
return {
|
|
uid: rule.uid,
|
|
name: rule.name
|
|
};
|
|
})
|
|
};
|
|
|
|
if (progressCallback) {
|
|
progressiveProcess.processData.office_role = process.processData.office_role;
|
|
progressCallback(JSON.parse(JSON.stringify(progressiveProcess)));
|
|
}
|
|
}
|
|
|
|
return process;
|
|
}
|
|
}
|