//---------------------------------------------
 public double CalcImputationAFaireSur(IElementACout elementACout, bool bCoutReel)
 {
     if (elementACout == null || elementACout.Row.RowState == DataRowState.Deleted)
     {
         return(0);
     }
     return(CUtilElementACout.CalcImputationAFaireSur(this, elementACout, bCoutReel));
 }
 //---------------------------------------------
 public double RecalcActualCost(IIndicateurProgression indicateur)
 {
     CUtilElementACout.RecalculeCoutDescendant(this, true, true, indicateur);
     return(CoutReel);
 }
 //---------------------------------------------
 public double RecalcEstimatedCost(IIndicateurProgression indicateur)
 {
     CUtilElementACout.RecalculeCoutDescendant(this, false, true, indicateur);
     return(CoutPrevisionnel);
 }
 //---------------------------------------------
 public void SetCoutAvecCalculDesParents(double fValeur, bool bCoutReel)
 {
     SetCoutSansCalculDesParents(fValeur, bCoutReel);
     CUtilElementACout.OnChangeCout(this, bCoutReel, false);
 }
Exemple #5
0
        //------------------------------------------------------------------------------------------------------------------------------
        private static void RecalcCoutMontant(IElementACout source, bool bCoutReel, HashSet <DataRow> setDejaRecalcules)
        {
            if (source == null)
            {
                return;
            }
            if (setDejaRecalcules.Contains(source.Row.Row))
            {
                return;
            }
            setDejaRecalcules.Add(source.Row.Row);


            if (source.Row.RowState == DataRowState.Deleted || source.Row.RowState == DataRowState.Detached)
            {
                source.VersionToReturn = DataRowVersion.Original;
            }
            CImputationsCouts       imputations      = source.GetImputationsAFaireSurUtilisateursDeCout();
            HashSet <IElementACout> elementsModifies = new HashSet <IElementACout>();
            CValeursImputées        newValeurs       = GetValeursImputéesSurUtilisateurs(source);

            newValeurs.Reset(bCoutReel);
            CValeursImputées oldValeurs         = GetValeursImputéesSurUtilisateurs(source);
            HashSet <string> newElementsImputes = new HashSet <string>();

            if (source.Row.RowState != DataRowState.Deleted && source.Row.RowState != DataRowState.Deleted)
            {
                if (!source.IsCoutFromSources(bCoutReel))
                {
                    double fCout = source.CalculeTonCoutPuisqueTuNeCalculePasAPartirDesSourcesDeCout(bCoutReel);
                    source.SetCoutSansCalculDesParents(fCout, bCoutReel);
                    SetValeurImputéeDeSource(source, source, bCoutReel ? source.CoutReel : source.CoutPrevisionnel, bCoutReel);
                    newValeurs.SetImputation(source, bCoutReel ? source.CoutReel : source.CoutPrevisionnel, bCoutReel);
                    newElementsImputes.Add(source.IdUniversel);
                }
            }


            foreach (CImputationCout imputation in imputations.Imputations)
            {
                newElementsImputes.Add(imputation.UtilisateurDeCout.IdUniversel);
                IElementACout utilisateur = imputation.UtilisateurDeCout;
                if (utilisateur.Row.RowState == DataRowState.Deleted || utilisateur.Row.RowState == DataRowState.Deleted)
                {
                    newValeurs.SetImputation(utilisateur, 0, bCoutReel);
                }
                else
                {
                    double fOld = oldValeurs.GetImputation(utilisateur, bCoutReel);
                    double fNew = 0;



                    if (source.Row.RowState != DataRowState.Deleted && source.Row.RowState != DataRowState.Detached)
                    {
                        fNew = source.CalcImputationAFaireSur(utilisateur, bCoutReel);
                    }
                    if (Math.Abs(fOld - fNew) > 0.01)
                    {
                        elementsModifies.Add(utilisateur);
                        setDejaRecalcules.Remove(utilisateur.Row.Row);
                        double fVal = bCoutReel ? utilisateur.CoutReel : utilisateur.CoutPrevisionnel;
                        fVal -= fOld;
                        fVal += fNew;
                        utilisateur.SetCoutSansCalculDesParents(fVal, bCoutReel);
                        SetValeurImputéeDeSource(utilisateur, source, fNew, bCoutReel);
                    }
                    newValeurs.SetImputation(utilisateur, fNew, bCoutReel);
                }
                CUtilElementACout.SetValeursImputéesSurUtilisateurs(source, newValeurs);
            }

            //Enlève les valeurs qui ont été imputées sur des éléments qui ne sont plus imputés
            foreach (IElementACout utilisateur in oldValeurs.GetObjetsImputés(source.ContexteDonnee))
            {
                if (!newElementsImputes.Contains(utilisateur.IdUniversel))
                {
                    //On avait imputé ce type, mais il ne faut plus
                    //Vérifie que le coût de cet utilisateur intègre bien mon cout
                    CValeursImputées valeurs = GetValeursImputéesDeSources(utilisateur);
                    if (valeurs.ContainsElement(source, bCoutReel))
                    {
                        double fImput = oldValeurs.GetImputation(utilisateur, bCoutReel);
                        if (fImput > 0.001)
                        {
                            elementsModifies.Add(utilisateur);
                            setDejaRecalcules.Remove(utilisateur.Row.Row);
                            double fVal = bCoutReel ? utilisateur.CoutReel : utilisateur.CoutPrevisionnel;
                            fVal -= fImput;
                            utilisateur.SetCoutSansCalculDesParents(fVal, bCoutReel);
                            SetValeurImputéeDeSource(utilisateur, source, 0, bCoutReel);
                        }
                    }
                }
            }


            if (source.Row.RowState != DataRowState.Deleted && source.Row.RowState != DataRowState.Detached)
            {
                source.TypesCoutsParentsARecalculer &= bCoutReel ? ~ETypeCout.réel : ~ETypeCout.Prévisionnel;
            }

            foreach (IElementACout eltModif in elementsModifies)
            {
                RecalcCoutMontant(eltModif, bCoutReel, setDejaRecalcules);
            }
        }