//------------------------------------------------
public virtual CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strImageKey);
result = serializer.TraiteListe <IColumnDefinition>(m_listeColonnes);
if (!result)
{
return(result);
}
foreach (IColumnDefinition col in m_listeColonnes)
{
col.Table = this;
}
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strSourceId);
}
return(result);
}
//-------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNomChamp);
serializer.TraiteString(ref m_strNomColonne);
serializer.TraiteType(ref m_typeDonnee);
return(result);
}
//-------------------------------------------------
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strIdUniverselLien);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_lien = null;
m_strIdUniverselDest = "";
m_strIdUniverselSource = "";
}
int nCol = m_couleurLien.ToArgb();
serializer.TraiteInt(ref nCol);
m_couleurLien = Color.FromArgb(nCol);
serializer.TraiteInt(ref m_nEpaisseurLien);
if (nVersion >= 1)
{
int nModeSortie = (int)m_modeSortie;
serializer.TraiteInt(ref nModeSortie);
m_modeSortie = (EModeSortieLien)nModeSortie;
}
return(result);
}
//------------------------------------------------------
protected override sc2i.common.CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strIdUniverselEtape);
if (serializer.Mode == ModeSerialisation.Lecture && m_strIdUniverselEtape.Length > 0)
{
serializer.TrackDbKeyReaded(m_strIdUniverselEtape);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_typeEtape = null;
}
int nCol = m_backColor.ToArgb();
serializer.TraiteInt(ref nCol);
m_backColor = Color.FromArgb(nCol);
nCol = m_foreColor.ToArgb();
serializer.TraiteInt(ref nCol);
m_foreColor = Color.FromArgb(nCol);
return(result);
}
/// ///////////////////////////////////////////////
protected override sc2i.common.CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 1 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableForResult = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableForResult);
}
return(result);
}
//----------------------------------------------
public override sc2i.common.CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strSharepointId);
serializer.TraiteString(ref m_strDescription);
return(result);
}
//-------------------------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strIdSource);
serializer.TraiteString(ref m_strTableName);
serializer.TraiteString(ref m_strColumnName);
if (nVersion >= 1)
{
serializer.TraiteObject <C2iExpression>(ref m_formule);
}
return(result);
}
//------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteObject <CEasyQuery>(ref m_query);
if (result)
{
result = serializer.TraiteObject <CListeQuerySource>(ref m_listeSources);
}
if (!result)
{
return(result);
}
int nNbTables = m_listeTablesARetourner.Count;
serializer.TraiteInt(ref nNbTables);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strTable in m_listeTablesARetourner)
{
string strTmp = strTable;
serializer.TraiteString(ref strTmp);
}
break;
case ModeSerialisation.Lecture:
m_listeTablesARetourner.Clear();
for (int n = 0; n < nNbTables; n++)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
m_listeTablesARetourner.Add(strTmp);
}
break;
}
return(result);
}
//---------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strLibelle);
result = serializer.TraiteObject <CEasyQuery>(ref m_query);
if (result)
{
result = serializer.TraiteObject <CListeQuerySource>(ref m_listeSources);
}
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNomTableSource);
serializer.TraiteString(ref m_strChampCleElement);
serializer.TraiteString(ref m_strChampLatitude);
serializer.TraiteString(ref m_strChampLongitude);
serializer.TraiteString(ref m_strChampLibelle);
serializer.TraiteDouble(ref m_fMetresEntrePoints);
return(result);
}
/// //////////////////////////////////////////
private void SerializeTable(C2iSerializer serializer, object[] tableau, bool bIsString)
{
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (object obj in tableau)
{
if (bIsString)
{
string strVal = obj.ToString();
serializer.TraiteString(ref strVal);
}
else
{
Double dVal = Convert.ToDouble(obj, CultureInfo.InvariantCulture);
serializer.TraiteDouble(ref dVal);
}
}
break;
case ModeSerialisation.Lecture:
for (int nTmp = 0; nTmp < tableau.Length; nTmp++)
{
if (bIsString)
{
string strVal = "";
serializer.TraiteString(ref strVal);
tableau[nTmp] = strVal;
}
else
{
double dVal = 0;
serializer.TraiteDouble(ref dVal);
tableau[nTmp] = dVal;
}
}
break;
}
}
//----------------------------------------------------
internal static void SerializeKey(C2iSerializer ser, ref CDbKey key)
{
switch (ser.Mode)
{
case ModeSerialisation.Lecture:
key = null;
string strTmp = "";
ser.TraiteString(ref strTmp);
if (strTmp.Length > 0)
{
key = CDbKey.CreateFromStringValue(strTmp);
}
break;
case ModeSerialisation.Ecriture:
string strTmpWrite = "";
if (key != null)
{
strTmpWrite = key.StringValue;
}
ser.TraiteString(ref strTmpWrite);
break;
}
}
public override CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
serializer.TraiteInt(ref m_nEspaceGraduations);
int nTmp = (int)m_orientation;
serializer.TraiteInt(ref nTmp);
m_orientation = (EGraduationOrientation)nTmp;
nTmp = (int)m_HorizontalAlignment;
serializer.TraiteInt(ref nTmp);
m_HorizontalAlignment = (E3DAlignement)nTmp;
nTmp = (int)m_VerticalAlignment;
serializer.TraiteInt(ref nTmp);
m_VerticalAlignment = (E3DAlignement)nTmp;
nTmp = (int)DepthAlignment;
serializer.TraiteInt(ref nTmp);
m_DepthAlignment = (E3DAlignement)nTmp;
nTmp = (int)m_faceAlignement;
serializer.TraiteInt(ref nTmp);
m_faceAlignement = (EFaceVueDynamique)nTmp;
if (nVersion > 0)
{
string strTmp = AssociatedCoordinatePrefixes;
serializer.TraiteString(ref strTmp);
AssociatedCoordinatePrefixes = strTmp;
}
return(result);
}
//---------------------------------------------------
public override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strCleStepToStop);
int nAction = (int)TypeAction;
serializer.TraiteInt(ref nAction);
TypeAction = (ETypeActionExterneOnWorkflowStep)nAction;
return(result);
}
//-------------------------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strIdSource);
result = serializer.TraiteObject <C2iExpression>(ref m_formule);
if (!result)
{
return(result);
}
serializer.TraiteBool(ref m_bEvaluateOnEachSourceElement);
return(result);
}
//---------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
//TESTDBKEYTODO : remplace m_nIDChampCustom par
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref m_dbKeyChampCustom, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref m_dbKeyChampCustom);
}
serializer.TraiteString(ref m_strNomColonne);
serializer.TraiteType(ref m_typeDonnee);
return(result);
}
//---------------------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteDoubleNullable(ref m_fCoutSaisi);
serializer.TraiteIntNullable(ref m_nIdTypeProjet);
serializer.TraiteDouble(ref m_fDureeJours);
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strCleProjetTemplate);
}
if (nVersion >= 2)
{
serializer.TraiteObject <C2iExpression>(ref m_formuleInitialisation);
}
return(result);
}
//---------------------------------------------------
public override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (nVersion < 3)
{
// TESTDBKEYOK
serializer.ReadDbKeyFromOldId(ref m_dbKeyProcess, typeof(CProcessInDb));
}
else
{
serializer.TraiteDbKey(ref m_dbKeyProcess);
}
serializer.TraiteBool(ref m_bDemarrageManuel);
serializer.TraiteString(ref m_strInstructions);
if (nVersion >= 1)
{
result = serializer.TraiteObject <CProcess>(ref m_process);
if (!result)
{
return(result);
}
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bUtiliserSortieDeProcessCommeCodeRetour);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture &&
serializer.GetObjetAttache(typeof(CContexteDonnee)) != null)
{
ContexteDonnee = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
}
else
{
ContexteDonnee = CContexteDonneeSysteme.GetInstance();
}
serializer.TraiteInt(ref m_nIdNextObjet);
if (nVersion > 0)
{
bool bHasType = TypeCible != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_typeCible);
}
else
{
m_typeCible = null;
}
}
else
{
m_typeCible = null;
}
//Lit les variables en premier car on en a besoin dans les actions
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables, this);
}
foreach (IVariableDynamique variable in m_listeVariables)
{
if (variable.IdVariable == c_strIdVariableElement) //TESTDBKEYOK
{
m_variableCible = (CVariableProcessTypeComplexe)variable;
}
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
foreach (IVariableDynamique var in m_listeVariables)
{
if (var.IdVariable == c_strIdVariableElement && var is CVariableProcessTypeComplexe)
{
m_variableCible = (CVariableProcessTypeComplexe)var;
m_typeCible = m_variableCible.TypeDonnee.TypeDotNetNatif;
m_bSurTableauDeCible = m_variableCible.TypeDonnee.IsArrayOfTypeNatif;
}
}
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeActions, this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeLiensActions, this);
}
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
//Lit les valeurs des variables
if (nVersion > 2)
{
result = SerializeValeursVariables(nVersion, serializer);
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bModeAsynchrone);
}
else
{
m_bModeAsynchrone = false;
}
if (nVersion >= 4)
{
serializer.TraiteString(ref m_strLibelle);
}
AssureVariableCible();
if (nVersion >= 5)
{
I2iSerializable objet = m_infoDeclencheur;
serializer.TraiteObject(ref objet);
m_infoDeclencheur = (CInfoDeclencheurProcess)objet;
}
if (nVersion >= 7)
{
serializer.TraiteBool(ref m_bSurTableauDeCible);
}
else
{
m_bSurTableauDeCible = false;
}
if (nVersion >= 9)
{
serializer.TraiteString(ref m_strLastErreur);
}
else
{
m_strLastErreur = "";
}
if (nVersion >= 10)
{
if (nVersion < 14 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableRetour = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableRetour);
}
}
Dictionary <int, I2iObjetGraphique> dicIdToObjet = null;
if (nVersion >= 12)
{
int nbEle = m_ordreZ.Count;
serializer.TraiteInt(ref nbEle);
if (serializer.Mode == ModeSerialisation.Lecture)
{
dicIdToObjet = new Dictionary <int, I2iObjetGraphique>();
foreach (CAction action in ListeActions)
{
dicIdToObjet[action.IdObjetProcess] = action;
}
foreach (CLienAction lien in ListeLiens)
{
dicIdToObjet[lien.IdObjetProcess] = lien;
}
m_ordreZ.Clear();
for (int n = 0; n < nbEle; n++)
{
int nId = 0;
serializer.TraiteInt(ref nId);
I2iObjetGraphique objTmp = null;
if (dicIdToObjet.TryGetValue(nId, out objTmp))
{
m_ordreZ.Add((IObjetDeProcess)objTmp);
}
}
}
else if (serializer.Mode == ModeSerialisation.Ecriture)
{
foreach (IObjetDeProcess objet in m_ordreZ)
{
int nCopy = objet.IdObjetProcess;
serializer.TraiteInt(ref nCopy);
}
}
}
else
{
m_ordreZ = new List <IObjetDeProcess>();
foreach (CAction action in ListeActions)
{
m_ordreZ.Add(action);
}
foreach (CLienAction lien in ListeLiens)
{
m_ordreZ.Add(lien);
}
}
if (nVersion >= 13)
{
serializer.TraiteBool(ref m_bModeTransactionnel);
}
else
{
m_bModeTransactionnel = false;
}
return(result);
}
/// //////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nRestriction = (int)RestrictionGlobale;
serializer.TraiteInt(ref nRestriction);
RestrictionUtilisateur = (ERestriction)nRestriction;
serializer.TraiteType(ref m_type);
int nNb = m_tableRestrictions.Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strKey in m_tableRestrictions.Keys)
{
string strTmp = strKey;
nRestriction = (int)m_tableRestrictions[strKey];
serializer.TraiteString(ref strTmp);
serializer.TraiteInt(ref nRestriction);
}
break;
case ModeSerialisation.Lecture:
m_tableRestrictions.Clear();
for (int nKey = 0; nKey < nNb; nKey++)
{
string strKey = "";
int nRest = 0;
serializer.TraiteString(ref strKey);
if (nVersion < 3 && m_convertisseurCle != null)
{
strKey = m_convertisseurCle.GetCleRestrictionCompatible(strKey);
}
serializer.TraiteInt(ref nRest);
m_tableRestrictions[strKey] = (ERestriction)nRest;
}
break;
}
if (nVersion >= 1)
{
serializer.TraiteInt(ref m_nPriorite);
serializer.TraiteBool(ref m_bSurchageComplete);
}
if (nVersion >= 2)
{
int nNbExceptions = m_dicContextesExceptions.Count;
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
serializer.TraiteInt(ref nNbExceptions);
foreach (string strTmp in m_dicContextesExceptions.Keys)
{
string strText = strTmp;
serializer.TraiteString(ref strText);
}
break;
case ModeSerialisation.Lecture:
serializer.TraiteInt(ref nNbExceptions);
List <String> lst = new List <string>();
for (int nException = 0; nException < nNbExceptions; nException++)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
lst.Add(strTmp);
}
ContextesException = lst.ToArray();
break;
}
}
return(result);
}
