コード例 #1
0
        /// //////////////////////////////////////////
        public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                //TESTDBKEYOK
                CContexteDonnee contexte = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
                CDbKey          key      = null;
                if (contexte != null)
                {
                    key = CSessionClient.GetSessionForIdSession(contexte.IdSession).GetInfoUtilisateur().KeyUtilisateur;
                }
                else
                {
                    key = CSessionClient.GetSessionUnique().GetInfoUtilisateur().KeyUtilisateur;
                }
                result.Data = null;
                if (key != null)
                {
                    CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());
                    if (user.ReadIfExists(key))
                    {
                        result.Data = user.Id;
                    }
                }
            }
            catch
            {
                result.Data = -1;
            }
            return(result);
        }
コード例 #2
0
        /// ////////////////////////////////////////
        public override CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            result = base.Serialize(serializer);
            if (!result)
            {
                return(result);
            }
            if (nVersion < 1)
            {
                //TESTDBKEYOK
                serializer.ReadDbKeyFromOldId(ref m_dbKeyChamp, typeof(CChampCustom));
                CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
                if (champ.ReadIfExists(m_dbKeyChamp))
                {
                    //Convertit le nom de propriété avec les DbKey
                    //ne pas appeller SetNomProprieteSansCleTypeChamp(GetKeyChamp()) car pour les filtres,
                    //le nom de propriété peut contenir un chemin
                    ConvertNomProprieteFromIdToDbKey();
                }
            }
            else
            {
                //TESTDBKEYOK
                serializer.TraiteDbKey(ref m_dbKeyChamp);
            }
            return(result);
        }
コード例 #3
0
        //----------------------------------------------------------------------------------
        public static CReferenceTypeForm[] GetReferencesTypeToEdit(Type tpElement)
        {
            List <CReferenceTypeForm> lstRefs = new List <CReferenceTypeForm>();

            if (tpElement == null)
            {
                return(lstRefs.ToArray());
            }
            foreach (Type tp in GetListeTypeFormToEdit(tpElement))
            {
                lstRefs.Add(new CReferenceTypeFormBuiltIn(tp));
            }

            //Charge les formulaires
            CListeObjetsDonnees listeFormulaires = new CListeObjetsDonnees(CContexteDonneeSysteme.GetInstance(), typeof(CFormulaire));

            listeFormulaires.Filtre = new CFiltreData(
                CFormulaire.c_champTypeElementEdite + " = @1 AND " +
                CFormulaire.c_champCodeRole + " is null",
                tpElement.ToString());
            foreach (CFormulaire formulaire in listeFormulaires)
            {
                lstRefs.Add(new CReferenceTypeFormDynamic(formulaire));
            }
            return(lstRefs.ToArray());
        }
コード例 #4
0
        public void AddProprietesAccedees(
            CArbreDefinitionsDynamiques arbre,
            Type typeSource,
            string strPropriete)
        {
            //TESTDBKEYOK
            CDbKey key = CDbKey.CreateFromStringValue(strPropriete);

            /*int nIdChamp = -1;
             *          try
             *          {
             *                  nIdChamp = Int32.Parse ( strPropriete );
             *          }
             *          catch
             *          {
             *          }*/
            CChampCalcule champCalcule = new CChampCalcule(CContexteDonneeSysteme.GetInstance());
            C2iExpression formule      = null;

            if (champCalcule.ReadIfExists(key))
            {
                formule = champCalcule.Formule;
                formule.GetArbreProprietesAccedees(arbre);
                CDefinitionProprieteDynamiqueChampCalcule.DetailleSousArbres(arbre, CContexteDonneeSysteme.GetInstance());
            }
        }
