Example #1
0
        //----------------------------------------------------------------------------
        /// <summary>
        ///
        /// </summary>
        /// <param name="nIdEO"></param>
        /// <returns></returns>
        public static CResultAErreur AjouterEO(IElementAEO element, int nIdEO)
        {
            CResultAErreur result = CResultAErreur.True;

            CListeObjetsDonnees listeEOExistantes = CRelationElement_EO.GetListeRelationsForElement((CObjetDonneeAIdNumerique)element);

            listeEOExistantes.Filtre =
                new CFiltreData(CEntiteOrganisationnelle.c_champId + " = @1", nIdEO);

            if (listeEOExistantes.Count > 0)
            {
                result.EmpileErreur(I.T("This Organisationnal Entity is already assigned to the element: @1|565", element.DescriptionElement));
                return(result);
            }
            // Affecte l'EO à l'élement
            CEntiteOrganisationnelle entite = new CEntiteOrganisationnelle(element.ContexteDonnee);

            if (entite.ReadIfExists(nIdEO))
            {
                CRelationElement_EO relation = new CRelationElement_EO(element.ContexteDonnee);
                relation.CreateNewInCurrentContexte();
                relation.EntiteOrganisationnelle = entite;
                relation.ElementLie = (CObjetDonneeAIdNumerique)element;
            }

            return(result);
        }
Example #2
0
        //-*-------------------------------------------------------
        public void TiagSetOEKeys(object[] keys)
        {
            CEntiteOrganisationnelle entite = new CEntiteOrganisationnelle(ContexteDonnee);

            if (entite.ReadIfExists(keys))
            {
                EntiteOrganisationnelle = entite;
            }
        }
        //-------------------------------------------------------------------
        /// <summary>
        /// Utilisé par TIAG pour affecter le l'entité parente par ses clés
        /// </summary>
        /// <param name="lstCles"></param>
        public void TiagSetParentEntityKeys(object[] lstCles)
        {
            CEntiteOrganisationnelle entite = new CEntiteOrganisationnelle(ContexteDonnee);

            if (entite.ReadIfExists(lstCles))
            {
                EntiteParente = entite;
            }
        }
Example #4
0
        //----------------------------------------------------------------
        public static void CopyAndReplaceEOS(IElementAEO eltAModifier, IElementAEO eltSource, string strCodeRacine)
        {
            string[]         strCodesAModifier = eltAModifier.CodesEntitesOrganisationnelles.Split('~');
            string[]         strCodesAAffecter = eltSource.CodesEntitesOrganisationnelles.Split('~');
            HashSet <string> setCodesAModifier = new HashSet <string>();
            HashSet <string> setcodesAAffecter = new HashSet <string>();

            foreach (string strCode in strCodesAAffecter)
            {
                if (strCode.StartsWith(strCodeRacine))
                {
                    setcodesAAffecter.Add(strCode);
                }
            }

            foreach (string strCode in strCodesAModifier)
            {
                if (strCode.StartsWith(strCodeRacine) && strCode.Length > 0)
                {
                    if (!setcodesAAffecter.Contains(strCodeRacine))
                    {
                        CEntiteOrganisationnelle ett = new CEntiteOrganisationnelle(eltAModifier.ContexteDonnee);
                        if (ett.ReadIfExists(new CFiltreData(CEntiteOrganisationnelle.c_champCodeSystemeComplet + "=@1",
                                                             strCode)))
                        {
                            eltAModifier.SupprimerEO(ett.Id);
                        }
                    }
                    else
                    {
                        setCodesAModifier.Add(strCode);
                    }
                }
            }
            foreach (string strCode in strCodesAAffecter)
            {
                if (strCode.StartsWith(strCodeRacine) && !setCodesAModifier.Contains(strCode) && strCode.Length > 0)
                {
                    CEntiteOrganisationnelle ett = new CEntiteOrganisationnelle(eltAModifier.ContexteDonnee);
                    if (ett.ReadIfExists(new CFiltreData(CEntiteOrganisationnelle.c_champCodeSystemeComplet + "=@1",
                                                         strCode)))
                    {
                        eltAModifier.AjouterEO(ett.Id);
                    }
                }
            }
        }
