//---------------------------------------------------------------
        public object GetValeur(CVersionDonneesObjetOperation version)
        {
            IChampPourVersion champ = GetChamp(version);

            if (champ is CChampCustomPourVersion)
            {
                CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
                object       valeur      = version.GetValeurStd();
                if (champCustom.TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
                {
                    Type tp = champCustom.TypeObjetDonnee;
                    if (tp != null && valeur is int)
                    {
                        CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { version.ContexteDonnee });
                        if (objet != null && objet.ReadIfExists((int)valeur))
                        {
                            return(objet);
                        }
                    }
                    return(null);
                }
                return(valeur);
            }
            return(null);
        }
Ejemplo n.º 2
0
 //---------------------------------------------------------------------
 public void SetValeur(object objet, object valeur)
 {
     if (objet != null && objet is IObjetDonneeAChamps)
     {
         if (valeur is int)
         {
             if ((int)valeur >= 0)
             {
                 CContexteDonnee contexte = ((IObjetDonneeAChamps)objet).ContexteDonnee;
                 CChampCustom    champ    = new CChampCustom(contexte);
                 if (champ.ReadIfExists(IdChampCustom))
                 {
                     CObjetDonneeAIdNumerique objetDonne = (CObjetDonneeAIdNumerique)Activator.CreateInstance(champ.TypeObjetDonnee, new object[] { contexte });
                     if (objetDonne.ReadIfExists((int)valeur))
                     {
                         CUtilElementAChamps.SetValeurChamp((IObjetDonneeAChamps)objet, m_nIdChampCustom, objetDonne);
                     }
                     else
                     {
                         throw new Exception(I.T("Object @1 @2 doesn't exist|515",
                                                 DynamicClassAttribute.GetNomConvivial(champ.TypeObjetDonnee),
                                                 valeur.ToString()));
                     }
                 }
             }
         }
         else
         {
             CUtilElementAChamps.SetValeurChamp((IObjetDonneeAChamps)objet, m_nIdChampCustom, null);
         }
     }
 }
Ejemplo n.º 3
0
        //----------------------------------------------------------
        public CResultAErreur AnnuleModificationPrevisionnelle(CVersionDonneesObjet versionObjet)
        {
            CContexteDonnee contexte    = versionObjet.ContexteDonnee;
            CResultAErreur  result      = CResultAErreur.True;
            int             nIdObjet    = versionObjet.IdElement;
            Type            typeObjet   = versionObjet.TypeElement;
            CVersionDonnees versionPrev = versionObjet.VersionDonnees;
            int             nIdVersion  = versionPrev.Id;

            //Vérifie que l'utilisateur peut travailler avec cette version
            result = versionPrev.EnregistreEvenement(CVersionDonnees.c_eventBeforeUtiliser, true);
            if (!result)
            {
                return(result);
            }
            contexte.SetVersionDeTravail(-1, false);



            //Suppression de l'objet associé
            string strPrimKey            = contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(typeObjet)).PrimaryKey[0].ColumnName;
            CListeObjetsDonnees listeTmp = new CListeObjetsDonnees(contexte, typeObjet);

            listeTmp.Filtre = new CFiltreData(
                CSc2iDataConst.c_champIdVersion + "=@1 and " +
                "(" + CSc2iDataConst.c_champOriginalId + "=@2 or " +
                strPrimKey + "=@2)",
                nIdVersion,
                nIdObjet);
            listeTmp.Filtre.IgnorerVersionDeContexte = true;
            result = CObjetDonneeAIdNumerique.Delete(listeTmp);
            if (!result)
            {
                return(result);
            }

            //Suppression de la version objet
            result = versionObjet.Delete();
            if (!result)
            {
                return(result);
            }

            //Force la modification de l'objet pour mettre à jour les versions suivantes
            CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });

            if (objet.ReadIfExists(nIdObjet))
            {
                //Passe dans la version de l'objet
                result = contexte.SetVersionDeTravail(objet.IdVersionDatabase, false);
                if (!result)
                {
                    return(result);
                }
                objet.Row.Row.SetModified();
            }
            return(result);
        }
Ejemplo n.º 4
0
        //-------------------------------------------------------
        public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
        {
            CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();

            using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
            {
                contexte.SetVersionDeTravail(version.Id, false);
                CMacro macro = new CMacro();
                macro.m_contexteDonnee = version.ContexteDonnee;
                macro.Libelle          = version.Libelle;

                CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme();
                variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
                variable.Nom        = "CurrentElement";
                variable.IdVariable = m_strIdVariableCurrentElement;
                macro.AddVariable(variable);

                Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
                Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
                foreach (CVersionDonneesObjet vo in version.VersionsObjets)
                {
                    if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
                    {
                        CMacroObjet mo = new CMacroObjet(macro);
                        mo.TypeObjet     = vo.TypeElement;
                        mo.IdObjet       = vo.IdElement;
                        mo.TypeOperation = vo.TypeOperation;
                        macro.AddObjet(mo);

                        dicMacrosObjets[vo.Id] = mo;
                        CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
                        if (objet.ReadIfExists(vo.IdElement))
                        {
                            dicObjetToMacros[objet] = mo;
                        }
                        mo.CreateVariable(objet);
                    }
                }
                foreach (CVersionDonneesObjet vo in version.VersionsObjets)
                {
                    if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
                    {
                        CMacroObjet    mo    = dicMacrosObjets[vo.Id];
                        CResultAErreur resMo = CResultAErreur.True;
                        resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
                        if (!resMo)
                        {
                            result.EmpileErreur(resMo.Erreur);
                        }
                    }
                }
                result.DataType = macro;
                return(result);
            }
        }
        //---------------------------------------------------------------------------
        /// <summary>
        /// Methode générique qui retourne une entité du jeux de test dans un contexte donné
        /// </summary>
        /// <typeparam name="TypeEntite"></typeparam>
        /// <param name="nId"></param>
        /// <param name="ctx"></param>
        /// <returns></returns>
        private CObjetDonneeAIdNumerique GetEntite(Type tp, int nId, CContexteDonnee ctx)
        {
            object obj = Activator.CreateInstance(tp, ctx);
            CObjetDonneeAIdNumerique entite = obj as CObjetDonneeAIdNumerique;

            if (entite != null && !entite.ReadIfExists(nId))
            {
                throw new Exception("L'entité: " + tp.ToString() + " avec l'ID " + nId.ToString() + " n'éxiste pas !");
            }
            return(entite);
        }
Ejemplo n.º 6
0
        public CObjetDonneeAIdNumerique GetObjetNomme()
        {
            Type tpObjet = TypeEntite;

            object obj = Activator.CreateInstance(tpObjet, new object[] { ContexteDonnee });
            CObjetDonneeAIdNumerique objAIdNum = obj as CObjetDonneeAIdNumerique;

            if (objAIdNum != null && objAIdNum.ReadIfExists(CleEntite))
            {
                return(objAIdNum);
            }
            return(null);
        }
Ejemplo n.º 7
0
        private void ShowInfos(object obj)
        {
            if (obj == null)
            {
                m_panelInfo.Visible = false;
            }
            CRepertoire repertoire = obj as CRepertoire;

            if (repertoire != null)
            {
                m_imageErreur.Image   = m_imagesFichiers.Images[GetIndexImageDossier(repertoire)];
                m_lblTitreErreur.Text = repertoire.Nom;
                m_txtErreur.Text      = repertoire.InfoImport;
            }
            CFichier fichier = obj as CFichier;

            if (fichier != null)
            {
                m_imageErreur.Image   = m_imagesFichiers.Images[GetIndexImageFichier(fichier)];
                m_lblTitreErreur.Text = fichier.Nom;
                if (fichier.KeyObjetAssocie != null && fichier.TypeObjetAssocie != null)
                {
                    m_txtErreur.Text = "Imported to ";
                    CObjetDonneeAIdNumerique objet = null;
                    if (CImportMyanmarConst.ContexteDonnee != null)
                    {
                        try
                        {
                            objet = Activator.CreateInstance(fichier.TypeObjetAssocie, new object[] { CImportMyanmarConst.ContexteDonnee }) as CObjetDonneeAIdNumerique;
                            if (obj != null && objet.ReadIfExists(fichier.KeyObjetAssocie))
                            {
                                m_txtErreur.Text += objet.DescriptionElement;
                            }
                        }
                        catch { }
                    }
                    if (objet == null && fichier.TypeObjetAssocie != null)
                    {
                        m_txtErreur.Text += DynamicClassAttribute.GetNomConvivial(fichier.TypeObjetAssocie);
                    }
                    else
                    {
                        m_txtErreur.Text += " ? ";
                    }
                }
                else
                {
                    m_txtErreur.Text = fichier.InfoImport;
                }
            }
        }