コード例 #5
0
        public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
        {
            List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();

            if (objet == null)
            {
                return(lstProps.ToArray());
            }
            Type tp = objet.TypeAnalyse;

            if (tp == null)
            {
                return(lstProps.ToArray());
            }

            if (!C2iFactory.IsInit())
            {
                return(lstProps.ToArray());
            }

            CContexteDonnee     contexte = CContexteDonneeSysteme.GetInstance();
            CListeObjetsDonnees liste    = new CListeObjetsDonnees(contexte, typeof(CSmartField));

            liste.Filtre = new CFiltreData(CSmartField.c_champTypeCible + "=@1", tp.ToString());
            foreach (CSmartField champ in liste)
            {
                CDefinitionProprieteDynamiqueSmartField def = new CDefinitionProprieteDynamiqueSmartField(champ);
                def.HasSubProperties = CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(def.TypeDonnee.TypeDotNetNatif);
                def.Rubrique         = champ.Categorie;
                lstProps.Add(def);
            }
            return(lstProps.ToArray());
        }
コード例 #6
0
        //--------------------------------------------------------------
        private void CFormEditeUniteInDb_Load(object sender, EventArgs e)
        {
            CWin32Traducteur.Translate(this);

            if (m_unite == null)
            {
                m_unite = new CUniteInDb(CContexteDonneeSysteme.GetInstance());
                m_unite.CreateNew();
                m_bIsNewUnite = true;
            }
            else
            {
                m_unite.BeginEdit();
                m_bIsNewUnite = false;
            }

            m_cmbClasse.ListDonnees       = CGestionnaireUnites.Classes;
            m_cmbClasse.ProprieteAffichee = "Libelle";
            m_cmbClasse.SelectedValue     = m_unite.Classe;

            m_txtIdUnite.Text                  = m_unite.GlobalId;
            m_txtLibellCourtUnite.Text         = m_unite.Libelle;
            m_txtLibelleLongUnite.Text         = m_unite.LibelleLong;
            m_txtFacteurConversion.DoubleValue = m_unite.FacteurVersBase;
            m_txtOffsetConversion.DoubleValue  = m_unite.OffsetVersBase;
            RefreshFormule();
        }
コード例 #7
0
        //-------------------------------------------------------
        private void InitChamps()
        {
            CFiltreData filtre = new CFiltreData(CProcessInDb.c_champTypeCible + "=@1",
                                                 typeof(CEtapeWorkflow).ToString());

            m_txtSelectProcess.Init(typeof(CProcessInDb),
                                    filtre,
                                    "Libelle",
                                    true);
            if (m_blocProcess.DbKeyProcess != null)
            {
                CProcessInDb process = new CProcessInDb(CContexteDonneeSysteme.GetInstance());
                if (process.ReadIfExists(m_blocProcess.DbKeyProcess))
                {
                    m_txtSelectProcess.ElementSelectionne = process;
                }
            }
            m_process = m_blocProcess.Process;
            m_txtInstructions.Text   = m_blocProcess.Instructions;
            m_chkManualStart.Checked = m_blocProcess.DemarrageManuel;
            CParametresInitialisationEtape parametres = m_blocProcess.TypeEtape != null ? m_blocProcess.TypeEtape.ParametresInitialisation : new CParametresInitialisationEtape();

            m_panelAffectations.Init(parametres);
            m_chkUtiliserSortieProcessCommeCodeRetour.Checked = m_blocProcess.UtiliserLaValeurDeSortieDeProcessCommeCodeRetour;

            UpdateVisuProcess();
        }
コード例 #8
0
        private void CControlActionReleve_Load(object sender, EventArgs e)
        {
            //Cherche les champs relevé
            CListeObjetsDonnees lst = CChampCustom.GetListeChampsForRole(CContexteDonneeSysteme.GetInstance(), CReleveEquipement.c_roleChampCustom);

            if (lst.Count == 0)
            {
                m_panelReleve.Height   = m_lblSerialReleve.Height;
                m_panelOriginal.Height = m_lblSerialDB.Height;
                Height = m_panelReleve.Height + m_panelOriginal.Height;
                m_panelChampsOriginaux.Visible = false;
                m_panelChampsReleve.Visible    = false;
            }
            else
            {
                foreach (CChampCustom champ in lst)
                {
                    CControleForCustomFieldReleve ctrl = new CControleForCustomFieldReleve();
                    ctrl.Init(champ);
                    m_panelChampsReleve.Controls.Add(ctrl);
                    ctrl.Dock            = DockStyle.Left;
                    ctrl.LockEdition     = true;
                    ctrl.OnValueChanged += new EventHandler(ctrlCustom_OnValueChanged);

                    ctrl = new CControleForCustomFieldReleve();
                    ctrl.Init(champ);
                    m_panelChampsOriginaux.Controls.Add(ctrl);
                    ctrl.Dock        = DockStyle.Left;
                    ctrl.LockEdition = true;
                }
                m_panelChampsOriginaux.Visible = true;
                m_panelChampsReleve.Visible    = true;
            }
        }
