//---------------------------------------------------------------------
public CResultAErreur AppliqueValeur(int?nIdVersion, IChampPourVersion champ, CObjetDonneeAIdNumerique objet, object valeur)
{
CResultAErreur result = CResultAErreur.True;
if (objet.Row.Table.Columns.Contains(champ.FieldKey))
{
try
{
if (valeur is byte[])
{
CDonneeBinaireInRow data = new CDonneeBinaireInRow(objet.ContexteDonnee.IdSession, objet.Row.Row, champ.FieldKey);
data.Donnees = (byte[])valeur;
objet.Row[champ.FieldKey] = data;
}
else if (valeur is IDifferencesBlob)
{
CContexteDonnee ctx = new CContexteDonnee(objet.ContexteDonnee.IdSession, true, false);
result = ctx.SetVersionDeTravail(nIdVersion, false);
if (!result)
{
return(result);
}
CObjetDonneeAIdNumerique objetDansVersion = (CObjetDonneeAIdNumerique)Activator.CreateInstance(objet.GetType(), new object[] { ctx });
if (objetDansVersion.ReadIfExists(objet.Id))
{
CDonneeBinaireInRow dataInVersion = new CDonneeBinaireInRow(ctx.IdSession, objetDansVersion.Row.Row, champ.FieldKey);
CDonneeBinaireInRow data = new CDonneeBinaireInRow(objet.ContexteDonnee.IdSession, objet.Row.Row, champ.FieldKey);
data.Donnees = dataInVersion.Donnees;
objet.Row[champ.FieldKey] = data;
}
else
{
throw new Exception(I.T("Error|199"));
}
}
else
{
objet.Row[champ.FieldKey] = valeur == null ? DBNull.Value : valeur;
}
}
catch
{
try
{
bool bOldEnforce = objet.ContexteDonnee.EnforceConstraints;
objet.ContexteDonnee.EnforceConstraints = false;
objet.Row[champ.FieldKey] = valeur == null ? DBNull.Value : valeur;
objet.ContexteDonnee.AssureParents(objet.Row.Row);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while applying value for field @1|189", champ.NomConvivial));
}
}
}
return(result);
}
/// //////////////////////////////////////////
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 CDonneeBinaireInRow GetCloneForRow(DataRow row)
{
AssureDonnees();
CDonneeBinaireInRow newDonnee = new CDonneeBinaireInRow(m_nIdSession, row, m_strChamp);
newDonnee.m_bLoaded = m_bLoaded;
newDonnee.m_bHasChangeSinceRead = m_bHasChangeSinceRead;
if (m_donnees != null)
{
byte[] data = (byte[])m_donnees.Clone();
newDonnee.m_donnees = data;
}
else
{
newDonnee.m_donnees = null;
}
if (m_donneesOriginales != null)
{
byte[] data = (byte[])m_donneesOriginales.Clone();
newDonnee.m_donneesOriginales = data;
}
else
{
newDonnee.m_donneesOriginales = null;
}
return(newDonnee);
}
public static object GetValeur(
DataRow row,
string strChampString,
string strChampBlob,
string strChampType,
CContexteDonnee ctx)
{
Type t = CActivatorSurChaine.GetType((string)row[strChampType]);
if (t == typeof(IDifferencesBlob))
{
CDonneeBinaireInRow blob = GetBlob(row, strChampBlob, ctx);
MemoryStream stream = new MemoryStream(blob.Donnees);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire serializer = new CSerializerReadBinaire(reader);
I2iSerializable objet = null;
CResultAErreur result = serializer.TraiteObject(ref objet);
reader.Close();
stream.Close();
if (result)
{
return(objet);
}
System.Console.WriteLine(I.T("Error while deserializing blob diffs|30000"));
return(null);
}
else if (t == typeof(byte[]))
{
CDonneeBinaireInRow blob = GetBlob(row, strChampBlob, ctx);
if (blob != null)
{
return(blob.Donnees);
}
else
{
return(null);
}
}
else if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(t))
{
int nId = Int32.Parse((string)row[strChampString]);
CObjetDonneeAIdNumerique obj = (CObjetDonneeAIdNumerique)Activator.CreateInstance(t, new object[] { ctx });
if (obj.ReadIfExists(nId))
{
return(obj);
}
return(null);
}
else if (t != null && row[strChampString] != DBNull.Value)
{
return(CUtilTexte.FromUniversalString((string)row[strChampString], t));
}
return(null);
}
////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Si la CDonneeBinaireInRow n'est pas liée à la row, renvoie un
/// nouveau CDonneeBinaireInRow qui correspond à la bonne row
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
public CDonneeBinaireInRow GetSafeForRow(DataRow row)
{
if (m_row != row)
{
CDonneeBinaireInRow newData = GetCloneForRow(row);
CContexteDonnee.ChangeRowSansDetectionModification(row, m_strChamp, newData);
return(newData);
}
return(this);
}
public static void StockValeur(
DataRow row,
int idSession,
string strChampType,
string strChampBlob,
string strChampString,
object val)
{
if (val is IDifferencesBlob)
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
CSerializerSaveBinaire serializer = new CSerializerSaveBinaire(writer);
I2iSerializable serTmp = (I2iSerializable)val;
CResultAErreur result = serializer.TraiteObject(ref serTmp);
if (!result)
{
throw new Exception(I.T("Can not serialize blob differences|192"));
}
row[strChampType] = typeof(IDifferencesBlob).ToString();
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(idSession, row, strChampBlob);
donnee.Donnees = stream.GetBuffer();
row[strChampBlob] = donnee;
writer.Close();
stream.Close();
}
else if (val is byte[])
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(idSession, row, strChampBlob);
donnee.Donnees = (byte[])val;
row[strChampBlob] = donnee;
row[strChampType] = typeof(byte[]).ToString();
}
else if (val != null && val.GetType() == typeof(CDonneeBinaireInRow))
{
row[strChampBlob] = val;
row[strChampType] = typeof(byte[]).ToString();
}
else if (val is CObjetDonneeAIdNumerique)
{
row[strChampString] = ((CObjetDonneeAIdNumerique)val).Id;
row[strChampString] = val.GetType().ToString();
}
else
{
row[strChampString] = CUtilTexte.ToUniversalString(val);
if (val != null)
{
row[strChampType] = val.GetType().ToString();
}
//else
// row[strChampType] = "";
}
}
public static CDonneeBinaireInRow GetBlob(DataRow row, string strChampBlob, CContexteDonnee ctx)
{
if (row[strChampBlob] == DBNull.Value)
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(ctx.IdSession, row, strChampBlob);
CContexteDonnee.ChangeRowSansDetectionModification(row, strChampBlob, donnee);
}
object obj = row[strChampBlob];
return((CDonneeBinaireInRow)obj);
}
public object GetValeur(CObjetDonneeAIdNumerique obj, IChampPourVersion champ)
{
if (obj.Row.Table.Columns[champ.FieldKey].DataType == typeof(CDonneeBinaireInRow))
{
if (obj.Row[champ.FieldKey] == DBNull.Value)
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(obj.ContexteDonnee.IdSession, obj.Row.Row, champ.FieldKey);
CContexteDonnee.ChangeRowSansDetectionModification(obj.Row.Row, champ.FieldKey, donnee);
}
/*DataRow row = obj.Row;
* DataTable tb = row.Table;
* IObjetServeur loader = ((CContexteDonnee)tb.DataSet).GetTableLoader(tb.TableName);
* CFiltreData filtre = CFiltreData.CreateFiltreAndSurRow(tb.PrimaryKey, row);
* ArrayList lstKeys = new ArrayList();
* foreach (DataColumn col in tb.PrimaryKey)
* lstKeys.Add(row[col]);
* CResultAErreur result = loader.ReadBlob(champ.FieldKey, lstKeys.ToArray());
* if ( result )*/
}
return(obj.Row[champ.FieldKey] == DBNull.Value ? null : obj.Row[champ.FieldKey]);
}
/// ///////////////////////////////////////////////////////////////
public CResultAErreur CreateValise(CObjetDonneeAIdNumeriqueAuto objet, DataSet ds)
{
int nIdSession = objet.ContexteDonnee.IdSession;
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contextePourChargementComplet = new CContexteDonnee(nIdSession, true, false))
{
result = contextePourChargementComplet.SetVersionDeTravail(objet.ContexteDonnee.IdVersionDeTravail, true);
if (!result)
{
return(result);
}
CObjetDonneeAIdNumeriqueAuto source = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(objet.GetType(), new object[] { contextePourChargementComplet });
if (!source.ReadIfExists(objet.Id))
{
result.EmpileErreur(I.T("Impossible to read the object @1 again|173", objet.Id.ToString()));
return(result);
}
ReadObjetEtDependances(source);
//Toutes les données sont lues, il n'y a plus qu'à les copier dans le dataset valise
foreach (DataTable tableSource in contextePourChargementComplet.Tables)
{
ds.Merge(tableSource);
//Crée les colonnes byte[] en place des CDonneeBinaireInRow
DataTable newTable = ds.Tables[tableSource.TableName];
if (tableSource.PrimaryKey.Length != 0)
{
foreach (DataColumn col in tableSource.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
newTable.Columns.Remove(col.ColumnName);
DataColumn newCol = new DataColumn(col.ColumnName, typeof(string));
newCol.AllowDBNull = true;
newTable.Columns.Add(col.ColumnName);
foreach (DataRow rowSource in tableSource.Rows)
{
ArrayList keys = new ArrayList();
foreach (DataColumn primKey in tableSource.PrimaryKey)
{
keys.Add(rowSource[primKey]);
}
DataRow rowDest = newTable.Rows.Find(keys.ToArray());
if (rowDest != null)
{
CDonneeBinaireInRow donnee = new CDonneeBinaireInRow(objet.ContexteDonnee.IdSession, rowSource, col.ColumnName);
byte[] dataBinaire = donnee.Donnees;
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
serializer.TraiteByteArray(ref dataBinaire);
rowDest[col.ColumnName] = serializer.String;
}
}
}
}
}
}
foreach (DataRelation relation in contextePourChargementComplet.Relations)
{
DataColumn colParente, colFille;
colParente = ds.Tables[relation.ParentTable.TableName].Columns[relation.ParentColumns[0].ColumnName];
colFille = ds.Tables[relation.ChildTable.TableName].Columns[relation.ChildColumns[0].ColumnName];
DataRelation rel = ds.Relations.Add(
relation.RelationName,
colParente,
colFille,
true);
rel.ChildKeyConstraint.UpdateRule = Rule.Cascade;
}
}
return(result);
}
/// ///////////////////////////// ///////////////////////////// //////////////////////////
/// <summary>
/// </summary>
/// <param name="rowSource"></param>
/// <param name="objetDest"></param>
/// <param name="interfaceMapping"></param>
/// <returns></returns>
private CResultAErreur ImporteObjet(DataRow rowSource, CObjetDonneeAIdNumeriqueAuto objetDest, IInterfaceImportObjetDonnee interfaceMapping)
{
CResultAErreur result = CResultAErreur.True;
rowSource[objetDest.GetChampId()] = objetDest.Id;
rowSource[c_colIsMappe] = true;
//Mappe les parents de l'objet dest
foreach (DataRelation relation in rowSource.Table.ParentRelations)
{
DataRow rowParente = rowSource.GetParentRow(relation);
if (rowParente != null && !(bool)rowParente[c_colIsMappe])
{
CObjetDonneeAIdNumeriqueAuto objetParent = null;
CListeObjetsDonnees liste = new CListeObjetsDonnees(objetDest.ContexteDonnee, CContexteDonnee.GetTypeForTable(relation.ParentTable.TableName));
result = interfaceMapping.MapObjet(rowParente, liste, ref objetParent);
if (!result)
{
return(result);
}
if (objetParent != null)
{
rowParente[objetParent.GetChampsId()[0]] = objetParent.Id;
}
else
{
rowSource[relation.ChildColumns[0]] = DBNull.Value;
}
rowParente[c_colIsMappe] = true;
objetDest.SetParent(relation.ChildColumns[0].ColumnName, objetParent);
}
}
objetDest.AssureData();
DataTable tableDest = objetDest.Table;
DataTable tableSource = rowSource.Table;
//Copie les données
objetDest.ContexteDonnee.CopyRow(rowSource, objetDest.Row.Row,
objetDest.GetChampId(), CSc2iDataConst.c_champIdSynchro, CContexteDonnee.c_colLocalKey,
CContexteDonnee.c_colIsToRead, CContexteDonnee.c_colIsFromDb);
//Convertit les données binaires
foreach (DataColumn colDest in tableDest.Columns)
{
if (colDest.DataType == typeof(CDonneeBinaireInRow))
{
DataColumn colSource = tableSource.Columns[colDest.ColumnName];
if (colSource != null && colSource.DataType == typeof(string))
{
object donneesSource = rowSource[colDest.ColumnName];
if (donneesSource != DBNull.Value)
{
CStringSerializer serializer = new CStringSerializer((string)donneesSource, ModeSerialisation.Lecture);
byte[] data = null;
serializer.TraiteByteArray(ref data);
CDonneeBinaireInRow donneeBinaire = new CDonneeBinaireInRow(objetDest.ContexteDonnee.IdSession,
objetDest.Row.Row, colDest.ColumnName);
if (data.Length == 0)
{
donneeBinaire.Donnees = null;
}
else
{
donneeBinaire.Donnees = data;
}
}
}
}
}
//Mappe les fils
foreach (DataRelation relation in rowSource.Table.ChildRelations)
{
DataRow[] rowsFilles = rowSource.GetChildRows(relation);
CObjetDonneeAIdNumeriqueAuto[] objetsFilles = new CObjetDonneeAIdNumeriqueAuto[rowsFilles.Length];
int nIndex = 0;
CListeObjetsDonnees listeFilles = objetDest.GetDependancesListe(relation.ChildTable.TableName, relation.ChildColumns[0].ColumnName);
if (listeFilles.Count != 0)
{
string strExclus = "";
foreach (DataRow rowFille in rowsFilles)
{
CObjetDonneeAIdNumeriqueAuto objetFils = null;
result = interfaceMapping.MapObjet(rowFille, listeFilles, ref objetFils);
if (!result)
{
return(result);
}
objetsFilles[nIndex] = objetFils;
if (objetFils != null)
{
if (strExclus.Length != 0)
{
strExclus += ",";
}
strExclus += objetFils.Id.ToString();
listeFilles.Filtre = new CFiltreData(objetFils.GetChampId() + " not in (" + strExclus + ")");
}
nIndex++;
}
}
nIndex = 0;
foreach (DataRow rowFille in rowSource.GetChildRows(relation))
{
CObjetDonneeAIdNumeriqueAuto objetFille = objetsFilles[nIndex];
if (objetFille == null)
{
objetFille = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(
CContexteDonnee.GetTypeForTable(relation.ChildTable.TableName),
new object[] { objetDest.ContexteDonnee });
objetFille.CreateNewInCurrentContexte();
}
result = ImporteObjet(rowFille, objetFille, interfaceMapping);
if (!result)
{
return(result);
}
rowFille[c_colIsMappe] = true;
nIndex++;
}
}
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);
}
