//----------------------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (!(obj is C2iStructureExport))
{
return(false);
}
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (Serialize(ser))
{
string strThis = ser.String;
ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (((C2iStructureExport)obj).Serialize(ser))
{
if (strThis.Equals(ser.String))
{
return(true);
}
}
}
return(false);
}
//-------------------------------------------------------------------
public CResultAErreur InitFromContexte(CContexteFormNavigable ctx)
{
CResultAErreur result = CResultAErreur.True;
m_contexte = ctx;
/*m_listeObjets = (CListeObjetsDonnees)CStockeurObjetPersistant.AlloueFromPersistantData(
* (byte[])ctx["ListeObjets"], CSc2iWin32DataClient.ContexteCourant );*/
CStringSerializer serializer = new CStringSerializer((string)ctx["ListeObjets"], ModeSerialisation.Lecture);
I2iSerializable obj = null;
if (serializer.TraiteObject(ref obj, CSc2iWin32DataClient.ContexteCourant))
{
m_listeObjets = (CListeObjetsDonnees)obj;
}
else
{
m_listeObjets = null;
}
if (AfterInitFromContexte != null)
{
AfterInitFromContexte(this, ctx);
}
return(result);
}
//-------------------------------------------------------------------
public virtual CResultAErreur InitFromContexte(CContexteFormNavigable ctx)
{
CResultAErreur result = CResultAErreur.True;
m_contexte = ctx;
if (ctx["CONTEXTE_UTILISATION"] != null)
{
ContexteUtilisation = ctx["CONTEXTE_UTILISATION"].ToString();
}
/*m_listeObjets = (CListeObjetsDonnees)CStockeurObjetPersistant.AlloueFromPersistantData(
* (byte[])ctx["ListeObjets"], CSc2iWin32DataClient.ContexteCourant );*/
CStringSerializer serializer = new CStringSerializer((string)ctx["ListeObjets"], ModeSerialisation.Lecture);
I2iSerializable obj = null;
result = serializer.TraiteObject(ref obj, CSc2iWin32DataClient.ContexteCourant);
if (!result)
{
System.Console.WriteLine(I.T("Erreur de chargement de la liste|30005") + result.Erreur.ToString());
m_listeObjets = null;
}
else
{
m_listeObjets = (CListeObjetsDonnees)obj;
}
m_filtreDeBaseAvantClasseDerivee = ctx["FILTRE_DE_BASE"] as CFiltreData;
m_bFiltreDeBaseStock = true;
m_panelListe.InitFromContexte(ctx);
if (AfterInitFromContexte != null)
{
AfterInitFromContexte(this, ctx);
}
return(result);
}
public static CParametreTriGantt GetParametreTriGantt(IElementDeGantt eltGantt)
{
if (eltGantt == null)
{
return(null);
}
string strCle = "Gantt sort";
strCle += "-" + eltGantt.GanttBarId;
string strSer = new CTimosAppRegistre().GetValue("preferences\\Gantt", strCle, "");
if (strSer != "")
{
CStringSerializer serializer = new CStringSerializer(strSer, ModeSerialisation.Lecture);
CParametreTriGantt tri = null;
try
{
if (serializer.TraiteObject <CParametreTriGantt>(ref tri))
{
return(tri);
}
}
catch { }
}
return(null);
}
public CContexteFormNavigable GetContexte()
{
CContexteFormNavigable contexte = new CContexteFormNavigable(GetType());
if (contexte == null)
{
return(null);
}
if (m_objetsAccedes != null)
{
ArrayList lst = new ArrayList( );
foreach (CObjetDonneeAIdNumerique objet in m_objetsAccedes)
{
lst.Add(new CReferenceObjetDonnee(objet));
}
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
serializer.TraiteArrayListOf2iSerializable(lst);
contexte["OBJETS"] = serializer.String;
}
contexte["DATE"] = m_controlAgenda.DateEnCours;
if (AfterGetContexte != null)
{
AfterGetContexte(this, contexte);
}
return(contexte);
}
public CResultAErreur InitFromContexte(CContexteFormNavigable contexte)
{
CResultAErreur result = CResultAErreur.True;
if (!result)
{
return(result);
}
if (contexte["OBJETS"] != null)
{
ArrayList lst = new ArrayList();
CStringSerializer serializer = new CStringSerializer((string)contexte["OBJETS"], ModeSerialisation.Lecture);
ArrayList lstObjets = new ArrayList();
if (serializer.TraiteArrayListOf2iSerializable(lst))
{
foreach (CReferenceObjetDonnee reference in lst)
{
lstObjets.Add(reference.GetObjet(CSc2iWin32DataClient.ContexteCourant));
}
m_objetsAccedes = (CObjetDonneeAIdNumerique[])lstObjets.ToArray(typeof(CObjetDonneeAIdNumerique));
}
}
m_controlAgenda.DateEnCours = (DateTime)contexte["DATE"];
if (AfterInitFromContexte != null)
{
AfterInitFromContexte(this, contexte);
}
return(result);
}
//-----------------------------------------------------------------
public static CDefinitionProprieteDynamique GetDefinitionProprieteDynamique(string strPropriete, ref string strSuite)
{
I2iSerializable objDef = null;
if (strPropriete.Length > 2 &&
strPropriete.Substring(0, 2) == "~#")
{
string strStart = strPropriete.Substring(2);
strSuite = "";
int nPos = strStart.IndexOf("~@#@");
if (nPos >= 0)
{
strSuite = strStart.Substring(nPos + 4);
if (strSuite.Length > 1 && strSuite.Substring(0, 1) == ".")
{
strSuite = strSuite.Substring(1);
}
strStart = strStart.Substring(0, nPos);
}
CStringSerializer serializer = new CStringSerializer(strPropriete.Substring(2), ModeSerialisation.Lecture);
objDef = (I2iSerializable)m_tableSerializeToDefinition[strPropriete];
if (objDef == null)
{
if (!serializer.TraiteObject(ref objDef))
{
objDef = null;
}
else
{
m_tableSerializeToDefinition[strPropriete] = objDef;
}
}
}
else
{
//Il s'agit d'un nom de champ
string[] strDatas = strPropriete.Split('.');
string strProp = "";
foreach (string strData in strDatas)
{
strProp += CDefinitionProprieteDynamique.c_strCaractereStartCleType +
CDefinitionProprieteDynamiqueDotNet.c_strCleTypeDefinition +
CDefinitionProprieteDynamique.c_strCaractereEndCleType +
strData + ".";
}
if (strProp.Length > 1)
{
strProp = strProp.Substring(0, strProp.Length - 1);
}
CDefinitionProprieteDynamiqueDotNet prop = new CDefinitionProprieteDynamiqueDotNet(strPropriete,
strProp, new CTypeResultatExpression(typeof(string), false), false, false, "");
strSuite = "";
return(prop);
}
return(objDef as CDefinitionProprieteDynamique);
}
public void SaveMemoUser(ref System.Collections.Generic.List <CMemoObjets.CReferenceObjetDonneeAvecLibelle> lst)
{
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (ser.TraiteListe <CMemoObjets.CReferenceObjetDonneeAvecLibelle>(lst))
{
SetValue("Preferences", "UserMemo", ser.String);
}
}
public static void SaveParametreNotifications(CParametresNotification parametre)
{
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (parametre.Serialize(ser))
{
new CTimosAppRegistre().SetValue("Preferences", "Notifications setup", ser.String);
}
}
private void Save()
{
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (ser.TraiteListe <CReferenceObjetDonneeAvecLibelle>(m_listeObjets))
{
C2iRegistre.SetValueInRegistreApplication("Preferences", "UserMemo", ser.String);
}
}
public static void SaveParametreVisuModulesParametrage(CParametreVisuModuleParametrage parametre)
{
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (parametre.Serialize(ser))
{
new CTimosAppRegistre().SetValue("Preferences", "module view", ser.String);
}
}
//----------------------------------------------------------------------------------
public override int GetHashCode()
{
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
if (Serialize(ser))
{
return(ser.String.GetHashCode());
}
return(m_table.GetHashCode());
}
public static void FillParametreNotifications(CParametresNotification parametre)
{
string strVal = new CTimosAppRegistre().GetValue("Preferences", "Notifications setup", "");
if (strVal == "")
{
return;
}
CStringSerializer ser = new CStringSerializer(strVal, ModeSerialisation.Lecture);
parametre.Serialize(ser);
}
/// ///////////////////////////////////////////////////////
private void SaveIntoRegistre()
{
if (m_postIt == null || m_postIt.IsNew())
{
return;
}
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
if (Serialize(serializer))
{
new CTimosAppRegistre().SetDataPostit(m_postIt.Id, serializer.String);
}
}
///////////////////////////////////////////////////
public static string GetPseudoCode(C2iExpression exp)
{
if (exp == null)
{
return("");
}
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
exp.GetPseudoCode(ser);
string strRetour = new CStringSerializerCompresseur().Compress(ser.String);
return(strRetour);
}
public bool ReadMemoUser(ref System.Collections.Generic.List <global::timos.Controles.MemoObjets.CMemoObjets.CReferenceObjetDonneeAvecLibelle> lst)
{
lst = new System.Collections.Generic.List <CMemoObjets.CReferenceObjetDonneeAvecLibelle>();
string strValue = GetValue("Preferences", "UserMemo", "");
if (strValue.Trim() == "")
{
return(false);
}
CStringSerializer ser = new CStringSerializer(strValue, ModeSerialisation.Lecture);
return(ser.TraiteListe <CMemoObjets.CReferenceObjetDonneeAvecLibelle>(lst));
}
/// <summary>
/// Surchages de CInfoStructureDynamique
/// </summary>
/// <param name="tp"></param>
/// <param name="nDepth"></param>
/// <returns></returns>
//-----------------------------------------------------------------
public static CInfoStructureDynamique GetStructure(Type tp, int nDepth)
{
if (nDepth < 0)
{
return(null);
}
CFournisseurPropDynStd fournisseur = new CFournisseurPropDynStd(false);
ArrayList lst = new ArrayList();
foreach (CDefinitionProprieteDynamique def in fournisseur.GetDefinitionsChamps(tp, 0, null))
{
if (!def.TypeDonnee.IsArrayOfTypeNatif)
{
CInfoChampDynamique info = null;
CInfoStructureDynamique infoFils = GetStructure(def.TypeDonnee.TypeDotNetNatif, nDepth - 1);
if (infoFils != null && infoFils.Champs.Count == 0)
{
infoFils = null;
}
//Champs simples, interpretés par CInterpreteurTextePropriete
if (def.GetType() == typeof(CDefinitionProprieteDynamique))
{
info = new CInfoChampDynamique(
def.Nom,
def.TypeDonnee.TypeDotNetNatif,
def.NomPropriete,
def.Rubrique,
infoFils);
}
else
{
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
I2iSerializable obj = (I2iSerializable)def;
serializer.TraiteObject(ref obj);
info = new CInfoChampDynamique(
def.Nom,
def.TypeDonnee.TypeDotNetNatif,
"~#" + serializer.String + "~@#@",
def.Rubrique,
infoFils);
}
lst.Add(info);
}
}
CInfoStructureDynamique infoStructure = new CInfoStructureDynamique();
infoStructure.NomConvivial = DynamicClassAttribute.GetNomConvivial(tp);
infoStructure.Champs = lst;
return(infoStructure);
}
public void Read()
{
string strValue = C2iRegistre.GetValueInRegistreApplication("Preferences", "UserMemo", "");
if (strValue.Trim() != "")
{
List <CReferenceObjetDonneeAvecLibelle> lst = new List <CReferenceObjetDonneeAvecLibelle>();
CStringSerializer ser = new CStringSerializer(strValue, ModeSerialisation.Lecture);
if (ser.TraiteListe <CReferenceObjetDonneeAvecLibelle>(lst))
{
m_listeObjets = lst;
}
}
}
//------------------------------------------------
private void SaveStateInRegistre()
{
if (m_strPreserveStateKey != null && m_strPreserveStateKey.Length > 0)
{
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
CResultAErreur result = SerializeState(serializer);
string strVal = serializer.String;
if (!result)
{
strVal = "";
}
C2iRegistre.SetValueInRegistreApplication(c_strCleRegistre, m_strPreserveStateKey, strVal);
}
}
public static CResultAErreur SauvegarderDansRegistre(CContexteSauvegardeProfilDesigner ctx)
{
CResultAErreur result = CResultAErreur.True;
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
CProfilEditeurObjetGraphique prof = ctx.Profil;
result = prof.Serialize(serializer);
if (result)
{
new CTimosAppRegistre().SetDataProfilDesigner(ctx.Cle, serializer.String);
}
return(result);
}
//-------------------------------------------------------------------
public CContexteFormNavigable GetContexte()
{
CContexteFormNavigable ctx = new CContexteFormNavigable(GetType());
//ctx["ListeObjets"] = CStockeurObjetPersistant.GetPersistantData(m_listeObjets);
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
I2iSerializable obj = m_listeObjets;
serializer.TraiteObject(ref obj);
ctx["ListeObjets"] = serializer.String;
if (AfterGetContexte != null)
{
AfterGetContexte(this, ctx);
}
return(ctx);
}
/// //////////////////////////////////////////////////////////
public CResultAErreur ExportData(string strChaineSerializationListeObjetDonnee, C2iStructureExport structure, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesDynamiquesPourFiltre, IIndicateurProgression indicateur)
{
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;
//Déserialise la liste d'objets
CStringSerializer serializer = new CStringSerializer(strChaineSerializationListeObjetDonnee, ModeSerialisation.Lecture);
C2iSponsor sponsor = new C2iSponsor();
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
try
{
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
I2iSerializable objet = null;
contexte.GestionParTablesCompletes = true;
result = serializer.TraiteObject(ref objet, contexte);
if (!result)
{
return(result);
}
if (objet == null || !(objet is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Error during the deserialization of source list|101"));
return(result);
}
CListeObjetsDonnees listeSource = (CListeObjetsDonnees)objet;
listeSource.RemplissageProgressif = false;
structure.TraiterSurServeur = false;
DataSet ds = new DataSet();
result = structure.Export(IdSession, listeSource, ref ds, elementAVariablesDynamiquesPourFiltre, indicateur);
if (result)
{
result.Data = ds;
}
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
sponsor.Unregister(indicateur);
}
return(result);
}
public static CParametreVisuModuleParametrage GetParametreVisuModulesParametrage()
{
string strVal = new CTimosAppRegistre().GetValue("Preferences", "module view", "");
if (strVal == "")
{
return(null);
}
CParametreVisuModuleParametrage parametre = new CParametreVisuModuleParametrage();
CStringSerializer ser = new CStringSerializer(strVal, ModeSerialisation.Lecture);
if (parametre.Serialize(ser))
{
return(parametre);
}
return(null);
}
/// ///////////////////////////////////////////////////////
private void ReadFromRegistre()
{
if (m_postIt == null || m_postIt.IsNew())
{
return;
}
string strData = new CTimosAppRegistre().GetDataPostit(m_postIt.Id);
try
{
CStringSerializer serializer = new CStringSerializer(strData, ModeSerialisation.Lecture);
Serialize(serializer);
}
catch
{
}
}
//-------------------------------------------------------------------
public virtual CContexteFormNavigable GetContexte()
{
CContexteFormNavigable ctx = new CContexteFormNavigable(GetType());
//ctx["ListeObjets"] = CStockeurObjetPersistant.GetPersistantData(m_listeObjets);
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
I2iSerializable obj = m_listeObjets;
serializer.TraiteObject(ref obj);
ctx["ListeObjets"] = serializer.String;
ctx["CONTEXTE_UTILISATION"] = ContexteUtilisation;
m_panelListe.FillContexte(ctx);
ctx["FILTRE_DE_BASE"] = m_filtreDeBaseAvantClasseDerivee;
if (AfterGetContexte != null)
{
AfterGetContexte(this, ctx);
}
return(ctx);
}
//----------------------------------------------------------------------------------
public CResultAErreur Export(int nIdSession,
IEnumerable list,
ref DataSet ds,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltre,
IIndicateurProgression indicateur)
{
if (list is CListeObjetsDonnees && m_bTraitementSurServeur)
{
CResultAErreur result = CResultAErreur.True;
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
I2iSerializable listeToSerialize = (I2iSerializable)list;
result = serializer.TraiteObject(ref listeToSerialize);
if (!result)
{
return(result);
}
I2iExporteurSurServeur exporteur = ( I2iExporteurSurServeur )C2iFactory.GetNewObjetForSession("C2iExporteurSurServeur", typeof(I2iExporteurSurServeur), nIdSession);
try
{
result = exporteur.ExportData(serializer.String, this, elementAVariablesPourFiltre, indicateur);
if (result)
{
ds = (DataSet)result.Data;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during the export on the server|101"));
}
return(result);
}
if (IsStructureComplexe)
{
return(ExportComplexe(nIdSession, list, ref ds, elementAVariablesPourFiltre, indicateur));
}
else
{
return(ExportSimple(nIdSession, list, ref ds, indicateur));
}
}
public static CResultAErreur InitialiserProfil(CContexteSauvegardeProfilDesigner ctx)
{
CResultAErreur result = CResultAErreur.True;
string strData = new CTimosAppRegistre().GetDataProfilDesigner(ctx.Cle);
if (strData != "")
{
try
{
CProfilEditeurObjetGraphique prof = ctx.Profil;
CStringSerializer serializer = new CStringSerializer(strData, ModeSerialisation.Lecture);
result = prof.Serialize(serializer);
ctx.Designer.Profil = prof;
}
catch
{
}
}
return(result);
}
public static void SetParametreTriGantt(IElementDeGantt eltGantt, CParametreTriGantt parametre)
{
if (eltGantt == null)
{
return;
}
string strCle = "Gantt sort";
strCle += "-" + eltGantt.GanttBarId;
string strSer = "";
if (parametre != null)
{
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
if (serializer.TraiteObject <CParametreTriGantt>(ref parametre))
{
strSer = serializer.String;
}
}
new CTimosAppRegistre().SetValue("preferences\\Gantt", strCle, strSer);
}
/// ///////////////////////////////////////////////////////////////
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);
}