コード例 #9
0
        public void Init(CProcess process, Type typeObjet, CActionImportFromTableRow.CMappageColonne mappage)
        {
            m_mappage = mappage;
            CColonneTableParametrable col = new CColonneTableParametrable(CContexteDonneeSysteme.GetInstance());

            col.ReadIfExists(mappage.IdColonne);
            m_lblColonne.Text = col.Libelle;
            Type tp = col.TypeDonneeChamp.TypeDotNetAssocie;
            List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>();

            foreach (CDefinitionProprieteDynamique def in new CFournisseurPropDynStd(false).GetDefinitionsChamps(typeObjet))
            {
                Type defType = def.TypeDonnee.TypeDotNetNatif;
                if (defType.IsGenericType && defType.GetGenericTypeDefinition() == typeof(Nullable <>))
                {
                    defType = defType.GetGenericArguments()[0];
                }
                if (defType == tp && !def.TypeDonnee.IsArrayOfTypeNatif)
                {
                    lst.Add(def);
                }
            }

            m_cmbChamp.ListDonnees       = lst;
            m_cmbChamp.ProprieteAffichee = "Nom";

            m_cmbChamp.SelectedValue = mappage.ProprieteCible;
            m_txtFormuleCondition.Init(process, typeof(CProcess));
            m_txtFormuleCondition.Formule = mappage.FormuleCondition;
        }
コード例 #10
0
        //-----------------------------------------------------------------------------
        public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
        {
            CResultAErreur  result    = CResultAErreur.True;
            CContexteDonnee ctxDonnee = null;

            if (ctx.ObjetSource is IObjetAContexteDonnee)
            {
                ctxDonnee = ((IObjetAContexteDonnee)ctx.ObjetSource).ContexteDonnee;
            }
            if (ctxDonnee == null)
            {
                ctxDonnee = ctx.GetObjetAttache(typeof(CContexteDonnee)) as CContexteDonnee;
            }
            if (ctxDonnee == null)
            {
                ctxDonnee = CContexteDonneeSysteme.GetInstance();
            }
            CNommageEntite nommage = new CNommageEntite(ctxDonnee);

            //TESTDBKEYOK
            if (nommage.ReadIfExists(m_keyNommageEntite)) //&& nommage.NomFort == m_strNom)
            {
                result.Data = nommage.GetObjetNomme();
            }
            else if (nommage.ReadIfExists(new CFiltreData(CNommageEntite.c_champNomFort + "=@1",
                                                          m_strNom)))
            {
                result.Data = nommage.GetObjetNomme();
            }
            return(result);
        }
コード例 #11
0
 //----------------------------------------------
 public void ChercheObjet(object objetCherche, CResultatRequeteRechercheObjet resultat)
 {
     if (objetCherche is CDefinitionProprieteDynamique)
     {
         CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
         CListeObjetDonneeGenerique <CFormulaire> lstFormulaires = new CListeObjetDonneeGenerique <CFormulaire>(contexte);
         foreach (CFormulaire form in lstFormulaires)
         {
             C2iWnd wnd = form.Formulaire;
             try
             {
                 if (wnd != null)
                 {
                     resultat.PushChemin(new CNoeudRechercheObjet_ObjetDonnee(form));
                     wnd.ChercheObjet(objetCherche, resultat);
                     resultat.PopChemin();
                 }
             }
             catch
             {
                 System.Console.WriteLine("Erreur recherche formulaire " + form.Libelle);
             }
         }
     }
 }
