const CrudService = require("./CrudService");
const WelcomeMail = require("../sms-mail/WelcomeMail");
const config = require("../config");
const path = require("path");
const {v4: uuidv4} = require("uuid");
const {birthPlace} = require("../database/models/Consultant");
/**
* @extends Myintranet.Services.CrudService
* @memberof Myintranet.Services
* @inheritDoc
*/
class ConsultantService extends CrudService {
constructor(db) {
super(db.User);
this.db = db;
}
/**
* Récupère le chemin complet du fichier document basé sur l'ID du document.
*
* @param {number} id - L'ID du document.
* @returns {Promise<string>} Une promesse qui résout avec le chemin complet du fichier document.
*/
async getFullDocPathname(id) {
let doc = await this.db.ConsultantFiles.findOne({
where: {id},
include: {model: this.db.Consultant, include: this.db.User},
});
let slug =
doc.Consultant.id +
"-" +
doc.Consultant.foldername;
let consultantStorageLocation = path.resolve(
path.join(config.storageLocation, slug)
);
switch (doc.typeDoc) {
case "CV":
return path.join(consultantStorageLocation, "CV", doc.name);
case "PI":
return path.join(consultantStorageLocation, "piece_identite", doc.name);
case "JD":
return path.join(
consultantStorageLocation,
"justificatif_domicile",
doc.name
);
case "ASS":
return path.join(
consultantStorageLocation,
"ATT_Securite_social",
doc.name
);
case "SI":
return path.join(
consultantStorageLocation,
"Simulation",
doc.name
);
case "CG":
return path.join(consultantStorageLocation, "Carte_grise", doc.name);
case "IB":
return path.join(
consultantStorageLocation,
"Informations_banquaire",
doc.name
);
case "CM":
return path.join(
consultantStorageLocation,
"Contrat_mutuelle",
doc.name
);
case "PC":
return path.join(
consultantStorageLocation,
"Permis_de_conduire",
doc.name
);
case "MU":
return path.join(
consultantStorageLocation,
"mutuelle",
doc.name
);
case "AP":
return path.join(consultantStorageLocation, "ATT_prevoyance", doc.name);
}
}
/**
* copythefile
* @private
* @param {@} file
* @param {*} pathTo
* @returns {Promise<any>}
*/
__copyFile(file, pathTo) {
return new Promise((resolve, reject) => {
file.mv(pathTo, (err) => {
if (err) {
reject(err);
} else {
resolve();
}
});
});
}
async getDocs1(request) {
let docsArray = await this.db.ConsultantFiles.findAll({
where: {ConsultantId: request.params.id},
});
let res = {};
for (let index = 0; index < docsArray.length; index++) {
const element = docsArray[index];
res[element.typeDoc.toLowerCase()] = element;
}
return res;
}
async uploadDocs1Files(request) {
let consultant = await this.db.Consultant.findOne({
where: {id: request.body.cid},
include: this.db.User,
});
let connected = request.user;
let Uploadedfiles = [];
let uploadedDoc;
let fileName;
const t = await this.db.sequelize.transaction();
try {
if (!consultant) {
throw new Error("consultant not found");
}
let slug =
consultant.id +
"-" +
consultant.foldername
let consultantStorageLocation = path.resolve(
path.join(config.storageLocation, slug)
);
if (request.files) {
if (request.files.cv) {
let cv = {...request.files.cv};
cv.typeDoc = "CV";
cv.name = this.getFileName(cv.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, cv.name.split('.').pop());
cv.ConsultantId = consultant.id;
delete cv.data;
let ibDbCV = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "CV",
},
});
if (!ibDbCV) {
ibDbCV = await this.db.ConsultantFiles.create(cv, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
cv,
{where: {id: ibDbCV.id}},
{transaction: t}
);
cv.id = ibDbCV.id
ibDbCV = cv
}
Uploadedfiles.push("CV");
await this.__copyFile(
request.files.cv,
path.join(consultantStorageLocation, "CV", cv.name)
);
uploadedDoc = ibDbCV;
}
if (request.files.pi) {
let pi = {...request.files.pi};
pi.typeDoc = "PI";
pi.name = this.getFileName(pi.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, pi.name.split('.').pop());
pi.ConsultantId = consultant.id;
delete pi.data;
let inDbPI = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "PI",
},
});
if (!inDbPI) {
inDbPI = await this.db.ConsultantFiles.create(pi, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
pi,
{where: {id: inDbPI.id}},
{transaction: t}
);
pi.id = inDbPI.id
inDbPI = pi
}
Uploadedfiles.push("piece_identite");
await this.__copyFile(
request.files.pi,
path.join(
consultantStorageLocation,
"piece_identite",
pi.name
)
);
uploadedDoc = inDbPI;
}
if (request.files.pc) {
let pc = {...request.files.pc};
pc.typeDoc = "PC";
pc.name = this.getFileName(pc.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, pc.name.split('.').pop());
pc.ConsultantId = consultant.id;
delete pc.data;
let inDbPC = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "PC",
},
});
if (!inDbPC) {
inDbPC = await this.db.ConsultantFiles.create(pc, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
pc,
{where: {id: inDbPC.id}},
{transaction: t}
);
pc.id = inDbPC.id
inDbPC = pc
}
Uploadedfiles.push("permis_de_conduire");
await this.__copyFile(
request.files.pc,
path.join(
consultantStorageLocation,
"permis_de_conduire",
pc.name
)
);
uploadedDoc = inDbPC;
}
if (request.files.mu) {
let mu = {...request.files.mu};
mu.typeDoc = "MU";
mu.name = this.getFileName(mu.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, mu.name.split('.').pop());
mu.ConsultantId = consultant.id;
delete mu.data;
let inDbMU = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "MU",
},
});
if (!inDbMU) {
inDbMU = await this.db.ConsultantFiles.create(mu, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
mu,
{where: {id: inDbMU.id}},
{transaction: t}
);
mu.id = inDbMU.id
inDbMU = mu;
}
Uploadedfiles.push("mutuelle");
await this.__copyFile(
request.files.mu,
path.join(
consultantStorageLocation,
"mutuelle",
mu.name
)
);
uploadedDoc = inDbMU;
}
if (request.files.jd) {
let jd = {...request.files.jd};
jd.typeDoc = "JD";
jd.name = this.getFileName(jd.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, jd.name.split('.').pop());
jd.ConsultantId = consultant.id;
delete jd.data;
let inDbJD = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "JD",
},
});
if (!inDbJD) {
inDbJD = await this.db.ConsultantFiles.create(jd, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
jd,
{where: {id: inDbJD.id}},
{transaction: t}
);
jd.id = inDbJD.id
inDbJD = jd
}
Uploadedfiles.push("justificatif_domicile");
await this.__copyFile(
request.files.jd,
path.join(
consultantStorageLocation,
"justificatif_domicile",
jd.name
)
);
uploadedDoc = inDbJD;
}
if (request.files.ass) {
let ass = {...request.files.ass};
ass.typeDoc = "ASS";
ass.name = this.getFileName(ass.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, ass.name.split('.').pop());
ass.ConsultantId = consultant.id;
delete ass.data;
let inDbASS = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "ASS",
},
});
if (!inDbASS) {
inDbASS = await this.db.ConsultantFiles.create(ass, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
ass,
{where: {id: inDbASS.id}},
{transaction: t}
);
ass.id = inDbASS.id
inDbASS = ass;
}
Uploadedfiles.push("ATT_Securite_social");
await this.__copyFile(
request.files.ass,
path.join(
consultantStorageLocation,
"ATT_Securite_social",
ass.name
)
);
uploadedDoc = inDbASS;
}
if (request.files.si) {
let si = {...request.files.si};
si.typeDoc = "SI";
si.name = this.getFileName(si.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, si.name.split('.').pop());
si.ConsultantId = consultant.id;
delete si.data;
let inDbSI = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "SI",
},
});
if (!inDbSI) {
inDbSI = await this.db.ConsultantFiles.create(si, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
si,
{where: {id: inDbSI.id}},
{transaction: t}
);
si.id = inDbSI.id
inDbSI = si
}
Uploadedfiles.push("simulation");
await this.__copyFile(
request.files.si,
path.join(
consultantStorageLocation,
"simulation",
si.name
)
);
uploadedDoc = inDbSI;
}
if (request.files.cg) {
let cg = {...request.files.cg};
cg.typeDoc = "CG";
cg.name = this.getFileName(cg.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, cg.name.split('.').pop());
cg.ConsultantId = consultant.id;
delete cg.data;
let inDbCG = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "CG",
},
});
if (!inDbCG) {
inDbCG = await this.db.ConsultantFiles.create(cg, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
cg,
{where: {id: inDbCG.id}},
{transaction: t}
);
cg.id = inDbCG.id
inDbCG = cg;
}
Uploadedfiles.push("Carte_grise");
await this.__copyFile(
request.files.cg,
path.join(
consultantStorageLocation,
"Carte_grise",
cg.name
)
);
uploadedDoc = inDbCG;
}
if (request.files.ib) {
let ib = {...request.files.ib};
ib.typeDoc = "IB";
ib.name = this.getFileName(ib.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, ib.name.split('.').pop());
ib.ConsultantId = consultant.id;
delete ib.data;
let inDbIB = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "IB",
},
});
if (!inDbIB) {
inDbIB = await this.db.ConsultantFiles.create(ib, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
ib,
{where: {id: inDbIB.id}},
{transaction: t}
);
ib.id = inDbIB.id
inDbIB = ib;
}
Uploadedfiles.push("Informations_banquaire");
await this.__copyFile(
request.files.ib,
path.join(
consultantStorageLocation,
"Informations_banquaire",
ib.name
)
);
uploadedDoc = inDbIB;
}
if (request.files.cm) {
let cm = {...request.files.cm};
cm.typeDoc = "CM";
cm.name = this.getFileName(cm.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, cm.name.split('.').pop());
cm.ConsultantId = consultant.id;
delete cm.data;
let inDbCM = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "CM",
},
});
if (!inDbCM) {
inDbCM = await this.db.ConsultantFiles.create(cm, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
cm,
{where: {id: inDbCM.id}},
{transaction: t}
);
cm.id = inDbCM.id
inDbCM = cm;
}
Uploadedfiles.push("Contrat_mutuelle");
await this.__copyFile(
request.files.cm,
path.join(
consultantStorageLocation,
"Contrat_mutuelle",
cm.name
)
);
uploadedDoc = inDbCM;
}
if (request.files.ap) {
let ap = {...request.files.ap};
ap.typeDoc = "AP";
ap.name = this.getFileName(ap.typeDoc, consultant.Utilisateur.firstname, consultant.Utilisateur.lastname, ap.name.split('.').pop());
ap.ConsultantId = consultant.id;
delete ap.data;
let inDbAP = await this.db.ConsultantFiles.findOne({
where: {
ConsultantId: consultant.id,
typeDoc: "AP",
},
});
if (!inDbAP) {
inDbAP = await this.db.ConsultantFiles.create(ap, {transaction: t});
} else {
await this.db.ConsultantFiles.update(
ap,
{where: {id: inDbAP.id}},
{transaction: t}
);
ap.id = inDbAP.id
inDbAP = ap;
}
Uploadedfiles.push("ATT_prevoyance");
await this.__copyFile(
request.files.ap,
path.join(
consultantStorageLocation,
"ATT_prevoyance",
ap.name
)
);
uploadedDoc = inDbAP;
}
await this.db.Action.create(
{
UtilisateurId: connected.id,
meta: JSON.stringify(Uploadedfiles),
type: "mise a jour",
text: `<b>${connected.firstname} ${connected.lastname
}</b> a modifié les documents (<b>${Uploadedfiles.join(
","
)}</b>) du Consultant : <b>${consultant.Utilisateur.firstname}-${consultant.Utilisateur.lastname
}</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
},
{transaction: t}
);
}
await t.commit();
return uploadedDoc;
} catch (e) {
await t.rollback();
throw e;
}
}
/**
*
*/
async getAll(request) {
let connectedUser = request.user;
let {db} = this;
if (connectedUser.type === "SuperAdmin") {
return this.getAllForSuperAdmin(request);
} else if (connectedUser.type === "Admin") {
return this.getAllForAdmin(request);
} else {
//Consultant
throw new Error(
"Un consultant ne peu pas consulter la liste des autres consultants, seul un admin ou un super admin le peuvent!"
);
}
}
async getAllSubsForSuperAdmin(request) {
let {db} = this;
let condition = {
include: [
{
model: db.Employeur,
},
{
model: db.ConsultantFiles,
},
{
model: db.User,
where: {type: {[db.Sequelize.Op.eq]: "Consultant"},},
},
{
model: db.Mission,
include: [
{model: db.Client},
{model: db.CraHistory},
{model: db.PrevHistory,},
{model: db.Employeur},
],
},
],
where: {status: {[db.Sequelize.Op.eq]: "SUBSCRIBED"}}
};
return new Promise((resolve, reject) => {
db.Consultant.findAll(condition).then(consultans => {
resolve(consultans)
}).catch(err => {
reject(err)
})
})
}
/**
* return all subscribed consultants for admin and superAdmin
* @param request
* @return {Promise<unknown>}
*/
async getAllSubs(request) {
let connectedUser = request.user;
if (connectedUser.type === "SuperAdmin") {
return await this.getAllSubsForSuperAdmin(request);
} else if (connectedUser.type === "Admin") {
return await this.getAllSubsForAdmin(request);
} else {
throw new Error(
"Un consultant ne peu pas consulter la liste des autres consultants, seul un admin ou un super admin le peuvent!"
);
}
}
/**
* return all subscribed consultants for admin
* @param request
* @return {Promise<unknown>}
*/
async getAllSubsForAdmin(request) {
let {db} = this;
let {f} = request.query;
let condition = {
include: [
{
model: db.Employeur,
}, {
model: db.ConsultantFiles,
},
{
model: db.User,
where: {type: "Consultant"},
},
{
model: db.Mission,
include: [
{model: db.Client},
{model: db.CraHistory},
{model: db.PrevHistory},
{model: db.Employeur},
],
},
],
where: {status: {[db.Sequelize.Op.eq]: "SUBSCRIBED"}}
};
return new Promise(async (resolve, reject) => {
try {
let connectedUser = request.user;
let consultantsIds = [];
let admin = await db.User.findOne({
where: {id: connectedUser.id},
include: {
model: db.Employeur,
include: db.Consultant,
},
});
admin.Employeurs.forEach((emp) => {
let ids = emp.Consultants.map((con) => con.id);
consultantsIds = consultantsIds.concat(ids);
});
let consultants = await db.Consultant.findAll({
where: {
id: {[db.Sequelize.Op.in]: consultantsIds},
status: {[db.Sequelize.Op.eq]: "SUBSCRIBED"}
},
include: condition.include,
});
resolve(consultants)
} catch (error) {
reject(error);
}
});
}
/**
* return all subscribed consultants for superAdmin
* @param request
* @return {Promise<unknown>}
*/
async getAllForSuperAdmin(request) {
let {f} = request.query;
let {db} = this;
let condition = {
include: [
{
model: db.Employeur,
},
{
model: db.User,
where: {type: {[db.Sequelize.Op.eq]: "Consultant"},},
},
{
model: db.Mission,
include: [
{model: db.Client},
{model: db.CraHistory},
{model: db.PrevHistory,},
{model: db.Employeur},
],
},
],
where: {
status: {
[db.Sequelize.Op.or]: {
[db.Sequelize.Op.notIn]: ["SUBSCRIBED", "PRESUB"],
[db.Sequelize.Op.is]: null
},
}
}
};
let consultants = await db.Consultant.findAll(condition);
let filtred;
let ActifConsultants = consultants.filter((consultant) => {
for (const mission of consultant.Missions) {
if (mission.dateEnd === null) {
return true;
}
}
return false;
});
switch (f) {
case "nomissions":
let nonActifConsultants = consultants.filter((consultant) => {
if (consultant.Missions.length === 0) {
return true;
} else {
for (const mission of consultant.Missions) {
console.log(mission.dateEnd)
if (mission.dateEnd === null) {
return false;
}
}
return true;
}
});
filtred = nonActifConsultants;
break;
case "prevNonSaisi":
let consultantsNoPrev = ActifConsultants.filter((consultant, i) => {
let missions = consultant.Missions;
for (const mission of missions) {
if (mission.dateEnd === null) {
if (mission.PrevHistories.length > 0) {
const prevs = mission.PrevHistories;
for (const prev of prevs) {
if (prev.nbJours === null || prev.nbJours === "") {
return consultant;
}
}
}
}
}
})
filtred = consultantsNoPrev;
break;
case "craNonSaisi":
let consultantsNoCra = ActifConsultants.filter((consultant, i) => {
let missions = consultant.Missions;
for (const mission of missions) {
if (mission.dateEnd === null) {
if (mission.CraHistories.length > 0) {
const cras = mission.CraHistories;
for (const cra of cras) {
if (cra.craFilename === null || cra.craFilename === "") {
return consultant;
}
}
}
}
}
})
filtred = consultantsNoCra;
break;
case "prevNonSaisiEtCraNonSaisi":
let consultantsNoCraNoPrev = ActifConsultants.filter((consultant, i) => {
let missions = consultant.Missions;
for (const mission of missions) {
if (mission.dateEnd === null) {
const cras = mission.CraHistories;
const prevs = mission.PrevHistories;
for (let j = 0; j < cras.length; j++) {
if ((cras[j].craFilename === null || cras[j].craFilename === "") && (prevs[j]?.nbJours === null || prevs[j]?.nbJours === "")) {
return true;
}
}
}
}
return false;
});
filtred = consultantsNoCraNoPrev;
break;
default:
filtred = ActifConsultants;
break;
}
let result = [];
for (let j = 0; j < filtred.length; j++) {
let c = filtred[j];
let cjson = c.toJSON()
for (let i = 0; i < c.Missions.length; i++) {
cjson.Missions[i].CraHistories = (await c.Missions[i].getCraHistories({order: [['year', 'ASC'], ['mounth', 'ASC']]}));
cjson.Missions[i].PrevHistories = (await c.Missions[i].getPrevHistories({order: [['year', 'ASC'], ['mounth', 'ASC']]}));
}
result.push(cjson);
}
return result;
}
async getAllForAdmin(request) {
let {db} = this;
let {f} = request.query;
let condition = {
include: [
{
model: db.Employeur,
},
{
model: db.User,
where: {type: "Consultant"},
},
{
model: db.Mission,
include: [
{model: db.Client},
{model: db.PrevHistory},
{model: db.CraHistory},
{model: db.Employeur},
],
},
],
where: {
status: {
[db.Sequelize.Op.or]: {
[db.Sequelize.Op.notIn]: ["SUBSCRIBED", "PRESUB"],
[db.Sequelize.Op.is]: null,
},
},
},
};
try {
let connectedUser = request.user;
let consultantsIds = [];
let admin = await db.User.findOne({
where: {id: connectedUser.id},
include: {
model: db.Employeur,
include: db.Consultant,
},
});
admin.Employeurs.forEach((emp) => {
let ids = emp.Consultants.map((con) => con.id);
consultantsIds = consultantsIds.concat(ids);
});
let consultants = await db.Consultant.findAll({
where: {
id: {[db.Sequelize.Op.in]: consultantsIds},
status: {
[db.Sequelize.Op.or]: {
[db.Sequelize.Op.notIn]: ["SUBSCRIBED", "PRESUB"],
[db.Sequelize.Op.is]: null,
},
},
},
include: condition.include,
});
let filteredConsultants = consultants.filter((consultant) => {
for (const mission of consultant.Missions) {
if (mission.dateEnd === null) {
return true;
}
}
return false;
});
let filtred =filteredConsultants;
switch (f) {
case "nomissions":
let nonActifConsultants = consultants.filter((consultant) => {
console.log(consultant.Missions)
if (consultant.Missions.length === 0) {
return true;
} else {
for (const mission of consultant.Missions) {
console.log(mission.dateEnd)
if (mission.dateEnd === null) {
return false;
}
}
return true;
}
});
filtred = nonActifConsultants;
break;
case "prevNonSaisi":
let consultantsNoPrev = consultants.filter((consultant, i) => {
let missions = consultant.Missions;
for (const mission of missions) {
if (mission.dateEnd === null) {
if (mission.PrevHistories.length > 0) {
const prevs = mission.PrevHistories;
for (const prev of prevs) {
if (prev.nbJours === null || prev.nbJours === "") {
return consultant;
}
}
}
}
}
});
filtred = consultantsNoPrev;
break;
case "craNonSaisi":
let consultantsNoCra = consultants.filter((consultant, i) => {
let missions = consultant.Missions;
for (const mission of missions) {
if (mission.dateEnd === null) {
if (mission.CraHistories.length > 0) {
const cras = mission.CraHistories;
for (const cra of cras) {
if (cra.craFilename === null || cra.craFilename === "") {
return consultant;
}
}
}
}
}
})
filtred = consultantsNoCra;
break;
case "prevNonSaisiEtCraNonSaisi":
let consultantsNoCraNoPrev = consultants.filter((consultant, i) => {
let missions = consultant.Missions;
for (const mission of missions) {
if (mission.dateEnd === null) {
const cras = mission.CraHistories;
const prevs = mission.PrevHistories;
for (let j = 0; j < cras.length; j++) {
if ((cras[j].craFilename === null || cras[j].craFilename === "") || (prevs[j]?.nbJours === null || prevs[j]?.nbJours === "")) {
return true;
}
}
}
}
return false;
});
filtred = consultantsNoCraNoPrev;
break;
default:
filtred = filteredConsultants;
break;
}
let result = [];
for (let j = 0; j < filtred.length; j++) {
let c = filtred[j];
let cjson = c.toJSON()
for (let i = 0; i < c.Missions.length; i++) {
cjson.Missions[i].CraHistories = (await c.Missions[i].getCraHistories({order: [['year', 'ASC'], ['mounth', 'ASC']]}));
cjson.Missions[i].PrevHistories = (await c.Missions[i].getPrevHistories({order: [['year', 'ASC'], ['mounth', 'ASC']]}));
}
result.push(cjson);
}
return result;
} catch (error) {
throw error;
}
}
async findByText(request) {
let {user} = request;
if (user.type === "SuperAdmin") {
return this.findByTextSuperAdmin(request);
} else if (user.type === "Admin") {
return this.findByTextAdmin(request);
} else {
throw new Error(
"Seule le super administrateur / Admin à le droit de voir les / ces Consultant"
);
}
}
async findByTextSuperAdmin(request) {
let {text} = request.body;
let {db} = this;
let {user} = request.user;
return new Promise((resolve, reject) => {
db.Consultant.findAll({
where: {
[db.Sequelize.Op.or]: {
"$Missions->Client.denominationSocial$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
"$Employeurs.denominationSocial$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
"$Utilisateur.firstname$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
"$Utilisateur.lastname$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
},
},
include: [
{model: db.Employeur, as: "Employeurs"},
{model: db.User, as: "Utilisateur"},
{
model: db.Mission,
as: "Missions",
include: [
{model: db.Client},
{
model: db.CraHistory,
order: [
[db.CraHistory, 'year', 'DESC'],
[db.CraHistory, 'mounth', 'DESC'],
]
}, // add the where condition to exclude old mounths
{model: db.PrevHistory}, // add the where condition to exclude old mounths
{model: db.Employeur},
],
},
],
order: [["createdAt", "DESC"]],
})
.then((users) => {
resolve(users);
})
.catch((err) => {
reject(err);
});
});
}
async findByTextAdmin(request) {
let {text} = request.body;
let {db} = this;
let {user} = request.user;
let connectedUser = request.user;
let consultantsIds = [];
let admin = await db.User.findOne({
where: {id: connectedUser.id},
include: {
model: db.Employeur,
include: db.Consultant,
},
});
admin.Employeurs.map((emp) => {
let ids = emp.Consultants.map((con) => con.id);
consultantsIds = consultantsIds.concat(ids);
});
// console.log(consultantsIds);
return new Promise((resolve, reject) => {
db.Consultant.findAll({
where: {
id: {[db.Sequelize.Op.in]: consultantsIds},
[db.Sequelize.Op.or]: {
"$Missions->Client.denominationSocial$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
"$Employeurs.denominationSocial$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
"$Utilisateur.firstname$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
"$Utilisateur.lastname$": {
[db.Sequelize.Op.like]: "%" + text + "%",
},
},
},
include: [
{model: db.Employeur, as: "Employeurs"},
{model: db.User, as: "Utilisateur"},
{
model: db.Mission,
include: [
{model: db.Client},
{model: db.CraHistory}, // add the where condition to exclude old mounths
{model: db.PrevHistory}, // add the where condition to exclude old mounths
{model: db.Employeur},
],
},
],
order: [["createdAt", "DESC"]],
})
.then((users) => {
resolve(users);
})
.catch((err) => {
reject(err);
});
});
}
async update(request) {
let {db} = this;
let id = this.__getIdFromRequest(request);
const t = await db.sequelize.transaction();
try {
if (id === null) {
throw new Error("Cant update With no Id")
} else {
let connected = request.user;
let data = request.body;
await db.Action.create({
UtilisateurId: connected.id,
meta: JSON.stringify(data),
type: "mise a jour",
text: `<b>${connected.firstname} ${connected.lastname}</b> a modifié le Consultant : <b>${data.Utilisateur.firstname}-${data.Utilisateur.lastname}</b> le : ${(new Date(Date.now())).toLocaleString("fr-FR")}`
}, {transaction: t})
await db.Consultant.update(data, {where: {id}}, {transaction: t});
await db.User.update(data.Utilisateur, {where: {id: data.Utilisateur.id}}, {transaction: t})
await t.commit();
return this.getOne(request);
}
} catch (e) {
await t.rollback();
throw e;
}
}
//
// async getOne(request) {
// let { db } = this;
// let id = this.__getIdFromRequest(request);
// let connected = request.user;
//
// let data = request.body;
// data.Utilisateur.firstname = this.capitalize(
// data.Utilisateur.firstname
// );
// await db.Action.create(
// {
// UtilisateurId: connected.id,
// meta: JSON.stringify(data),
// type: "mise a jour",
// text: `<b>${connected.firstname} ${
// connected.lastname
// }</b> a modifié le Consltant : <b>${data.Utilisateur.firstname}-${
// data.Utilisateur.lastname
// }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
// },
// { transaction: t }
// );
// await db.Consultant.update(data, { where: { id } }, { transaction: t });
// await db.User.update(
// data.Utilisateur,
// { where: { id: data.Utilisateur.id } },
// { transaction: t }
// );
// await t.commit();
// return true;
// }
// } catch (e) {
// await t.rollback();
// throw e;
// }
// }
async getOne(request) {
let {db} = this;
let id = this.__getIdFromRequest(request);
let connected = request.user;
if (
connected.type === "SuperAdmin" ||
connected.type === "Admin" ||
connected.Consultant.id === id
) {
let consultantModel = await db.Consultant.findOne({
where: {id}, include: [db.Employeur, db.ConsultantFiles, db.User, {
model: db.Mission,
include: [
{model: db.Client},
{model: db.Employeur},
{model: db.Missionfiles},
],
}]
});
let consultant = {...consultantModel.toJSON()}
for (let i = 0; i < consultant.Missions.length; i++) {
consultant.Missions[i].CraHistories = (await consultantModel.Missions[i].getCraHistories({order: [['year', 'ASC'], ['mounth', 'ASC']]}));
consultant.Missions[i].PrevHistories = (await consultantModel.Missions[i].getPrevHistories({order: [['year', 'ASC'], ['mounth', 'ASC']]}));
}
return consultant;
} else {
throw new Error("Vous n'êtes pas autorisé à consulter ce consultant");
}
}
//TODO: Remove this one not in use
async getOneold(request) {
let {db} = this;
let id = this.__getIdFromRequest(request);
let connected = request.user;
// console.log(connected.Consultant.id,id)
if (
connected.type === "SuperAdmin" ||
connected.type === "Admin" ||
connected.Consultant.id === id
) {
let condition = {
where: {id},
include: [
{model: db.Employeur},
{
model: db.ConsultantFiles,
},
{
model: db.User,
},
{
model: db.Mission,
include: [
{model: db.Client},
{model: db.CraHistory, order: ['year', 'mounth', 'DESC']}, // add the where condition to exclude old mounths
{model: db.PrevHistory, order: ['year', 'mounth', 'DESC']}, // add the where condition to exclude old mounths
{model: db.Employeur},
{model: db.Missionfiles},
],
},
],
order: ['Missions->CraHistories.year', 'DESC']
};
//console.log(condition);
return db.Consultant.findOne(condition);
} else {
throw new Error("Vous n'êtes pas autorisé à consulter ce consultant");
}
}
async add(request) {
let {db} = this;
const t = await db.sequelize.transaction();
try {
let User = request.body;
console.log(User)
User.type = "Consultant";
User.status = "VALID"
let connected = request.user;
User.foldername = `${User.Utilisateur.firstname}-${User.Utilisateur.lastname}`;
let userConsultant = await db.Consultant.create(User, {
transaction: t,
include: [
{
model: db.User,
},
],
});
console.log("voici le consultnat ", userConsultant)
let employeur = await db.Employeur.findOne({
where: {id: User.Employeur.id},
});
await userConsultant.addEmployeurs(employeur, {transaction: t});
// let u = User.Utilisateur;
// u.ConsultantId = userConsultant.id;
// let userConsultant = await db.User.create(User., {
// include: [{
// model: db.User,
// transaction: t
// }]
// }, {transaction: t});
await db.Action.create(
{
UtilisateurId: connected.id,
meta: JSON.stringify(User),
type: "creation",
text: `<b>${connected.firstname} ${connected.lastname
}</b> a créé le Consultant : <b>${User.Utilisateur.firstname} ${User.Utilisateur.lastname
}</b>, Un mail de bienvenu a été envoyé à l address : <b>${User.Utilisateur.login
}</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
},
{transaction: t}
);
userConsultant.link = await db.SecuredLink.create(
{
token: uuidv4(),
UtilisateurId: userConsultant.Utilisateur.id,
reason: "Consultant creation",
},
{transaction: t}
);
userConsultant.login = userConsultant.Utilisateur.login;
userConsultant.firstname = userConsultant.Utilisateur.firstname;
userConsultant.lastname = userConsultant.Utilisateur.lastname;
let w = new WelcomeMail(
userConsultant,
"Confirmer votre inscription - My Intranet"
);
let infos = await w.send();
console.log("email sent");
await t.commit();
return await this.getOne({
user: request.user,
body: {id: userConsultant.id},
});
} catch (e) {
await t.rollback();
throw e;
}
}
async addConsultantforAdmin(request) {
let {db} = this;
let {body, files} = request;
const t = await db.sequelize.transaction();
try {
let User = {
address: body['infos-address'],
zipCode: body['infos-zipcode'],
city: body['infos-city'],
secuNum: body['infos-secu'],
birthDate: body['infos-birthDate'],
codePlace: body['infos-codeplace'],
birthPlace: body['infos-birthPlace'],
Utilisateur: {
login: body['infos-email'],
firstname: body['infos-firstname'],
lastname: body['infos-lastname'],
phone: body['infos-phone'],
gender: body['infos-gender']
},
employeur: JSON.parse(body["infos-Employeur"])
}
User.type = "Consultant";
User.foldername = `${User.Utilisateur.firstname}-${User.Utilisateur.lastname}`;
User.status = "VALID";
let userConsultant = await db.Consultant.create(User, {
transaction: t,
include: [
{
model: db.User,
},
],
});
for (const key in files) {
if (Object.hasOwnProperty.call(files, key)) {
const file = files[key];
let dbFiles = {...file}
file.ConsultantId = userConsultant.id;
file.typeDoc = key.toUpperCase().replace("DOCS-", "");
let fileName;
fileName = this.getFileName(file.typeDoc, userConsultant.Utilisateur.firstname, userConsultant.Utilisateur.lastname, file.name.split('.').pop());
file.name = fileName;
let dbFile = await db.ConsultantFiles.create(file, {transaction: t});
dbFile.Consultant = userConsultant;
// dbFiles.push(dbFile);
console.log(file)
await file.mv(this.getFullDocPathnam(dbFile));
}
}
let employeur = await db.Employeur.findOne({
where: {id: User.employeur.id}
});
console.log(User.employeur)
await userConsultant.addEmployeurs(employeur, {transaction: t});
let mission = {
title: body['mission-title'],
dateStart: body['mission-dateStart'],
tjm: body['mission-tjm'],
ConsultantId: userConsultant.id,
ClientId: JSON.parse(body["mission-Client"]).id,
EmployeurId: employeur.id,
};
// let client = await db.Client.findOne({
// where: { id: mission.ClientId }
// });
// console.log(mission)
await db.Mission.create(mission, {transaction: t});
let connected = request.user;
await db.Action.create({
UtilisateurId: connected.id,
meta: JSON.stringify(userConsultant),
type: "creation",
text: `<b>${connected.firstname} ${connected.lastname}</b> a créé le Consultant : <b>${User.Utilisateur.firstname} ${User.Utilisateur.lastname}</b>, Un mail de bienvenue a été envoyé à l'adresse : <b>${User.Utilisateur.login}</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
}, {transaction: t});
userConsultant.link = await db.SecuredLink.create({
token: uuidv4(),
UtilisateurId: userConsultant.Utilisateur.id,
reason: "Consultant creation",
}, {transaction: t});
userConsultant.login = userConsultant.Utilisateur.login;
userConsultant.firstname = userConsultant.Utilisateur.firstname;
userConsultant.lastname = userConsultant.Utilisateur.lastname;
let w = new WelcomeMail(userConsultant, "Confirmer votre inscription - My Intranet");
let infos = await w.send();
console.log("email sent");
await t.commit();
return await this.getOne({
user: request.user,
body: {id: userConsultant.id},
});
} catch (e) {
await t.rollback();
throw e;
}
}
/**
* Génère le chemin complet du fichier document basé sur les informations du consultant et le type de document.
*
* @param {Object} doc - L'objet document contenant les informations nécessaires.
* @param {Object} doc.Consultant - L'objet consultant contenant les informations du consultant.
* @param {number} doc.Consultant.id - L'ID du consultant.
* @param {string} doc.Consultant.foldername - Le nom du dossier du consultant.
* @param {string} doc.typeDoc - Le type de document. Les valeurs possibles sont: "CV", "PI", "JD", "ASS", "SI", "CG", "IB", "CM", "PC", "MU", "AP".
* @param {string} doc.name - Le nom du fichier document.
* @returns {string} Le chemin complet du fichier document.
*/
getFullDocPathnam(doc) {
let slug =
doc.Consultant.id +
"-" +
doc.Consultant.foldername;
let consultantStorageLocation = path.resolve(
path.join(config.storageLocation, slug)
);
switch (doc.typeDoc) {
case "CV":
return path.join(consultantStorageLocation, "CV", doc.name);
case "PI":
return path.join(consultantStorageLocation, "piece_identite", doc.name);
case "JD":
return path.join(
consultantStorageLocation,
"justificatif_domicile",
doc.name
);
case "ASS":
return path.join(
consultantStorageLocation,
"ATT_Securite_social",
doc.name
);
case "SI":
return path.join(
consultantStorageLocation,
"simulation",
doc.name
);
case "CG":
return path.join(consultantStorageLocation, "Carte_grise", doc.name);
case "IB":
return path.join(
consultantStorageLocation,
"Informations_banquaire",
doc.name
);
case "CM":
return path.join(
consultantStorageLocation,
"Contrat_mutuelle",
doc.name
);
case "PC":
return path.join(
consultantStorageLocation,
"Permis_de_conduire",
doc.name
);
case "MU":
return path.join(
consultantStorageLocation,
"mutuelle",
doc.name
);
case "AP":
return path.join(consultantStorageLocation, "ATT_prevoyance", doc.name);
}
}
/**
* Génère le nom de fichier basé sur le type de document, le prénom, le nom et l'extension.
*
* @param {string} typeDoc - Le type de document. Les valeurs possibles sont: "CV", "JD", "ASS", "PI", "CG", "PC", "IB", "SI", "CM", "AP".
* @param {string} firstname - Le prénom de la personne.
* @param {string} lastname - Le nom de famille de la personne.
* @param {string} extension - L'extension du fichier (par exemple, "pdf", "jpg").
* @returns {string} Le nom de fichier formaté.
*/
getFileName(typeDoc, firstname, lastname, extension) {
const typeDocNames = {
"CV": "7.CV",
"JD": "2.Justificatif de domicile",
"ASS": "1.Attestation De Droits SécuSocial",
"PI": "4.CNI",
"CG": "5.Carte grise",
"PC": "6.Permis de conduire",
"IB": "3.RIB",
"SI": "8.Simulation",
"CM": "9.Contrat mutuelle",
// "MU": "10.Mutuelle",
"AP": "10.Notice de prévoyance"
};
let baseName = typeDocNames[typeDoc] || typeDoc;
return `${baseName}-${firstname} ${lastname}.${extension}`;
}
sendWelcomeNail(user, cb) {
let welcomeMail = new WelcomeMail(user);
return welcomeMail.send(cb);
}
async delete(request) {
let {db} = this;
let connected = request.user;
let id = this.__getIdFromRequest(request);
const t = await db.sequelize.transaction();
try {
if (!id) {
throw new Error("cant update with no id");
} else {
let userToDelete = await db.Consultant.findOne({
where: {id},
include: [
{model: db.User},
{
model: db.Mission,
include: [{model: db.CraHistory}, {model: db.PrevHistory}],
},
],
});
if (userToDelete.type === "SuperAdmin") {
throw new Error("Impossible de supprimer l'utilisateur SuperAdmin ");
}
if (userToDelete.Missions.length > 0) {
let MissionWithPrevAndCra = userToDelete.Missions.some(
(mission) =>
mission.dateEnd === null &&
mission.PrevHistories.length > 0 &&
mission.CraHistories.length > 0
);
if (MissionWithPrevAndCra) {
throw new Error(
"Impossible de supprimer un consultant qui a une mission en cours contenant un Prev et un Cra."
);
} else {
await db.Action.create(
{
UtilisateurId: connected.id,
meta: JSON.stringify(userToDelete.toJSON()),
type: "suppression",
text: `<b>${connected.firstname} ${connected.lastname
}</b> a supprimé le consultant : <b>${userToDelete.Utilisateur.firstname
}-${userToDelete.Utilisateur.lastname}</b> le : ${new Date(
Date.now()
).toLocaleString("fr-FR")}`,
},
{transaction: t}
);
await userToDelete.Utilisateur.destroy(
{force: true},
{transaction: t}
);
await userToDelete.destroy({force: true}, {transaction: t});
for (const mission of userToDelete.Missions) {
mission.destroy({force: true});
}
}
} else {
await db.Action.create(
{
UtilisateurId: connected.id,
meta: JSON.stringify(userToDelete.toJSON()),
type: "suppression",
text: `<b>${connected.firstname} ${connected.lastname
}</b> a supprimé le consultant : <b>${userToDelete.Utilisateur.firstname
}-${userToDelete.Utilisateur.lastname}</b> le : ${new Date(
Date.now()
).toLocaleString("fr-FR")}`,
},
{transaction: t}
);
await userToDelete.Utilisateur.destroy(
{force: true},
{transaction: t}
);
await userToDelete.destroy({force: true}, {transaction: t});
}
return await t.commit();
}
} catch (error) {
await t.rollback();
throw error;
}
}
async validateSunscriber(request) {
let {db} = this;
const t = await db.sequelize.transaction();
try {
let connected = request.user;
let consultant = request.body;
// consultant.status = "VALID";
await db.Consultant.update(consultant, {
where: {id: consultant.id},
transaction: t
});
await db.Utilisateur.update(consultant.Utilisateur, {
where: {id: consultant.Utilisateur.id},
transaction: t
})
await db.Mission.update(consultant.Missions[0], {
where: {id: consultant.Missions[0].id},
transaction: t
});
await db.Client.update(consultant.Missions[0].Client, {
where: {id: consultant.Missions[0].Client.id},
transaction: t
});
await db.Action.create(
{
UtilisateurId: connected.id,
meta: JSON.stringify(consultant),
type: "Validation",
text: `<b>${connected.firstname} ${connected.lastname
}</b> a Valider le consultant : <b>${consultant.Utilisateur.firstname
}-${consultant.Utilisateur.lastname}</b> le : ${new Date(
Date.now()
).toLocaleString("fr-FR")}`,
},
{transaction: t}
);
if (consultant.status === "VALID") {
consultant.Utilisateur.link = await db.SecuredLink.create(
{
token: uuidv4(),
UtilisateurId: consultant.Utilisateur.id,
reason: "Consultant creation",
},
{transaction: t}
);
let w = new WelcomeMail(
consultant.Utilisateur,
"Confirmer votre inscription - My Intranet"
);
let infos = await w.send();
}
return await t.commit();
} catch (error) {
await t.rollback();
throw error;
}
}
}
module.exports = ConsultantService;