////////////////////////////////////////////////////////////////////////
public object Clone()
{
CFiltreSynchronisation filtreCopie = new CFiltreSynchronisation();
C2iSerializer.CloneTo(this, filtreCopie);
return(filtreCopie);
}
////////////////////////////////////////////////////////////////////////
private void CreateFiltreForAllParents(Hashtable tableRelationsFaites)
{
CStructureTable structure = CStructureTable.GetStructure(CContexteDonnee.GetTypeForTable(NomTable));
foreach (CInfoRelation relationParente in structure.RelationsParentes)
{
if (tableRelationsFaites[relationParente.RelationKey] == null)
{
tableRelationsFaites[relationParente.RelationKey] = true;
CFiltreSynchronisation filtreFils = GetFilsForRelation(relationParente);
if (filtreFils == null)
{
filtreFils = new CFiltreSynchronisation(relationParente.TableParente);
filtreFils.m_bIsAutoAdd = true;
filtreFils.IsLienToFullTableParente = TouteLaTable;
AddFils(filtreFils, relationParente);
}
filtreFils.CreateFiltreForAllParents((Hashtable)tableRelationsFaites.Clone());
}
}
foreach (CFiltreSynchronisation filtreFils in m_listeFils)
{
if (tableRelationsFaites[filtreFils.RelationToParent.RelationKey] == null)
{
tableRelationsFaites[filtreFils.RelationToParent.RelationKey] = true;
if (filtreFils.NomTable == filtreFils.RelationToParent.TableFille)
{
filtreFils.CreateFiltreForAllParents((Hashtable)tableRelationsFaites.Clone());
}
}
}
}
////////////////////////////////////////////////////////////////////////
public CFiltresDynamiquesForTables CalculeFiltresForTables()
{
CFiltresDynamiquesForTables filtres = new CFiltresDynamiquesForTables();
//Crée un filtre pour chaque les tables fullsnchro
foreach (string strNomTable in CContexteDonnee.MappeurTableToClass.GetListeTables())
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null && tp.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length > 0)
{
CFiltreSynchronisation filtreTableFull = new CFiltreSynchronisation(strNomTable);
filtreTableFull.TouteLaTable = true;
filtreTableFull.IsAutoAdd = true;
filtreTableFull.CreateFiltreForAllParents();
filtreTableFull.CreateFiltreForAllCompositions();
filtreTableFull.FiltreDynamique = CFiltreSynchronisation.GetFiltreDynamiqueSynchro(tp);
filtres.AddFiltreSynchronisation(filtreTableFull);
}
}
foreach (CFiltreSynchronisation filtre in m_listefiltresSynchronisation)
{
filtre.CalculeFiltresForTables();
filtres.AddFiltreSynchronisation(filtre);
}
return(filtres);
}
////////////////////////////////////////////////////////////////////////
public void CopySansFilsTo(CFiltreSynchronisation filtre)
{
filtre.m_strNomTable = m_strNomTable;
if (m_filtreDynamique != null)
{
filtre.m_filtreDynamique = (CFiltreDynamique)m_filtreDynamique.Clone();
}
filtre.m_relationToParent = m_relationToParent;
filtre.m_bTouteLaTable = m_bTouteLaTable;
filtre.m_bIsAutoAdd = m_bIsAutoAdd;
}
////////////////////////////////////////////////////////////////////////
public CFiltreDynamique GetFiltreDynamiqueForTable(string strNomTable, ref bool bShouldSynchroniseTable)
{
ArrayList lst = (ArrayList)m_tableTableToFiltreSynchronisation[strNomTable];
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null && tp.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length > 0)
{
bShouldSynchroniseTable = true;
return(null);
}
if (lst == null || lst.Count == 0)
{
bShouldSynchroniseTable = false;
return(null);
}
bShouldSynchroniseTable = true;
CFiltreDynamique filtreDynamique = CFiltreSynchronisation.GetFiltreDynamiqueSynchro(CContexteDonnee.GetTypeForTable(strNomTable));
CComposantFiltreDynamiqueOu composantOu = new CComposantFiltreDynamiqueOu();
foreach (CFiltreSynchronisation filtreSynchro in lst)
{
if (filtreSynchro.TouteLaTable || filtreSynchro.FiltreDynamique == null)
{
return(null);
}
CFiltreDynamique filtreLocal = filtreSynchro.GetFiltreToElementPrincipal();
if (filtreLocal != null && filtreLocal.ComposantPrincipal != null)
{
composantOu.AddComposantFils(filtreLocal.ComposantPrincipal);
}
if (filtreLocal == null)
{
return(null);
}
}
if (composantOu.GetNbComposantsFils() == 0)
{
return(null);
}
if (composantOu.GetNbComposantsFils() == 1)
{
filtreDynamique.ComposantPrincipal = composantOu.ComposantsFils[0];
}
else
{
filtreDynamique.ComposantPrincipal = composantOu;
}
return(filtreDynamique);
}
////////////////////////////////////////////////////////////////////////
private void PrivateAddFiltre(CFiltreSynchronisation filtre)
{
ArrayList lst = (ArrayList)m_tableTableToFiltreSynchronisation[filtre.NomTable];
if (lst == null)
{
lst = new ArrayList();
m_tableTableToFiltreSynchronisation[filtre.NomTable] = lst;
}
CInfoRelation relation = filtre.RelationToParent;
if (relation != null)
{
//Regarde s'il y a un filtre sur la table complète avant d'aller plus loin !
foreach (CFiltreSynchronisation filtreExistant in lst)
{
if (filtreExistant.IsLienToFullTableParente &&
filtreExistant.RelationToParent.Equals(relation))
{
//Il y a un filtre sur toute la table liée, on n'ajoute pas celui-ci
return;
}
}
if (filtre.IsLienToFullTableParente)
{
//Supprime tous les autres filtres pour la même relation
//puisqu'on ajoute un filtre sur toute la table liée
for (int nFiltre = lst.Count - 1; nFiltre >= 0; nFiltre--)
{
CFiltreSynchronisation filtreExistant = (CFiltreSynchronisation)lst[nFiltre];
if (relation.Equals(filtreExistant.RelationToParent))
{
lst.RemoveAt(nFiltre);
}
}
}
}
lst.Add(filtre);
foreach (CFiltreSynchronisation filtreFils in filtre.FiltresFils)
{
PrivateAddFiltre(filtreFils);
}
}
////////////////////////////////////////////////////////////////////////
protected void DefinitParent(CFiltreSynchronisation filtre, CInfoRelation relationToParent)
{
m_filtreParent = filtre;
m_relationToParent = relationToParent;
}
////////////////////////////////////////////////////////////////////////
public void AddFils(CFiltreSynchronisation filtreFils, CInfoRelation relationToParent)
{
m_listeFils.Add(filtreFils);
filtreFils.DefinitParent(this, relationToParent);
}
////////////////////////////////////////////////////////////////////////
public void AddFiltreSynchronisation(CFiltreSynchronisation filtreSynchro)
{
PrivateAddFiltre(filtreSynchro);
}
////////////////////////////////////////////////////////////////////////
public void RemoveFiltre(CFiltreSynchronisation filtre)
{
m_listefiltresSynchronisation.Remove(filtre);
}
////////////////////////////////////////////////////////////////////////
public void AddFiltre(CFiltreSynchronisation filtre)
{
m_listefiltresSynchronisation.Add(filtre);
}
