Example #1
0
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur MySerialize(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_strIdVariableAModifier = nIdTemp.ToString();
            }
            else
            {
                serializer.TraiteString(ref m_strIdVariableAModifier);
            }

            I2iSerializable objet = m_expressionValeur;

            result = serializer.TraiteObject(ref objet);
            if (!result)
            {
                return(result);
            }
            m_expressionValeur = (C2iExpression)objet;

            return(result);
        }
Example #2
0
        //-------------------------------------------------------------------
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CRelationTypeEquipement_TypeTableParametrable relation = (CRelationTypeEquipement_TypeTableParametrable)objet;

                if (relation.TypeEquipement == null)
                {
                    result.EmpileErreur(I.T("The Equipment type cannot be null|109"));
                }

                if (relation.TypeTableParametrable == null)
                {
                    result.EmpileErreur(I.T("Custom table type cannot be empty|379"));
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Example #3
0
        //-------------------------------------------------------
        private void VerifieCoordonnee()
        {
            CResultAErreur result = CResultAErreur.True;
            string         strNum = m_niveau.RelationSysCoor_FormatNum.IsolerReference(m_txtValeur.Text);

            if (m_txtValeur.Text != "")
            {
                result = m_niveau.RelationSysCoor_FormatNum.GetIndex(m_txtValeur.Text);
            }
            if (!result)
            {
                m_txtValeur.BackColor = Color.Red;
                m_tooltip.SetToolTip(m_txtValeur, result.Erreur.ToString());
            }
            else
            {
                m_txtValeur.BackColor = Color.White;
                SetAideTooltip();
            }
            if (OnChangeValue != null)
            {
                OnChangeValue(this, new EventArgs());
            }
        }
Example #4
0
        //------------------------------------------------------------
        public CResultAErreur GetValue(object objet, string strPropriete)
        {
            CResultAErreur result      = CResultAErreur.True;
            CObjetDonnee   objetDonnee = objet as CObjetDonnee;

            if (objetDonnee == null)
            {
                result.Data = null;
                return(result);
            }
            int nIdSmartField = -1;

            try
            {
                nIdSmartField = Int32.Parse(strPropriete);
            }
            catch
            {
                result.EmpileErreur(I.T("Bad SmartField field format (@1)|20059", strPropriete));
                return(result);
            }
            CContexteDonnee contexte   = objetDonnee.ContexteDonnee;
            CSmartField     smartField = new CSmartField(contexte);

            if (!smartField.ReadIfExists(nIdSmartField))
            {
                result.EmpileErreur(I.T("Smart field @1 doesn't exists|20060", strPropriete));
                return(result);
            }
            if (smartField.Definition != null)
            {
                return(CInterpreteurProprieteDynamique.GetValue(objet, smartField.Definition));
            }
            result.Data = null;
            return(result);
        }
Example #5
0
            public CResultAErreur Serialize(C2iSerializer serializer)
            {
                int            nVersion = GetNumVersion();
                CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

                if (!result)
                {
                    return(result);
                }
                result = serializer.TraiteObject <CReferenceObjetDonnee>(ref m_reference);
                if (!result)
                {
                    return(result);
                }
                string strLibelle = "";

                if (serializer.Mode == ModeSerialisation.Ecriture && m_strLibelle == null)
                {
                    //S'assure que le libellé est bien chargé
                    strLibelle = Libelle;
                }
                serializer.TraiteString(ref m_strLibelle);
                return(result);
            }
Example #6
0
        //-------------------------------------------------------------------
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CRelationUtilisateur_Profil_EO rel = (CRelationUtilisateur_Profil_EO)objet;


                if (rel.UtilisateurProfil == null)
                {
                    result.EmpileErreur(I.T("The relation to User/Profile cannot be null|300"));
                }
                if (rel.EntiteOrganisationnelle == null)
                {
                    result.EmpileErreur(I.T("The profile of the Organisational Entity cannot be null|301"));
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
        public CNiveauCoordonnee[] DecodeCoordonnee(string strCoordonnee)
        {
            List <CNiveauCoordonnee> lst = new List <CNiveauCoordonnee>();

            if (strCoordonnee == null || strCoordonnee == "")
            {
                return(null);
            }
            string[] strNiveaux = strCoordonnee.Split(CSystemeCoordonnees.c_separateurNumerotations);

            if (strNiveaux.Length > RelationParametragesNiveau.Count())
            {
                return(null);
            }

            CParametrageNiveau[] parametragesNiveaux = ParametragesNiveauxOrdonnees;

            //On va remonter niveau par niveau
            int nI = 0;

            foreach (CParametrageNiveau parametrageNiv in ParametragesNiveauxOrdonnees)
            {
                string strNiv = strNiveaux[nI];

                //Vérification syntaxique de la partie de coordonnée
                string         strPrefixe = parametrageNiv.RelationSysCoor_FormatNum.IsolerPrefixe(strNiv);
                CResultAErreur result     = parametrageNiv.RelationSysCoor_FormatNum.GetIndex(strNiv);
                if (!result)
                {
                    return(null);
                }
                int nIndex = (int)result.Data;
                lst.Add(new CNiveauCoordonnee(strNiv, strPrefixe, nIndex));
            }
            return(lst.ToArray());
        }
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
        {
            CResultAErreur result = CResultAErreur.True;

            //Calcule le fichier ou l'url
            CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);

            contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
            result = FormuleLibelle.Eval(contexteEval);
            if (!result)
            {
                result.EmpileErreur(I.T("Error during the Label evaluation|20002"));
                return(result);
            }
            CVersionDonnees version = new CVersionDonnees(contexte.ContexteDonnee);

            version.CreateNew();
            version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Etiquette;
            version.Libelle         = (string)result.Data;
            version.Date            = DateTime.Now;
            result = version.CommitEdit();
            if (!result)
            {
                return(result);
            }
            foreach (CLienAction lien in GetLiensSortantHorsErreur())
            {
                if (!(lien is CLienUtilisateurAbsent))
                {
                    result.Data = lien;
                    return(result);
                }
            }
            result.Data = null;
            return(result);
        }
        public override sc2i.common.CResultAErreur MyMajChamps()
        {
            CResultAErreur result = base.MyMajChamps();

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

            if (Equipement != null && m_spvEquip == null && m_extModeEdition.ModeEdition)
            {
                m_spvEquip = CSpvEquip.GetSpvEquipFromEquipementAvecCreation(Equipement);
            }

            m_spvEquip.AdresseIP      = m_txtBoxIPAddress.Text;
            m_spvEquip.IndexSnmp      = m_txtBoxSnmpIndex.Text;
            m_spvEquip.CommunauteSnmp = m_txtBoxSnmpCommunity.Text;
            m_spvEquip.ReferenceSnmpTypeEquipement = m_txtBoxEquiptTypeSnmpReference.Text;
            m_spvEquip.EquipementDeMediation       = m_txtBoxMediationEquipment.Text;
            m_spvEquip.ARedecouvrirPeriodiquement  = m_chkToRediscover.Checked;
            m_spvEquip.ASuperviser = m_chkToSurv.Checked;

            return(result);
        }
Example #10
0
        //-------------------------------------------------------------------
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CCalendrier calendrier = (CCalendrier)objet;

                if (calendrier.Libelle == "")
                {
                    result.EmpileErreur(I.T("The label cannot be empty|126"));
                }

                if (calendrier.HoraireParDefaut == null)
                {
                    result.EmpileErreur(I.T("The default daily schedule must be defined|169"));
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Example #11
0
        //-------------------------------------------------------------------
        public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
        {
            CResultAErreur result = base.TraitementAvantSauvegarde(contexte);

            if (!result)
            {
                return(result);
            }
            DataTable table = contexte.Tables[GetNomTable()];

            if (table == null)
            {
                return(result);
            }
            ArrayList lst = new ArrayList(table.Rows);

            foreach (DataRow row in table.Rows)
            {
                if (row.RowState == DataRowState.Modified)
                {
                }
            }
            return(result);
        }
Example #12
0
        //-------------------------------------------------------
        public CResultAErreur MajChamps()
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_generator != null)
            {
                if (CurrentItemIndex != null)
                {
                    ItemControl.MajChamps();
                }
                List <CMapLineDessin> lst = new List <CMapLineDessin>();
                foreach (CCustomizableListItem item in Items)
                {
                    CMapLineDessin dessin = item.Tag as CMapLineDessin;
                    if (dessin != null)
                    {
                        dessin.Index = item.Index;
                        lst.Add(dessin);
                    }
                }
                m_generator.LinesDessin = lst.ToArray();
            }
            return(result);
        }
