예제 #1
0
        //---------------------------------------------
        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);
        }
예제 #2
0
        //---------------------------------------------------
        public override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = serializer.TraiteObject <CParametreDeclencheurEvenement>(ref m_parametreDeclencheur);
            if (result)
            {
                result = serializer.TraiteObject <C2iExpression>(ref m_formuleElementDeclencheur);
            }
            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);
        }
예제 #4
0
        //---------------------------------------------------
        public override 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 < 3)
            {
                // TESTDBKEYTODO
                serializer.ReadDbKeyFromOldId(ref m_dbKeyTypeProjet, typeof(CTypeProjet));
            }
            else
            {
                serializer.TraiteDbKey(ref m_dbKeyTypeProjet);
            }

            int nId = m_nIdChampProjet == null ? -1 : m_nIdChampProjet.Value;

            serializer.TraiteInt(ref nId);
            if (serializer.Mode == ModeSerialisation.Lecture)
            {
                m_nIdChampProjet = nId >= 0 ? (int?)nId : null;
            }

            result = serializer.TraiteListe <CAffectationsProprietes>(m_listeAffectations);
            if (!result)
            {
                return(result);
            }

            if (nVersion >= 1)
            {
                result = serializer.TraiteObject <C2iExpression>(ref m_formuleGanttId);
            }
            if (!result)
            {
                return(result);
            }
            if (nVersion >= 2)
            {
                serializer.TraiteBool(ref m_bGererIterations);
            }

            return(result);
        }
예제 #5
0
        //------------------------------------------------------
        protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = serializer.TraiteObject <CChartSetup>(ref m_parametreChart);
            if (!result)
            {
                return(result);
            }
            return(result);
        }
예제 #6
0
        //-------------------------------------------
        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);
            }
            result = serializer.TraiteObject <CFiltreDynamique>(ref m_filtreDynamique);
            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);
            }
            serializer.TraiteString(ref m_strIdSource);
            result = serializer.TraiteObject <C2iExpression>(ref m_formule);
            if (!result)
            {
                return(result);
            }
            serializer.TraiteBool(ref m_bEvaluateOnEachSourceElement);
            return(result);
        }
예제 #9
0
        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);
            }
            result = serializer.TraiteObject <C2iExpression>(ref m_formuleObjets);
            if (!result)
            {
                return(result);
            }
            return(result);
        }
예제 #10
0
        //---------------------------------------------------------------
        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);
        }
예제 #11
0
        //---------------------------------------------------
        public override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }

            if (nVersion < 2)
            {
                // TESTDBKEYOK
                serializer.ReadDbKeyFromOldId(ref m_dbKeyTypeWorkflow, typeof(CTypeWorkflow));
                // TESTDBKEYOK
                serializer.ReadDbKeyFromOldId(ref m_dbKeyTypeEtapeDemarrage, typeof(CTypeEtapeWorkflow));
            }
            else
            {
                serializer.TraiteDbKey(ref m_dbKeyTypeWorkflow);
                serializer.TraiteDbKey(ref m_dbKeyTypeEtapeDemarrage);
            }

            if (nVersion >= 1)
            {
                result = serializer.TraiteObject <C2iExpression>(ref m_formuleInitialisationWorkflow);
                if (!result)
                {
                    return(result);
                }
            }
            else if (serializer.Mode == ModeSerialisation.Lecture)
            {
                m_formuleInitialisationWorkflow = null;
            }

            return(result);
        }
예제 #12
0
        //---------------------------------------------------
        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);
        }
예제 #13
0
        /// ////////////////////////////////////////////////////////
        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);
        }
예제 #14
0
        /// /////////////////////////////////////////////////////////
        public CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            int nNb = m_tableRestrictions.Count;

            serializer.TraiteInt(ref nNb);
            switch (serializer.Mode)
            {
            case ModeSerialisation.Ecriture:
                foreach (Type tp in m_tableRestrictions.Keys)
                {
                    Type            tpTemp      = tp;
                    I2iSerializable restriction = (I2iSerializable)m_tableRestrictions[tp];
                    serializer.TraiteType(ref tpTemp);
                    result = serializer.TraiteObject(ref restriction);
                    if (!result)
                    {
                        return(result);
                    }
                }
                break;

            case ModeSerialisation.Lecture:
                m_tableRestrictions.Clear();
                for (int nType = 0; nType < nNb; nType++)
                {
                    Type            tp   = null;
                    I2iSerializable rest = null;
                    serializer.TraiteType(ref tp);
                    result = serializer.TraiteObject(ref rest, tp);
                    if (!result)
                    {
                        return(result);
                    }
                    if (tp != null)
                    {
                        m_tableRestrictions[tp] = rest;
                    }
                }
                break;
            }
            if (nVersion >= 1)
            {
                serializer.TraiteBool(ref m_bIsAdministrateur);
            }
            if (nVersion >= 2)
            {
                bool bHasAnnulation = SeuilAnnulationPriorites != null;
                serializer.TraiteBool(ref bHasAnnulation);
                if (bHasAnnulation)
                {
                    int nTmp = SeuilAnnulationPriorites == null ? 0 : (int)m_nSeuilAnnulationPriorites;
                    serializer.TraiteInt(ref nTmp);
                    SeuilAnnulationPriorites = nTmp;
                }
            }
            return(result);
        }