//------------------------------------------------------------------------------------------------------------------------------
private static void OnChangeCoutSansCalculCoutDescendant(IElementACout source, bool bCoutReel, bool bImmediatement)
{
List <IElementACout> lstSources = new List <IElementACout>();
lstSources.Add(source);
OnChangeCoutSansCalculCoutDescendant(lstSources, bCoutReel, bImmediatement);
}
//---------------------------------------------------------
public void AddImputation(IElementACout elt, double fRatio, CRelationBesoin_Satisfaction relationAssociée)
{
if (elt != null)
{
AddImputation(new CImputationCout(elt, fRatio, relationAssociée));
}
}
//------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Recalcule un cout
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="elementARecalculer"></param>
/// <param name="bCoutReel"></param>
/// <param name="bRecursif"></param>
/// <returns></returns>
public static CResultAErreur RecalculeCoutDescendant(IElementACout elementARecalculer, bool bCoutReel, bool bRecursif, IIndicateurProgression indicateur)
{
List <IElementACout> lstElements = new List <IElementACout>();
lstElements.Add(elementARecalculer);
return(RecalculeCoutsDescendants(lstElements, bCoutReel, bRecursif, indicateur));
}
//------------------------------------------------------------------------------------------------------------------------------
public static void OnChangeCout(IElementACout source, bool bCoutReel, bool bImmediatement)
{
List <IElementACout> lstSources = new List <IElementACout>();
lstSources.Add(source);
OnChangeCout(lstSources, bCoutReel, bImmediatement);
}
//---------------------------------------------
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 CalcImputationAFaireSur(IElementACout elementACout, bool bCoutReel)
{
if (elementACout is CIntervention && elementACout.Id == Intervention.Id && bCoutReel)
{
return(CoutReel);
}
return(0);
}
//------------------------------------------------------------------------------------------------------------------------------
private static void SetValeursImputéesDeSources(IElementACout utilisateur, CValeursImputées valeurs)
{
if (utilisateur == null || utilisateur.Row.RowState == DataRowState.Deleted || utilisateur.Row.RowState == DataRowState.Detached)
{
return;
}
utilisateur.Row[c_champImputationsParLesSources] = valeurs.GetStringSerialization();
}
//------------------------------------------------------------------------------------------------------------------------------
private static void SetValeursImputéesSurUtilisateurs(IElementACout source, CValeursImputées valeurs)
{
if (source == null || source.Row.RowState == DataRowState.Deleted || source.Row.RowState == DataRowState.Detached)
{
return;
}
source.Row[c_champImputationsVersUtilisateurs] = valeurs.GetStringSerialization();
}
//------------------------------------------------------------------------------------------------------------------------------
public static bool IsSourceDe(IElementACout elementSource, IElementACout utilisateur)
{
HashSet <IElementACout> setUtilisateurs = new HashSet <IElementACout>();
FillSetUtilisateurs(elementSource, setUtilisateurs, utilisateur);
if (setUtilisateurs.Contains(utilisateur))
{
return(true);
}
return(false);
}
//------------------------------------------------------------------------------------------------------------------------------
private static void SetValeurImputéeSurUtilisateur(IElementACout source, IElementACout utilisateur, double fImputation, bool bCoutReel)
{
if (source.Row.RowState == DataRowState.Deleted || source.Row.RowState == DataRowState.Deleted)
{
return;
}
CValeursImputées valeurs = GetValeursImputéesSurUtilisateurs(source);
valeurs.SetImputation(utilisateur, fImputation, bCoutReel);
SetValeursImputéesSurUtilisateurs(source, valeurs);
}
//------------------------------------------------------------------------------------------------------------------------------
public static double CalcImputationAFaireSur(IElementACout source, IElementACout utilisateur, bool bCoutReel)
{
if (source == null || source.Row.RowState == DataRowState.Detached || source.Row.RowState == DataRowState.Deleted ||
utilisateur == null || utilisateur.Row.RowState == DataRowState.Deleted || utilisateur.Row.RowState == DataRowState.Detached)
{
return(0);
}
CImputationsCouts imputations = source.GetImputationsAFaireSurUtilisateursDeCout();
return(imputations.GetCoutImputéeA(utilisateur, bCoutReel));
}
//---------------------------------------------------------
public CImputationCout GetImputation(IElementACout elt)
{
if (elt == null)
{
return(null);
}
CImputationCout imputation = null;
m_dicImputations.TryGetValue(elt, out imputation);
return(imputation);
}
//------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Note toutes les sources d'un élément, sources appartenant aux types spécifiés,
/// qu'elle doivent noter leur cout comme modifié
/// </summary>
/// <param name="elt"></param>
/// <param name="typesDesElementsAInvalider"></param>
public static void InvalideLeCoutDesSources(IElementACout elt, bool bCoutReel, params Type[] typesDesElementsAInvalider)
{
HashSet <IElementACout> setFaits = new HashSet <IElementACout>();
HashSet <Type> typesAInvalider = new HashSet <Type>();
foreach (Type tp in typesDesElementsAInvalider)
{
typesAInvalider.Add(tp);
}
InvalideLeCoutDesSources(elt, bCoutReel, typesAInvalider, setFaits);
}
//--------------------------------------------------------------------------
public double GetCoutResume(bool bCoutReel)
{
Dictionary <IElementACout, bool> setElementToAPrendreEnCompte = new Dictionary <IElementACout, bool>();
FillSetElementsACoutPourResumeCout(bCoutReel, setElementToAPrendreEnCompte);
Dictionary <IElementACout, CImputationsCouts> cacheImputations = new Dictionary <IElementACout, CImputationsCouts>();
//On a tous les besoins dans un hashet, maintenant, il faut sommer les couts
double fCout = 0;
foreach (KeyValuePair <IElementACout, bool> kv in setElementToAPrendreEnCompte)
{
if (kv.Value)
{
IElementACout element = kv.Key;
if (element is CBesoin)
{
bool bSourceInSet = false;
foreach (IElementACout elt in element.GetSourcesDeCout(bCoutReel))
{
if (setElementToAPrendreEnCompte.ContainsKey(elt))
{
bSourceInSet = true;
break;
}
}
if (!bSourceInSet)
{
fCout += bCoutReel ? element.CoutReel : element.CoutPrevisionnel;
}
else
{
foreach (IElementACout source in element.GetSourcesDeCout(bCoutReel))
{
if (!setElementToAPrendreEnCompte.ContainsKey(source))
//Si la source est dans le set, elle sera ajoutée, donc on ne la prend pas
{
CImputationsCouts imputations = null;
if (!cacheImputations.TryGetValue(source, out imputations))
{
imputations = source.GetImputationsAFaireSurUtilisateursDeCout();
cacheImputations[source] = imputations;
}
fCout += imputations.GetCoutImputéeA(element, bCoutReel);
}
}
}
}
}
}
return(fCout);
}
//---------------------------------------------------------
void itemElementACout_MouseUp(object sender, MouseEventArgs e)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
if (item != null && (e.Button == MouseButtons.Right || item.DropDownItems.Count == 0))
{
IElementACout elt = item != null ? item.Tag as IElementACout : null;
if (elt != null)
{
CFormMain.GetInstance().EditeElement(elt.ObjetPourEditionElementACout, false, "");
}
}
}
//--------------------------------------------------
public double GetImputation(IElementACout element, bool bCoutReel)
{
if (element == null)
{
return(0);
}
string strKey = GetKey(element, bCoutReel);
if (m_dicImputations.ContainsKey(strKey))
{
return(m_dicImputations[strKey]);
}
return(0);
}
private ToolStripItem CreateItemSatisfaction(IElementACout utilisateur, IElementACout source)
{
CImputationsCouts imputation = source.GetImputationsAFaireSurUtilisateursDeCout();
if (imputation != null)
{
CImputationCout i = imputation.GetImputation(utilisateur);
if (i != null && i.Poids != 0)
{
double fVal = imputation.GetCoutImputéeA(utilisateur, m_bMenuForCoutReel);
ToolStripMenuItem itemElementACout = new ToolStripMenuItem();
itemElementACout.Text = fVal.ToString("0.####") + " ";
if (source is ISatisfactionBesoin)
{
itemElementACout.Text += ((ISatisfactionBesoin)source).LibelleSatisfactionComplet;
}
else
{
itemElementACout.Text += source.Libelle;
}
if (source is ISatisfactionBesoin && utilisateur is CBesoin)
{
double fPct = CUtilSatisfaction.GetPourcentageFor((CBesoin)utilisateur, (ISatisfactionBesoin)source);
itemElementACout.Text += " (" + fPct.ToString("0.##") + "%)";
}
else
{
itemElementACout.Text += " (100%)";
}
itemElementACout.Tag = source;
itemElementACout.Image = DynamicClassAttribute.GetImage(source.GetType());
if (fVal == 0)
{
itemElementACout.BackColor = Color.LightPink;
}
if (source.GetSourcesDeCout(m_bMenuForCoutReel).Length > 0)
{
ToolStripMenuItem dummy = new ToolStripMenuItem();
itemElementACout.DropDownItems.Add(dummy);
itemElementACout.DropDownOpening += new EventHandler(itemElementACout_DropDownOpening);
}
itemElementACout.MouseUp += new MouseEventHandler(itemElementACout_MouseUp);
return(itemElementACout);
}
}
return(null);
}
//------------------------------------------------------------------------------------------------------------------------------
private static void AffecteValeurCalcSansSourcesToElement(IElementACout element, bool bCoutReel)
{
if (element == null)
{
return;
}
double fCout = element.CalculeTonCoutPuisqueTuNeCalculePasAPartirDesSourcesDeCout(bCoutReel);
element.SetCoutSansCalculDesParents(fCout, bCoutReel);
CValeursImputées valeurs = GetValeursImputéesDeSources(element);
valeurs.Reset(bCoutReel);
valeurs.SetImputation(element, fCout, bCoutReel);
SetValeurImputéeSurUtilisateur(element, element, fCout, bCoutReel);
}
//--------------------------------------------------
private string GetKey(IElementACout element, bool bCoutReel)
{
string strType = element.GetType().Sc2iTypeId();
string strIdUniversel = "";
if (element.Row.RowState == DataRowState.Deleted || element.Row.RowState == DataRowState.Detached)
{
strIdUniversel = (string)element.Row[CObjetDonnee.c_champIdUniversel, DataRowVersion.Original];
}
else
{
strIdUniversel = element.IdUniversel;
}
return(strType + "|" + strIdUniversel + "|" + (bCoutReel ? "1" : "0"));
}
//Les outils de stockage de cout imputé ne doivent pas être utilisée en dehors,
//car ces valeurs risquent d'être mals exploitées. La Somme des valeurs imputées de source
//Peut ne pas être égale au cout correspondant, ça peut arriver lors d'un changement
//de destination de cout par exemple.
//------------------------------------------------------------------------------------------------------------------------------
private static CValeursImputées GetValeursImputéesSurUtilisateurs(IElementACout elementSource)
{
if (elementSource == null)
{
return(new CValeursImputées());
}
string strTmp = "";
if (elementSource.Row.RowState == DataRowState.Deleted || elementSource.Row.RowState == DataRowState.Detached)
{
strTmp = (string)elementSource.Row[c_champImputationsVersUtilisateurs, DataRowVersion.Original];
}
else
{
strTmp = (string)elementSource.Row[c_champImputationsVersUtilisateurs];
}
return(new CValeursImputées(strTmp));
}
//------------------------------------------------------------------------------------------------------------------------------
private static void UpdateValeurAAjouterAuxSourceDeElement(IElementACout element, bool bCoutReel)
{
if (!element.ShouldAjouterCoutPropreAuCoutDesSource(bCoutReel))
{
return;
}
double fOld = GetValeurImputéeDeSource(element, element, bCoutReel);
double fNew = element.CalculeTonCoutPuisqueTuNeCalculePasAPartirDesSourcesDeCout(bCoutReel);
if (fOld != fNew)
{
double fCout = bCoutReel ? element.CoutReel : element.CoutPrevisionnel;
fCout -= fOld;
fCout += fNew;
SetValeurImputéeDeSource(element, element, fNew, bCoutReel);
element.SetCoutSansCalculDesParents(fCout, bCoutReel);
}
}
//------------------------------------------------------------------------------------------------------------------------------
private static CValeursImputées GetValeursImputéesDeSources(IElementACout utilisateur)
{
if (utilisateur == null)
{
return(new CValeursImputées());
}
string strTmp = "";
if (utilisateur.Row.RowState == DataRowState.Deleted || utilisateur.Row.RowState == DataRowState.Detached)
{
strTmp = (string)utilisateur.Row[c_champImputationsParLesSources, DataRowVersion.Original];
}
else
{
strTmp = (string)utilisateur.Row[c_champImputationsParLesSources];
}
return(new CValeursImputées(strTmp));
}
//---------------------------------------------
public double CalcImputationAFaireSur(IElementACout elementACout, bool bCoutReel)
{
if (elementACout == null || elementACout.Row.RowState == DataRowState.Deleted)
{
return(0);
}
if (bCoutReel)
{
if (FractionIntervention != null)
{
return(CoutReel);
}
}
else if (Intervention != null)
{
return(CoutPrevisionnel);
}
return(0);
}
//---------------------------------------------------------
public double GetCoutImputéeA(IElementACout elt, bool bCoutReel)
{
double fCout = bCoutReel?ElementSource.CoutReel:ElementSource.CoutPrevisionnel;
if (fCout == 0)
{
return(0);
}
CImputationCout imputation = null;
if (m_dicImputations.TryGetValue(elt, out imputation))
{
if (PoidsTotal > 0)
{
return(imputation.Poids / PoidsTotal * fCout);
}
}
return(0);
}
//------------------------------------------------------------------------------------------------------------------------------
public static IElementACout[] GetElementsACoutFinaux(IElementACout element, bool bCoutReel)
{
HashSet <IElementACout> setElements = new HashSet <IElementACout>();
Dictionary <IElementACout, IElementACout[]> sources = new Dictionary <IElementACout, IElementACout[]>();
FillDicSources(bCoutReel, element, true, sources);
foreach (IElementACout[] sourcesDeElt in sources.Values)
{
foreach (IElementACout source in sourcesDeElt)
{
IElementACout[] tmp = new IElementACout[0];;
sources.TryGetValue(source, out tmp);
if (tmp.Length == 0)
{
setElements.Add(source);
}
}
}
return(setElements.ToArray());
}
//------------------------------------------------------------------------------------------------------------------------------
private static void FillDicSources(
bool bCoutReel,
IElementACout elementACout,
bool bRecursif,
Dictionary <IElementACout, IElementACout[]> elementsToSource)
{
if (elementsToSource.ContainsKey(elementACout))
{
return;
}
IElementACout[] sources = elementACout.GetSourcesDeCout(bCoutReel);
elementsToSource[elementACout] = sources;
if (bRecursif)
{
foreach (IElementACout source in sources)
{
FillDicSources(bCoutReel, source, true, elementsToSource);
}
}
}
//--------------------------------------------------
public void SetImputation(IElementACout element, double fValeur, bool bCoutReel)
{
if (element == null)
{
return;
}
string strKey = GetKey(element, bCoutReel);
if (fValeur < 0.001 || element.Row.RowState == DataRowState.Deleted || element.Row.RowState == DataRowState.Detached)
{
if (m_dicImputations.ContainsKey(strKey))
{
m_dicImputations.Remove(strKey);
}
}
else
{
m_dicImputations[strKey] = fValeur;
}
}
//------------------------------------------------------------------------------------------------------------------------------
private static void InvalideLeCoutDesSources(IElementACout elt, bool bCoutReel, HashSet <Type> typesAInvalider, HashSet <IElementACout> elementsFaits)
{
if (elt == null || elt.Row.RowState == DataRowState.Deleted || elt.Row.RowState == DataRowState.Detached)
{
return;
}
if (elementsFaits.Contains(elt))
{
return;
}
elementsFaits.Add(elt);
foreach (IElementACout source in elt.GetSourcesDeCout(bCoutReel))
{
InvalideLeCoutDesSources(source, bCoutReel, typesAInvalider, elementsFaits);
}
if (typesAInvalider.Contains(elt.GetType()))
{
OnChangeCout(elt, bCoutReel, false);
}
}
//---------------------------------------------------------
void itemElementACout_DropDownOpening(object sender, EventArgs e)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
IElementACout elt = item != null ? item.Tag as IElementACout : null;
if (elt != null)
{
if (item.DropDownItems.Count == 1 && item.DropDownItems[0].Tag == null)
{
item.DropDownItems.Clear();
foreach (IElementACout source in elt.GetSourcesDeCout(m_bMenuForCoutReel))
{
ToolStripItem itemFils = CreateItemSatisfaction(elt, source);
if (itemFils != null)
{
item.DropDownItems.Add(itemFils);
}
}
}
}
}
//------------------------------------------------------------------------------------------------------------------------------
public static void FillSetUtilisateurs(IElementACout elementACout, HashSet <IElementACout> set, params IElementACout[] stopOn)
{
if (set.Contains(elementACout))
{
return;
}
set.Add(elementACout);
if (stopOn.Length > 0 && stopOn.Contains(elementACout))
{
return;
}
CImputationsCouts imputations = elementACout.GetImputationsAFaireSurUtilisateursDeCout();
foreach (CImputationCout imput in imputations.Imputations)
{
IElementACout elt = imput.UtilisateurDeCout;
if (elt != null && elt.Row.RowState != DataRowState.Deleted && elt.Row.RowState != DataRowState.Detached)
{
FillSetUtilisateurs(elt, set, stopOn);
}
}
}