コード例 #12
0
        //----------------------------------------------------
        public void  ChercheObjet(object objetCherche, CResultatRequeteRechercheObjet resultat)
        {
            CContexteDonnee ctx = CContexteDonneeSysteme.GetInstance();
            CListeObjetDonneeGenerique <CProcessInDb> lstProcess = new CListeObjetDonneeGenerique <CProcessInDb>(ctx);

            foreach (CProcessInDb processInDb in lstProcess)
            {
                try
                {
                    processInDb.RechercheObjet(objetCherche, resultat);
                }
                catch { }
            }
            CListeObjetDonneeGenerique <CEvenement> lstEvents = new CListeObjetDonneeGenerique <CEvenement>(ctx);

            foreach (CEvenement evt in lstEvents)
            {
                try
                {
                    evt.RechercheObjet(objetCherche, resultat);
                }
                catch
                {
                }
            }
        }
コード例 #13
0
        public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
        {
            List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();

            if (objet == null)
            {
                return(lstProps.ToArray());
            }
            Type tp = objet.TypeAnalyse;

            if (tp == null)
            {
                return(lstProps.ToArray());
            }
            if (!C2iFactory.IsInit())
            {
                return(lstProps.ToArray());
            }

            CContexteDonnee     contexte     = CContexteDonneeSysteme.GetInstance();
            CListeObjetsDonnees listeEntites = new CListeObjetsDonnees(contexte, typeof(CListeEntites));

            listeEntites.Filtre = new CFiltreData(
                CListeEntites.c_champTypeElementSourceDeRecherche + "=@1",
                tp.ToString());
            foreach (CListeEntites liste in listeEntites)
            {
                CDefinitionProprieteDynamiqueListeEntites def = new CDefinitionProprieteDynamiqueListeEntites(liste);
                def.Rubrique = I.T("Lists|60");
                lstProps.Add(def);
            }
            return(lstProps.ToArray());
        }
コード例 #14
0
        //---------------------------------------
        private void InitFiltres()
        {
            CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());

            if (typeDonnee == null)
            {
                m_listeFiltresDeBase.Clear();
                m_listeFiltresUser.Clear();
                return;
            }
            CParametreDonneeCumulee   parametre   = typeDonnee.Parametre;
            Dictionary <string, bool> dicToDelete = new Dictionary <string, bool>();

            foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase)
            {
                dicToDelete[filtre.ChampAssocie] = true;
            }
            foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser)
            {
                dicToDelete[filtre.ChampAssocie] = true;
            }
            foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
            {
                if (cle.TypeLie != null)
                {
                    CFiltreDonneePrecalculee filtre = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
                    if (filtre != null)
                    {
                        dicToDelete[filtre.ChampAssocie] = false;
                    }
                    if (m_listeFiltresDeBase.Count(f => f.ChampAssocie == cle.Champ) == 0)
                    {
                        CFiltreDynamique filtreTmp = new CFiltreDynamique();
                        filtreTmp.TypeElements = cle.TypeLie;
                        m_listeFiltresDeBase.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
                    }
                    if (m_listeFiltresUser.Count(f => f.ChampAssocie == cle.Champ) == 0)
                    {
                        CFiltreDynamique filtreTmp = new CFiltreDynamique();
                        filtreTmp.TypeElements = cle.TypeLie;
                        m_listeFiltresUser.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
                    }
                }
            }
            foreach (KeyValuePair <string, bool> kv in dicToDelete)
            {
                if (kv.Value)
                {
                    foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
                    {
                        m_listeFiltresUser.Remove(filtre);
                    }
                    foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
                    {
                        m_listeFiltresDeBase.Remove(filtre);
                    }
                }
            }
        }