Example #5
0
        ////////////////////////////////////////////////
        public string GetFiltreEO(int?nIdVersion, Type typeElements)
        {
            string             strFiltre = "";
            CProfilUtilisateur profilLie = Profil;

            if (profilLie == null && Profil_Inclusion != null)
            {
                if (!Profil_Inclusion.ShouldApply(nIdVersion))
                {
                    return("");
                }
                profilLie = Profil_Inclusion.ProfilFils;
            }
            if (profilLie == null)
            {
                return("");
            }
            string strTmp = "";

            if (profilLie.ShouldFiltrerSur(typeElements))
            {
                CEntiteOrganisationnelle entite = profilLie.EntiteOrganisationnelle;
                CEntiteOrganisationnelle racine = entite;
                if (racine == null)
                {
                    return("");
                }
                while (racine.EntiteParente != null)
                {
                    racine = racine.EntiteParente;
                }
                if (!profilLie.MasquerLesHorsBranche)
                {
                    strFiltre = CUtilElementAEO.c_champEO + " not like '%~" + racine.CodeSystemeComplet + "%'";
                }
                if (!profilLie.Affinable || RelationsEntiteOrganisationnelles.Count == 0)//Pas de lien spécifique
                {
                    if (strFiltre != "")
                    {
                        strFiltre += " or ";
                    }
                    strFiltre += CUtilElementAEO.c_champEO + " like '%~" + entite.CodeSystemeComplet + "%'";
                }
                if (profilLie.Affinable)
                {
                    foreach (CEntiteOrganisationnelle entiteLiee in EntitesLiesExplicites)
                    {
                        if (strTmp != "")
                        {
                            strTmp += " or ";
                        }
                        strTmp += CUtilElementAEO.c_champEO + " like '%~" + entiteLiee.CodeSystemeComplet + "%'";
                    }
                    if (strTmp != "")
                    {
                        if (strFiltre != "")
                        {
                            strFiltre += " or ";
                        }
                        strFiltre += strTmp;
                    }
                    if (strFiltre != "")
                    {
                        strFiltre = "(" + strFiltre + ")";
                    }
                }
            }

            string strSousFiltres = "";

            foreach (CRelationUtilisateur_Profil relSousProfil in RelationFilles)
            {
                strTmp = relSousProfil.GetFiltreEO(nIdVersion, typeElements);
                if (strTmp != "")
                {
                    if (strSousFiltres != "")
                    {
                        strSousFiltres += " or ";
                    }
                    strSousFiltres += "(" + strTmp + ")";
                }
            }
            if (strSousFiltres != "")
            {
                if (strFiltre != "")
                {
                    strFiltre += " and ";
                }
                strFiltre += "(" + strSousFiltres + ")";
            }
            return(strFiltre);
        }
Example #6
0
        //---------------------------------------------
        /// <summary>
        /// Retourne le filtre à appliquer à un élément pour obtenir tous les éléments
        /// ayant en commun les types d'EO demandés
        /// </summary>
        /// <param name="element"></param>
        /// <param name="typesCommuns"></param>
        /// <param name="bFillesSeulement">Indique que seules le EOS = ou filles sont prises en compte (true),
        /// ou seules les EOs parentes (false)</param>
        /// <returns></returns>
        public static CFiltreData GetFiltrePourTypeEosCommuns(IElementAEO element, List <COptionCorrespondanceEO> typesCommuns)
        {
            CFiltreData filtre = null;

            Dictionary <COptionCorrespondanceEO, Dictionary <string, EModeComparaisonEO> > tableEOS = new Dictionary <COptionCorrespondanceEO, Dictionary <string, EModeComparaisonEO> >();

            foreach (CEntiteOrganisationnelle eo in CUtilElementAEO.GetToutesEOs(element))
            {
                foreach (COptionCorrespondanceEO option in typesCommuns)
                {
                    Dictionary <string, EModeComparaisonEO> dicoOption = null;
                    if (tableEOS.ContainsKey(option))
                    {
                        dicoOption = tableEOS[option];
                    }
                    else
                    {
                        dicoOption       = new Dictionary <string, EModeComparaisonEO>();
                        tableEOS[option] = dicoOption;
                    }

                    switch (option.ModeComparaison)
                    {
                    case EModeComparaisonEO.FillesUniquement:
                        if (eo.TypeEntite == option.TypeEO)
                        {
                            dicoOption[eo.CodeSystemeComplet] = option.ModeComparaison;
                        }
                        else if (eo.TypeEntite.IsChildOf(option.TypeEO))
                        {
                            dicoOption[eo.GetParent(option.TypeEO).CodeSystemeComplet] = option.ModeComparaison;
                        }
                        else if (option.TypeEO.IsChildOf(eo.TypeEntite))
                        {
                            foreach (CEntiteOrganisationnelle eoFille in eo.GetChilds(option.TypeEO))
                            {
                                dicoOption[eoFille.CodeSystemeComplet] = option.ModeComparaison;
                            }
                        }
                        break;

                    case EModeComparaisonEO.ParentsUniquement:
                    case EModeComparaisonEO.BrancheComplete:
                        CEntiteOrganisationnelle eoTmp = eo;
                        string strLib = option.TypeEO.Libelle;
                        while (eoTmp.TypeEntite.IsChildOf(option.TypeEO) && !eoTmp.TypeEntite.Equals(option.TypeEO))
                        {
                            eoTmp = eoTmp.EntiteParente;
                        }
                        strLib = eoTmp.Libelle;
                        if (eoTmp != null && eoTmp.TypeEntite.Equals(option.TypeEO))
                        {
                            while (eoTmp != null)
                            {
                                dicoOption[eoTmp.CodeSystemeComplet] = option.ModeComparaison;
                                eoTmp = eoTmp.EntiteParente;
                            }
                        }
                        break;

                    case EModeComparaisonEO.Egalite:
                        if (eo.TypeEntite == option.TypeEO)
                        {
                            dicoOption[eo.CodeSystemeComplet] = option.ModeComparaison;
                        }
                        break;
                    }
                }
            }
            if (tableEOS.Count > 0)
            {
                string strFiltreEO = "";
                int    nIndex      = 1;
                filtre = new CFiltreData("");
                foreach (Dictionary <string, EModeComparaisonEO> dico in tableEOS.Values)
                {
                    if (dico.Count != 0)
                    {
                        strFiltreEO += "(";
                        foreach (KeyValuePair <string, EModeComparaisonEO> entry in dico)
                        {
                            string             strCodeEO = entry.Key;
                            EModeComparaisonEO mode      = entry.Value;
                            strFiltreEO += CUtilElementAEO.c_champEO + " like @" + (nIndex++) + " or ";
                            switch (mode)
                            {
                            case EModeComparaisonEO.FillesUniquement:
                                filtre.Parametres.Add("%~" + strCodeEO + "%");
                                break;

                            case EModeComparaisonEO.ParentsUniquement:
                            case EModeComparaisonEO.Egalite:
                                filtre.Parametres.Add("%~" + strCodeEO + "~%");
                                break;

                            case EModeComparaisonEO.BrancheComplete:
                                filtre.Parametres.Add("%~" + strCodeEO + "%");
                                break;
                            }
                        }
                        strFiltreEO = strFiltreEO.Substring(0, strFiltreEO.Length - 4) + ") and ";
                    }
                }
                if (strFiltreEO.Length > 0)
                {
                    strFiltreEO   = strFiltreEO.Substring(0, strFiltreEO.Length - 5);
                    filtre.Filtre = strFiltreEO;
                }
            }
            return(filtre);
        }