////////////////////////////////////////////////////////////////////////////////////
private void AssureDonnees()
{
if (m_bLoaded)
{
return;
}
IObjetServeur loader = ((CContexteDonnee)m_row.Table.DataSet).GetTableLoader(m_row.Table.TableName);
CFiltreData filtre = CFiltreData.CreateFiltreAndSurRow(m_row.Table.PrimaryKey, m_row);
ArrayList lstKeys = new ArrayList();
foreach (DataColumn col in m_row.Table.PrimaryKey)
{
lstKeys.Add(m_row[col]);
}
CResultAErreur result = loader.ReadBlob(m_strChamp, lstKeys.ToArray());
if (!result)
{
throw new CExceptionErreur(result.Erreur);
}
m_donnees = (byte[])result.Data;
if (m_donnees != null)
{
m_donneesOriginales = (byte[])m_donnees.Clone();
}
else
{
m_donneesOriginales = null;
}
m_bLoaded = true;
}
//////////////////////////////////////////////////
/// <summary>
/// Crée un filtre and à partir des données d'une DataRow
/// </summary>
/// <param name="strChamps">
/// Liste des champs
/// </param>
/// <param name="row">
/// Ligne contenant les données
/// </param>
/// <returns></returns>
public static CFiltreData CreateFiltreAndSurValeurs(string[] strChamps, object[] valeurs)
{
CFiltreData filtre = new CFiltreData( );
int nIndex = 1;
foreach (string strChamp in strChamps)
{
filtre.Filtre += strChamp + "=@" + nIndex + " and ";
filtre.Parametres.Add(valeurs[nIndex - 1]);
nIndex++;
}
filtre.Filtre = filtre.Filtre.Substring(0, filtre.Filtre.Length - 5);
return(filtre);
}
//////////////////////////////////////////////////
/// <summary>
/// Crée un filtre and à partir des données d'une DataRow
/// </summary>
/// <param name="strChamps">
/// Liste des champs
/// </param>
/// <param name="row">
/// Ligne contenant les données
/// </param>
/// <returns></returns>
public static CFiltreData CreateFiltreAndSurRow(string[] strChamps, DataRow row, DataRowVersion version)
{
CFiltreData filtre = new CFiltreData( );
int nIndex = 1;
foreach (string strChamp in strChamps)
{
filtre.Filtre += strChamp + "=@" + nIndex + " and ";
filtre.Parametres.Add(row[strChamp, version]);
nIndex++;
}
filtre.Filtre = filtre.Filtre.Substring(0, filtre.Filtre.Length - 5);
return(filtre);
}
//////////////////////////////////////////////////
protected void CopyTo(CFiltreData filtre)
{
filtre.Filtre = m_strFiltre;
foreach (object param in Parametres)
{
filtre.Parametres.Add(param);
}
filtre.m_strSortOrder = m_strSortOrder;
filtre.IgnorerVersionDeContexte = IgnorerVersionDeContexte;
filtre.IntegrerLesElementsSupprimes = IntegrerLesElementsSupprimes;
filtre.IdsDeVersionsALire = IdsDeVersionsALire;
filtre.IntergerParentsHierarchiques = IntergerParentsHierarchiques;
filtre.IntegrerFilsHierarchiques = IntegrerFilsHierarchiques;
filtre.NeConserverQueLesRacines = NeConserverQueLesRacines;
}
////////////////////////////////////////////////////////
public string GetString(CFiltreData filtre)
{
if (filtre is CFiltreDataAvance)
{
return(GetStringAvance((CFiltreDataAvance)filtre));
}
string strFiltre = filtre.Filtre;
//Remplace le & (operateur binaire) qui n'est pas implémenté
strFiltre = RemplaceEtOuBinaire(strFiltre, 0);
int nNumParametre = 1;
foreach (object obj in filtre.Parametres)
{
string strReplace = obj.ToString();
if (obj is String)
{
strReplace = strReplace.Replace("'", "''");
strReplace = "'" + strReplace + "'";
}
if (obj is DateTime)
{
DateTime dt = (DateTime)obj;
strReplace = "#" + dt.ToString("MM/dd/yyyy HH:mm:ss") + "#";
}
if (obj is bool)
{
strReplace = ((bool)obj)?"1":"0";
}
/*if ( strFiltre.IndexOf("@"+nNumParametre.ToString()) >= 0 )
* strFiltre = strFiltre.Replace("@"+nNumParametre.ToString(), strReplace );
* else*/
Regex ex = new Regex("(@" + nNumParametre.ToString() + ")(?<SUITE>[^0123456789]{1})");
//stef 29/05/2012, les $ sont mals gérés dans une chaine de remplacement, et
//ça met le bronx dans le replace.
//On remplace donc les $ par une chaine improbables pour qu'il n'y ait
//Plus de $ dans la chaine de replace
strReplace = strReplace.Replace("$", "#~é&,解");
strFiltre = ex.Replace(strFiltre + " ", strReplace + "${SUITE}");
strFiltre = strFiltre.Replace("#~é&,解", "$");
//strFiltre = strFiltre.Replace("@"+nNumParametre.ToString(), strReplace );
nNumParametre++;
}
return(strFiltre);
}
//-----------------------------------------------------------------------
//////////////////////////////////////////////////
public static bool IsUnique(CObjetDonnee objet, string strChamp, string strValeurChamp)
{
if (objet == null)
{
return(true);
}
CFiltreData filtre = CFiltreData.CreateFiltreAndSurRow(objet.GetChampsId(), objet.Row);
filtre.Filtre = strChamp + " like @" + (filtre.Parametres.Count + 1) + " and not(" + filtre.Filtre + ")";
filtre.Parametres.Add(strValeurChamp);
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, objet.GetType());
liste.Filtre = filtre;
if (liste.CountNoLoad != 0)
{
return(false);
}
return(true);
}
/// <summary>
/// Vérifie qu'une dataRow vérifie ses règles d'unicité
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
private static CResultAErreur VerifieUnicite(DataRow row, List <CInfoFiltreUnique> listeFiltres, Type typeObjet)
{
CResultAErreur result = CResultAErreur.True;
if (row.RowState == DataRowState.Detached ||
row.RowState == DataRowState.Deleted)
{
return(result);
}
foreach (CInfoFiltreUnique info in listeFiltres)
{
CFiltreData filtre = new CFiltreData(info.Filtre.Filtre);
filtre.Parametres.Add(row[row.Table.PrimaryKey[0]]);
int nIndex = 2;
List <string> lstValeurs = new List <String>();
foreach (string strChamp in info.Attribute.Champs)
{
if (!row.Table.Columns.Contains(strChamp))
{
return(result);
}
if (row[strChamp] == DBNull.Value)
{
filtre.Filtre.Replace("=@" + nIndex, " is null");
filtre.Parametres.Add("");
}
else
{
filtre.Parametres.Add(row[strChamp]);
}
lstValeurs.Add(row[strChamp].ToString());
}
CListeObjetsDonnees liste = new CListeObjetsDonnees((CContexteDonnee)row.Table.DataSet, typeObjet);
liste.Filtre = filtre;
if (liste.Count > 0)
{
result.EmpileErreur(I.TT(typeObjet, info.Attribute.Message, lstValeurs.ToArray()));
return(result);
}
}
return(result);
}
//-------------------------------------------------------------------------------------------
private static CFiltreData GetFiltreSynchro(int nIdSession, int nIdSynchroDebut, int nIdSynchroFin, CFiltresSynchronisation filtres, DataTable table)
{
CFiltreData filtreSynchro = null;
if (filtres != null)
{
filtreSynchro = filtres.GetFiltreForTable(nIdSession, table.TableName);
}
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 (nIdSynchroDebut == -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(nIdSynchroDebut);
filtreSynchro.Parametres.Add(nIdSynchroFin);
return(filtreSynchro);
}
////////////////////////////////////////////////////////////
public static CResultAErreur DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(CListeObjetsDonnees liste, bool bDansContexteCourant)
{
CResultAErreur result = CResultAErreur.True;
bool bOldEnforce = liste.ContexteDonnee.EnforceConstraints;
StringBuilder bl = new StringBuilder();
foreach (CObjetDonneeAIdNumerique objetTmp in liste)
{
if (objetTmp.IsValide())
{
bl.Append(objetTmp.Id);
bl.Append(',');
}
}
if (bl.Length == 0)
{
return(result);
}
bl.Remove(bl.Length - 1, 1);
if (IsUtiliseDansVersionFuture(liste, bl.ToString()))
{
result.EmpileErreur(I.T("Cannot delete these elements because they will be used in future versions|187"));
return(result);
}
try
{
liste.ContexteDonnee.EnforceConstraints = false;
if (liste.Count == 0)
{
return(result);
}
foreach (CObjetDonneeAIdNumerique objet in liste)
{
if (objet.IsValide())
{
result = objet.MyCanDelete();
if (!result)
{
return(result);
}
}
}
Type typeElements = liste.TypeObjets;
string strListeIds = "";
foreach (CObjetDonneeAIdNumerique objet in liste)
{
if (objet.IsValide())
{
strListeIds += objet.Id.ToString() + ",";
}
}
strListeIds = strListeIds.Substring(0, strListeIds.Length - 1);
string strNomTable = CContexteDonnee.GetNomTableForType(liste.TypeObjets);
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(strNomTable))
{
if (relation.TableParente == strNomTable)
{
//Car la dépendance doit être lue pour la suppression
CListeObjetsDonnees listeDep = liste.GetDependancesFilles(relation);
result = DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(listeDep, bDansContexteCourant);
if (!result)
{
return(result);
}
}
}
if (typeElements.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length == 0)
{
//Peut-on supprimer les relationsTypeId
foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
{
Type tpLiens = CContexteDonnee.GetTypeForTable(relation.TableFille);
CListeObjetsDonnees listeTypeId = new CListeObjetsDonnees(liste.ContexteDonnee, tpLiens, false);
CFiltreData filtre = new CFiltreData(
relation.ChampType + "=@1 and " +
relation.ChampId + " in (" + strListeIds + ")",
typeElements.ToString());
listeTypeId.Filtre = filtre;
listeTypeId.PreserveChanges = true;
result = DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(listeTypeId, bDansContexteCourant);
}
}
foreach (CObjetDonneeAIdNumerique objet in liste.ToArrayList())
{
if (objet.IsValide())
{
result = objet.DoDeleteInterneACObjetDonneeNePasUtiliserSansBonneRaison(bDansContexteCourant);
if (!result)
{
return(result);
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
liste.ContexteDonnee.EnforceConstraints = bOldEnforce;
}
catch
{
if (liste.ContexteDonnee.HasErrors)
{
foreach (DataTable table in liste.ContexteDonnee.Tables)
{
if (table.HasErrors)
{
foreach (DataRow row in table.Rows)
{
if (row.HasErrors)
{
string strKey = "";
foreach (DataColumn col in table.PrimaryKey)
{
strKey += row[col].ToString() + "/";
}
result.EmpileErreur("Error while deleting (" + table.TableName + "[" +
strKey + "] : " + row.RowError);
}
}
}
}
}
}
}
return(result);
}
public CListeObjetDonneeGenerique(CContexteDonnee contexte, CFiltreData filtrePrincipal)
: base(contexte, typeof(TypeObjets), filtrePrincipal)
{
}
public CInfoFiltreUnique(UniqueAttribute attr, CFiltreData filtre)
{
Attribute = attr;
Filtre = filtre;
}
/////////////////////////////////////////////////////////////////
/// <summary>
/// Ajoute la suppression de relationsTypeId qui sont des compositions
/// </summary>
/// <returns></returns>
public static CResultAErreur DoDeleteInterneACObjetDonneeNePasUtiliserSansBonneRaison(CListeObjetsDonnees liste, bool bDansContexteCourant)
{
CResultAErreur result = CResultAErreur.True;
if (liste.Count == 0)
{
return(result);
}
Type typeElements = liste.TypeObjets;
int nTailleBloc = 500; //Travaille par bloc de 500 éléments
int nCount = liste.Count;
for (int nBloc = 0; nBloc < nCount; nBloc += nTailleBloc)
{
StringBuilder blIds = new StringBuilder();
int nMin = Math.Min(nBloc + nTailleBloc, nCount);
for (int nElement = nBloc; nElement < nMin; nElement++)
{
if (((CObjetDonneeAIdNumerique)liste[nElement]).IsValide())
{
blIds.Append(((CObjetDonneeAIdNumerique)liste[nElement]).Id);
blIds.Append(',');
}
}
if (blIds.Length > 0)
{
blIds.Remove(blIds.Length - 1, 1);
{
string strListeIds = blIds.ToString();
//Supprime tous les fils de relation TypeId
foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
{
if (relation.Composition)
{
Type tpLiens = CContexteDonnee.GetTypeForTable(relation.TableFille);
if (relation.IsAppliqueToType(typeElements))
{
CListeObjetsDonnees listeTypeId = new CListeObjetsDonnees(liste.ContexteDonnee, tpLiens, false);
CFiltreData filtre = new CFiltreData(
relation.ChampType + "=@1 and " +
relation.ChampId + " in (" + strListeIds + ")",
typeElements.ToString());
listeTypeId.Filtre = filtre;
listeTypeId.PreserveChanges = true;
result = DoDeleteInterneACObjetDonneeNePasUtiliserSansBonneRaison(listeTypeId, bDansContexteCourant);
if (!result)
{
return(result);
}
}
}
}
}
}
}
List <CInfoRelation> relationsAMettreANull = new List <CInfoRelation>();
string strNomTable = CContexteDonnee.GetNomTableForType(liste.TypeObjets);
foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(strNomTable))
{
if (info.PasserLesFilsANullLorsDeLaSuppression && info.TableParente == strNomTable)
{
relationsAMettreANull.Add(info);
}
}
//Met à null ce qui doit l'être
for (int nBloc = 0; nBloc < nCount; nBloc += nTailleBloc)
{
int nMin = Math.Min(nBloc + nTailleBloc, nCount);
StringBuilder bl = new StringBuilder();
for (int nElt = nBloc; nElt < nMin; nElt++)
{
if (((CObjetDonneeAIdNumerique)liste[nElt]).IsValide())
{
bl.Append(((CObjetDonneeAIdNumerique)liste[nElt]).Id);
bl.Append(',');
}
}
bl.Remove(bl.Length - 1, 1);
if (bl.Length > 0)
{
foreach (CInfoRelation relationToNull in relationsAMettreANull)
{
CListeObjetsDonnees lstFils = new CListeObjetsDonnees(liste.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relationToNull.TableFille));
lstFils.Filtre = new CFiltreData(relationToNull.ChampsFille[0] + " in(" +
bl.ToString() + ")");
lstFils.Filtre.IgnorerVersionDeContexte = true;
lstFils.Filtre.IntegrerLesElementsSupprimes = true;
lstFils.PreserveChanges = true;
foreach (CObjetDonnee fils in lstFils.ToArrayList())
{
fils.Row.Row.BeginEdit();
foreach (string strChamp in relationToNull.ChampsFille)
{
fils.Row.Row[strChamp] = DBNull.Value;
}
fils.Row.Row.EndEdit();
}
}
}
}
foreach (CObjetDonneeAIdNumerique objet in liste.ToArrayList())
{
try
{
if (objet.Row.RowState != DataRowState.Deleted && objet.Row.RowState != DataRowState.Detached)
{
objet.Row.Row.Sc2iDelete();
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
}
return(result);
}
///////////////////////////////////////////////////
public static CFiltreData GetOrFiltre(CFiltreData filtre1, CFiltreData filtre2)
{
return(CombineFiltres(filtre1, filtre2, "OR"));
}
/// <summary>
/// Retourne un filtre de recherche rapide pour le type demandé
///
/// </summary>
/// <param name="tp"></param>
/// <param name="bContient">Indique que le filtre est un filtre 'Contient' et non 'Commence par'</param>
/// <returns></returns>
public static CFiltreData GetFiltreRapideForType(Type tp)
{
if (tp == null)
{
return(null);
}
CFiltreData filtreRetour = null;
if (m_filtreRapideDelegate != null)
{
m_filtreRapideDelegate.Invoke(tp, ref filtreRetour);
}
if (filtreRetour != null)
{
return(filtreRetour);
}
bool bAvance = false;
ArrayList lstChamps = new ArrayList();
foreach (PropertyInfo prop in tp.GetProperties())
{
if (prop.PropertyType == typeof(string))
{
bool bPrendre = false;
if (prop.Name.ToUpper() == "LIBELLE" || prop.Name.ToUpper() == "NOM")
{
bPrendre = true;
}
else
{
object[] attribs = prop.GetCustomAttributes(typeof(RechercheRapideAttribute), true);
bPrendre = attribs.Length > 0;
}
if (bPrendre)
{
//Cherche le nom du champ correspondant
object[] attribs = prop.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true);
if (attribs.Length > 0)
{
TableFieldPropertyAttribute attr = (TableFieldPropertyAttribute)attribs[0];
lstChamps.Add(attr.NomChamp);
}
}
}
}
object[] attribsClasse = tp.GetCustomAttributes(typeof(RechercheRapideAttribute), true);
foreach (RechercheRapideAttribute attr in attribsClasse)
{
if (attr.ChampFiltre != "")
{
lstChamps.Add(attr.ChampFiltre);
}
if (attr.ChampFiltre.IndexOf('.') >= 0)
{
bAvance = true;
}
}
if (lstChamps.Count == 0)
{
return(null);
}
string strFiltre = "";
foreach (string strChamp in lstChamps)
{
strFiltre += strChamp + " like @1 or ";
}
strFiltre = strFiltre.Substring(0, strFiltre.Length - 4);
if (bAvance)
{
return(new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(tp),
strFiltre, ""));
}
return(new CFiltreData(strFiltre, ""));
}
////////////////////////////////////////////////////////
public string GetStringExpression(IExpression expression, CFiltreData filtre)
{
string strRetour = "";
if (expression is CComposantFiltre)
{
expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
}
if (expression is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
foreach (CInfoRelationComposantFiltre info in champ.Relations)
{
strRetour += "Parent(" + info.RelationKey + ").";
}
strRetour += champ.NomChamp;
}
else if (expression is CComposantFiltreConstante)
{
CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
if (constante.Valeur is String)
{
strRetour = "'" + constante.Valeur.ToString().Replace("'", "''") + "'";
}
else if (constante.Valeur is DateTime)
{
strRetour += ((DateTime)constante.Valeur).ToShortDateString();
}
else
{
strRetour += constante.Valeur.ToString();
}
}
else if (expression is CComposantFiltreListe)
{
CComposantFiltreListe liste = (CComposantFiltreListe)expression;
strRetour = "";
foreach (IExpression expDeListe in liste.Liste)
{
strRetour += GetStringExpression(expDeListe, filtre) + ",";
}
if (strRetour.Length > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour = "(" + strRetour + ")";
}
else if (expression is CComposantFiltreOperateur)
{
COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
string strTexteOperateur = operateur.Texte;
if (operateur.Niveau > 0 && operateur.Niveau != 4)
{
if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
{
strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
}
strRetour = GetStringExpression((IExpression)expression.Parametres[0], filtre) +
" " + strTexteOperateur +
" " + GetStringExpression((IExpression)expression.Parametres[1], filtre);
}
else
{
strRetour = strTexteOperateur + "(";
foreach (IExpression exp in expression.Parametres)
{
strRetour += GetStringExpression(exp, filtre) + ",";
}
if (expression.Parametres.Count > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour += ")";
}
}
return(strRetour);
}
//------------------------------------------------------------------------------------
private CResultAErreur IntegreModif(
ref bool bHasData,
DataTable table,
IObjetServeur loader,
CFiltreData filtreSynchro,
int nIdSyncStart,
int nIdSyncEnd)
{
CResultAErreur result = CResultAErreur.True;
DataTable newTable = loader.Read(filtreSynchro);
if (newTable.Rows.Count != 0)
{
bHasData = true;
}
foreach (DataRow row in newTable.Rows)
{
if (nIdSyncStart == -1)
{
row.AcceptChanges();
row.SetAdded();
}
else
{
int?nIdSessionRow = row[CSc2iDataConst.c_champIdSynchro] as int?;
if (nIdSessionRow == null &&
nIdSessionRow.Value >= nIdSyncStart)
{
row.AcceptChanges();
row.SetModified();
}
}
}
IntegreTable(newTable, false);
//Synchronisation des blobs
if (loader.HasBlobs())
{
string strPrim = table.PrimaryKey[0].ColumnName;
foreach (DataColumn col in table.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
foreach (DataRow row in table.Rows)
{
result = loader.ReadBlob(col.ColumnName, new object[] { row[strPrim] });
if (result)
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(IdSession, row, col.ColumnName);
donnee.Donnees = (byte[])result.Data;
row[col.ColumnName] = donnee;
}
if (!result)
{
return(result);
}
}
}
}
}
//Gestion des ajouts et suppressions
CListeObjetDonneeGenerique <CEntreeLogSynchronisation> lst = new CListeObjetDonneeGenerique <CEntreeLogSynchronisation>(this);
if (nIdSyncStart == -1)
{
lst.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champTable + "=@1 and " +
CSc2iDataConst.c_champIdSynchro + "<=@2",
table.TableName,
nIdSyncEnd);
}
else
{
lst.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champTable + "=@1 and " +
CSc2iDataConst.c_champIdSynchro + "<=@2 and " +
CSc2iDataConst.c_champIdSynchro + ">=@3",
table.TableName,
nIdSyncEnd,
nIdSyncStart);
}
lst.Tri = CEntreeLogSynchronisation.c_champType;
foreach (CEntreeLogSynchronisation log in lst)
{
if (log.TypeModif == CEntreeLogSynchronisation.TypeModifLogSynchro.tAdd)
{
DataRow row = table.Rows.Find(log.IdElement);
if (row != null && row.RowState != DataRowState.Added)
{
row.AcceptChanges();
row.SetAdded();
}
}
if (log.TypeModif == CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete)
{
DataRow row = table.Rows.Find(log.IdElement);
if (row != null)
{
if (row.RowState == DataRowState.Added)
{
table.Rows.Remove(row);
}
else
{
row.Delete();
}
}
}
}
return(result);
}
protected CResultAErreur FillWithModifsFromVersion(
int nIdSynchroDebut,
int nIdSynchroFin,
ref bool bHasData,
CFiltresSynchronisation filtres,
bool bOnlyTablesIndiqueesDansFiltresSynchro,
bool bNePasLireLesDonnées)
{
m_nIdSynchro = nIdSynchroDebut;
CResultAErreur result = CResultAErreur.True;
Clear();
//Crée la structure
string[] strTables = m_mappeurTablesToClass.GetListeTables();
if (bOnlyTablesIndiqueesDansFiltresSynchro)
{
strTables = filtres.TablesDefinies;
}
foreach (string strTable in strTables)
{
try
{
GetTableSafe(strTable);
}
catch
{
//La table n'existe pas, elle n'est probablement pas dans la structure secondaire
}
}
//va chercher les informations dans la base pour chaque table
ArrayList lst = GetTablesOrderInsert();
int nTable = 0;
bool bOldEnforce = EnforceConstraints;
EnforceConstraints = false;
List <CModifSynchronisation> lstModifs = new List <CModifSynchronisation>();
foreach (DataTable table in lst)
{
if (m_mappeurTablesToClass.IsSynchronisable(table.TableName))
{
IObjetServeur loader = GetTableLoader(table.TableName);
CFiltreData filtreSynchro = GetFiltreSynchro(IdSession, nIdSynchroDebut, nIdSynchroFin, filtres, table);
if (bNePasLireLesDonnées)
{
int nCount = loader.CountRecords(table.TableName, filtreSynchro);
if (nCount > 0)
{
CModifSynchronisation modif = new CModifSynchronisation(
table.TableName,
nCount,
filtreSynchro,
nIdSynchroDebut,
nIdSynchroFin);
lstModifs.Add(modif);
}
}
else
{
nTable++;
result = IntegreModif(
ref bHasData,
table,
loader,
filtreSynchro,
nIdSynchroDebut,
nIdSynchroFin);
if (!result)
{
return(result);
}
}
}
}
if (!bNePasLireLesDonnées)
{
//Intègre la table des synclog
CListeObjetDonneeGenerique <CEntreeLogSynchronisation> lstLogs = new CListeObjetDonneeGenerique <CEntreeLogSynchronisation>(this);
if (nIdSynchroDebut >= 0)
{
lstLogs.Filtre = new CFiltreData(CSc2iDataConst.c_champIdSynchro + ">=@1 and " +
CSc2iDataConst.c_champIdSynchro + "<=@2",
nIdSynchroDebut,
nIdSynchroFin);
}
else
{
lstLogs.Filtre = new CFiltreData(CSc2iDataConst.c_champIdSynchro + ">=@1",
nIdSynchroFin);
}
lstLogs.AssureLectureFaite();
}
EnforceConstraints = bOldEnforce;
Hashtable tableRowAdd = new Hashtable(); //Liste des éléments ajoutés
ArrayList listRowToDelete = new ArrayList();
//Les éléments sont supprimés s'ils ont été ajoutés et supprimés ensuite
/*//Charge les logs de données ajoutées et supprimées
* CListeObjetsDonnees lstEntrees = new CListeObjetsDonnees ( this, typeof(CEntreeLogSynchronisation));
* lstEntrees.Filtre = new CFiltreData ( CSc2iDataConst.c_champIdSynchro+">=@1 and "+
* CSc2iDataConst.c_champIdSynchro+"<=@2", nIdSynchroDebut, nIdSynchroFin);
* if ( bOnlyTablesIndiqueesDansFiltresSynchro )
* {
* StringBuilder bl = new StringBuilder();
* foreach ( string strTable in strTables )
* bl.Append("'"+strTable+"',");
* bl.Remove ( bl.Length-1, 1);
* lstEntrees.Filtre = CFiltreData.GetAndFiltre ( lstEntrees.Filtre,
* new CFiltreData ( CEntreeLogSynchronisation.c_champTable+" in ("+
* bl.ToString()+")"));
* }
* foreach ( CEntreeLogSynchronisation entree in lstEntrees )
* {
* if ( entree.TypeModif == CEntreeLogSynchronisation.TypeModifLogSynchro.tAdd )
* {
* DataTable table = GetTableSafe ( entree.TableConcernee );
* CObjetDonneeAIdNumerique obj = (CObjetDonneeAIdNumerique)GetNewObjetForTable ( table );
* obj.Id = entree.IdElement;
* tableRowAdd[entree.TableConcernee+"_"+entree.IdElement] = entree.Row;
* bHasData = true;
* }
* else
* {
* if ( tableRowAdd[entree.TableConcernee+"_"+entree.IdElement] != null )
* {
* listRowToDelete.Add ( entree.Row );
* listRowToDelete.Add ( tableRowAdd[entree.TableConcernee+"_"+entree.IdElement] );
* bHasData = true;
* }
* }
* }
*
* foreach ( DataRow row in listRowToDelete )
* {
* row.Delete();
* }*/
if (bNePasLireLesDonnées)
{
result.Data = lstModifs;
}
return(result);
}
//-------------------------------------
/// <summary>
/// Retourne tous les fils qui étaient affecté à l'objet à l'époque
/// </summary>
/// <param name="objet"></param>
/// <param name="relationFille"></param>
/// <returns></returns>
public int[] GetIdsChildsHistoriques(CObjetDonneeAIdNumerique objet, CInfoRelation relationFille)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relationFille.TableFille);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFils))
{
return(new int[0]);
}
CChampPourVersionInDb champFille = new CChampPourVersionInDb(relationFille.ChampsFille[0], "");
//Recherche toutes les modifications de la propriété fille
CListeObjetsDonnees listeModifsFilles = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CVersionDonneesObjetOperation));
listeModifsFilles.Filtre = new CFiltreDataAvance(
CVersionDonneesObjetOperation.c_nomTable,
CVersionDonneesObjetOperation.c_champChamp + "=@1 and " +
CVersionDonneesObjetOperation.c_champTypeChamp + "=@2 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champTypeElement + "=@3 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@4 and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_champId + ">=@5",
champFille.FieldKey,
champFille.TypeChampString,
tpFils.ToString(),
(int)CTypeVersion.TypeVersion.Archive,
Id);
listeModifsFilles.Tri = CVersionDonneesObjetOperation.c_champId + " desc";
listeModifsFilles.ReadDependances("VersionObjet");
ArrayList lstFils = new ArrayList();
//Remplit la liste des fils avec les fils actuels
//Récupère la liste de tous les fils actuels
//et supprimés depuis. En effet, un element supprimé depuis cette version mais qui est
//toujours lié à l'objet était donc lié à l'objet à l'époque
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = relationFille.TableFille;
C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID",
new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champDeRequete);
CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and (" +
CSc2iDataConst.c_champIdVersion + " is null or " +
CSc2iDataConst.c_champIdVersion + ">=@2)",
objet.Id,
Id);
filtre.IgnorerVersionDeContexte = true;
requete.FiltreAAppliquer = filtre;
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
lstFils.Add(row[0]);
}
}
foreach (CVersionDonneesObjetOperation data in listeModifsFilles)
{
if (data.GetValeur() is int && (int)data.GetValeur() == objet.Id)
{
if (!lstFils.Contains(data.VersionObjet.IdElement))
{
lstFils.Add(data.VersionObjet.IdElement);
}
}
else
{
lstFils.Remove(data.VersionObjet.IdElement);
}
}
//Toutes les entités créées après la version ont également été ajoutées,
//Donc n'y étaient pas
if (lstFils.Count > 0)
{
StringBuilder builder = new StringBuilder();
foreach (int nId in lstFils)
{
builder.Append(nId.ToString());
builder.Append(",");
}
string strIds = builder.ToString();
strIds = strIds.Substring(0, strIds.Length - 1);
requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = CVersionDonneesObjet.c_nomTable;
requete.FiltreAAppliquer = new CFiltreData(
CVersionDonneesObjet.c_champIdElement + " in (" + strIds + ") and " +
CVersionDonneesObjet.c_champTypeElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeOperation + "=@2 and " +
CVersionDonnees.c_champId + ">=@3",
tpFils.ToString(),
CTypeOperationSurObjet.TypeOperation.Ajout,
Id);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
requete.ListeChamps.Add(new C2iChampDeRequete("Id",
new CSourceDeChampDeRequete(CVersionDonneesObjet.c_champIdElement),
typeof(int),
OperationsAgregation.None,
true));
result = requete.ExecuteRequete(ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
lstFils.Remove(row[0]);
}
}
}
return((int[])lstFils.ToArray(typeof(int)));
}
/*///////////////////////////////////////////////////
* public void AddAndFiltre ( CFiltreData filtre )
* {
* if ( filtre == null || !filtre.HasFiltre )
* return;
* if ( m_strFiltre.Trim() != "" )
* m_strFiltre = "("+m_strFiltre+") and ";
* string strNewFiltre = filtre.Filtre+" ";
* int nNumNewParam = Parametres.Count +1;
* for ( int nParam = 0; nParam < filtre.Parametres.Count; nParam++ )
* {
* strNewFiltre = strNewFiltre.Replace("@"+(nParam+1).ToString()+" ", "@"+nNumNewParam.ToString()+" ");
* Parametres.Add ( filtre.Parametres[nParam] );
* nNumNewParam++;
* }
* m_strFiltre += strNewFiltre;
* }*/
///////////////////////////////////////////////////
protected static CFiltreData CombineFiltres(CFiltreData filtre1, CFiltreData filtre2, string strOperateur)
{
if ((filtre1 == null || !filtre1.HasFiltre) && (filtre2 == null || !filtre2.HasFiltre))
{
return(null);
}
if (filtre1 == null || !filtre1.HasFiltre)
{
return(filtre2.GetClone());
}
if (filtre2 == null || !filtre2.HasFiltre)
{
return(filtre1.GetClone());
}
if (filtre1 is CFiltreDataImpossible || filtre2 is CFiltreDataImpossible)
{
return(new CFiltreDataImpossible());
}
CFiltreData filtreResult = null;
if (filtre1 is CFiltreDataAvance || filtre2 is CFiltreDataAvance)
{
string strTable;
if (filtre1 is CFiltreDataAvance)
{
strTable = ((CFiltreDataAvance)filtre1).TablePrincipale;
if (filtre2 is CFiltreDataAvance &&
((CFiltreDataAvance)filtre2).TablePrincipale != strTable)
{
throw new Exception(I.T("Cannot combine @1 filter on different tables|133", strOperateur));
}
}
else
{
strTable = ((CFiltreDataAvance)filtre2).TablePrincipale;
}
filtreResult = new CFiltreDataAvance(strTable, "");
if (!(filtre1 is CFiltreDataAvance))
{
filtre1 = CFiltreDataAvance.ConvertFiltreToFiltreAvance(strTable, filtre1);
}
if (!(filtre2 is CFiltreDataAvance))
{
filtre2 = CFiltreDataAvance.ConvertFiltreToFiltreAvance(strTable, filtre2);
}
CResultAErreur result = CResultAErreur.True;
CFiltreDataAvance filtre1Avance = filtre1 as CFiltreDataAvance;
CComposantFiltre composant1 = filtre1Avance.ComposantPrincipal;
if (composant1 == null)
{
result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(filtre1.Filtre, strTable);
if (!result)
{
result.EmpileErreur(I.T("Error while analyzing filter @1|134", filtre1.Filtre));
throw new CExceptionErreur(result.Erreur);
}
composant1 = result.Data as CComposantFiltre;
}
CFiltreDataAvance copie = filtre2.GetClone() as CFiltreDataAvance;
copie.RenumerotteParameters(filtre1.Parametres.Count + 1);
CComposantFiltre composant2 = copie.ComposantPrincipal;
if (composant2 == null)
{
result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(copie.Filtre, strTable);
if (!result)
{
result.EmpileErreur(I.T("Error while analyzing filter @1|134", copie.Filtre));
throw new CExceptionErreur(result.Erreur);
}
composant2 = result.Data as CComposantFiltre;
}
CComposantFiltre composantPrincipal = null;
if (strOperateur.ToUpper() == "OR")
{
composantPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
}
if (strOperateur.ToUpper() == "AND")
{
composantPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
}
if (composantPrincipal != null)
{
composantPrincipal.Parametres.Add(composant1);
composantPrincipal.Parametres.Add(composant2);
filtreResult = new CFiltreDataAvance(strTable, composantPrincipal);
}
else
{
filtreResult.Filtre = "(" + composant1.GetString() + ") " + strOperateur + " (" +
composant2.GetString() + ")";
}
}
else
{
filtreResult = new CFiltreData();
filtreResult.Filtre = "(" + filtre1.Filtre + ")";
CFiltreData copie = filtre2.GetClone();
copie.RenumerotteParameters(filtre1.Parametres.Count + 1);
filtreResult.Filtre += " " + strOperateur + " (" + copie.Filtre + ")";
}
foreach (object parametre in filtre1.Parametres)
{
filtreResult.Parametres.Add(parametre);
}
foreach (object parametre in filtre2.Parametres)
{
filtreResult.Parametres.Add(parametre);
}
if (filtre1 != null && filtre1.SortOrder != "")
{
filtreResult.SortOrder = filtre1.SortOrder;
}
if (filtre2 != null && filtre2.SortOrder != "")
{
if (filtreResult.SortOrder != "")
{
filtreResult.SortOrder += ",";
}
filtreResult.SortOrder += filtre2.SortOrder;
}
if (filtre1 != null)
{
filtreResult.IntegrerLesElementsSupprimes |= filtre1.IntegrerLesElementsSupprimes;
filtreResult.IgnorerVersionDeContexte |= filtre1.IgnorerVersionDeContexte;
filtreResult.IdsDeVersionsALire = filtre1.IdsDeVersionsALire;
filtreResult.IntergerParentsHierarchiques |= filtre1.IntergerParentsHierarchiques;
filtreResult.IntegrerFilsHierarchiques |= filtre1.IntegrerFilsHierarchiques;
filtreResult.NeConserverQueLesRacines |= filtre1.NeConserverQueLesRacines;
}
if (filtre2 != null)
{
filtreResult.IntegrerLesElementsSupprimes |= filtre2.IntegrerLesElementsSupprimes;
filtreResult.IgnorerVersionDeContexte |= filtre2.IgnorerVersionDeContexte;
filtreResult.IntergerParentsHierarchiques |= filtre2.IntergerParentsHierarchiques;
filtreResult.IntegrerFilsHierarchiques |= filtre2.IntegrerFilsHierarchiques;
filtreResult.NeConserverQueLesRacines |= filtre2.NeConserverQueLesRacines;
if (filtre2.IdsDeVersionsALire != null)
{
if (filtreResult.IdsDeVersionsALire != null)
{
Hashtable tblIds = new Hashtable();
foreach (int nId in filtreResult.IdsDeVersionsALire)
{
tblIds[nId] = true;
}
foreach (int nId in filtre2.IdsDeVersionsALire)
{
tblIds[nId] = true;
}
ArrayList lst = new ArrayList();
foreach (int nId in tblIds.Keys)
{
lst.Add(nId);
}
filtreResult.IdsDeVersionsALire = (int[])lst.ToArray(typeof(int));
}
else
{
filtreResult.IdsDeVersionsALire = filtre2.IdsDeVersionsALire;
}
}
}
return(filtreResult);
}
//-----------------------------------------------------------------
public void AddFiltreForTable(string strTable, CFiltreData filtre, bool bAvecCompositions)
{
AddFiltreSynchroPourTable(strTable, new CFiltreSynchronisationFiltreData(filtre), bAvecCompositions);
}
///////////////////////////////////////////////////
public static CFiltreData GetAndFiltre(CFiltreData filtre1, CFiltreData filtre2)
{
return(CombineFiltres(filtre1, filtre2, "AND"));
}
////////////////////////////////////////////////////////////
private void Init(
CObjetDonnee objetParent,
string strNomTableFille,
string[] strChampsFille,
bool bAppliquerFiltreParDefaut)
{
m_strNomTableFille = strNomTableFille;
m_strChampsFille = strChampsFille;
m_objetConteneur = objetParent;
if (!RemplissageProgressif)
{
objetParent.AssureDependances(strNomTableFille, strChampsFille);
}
/*Stef 26042012 : suppression de cette optimisation,
* le problème est que si on ajoute des fils, alors, le filtre ne les voit plus !
* DataTable tableFille = ContexteDonnee.GetTableSafe(strNomTableFille);
* if (!RemplissageProgressif && tableFille != null && tableFille.PrimaryKey.Length == 1 &&
* tableFille.PrimaryKey[0].DataType == typeof(int))
* {
* string strFK = ContexteDonnee.GetForeignKeyName(objetParent.GetNomTable(), strNomTableFille, strChampsFille);
* DataRow[] rows = objetParent.Row.Row.GetChildRows(strFK);
* if (rows.Length == 0)
* m_filtrePrincipal = new CFiltreDataImpossible();
* else
* {
* DataColumn colKey = tableFille.PrimaryKey[0];
* StringBuilder bl = new StringBuilder();
* foreach (DataRow row in rows)
* {
* bl.Append(row[colKey]);
* bl.Append(',');
* }
* bl.Remove(bl.Length - 1, 1);
* m_filtrePrincipal = new CFiltreData(colKey.ColumnName + " in (" + bl.ToString() + ")");
* }
* }
* else*/
m_filtrePrincipal = CFiltreData.CreateFiltreAndSurValeurs(strChampsFille, objetParent.GetValeursCles());
m_bAppliquerFiltreParDefaut = bAppliquerFiltreParDefaut;
#if PDA
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTableFille));
objet.ContexteDonnee = m_objetConteneur.ContexteDonnee;
#else
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTableFille), new object[] { m_objetConteneur.ContexteDonnee });
#endif
CFiltreData filtre = bAppliquerFiltreParDefaut?objet.FiltreStandard:null;
if (filtre != null)
{
m_filtrePrincipal = CFiltreData.GetAndFiltre(m_filtrePrincipal, filtre);
}
if (!RemplissageProgressif)
{
//Puisque les objets sont lus, il n'y a aucune raison d'aller relire cette liste depuis
//La base de données
InterditLectureInDB = true;
m_bIsToRead = false;
}
}
/// ////////////////////////////////////////////////////////////////////////
public static void Merge(DataTable tableSource, DataSet dsDest, bool bPreseveChanges)
{
DataTable tableDest = dsDest.Tables[tableSource.TableName];
if (tableDest == null)
{
//Création de la table
tableDest = AddTableCopie(tableSource, dsDest);
}
bool bOldEnforce = dsDest.EnforceConstraints;
if (tableSource.Rows.Count == 0)
{
return;
}
DataColumn[] keys = tableSource.PrimaryKey;
int nNbKeys = tableSource.PrimaryKey.Length;
Hashtable tableSupprimees = null;
//Si une seule clé, stocke la liste des supprimées dans une hashtable
//pour un recherche plus rapide
if (nNbKeys == 1 && bPreseveChanges)
{
tableSupprimees = new Hashtable();
DataRow[] rows = tableDest.Select("", "", DataViewRowState.Deleted);
foreach (DataRow row in rows)
{
tableSupprimees[row[keys[0].ColumnName, DataRowVersion.Original]] = true;
}
}
dsDest.EnforceConstraints = false;
DataColumn colIsToRead = tableDest.Columns[CContexteDonnee.c_colIsToRead];
try
{
foreach (DataRow row in tableSource.Rows)
{
try
{
DataRowVersion version = DataRowVersion.Default;
if (row.RowState == DataRowState.Deleted)
{
version = DataRowVersion.Original;
}
object[] cles = new object[nNbKeys];
for (int n = 0; n < nNbKeys; n++)
{
cles[n] = row[keys[n], version];
}
//Tente d'abord le lien sur la clé primaire
DataRow rowDest = tableDest.Rows.Find(cles);
if (rowDest != null)
{
bool bShouldUpdate = (rowDest.RowState & (DataRowState.Modified | DataRowState.Added | DataRowState.Deleted)) == 0;
if (bPreseveChanges && colIsToRead != null)
{
bShouldUpdate = (bool)rowDest[colIsToRead];
}
if (bShouldUpdate)
{
if (row.RowState == DataRowState.Deleted && rowDest.RowState != DataRowState.Deleted)
{
rowDest.Delete();
}
else
{
if (dsDest is CContexteDonnee)
{
((CContexteDonnee)dsDest).CopyRow(row, rowDest, DataRowVersion.Current, true);
}
else
{
CopyRow(row, rowDest, DataRowVersion.Current, true);
}
}
}
}
//Si la ligne existe dans le contexte de destination mais
//qu'elle a été supprimée, Find ne la trouve pas, il faut donc
//Vérifier si elle n'est pas là autrement
else
{
bool bShouldImporte = true;
if (bPreseveChanges) //On n'importe pas les lignes supprimées
//si on conserve les modifs faites dans la destination
{
if (tableSupprimees != null)
{
if (tableSupprimees.Contains(row[keys[0]]))
{
bShouldImporte = false;
}
}
else
{
CFiltreData filtre = CFiltreData.CreateFiltreAndSurRow(keys, row, DataRowVersion.Original);
DataRow[] rows = tableDest.Select(new CFormatteurFiltreDataToStringDataTable().GetString(filtre), "", DataViewRowState.Deleted);
if (rows.Length == 1 && rows[0].RowState == DataRowState.Deleted)
{
bShouldImporte = false;
}
}
}
if (bShouldImporte && row.RowState != DataRowState.Deleted)
{
tableDest.ImportRow(row);
}
}
}
catch (Exception e)
{
throw e;
}
finally
{
}
}
}
finally
{
dsDest.EnforceConstraints = bOldEnforce;
}
}
////////////////////////////////////////////////////////////
public static CResultAErreur CanDelete(CListeObjetsDonnees liste)
{
CResultAErreur result = CResultAErreur.True;
if (liste.Count == 0)
{
return(result);
}
bool bPasObjetAIdNumeriqueAuto = false;
foreach (CObjetDonnee objet in liste)
{
if (!(objet is CObjetDonneeAIdNumerique))
{
bPasObjetAIdNumeriqueAuto = true;
result = objet.CanDelete();
}
else
{
result = ((CObjetDonneeAIdNumerique)objet).MyCanDelete();
}
if (!result)
{
return(result);
}
}
if (bPasObjetAIdNumeriqueAuto)
{
return(result);
}
Type typeElements = liste.TypeObjets;
string strListeIds = "";
int nCount = liste.Count;
int nTailleParBloc = 500;
string strNomTable = CContexteDonnee.GetNomTableForType(liste.TypeObjets);
//Copie de la liste, pour sécuriser le parcours
List <CObjetDonneeAIdNumerique> lstElements = liste.ToList <CObjetDonneeAIdNumerique>();
//Travaille par bloc de 500 enregistrements pour les contrôles
for (int nBloc = 0; nBloc < nCount; nBloc += nTailleParBloc)
{
StringBuilder bl = new StringBuilder();
int nMin = Math.Min(nBloc + nTailleParBloc, nCount);
//Liste des éléments du bloc en cours
for (int nElement = nBloc; nElement < nMin; nElement++)
{
bl.Append(lstElements[nElement].Id);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
//Liste des objets du bloc en cours
CListeObjetsDonnees listePartielle = new CListeObjetsDonnees(liste.ContexteDonnee, liste.TypeObjets, false);
listePartielle.Filtre = new CFiltreData(
liste.ContexteDonnee.GetTableSafe(strNomTable).PrimaryKey[0].ColumnName + " in (" +
bl.ToString() + ")");;
listePartielle.InterditLectureInDB = true; //Pas besoin de lire car les éléments sont déjà dans le contexte de données
listePartielle.Filtre.IntegrerLesElementsSupprimes = liste.Filtre != null?
liste.Filtre.IntegrerLesElementsSupprimes:
(liste.FiltrePrincipal != null?liste.FiltrePrincipal.IntegrerLesElementsSupprimes:false);
listePartielle.Filtre.IgnorerVersionDeContexte = liste.Filtre != null ?
liste.Filtre.IgnorerVersionDeContexte:
(liste.FiltrePrincipal != null ? liste.FiltrePrincipal.IgnorerVersionDeContexte : false);
strListeIds = bl.ToString();
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(strNomTable))
{
if (relation.TableParente == strNomTable) //Relation fille
{
if (!relation.Composition) //Ce n'est pas une composition, il ne faut pas qu'il y ait de fils
{
if (!relation.PasserLesFilsANullLorsDeLaSuppression) //Sinon, ce n'est pas grave !
{
IObjetServeur objServeur = liste.ContexteDonnee.GetTableLoader(relation.TableFille);
//Ceux pour lesquels les dépendances sont chargés n'ont pas besoin de regarder la base
StringBuilder strIdsAVoirDansLaBase = new StringBuilder();
DataRelation dataRel = null;
foreach (DataRelation childRel in liste.ContexteDonnee.GetTableSafe(relation.TableParente).ChildRelations)
{
bool bCestElle = false;
if (childRel.ChildTable.TableName == relation.TableFille)
{
if (childRel.ChildColumns.Length == relation.ChampsFille.Length)
{
bCestElle = true;
for (int nCol = 0; nCol < childRel.ChildColumns.Length; nCol++)
{
if (childRel.ChildColumns[nCol].ColumnName != relation.ChampsFille[nCol])
{
bCestElle = false;
break;
}
}
}
}
if (bCestElle)
{
dataRel = childRel;
break;
}
}
if (dataRel != null)
{
foreach (CObjetDonneeAIdNumerique objetTmp in listePartielle)
{
string strFKName = objetTmp.ContexteDonnee.GetForeignKeyName(dataRel);
if (objetTmp.IsDependanceChargee(strFKName))
{
DataRow[] rowsFilles = objetTmp.Row.Row.GetChildRows(dataRel);
if (rowsFilles.Length > 0)
{
result.EmpileErreur(I.T("Cannot delete element @1, @2 elements (@3) are linked|190",
objetTmp.DescriptionElement,
rowsFilles.Length.ToString(),
relation.TableFille));
return(result);
}
}
else
{
strIdsAVoirDansLaBase.Append(objetTmp.Id);
strIdsAVoirDansLaBase.Append(',');
}
}
if (strIdsAVoirDansLaBase.Length > 0)
{
strIdsAVoirDansLaBase.Remove(strIdsAVoirDansLaBase.Length - 1, 1);
}
}
else
{
strIdsAVoirDansLaBase.Append(strListeIds);
}
if (strIdsAVoirDansLaBase.Length > 0)
{
CFiltreData filtre = new CFiltreData(relation.ChampsFille[0] + " in (" +
strIdsAVoirDansLaBase.ToString() + ")");
int nNb = objServeur.CountRecords(relation.TableFille, filtre);
if (nNb != 0)
{
Type tp = CContexteDonnee.GetTypeForTable(relation.TableFille);
result.EmpileErreur(I.T("Cannot delete '@1' elements because '@2' elements are dependent|160", DynamicClassAttribute.GetNomConvivial(typeElements), DynamicClassAttribute.GetNomConvivial(tp)));
return(result);
}
}
}
}
else //C'est une composition
{
CListeObjetsDonnees listeDep = listePartielle.GetDependancesFilles(relation, liste.Filtre != null && liste.Filtre.IntegrerLesElementsSupprimes ||
liste.FiltrePrincipal != null && liste.FiltrePrincipal.IntegrerLesElementsSupprimes);
result = CanDelete(listeDep);
if (!result)
{
return(result);
}
}
}
}
//Peut-on supprimer les relationsTypeId
foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
{
Type tpLiens = CContexteDonnee.GetTypeForTable(relation.TableFille);
if (relation.AppliquerContrainteIntegrite && !relation.CanDeleteToujours && relation.IsAppliqueToType(typeElements))
{
CListeObjetsDonnees listeTypeId = new CListeObjetsDonnees(liste.ContexteDonnee, tpLiens, false);
CFiltreData filtre = new CFiltreData(
relation.ChampType + "=@1 and " +
relation.ChampId + " in (" + strListeIds + ")",
typeElements.ToString());
listeTypeId.Filtre = filtre;
if (relation.Composition)
{
result = CanDelete(listeTypeId);
if (!result)
{
return(result);
}
}
else
{
int nNb = listeTypeId.CountNoLoad;
if (nNb != 0)
{
Type tp = CContexteDonnee.GetTypeForTable(relation.TableFille);
result.EmpileErreur(I.T("Cannot delete the required elements because elements @1 exist in database|161", DynamicClassAttribute.GetNomConvivial(tpLiens)));
return(result);
}
}
}
}
if (IsUtiliseDansVersionFuture(liste, strListeIds))
{
result.EmpileErreur(I.T("Cannot delete these elements because they will be used in future versions|187"));
return(result);
}
}
}
return(result);
}