예제 #1
0
        //-------------------------------------------------------------------------------
        private CResultAErreur CreateVersionRecursif(CProjet projet)
        {
            CResultAErreur res = CResultAErreur.True;

            if (projet.Projet != null)
            {
                res = CreateVersionRecursif(projet.Projet);
            }
            if (!res)
            {
                return(res);
            }
            if (projet.IsNew() && projet.TypeProjet != null && projet.TypeProjet.OptionVersion.Code == timos.data.projet.EOptionTypeProjetVersion.VersionAutomatique)
            {
                res = projet.CreateDataVersionInCurrentContext();
            }
            return(res);
        }
예제 #2
0
        //-----------------------------------------------------
        private CResultAErreur AfficherEditeur(IElementDeProjet element)
        {
            CResultAErreur result = CResultAErreur.True;

            if (element is CProjet)
            {
                CProjet projet = (CProjet)element;
                if (projet.IsNew() && m_controlEdition.ModeEdition == EModeEditeurProjet.Selection)
                {
                    projet.BeginEdit();
                }

                CFormNavigateurPopup.Show(new CFormEditionProjet(projet));
                if (!projet.IsValide() || !projet.VerifieDonnees(false).Result)
                {
                    result = CResultAErreur.False;
                }
            }
            if (element is CIntervention)
            {
                CIntervention inter = (CIntervention)element;
                if (inter.IsNew() && m_controlEdition.ModeEdition == EModeEditeurProjet.Selection)
                {
                    inter.BeginEdit();
                }

                CFormNavigateurPopup.Show(new CFormEditionIntervention(inter));
                if (!inter.IsValide() || !inter.VerifieDonnees(false).Result)
                {
                    result = CResultAErreur.False;
                }
            }
            if (result)
            {
                ActualiserDesigner();
                GenererListeContenu();
            }
            return(result);
        }