コード例 #15
0
        //---------------------------------------------------------------------
        private void Init(
            CConfigWndMapView config,
            CObjetPourSousProprietes objetEdite,
            IFournisseurProprietesDynamiques fournisseurProprietes)
        {
            m_configEditee          = config;
            m_fournisseurProprietes = fournisseurProprietes;
            m_objetEdite            = objetEdite;
            m_txtFormuleLatitude.Init(FournisseurProprietes, ObjetEdite);
            m_txtFormuleLongitude.Init(FournisseurProprietes, ObjetEdite);
            m_txtFormuleZoom.Init(FournisseurProprietes, ObjetEdite);
            m_txtFormuleKeepState.Init(FournisseurProprietes, ObjetEdite);

            m_txtFormuleLatitude.Formule  = m_configEditee.FormuleLatitude;
            m_txtFormuleLongitude.Formule = m_configEditee.FormuleLongitude;
            m_txtFormuleZoom.Formule      = m_configEditee.FormuleZoomFactor;
            m_txtFormuleKeepState.Formule = m_configEditee.FormulePreserveStateKey;

            m_chkPreserveCenter.Checked  = m_configEditee.PreserveCenter;
            m_chkPreserveLayers.Checked  = m_configEditee.PreserveLayers;
            m_chkPreserveMapMode.Checked = m_configEditee.PreserveMapMode;
            m_chkPreserveZoom.Checked    = m_configEditee.PreserveZoom;


            m_rbtnViewMap.Checked = config.MapMode == EWndMapMode.Map;
            m_rbtnAerial.Checked  = config.MapMode == EWndMapMode.Aerial;
            m_rbtnHybride.Checked = config.MapMode == EWndMapMode.Hybrid;

            CListeObjetDonneeGenerique <CConfigMapDatabase> lstConfigs = CConfigMapDatabase.GetConfigsFor(
                CContexteDonneeSysteme.GetInstance(),
                objetEdite);

            m_wndListeCalques.BeginUpdate();
            foreach (CConfigMapDatabase configDB in lstConfigs)
            {
                bool bIsChecked = false;
                //TESTDBKEYOK
                CConfigCalqueMap configCalque = m_configEditee.GetConfigForCalque(configDB.DbKey);
                if (configCalque == null)
                {
                    configCalque = new CConfigCalqueMap();
                    //TESTDBKEYOK
                    configCalque.KeyConfigMapDatabase = configDB.DbKey;
                }
                else
                {
                    bIsChecked = true;
                }
                configCalque.generator = configDB.MapGenerator;
                ListViewItem item = new ListViewItem(configDB.Libelle);
                item.Tag     = configCalque;
                item.Checked = bIsChecked;
                m_wndListeCalques.Items.Add(item);
            }
            m_wndListeCalques.EndUpdate();
        }
コード例 #16
0
        //-----------------------------------------------------
        public CResultAErreur Serialize(C2iSerializer serializer)
        {
            int            nVersion = GetNumVersion();
            CResultAErreur result   = serializer.TraiteVersion(ref nVersion);

            if (!result)
            {
                return(result);
            }
            switch (serializer.Mode)
            {
            case ModeSerialisation.Ecriture:
                //TESTDBKEYTODO : remplacer IdChamp par DbKey
                CDbKey dbKeyChampWrite = ChampCustom != null ? ChampCustom.DbKey : null;
                if (nVersion < 1)
                {
                    serializer.ReadDbKeyFromOldId(ref dbKeyChampWrite, typeof(CChampCustom));
                }
                else
                {
                    serializer.TraiteDbKey(ref dbKeyChampWrite);
                }
                break;

            case ModeSerialisation.Lecture:
                CContexteDonnee contexte = serializer.GetObjetAttache(typeof(CContexteDonnee)) as CContexteDonnee;
                if (contexte == null)
                {
                    contexte = CContexteDonneeSysteme.GetInstance();
                }
                //TESTDBKEYTODO : remplacer IdChamp par DbKey
                CDbKey dbKeyChampRead = null;
                if (nVersion < 1)
                {
                    serializer.ReadDbKeyFromOldId(ref dbKeyChampRead, typeof(CChampCustom));
                }
                else
                {
                    serializer.TraiteDbKey(ref dbKeyChampRead);
                }
                if (dbKeyChampRead == null)
                {
                    m_champ = null;
                }
                else
                {
                    m_champ = new CChampCustom(contexte);
                    if (!m_champ.ReadIfExists(dbKeyChampRead))
                    {
                        m_champ = null;
                    }
                }
                break;
            }
            return(result);
        }
コード例 #17
0
        public CFonctionDynamique GetFonctionSupplementaire(string strIdFonction)
        {
            CFonctionDynamiqueInDb f = new CFonctionDynamiqueInDb(CContexteDonneeSysteme.GetInstance());

            if (f.ReadIfExistsUniversalId(strIdFonction))
            {
                return(f.Fonction);
            }
            return(null);
        }