Example #13
0
        private void m_btnOk_Click(object sender, EventArgs e)
        {
            //Vérifie l'équipement
            CResultAErreur result = CResultAErreur.True;

            result  = m_selectTypeEquipement.MajChamps();
            result &= m_panelCoordonnee.MajChamps();

            if (m_releveEqpt.TypeEquipement == null)
            {
                result.EmpileErreur(I.T("Select equipment type|20030"));
            }
            if (result)
            {
                m_releveEqpt.NumeroSerie = m_txtSerial.Text;
            }
            if (result)
            {
                foreach (Control ctrl in m_panelChampsCustom.Controls)
                {
                    CControleForCustomFieldReleve c = ctrl as CControleForCustomFieldReleve;
                    if (c != null)
                    {
                        result = c.MajChamp();
                    }
                }
            }

            if (!result)
            {
                CFormAlerte.Afficher(result.Erreur);
                return;
            }
            DialogResult = DialogResult.OK;
            Close();
        }
        //-------------------------------------------------------------------
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CRelationTypeEO_FormulaireParType rel = (CRelationTypeEO_FormulaireParType)objet;


                if (rel.TypeEntiteOrganisationnelle == null)
                {
                    result.EmpileErreur(I.T("The Organisational Entity Type cannot be null|298"));
                }
                if (rel.Formulaire == null)
                {
                    result.EmpileErreur(I.T("The form cannot be null|299"));
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Example #15
0
        //------------------------------------------------------------------------
        public CResultAErreur MajChamps()
        {
            CResultAErreur result = CResultAErreur.True;
            CResultAErreurType <IPostFilter> resPost = new CResultAErreurType <IPostFilter>();

            if (m_editeurEnCours != null)
            {
                resPost = m_editeurEnCours.MajChamps();
                if (!resPost)
                {
                    result.EmpileErreur(resPost.Erreur);
                    return(result);
                }
                if (m_odeqTable != null)
                {
                    m_odeqTable.PostFilter = resPost.DataType;
                }
            }
            else
            {
                m_odeqTable.PostFilter = null;
            }
            return(result);
        }
        ///////////////////////////////////////////////////////////////
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                //TODO : Insérer la logique de vérification de donnée
                CSpvFamilleMibmodule familleSPV = (CSpvFamilleMibmodule)objet;

                // Vérifier que le libellé est renseigné
                if (familleSPV.ChampLibelle == "")
                {
                    result.EmpileErreur(I.T("The family label must be specified|50008"));
                }

                // Vérifier que la famille n'est pas son propre parent
                CSpvFamilleMibmodule familleMere = familleSPV.FamilleParente;
                while (familleMere != null)
                {
                    if (familleMere == familleSPV)
                    {
                        result.EmpileErreur(I.T("Error in the family hierarchy, the family is its own parent family|50009"));
                        return(result);
                    }
                    familleMere = familleMere.FamilleParente;
                }

                // Vérifier que la famille est unique dans la branche
                result = VerifieUnicite(familleSPV);
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
        /// //////////////////////////////////////////
        protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                bool bErreur = false;
                if (GetNbParametresNecessaires() >= 0 && Parametres.Count != GetNbParametresNecessaires())
                {
                    result.EmpileErreur(I.T("The expected number of parameters isn't correct (@1 expected)|172", GetNbParametresNecessaires().ToString()));
                    return(result);
                }
                try
                {
                    result  = Parametres2i[0].Eval(ctx);
                    bErreur = !result.Result;
                    if (result.Data is Double && Double.IsNaN((double)result.Data))
                    {
                        result = Parametres2i[1].Eval(ctx);
                    }
                }
                catch
                {
                    bErreur = true;
                }
                if (bErreur)
                {
                    result = Parametres2i[1].Eval(ctx);
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
        public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
        {
            CResultAErreur result = base.TraitementAvantSauvegarde(contexte);
            DataTable      table  = contexte.Tables[CLienReseauSupport.c_nomTable];

            if (table != null)
            {
                ArrayList lstRows = new ArrayList(table.Rows);
                foreach (DataRow row in lstRows)
                {
                    if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
                    {
                        CLienReseauSupport sup = new CLienReseauSupport(row);

                        /* if(!sup.EstSupporte.CanSupport(sup.Supporte))
                         * {
                         *   result.EmpileErreur("Impossible to add the link : the supported link @1 is supported by the supporting link @2|", sup.Supporte.Libelle,sup.EstSupporte.Libelle);
                         *   return result;
                         * }*/
                    }
                }
            }
            return(result);
        }
        /// <summary>
        /// Cette méthode va vérifier que pour la coordonnee et son occupation il n'y a une interaction <br/>
        /// avec d'une liste d'objets à coordonnées
        /// </summary>
        /// <param name="strCoordonneeDebut">Coordonnée souhaité</param>
        /// <param name="strCoordonneeFin">Coordonnée de fin (Coordonnée Souhaité + Occupation)</param>
        /// <param name="lstobj">Liste des objets à tester pour savoir si il y a une interaction</param>
        /// <returns>Renvoi faux si aucune interaction</returns>
        public CResultAErreur Test_Interactions(
            string strCoordonneeDebut,
            string strCoordonneeFin,
            List <IObjetACoordonnees> lstobj)
        {
            CResultAErreur result = CResultAErreur.True;

            List <IObjetACoordonnees> conflits = new List <IObjetACoordonnees>();

            foreach (IObjetACoordonnees obj in lstobj)
            {
                if (obj.Coordonnee != null && obj.Coordonnee != "")
                {
                    string strCoorfilsdebut = obj.Coordonnee;
                    string strCoorfilsfin   = strCoorfilsdebut;

                    //Il faut que la fin du fils soit avant le debut de la coor
                    int compare1 = SystemeCoordonnees.CompareAdresse(strCoorfilsdebut, strCoordonneeDebut, true);
                    //Ou que le debut du fils soit apres la fin de la coor
                    int compare2 = SystemeCoordonnees.CompareAdresse(strCoorfilsfin, strCoordonneeFin, true);

                    if (compare1 < 0 || compare2 > 0)
                    {
                        continue;
                    }
                    else
                    {
                        result.EmpileErreur(I.T("@1 occupies a coordinate in conflict with the coordinate @2 (at @3)|180", obj.DescriptionElement, strCoordonneeDebut, strCoordonneeFin));
                        conflits.Add(obj);
                    }
                }
            }
            result.Data = conflits;

            return(result);
        }
Example #20
0
        /// ////////////////////////////////////////////////////////
        public override CResultAErreur VerifieDonnees()
        {
            CResultAErreur result = CResultAErreur.True;

            if (m_expressionElementSource == null)
            {
                result.EmpileErreur(I.T("Incorrect formula for Edited element|385"));
            }
            if (!(m_expressionElementSource.TypeDonnee.TypeDotNetNatif.IsSubclassOf(typeof(CObjetDonnee))) ||
                m_expressionElementSource.TypeDonnee.IsArrayOfTypeNatif)
            {
                result.EmpileErreur(I.T("The edited element formula must return an entity|386"));
            }
            if (m_formuleParametresImpression == null ||
                !typeof(string).IsAssignableFrom(m_formuleParametresImpression.TypeDonnee.TypeDotNetNatif))
            {
                result.EmpileErreur(I.T("Print setup formula is not correct|20041"));
            }
            if (m_nIdModeleAImprimer < 0)
            {
                result.EmpileErreur(I.T("The text modele must be selected|20040"));
            }
            return(result);
        }
        //-------------------------------------------------------------
        protected override CResultAErreur MySerialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = SerializeParent <CTypeSite>(serializer);
            if (result)
            {
                result = SerializeParent <CTypeSite>(serializer);
            }
            if (result)
            {
                result = SerializeParent <CSite>(serializer);
            }
            if (result)
            {
                result = SerializeParent <CTypeEquipement>(serializer);
            }
            if (result)
            {
                result = SerializeParent <CStock>(serializer);
            }
            if (result)
            {
                result = SerializeParent <CEquipement>(serializer);
            }
            if (result)
            {
                result = SerializeParent <CSystemeCoordonnees>(serializer);
            }
            return(result);
        }
Example #22
0
        /// ////////////////////////////////////////////
        public CResultAErreur ExecuteAction(string strCodeAction, Hashtable valeursParametres)
        {
            //Alloue l'action
            Type           tp     = (Type)m_tableCodeActionToType[strCodeAction];
            CResultAErreur result = CResultAErreur.True;

            if (tp == null)
            {
                result.EmpileErreur(I.T("No action with the code '@1' exists|104", strCodeAction));
                return(result);
            }
            IActionSurServeur action = null;

            try
            {
                action = (IActionSurServeur)Activator.CreateInstance(tp);
            }
            catch
            {
                result.EmpileErreur(I.T("Impossible to allocate an action of the @1 type|105", strCodeAction));
                return(result);
            }
            return(action.Execute(IdSession, valeursParametres));
        }
        //------------------------------------------------------
        public static void EditeRestricitionsSpecifiques(
            IElementARestrictionsSpecifiques element,
            bool bModeEdition)
        {
            CFormEditRestrictionsSpecifiques form  = new CFormEditRestrictionsSpecifiques();
            CObjetDonneeAIdNumerique         objet = element as CObjetDonneeAIdNumerique;

            objet.BeginEdit();
            form.m_elementARestrictions       = objet as IElementARestrictionsSpecifiques;
            form.m_extModeEdition.ModeEdition = bModeEdition;
            if (form.ShowDialog() == DialogResult.OK && bModeEdition)
            {
                CResultAErreur result = objet.CommitEdit();
                if (!result)
                {
                    CFormAlerte.Afficher(result.Erreur);
                }
            }
            else
            {
                objet.CancelEdit();
            }
            form.Dispose();
        }
Example #24
0
        public CResultAErreur MajChamps()
        {
            CResultAErreur result = m_linkField.FillObjetFromDialog(m_agentFinder);

            if (result)
            {
                m_agentFinder.FormuleDeclenchement  = m_txtFormuleCondition.Formule;
                m_agentFinder.GenericRequestedValue = m_cmbGenericCode.SelectedItem as GenericCode?;
            }
            m_agentFinder.AutoUpdateIpOnMediationServices = m_chkUpdateIPOnMediation.Checked;
            m_agentFinder.AutoUpdateIpOnTimosDatabase     = m_chkUpdateIpInTimos.Checked;
            m_agentFinder.FormuleCleSpecifique            = m_txtFormuleCleSpecifiqueAgent.Formule;
            if (result)
            {
                result = m_agentFinder.VerifieDonnees();
            }
            if (result)
            {
                m_originalAgentFinder.Database.Merge(m_agentFinder.Database, false);// ImporteObjet(m_handler, true, true);
                //CCloner2iSerializable.CopieTo(m_handler, m_originalHandler);
            }

            return(result);
        }
Example #25
0
        /// //////////////////////////////////////////
        public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
        {
            CResultAErreur result    = CResultAErreur.True;
            string         strFormat = "";

            if (Parametres.Count == 2)
            {
                strFormat = valeursParametres[1].ToString();
            }
            object objet = valeursParametres[0];

            if (objet == null)
            {
                result.Data = null;
            }
            else
            {
                if (strFormat != "")
                {
                    MethodInfo method = objet.GetType().GetMethod("ToString", new Type[] { typeof(string) });
                    if (method != null)
                    {
                        result.Data = method.Invoke(objet, new object[] { strFormat });
                    }
                    else
                    {
                        result.Data = objet.ToString();
                    }
                }
                else
                {
                    result.Data = objet.ToString();
                }
            }
            return(result);
        }
        /// //////////////////////////////////////////////////
        protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
        {
            CResultAErreur result = MyExecute(contexte);

            if (!result)
            {
                result.EmpileErreur(I.T("@1 action execution error|203", Libelle));
                return(result);
            }
            CLienAction[] liens = GetLiensSortantHorsErreur();
            if (liens.Length < 1)
            {
                result.Data = null;
            }
            else if (liens.Length == 1)
            {
                result.Data = liens[0];
            }
            else
            {
                result.Data = liens;
            }
            return(result);
        }
        //----------------------------------------------
        protected override CResultAErreur MySerialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = SerializeChamps(serializer,
                                     c_champIp,
                                     c_champCommunaute,
                                     c_champPort,
                                     c_champVersionSnmp);
            if (result)
            {
                result = SerializeParent <CTypeAgentPourSupervision>(serializer);
            }
            if (result)
            {
                result = SerializeChilds <CEntiteSnmpPourSupervision>(serializer);
            }
            if (nVersion >= 1 && result)
            {
                result = SerializeChamp(serializer, c_champTrapsIp);
            }
            if (nVersion >= 2 && result)
            {
                result = SerializeChilds <CSnmpPollingSetup>(serializer);
            }
            if (nVersion >= 3 && result)
            {
                result = SerializeChilds <CSnmpHotelPollingSetup>(serializer);
            }
            return(result);
        }
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CListeObjetsDonnees liste  = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CActeur));
                CFiltreData         filtre = new CFiltreDataAvance(
                    CActeur.c_nomTable,
                    "Has(" + CEOplanifiee_Acteur.c_nomTable + "." + CEOplanifiee_Acteur.c_champId + ")");
                liste.Filtre = filtre;
                foreach (CActeur acteur in liste)
                {
                    //Il suffit de modifier l'acteur pour qu'on recalcule ces eos
                    CUtilElementAEO.UpdateEOSInCurrentContext(acteur);
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }

            return(result);
        }