예제 #3
0
        // /////////////////////////////////////////////////////////
        /// <summary>
        /// Le data du result contient un IBaseGantt
        /// </summary>
        /// <returns></returns>
        public static CResultAErreur CreateGantt ( 
            CProjet projet, 
            CParametreNiveauArbreGanttGroupe groupeRacine,
            CFiltreData filtreElements )
        {
            CResultAErreur result = CResultAErreur.True;
            if (projet == null)
                return result;
            CElementDeGanttProjet elementRacine = new CElementDeGanttProjet(null, projet);
            if (!result)
                return result;
            List<CProjet> lstProjets = new List<CProjet>();
            if (!projet.IsNew())//Si le projet est nouveau, on ne peut pas filtrer
                //car les éléments ne sont pas encore en base
            {
                CFiltreData filtre = result.Data as CFiltreData;
                filtre = CFiltreData.GetAndFiltre(filtreElements,
                    new CFiltreData(CProjet.c_champCodeSystemeComplet + " like @1 and " +
                        CProjet.c_champId + "<>@2",
                        projet.CodeSystemeComplet + "%",
                        projet.Id));
                CListeObjetsDonnees lstObjetProjets = new CListeObjetsDonnees(projet.ContexteDonnee, typeof(CProjet), filtre);

                lstObjetProjets.PreserveChanges = true;
                lstObjetProjets.ModeSansTri = true;
                lstProjets.AddRange(lstObjetProjets.ToList<CProjet>());


                lstObjetProjets.ReadDependances("ProjetsFils","LiensEnTantQueProjetA", "LiensEnTantQueProjetB", "ContraintesPropres", "AnomaliesDuProjet");
                CUtilElementAChamps.ReadChampsCustom(lstObjetProjets);
            }
            //Il faut ajouter les projets qui ne sont pas encore en base et qui n'ont donc pas de code system
            List<CProjet> lstALire = new List<CProjet>();
            lstALire.Add(projet);
            DataRelation relation = null;
            foreach ( DataRelation rel in projet.ContexteDonnee.Tables[CProjet.c_nomTable].ChildRelations )
            {
                if ( rel.ChildTable.TableName == CProjet.c_nomTable )
                {
                    relation = rel;
                    break;
                }
            }
            while (lstALire.Count > 0 && relation != null)
            {
                List<CProjet> prochaineGeneration = new List<CProjet>();
                foreach (CProjet test in lstALire)
                {
                    DataRow[] rowsDeps = test.Row.Row.GetChildRows(relation);
                    foreach (DataRow row in rowsDeps)
                    {
                        if (row.RowState != DataRowState.Deleted)
                        {
                            CProjet prj = new CProjet(row);
                            if (prj.IsNew() && !lstProjets.Contains(prj) )
                            {
                                lstProjets.Add(prj);
                                
                            }
                            prochaineGeneration.Add(prj);
                        }
                    }
                }
                lstALire = prochaineGeneration;
            }
           
            

            
            //Comme on est passé par un filtre Avancé, les nouveaux éléments ne sont
            //pas dans la liste. On les ajoute donc !
            //Vérifie qu'il y a des éléments dont l'id est négatif
            CListeObjetsDonnees lstTmp = new CListeObjetsDonnees(projet.ContexteDonnee,
                typeof(CProjet));
            lstTmp.Filtre = new CFiltreData(CProjet.c_champId + "<@1", 0);
            lstTmp.InterditLectureInDB = true;
            if (lstTmp.Count > 0)//Il y a des projets tous neufs dans le contexte
            {
                foreach (CProjet projetTmp in new ArrayList(lstProjets))
                {
                    //N'utilise pas ProjetsFils pour ne pas lire dans la base
                    CListeObjetsDonnees lstFils = new CListeObjetsDonnees(projet.ContexteDonnee,
                        typeof(CProjet),
                        new CFiltreData(CProjet.c_champIdParent + "=@1", projetTmp.Id));
                    lstFils.InterditLectureInDB = true;
                    lstFils.Filtre = new CFiltreData(CProjet.c_champId + "<0");
                    foreach (CProjet projetFils in lstFils)
                        if (!lstProjets.Contains(projetFils))
                            lstProjets.Add(projetFils);
                }
                //Les nouveaux sous projet du projet principal doivent également être ajoutés
                CListeObjetsDonnees lstFilsPrincipal = projet.ProjetsFils;
                lstFilsPrincipal.Filtre = new CFiltreData(CProjet.c_champId + "<0");
                foreach (CProjet projetFils in lstFilsPrincipal)
                    if (!lstProjets.Contains(projetFils))
                        lstProjets.Add(projetFils);
            }
            CContexteDonnee contexteDeTravail = projet.ContexteDonnee;

            return PrepareGantt(groupeRacine,result, elementRacine, lstProjets, contexteDeTravail);
        }
예제 #4
0
        //-------------------------------------------------------------------
        public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                result = base.TraitementAvantSauvegarde(contexte);
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
                return(result);
            }
            if (!result)
            {
                return(result);
            }
            DataTable table = contexte.Tables[GetNomTable()];

            if (table == null)
            {
                return(result);
            }
            HashSet <CProjet>     projetsARecalculer     = new HashSet <CProjet>();
            HashSet <CMetaProjet> metaProjetsARecalculer = new HashSet <CMetaProjet>();
            bool       bIsCalculatingAsynchrones         = CGestionnaireProjetsAsynchrones.IsModeCalculProjet(contexte);
            List <int> lstProjetsAsynchrones             = new List <int>();
            List <int> lstMetasProjetsAsynchrones        = new List <int>();

            foreach (DataRow row in new ArrayList(table.Rows))
            {
                if (!bIsCalculatingAsynchrones)
                {
                    GereProjetAsynchrone(row);
                }
                if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
                {
                    CProjet projet = new CProjet(row);

                    if (projet.ModeCalculDatesParentes == (int)EModeCalculDatesProjet.Suspended)
                    {
                        projet.ModeCalculDatesParentes = (int)EModeCalculDatesProjet.Automatic;
                    }
                    if (projet.IsNew())
                    {
                        result = CreateVersionRecursif(projet);
                        if (!result)
                        {
                            return(result);
                        }
                        projetsARecalculer.Add(projet);
                    }
                    // Si les dates réelles (Début ou fin ) sont renseignées, alors on mes le flag Dates Auto à False
                    if ((projet.DateDebutReel != null || projet.DateFinRelle != null) && !projet.HasChilds())
                    {
                        projet.DateDebutAuto = false;
                    }

                    // Si les dates planifiées on changées, force le Parent de plus haut niveau à recalculer ses dates
                    if (!row.HasVersion(DataRowVersion.Original) ||
                        (row[CProjet.c_champDateDebutPlanifiee] != row[CProjet.c_champDateDebutPlanifiee, DataRowVersion.Original] ||
                         row[CProjet.c_champDateFinPlanifiee] != row[CProjet.c_champDateFinPlanifiee, DataRowVersion.Original] ||
                         row[CProjet.c_champDateDebutReel] != row[CProjet.c_champDateDebutReel, DataRowVersion.Original] ||
                         row[CProjet.c_champDateFinReel] != row[CProjet.c_champDateFinReel, DataRowVersion.Original] ||
                         row[CProjet.c_champPctAvancement] != row[CProjet.c_champPctAvancement, DataRowVersion.Original] ||
                         row[CProjet.c_champPoids] != row[CProjet.c_champPoids, DataRowVersion.Original])
                        )
                    {
                        foreach (CRelationMetaProjet_Projet rel in projet.RelationsMetaProjets)
                        {
                            if (rel.IsValide() && rel.MetaProjet.IsValide())
                            {
                                if (rel.MetaProjet.ModeUpdateAsynchrone && rel.MetaProjet.Row.RowState != DataRowState.Added || bIsCalculatingAsynchrones)
                                {
                                    lstMetasProjetsAsynchrones.Add(rel.MetaProjet.Id);
                                }
                                else
                                {
                                    metaProjetsARecalculer.Add(rel.MetaProjet);
                                }
                            }
                        }
                        if (projet.IsNew() && !projet.HasChilds())
                        {
                            projet.CalcWeight(false);
                            projet.CalcProgress(false);
                        }
                        projet = projet.Projet;
                        while (projet != null && projet.IsValide())
                        {
                            if (!projet.ModeUpdateAsynchrone || projet.Row.RowState == DataRowState.Added || bIsCalculatingAsynchrones)
                            {
                                projetsARecalculer.Add(projet);
                                projet = projet.Projet;
                            }
                            else
                            {
                                lstProjetsAsynchrones.Add(projet.Id);
                                break;
                            }
                        }
                    }
                }

                if (row.RowState == DataRowState.Deleted)
                {
                    CProjet projet = new CProjet(row);
                    projet.VersionToReturn = DataRowVersion.Original;
                    if (projet.Projet != null && projet.Projet.IsValide())
                    {
                        projetsARecalculer.Add(projet.Projet);
                    }
                }
            }
            //Tri les projets par profondeur (du plus profond au moins profond)


            List <CProjet> lstProjetsTries = new List <CProjet>();

            foreach (CProjet projet in projetsARecalculer)
            {
                if (projet.Row.RowState != DataRowState.Deleted)
                {
                    lstProjetsTries.Add(projet);
                }
            }
            try
            {
                lstProjetsTries.Sort(delegate(CProjet x, CProjet y)
                {
                    return(-x.CodeSystemeComplet.Length.CompareTo(y.CodeSystemeComplet.Length));
                });
            }
            catch (Exception ex)
            {
                result.EmpileErreur(new CErreurException(ex));
                return(result);
            }



            // Recalcul les dates PLANIFIEES des projets marqués A recalculés, et leur Avancement
            foreach (CProjet projet in lstProjetsTries)
            {
                if (projet.HasChilds())
                {
                    projet.UpdateDateDebutPlanifieeCalculeeFromChilds();
                    projet.UpdateDateFinPlanifieeCalculeeFromChilds();
                    projet.UpdateDateDebutReelleFromFils();
                    projet.UpdateDateFinReelleFromFils();
                }
                projet.UpdateWeight();
                projet.UpdateProgress();
            }
            foreach (CMetaProjet meta in metaProjetsARecalculer)
            {
                meta.UpdateDateDebutPlanifieeFromChilds(true);
                meta.UpdateDateFinPlanifieeFromChilds(true);
                meta.UpdateDateDebutReelleFromChilds(true);
                meta.UpdateDateFinReelleFromChilds(true);
                meta.CalcProgress(false);
            }
            if (!bIsCalculatingAsynchrones)
            {
                CGestionnaireProjetsAsynchrones.ASyncCalc(IdSession, lstProjetsAsynchrones, lstMetasProjetsAsynchrones);
            }
            return(result);
        }