public CResultAErreur UpdateEOs(CReferenceObjetDonnee referenceObject)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CObjetDonnee objet = referenceObject.GetObjet(contexte);
if (objet is IElementAEO)
{
result = CUtilElementAEO.UpdateEOSInCurrentContext((IElementAEO)objet);
if (result)
{
result = contexte.SaveAll(true);
}
return(result);
}
}
return(result);
}
//////////////////////////////////////////////////////////////////////
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = base.TraitementAvantSauvegarde(contexte);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
ArrayList lst = new ArrayList(table.Rows);
Dictionary <IElementAEO, bool> tableElementsToUpdate = new Dictionary <IElementAEO, bool>();
foreach (DataRow row in lst)
{
if (
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Added)
{
CRelationElement_EO rel = new CRelationElement_EO(row);
CObjetDonneeAIdNumerique objet = rel.ElementLie;
if (objet != null)
{
if (objet is IElementAEO)
{
tableElementsToUpdate[(IElementAEO)objet] = true;
// Vérifie les Exception de Type pour le Type d'EO
if (rel.EntiteOrganisationnelle != null &&
rel.EntiteOrganisationnelle.TypeEntite != null &&
rel.EntiteOrganisationnelle.TypeEntite.HasExceptionForType(objet.GetType()))
{
result.EmpileErreur(I.T("@1 cannot be affected to Organizational Entity @2. There is an Exception on this Type|10011",
((IElementAEO)objet).DescriptionElement, rel.EntiteOrganisationnelle.Libelle));
return(result);
}
}
}
}
else if (row.RowState == DataRowState.Deleted)
{
CRelationElement_EO rel = new CRelationElement_EO(row);
rel.VersionToReturn = DataRowVersion.Original;
CObjetDonneeAIdNumerique objet = rel.ElementLie;
if (objet != null && objet.IsValide() && objet is IElementAEO && (!(rel.Row[CSc2iDataConst.c_champIsDeleted] is bool) || (bool)rel.Row[CSc2iDataConst.c_champIsDeleted] != true))
{
tableElementsToUpdate[(IElementAEO)objet] = true;
}
}
}
//Met à jour les eos des éléments qui ont bougé
foreach (IElementAEO element in tableElementsToUpdate.Keys)
{
result = CUtilElementAEO.UpdateEOSInCurrentContext(element);
if (!result)
{
return(result);
}
}
return(result);
}
//----------------------------------------------------------------
/// <summary>
/// Controle si les donnateurs d'EO ont changé, si oui,
/// répercute les EOS du donnateur sur l'élément et ses héritiers
/// </summary>
/// <param name="elt"></param>
/// <returns></returns>
public static CResultAErreur OnChangementElementAEO(IElementAEO elt)
{
CResultAErreur result = CResultAErreur.True;
if (elt == null)
{
return(result);
}
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)elt;
Hashtable tableParentsOld = new Hashtable();
Hashtable tableParentsNew = new Hashtable();
bool bHasChange = objet.Row.RowState == DataRowState.Added;
if (!bHasChange || objet.Row.RowState == DataRowState.Modified)
{
DataRowVersion version = objet.VersionToReturn;
objet.VersionToReturn = DataRowVersion.Original;
IElementAEO[] donnateurs = elt.DonnateursEO;
if (donnateurs != null)
{
foreach (IElementAEO donnateur in donnateurs)
{
if (donnateur != null)
{
tableParentsOld[donnateur] = true;
}
}
}
objet.VersionToReturn = version;
donnateurs = elt.DonnateursEO;
if (donnateurs != null)
{
foreach (IElementAEO donnateur in donnateurs)
{
if (donnateur != null)
{
if (!tableParentsOld.Contains(donnateur))
{
bHasChange = true;
break;
}
tableParentsNew[donnateur] = true;
}
}
}
//Vérifie que les anciens sont tous là
foreach (IElementAEO old in tableParentsOld.Keys)
{
if (!tableParentsNew.Contains(old))
{
bHasChange = true;
break;
}
}
}
if (bHasChange)
{
//On est bon pour retravailler l'élément et tous ses fils
CUtilElementAEO.UpdateEOSInCurrentContext(elt);
}
return(result);
}
//----------------------------------------------------------------
public CResultAErreur SetAllOrganizationalEntities(IElementAEO elt, int[] nIdsOE)
{
return(CUtilElementAEO.SetAllOrganizationalEntities(elt, nIdsOE));
}
//---------------------------------------------------------------------------------
public CResultAErreur SupprimerEO(IElementAEO elt, int nIdEO)
{
return(CUtilElementAEO.SupprimerEO(elt, nIdEO));
}
//---------------------------------------------------------------------------------
public void CompleteRestriction(IElementAEO elt, CRestrictionUtilisateurSurType restriction)
{
CUtilElementAEO.CompleteRestriction(elt, restriction);
}
//---------------------------------------------------------------------------------
public CResultAErreur AjouterEO(IElementAEO elt, int nIdEO)
{
return(CUtilElementAEO.AjouterEO(elt, nIdEO));
}
//---------------------------------------------
/// <summary>
/// Retourne le filtre à appliquer à un élément pour obtenir tous les éléments
/// ayant en commun les types d'EO demandés
/// </summary>
/// <param name="element"></param>
/// <param name="typesCommuns"></param>
/// <param name="bFillesSeulement">Indique que seules le EOS = ou filles sont prises en compte (true),
/// ou seules les EOs parentes (false)</param>
/// <returns></returns>
public static CFiltreData GetFiltrePourTypeEosCommuns(IElementAEO element, List <COptionCorrespondanceEO> typesCommuns)
{
CFiltreData filtre = null;
Dictionary <COptionCorrespondanceEO, Dictionary <string, EModeComparaisonEO> > tableEOS = new Dictionary <COptionCorrespondanceEO, Dictionary <string, EModeComparaisonEO> >();
foreach (CEntiteOrganisationnelle eo in CUtilElementAEO.GetToutesEOs(element))
{
foreach (COptionCorrespondanceEO option in typesCommuns)
{
Dictionary <string, EModeComparaisonEO> dicoOption = null;
if (tableEOS.ContainsKey(option))
{
dicoOption = tableEOS[option];
}
else
{
dicoOption = new Dictionary <string, EModeComparaisonEO>();
tableEOS[option] = dicoOption;
}
switch (option.ModeComparaison)
{
case EModeComparaisonEO.FillesUniquement:
if (eo.TypeEntite == option.TypeEO)
{
dicoOption[eo.CodeSystemeComplet] = option.ModeComparaison;
}
else if (eo.TypeEntite.IsChildOf(option.TypeEO))
{
dicoOption[eo.GetParent(option.TypeEO).CodeSystemeComplet] = option.ModeComparaison;
}
else if (option.TypeEO.IsChildOf(eo.TypeEntite))
{
foreach (CEntiteOrganisationnelle eoFille in eo.GetChilds(option.TypeEO))
{
dicoOption[eoFille.CodeSystemeComplet] = option.ModeComparaison;
}
}
break;
case EModeComparaisonEO.ParentsUniquement:
case EModeComparaisonEO.BrancheComplete:
CEntiteOrganisationnelle eoTmp = eo;
string strLib = option.TypeEO.Libelle;
while (eoTmp.TypeEntite.IsChildOf(option.TypeEO) && !eoTmp.TypeEntite.Equals(option.TypeEO))
{
eoTmp = eoTmp.EntiteParente;
}
strLib = eoTmp.Libelle;
if (eoTmp != null && eoTmp.TypeEntite.Equals(option.TypeEO))
{
while (eoTmp != null)
{
dicoOption[eoTmp.CodeSystemeComplet] = option.ModeComparaison;
eoTmp = eoTmp.EntiteParente;
}
}
break;
case EModeComparaisonEO.Egalite:
if (eo.TypeEntite == option.TypeEO)
{
dicoOption[eo.CodeSystemeComplet] = option.ModeComparaison;
}
break;
}
}
}
if (tableEOS.Count > 0)
{
string strFiltreEO = "";
int nIndex = 1;
filtre = new CFiltreData("");
foreach (Dictionary <string, EModeComparaisonEO> dico in tableEOS.Values)
{
if (dico.Count != 0)
{
strFiltreEO += "(";
foreach (KeyValuePair <string, EModeComparaisonEO> entry in dico)
{
string strCodeEO = entry.Key;
EModeComparaisonEO mode = entry.Value;
strFiltreEO += CUtilElementAEO.c_champEO + " like @" + (nIndex++) + " or ";
switch (mode)
{
case EModeComparaisonEO.FillesUniquement:
filtre.Parametres.Add("%~" + strCodeEO + "%");
break;
case EModeComparaisonEO.ParentsUniquement:
case EModeComparaisonEO.Egalite:
filtre.Parametres.Add("%~" + strCodeEO + "~%");
break;
case EModeComparaisonEO.BrancheComplete:
filtre.Parametres.Add("%~" + strCodeEO + "%");
break;
}
}
strFiltreEO = strFiltreEO.Substring(0, strFiltreEO.Length - 4) + ") and ";
}
}
if (strFiltreEO.Length > 0)
{
strFiltreEO = strFiltreEO.Substring(0, strFiltreEO.Length - 5);
filtre.Filtre = strFiltreEO;
}
}
return(filtre);
}
