public ActionResult Add(string utilisateurId, [FromBody] MandatViewModel mandat)
{
var utilisateur = utilisateurGraphRepository.GetOne(utilisateurId);
var conseiller = utilisateur.Conseiller;
var societeDeConseil = new Employeur {
Nom = mandat.NomEntreprise
};
var client = new Client {
Nom = mandat.NomClient
};
var projet = new Projet
{
DateDebut = mandat.DebutProjet,
CellulaireReference = mandat.CellulaireReference,
Description = mandat.ContexteProjet,
CourrielReference = mandat.CourrielReference,
Envergure = mandat.Envergure,
DateFin = mandat.FinProjet,
FonctionReference = mandat.FonctionReference,
NomReference = mandat.NomReference,
TelephoneReference = mandat.TelephoneReference,
Nom = mandat.TitreProjet,
SocieteDeConseil = societeDeConseil,
Client = client,
Technologies = mandat.Technologies.Select(x => technologieGraphRepository.GetOne(x.GraphId)).ToList()
};
var fonction = fonctionGraphRepository.GetOne(mandat.GraphIdFonction);
var mandatModel = new Mandat
{
DateDebut = mandat.DebutMandat,
Efforts = mandat.Efforts,
DateFin = mandat.FinMandat,
Numero = mandat.NumeroMandat.ToString(),
Description = mandat.PorteeDesTravaux,
Titre = mandat.TitreMandat,
Fonction = fonction,
Projet = projet,
Taches = mandat.Taches.Select(x => tacheGraphRepository.Search(new Tache {
Description = x.Description
}, true).First()).ToList()
};
conseiller.Mandats.Add(mandatModel);
mandatGraphRepository.Add(mandatModel);
editionObjectGraphRepository.AjouterNoeud(objetAjoute: mandatModel, viewModelProprieteNom: "Mandats", noeudModifie: utilisateur.Conseiller);
mandat.GraphId = mandatModel.GraphKey;
return(Json(mandat));
}
private void AssemblerTache(CVSection environnementSection, Mandat mandat)
{
var taches = environnementSection.Nodes.Cast <XmlDocParagraph>().ToList().Skip(1);
var tachesObj = taches.Select(x => new Tache()
{
Description = x.GetParagraphText()
});
mandat.Taches.AddRange(tachesObj);
}
public ActionResult CreateMandat(MandatModel pm)
{
Mandat m = new Mandat
{
StartDate = pm.StartDate,
EndDate = pm.EndDate
};
return(View(pm));
sm.Add(m);
sm.Commit();
return(RedirectToAction("FrontEndLayout"));
}
private List <TacheViewModel> GetTaches(string utilisateurId, Mandat mandat)
{
var noeudsModifie = new List <GraphObject> {
mandat
};
var taches = mandat.Taches.Cast <GraphObject>().ToList();
var tachesViewModels = ViewModelFactory <Tache, TacheViewModel> .GetViewModels(
utilisateurId : utilisateurId,
noeudsModifie : noeudsModifie,
graphObjects : taches,
map : mapTache);
return(tachesViewModels.ConvertAll(x => (TacheViewModel)x));
}
private List <TechnologieViewModel> GetTechnologies(string utilisateurId, Mandat mandat)
{
var noeudsModifie = new List <GraphObject> {
mandat
};
var technologies = mandat.Projet.Technologies.Cast <GraphObject>().ToList();
var techsViewModels = ViewModelFactory <Technologie, TechnologieViewModel> .GetViewModels(
utilisateurId : utilisateurId,
noeudsModifie : noeudsModifie,
graphObjects : technologies,
map : mapTechnologie);
return(techsViewModels.ConvertAll(x => (TechnologieViewModel)x));
}
// GET: Mandat/Create
public ActionResult Create()
{
Mandat mandat = new Mandat();
var x = clientService.GetAll().Select(c => new SelectListItem
{
Text = c.idProject.ToString() + "",
Value = c.idProject + ""
});
var y = rs.GetAll().Select(e => new SelectListItem
{
Text = e.Id.ToString(),
Value = e.Id + ""
});
mandat.Projects = x;
mandat.Ressources = y;
return(View(mandat));
}
private List <Mandat> AssemblerMandats(CVSection clientSection)
{
List <Mandat> mandats = null;
try
{
mandats = new List <Mandat>();
List <XmlDocNode> mandatsNodes = new List <XmlDocNode>(),
mandatNodes = new List <XmlDocNode>();
mandatsNodes.AddRange(clientSection.Nodes.SkipWhile(x => x is XmlDocParagraph));
do
{
try
{
mandatNodes.Add(mandatsNodes.First(x => x is XmlDocTable));
mandatNodes.AddRange(mandatsNodes.SkipWhile(x => x is XmlDocTable).TakeWhile(x => x is XmlDocParagraph));
mandatsNodes.RemoveAll(x => mandatNodes.Contains(x));
Mandat mandat = AssemblerMandat(mandatNodes);
mandats.Add(mandat);
mandatNodes.Clear();
}
catch (Exception ex)
{
WriteToErrorLog(ex);
mandatNodes.Clear();
}
} while (mandatsNodes.Count > 0);
}
catch (Exception ex)
{
WriteToErrorLog(ex);
}
return(mandats);
}
public ActionResult Create(Mandat mandat)
{
try
{
// TODO: Add insert logic here
Domain.Entity.Mandat m = new Domain.Entity.Mandat();
m.date_debut = mandat.date_debut;
m.date_fin = mandat.date_fin;
m.idProject = mandat.idProject;
m.IdRessource = mandat.IdRessource;
m.NomMandat = mandat.NomMandat;
//m.archive = mandat.archive;
ms.Add(m);
ms.Commit();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
private Mandat AssemblerMandat(List <XmlDocNode> mandatNodes)
{
ProjetGraphRepository projetGraphRepository = new ProjetGraphRepository();
FonctionGraphRepository fonctionGraphRepository = new FonctionGraphRepository();
TechnologieGraphRepository technologieGraphRepository = new TechnologieGraphRepository();
Mandat mandat = new Mandat();
Projet projet = new Projet();
Technologie technologie = null;
int parseInt = 0, mois, annee;
string concatenatedString, envergureText, environnement, tech;
string[] periode, debut, fin, splitedString, technologies;
List <XmlDocParagraph> infoParagraphs = new List <XmlDocParagraph>(), infoParagraphsSecondColumn = new List <XmlDocParagraph>();
XmlDocTable infoTable = (XmlDocTable)mandatNodes.First(x => x is XmlDocTable);
infoParagraphs.AddRange(infoTable.GetParagraphsFromColumn(1));
infoParagraphsSecondColumn.AddRange(infoTable.GetParagraphsFromColumn(2));
for (int i = 0; i < infoParagraphs.Count; i++)
{
concatenatedString = string.Empty;
if (infoParagraphs[i].GetParagraphText().Contains("Projet"))
{
projet.Nom = infoParagraphsSecondColumn[i].GetParagraphText();
}
if (infoParagraphs[i].GetParagraphText().Contains("Mandat"))
{
mandat.Numero = infoParagraphsSecondColumn[i].GetParagraphText();
}
if (infoParagraphs[i].GetParagraphText().Contains("Envergure"))
{
envergureText = infoParagraphsSecondColumn[i].GetParagraphText().Trim();
if (envergureText.Any(x => char.IsDigit(x)))
{
projet.Envergure = int.Parse(string.Join("", envergureText.Where(x => char.IsDigit(x)).ToArray()));
}
}
if (infoParagraphs[i].GetParagraphText().Contains("Fonction"))
{
Fonction fonction;
fonction = fonctionGraphRepository.CreateIfNotExists(new Dictionary <string, object> {
{ "Description", infoParagraphsSecondColumn[i].GetParagraphText() }
});
mandat.Fonction = fonction;
}
if (infoParagraphs[i].GetParagraphText().Contains("Période"))
{
periode = infoParagraphsSecondColumn[i].GetParagraphText().Split("à");
if (periode.Length > 1)
{
debut = periode[0].Trim().Split(" ").Where(x => !string.IsNullOrEmpty(x)).ToArray();
if (debut.Length > 1)
{
mois = DicMois[RemoveAcentuation(debut[0].Trim().ToUpper())];
annee = int.Parse(debut[1].Trim());
mandat.DateDebut = DateTime.Parse($"{annee}-{mois}-01");
}
if (periode[1].Contains("ce jour"))
{
mandat.DateFin = DateTime.MinValue;
}
else
{
fin = periode[1].Trim().Split(" ").Where(x => !string.IsNullOrEmpty(x)).ToArray();
if (fin.Length > 1)
{
mois = DicMois[RemoveAcentuation(fin[0].Trim().ToUpper())];
annee = int.Parse(fin[1].Sanitize());
mandat.DateFin = DateTime.Parse($"{annee}-{mois}-01");
}
}
}
}
if (infoParagraphs[i].GetParagraphText().Contains("Efforts"))
{
splitedString = infoParagraphsSecondColumn[i].GetParagraphText().Split(" ");
parseInt = 0;
if (int.TryParse(splitedString[0], out parseInt))
{
mandat.Efforts = parseInt;
}
}
if (infoParagraphs[i].GetParagraphText().Contains("Référence"))
{
projet.NomReference = infoParagraphsSecondColumn[i].GetParagraphText();
}
}
infoParagraphsSecondColumn.Clear();
infoParagraphsSecondColumn = null;
infoParagraphs.Clear();
infoParagraphs = mandatNodes.SkipWhile(x => x is XmlDocTable).Cast <XmlDocParagraph>().ToList();
var sections = new List <CVSection>();
SectionsExtractor CvSectionsExtractor = new SectionsExtractor();
List <XmlNode> Nodes = (List <XmlNode>)infoParagraphs.Select(x => x.OriginalNode).ToList();
List <IXmlToken> matchTokens = new List <IXmlToken>();
matchTokens.Add(MandatTextToken.CreateTextToken());
try
{
sections = CvSectionsExtractor.GetCVSections(Nodes, matchTokens, "DESCRIPTION");
aSection = sections.DefaultIfEmpty(null).FirstOrDefault(x => x.Identifiant == "DESCRIPTION");
AssemblerDescription(aSection, projet);
}
catch (Exception ex)
{
WriteToErrorLog(ex);
}
try
{
aSection = sections.DefaultIfEmpty(null).FirstOrDefault(x => x.Identifiant == "ENVIRONNEMENT TECHNOLOGIQUE");
AssemblerEnvironnementTecnologic(aSection, projet);
}
catch (Exception ex)
{
WriteToErrorMessageLog("Mandat" + projet.Description);
WriteToErrorLog(ex);
}
try
{
aSection = sections.DefaultIfEmpty(null).FirstOrDefault(x => x.Identifiant == "LES TÂCHES SUIVANTES");
AssemblerTache(aSection, mandat);
}
catch (Exception ex)
{
WriteToErrorMessageLog("Mandat: " + projet.Nom);
WriteToErrorLog(ex);
}
mandat.Titre = projet.Nom;
mandat.Projet = projet;
projet.DateDebut = mandat.DateDebut;
projet.DateFin = mandat.DateFin;
return(mandat);
}
public Utilisateur Map(CVViewModel cVViewModel)
{
Utilisateur utilisateur = new Utilisateur();
utilisateur.GraphKey = cVViewModel.GraphIdUtilisateur;
utilisateur.Prenom = cVViewModel.Prenom;
utilisateur.Nom = cVViewModel.Nom;
utilisateur.Conseiller = new Conseiller {
GraphKey = cVViewModel.GraphIdConseiller
};
utilisateur.Conseiller.Fonction = new Fonction();
utilisateur.Conseiller.Fonction.GraphKey = cVViewModel.GraphIdFonction;
utilisateur.Conseiller.Fonction.Description = cVViewModel.Fonction;
utilisateur.Conseiller.CVs.Add(new CV());
utilisateur.Conseiller.CVs.First().GraphKey = cVViewModel.GraphIdCV;
utilisateur.Conseiller.CVs.First().ResumeExperience = cVViewModel.Biographie;
foreach (DomaineDInterventionViewModel domaineDIntervention in cVViewModel.DomainesDIntervention)
{
utilisateur.Conseiller.DomaineDInterventions.Add(new DomaineDIntervention {
GraphKey = domaineDIntervention.GraphId, Description = domaineDIntervention.Description
});
}
foreach (FormationAcademiqueViewModel formationAcademique in cVViewModel.FormationsAcademique)
{
FormationScolaire formationScolaire = new FormationScolaire();
formationScolaire.GraphKey = formationAcademique.GraphId;
formationScolaire.Diplome = formationAcademique.Diplome;
formationScolaire.DateConclusion = formationAcademique.Annee;
formationScolaire.Ecole = new Instituition();
formationScolaire.Ecole.GraphKey = formationAcademique.GraphIdEtablissement;
formationScolaire.Ecole.Nom = formationAcademique.Etablissement;
utilisateur.Conseiller.FormationsScolaires.Add(formationScolaire);
}
foreach (CertificationViewModel certification in cVViewModel.Certifications)
{
utilisateur.Conseiller.Formations.Add(new Formation {
GraphKey = certification.GraphId, Description = certification.Description, AnAcquisition = certification.Annee, Type = new Genre {
GraphKey = certification.GraphIdGenre, Descriminator = "Formation", Description = "Certification"
}
});
}
foreach (MandatViewModel mandatViewModel in cVViewModel.Mandats)
{
Mandat mandat = new Mandat();
mandat.GraphKey = mandatViewModel.GraphId;
mandat.Projet = new Projet {
GraphKey = mandatViewModel.GraphIdProjet
};
mandat.Projet.Client = new Client {
GraphKey = mandatViewModel.GraphIdClient
};
mandat.Projet.Client.Nom = mandatViewModel.NomClient;
mandat.Numero = mandatViewModel.NumeroMandat.ToString();
mandat.Projet.SocieteDeConseil = new Employeur {
GraphKey = mandatViewModel.GraphIdSocieteDeConseil
};
mandat.Projet.SocieteDeConseil.Nom = mandatViewModel.NomEntreprise;
mandat.Projet.Nom = mandatViewModel.TitreProjet;
mandat.Titre = mandatViewModel.TitreMandat;
mandat.Projet.Envergure = mandatViewModel.Envergure;
mandat.Efforts = mandatViewModel.Efforts;
mandat.Fonction = new Fonction {
GraphKey = mandatViewModel.GraphIdFonction
};
mandat.Fonction.Description = mandatViewModel.Fonction;
mandat.Projet.Description = mandatViewModel.ContexteProjet;
mandat.Description = mandatViewModel.PorteeDesTravaux;
mandat.Projet.DateDebut = mandatViewModel.DebutProjet;
mandat.Projet.DateFin = mandatViewModel.FinProjet;
mandat.DateDebut = mandatViewModel.DebutMandat;
mandat.DateFin = mandatViewModel.FinMandat;
mandat.Projet.NomReference = mandatViewModel.NomReference;
mandat.Projet.TelephoneReference = mandatViewModel.TelephoneReference;
mandat.Projet.CellulaireReference = mandatViewModel.CellulaireReference;
mandat.Projet.CourrielReference = mandatViewModel.CourrielReference;
mandat.Projet.FonctionReference = mandatViewModel.FonctionReference;
foreach (TechnologieViewModel technologie in mandatViewModel.Technologies)
{
mandat.Projet.Technologies.Add(new Technologie {
GraphKey = technologie.GraphId, Nom = technologie.Description
});
}
foreach (TacheViewModel tache in mandatViewModel.Taches)
{
mandat.Taches.Add(new Tache {
GraphKey = tache.GraphId, Description = tache.Description
});
}
utilisateur.Conseiller.Mandats.Add(mandat);
}
foreach (TechnologieViewModel technologie in cVViewModel.Technologies)
{
utilisateur.Conseiller.Technologies.Add(new Technologie {
GraphKey = technologie.GraphId, Nom = technologie.Description, MoisDExperience = technologie.Mois
});
}
foreach (PerfectionnementViewModel perfeccionnement in cVViewModel.Perfectionnements)
{
utilisateur.Conseiller.Formations.Add(new Formation {
GraphKey = perfeccionnement.GraphId, Description = perfeccionnement.Description, AnAcquisition = perfeccionnement.Annee, Type = new Genre {
GraphKey = perfeccionnement.GraphIdGenre, Descriminator = "Formation", Description = "Perfectionnement"
}
});
}
foreach (LangueViewModel langueViewModel in cVViewModel.Langues)
{
Langue langue = new Langue();
langue.GraphKey = langueViewModel.GraphId;
langue.Nom = langueViewModel.Nom;
if (langueViewModel.NiveauParle == null)
{
langue.Parle = Niveau.Avancé;
}
else
{
langue.Parle = (Niveau)System.Enum.Parse(typeof(Niveau), langueViewModel.NiveauParle);
}
if (langueViewModel.NiveauEcrit == null)
{
langue.Ecrit = Niveau.Avancé;
}
else
{
langue.Ecrit = (Niveau)System.Enum.Parse(typeof(Niveau), langueViewModel.NiveauEcrit);
}
if (langueViewModel.NiveauLu == null)
{
langue.Lu = Niveau.Avancé;
}
else
{
langue.Lu = (Niveau)System.Enum.Parse(typeof(Niveau), langueViewModel.NiveauLu);
}
utilisateur.Conseiller.Langues.Add(langue);
}
return(utilisateur);
}