Ejemplo n.º 8
0
        //------------------------------------------------------------------------------------------
        public CResultAErreur Execute(CContexteExecutionMacro contexteExecution)
        {
            CResultAErreur result = CResultAErreur.True;

            //Initialise les valeurs des variables
            foreach (KeyValuePair <string, CDbKey> kv in m_dicVariableToInitialId)
            {
                IVariableDynamique var = GetVariable(kv.Key);
                if (var != null && kv.Value != null)
                {
                    Type tpObjet = var.TypeDonnee.TypeDotNetNatif;
                    if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjet))
                    {
                        try
                        {
                            CObjetDonneeAIdNumerique obj = Activator.CreateInstance(tpObjet, new object[] { contexteExecution.ContexteDonnee }) as CObjetDonneeAIdNumerique;
                            if (obj != null && obj.ReadIfExists(kv.Value))
                            {
                                SetValeurChamp(kv.Key, obj);
                            }
                        }
                        catch { }
                    }
                }
            }

            IVariableDynamique variable = VariableCible;

            if (variable == null)
            {
                result.EmpileErreur("#Macro target is not specified");
                return(result);
            }
            if (contexteExecution.Cible != null && variable.TypeDonnee.TypeDotNetNatif != contexteExecution.Cible.GetType())
            {
                result.EmpileErreur("#Macro must be applied on " + DynamicClassAttribute.GetNomConvivial(variable.TypeDonnee.TypeDotNetNatif));
                return(result);
            }
            SetValeurChamp(variable.IdVariable, contexteExecution.Cible);
            if (Formulaire != null)
            {
                if (CFormFormulairePopup.EditeElement(Formulaire, this, "MACRO"))
                {
                    foreach (CMacroObjet macObj in Objets)
                    {
                        macObj.Execute(contexteExecution);
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 9
0
 //----------------------------------
 public CObjetDonneeAIdNumerique GetObjet(CContexteDonnee ctx)
 {
     if (IdObjet != null)
     {
         try
         {
             CObjetDonneeAIdNumerique objet = Activator.CreateInstance(m_typeObjet, new object[] { ctx }) as CObjetDonneeAIdNumerique;
             if (objet.ReadIfExists(IdObjet.Value))
             {
                 return(objet);
             }
         }
         catch { }
     }
     return(null);
 }
Ejemplo n.º 10
0
        //-------------------------------------------------------
        public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
        {
            CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();

            using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
            {
                contexte.SetVersionDeTravail(version.Id, false);
                CMacro macro = new CMacro();
                macro.m_contexteDonnee = version.ContexteDonnee;

                Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
                Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
                foreach (CVersionDonneesObjet vo in version.VersionsObjets)
                {
                    CMacroObjet mo = new CMacroObjet(macro);
                    mo.TypeObjet     = vo.TypeElement;
                    mo.IdObjet       = vo.IdElement;
                    mo.TypeOperation = vo.TypeOperation;
                    macro.AddObjet(mo);

                    dicMacrosObjets[vo.Id] = mo;
                    CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
                    if (objet.ReadIfExists(vo.IdElement))
                    {
                        dicObjetToMacros[objet] = mo;
                    }
                    mo.CreateVariable(objet);
                }
                foreach (CVersionDonneesObjet vo in version.VersionsObjets)
                {
                    CMacroObjet    mo    = dicMacrosObjets[vo.Id];
                    CResultAErreur resMo = CResultAErreur.True;
                    resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
                    if (!resMo)
                    {
                        result.EmpileErreur(resMo.Erreur);
                    }
                }
                result.DataType = macro;
                return(result);
            }
        }
Ejemplo n.º 11
0
        //------------------------------------------------------------
        public CResultAErreur GetValue(object objet, string strPropriete)
        {
            CResultAErreur           result      = CResultAErreur.True;
            CObjetDonneeAIdNumerique objetTypeId = objet as CObjetDonneeAIdNumerique;

            if (objetTypeId == null)
            {
                return(result);
            }
            //trouve la relation correspondante à l'identifiant de la propriété
            RelationTypeIdAttribute relation = null;

            foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
            {
                if (relTest.IdRelation == strPropriete)
                {
                    relation = relTest;
                    break;
                }
            }
            if (relation == null)
            {
                result.EmpileErreur(I.T("Relation @1 doesn't exists|20030", strPropriete));
                return(result);
            }
            CObjetDonneeAIdNumerique objetParent = null;

            //Récupère le type de l'objet parent
            try
            {
                Type tp = CActivatorSurChaine.GetType((string)objetTypeId.Row[relation.ChampType], false);
                objetParent = Activator.CreateInstance(tp, new object[] { objetTypeId.ContexteDonnee }) as CObjetDonneeAIdNumerique;
                if (!objetParent.ReadIfExists((int)objetTypeId.Row[relation.ChampId]))
                {
                    objetParent = null;
                }
            }
            catch { }
            result.Data = objetParent;
            return(result);
        }
        /// //////////////////////////////////////////////////////////////////////////
        public CResultAErreur DeclencheEvenementStatiques(Type typeObjet, CDbKey dbKeyObjet)
        {
            CResultAErreur result = CResultAErreur.True;

            using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
            {
                CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
                if (!objet.ReadIfExists(dbKeyObjet))
                {
                    result.EmpileErreur(I.T("The @1 object with id @2 doesn't exist|106", DynamicClassAttribute.GetNomConvivial(typeObjet), dbKeyObjet.StringValue));
                    return(result);
                }
                IDeclencheurAction[] declencheurs = CRecuperateurDeclencheursActions.GetDeclencheursAssocies(objet);
                foreach (IDeclencheurAction declencheur in declencheurs)
                {
                    if (declencheur is CEvenement)
                    {
                        CEvenement evt = (CEvenement)declencheur;
                        CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess();
                        bool bShouldDeclenche = false;
                        if (!evt.DejaDeclenchePourEntite(objet))
                        {
                            bShouldDeclenche = evt.ParametreDeclencheur.ShouldDeclenche(
                                objet,
                                false,
                                true,
                                ref infoDeclencheur);
                        }
                        if (bShouldDeclenche)
                        {
                            evt.EnregistreDeclenchementEvenement(objet, infoDeclencheur);
                        }
                        if (!result)
                        {
                            return(result);
                        }
                    }
                }
            }
            return(result);
        }
 /// ///////////////////////////////////////////
 public object GetValeurParDefaut(CContexteDonnee contexte)
 {
     if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(m_type.TypeDotNetNatif))
     {
         try
         {
             CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(m_type.TypeDotNetNatif, new object[] { contexte });
             // TESTDBKEYOK
             if (m_dbKeyIdInitial != null && objet.ReadIfExists(m_dbKeyIdInitial))
             {
                 return(objet);
             }
         }
         catch { }
     }
     if (m_type.TypeDotNetNatif.GetCustomAttributes(typeof(VariableAutoAlloueeAttribute), true).Length > 0 && !m_type.IsArrayOfTypeNatif)
     {
         return(Activator.CreateInstance(m_type.TypeDotNetNatif, new object[0]));
     }
     return(null);
 }
Ejemplo n.º 14
0
        //------------------------------------------------------------------------------
        public CDataPlanning(Type typeElement, int nIdElement, CContexteDonnee ctx)
        {
            m_typeElement = typeElement;

            try
            {
                CObjetDonneeAIdNumerique element = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(typeElement, new object[] { ctx });
                if (element.ReadIfExists(nIdElement))
                {
                    m_element = (IElementDataDeTableauPlanning)element;
                }
                else
                {
                    m_element = null;
                }
            }
            catch
            {
                m_element = null;
            }
        }
Ejemplo n.º 15
0
        //----------------------------------
        public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
        {
            List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();

            lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
            List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();

            lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
            CResultAErreur           result = CResultAErreur.True;
            CObjetDonneeAIdNumerique objet  = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;

            if (!objet.ReadIfExists(vo.IdElement))
            {
                objet = null;
            }
            else
            {
                DesignationObjet = objet.DescriptionElement;
            }
            switch (vo.TypeOperation.Code)
            {
            case CTypeOperationSurObjet.TypeOperation.Ajout:
                if (objet != null && objet.IsValide())
                {
                    foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
                    {
                        string strNom = def.NomProprieteSansCleTypeChamp;
                        if (!def.IsReadOnly && strNom != "IsDeleted" && strNom != "Id" &&
                            strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
                        {
                            CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
                            if (resultVal)
                            {
                                object            data = resultVal.Data;
                                CMacroObjetValeur mv   = new CMacroObjetValeur(this);
                                mv.Champ = def;
                                if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
                                {
                                    AddValeur(mv);
                                }
                                else
                                {
                                    result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", def.Nom), true));
                                }
                            }
                        }
                    }
                    if (objet is CElementAChamp)
                    {
                        foreach (CRelationElementAChamp_ChampCustom rel in ((CElementAChamp)objet).RelationsChampsCustom)
                        {
                            object data = rel.Valeur;
                            if (data != null)
                            {
                                CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == rel.ChampCustom.Id);
                                if (defCust != null)
                                {
                                    CMacroObjetValeur mv = new CMacroObjetValeur(this);
                                    mv.Champ = defCust;
                                    mv.Champ = defCust;
                                    this.AddValeur(mv);
                                    if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
                                    {
                                        this.AddValeur(mv);
                                    }
                                    else
                                    {
                                        result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", rel.ChampCustom.Nom), true));
                                    }
                                }
                            }
                        }
                    }
                }

                break;

            case CTypeOperationSurObjet.TypeOperation.Suppression:
                break;

            case CTypeOperationSurObjet.TypeOperation.Modification:
                CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
                foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
                {
                    CDefinitionProprieteDynamique def   = null;
                    IChampPourVersion             champ = valeur.Champ;
                    if (champ is CChampPourVersionInDb)
                    {
                        string          strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
                        CInfoChampTable infoChamp   = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
                        if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
                            infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
                            infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
                        {
                            string strNomPropriete = infoChamp.Propriete;
                            def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
                        }
                    }
                    else if (champ is CChampCustomPourVersion)
                    {
                        CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
                        if (champCustom != null)
                        {
                            def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
                                                                 ((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == champCustom.Id);
                        }
                    }
                    if (def != null && !def.IsReadOnly)
                    {
                        CMacroObjetValeur mv = new CMacroObjetValeur(this);
                        mv.Champ = def;
                        if (!FillMacroValeurWithValue(mv, valeur.GetValeur(), dicObjetToMacro))
                        {
                            result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", valeur.NomChampConvivial), true));
                        }
                        else
                        {
                            AddValeur(mv);
                        }
                    }
                }
                break;
            }
            if (Valeurs.Count() == 0)
            {
                TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
            }
            return(result);
        }
Ejemplo n.º 16
0
        /// <summary>
        /// /////////////////////////////////////////////////////////////////////////////////
        /// </summary>
        /// <param name="table"></param>
        /// <param name="result"></param>
        ///
        private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData)
        {
            CResultAErreur result = CResultAErreur.True;

            ///Stef 22/07/08 : l'appel à shouldDeclenche peut
            ///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas
            ///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce
            ///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent
            ///dans un contexte sans gestion par tables complètes, on est mal, parce que
            ///ça va génerer une requête par champ.
            ///Donc, on lit tous les champs custom avant de commencer
            CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom));

            listeChamps.PreserveChanges = true;            //Pour ne pas modifier les champs modifiés
            listeChamps.AssureLectureFaite();

            DateTime dt = DateTime.Now;
            CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( );

            ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte);

            //Pour empêcher de regarder deux fois les évenements d'un même objet
            //Type->Dictionnaire des ids vus
            Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >();

            DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged);

            Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null;

            if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser))
            {
                listeElementsARepasser             = new Dictionary <string, Dictionary <int, bool> >();
                m_listeElementsARepasser[contexte] = listeElementsARepasser;
            }

            bool bFirstPasse     = true;
            int  nLimiteurPasses = 0;

            while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5)
            {
                nLimiteurPasses++;

                foreach (DataTable table in lstTables)
                {
                    if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1)
                    {
                        string strChampCle = table.PrimaryKey[0].ColumnName;

                        Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName);
                        if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets))
                        {
                            continue;
                        }

                        Type typeOriginal = tpObjets;

                        //Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié
                        //Mais le champ peut l'être
                        if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom)))
                        {
                            int  nLigne = 0;
                            bool bGoOut = false;
                            while (table.Rows.Count > nLigne && !bGoOut)
                            {
                                if (table.Rows[nLigne].RowState != DataRowState.Deleted)
                                {
                                    CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]);
                                    tpObjets    = rel.ElementAChamps.GetType();
                                    strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0];
                                    bGoOut      = true;
                                }
                                nLigne++;
                            }
                        }

                        //Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements
                        if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0)
                        {
                            continue;
                        }

                        ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail);

                        //Id des éléments modifiés
                        List <int> listeIdsElementsAVerifierHandlers = new List <int>();
                        string     strPrimaryKey = "";
                        if (table.PrimaryKey.Length == 1 &&
                            table.PrimaryKey[0].DataType == typeof(int))
                        {
                            strPrimaryKey = table.PrimaryKey[0].ColumnName;
                        }

                        Dictionary <int, bool> tableIdsVues = null;
                        if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues))
                        {
                            tableIdsVues          = new Dictionary <int, bool>();
                            elementsVus[tpObjets] = tableIdsVues;
                        }

                        Dictionary <int, bool> listeARepasserPourTable = null;
                        if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable))
                        {
                            listeARepasserPourTable = null;
                        }

                        List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>();

                        //Stef 16/11/2012 :
                        //Si c'est un élément à champs, il est consideré comme modifié
                        //si un de ses champs custom est modifiés
                        //Ca a été fait parce que les handlers d'évenement n'étaient
                        //Pas pris en compte sur modif de champ custom
                        //On n'enlève pas pour autant l'ancienne méthode qui consiste
                        //à considérer l'élément modifié losrqu'on passe sur la table des
                        //valeurs de champs custom
                        if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0)
                        {
                            //Regarde s'il y a des relations
                            IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps;
                            string strTableChamps         = objAChamp.GetNomTableRelationToChamps();
                            //Trouve la relation à la table
                            DataTable tableChamps = contexte.Tables[strTableChamps];
                            if (tableChamps != null)//Si la table champs n'est pas là, c'est
                            //qu'elle n'a pas été modifiée !! c'est logique çà
                            {
                                DataRelation rel = null;
                                foreach (DataRelation relTest in tableChamps.ParentRelations)
                                {
                                    if (relTest.ParentTable.TableName == table.TableName)
                                    {
                                        rel = relTest;
                                        break;
                                    }
                                }
                                if (rel != null)//On peut vérifier !
                                {
                                    foreach (DataRow row in new ArrayList(table.Rows))
                                    {
                                        if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine
                                        {
                                            DataRow[] rowsChamps = row.GetChildRows(rel);
                                            foreach (DataRow rowChamp in rowsChamps)
                                            {
                                                if (rowChamp.RowState != DataRowState.Unchanged)
                                                {
                                                    //Aloue l'objet pour s'assurer que la ligne est bien pleine
                                                    CObjetDonnee objTmp = contexte.GetNewObjetForRow(row);
                                                    objTmp.AssureData();
                                                    row.SetModified();
                                                    string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification];
                                                    if (strOldContexte.Length == 0)
                                                    {
                                                        row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification,
                                                                                                                 rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string;
                                                    }
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        foreach (DataRow row in new ArrayList(table.Rows))
                        {
                            CObjetDonneeAIdNumerique objet = null;
                            if (lstEvenements.Count > 0)
                            {
                                if (row.RowState == DataRowState.Added ||
                                    row.RowState == DataRowState.Modified ||
                                    row.RowState == DataRowState.Deleted)
                                {
                                    objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row);
                                    if (objet.Row.RowState == DataRowState.Deleted)
                                    {
                                        objet.VersionToReturn = DataRowVersion.Original;
                                    }
                                    if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet))
                                    {
                                        lstObjetsAvecEvenementsSpecifiques.Add(objet);
                                    }

                                    if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal))
                                    {
                                        CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom;
                                        objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps;
                                        if (objet.Row.RowState == DataRowState.Unchanged)
                                        {
                                            objet.Row.Row.SetModified();
                                        }
                                        if (objet.Row.RowState == DataRowState.Deleted)
                                        {
                                            objet.VersionToReturn = DataRowVersion.Original;
                                        }
                                        if (rel.ContexteDeModification.Length != 0 &&
                                            objet.ContexteDeModification.Length == 0)
                                        {
                                            objet.ContexteDeModification = rel.ContexteDeModification;
                                        }
                                    }
                                    if (!tableIdsVues.ContainsKey(objet.Id) || (
                                            listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id)))
                                    {
                                        tableIdsVues[objet.Id] = true;
                                        foreach (CEvenement evt in lstEvenements)
                                        {
                                            if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet))
                                            {
                                                //Attention, si c'est une valeur de champ custom, envoie la valeur,
                                                //c'est elle qui sera testée.
                                                CInfoDeclencheurProcess infoDeclencheur = null;
                                                if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur))
                                                {
                                                    infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey;
                                                    infoDeclencheur.Info = evt.Libelle;
                                                    traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur);
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            //Regarde les handle d'évenement sur l'objet
                            if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified))
                            {
                                listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]);
                            }
                        }
                        if (listeARepasserPourTable != null)
                        {
                            listeARepasserPourTable.Clear();
                        }

                        if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse)
                        {
                            //traitement par paquet de 500
                            for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500)
                            {
                                int           nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count);
                                StringBuilder bl   = new StringBuilder();
                                for (int nIndex = nIndexLot; nIndex < nMin; nIndex++)
                                {
                                    bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString());
                                    bl.Append(",");
                                }
                                string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1);
                                //Recherche tous les handlers d'évenement pour les objets concernés
                                CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
                                listeHandler.Filtre = new CFiltreData(
                                    CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " +
                                    CHandlerEvenement.c_champTypeCible + "=@1 and " +
                                    CHandlerEvenement.c_champTypeEvenement + "=@2",
                                    tpObjets.ToString(),
                                    (int)TypeEvenement.Modification);
                                listeHandler.PreserveChanges = true;
                                foreach (CHandlerEvenement handler in listeHandler)
                                {
                                    if (handler.Row.RowState != DataRowState.Deleted)
                                    {
                                        CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte });
                                        if (objetTmp.ReadIfExists(handler.IdElementCible))
                                        {
                                            CInfoDeclencheurProcess infoDeclencheur = null;
                                            if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur))
                                            {
                                                if (infoDeclencheur != null && handler.EvenementLie != null)
                                                {
                                                    infoDeclencheur.Info = handler.EvenementLie.Libelle;
                                                }
                                                traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        //Annule les évenements spécifiques, ils ont été traités !
                        foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques)
                        {
                            EvenementAttribute.ClearEvenements(objet);
                        }
                    }
                }

                //Execute ce qui peut être executé tout de suite
                foreach (DataTable table in contexte.Tables)
                {
                    table.RowChanged += handlerRedo;
                }
                listeElementsARepasser.Clear();
                foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet)
                {
                    if (couple.Objet is CObjetDonneeAIdNumerique &&
                        couple.PeutEtreExecuteSurLePosteClient)
                    {
                        result = couple.OnDeclencheSurClient();
                        if (!result)
                        {
                            return(result);
                        }
                    }
                }
                foreach (DataTable table in contexte.Tables)
                {
                    table.RowChanged -= handlerRedo;
                }
                bFirstPasse = false;
            }

            if (traitement.CouplesEvenementOuHandlerObjet.Count != 0)
            {
                tableData[c_cleDonneeListeTraitements] = traitement;
            }
            m_listeElementsARepasser.Remove(contexte);
            return(result);
        }
Ejemplo n.º 17
0
        private void m_arbreObjet_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            using (CWaitCursor waiter = new CWaitCursor())
            {
                if (e.Node.Nodes.Count != 1 || e.Node.Nodes[0].Tag != DBNull.Value)
                {
                    return;                    //C'est un vrai noeud, on ne remplit pas
                }
                e.Node.Nodes.Clear();

                if (e.Node.Tag is CObjetDonneeAIdNumerique)
                {
                    CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)e.Node.Tag;
                    CValeursHistorique       valeursHistoriques = GetValeursHistorique(objet);

                    CStructureTable structure = CStructureTable.GetStructure(objet.GetType());

                    #region relations parentes
                    //traitement des relations parentes
                    foreach (CInfoRelation relation in structure.RelationsParentes)
                    {
                        Type tpParent = CContexteDonnee.GetTypeForTable(relation.TableParente);
                        if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpParent) && relation.Propriete != "")
                        {
                            int    nImage    = c_nImageUnchanged;
                            object newValeur = objet.Row[relation.ChampsFille[0]];
                            if (newValeur == null)                            //Pour éviter les problèmes de null
                            {
                                newValeur = DBNull.Value;
                            }
                            object oldValeur = newValeur;
                            //Cherche si la valeur pour cette version a changé
                            CChampPourVersionInDb champ = new CChampPourVersionInDb(relation.ChampsFille[0], relation.ChampsFille[0]);
                            if (valeursHistoriques.ContainsKey(champ))
                            {
                                oldValeur = valeursHistoriques[champ];
                                if (!newValeur.Equals(oldValeur))
                                {
                                    nImage = c_nImageEdit;
                                }
                            }
                            TreeNode node = new TreeNode(relation.NomConvivial);
                            node.Tag                = relation;
                            node.ImageIndex         = nImage;
                            node.SelectedImageIndex = nImage;
                            e.Node.Nodes.Add(node);

                            //Ajoute la valeur actuelle
                            CObjetDonneeAIdNumerique parent = (CObjetDonneeAIdNumerique)objet.GetParent(relation.ChampsFille[0], tpParent);
                            TreeNode nodeParent             = CreateNodeObjet(node.Nodes, parent);
                            nodeParent.StateImageIndex = c_nImageActuel;

                            //Ajoute valeur historique
                            if (!newValeur.Equals(oldValeur))
                            {
                                parent     = null;
                                nodeParent = null;
                                if (oldValeur is int)
                                {
                                    //récupère l'ancien parent
                                    parent = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpParent, new object[] { objet.ContexteDonnee });
                                    if (!parent.ReadIfExists((int)oldValeur))
                                    {
                                        parent = null;
                                    }
                                }
                                nodeParent = CreateNodeObjet(node.Nodes, parent);
                                nodeParent.StateImageIndex = c_nImageHistory;
                            }
                        }
                    }
                    #endregion

                    #region relations filles
                    foreach (CInfoRelation relationFille in structure.RelationsFilles)
                    {
                        if (relationFille.NomConvivial != "")
                        {
                            Type tpFille = CContexteDonnee.GetTypeForTable(relationFille.TableFille);
                            if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFille))
                            {
                                int      nImageNodeRelation = c_nImageUnchanged;
                                TreeNode nodeRelation       = new TreeNode(relationFille.NomConvivial);
                                e.Node.Nodes.Add(nodeRelation);

                                Hashtable tableOldIds = new Hashtable();
                                foreach (int nId in m_version.GetIdsChildsHistoriques(objet, relationFille))
                                {
                                    tableOldIds.Add(nId, true);
                                }


                                //Récupère la liste de tous les fils actuels
                                C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
                                requete.TableInterrogee = relationFille.TableFille;
                                C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID",
                                                                                         new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName),
                                                                                         typeof(int),
                                                                                         OperationsAgregation.None,
                                                                                         true);
                                requete.ListeChamps.Add(champDeRequete);
                                CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and " +
                                                                     CSc2iDataConst.c_champIdVersion + " is null",
                                                                     objet.Id);
                                filtre.IgnorerVersionDeContexte = true;
                                requete.FiltreAAppliquer        = filtre;
                                Hashtable      tableNewIds = new Hashtable();
                                CResultAErreur result      = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
                                if (result)
                                {
                                    foreach (DataRow row in ((DataTable)result.Data).Rows)
                                    {
                                        tableNewIds.Add(row[0], true);
                                    }
                                }
                                //Ajoute les ids actuels
                                foreach (int nId in tableNewIds.Keys)
                                {
                                    CObjetDonneeAIdNumerique fils = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpFille, new object[] { objet.ContexteDonnee });
                                    if (fils.ReadIfExists(nId))
                                    {
                                        int nImage = -1;
                                        if (!tableOldIds.ContainsKey(nId))
                                        {
                                            nImage             = c_nImagePlus;
                                            nImageNodeRelation = c_nImageEdit;
                                        }
                                        TreeNode nodeFille = CreateNodeObjet(nodeRelation.Nodes, fils);
                                        if (nImage >= 0)
                                        {
                                            nodeFille.StateImageIndex = nImage;
                                        }
                                    }
                                }
                                //Ajoute les vieux ids
                                foreach (int nId in tableOldIds.Keys)
                                {
                                    if (!tableNewIds.ContainsKey(nId))
                                    {
                                        CObjetDonneeAIdNumerique fils = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpFille, new object[] { objet.ContexteDonnee });
                                        if (fils.ReadIfExists(nId))
                                        {
                                            int nImage = c_nImageMoins;
                                            nImageNodeRelation = c_nImageEdit;
                                            TreeNode nodeFille = CreateNodeObjet(nodeRelation.Nodes, fils);
                                            nodeFille.StateImageIndex = nImage;
                                        }
                                    }
                                }
                                nodeRelation.ImageIndex         = nImageNodeRelation;
                                nodeRelation.SelectedImageIndex = nImageNodeRelation;
                            }
                        }
                    }
                    #endregion
                }
            }
        }
Ejemplo n.º 18
0
        /// /////////////////////////////////////////////////////////
        public static object StringToType(TypeDonnee type, string strTexte, CContexteDonnee contexteDonnee)
        {
            if (strTexte.ToUpper() == c_ConstanteNull)
            {
                return(null);
            }
            switch (type)
            {
            case TypeDonnee.tBool:
                return(strTexte.ToString() == "1" || strTexte.ToUpper() == "TRUE");

            case TypeDonnee.tDate:
                try
                {
                    return(Convert.ChangeType(strTexte, typeof(DateTime), null));
                }
                catch
                {
                    //Tente le format sc2i de date chaine
                    try
                    {
                        return(CUtilDate.FromUniversalString(strTexte));
                    }
                    catch
                    {
                        return(null);
                    }
                }

            case TypeDonnee.tDouble:
                try
                {
                    return(CUtilDouble.DoubleFromString(strTexte));
                }
                catch
                {
                    return(null);
                }

            case TypeDonnee.tEntier:
                try
                {
                    return(Convert.ChangeType(strTexte, typeof(int), null));
                }
                catch
                {
                    return(null);
                }

            case TypeDonnee.tString:
                return(strTexte);

            case TypeDonnee.tObjetDonneeAIdNumeriqueAuto:
                try
                {
                    if (contexteDonnee == null)
                    {
                        return(null);
                    }
                    //Syntaxe : classe|id
                    int nPos = strTexte.LastIndexOf("|");
                    if (nPos < 0)
                    {
                        return(null);
                    }
                    string strClasse = strTexte.Substring(0, nPos);
                    int    nId       = Int32.Parse(strTexte.Substring(nPos + 1));
                    Type   tp        = CActivatorSurChaine.GetType(strClasse, true);
                    if (tp != null)
                    {
                        CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { contexteDonnee });
                        if (objet.ReadIfExists(nId))
                        {
                            return(objet);
                        }
                    }
                    return(null);
                }
                catch
                {
                    return(null);
                }
            }
            return(null);
        }
Ejemplo n.º 19
0
        //------------------------------------
        private CResultAErreur ImporteRow(DataRow row, CFiltreData filtreCle, CContexteDonnee contexteDestination)
        {
            CResultAErreur result = CResultAErreur.True;

            Dictionary <CDefinitionProprieteDynamique, object> dicValeurs = new Dictionary <CDefinitionProprieteDynamique, object>();
            List <object> lstValeurs = new List <object>();

            if (filtreCle != null)
            {
                filtreCle.Parametres.Clear();
            }
            foreach (CMappageChampImport mappage in Mappages)
            {
                object valeur = mappage.Origine.GetValeur(row);
                if (mappage.IsCle && filtreCle != null)
                {
                    if (valeur == null)
                    {
                        result.EmpileErreur("Can not import field @1 as key, because imported value is null|20045", mappage.ProprieteDestination.Nom);
                        return(result);
                    }
                    filtreCle.Parametres.Add(valeur);
                }
                dicValeurs[mappage.ProprieteDestination] = valeur;
            }
            CObjetDonnee objet   = Activator.CreateInstance(m_typeCible, new object[] { contexteDestination }) as CObjetDonnee;
            bool         bCreate = true;

            //Cherche si l'objet exite
            if (filtreCle != null)
            {
                bCreate = !objet.ReadIfExists(filtreCle, !m_bChargerTouteLaCible);
            }
            if (bCreate && (OptionImport & EOptionImport.Create) != EOptionImport.Create)
            {
                return(result);
            }
            if (!bCreate && (OptionImport & EOptionImport.Update) != EOptionImport.Update)
            {
                return(result);
            }
            if (bCreate)
            {
                objet.CreateNewInCurrentContexte(null);
            }
            bool bUpdate = false;

            foreach (KeyValuePair <CDefinitionProprieteDynamique, object> kv in dicValeurs)
            {
                object val = kv.Value;
                if (kv.Value is int && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(kv.Key.TypeDonnee.TypeDotNetNatif))
                {
                    CObjetDonneeAIdNumerique obj = Activator.CreateInstance(kv.Key.TypeDonnee.TypeDotNetNatif, new object[] { contexteDestination }) as CObjetDonneeAIdNumerique;
                    if (!obj.ReadIfExists((int)kv.Value, !m_bChargerTouteLaCible))
                    {
                        obj = null;
                    }
                    val = obj;
                }

                result = CInterpreteurProprieteDynamique.GetValue(objet, kv.Key);
                if (result)
                {
                    object valeurOrigine = result.Data;
                    if ((val == null && valeurOrigine != null) ||
                        (valeurOrigine == null && val != null) ||
                        (val != null && valeurOrigine != null && !val.Equals(valeurOrigine)))
                    {
                        result = CInterpreteurProprieteDynamique.SetValue(objet, kv.Key, val);
                        if (!result)
                        {
                            return(result);
                        }
                        bUpdate = true;
                    }
                }
            }
            if (bCreate)
            {
                m_nNbCreated++;
            }
            else if (bUpdate)
            {
                m_nNbUpdated++;
            }

            return(result);
        }
Ejemplo n.º 20
0
        //-------------------------------------------------------------------------------
        public CResultAErreur FillFromSnmp(CEntiteSnmpPourSupervision entiteFromSnmp)
        {
            CResultAErreur result    = CResultAErreur.True;
            CTypeAgentSnmp typeAgent = AgentSnmp.TypeAgent;

            CTypeEntiteSnmp[] typesEntites = (CTypeEntiteSnmp[])typeAgent.TypesEntites.ToArray(typeof(CTypeEntiteSnmp));
            CTypeEntiteSnmp   typeEntite   = typesEntites.FirstOrDefault(t => t.Id.ToString() == entiteFromSnmp.TypeEntite.Id);

            if (typeEntite == null)
            {
                result.EmpileErreur(I.T("Can not find Snmp entity type @1|20309", entiteFromSnmp.TypeEntite.Id));
                return(result);
            }
            TypeEntiteSnmp = typeEntite;
            Index          = entiteFromSnmp.Index;
            Libelle        = entiteFromSnmp.Libelle;

            //Affecte les champs
            foreach (CChampEntiteFromQueryToChampCustom champ in typeEntite.ChampsFromQuery)
            {
                if (champ.IdChampCustom != null)
                {
                    CChampCustom champCustom = new CChampCustom(ContexteDonnee);
                    if (champCustom.ReadIfExists(champ.IdChampCustom))
                    {
                        object valeur = entiteFromSnmp.GetValeurChamp(champ.Champ.Id);
                        if (valeur != null)
                        {
                            if (champCustom.TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
                            {
                                Type tp = champCustom.TypeObjetDonnee;
                                CObjetDonneeAIdNumerique obj = Activator.CreateInstance(tp, new object[] { ContexteDonnee }) as CObjetDonneeAIdNumerique;
                                if (valeur is int)
                                {
                                    if (obj != null && obj.ReadIfExists((int)valeur, true))
                                    {
                                        SetValeurFromSnmp(champ.IdChampCustom.Value, obj);
                                    }
                                }
                                else
                                {
                                    SetValeurFromSnmp(champ.IdChampCustom.Value, null);
                                }
                            }
                            else
                            {
                                SetValeurFromSnmp(champ.IdChampCustom.Value, valeur);
                            }
                        }
                    }
                }
            }

            //calcule le libellé
            if (typeEntite.FormuleCalculLibelle != null)
            {
                CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this);
                result = typeEntite.FormuleCalculLibelle.Eval(ctx);
                if (result && result.Data != null)
                {
                    Libelle = result.Data.ToString();
                }
                result = CResultAErreur.True;
            }

            return(result);
        }
Ejemplo n.º 21
0
        /// //////////////////////////////////////////
        public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
        {
            CResultAErreur result = CResultAErreur.True;
            string         strVal = listeParametres[0].ToString();

            Type tp = listeParametres[0] as Type;

            if (tp == null)
            {
                tp = CActivatorSurChaine.GetType(strVal, true);
            }
            if (tp == null)
            {
                tp = CActivatorSurChaine.GetType(strVal, false);
            }
            if (tp == null)
            {
                result.EmpileErreur(I.T("The @1 type does not exist|221", strVal));
                return(result);
            }
            if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tp))
            {
                result.EmpileErreur(I.T("The @1 type cannot be loaded by the 'GetEntite' function|222", strVal));
                return(result);
            }
            try
            {
                CContexteDonnee contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
                if (contexteDonnee == null)
                {
                    contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
                    ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
                }
                CObjetDonneeAIdNumerique obj = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { contexteDonnee });
                if (listeParametres[1] is int)
                {
                    if (obj.ReadIfExists((int)listeParametres[1]))
                    {
                        result.Data = obj;
                    }
                    else
                    {
                        result.Data = null;
                    }
                }
                // YK 14/04/2011 Surcharge du deuxième paramètre en String Nom de l'entité nommée
                else if (listeParametres[1] is string)
                {
                    CNommageEntite nommage = new CNommageEntite(contexteDonnee);
                    if (nommage.ReadIfExists(new CFiltreData(
                                                 CNommageEntite.c_champTypeEntite + " = @1 AND " +
                                                 CNommageEntite.c_champNomFort + " = @2",
                                                 tp.ToString(),
                                                 (string)listeParametres[1])))
                    {
                        result.Data = nommage.GetObjetNomme();
                    }
                    else if (typeof(IObjetDonnee).IsAssignableFrom(tp))
                    {
                        IObjetDonnee objUniv = (IObjetDonnee)Activator.CreateInstance(tp, new object[] { contexteDonnee });
                        if (objUniv.ReadIfExistsUniversalId((string)listeParametres[1]))
                        {
                            result.Data = objUniv;
                        }
                    }
                    else
                    {
                        result.Data = null;
                    }
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Ejemplo n.º 22
0
        ////////////////////////////////////////////////////////////
        public override CResultAErreur Serialize(C2iSerializer serializer)
        {
            CResultAErreur result   = CResultAErreur.True;
            int            nVersion = GetNumVersion();

            result = serializer.TraiteVersion(ref nVersion);
            if (result)
            {
                result = base.Serialize(serializer);
            }
            if (!result)
            {
                return(result);
            }


            bool bHasElement;

            #region Version 0 : un seul élément
            if (nVersion == 0)
            {
                CObjetDonneeAIdNumerique objet = null;
                if (m_elementsAAgenda.Length > 0)
                {
                    objet = m_elementsAAgenda[0];
                }
                switch (serializer.Mode)
                {
                case ModeSerialisation.Ecriture:
                    bHasElement = objet != null;
                    serializer.TraiteBool(ref bHasElement);
                    if (bHasElement)
                    {
                        Type tp = objet.GetType();
                        serializer.TraiteType(ref tp);
                        int nId = objet.Id;
                        serializer.TraiteInt(ref nId);
                    }
                    break;

                case ModeSerialisation.Lecture:
                    bHasElement = false;
                    serializer.TraiteBool(ref bHasElement);
                    if (!bHasElement)
                    {
                        objet = null;
                    }
                    else
                    {
                        Type tp = null;
                        serializer.TraiteType(ref tp);
                        objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { m_contexte });
                        int nId = 0;
                        serializer.TraiteInt(ref nId);
                        if (!objet.ReadIfExists(nId))
                        {
                            objet = null;
                        }
                    }
                    if (objet == null)
                    {
                        m_elementsAAgenda = new CObjetDonneeAIdNumerique[0];
                    }
                    else
                    {
                        m_elementsAAgenda = new CObjetDonneeAIdNumerique[] { objet }
                    };
                    break;
                }
            }
            #endregion
            return(result);
        }
Ejemplo n.º 23
0
        //-----------------------------------------------------------------------
        private CResultAErreur TraiteModifiesFromSecondaire(CContexteDonnee ctxSecondaire)
        {
            CResultAErreur       result     = CResultAErreur.True;
            CUtilSynchronisation utilSync   = new CUtilSynchronisation(IdSession);
            int       nIdSyncSessionEnCours = utilSync.IdSyncSession;
            ArrayList lstTables             = ctxSecondaire.GetTablesOrderInsert();

            DataTable tableLogsSynchroFromSecondaire = ctxSecondaire.Tables[CEntreeLogSynchronisation.c_nomTable];

            if (tableLogsSynchroFromSecondaire == null)
            {
                result.EmpileErreur(I.T("Synchro table missing|20003"));
                return(result);
            }

            foreach (DataTable tableSource in lstTables)
            {
                Type tpObjet = CContexteDonnee.GetTypeForTable(tableSource.TableName);
                if (
                    tableSource.PrimaryKey.Length == 1 &&
                    m_mappeurTablesToClass.IsSynchronisable(tableSource.TableName) &&
                    tpObjet != null)
                {
                    DataTable tableDest  = GetTableSafe(tableSource.TableName);
                    string    strPrimKey = tableDest.PrimaryKey[0].ColumnName;
                    ArrayList lstRows    = new ArrayList(tableSource.Rows);
                    foreach (DataRow rowSource in lstRows)
                    {
                        //S'assure que la rowSource a bien été modifiée
                        if (rowSource.RowState == DataRowState.Modified)
                        {
                            DataRow rowDest = tableDest.Rows.Find(rowSource[strPrimKey]);
                            if (rowDest == null)
                            {
                                CObjetDonneeAIdNumerique objet = Activator.CreateInstance(tpObjet, new object[] { this }) as CObjetDonneeAIdNumerique;
                                if (objet != null)
                                {
                                    if (!objet.ReadIfExists((int)rowSource[strPrimKey]))
                                    {
                                        objet = null;
                                    }
                                    else
                                    {
                                        rowDest = objet.Row.Row;
                                    }
                                }
                            }
                            else
                            {
                                CObjetDonneeAIdNumerique objet = Activator.CreateInstance(tpObjet, new object[] { rowDest }) as CObjetDonneeAIdNumerique;
                                //S'assure de la lecture de la ligne
                                DataRow rowTmp = objet.Row.Row;
                            }

                            if (rowDest != null)//sinon, c'est bizarre, ça
                            //veut dire que la ligne aurait été supprimée dans la base principale
                            {
                                foreach (DataColumn col in tableSource.Columns)
                                {
                                    if (rowDest.Table.Columns.Contains(col.ColumnName) &&
                                        col.ColumnName != strPrimKey)
                                    {
                                        rowDest[col.ColumnName] = rowSource[col.ColumnName];
                                    }
                                }
                                rowDest[CSc2iDataConst.c_champIdSynchro] = nIdSyncSessionEnCours;
                            }
                        }
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 24
0
        //----------------------------------
        public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
        {
            CStructureTable structure = CStructureTable.GetStructure(vo.TypeElement);

            List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();

            lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
            List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();

            lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
            CResultAErreur           result = CResultAErreur.True;
            CObjetDonneeAIdNumerique objet  = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;

            if (!objet.ReadIfExists(vo.IdElement))
            {
                objet = null;
            }
            else
            {
                DesignationObjet = objet.DescriptionElement;
            }
            switch (vo.TypeOperation.Code)
            {
            case CTypeOperationSurObjet.TypeOperation.Ajout:
                if (objet != null && objet.IsValide())
                {
                    foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
                    {
                        string strNom = def.NomProprieteSansCleTypeChamp;
                        if (strNom != "IsDeleted" && strNom != "Id" &&
                            strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
                        {
                            bool bAdd = !def.IsReadOnly;
                            if (def.IsReadOnly)
                            {
                                //Si readonly mais a l'attribut ForceSetOnMacro, on l'ajoute quand même
                                PropertyInfo info = vo.TypeElement.GetProperty(strNom);
                                if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length != 0)
                                {
                                    bAdd = true;
                                }
                            }
                            if (bAdd)
                            {
                                CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
                                if (resultVal)
                                {
                                    object            data = resultVal.Data;
                                    CMacroObjetValeur mv   = new CMacroObjetValeur(this);
                                    mv.Champ = def;
                                    if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
                                    {
                                        AddValeur(mv);
                                    }
                                    else
                                    {
                                        result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", def.Nom,
                                                                                      DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
                                    }
                                }
                            }
                        }
                    }
                    if (objet is IObjetDonneeAChamps)
                    {
                        foreach (CRelationElementAChamp_ChampCustom rel in ((IObjetDonneeAChamps)objet).RelationsChampsCustom)
                        {
                            object data = rel.Valeur;
                            if (data != null)
                            {
                                CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == rel.ChampCustom.DbKey);
                                if (defCust != null)
                                {
                                    CMacroObjetValeur mv = new CMacroObjetValeur(this);
                                    mv.Champ = defCust;
                                    mv.Champ = defCust;
                                    if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
                                    {
                                        this.AddValeur(mv);
                                    }
                                    else
                                    {
                                        result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", rel.ChampCustom.Nom,
                                                                                      DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
                                    }
                                }
                            }
                        }
                    }
                }

                break;

            case CTypeOperationSurObjet.TypeOperation.Suppression:
                break;

            case CTypeOperationSurObjet.TypeOperation.Modification:
                CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
                foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
                {
                    CDefinitionProprieteDynamique def   = null;
                    IChampPourVersion             champ = valeur.Champ;
                    if (champ is CChampPourVersionInDb)
                    {
                        string          strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
                        CInfoChampTable infoChamp   = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
                        if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
                            infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
                            infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
                        {
                            string strNomPropriete = infoChamp.Propriete;
                            def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
                        }
                        if (def == null)
                        {
                            CInfoRelation relation = structureObjet.RelationsParentes.FirstOrDefault(i => i.ChampsFille.Length == 1 && i.ChampsFille[0] == strNomChamp);
                            if (relation != null)
                            {
                                def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == relation.Propriete);
                            }
                        }
                    }
                    else if (champ is CChampCustomPourVersion)
                    {
                        CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
                        if (champCustom != null)
                        {
                            def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
                                                                 ((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == champCustom.DbKey);
                        }
                    }
                    if (def != null)
                    {
                        bool bAdd = !def.IsReadOnly;
                        if (def.IsReadOnly)
                        {
                            //Si readonly mais a l'attribut TiagRelation, on l'ajoute quand même
                            PropertyInfo info = vo.TypeElement.GetProperty(def.NomProprieteSansCleTypeChamp);
                            if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length > 0)
                            {
                                bAdd = true;
                            }
                        }
                        if (bAdd)
                        {
                            CMacroObjetValeur mv = new CMacroObjetValeur(this);
                            mv.Champ = def;
                            object val = valeur.GetValeur();
                            if (val != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(def.TypeDonnee.TypeDotNetNatif) && valeur.TypeValeur == typeof(int))
                            {
                                CObjetDonneeAIdNumerique objetParent = Activator.CreateInstance(def.TypeDonnee.TypeDotNetNatif, new object[] { objet.ContexteDonnee }) as CObjetDonneeAIdNumerique;
                                if (objetParent.ReadIfExists((int)valeur.GetValeur()))
                                {
                                    val = objetParent;
                                }
                                else
                                {
                                    val = null;
                                }
                            }

                            if (!FillMacroValeurWithValue(mv, val, dicObjetToMacro))
                            {
                                result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of @2 in macro", valeur.NomChampConvivial,
                                                                              DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
                            }
                            else
                            {
                                AddValeur(mv);
                            }
                        }
                    }
                }
                break;
            }
            if (Valeurs.Count() == 0)
            {
                TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
            }
            return(result);
        }
Ejemplo n.º 25
0
        //--------------------------------------------------------------------------------------------------------------------
        public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
        {
            CResultAErreur   result   = CResultAErreur.True;
            IDataBaseCreator createur = connection.GetDataBaseCreator();
            string           strNomTableInContexte = CContexteDonnee.GetNomTableForType(m_type);
            string           strNomTableInDb       = CContexteDonnee.GetNomTableInDbForNomTable(strNomTableInContexte);

            createur.CreationOuUpdateTableFromType(m_type);
            string strChampIdObjet = m_strChampIdObjet;

            if (m_strChampIdObjet.StartsWith("#SQL#"))
            {
                strChampIdObjet = m_strChampIdObjet.Substring("#SQL#".Length);
            }
            CObjetServeur.ClearCacheSchemas();
            if (createur.ChampExists(strNomTableInDb, strChampIdObjet) &&
                createur.ChampExists(strNomTableInDb, m_strChampDbKey))
            {
                using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
                {
                    C2iRequeteAvancee requete = new C2iRequeteAvancee();
                    requete.TableInterrogee = strNomTableInDb;
                    CStructureTable structure = CStructureTable.GetStructure(m_type);

                    /*
                     * requete.ListeChamps.Add ( new C2iChampDeRequete (
                     *  "ID",
                     *  new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
                     *  typeof(int),
                     *  OperationsAgregation.None,
                     *  true ));*/
                    requete.ListeChamps.Add(new C2iChampDeRequete(
                                                "IDOBJET",
                                                new CSourceDeChampDeRequete(m_strChampIdObjet),
                                                typeof(int),
                                                OperationsAgregation.None,
                                                true));
                    if (m_typeObjetFixe == null)
                    {
                        requete.ListeChamps.Add(new C2iChampDeRequete(
                                                    "TYPEOBJET",
                                                    new CSourceDeChampDeRequete(m_strChampTypeObjet),
                                                    typeof(string),
                                                    OperationsAgregation.None,
                                                    true));
                    }
                    result = requete.ExecuteRequete(connection.IdSession);
                    if (!result)
                    {
                        return(result);
                    }
                    DataTable table = result.Data as DataTable;
                    Dictionary <int, int?> dicIdToIdObjet = new Dictionary <int, int?>();
                    string strFieldIdObjetInTable         = m_strChampIdObjet.Replace("#SQL#", "");
                    foreach (DataRow row in table.Rows)
                    {
                        object val    = row["IDOBJET"];
                        int?   nValId = val == DBNull.Value?null:(int?)val;
                        if (nValId != null && nValId >= 0)
                        {
                            CDbKey key = null;
                            Type   tp  = m_typeObjetFixe;
                            if (tp == null)//Type non fixe
                            {
                                string strType = (string)row["TYPEOBJET"];
                                tp = CActivatorSurChaine.GetType(strType);
                            }
                            if (tp != null)
                            {
                                CObjetDonneeAIdNumerique objPointe = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, ctx);
                                if (objPointe.ReadIfExists(nValId.Value))
                                {
                                    key = objPointe.DbKey;
                                }
                            }
                            if (key != null)
                            {
                                string strRequete = "Update " + strNomTableInDb + " set " +
                                                    m_strChampDbKey + "=" + connection.GetStringForRequete(key.StringValue) + " where " +
                                                    strFieldIdObjetInTable + "=" + nValId.Value;
                                if (m_typeObjetFixe == null)
                                {
                                    strRequete += " and " + m_strChampTypeObjet + "='" +
                                                  row["TYPEOBJET"].ToString() + "'";
                                }
                                connection.RunStatement(strRequete);
                            }
                        }
                    }
                }
                //Supprime le champ
                createur.DeleteChamp(strNomTableInDb, strChampIdObjet);
            }
            return(result);
        }
        //-------------------------------------------------------------------
        public virtual object GetValeur(DataRowVersion version)
        {
            if (ChampCustom == null)
            {
                return("");
            }
            if (IsNull)
            {
                return(null);
            }
            try
            {
                switch (ChampCustom.TypeDonneeChamp.TypeDonnee)
                {
                case TypeDonnee.tBool:
                    return((bool)Row[c_champValeurBool, version]);

                case TypeDonnee.tDate:
                    return((DateTime)Row[c_champValeurDate, version]);

                case TypeDonnee.tDouble:
                    if (ChampCustom.ClasseUnite != null)
                    {
                        string strFormat = (string)Row[c_champValeurString, version];
                        if (strFormat == null || strFormat.Trim().Length == 0)
                        {
                            strFormat = ChampCustom.FormatAffichageUnite;
                            if (strFormat.Trim().Length == 0)
                            {
                            }
                        }
                        if (strFormat == null)
                        {
                            strFormat = "";
                        }
                        return(new CValeurUnite((double)Row[c_champValeurDouble],
                                                ChampCustom.ClasseUnite.UniteBase,
                                                strFormat));
                    }
                    return((double)Row[c_champValeurDouble, version]);

                case TypeDonnee.tEntier:
                    return((int)Row[c_champValeurInt, version]);

                case TypeDonnee.tString:
                    return((string)Row[c_champValeurString, version]);

                case TypeDonnee.tObjetDonneeAIdNumeriqueAuto:
                {
                    string strType = (string)Row[c_champValeurString, version];
                    int    nId     = (int)Row[c_champValeurInt, version];
                    Type   tp      = CActivatorSurChaine.GetType(strType, true);
                    if (tp != null)
                    {
                        CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { ContexteDonnee });
                        if (objet.ReadIfExists(nId))
                        {
                            return(objet);
                        }
                    }
                    return(null);
                }
                }
            }
            catch
            {
            }
            return(ChampCustom.TypeDonneeChamp.ObjectToType("", ContexteDonnee));
        }
Ejemplo n.º 27
0
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur  MyExecute(CContexteExecutionAction contexte)
        {
            CResultAErreur result = CResultAErreur.True;

            List <Type> lstTypesAVerifier = new List <Type>();

            //Trouve tous les types héritant de CMappableTimos
            foreach (Assembly ass in sc2i.common.CGestionnaireAssemblies.GetAssemblies())
            {
                foreach (Type tp in ass.GetTypes())
                {
                    if (typeof(IObjetSPVAvecObjetTimos).IsAssignableFrom(tp))
                    {
                        lstTypesAVerifier.Add(tp);
                    }
                }
            }
            List <string> lstTablesDansOrdre = new List <string>();

            using (CContexteDonnee ctxTmp = new CContexteDonnee(contexte.IdSession, true, false))
            {
                foreach (Type tp in lstTypesAVerifier)
                {
                    string strTable = CContexteDonnee.GetNomTableForType(tp);
                    if (strTable != null)
                    {
                        ctxTmp.GetTableSafe(strTable);
                    }
                }
                foreach (DataTable table in ctxTmp.GetTablesOrderInsert())
                {
                    lstTablesDansOrdre.Add(table.TableName);
                }
            }
            foreach (string strNomTable in lstTablesDansOrdre)
            {
                Type   tp       = CContexteDonnee.GetTypeForTable(strNomTable);
                Type   tpParent = tp;
                Type[] generics = new Type[0];
                while (tpParent != null && generics.Length == 0)
                {
                    if (tpParent.IsGenericType && tpParent.GetGenericTypeDefinition() == typeof(CMappableAvecTimos <,>))
                    {
                        generics = tpParent.GetGenericArguments();
                    }
                    tpParent = tpParent.BaseType;
                }
                if (generics.Length == 0)
                {
                    continue;
                }

                IObjetSPVAvecObjetTimos obj = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as IObjetSPVAvecObjetTimos;
                Type typeTimos = obj.GetTypeObjetsTimos();
                //Lit tous les objets TIMOS
                CListeObjetsDonnees lstObjetsTimos = new CListeObjetsDonnees(contexte.ContexteDonnee, typeTimos);
                lstObjetsTimos.AssureLectureFaite();
                CListeObjetsDonnees lstObjetsSpv = new CListeObjetsDonnees(contexte.ContexteDonnee, obj.GetType());
                lstObjetsSpv.AssureLectureFaite();
                string strIdObjetTimosInObjetSpv = obj.GetChampIdObjetTimos();
                Type   tpMappable = typeof(CMappeurTimos <,>).MakeGenericType(generics);
                IMappeurTimosNonGenerique mappeur = Activator.CreateInstance(tpMappable) as IMappeurTimosNonGenerique;
                foreach (CObjetDonneeAIdNumerique objTimos in (CObjetDonneeAIdNumerique[])lstObjetsTimos.ToArray(typeof(CObjetDonneeAIdNumerique)))
                {
                    CObjetDonneeAIdNumerique objSpv = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as CObjetDonneeAIdNumerique;
                    if (!objSpv.ReadIfExists(new CFiltreData(strIdObjetTimosInObjetSpv + "=@1",
                                                             objTimos.Id), false))
                    {
                        mappeur.GetObjetSpvFromObjetTimosAvecCreationSansGenerique(objTimos);
                    }
                }
            }
            return(result);
        }