コード例 #18
0
        //------------------------------------------------------------
        public int GetIdUtilisateurFromKey(CDbKey key)
        {
            CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());

            if (user.ReadIfExists(key))
            {
                return(user.Id);
            }
            return(-1);
        }
コード例 #19
0
        //------------------------------------------------------------
        public CDbKey GetKeyUtilisateurFromId(int nId)
        {
            CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());

            if (user.ReadIfExists(nId))
            {
                return(user.DbKey);
            }
            return(null);
        }
コード例 #20
0
        public static int GetIdFromDbKey(CDbKey dbKey)
        {
            CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());

            if (champ.ReadIfExists(dbKey))
            {
                return(champ.Id);
            }

            return(-1);
        }
コード例 #21
0
        //-------------------------------------------------------------------------
        private void FillListeChamps(CRestrictionUtilisateurSurType restriction)
        {
            m_wndListeChamps.BeginUpdate();
            m_wndListeChamps.Items.Clear();
            CInfoStructureDynamique info     = CInfoStructureDynamique.GetStructure(restriction.TypeAssocie, 0);
            List <ListViewItem>     lstItems = new List <ListViewItem>();

            foreach (CInfoChampDynamique champ in info.Champs)
            {
                string strTmp = "";
                CDefinitionProprieteDynamique def = CConvertisseurInfoStructureDynamiqueToDefinitionChamp.GetDefinitionProprieteDynamique(champ.NomPropriete, ref strTmp);
                //Uniquement les propriétés "classiques"
                //voir CTimosApp.GetStructure
                if (def != null && typeof(CDefinitionProprieteDynamiqueDotNet).IsAssignableFrom(def.GetType()))
                {
                    ListViewItem item = new ListViewItem();
                    item.Text       = champ.NomChamp;
                    item.Tag        = def.NomProprieteSansCleTypeChamp;
                    item.ImageIndex = GetIndexImage(restriction.GetRestriction(def.NomProprieteSansCleTypeChamp));
                    lstItems.Add(item);
                }
            }
            lstItems.Sort((x, y) => x.Text.CompareTo(y.Text));
            if (typeof(IElementAChamps).IsAssignableFrom(restriction.TypeAssocie))
            {
                CRoleChampCustom role = CRoleChampCustom.GetRoleForType(restriction.TypeAssocie);
                if (role != null)
                {
                    CListeObjetsDonnees listeChampsCustom = CChampCustom.GetListeChampsForRole(CContexteDonneeSysteme.GetInstance(), role.CodeRole);
                    foreach (CChampCustom champ in listeChampsCustom)
                    {
                        ListViewItem item = new ListViewItem();
                        item.Text       = champ.Nom;
                        item.Tag        = champ.CleRestriction;
                        item.ImageIndex = GetIndexImage(restriction.GetRestriction(champ.CleRestriction));
                        lstItems.Add(item);
                    }
                    lstItems.Sort((x, y) => x.Text.CompareTo(y.Text));

                    CListeObjetsDonnees listeFormulaires = new CListeObjetsDonnees(CContexteDonneeSysteme.GetInstance(), typeof(CFormulaire));
                    listeFormulaires.Filtre = CFormulaire.GetFiltreFormulairesForRole(role.CodeRole);
                    foreach (CFormulaire formulaire in listeFormulaires)
                    {
                        ListViewItem item = new ListViewItem();
                        item.Text       = "{" + formulaire.Libelle + "}";
                        item.Tag        = formulaire.CleRestriction;
                        item.ImageIndex = GetIndexImage(restriction.GetRestriction(formulaire.CleRestriction));
                        lstItems.Add(item);
                    }
                }
            }
            m_wndListeChamps.Items.AddRange(lstItems.ToArray());
            m_wndListeChamps.EndUpdate();
        }
コード例 #22
0
ファイル: CSpvParamSysteme.cs プロジェクト: ykebaili/Timos
        ///////////////////////////////////////////////////////////////
        /// <summary>
        /// récupère un paramètre système
        /// </summary>
        /// <param name="strParametre"></param>
        /// <returns></returns>
        public static string GetParametreSysteme(string strParametre)
        {
            CSpvParamSysteme parametre = new CSpvParamSysteme(CContexteDonneeSysteme.GetInstance());

            if (parametre.ReadIfExists(new CFiltreData(c_champPARAM_VALEUR + " like @1",
                                                       strParametre + "=%")))
            {
                return(parametre.Valeur);
            }
            return("");
        }
コード例 #23
0
 public static object GetValeurChamp(this IElementAChamps elt, CDbKey key, DataRowVersion version)
 {
     if (key != null)
     {
         CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
         if (champ.ReadIfExists(key))
         {
             return(elt.GetValeurChamp(champ.Id, version));
         }
     }
     return(null);
 }
        //------------------------------------------------------------
        public override CResultAErreur GetValue(object objet, string strPropriete)
        {
            CResultAErreur result = CResultAErreur.True;

            result.Data = null;
            string strIdChamp     = null;
            bool   bEntiteToChamp = false;

            if (

                /*Pour compatibilité, avant modifs de décembre 2015, le nom du champ était en fait le même qu'une propriété champ custom.
                 * En décembre 2015, ajout de la possiblité de retourner les valeurs display de champ custom dans les requêtes,
                 * ce qui a changé le nom de la propriétés
                 * */
                CInfoRelationEntiteToValeurChampCustom.DecomposeNomPropriete(strPropriete, ref strIdChamp) ||
                /*fin pour compatiblité*/
                CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bEntiteToChamp))
            {
                IElementAChamps eltAChamps = objet as IElementAChamps;
                if (eltAChamps == null)
                {
                    return(result);
                }
                result.Data = eltAChamps.GetValeurChamp(strIdChamp);
                CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
                if (result.Data != null && champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
                {
                    if (!champ.IsChoixParmis())
                    {
                        result.Data = result.Data.ToString();
                    }
                    else
                    {
                        foreach (CValeurChampCustom valeur in champ.ListeValeurs)
                        {
                            if (valeur.Value.Equals(result.Data))
                            {
                                result.Data = valeur.Display;
                                return(result);
                            }
                        }
                    }
                }
            }
            else if (CInfoRelationEValeurChampCustomToDisplay.DecomposeNomPropriete(strPropriete, ref strIdChamp))
            {
                //Rien de spécial, il s'agit de la navigation vers la valeur du champ qui a déjà été reprise par le composant filtre to champ entité
                //car la propriété complète d'un definitionDisplayValue est donnée par GetKeyChamp qui ajoute un composant Element->ValeurChamp + ValeurChamp->Display value
                result.Data = objet;
            }

            return(result);
        }
コード例 #25
0
 private void AssureRecepteurs()
 {
     if (m_recepteurAjout == null)
     {
         m_recepteurAjout = new CRecepteurNotification(CContexteDonneeSysteme.GetInstance().IdSession, typeof(CDonneeNotificationAjoutEnregistrement));
         m_recepteurAjout.OnReceiveNotification += new NotificationEventHandler(m_recepteurAjout_OnReceiveNotification);
     }
     if (m_recepteurModification == null)
     {
         m_recepteurModification = new CRecepteurNotification(CContexteDonneeSysteme.GetInstance().IdSession, typeof(CDonneeNotificationModificationContexteDonnee));
         m_recepteurModification.OnReceiveNotification += new NotificationEventHandler(m_recepteurModification_OnReceiveNotification);
     }
 }
コード例 #26
0
        //-----------------------------------------------------------------------
        public static CPreferenceFiltreRapide GetPreferenceForType(Type typeElements)
        {
            CContexteDonnee         contexte   = CContexteDonneeSysteme.GetInstance();
            CPreferenceFiltreRapide prefFiltre = new CPreferenceFiltreRapide(contexte);

            if (prefFiltre.ReadIfExists(new CFiltreData(
                                            CPreferenceFiltreRapide.c_champTypeObjets + "=@1",
                                            typeElements.ToString())))
            {
                return(prefFiltre);
            }
            return(null);
        }
コード例 #27
0
        //-------------------------------------------------------
        protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
        {
            CEasyQuery     query  = Query;
            CResultAErreur result = CResultAErreur.True;

            if (result && TypeSource == null)
            {
                result.EmpileErreur(I.T("###Table object must be specified |"));
            }
            if (query == null || sources == null)
            {
                result.EmpileErreur(I.T("###Query needs a source to provide datas|"));
            }

            C2iRequeteAvancee requete = new C2iRequeteAvancee();

            requete.TableInterrogee = CContexteDonnee.GetNomTableForType(TypeSource);

            result = FiltreDynamique.GetFiltreData();
            if (!result)
            {
                return(result);
            }
            if (result.Data is CFiltreData)
            {
                requete.FiltreAAppliquer = result.Data as CFiltreData;
            }
            foreach (IColumnDeEasyQuery col in Columns)
            {
                CColumnDeEasyQueryChampDeRequete colR = col as CColumnDeEasyQueryChampDeRequete;
                requete.ListeChamps.Add(colR);
            }
            DataTable table = null;

            if (requete.ListeChamps.Count > 0)
            {
                result = requete.ExecuteRequete(CContexteDonneeSysteme.GetInstance().IdSession);
                if (!result)
                {
                    result.EmpileErreur(I.T("###Error on table @1|"));
                    return(result);
                }
                table = result.Data as DataTable;
            }
            else
            {
                table = new DataTable();
            }
            table.TableName = NomFinal;
            return(result);
        }
コード例 #28
0
 //---------------------------------------------------------
 private CFormulaire GetFormulaire(C2iWndReference info)
 {
     try
     {
         int         nId  = Int32.Parse(info.WndKey);
         CFormulaire form = new CFormulaire(CContexteDonneeSysteme.GetInstance());
         if (form.ReadIfExists(nId))
         {
             return(form);
         }
     }
     catch { }
     return(null);
 }
コード例 #29
0
        /// ///////////////////////////////////////////////////////////
        private static void UpdateTableDonneesCumulees()
        {
            int nIdSession = 0;

            try
            {
                nIdSession = CSessionClient.GetSessionUnique().IdSession;
            }
            catch
            { }
            if (m_recepteurNotificationModifTypeDonneeCumulee == null)
            {
                m_recepteurNotificationModifTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationModificationContexteDonnee));
                m_recepteurNotificationModifTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
            }
            if (m_recepteurNotificationAjoutTypeDonneeCumulee == null)
            {
                m_recepteurNotificationAjoutTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationAjoutEnregistrement));
                m_recepteurNotificationAjoutTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
            }
            if (m_tableTypeToDonneesCumulees != null)
            {
                m_tableTypeToDonneesCumulees.Clear();
            }
            else
            {
                m_tableTypeToDonneesCumulees = new Dictionary <Type, List <CTypeDonneeCumulee> >();
            }
            CContexteDonnee     contexte = CContexteDonneeSysteme.GetInstance();
            CListeObjetsDonnees liste    = new CListeObjetsDonnees(contexte, typeof(CTypeDonneeCumulee));

            foreach (CTypeDonneeCumulee type in liste)
            {
                CParametreDonneeCumulee parametre = type.Parametre;
                foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
                {
                    if (cle.TypeLie != null)
                    {
                        List <CTypeDonneeCumulee> lst = null;
                        if (!m_tableTypeToDonneesCumulees.TryGetValue(cle.TypeLie, out lst))
                        {
                            lst = new List <CTypeDonneeCumulee>();
                            m_tableTypeToDonneesCumulees[cle.TypeLie] = lst;
                        }
                        lst.Add(type);
                    }
                }
            }
        }
        public COptimiseurProprieteDynamiqueChampCustomDisplayValue(CDbKey keyChamp)
        {
            m_dbKeyChamp = keyChamp;
            CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());

            if (champ.ReadIfExists(keyChamp))
            {
                if (champ.IsChoixParmis())
                {
                    foreach (CValeurChampCustom valeur in champ.ListeValeurs)
                    {
                        m_dicValeurs[valeur.Value] = valeur.Display;
                    }
                }
            }
        }