Пример #1
0
        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));
        }
Пример #2
0
        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);
        }
Пример #3
0
        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"));
        }
Пример #4
0
        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));
        }
Пример #5
0
        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));
        }
Пример #7
0
        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());
            }
        }
Пример #9
0
        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);
        }
Пример #10
0
        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);
        }