/// //////////////////////////////////////////////////////////////////
/// le data du result contient le dataset à appliquer à la base distante
public CResultAErreur GetModifsInMain(
int nIdSyncSessionFrom,
int nIdSyncSessionSecondaireCourant,
string strCodeGroupeSynchronisation)
{
CResultAErreur result = CResultAErreur.True;
CFiltresSynchronisation filtres = GetFiltres(strCodeGroupeSynchronisation);
IDatabaseConnexionSynchronisable connexionMain = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, m_strIdConnexion);
int nIdSyncMain = connexionMain.IdSyncSession;
while (connexionMain.IdSyncSession <= nIdSyncSessionSecondaireCourant)
{
connexionMain.IncrementeSyncSession();
}
CContexteDonneesSynchro ctxMain = new CContexteDonneesSynchro(IdSession, true);
bool bHasChange = false;
ctxMain.FillWithModifsFromVersion(nIdSyncSessionFrom == -1?-1:nIdSyncSessionFrom + 1, nIdSyncMain, ref bHasChange, filtres, false);
if (bHasChange)
{
DataSet dsRetour = new DataSet();
foreach (DataTable table in ctxMain.Tables)
{
if (table.Rows.Count != 0)
{
DataTable tableCopie = CUtilDataSet.AddTableCopie(table, dsRetour);
ArrayList lst = new ArrayList();
foreach (DataColumn col in tableCopie.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
lst.Add(col);
}
}
foreach (DataColumn col in lst)
{
tableCopie.Columns.Remove(col);
}
foreach (DataRow row in table.Rows)
{
tableCopie.ImportRow(row);
}
}
}
dsRetour.ExtendedProperties[c_cleIdSynchro] = nIdSyncMain;
result.Data = dsRetour;
}
return(result);
}
/*/// /////////////////////////////////////////////////////////////
* private static void OnNettoyage ( object state )
* {
* lock ( m_cacheFiltres )
* {
* for ( int nCache = m_cacheFiltres.Count-1; nCache >= 0; nCache-- )
* {
* CCacheFiltres cache = (CCacheFiltres)m_cacheFiltres[nCache];
* TimeSpan sp = DateTime.Now - cache.LastDateUse;
* if ( sp.TotalMinutes > 10 )
* m_cacheFiltres.RemoveAt ( nCache );
* }
* }
* }
*
* /// /////////////////////////////////////////////////////////////
* private static CCacheFiltres GetCache ( int nIdSession, int nIdUtilisateur, string strTypeSynchro )
* {
* lock ( m_cacheFiltres )
* {
* foreach ( CCacheFiltres cache in m_cacheFiltres )
* {
* if ( cache.IdSession == nIdSession &&
* cache.IdUtilisateur == nIdUtilisateur &&
* cache.TypeSynchro == strTypeSynchro )
* {
* return cache;
* }
* }
* return null;
* }
* }
*
* /// /////////////////////////////////////////////////////////////
* private static void OnUseFiltre (
* int nIdSession,
* int nIdUtilisateur,
* string strTypeSynchro,
* CFiltresSynchronisation filtres )
* {
* CCacheFiltres cache = GetCache ( nIdSession, nIdUtilisateur, strTypeSynchro );
* if ( cache != null )
* cache.RenouvelleLastUse();
* else
* {
* cache = new CCacheFiltres ( nIdSession, nIdUtilisateur, strTypeSynchro, filtres );
* lock ( m_cacheFiltres )
* {
* m_cacheFiltres.Add ( cache );
* }
* }
* }*/
/// /////////////////////////////////////////////////////////////
public CResultAErreur GetFiltresSynchronisation(string strCodeGroupeSynchronisation)
{
CResultAErreur result = CResultAErreur.True;
/*/CCacheFiltres cache = GetCache ( IdSession, nIdUtilisateur, strTypeSynchronisation );
* if ( cache != null )
* {
* result.Data = cache.Filtres;
* return result;
* }
*/
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
//Cherche le groupe de synchronisation
CGroupeUtilisateursSynchronisation groupe = new CGroupeUtilisateursSynchronisation(contexte);
if (!groupe.ReadIfExists(new CFiltreData(CGroupeUtilisateursSynchronisation.c_champCode + "=@1 or " +
CGroupeUtilisateursSynchronisation.c_champIdMachine + "=@1",
strCodeGroupeSynchronisation)))
{
result.EmpileErreur(I.T("The group '@1' doesn't exist|121", strCodeGroupeSynchronisation));
return(result);
}
CParametreSynchronisationInDb parametreInDb = groupe.ParametreSynchronisation;
CParametreSynchronisation parametre = parametreInDb.Parametre;
if (parametre != null)
{
result = parametre.GetFiltresFinaux(IdSession, groupe);
if (result)
{
CFiltresSynchronisation filtres = (CFiltresSynchronisation)result.Data;
//OnUseFiltre ( IdSession, nIdUtilisateur, strTypeSynchronisation, filtres );
result.Data = filtres;
return(result);
}
}
}
return(result);
}
//------------------------------------------------------------------------------------
public CFiltreData GetFiltreData(int nIdSession, CFiltresSynchronisation filtresSynchro)
{
return(null);
}
//--------------------------------------------------------
public CFiltreData GetFiltreData(int nIdSession, CFiltresSynchronisation filtresSynchro)
{
if (m_filtreDejaCalcule != null)
{
return(m_filtreDejaCalcule);
}
Type tp = CContexteDonnee.GetTypeForTable(m_strNomTableFille);
if (tp == null)
{
return(null);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure == null)
{
return(null);
}
CFiltreData filtre = null;
foreach (CInfoRelation relationParente in structure.RelationsParentes)
{
if (relationParente.Composition &&
(relationParente.TableParente == m_strNomTableParenteDeComposition ||
m_strNomTableParenteDeComposition.Length == 0))
{
Type tpParent = CContexteDonnee.GetTypeForTable(relationParente.TableParente);
CStructureTable structParente = CStructureTable.GetStructure(tpParent);
if (structParente != null && structParente.NomTable != m_strNomTableFille)
{
HashSet <int> lstIdsALire = new HashSet <int>();
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = relationParente.TableParente;
requete.FiltreAAppliquer = filtresSynchro.GetFiltreForTable(nIdSession, relationParente.TableParente);
requete.ListeChamps.Add(
new C2iChampDeRequete(structParente.ChampsId[0].NomChamp,
new CSourceDeChampDeRequete(structParente.ChampsId[0].NomChamp),
typeof(int),
OperationsAgregation.None,
true));
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int?nVal = row[0] as int?;
if (nVal != null)
{
lstIdsALire.Add(nVal.Value);
}
}
}
}
if (lstIdsALire.Count > 0)
{
StringBuilder bl = new StringBuilder();
foreach (int nId in lstIdsALire)
{
bl.Append(nId.ToString());
bl.Append(',');
}
bl.Remove(bl.Length - 1, 1);
filtre = CFiltreData.GetOrFiltre(filtre,
new CFiltreData(relationParente.ChampsFille[0] + " in (" + bl.ToString() + ")"));
}
}
}
}
if (filtre == null)
{
filtre = new CFiltreDataImpossible();
}
m_filtreDejaCalcule = filtre;
return(m_filtreDejaCalcule);
}
//----------------------------------------------------------------------------------------------------
public IDonneeSynchronisationMediation GetUpdatesForProxy(int nIdProxy, int nIdLastSyncSession)
{
using (CSessionClient session = CSessionClient.CreateInstance())
{
CResultAErreur result = session.OpenSession(new CAuthentificationSessionProcess());
if (!result)
{
return(null);
}
using (CContexteDonneesSynchro ctx = new CContexteDonneesSynchro(session.IdSession, true))
{
CSc2iDataServer connexionManager = CSc2iDataServer.GetInstance();
IDatabaseConnexionSynchronisable cnxSync = connexionManager.GetDatabaseConnexion(session.IdSession, typeof(CTypeAgentSnmpServeur)) as IDatabaseConnexionSynchronisable;
if (cnxSync == null)
{
return(null);
}
cnxSync.IncrementeSyncSession();
int nIdSyncMax = cnxSync.IdSyncSession - 1;
CFiltresSynchronisation filtres = new CFiltresSynchronisation();
filtres.AddFiltreForTable(CTypeAlarme.c_nomTable, null, false);
filtres.AddFiltreForTable(CSeveriteAlarme.c_nomTable, null, false);
filtres.AddFiltreForTable(CTypeAgentSnmp.c_nomTable, null, false);
filtres.AddFiltreForTable(CAgentSnmp.c_nomTable,
new CFiltreData(CSnmpProxyInDb.c_champId + "=@1",
nIdProxy)
, false);
filtres.AddFiltreForTable(CTypeEntiteSnmp.c_nomTable, null, false);
filtres.AddFiltreForTable(CEntiteSnmp.c_nomTable, new CFiltreDataAvance(
CEntiteSnmp.c_nomTable,
CAgentSnmp.c_nomTable + "." +
CSnmpProxyInDb.c_champId + "=@1",
nIdProxy), false);
filtres.AddFiltreForTable(CRelationTypeEntiteSnmp_ChampCustom.c_nomTable, null, false);
filtres.AddFiltreForTable(CRelationEntiteSnmp_ChampCustom.c_nomTable,
new CFiltreDataAvance(CRelationEntiteSnmp_ChampCustom.c_nomTable,
CEntiteSnmp.c_nomTable + "." +
CAgentSnmp.c_nomTable + "." +
CSnmpProxyInDb.c_champId + "=@1",
nIdProxy), false);
// Prend uniquement les Filtrages d'alarme compris entre les dates de validité et marqués Enabled
filtres.AddFiltreForTable(CParametrageFiltrageAlarmes.c_nomTable,
new CFiltreData(
CParametrageFiltrageAlarmes.c_champIsActif + " = @1 AND " +
CParametrageFiltrageAlarmes.c_champDateDebutValidite + " <= @2 AND " +
CParametrageFiltrageAlarmes.c_champDateFinValidite + " > @2",
true,
DateTime.Now.Date), false);
filtres.AddFiltreForTable(CCategorieMasquageAlarme.c_nomTable, null, false);
DateTime dt = DateTime.Now;
// Créer le MemoryDB
bool bHasData = false;
result = ctx.FillWithModifsFromVersion(nIdLastSyncSession, nIdSyncMax, ref bHasData, filtres, true);
if (!result)
{
return(null);
}
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine("Lecture modifs médiation : " + sp.TotalMilliseconds);
dt = DateTime.Now;
CDonneesSynchronisationMediation donneesSynchro = new CDonneesSynchronisationMediation(
CMemoryDbPourSupervision.GetMemoryDb(ctx), nIdSyncMax);
CListeObjetsDonnees lstObjets = new CListeObjetsDonnees(ctx, typeof(CSeveriteAlarme));
lstObjets.InterditLectureInDB = true;
foreach (CSeveriteAlarme severite in lstObjets)
{
severite.GetTypeForSupervision(donneesSynchro.Database);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CTypeAlarme));
lstObjets.InterditLectureInDB = true;
foreach (CTypeAlarme type in lstObjets)
{
type.GetTypeForSupervision(donneesSynchro.Database, true);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CTypeAgentSnmp));
lstObjets.InterditLectureInDB = true;
lstObjets.ReadDependances("TypesEntites");
foreach (CTypeAgentSnmp type in lstObjets)
{
type.GetTypeAgentPourSupervision(donneesSynchro.Database);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CAgentSnmp));
lstObjets.InterditLectureInDB = true;
lstObjets.ReadDependances("EntitesSnmp", "EntitesSnmp.RelationsChampsCustom",
"EntitesSnmp.SiteSupervise",
"EntitesSnmp.EquipementLogiqueSupervise",
"EntitesSnmp.EquipementLogiqueSupervise.Site",
"EntitesSnmp.LienReseauSupervise");
foreach (CAgentSnmp agent in lstObjets)
{
agent.GetAgentPourSupervision(donneesSynchro.Database, true);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CParametrageFiltrageAlarmes));
lstObjets.InterditLectureInDB = true;
foreach (CParametrageFiltrageAlarmes parametreFiltre in lstObjets)
{
parametreFiltre.GetLocalParametrageForSupervision(donneesSynchro.Database);
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CCategorieMasquageAlarme));
lstObjets.InterditLectureInDB = true;
foreach (CCategorieMasquageAlarme categorie in lstObjets)
{
categorie.GetLocalCategorieForSupervision(donneesSynchro.Database);
}
//S'assure que les entités des valeurs de champ entité sont chargés
lstObjets = new CListeObjetsDonnees(ctx, typeof(CRelationEntiteSnmp_ChampCustom));
lstObjets.InterditLectureInDB = true;
foreach (CRelationEntiteSnmp_ChampCustom rel in lstObjets)
{
if (rel != null && rel.ElementAChamps != null)
{
((CObjetDonnee)rel.ElementAChamps).AssureData();
}
}
lstObjets = new CListeObjetsDonnees(ctx, typeof(CEntiteSnmp));
lstObjets.InterditLectureInDB = true;
foreach (CEntiteSnmp entite in lstObjets)
{
CTypeEntiteSnmp typeEntite = entite.TypeEntiteSnmp;
futurocom.snmp.entitesnmp.CTypeEntiteSnmpPourSupervision te = typeEntite.GetTypeEntitePourSupervision(donneesSynchro.Database, true);
entite.GetEntitePourSupervision(te);
}
sp = DateTime.Now - dt;
Console.WriteLine("Intégration modifs médiation : " + sp.TotalMilliseconds);
return(donneesSynchro);
}
}
}
////////////////////////////////////////////////////////////////////////
/// <summary>
/// Retourne les filtres finaux pour toutes les tables
//Le data du result contient les filtresdata finaux
/// </summary>
/// <param name="nIdSession"></param>
/// <param name="nIdUtilisateur">Id de l'utilisateur</param>
/// <param name="listeUsersGroupe">Id des utilisateurs associés à celui ci</param>
/// <returns></returns>
public CResultAErreur GetFiltresFinaux(int nIdSession, CGroupeUtilisateursSynchronisation groupe)
{
CResultAErreur result = CResultAErreur.True;
try
{
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
CFiltresDynamiquesForTables filtresForTables = CalculeFiltresForTables();
CFiltresSynchronisation filtres = new CFiltresSynchronisation();
foreach (string strNomTable in CContexteDonnee.MappeurTableToClass.GetListeTables())
{
bool bShouldImporte = false;
CFiltreDynamique filtreDynamique = filtresForTables.GetFiltreDynamiqueForTable(strNomTable, ref bShouldImporte);
if (!bShouldImporte)
{
filtres.AddFiltreForTable(strNomTable, new CFiltreDataImpossible(), true);
}
else
{
if (filtreDynamique == null)
{
filtres.AddFiltreForTable(strNomTable, null, true);
}
else
{
//Trouve la variable contenant le groupe
CVariableDynamique variable = null;
foreach (CVariableDynamique v in filtreDynamique.ListeVariables)
{
if (v.Nom == CFiltreSynchronisation.c_nomVariableListeUtilisateurs)
{
variable = v;
}
}
filtreDynamique.SetValeurChamp(variable, groupe.ListeIdsUtilisateurs);
filtreDynamique.ContexteDonnee = contexte;
CResultAErreur resultTmp = filtreDynamique.GetFiltreData();
CFiltreData filtreData = null;
if (!result)
{
result.Erreur.EmpileErreurs(resultTmp.Erreur);
result.EmpileErreur(I.T("Error in table @1|189", strNomTable));
}
else
{
filtreData = (CFiltreData)resultTmp.Data;
filtres.AddFiltreForTable(strNomTable, filtreData, true);
}
}
}
}
result.Data = filtres;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// /////////////////////////////////////////////////////////
public DataSet GetAddAndUpdateInTableMain(
string strNomTable,
int nSessionSyncDebut,
int nSessionSyncFin,
string strCodeGroupeSynchronisation)
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
DataSet dsDest = null;
if (tp == null)
{
return(null);
}
//Récupère les filtres
CFiltresSynchronisation filtres = GetFiltres(strCodeGroupeSynchronisation);
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CFiltreData filtreSynchro = null;
if (filtres != null)
{
filtreSynchro = filtres.GetFiltreForTable(m_nIdSession, strNomTable);
}
if (filtreSynchro == null)
{
filtreSynchro = new CFiltreData();
}
int nNumParametreIdSync = filtreSynchro.Parametres.Count + 1;
string strFiltre = filtreSynchro.Filtre;
filtreSynchro.Filtre = "(" + CSc2iDataConst.c_champIdSynchro + ">=@" + nNumParametreIdSync.ToString() + " and " +
CSc2iDataConst.c_champIdSynchro + "<=@" + (nNumParametreIdSync + 1).ToString();
if (nSessionSyncDebut == -1)
//C'est la première synchro, intègre les éléments modifiés avant prise en charge
//des synchros
{
if (filtreSynchro is CFiltreDataAvance)
{
filtreSynchro.Filtre += " or hasno(" + CSc2iDataConst.c_champIdSynchro + ")";
}
else
{
filtreSynchro.Filtre += " or " + CSc2iDataConst.c_champIdSynchro + " is null";
}
}
filtreSynchro.Filtre += ")";
if (strFiltre != "")
{
filtreSynchro.Filtre += " and (" + strFiltre + ")";
}
filtreSynchro.Parametres.Add(nSessionSyncDebut);
filtreSynchro.Parametres.Add(nSessionSyncFin);
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, tp, false);
liste.Filtre = filtreSynchro;
liste.AssureLectureFaite();
//Charge les données de synchronisation
CFiltreData filtreDataSync = new CFiltreData(CEntreeLogSynchronisation.c_champTable + "=@1 and " +
CSc2iDataConst.c_champIdSynchro + ">=@2 and " +
CSc2iDataConst.c_champIdSynchro + "<=@3",
strNomTable, nSessionSyncDebut, nSessionSyncFin);
liste = new CListeObjetsDonnees(contexte, typeof(CEntreeLogSynchronisation), false);
liste.Filtre = filtreDataSync;
liste.AssureLectureFaite();
//Transforme le contexte en dataset (pour sérialisation web !! )
dsDest = new DataSet();
foreach (DataTable table in contexte.Tables)
{
DataTable tableDest = CUtilDataSet.AddTableCopie(table, dsDest);
foreach (DataRow row in table.Rows)
{
tableDest.ImportRow(row);
}
//Supprime les colonnes blob
for (int nCol = tableDest.Columns.Count - 1; nCol >= 0; nCol--)
{
if (tableDest.Columns[nCol].DataType == typeof(CDonneeBinaireInRow))
{
tableDest.Columns.RemoveAt(nCol);
}
}
}
}
return(dsDest);
}
/// //////////////////////////////////////////////////////////////////
public CResultAErreur PutMainIntoSecondary(string strConnexionSecondaire, CFiltresSynchronisation filtres, string strCodeGroupeSynchronisation)
{
CResultAErreur result = CResultAErreur.True;
/*
* CSc2iDataServer connexionManager = CSc2iDataServer.GetInstance();
*
* string strConnexionMain = connexionManager.GetDatabaseConnexion(IdSession, m_strIdConnexion).ConnexionString;
*
* IDatabaseConnexionSynchronisable connexionSecondaire, connexionMain;
*
*
* connexionMain = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, m_strIdConnexion);
*
*
* //Crée la connexion à la base secondaire
* connexionSecondaire = new IDatabaseConnexionSynchronisable(IdSession);
* connexionSecondaire.ConnexionString = strConnexionSecondaire;
*
*
* try
* {
* int nIdLastSyncSecondaire = connexionSecondaire.LastVersionVueDeBasePrincipale;
*
* int nIdSyncMain = connexionMain.IdSyncSession;
*
* if ( nIdLastSyncSecondaire > connexionSecondaire.LastSyncIdPutInMain )
* {
* result.EmpileErreur(I.T("The synchronization Secondary -> primary must be done before this operation|209"));
* return result;
* }
*
* //Remplit le contexte primaire avec les informations à mettre à jour
* using (CContexteDonneesSynchroMain ctxMain = new CContexteDonneesSynchroMain(IdSession, true))
* {
* bool bHasChange = false;
* //Change le numéro de version de la base primaire, ainsi,
* // s'il y a des modifs après ou pendant la lecture, elles auront bien lieu dans une autre
* // session de synchronisation
* //
* while ( connexionMain.IdSyncSession <= connexionSecondaire.IdSyncSession )
* connexionMain.IncrementeSyncSession();
* ctxMain.FillWithModifsFromVersion(nIdLastSyncSecondaire==-1?-1:nIdLastSyncSecondaire+1, nIdSyncMain, ref bHasChange, filtres, false);
* if ( bHasChange )
* {
* //Passe sur la base secondaire
* connexionManager.SetDatabaseConnexion(IdSession, m_strIdConnexion, connexionSecondaire);
*
* //Toutes les modifs apportées sur la base secondaire doivent porter l'id de synchro
* //Initial de la base secondaire, sinon les modifs font du
* //ping pong entre secondaire et main,
* //Ces modifs ne doivent surtout pas apparaitre
* //lors d'une synchro de sec->main !
* connexionSecondaire.LockSyncSessionLocalTo ( nIdLastSyncSecondaire );
*
* //Répercute les modifs de la base secondaire sur la base primaire
* using (CContexteDonneesSynchroSecondaire donneeSec = new CContexteDonneesSynchroSecondaire(IdSession, true))
* {
* result = donneeSec.ChargeDonneesAMettreAJour ( ctxMain );
*
* donneeSec.EnforceConstraints = false;
* if ( result )
* result = donneeSec.AjouteNouveaux ( ctxMain );
* if ( result )
* result = donneeSec.Update ( ctxMain );
* if ( result )
* result = donneeSec.Delete ( ctxMain );
* donneeSec.EnforceConstraints = true;
* try
* {
* connexionSecondaire.BeginTrans();
* }
* catch ( Exception e )
* {
* result.EmpileErreur(new CErreurException (e));
* result.EmpileErreur(I.T("Error while data synchronization|208"));
* return result;
* }
*
* if ( result )
* result = donneeSec.WriteChanges( ctxMain );
*
*
* if ( result )
* {
* if ( connexionSecondaire.LastSyncIdPutInMain == -1 )
* connexionSecondaire.LastSyncIdPutInMain = connexionSecondaire.IdSyncSession;
*
* connexionSecondaire.UnlockSyncSessionLocal();
* while ( connexionSecondaire.IdSyncSession < connexionMain.IdSyncSession )
* connexionSecondaire.IncrementeSyncSession();
*
* connexionSecondaire.LastVersionVueDeBasePrincipale = nIdSyncMain==-1?0:nIdSyncMain;
*
* while ( connexionMain.IdSyncSession <= connexionSecondaire.IdSyncSession )
* connexionMain.IncrementeSyncSession();
* connexionSecondaire.CommitTrans();
* }
*
* if ( !result )
* {
* connexionSecondaire.RollbackTrans();
* }
* }
* }
* }
* }
* catch ( Exception e )
* {
* result.EmpileErreur(new CErreurException(e));
* result.EmpileErreur(I.T("Error while data synchronization|208"));
* }
* finally
* {
* CSc2iDataServer.GetInstance().SetDatabaseConnexion(IdSession, m_strIdConnexion,connexionMain);
* connexionSecondaire.Dispose();
* }*/
return(result);
}
//------------------------------------------------
public CFiltreData GetFiltreData(int nIdSession, CFiltresSynchronisation filtres)
{
return(m_filtre);
}
//-----------------------------------------------------------------
public CFiltreData GetFiltreData(int nIdSession, CFiltresSynchronisation filtresSynchro)
{
if (m_filtreDejaCalcule != null)
{
return(m_filtreDejaCalcule);
}
Type tp = CContexteDonnee.GetTypeForTable(m_strNomTable);
if (tp == null)
{
return(null);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure == null)
{
return(null);
}
HashSet <int> lstIdsALire = new HashSet <int>();
List <CInfoRelation> relationsFilles = new List <CInfoRelation>();
foreach (Type tpTest in CContexteDonnee.GetAllTypes())
{
CStructureTable s = CStructureTable.GetStructure(tpTest);
if (s != null)
{
foreach (CInfoRelation relation in s.RelationsParentes)
{
if (relation.TableParente == m_strNomTable)
{
relationsFilles.Add(relation);
}
}
}
}
//va chercher les dépendances filles qui auront besoin d'éléments de ce type
foreach (CInfoRelation relation in relationsFilles)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relation.TableFille);
//Vérifie qu'il n'y a pas de filtre FilsDe ou FilsComposition sur la table
bool bPrendreCetteTable = true;
foreach (IFiltreSynchronisation filtre in filtresSynchro.GetFiltresSynchroPourTable(relation.TableFille))
{
if (relation.Composition && filtre is CFiltreSynchronisationFilsCompositions)
{
bPrendreCetteTable = false;
break;
}
CFiltreSynchronisationFilsDe filsDe = filtre as CFiltreSynchronisationFilsDe;
if (filsDe != null)
{
if (filsDe.TablesParentes.Contains(m_strNomTable))
{
bPrendreCetteTable = false;
break;
}
}
}
if (bPrendreCetteTable)
{
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = relation.TableFille;
if (relation.TableFille != m_strNomTable)
{
requete.FiltreAAppliquer = filtresSynchro.GetFiltreForTable(nIdSession, relation.TableFille);
}
requete.ListeChamps.Add(
new C2iChampDeRequete(relation.ChampsFille[0],
new CSourceDeChampDeRequete(relation.ChampsFille[0]),
typeof(int),
OperationsAgregation.None,
true));
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int?nVal = row[0] as int?;
if (nVal != null)
{
lstIdsALire.Add(nVal.Value);
}
}
}
}
}
}
if (lstIdsALire.Count == 0)
{
m_filtreDejaCalcule = new CFiltreDataImpossible();
return(m_filtreDejaCalcule);
}
StringBuilder bl = new StringBuilder();
foreach (int nId in lstIdsALire)
{
bl.Append(nId);
bl.Append(',');
}
bl.Remove(bl.Length - 1, 1);
m_filtreDejaCalcule = new CFiltreData(structure.ChampsId[0].NomChamp + " in (" + bl.ToString() + ")");
return(m_filtreDejaCalcule);
}