////////////////////////////////////////////////////////////////////////////////////
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;
}
/// //////////////////////////////////////////
public CResultAErreur SaveBlobs()
{
CResultAErreur result = CResultAErreur.True;
foreach (DataTable table in Tables)
{
if (m_mappeurTablesToClass.IsSynchronisable(table.TableName))
{
IObjetServeur loader = GetTableLoader(table.TableName);
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)
{
if (row[col.ColumnName] != DBNull.Value)
{
CDonneeBinaireInRow db = (CDonneeBinaireInRow)row[col.ColumnName];
result = loader.SaveBlob(col.ColumnName, new object[] { row[strPrim] }, db.Donnees, null, null);
if (!result)
{
return(result);
}
}
}
}
}
}
}
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public CResultAErreur IntegreModif(CModifSynchronisation modif)
{
DataTable table = GetTableSafe(modif.TableName);
IObjetServeur loader = GetTableLoader(modif.TableName);
bool bTmp = false;
return(IntegreModif(ref bTmp, table, loader, modif.FiltreSynchronisation, modif.IdSyncStart, modif.IdSyncEnd));
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 3];
for (int nIndex = 3; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 3] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[2], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("CalculSql cannot be applied here|204"));
return(result);
}
CObjetDonnee objet = (CObjetDonnee)ctx.ObjetSource;
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
Type tpInterroge = CContexteDonnee.GetTypeForTable(filtre.TablePrincipale);
result = Parametres2i[1].Eval(ctx);
if (!result)
{
return(result);
}
result = GetClauseSelect(result.Data.ToString(), tpInterroge);
IObjetServeur serveur = objet.ContexteDonnee.GetTableLoader(filtre.TablePrincipale);
result = serveur.ExecuteScalar((string)result.Data, filtre);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in calculSql|205"));
}
return(result);
}
////////////////////////////////////////////////////////////////////////////////////
/// <summary>
///
/// </summary>
/// <param name="nIdVersionArchive">Id du CVersionDonnees auquel est associée la modification</param>
/// <returns></returns>
public CResultAErreur SaveData(int?nIdVersionArchive)
{
if (!m_bHasChangeSinceRead)
{
return(CResultAErreur.True);
}
if (!m_bLoaded)
{
return(CResultAErreur.True);
}
IObjetServeur loader = ((CContexteDonnee)m_row.Table.DataSet).GetTableLoader(m_row.Table.TableName);
ArrayList lst = new ArrayList();
foreach (DataColumn col in m_row.Table.PrimaryKey)
{
lst.Add(m_row[col]);
}
CResultAErreur result = loader.SaveBlob(m_strChamp, lst.ToArray(), m_donnees, nIdVersionArchive, m_donneesOriginales);
return(result);
}
///////////////////////////////////////////////////////////////////////////////
protected override void PrepareLoader(IObjetServeur loader)
{
loader.DesactiverIdentifiantAutomatique = true;
loader.DesactiverContraintes = true;
}
/// //////////////////////////////////////////
///<summary>
///Charge les données de la table qui vont devoir être mise à jour
///à partir des données modifiées dans la table source
///</summary>
public CResultAErreur ChargeDonneesAMettreAJour(DataSet donneesSources)
{
CResultAErreur result = CResultAErreur.True;
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(donneesSources);
foreach (DataTable table in lstTables)
{
DataTable tableDest = null;
//S'assure que la table est bien chargée
try
{
tableDest = GetTableSafe(table.TableName);
}
catch
{
//La table n'existe pas
}
if (tableDest != null && m_mappeurTablesToClass.IsSynchronisable(table.TableName) && table.Rows.Count != 0)
{
IObjetServeur serveur = CContexteDonnee.GetTableLoader(tableDest.TableName, null, IdSession);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(tableDest.TableName);
if (serveur.CountRecords(strNomTableInDb, new CFiltreData("1=1")) != 0) //Première maj : copie complète
{
string strColPrim = table.PrimaryKey[0].ColumnName;
string strFiltre = "";
foreach (DataRow row in table.Rows)
{
strFiltre += row[strColPrim].ToString() + ",";
}
if (strFiltre.Length != 0)
{
//Supprime la dernière virgule;
strFiltre = strFiltre.Substring(0, strFiltre.Length - 1);
strFiltre = strColPrim += " in (" + strFiltre + ")";
IObjetServeur loader = GetTableLoader(table.TableName);
DataTable tableNew = loader.Read(new CFiltreData(strFiltre));
if (table == null)
{
result.EmpileErreur(I.T("Error while reading table @1|128", table.TableName));
return(result);
}
IntegreTable(tableNew, false);
}
}
}
}
//Charge les éléments à supprimer
CContexteDonnee contexteForListe = new CContexteDonnee(IdSession, true, false);
DataTable tableSync = donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable];
DataTable tableCopie = CUtilDataSet.AddTableCopie(donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable], contexteForListe);
foreach (DataRow row in tableSync.Rows)
{
tableCopie.ImportRow(row);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForListe, typeof(CEntreeLogSynchronisation));
liste.InterditLectureInDB = true;
liste.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champType + "=@1", (int)CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete);
foreach (CEntreeLogSynchronisation entree in liste)
{
DataTable table = GetTableSafe(entree.TableConcernee);
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)GetNewObjetForTable(table);
objet.ReadIfExists(entree.IdElement);
}
return(result);
}
//------------------------------------------------------------------------------------
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);
}
////////////////////////////////////////////////////////////
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);
}