Example #29
0
        /// ///////////////////////////////////////////
        public override sc2i.common.CResultAErreur RunService(object parametre)
        {
            MyDispose();
            CResultAErreur result = CResultAErreur.True;

            CActionCopierLocalDansGed.CParametresCopierLocalDansGed paramCopie = parametre as CActionCopierLocalDansGed.CParametresCopierLocalDansGed;
            if (paramCopie == null)
            {
                result.EmpileErreur(I.T("Bad parameter value for service GetLocalFile|20121"));
                return(result);
            }
            if (paramCopie.NomFichierLocal.ToUpper().StartsWith("FTP://"))
            {
                //Si FTP récupère le fichier FTP et l'envoie dans un fichier local temporaire
                result = GetFileFromFtp(paramCopie);
                if (!result)
                {
                    return(result);
                }
                paramCopie.NomFichierLocal = m_fichierTemporaireFromFTP.NomFichier;
            }

            string strNomFichier = paramCopie.NomFichierLocal;

            if (!File.Exists(strNomFichier))
            {
                result.EmpileErreur(I.T("File @1 doesn't exists|20122", strNomFichier));
                return(result);
            }
            m_streamFichier = new FileStream(strNomFichier, FileMode.Open, FileAccess.Read);
            CSourceDocumentStream source = new CSourceDocumentStream(
                m_streamFichier, Path.GetExtension(strNomFichier));

            result.Data = source;
            return(result);
        }
Example #30
0
        //-------------------------------------------------------------------
        public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                CCategorieGED cat = (CCategorieGED)objet;

                if (cat.Libelle == "")
                {
                    result.EmpileErreur(I.T("The category label cannot be empty|105"));
                }

                if (!CObjetDonneeAIdNumerique.IsUnique(cat, CCategorieGED.c_champLibelle, cat.Libelle))
                {
                    result.EmpileErreur(I.T("Another category with this label already exists|106"));
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }