//-------------------------------------------------
public virtual CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type tp, int nNbNiveaux, CDefinitionProprieteDynamique defParente)
{
/*ITraducteurNomChamps traducteur = null;
* if ( defParente is ITraducteurNomChamps )
* traducteur = (ITraducteurNomChamps)defParente;*/
CDefinitionProprieteDynamique[] defs = new CDefinitionProprieteDynamique[0];
CFournisseurPropDynStd four = new CFournisseurPropDynStd(true);
if (!tp.IsSubclassOf(GetType()) && tp != GetType())
{
defs = four.GetDefinitionsChamps(tp, nNbNiveaux, defParente);
if (defParente != null)
{
return(defs);
}
}
List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>();
foreach (CDefinitionProprieteDynamique def in defs)
{
lst.Add(def);
}
lst.AddRange(GetProprietesInstance());
return(lst.ToArray( ));
}
/// /////////////////////////////////////////////////////////////
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type tp, int nNbNiveaux, CDefinitionProprieteDynamique defParente)
{
CDefinitionProprieteDynamique[] defs = new CDefinitionProprieteDynamique[0];
CFournisseurPropDynStd four = new CFournisseurPropDynStd(true);
if (!tp.IsSubclassOf(GetType()) && tp != GetType())
{
IFournisseurProprietesDynamiques fourDeVariable = GetFournisseurPourDefinitionChamp(defParente, tp);
if (fourDeVariable == null)
{
fourDeVariable = four;
}
defs = fourDeVariable.GetDefinitionsChamps(tp, nNbNiveaux, defParente);
if (defParente != null)
{
return(defs);
}
}
ArrayList lst = new ArrayList(defs);
lst.AddRange(GetProprietesInstance());
return((CDefinitionProprieteDynamique[])lst.ToArray(typeof(CDefinitionProprieteDynamique)));
}
/// /////////////////////////////////////////////
/// Implémentation du IFournisseurProprietesDynamiques
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(Type tp, int nNbNiveaux, CDefinitionProprieteDynamique defParente)
{
/*ITraducteurNomChamps traducteur = null;
* if ( defParente is ITraducteurNomChamps )
* traducteur = (ITraducteurNomChamps)defParente;*/
CFournisseurPropDynStd four = new CFournisseurPropDynStd(true);
ArrayList lst = new ArrayList();
lst.AddRange(four.GetDefinitionsChamps(tp, nNbNiveaux, defParente));
lst.AddRange(GetProprietesInstance());
return((CDefinitionProprieteDynamique[])lst.ToArray(typeof(CDefinitionProprieteDynamique)));
}
//-------------------------------------------------
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
if (objet != null)
{
Type tp = objet.TypeAnalyse;
if (tp.IsSubclassOf(GetType()) || tp == GetType())
{
return(GetProprietesInstance());
}
;
CFournisseurPropDynStd four = new CFournisseurPropDynStd(true);
IFournisseurProprietesDynamiques fourDeVariable = GetFournisseurPourDefinitionChamp(defParente, objet.TypeAnalyse);
if (fourDeVariable == null)
{
fourDeVariable = four;
}
return(fourDeVariable.GetDefinitionsChamps(objet, defParente));
}
return(new CDefinitionProprieteDynamique[0]);
}
/// //////////////////////////////////////////////////
public object Calcule(object objetEvalue, CFournisseurPropDynStd fournisseur)
{
if (objetEvalue == null)
{
return(null);
}
if (fournisseur == null)
{
fournisseur = new CFournisseurPropDynStd();
}
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetEvalue);
contexte.AttacheObjet(typeof(CContexteDonnee), ContexteDonnee);
CResultAErreur result = Formule.Eval(contexte);
contexte.DetacheObjet(typeof(CContexteDonnee));
if (result)
{
return(result.Data);
}
return(null);
}
/// ///////////////////////////////////////////////////////////
protected virtual void GetDefinitionsChamps(Type tp, int nProfondeur, ArrayList lstProps, string strCheminConvivial, string strCheminReel, CDefinitionProprieteDynamique defParente)
{
/*ITraducteurNomChamps traducteur = null;
* if ( defParente is ITraducteurNomChamps )
* traducteur = (ITraducteurNomChamps)defParente;*/
if (nProfondeur < 0)
{
return;
}
CStructureTable structure = null;
try
{
structure = CStructureTable.GetStructure(tp);
}
catch
{
return;
}
foreach (CInfoChampTable info in structure.Champs)
{
//Trouve la méthode correspondante
//18/09 bug : si un classe générique surcharge une propriété de sa classe de base,
//GetProperty retourne une erreur sur cette propriété
PropertyInfo propInfo = GetPropertySafe(tp, info.Propriete);
if (propInfo != null)
{
CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueDotNet(
strCheminConvivial + info.NomConvivial,
strCheminReel + info.Propriete,
new CTypeResultatExpression(propInfo.PropertyType, false), false, true,
""
);
AddDefinition(lstProps, def /*, traducteur*/);
GetDefinitionsChamps(propInfo.PropertyType, nProfondeur - 1, lstProps, strCheminConvivial + info.NomConvivial + ".", strCheminReel + info.Propriete + ".", def);
}
}
//Ajoute les relations parentes
foreach (CInfoRelation relation in structure.RelationsParentes)
{
PropertyInfo propInfo = GetPropertySafe(tp, relation.Propriete);
if (propInfo != null)
{
CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueRelation(
strCheminConvivial + relation.NomConvivial,
strCheminReel + relation.Propriete,
relation,
new CTypeResultatExpression(propInfo.PropertyType, false));
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Ajoute les relations filles
foreach (CInfoRelation relation in structure.RelationsFilles)
{
PropertyInfo propInfo = GetPropertySafe(tp, relation.Propriete);
if (propInfo != null)
{
object[] attribs = propInfo.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length != 0)
{
string strNomConvivial = strCheminConvivial + relation.NomConvivial;
object[] attrsDynCh = propInfo.GetCustomAttributes(typeof(DynamicChildsAttribute), true);
if (attrsDynCh.Length != 0)
{
DynamicChildsAttribute dynAtt = attrsDynCh[0] as DynamicChildsAttribute;
strNomConvivial = strCheminConvivial + dynAtt.NomConvivial;
}
Type tpFille = ((RelationFilleAttribute)attribs[0]).TypeFille;
//Pas les relations aux champs custom, elles sont gerées en dessous
//30/11/2011 stef : Euh, en fait, si, ça peut servir ! pour accélerer des filtres
/*if ( !tpFille.IsSubclassOf ( typeof(CRelationElementAChamp_ChampCustom) ))*/
AddDefinition(lstProps,
new CDefinitionProprieteDynamiqueRelation(
strNomConvivial,
strCheminReel + relation.Propriete,
relation,
new CTypeResultatExpression(tpFille, true)) /*,
* traducteur*/);
}
}
}
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(tp);
if (role != null)
{
CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(m_contexteDonneeCache, role.CodeRole);
foreach (CChampCustom champ in listeChamps)
{
CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Ajoute les relations TypeId
foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
{
if (relation.NomConvivialPourParent != "" && relation.IsAppliqueToType(tp))
{
AddDefinition(lstProps, new CDefinitionProprieteDynamiqueRelationTypeId(relation) /*, traducteur*/);
}
}
//Ajoute les données cumulées
CTypeDonneeCumulee[] donnees = CFournisseurPropDynStd.GetTypesDonneesPourType(tp);
foreach (CTypeDonneeCumulee typeDonnee in donnees)
{
int nCle = 0;
foreach (CCleDonneeCumulee cle in typeDonnee.Parametre.ChampsCle)
{
if (cle.TypeLie == tp)
{
CDefinitionProprieteDynamiqueDonneeCumulee def =
new CDefinitionProprieteDynamiqueDonneeCumulee(
typeDonnee,
nCle);
AddDefinition(lstProps, def /*, traducteur*/);
break;
}
}
}
//Liens sur champs custom fils
//Liens sur champs custom
CListeObjetsDonnees listeChampsFils = new CListeObjetsDonnees(m_contexteDonneeCache, typeof(CChampCustom));
listeChampsFils.Filtre = new CFiltreData(
CChampCustom.c_champTypeObjetDonnee + "=@1",
tp.ToString());
foreach (CChampCustom champ in listeChampsFils)
{
CDefinitionProprieteDynamiqueChampCustomFils def = new CDefinitionProprieteDynamiqueChampCustomFils(
champ);
if (champ.Categorie.Trim() != "")
{
def.Rubrique = champ.Categorie;
}
else
{
def.Rubrique = I.T("Complementary informations|59");
}
AddDefinition(lstProps, def /*, traducteur*/);
}
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, string strPropriete)
{
CFournisseurPropDynStd fournisseur = new CFournisseurPropDynStd(false);
if (objetInterroge == null)
{
return(null);
}
//Est-ce une propriété simple ?(majorité des cas )
object objetAInterroger = null;
MemberInfo membre = null;
if (CInterpreteurTextePropriete.GetObjetFinalEtMemberInfo(objetInterroge, strPropriete, ref objetAInterroger, ref membre) && membre != null)
{
return(CInterpreteurTextePropriete.GetValue(objetAInterroger, membre));
}
//Bon pas de bol, c'est autre chose, il faut donc chercher ce que c'est
Type tp = objetInterroge.GetType();
string strPropDebut = strPropriete.Split('.')[0];
object objetPremier = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
if (objetPremier == null)
{
string strIdChamp = CDefinitionProprieteDynamiqueChampCustom.GetIdPropriete(strPropDebut);
foreach (CDefinitionProprieteDynamique def in fournisseur.GetDefinitionsChamps(tp, 0))
{
if (def.NomPropriete == strPropDebut ||
(strIdChamp != "" && def is CDefinitionProprieteDynamiqueChampCustom) &&
((CDefinitionProprieteDynamiqueChampCustom)def).DbKeyChamp == CDbKey.CreateFromStringValue(strIdChamp))
{
objetPremier = GetValue(objetInterroge, def);
//Si la suite est une relation de la valeur champ vers l'objet, il ne faut pas
//traier la suite
if (strPropDebut != strPropriete)
{
string strSuiteTmp = strPropriete.Substring(strPropDebut.Length + 1);
if (CInfoRelationComposantFiltreChampToEntite.IsRelationFromChampToEntite(strSuiteTmp))
{
//On a déjà traité ce lien par GetValeurPropriété (qui retourne la valeur
//et nom pas le lien vers la valeur)
strPropDebut += "." + strPropriete.Split('.')[1];
}
}
break;
}
}
}
if (objetPremier == null)
{
return(null);
}
if (strPropDebut == strPropriete)
{
return(objetPremier);
}
string strSuite = strPropriete.Substring(strPropDebut.Length + 1);
return(GetValue(objetPremier, strSuite));
}