/// ///////////////////////////////////////////////
public CDefinitionProprieteDynamique GetProprieteInverse(Type typePortantLaPropriete, CDefinitionProprieteDynamique def)
{
CDefinitionProprieteDynamiqueDotNet defDotNet = def as CDefinitionProprieteDynamiqueDotNet;
if (typePortantLaPropriete == null || defDotNet == null)
{
return(null);
}
PropertyInfo info = typePortantLaPropriete.GetProperty(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
object[] attrs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attrs.Length > 0)
{
string strProp = ((RelationFilleAttribute)attrs[0]).ProprieteFille;
if (strProp.Length != 0)
{
return(new CDefinitionProprieteDynamiqueDotNet(strProp, strProp,
new CTypeResultatExpression(info.PropertyType, false), true, false, ""));
}
}
}
return(null);
}
//-----------------------------------------------------------
private C2iRequeteAvancee GetRequete(CParametreInspirationProprieteDeType parametre)
{
C2iRequeteAvancee requete = null;
if (m_dicRequetes.TryGetValue(parametre, out requete))
{
return(requete);
}
if (parametre.Type == null)
{
return(null);
}
CDefinitionProprieteDynamiqueChampCustom defCustom = parametre.Champ as CDefinitionProprieteDynamiqueChampCustom;
if (defCustom != null)
{
requete = GetRequeteChampCustom(parametre);
}
CDefinitionProprieteDynamiqueDotNet defDotNet = parametre.Champ as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
requete = GetRequeteChampDotNet(parametre);
}
m_dicRequetes[parametre] = requete;
return(requete);
}
//-----------------------------------------------------------------
public static CDefinitionProprieteDynamique GetDefinitionProprieteDynamique(string strPropriete, ref string strSuite)
{
I2iSerializable objDef = null;
if (strPropriete.Length > 2 &&
strPropriete.Substring(0, 2) == "~#")
{
string strStart = strPropriete.Substring(2);
strSuite = "";
int nPos = strStart.IndexOf("~@#@");
if (nPos >= 0)
{
strSuite = strStart.Substring(nPos + 4);
if (strSuite.Length > 1 && strSuite.Substring(0, 1) == ".")
{
strSuite = strSuite.Substring(1);
}
strStart = strStart.Substring(0, nPos);
}
CStringSerializer serializer = new CStringSerializer(strPropriete.Substring(2), ModeSerialisation.Lecture);
objDef = (I2iSerializable)m_tableSerializeToDefinition[strPropriete];
if (objDef == null)
{
if (!serializer.TraiteObject(ref objDef))
{
objDef = null;
}
else
{
m_tableSerializeToDefinition[strPropriete] = objDef;
}
}
}
else
{
//Il s'agit d'un nom de champ
string[] strDatas = strPropriete.Split('.');
string strProp = "";
foreach (string strData in strDatas)
{
strProp += CDefinitionProprieteDynamique.c_strCaractereStartCleType +
CDefinitionProprieteDynamiqueDotNet.c_strCleTypeDefinition +
CDefinitionProprieteDynamique.c_strCaractereEndCleType +
strData + ".";
}
if (strProp.Length > 1)
{
strProp = strProp.Substring(0, strProp.Length - 1);
}
CDefinitionProprieteDynamiqueDotNet prop = new CDefinitionProprieteDynamiqueDotNet(strPropriete,
strProp, new CTypeResultatExpression(typeof(string), false), false, false, "");
strSuite = "";
return(prop);
}
return(objDef as CDefinitionProprieteDynamique);
}
internal CResultAErreur Execute(CObjetDonneeAIdNumerique cible)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(MacroObjet.Macro);
CResultAErreur result = FormuleValeur.Eval(ctx);
if (result)
{
try
{
if (!m_champ.IsReadOnly)
{
CInterpreteurProprieteDynamique.SetValue(cible, m_champ, result.Data);
}
else//Peut être un champ forçable pour les macros
{
CDefinitionProprieteDynamiqueDotNet defDotNet = m_champ as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
PropertyInfo info = info = cible.GetType().GetProperty(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
object[] attrs = info.GetCustomAttributes(typeof(TiagRelationAttribute), true);
if (attrs != null && attrs.Length > 0)
{
TiagRelationAttribute att = (TiagRelationAttribute)attrs[0];
MethodInfo meth = cible.GetType().GetMethod(att.NomMethodeSetClesParentes);
if (meth != null)
{
object[] lstCles = null;
CObjetDonnee obj = result.Data as CObjetDonnee;
if (obj == null)
{
lstCles = new object[1];
}
else
{
lstCles = obj.GetValeursCles();
}
meth.Invoke(cible, new object[] { lstCles });
}
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur("#Error while affecting property " + m_champ.Nom);
}
}
return(result);
}
public CDefinitionProprieteDynamique[] GetProprietesInstance()
{
CDefinitionProprieteDynamiqueDotNet def = new CDefinitionProprieteDynamiqueDotNet(
"Source_Element",
"SourceElement",
new CTypeResultatExpression(m_typeSource, false),
true,
false,
"");
return(new CDefinitionProprieteDynamique[] { def });
}
//--------------------------------------------
/// <summary>
/// Si succès, retourne le filtre correspondant à cet élément
/// en tant que clé. le texte du filtre (format filtreData) est contenu dans le data du result
/// avec le paramètre valeur = @n
/// </summary>
/// <param name="typeCible"></param>
/// <returns></returns>
public static CResultAErreur GetFiltreCle(
Type typeCible,
CDefinitionProprieteDynamique definition,
int nNumeroParametre)
{
CResultAErreur result = CResultAErreur.True;
CDefinitionProprieteDynamiqueDotNet def = definition as CDefinitionProprieteDynamiqueDotNet;
PropertyInfo info = null;
if (def != null)
{
info = typeCible.GetProperty(def.NomProprieteSansCleTypeChamp);
}
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true);
if (attribs.Length > 0)
{
TableFieldPropertyAttribute attr = attribs[0] as TableFieldPropertyAttribute;
result.Data = attr.NomChamp + "=@" + nNumeroParametre;
return(result);
}
attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
if (attribs.Length > 0)
{
RelationAttribute attr = attribs[0] as RelationAttribute;
if (attr.ChampsFils.Length == 1)
{
result.Data = attr.ChampsFils[0] + "=@" + nNumeroParametre;
return(result);
}
}
}
//Sinon, si ID d'un objet a id auto
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(typeCible))
{
if (definition.NomPropriete == "#PP|Id")
{
//Trouve le champ id
string strChampId = CObjetDonnee.GetChampsId(typeCible)[0];
result.Data = strChampId + "=@" + nNumeroParametre;
return(result);
}
}
result.EmpileErreur(I.T("Can not use field @1 as key in imort|20044", definition.Nom));
return(result);
}
//-----------------------------------------------------------------
public static string GetProprieteDotNetFromProprieteStructureDynamique(string strProp)
{
string strRetour = "";
string strSuite = strProp;
while (strSuite.Length > 0)
{
CDefinitionProprieteDynamique defProp = GetDefinitionProprieteDynamique(strSuite, ref strSuite);
CDefinitionProprieteDynamiqueDotNet propDotNet = defProp as CDefinitionProprieteDynamiqueDotNet;
if (propDotNet == null)
{
return(strProp);
}
if (strRetour.Length > 0)
{
strRetour += ".";
}
strRetour += propDotNet.NomProprieteSansCleTypeChamp;
}
return(strRetour);
}
/// <summary>
/// retourne l'objet donné sélectionné à partir de la valeur retournée
/// </summary>
/// <remarks>
/// Ne fonctionne pas toujours, ça ne fonctionne que si la valeur retournée
/// est un champ DOTNET de l'entité sélectionnée
/// </remarks>
/// <param name="valeurRetournee"></param>
/// <param name="contexte"></param>
/// <returns></returns>
public CReferenceObjetDonnee GetObjetFromValeurRetournee(object valeurRetournee)
{
if (valeurRetournee == null)
{
return(null);
}
C2iExpressionChamp exp = ExpressionRetournee as C2iExpressionChamp;
if (exp != null)
{
CDefinitionProprieteDynamique propDyn = exp.DefinitionPropriete;
CDefinitionProprieteDynamiqueDotNet defDotNet = propDyn as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(m_filtreSelection.TypeElements, new object[] { CContexteDonneeSysteme.GetInstance() });
CStructureTable structure = CStructureTable.GetStructure(m_filtreSelection.TypeElements);
CInfoChampTable info = structure.GetChampFromPropriete(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
CResultAErreur result = m_filtreSelection.GetFiltreData();
CFiltreData filtre = null;
if (result && result.Data is CFiltreData)
{
filtre = result.Data as CFiltreData;
}
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(info.NomChamp + "=@1",
valeurRetournee));
if (objet.ReadIfExists(filtre))
{
return(new CReferenceObjetDonnee(objet));
}
}
}
}
return(null);
}
internal void CreateVariable(CObjetDonnee objet)
{
CVariableDynamiqueSelectionObjetDonnee variable = new CVariableDynamiqueSelectionObjetDonnee(Macro);
if (objet != null)
{
variable.Nom = objet.DescriptionElement.Trim().Replace("[", "-").Replace("]", "-");
}
else
{
variable.Nom = "V" + variable.IdVariable;
}
CFiltreDynamique filtre = new CFiltreDynamique(Macro, Macro.ContexteDonnee);
filtre.TypeElements = TypeObjet;
variable.FiltreSelection = filtre;
variable.ExpressionRetournee = new C2iExpressionThis(TypeObjet);
string strField = DescriptionFieldAttribute.GetDescriptionField(TypeObjet, "DescriptionElement");
if (strField != "")
{
CDefinitionProprieteDynamiqueDotNet def = new CDefinitionProprieteDynamiqueDotNet(
strField,
strField,
new CTypeResultatExpression(typeof(string), false),
false,
true,
"");
variable.ExpressionAffichee = new C2iExpressionChamp(def);
}
Macro.AddVariable(variable);
Macro.SetInitialValue(variable, objet as CObjetDonneeAIdNumerique);
m_strIdVariableAssociee = variable.IdVariable;
CDefinitionProprieteDynamiqueVariableDynamique defSource = new CDefinitionProprieteDynamiqueVariableDynamique(variable);
FormuleSelectionObjet = new C2iExpressionChamp(defSource);
}
////////////////////////////////////////////////////////////////////////
/// <summary>
/// Retourne un filtre dynamique pour la table associée en
/// prenant en compte les filtres des parents
/// </summary>
/// <returns></returns>
public CFiltreDynamique GetFiltreToElementPrincipal()
{
if (TouteLaTable)
{
return(null);
}
CFiltreDynamique filtreDynamiqueParent = null;
if (FiltreParent != null)
{
filtreDynamiqueParent = FiltreParent.GetFiltreToElementPrincipal();
}
Type typeElements = CContexteDonnee.GetTypeForTable(NomTable);
CStructureTable structure = CStructureTable.GetStructure(typeElements);
CFiltreDynamique filtreFinal = (CFiltreDynamique)FiltreDynamique.Clone();
CDefinitionProprieteDynamique defToParent = null;
//Trouve la propriété qui amène sur le parent
if (RelationToParent != null)
{
if (RelationToParent.TableFille == NomTable)
{
if (filtreDynamiqueParent != null && filtreDynamiqueParent.ComposantPrincipal != null)
{
Type tp = CContexteDonnee.GetTypeForTable(RelationToParent.TableParente);
string strNomConvivial = DynamicClassAttribute.GetNomConvivial(tp);
//Nous somme dans une relation fille
foreach (CInfoRelation relationParente in structure.RelationsParentes)
{
if (relationParente.RelationKey == RelationToParent.RelationKey)
{
defToParent = new CDefinitionProprieteDynamiqueDotNet(
strNomConvivial,
relationParente.Propriete,
new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(relationParente.TableParente), false),
true,
true,
"");
break;
}
}
if (defToParent == null)
{
defToParent = new CDefinitionProprieteDynamique(
strNomConvivial,
RelationToParent.RelationKey,
new CTypeResultatExpression(tp, false),
true,
true,
"");
}
}
}
else
{
//Nous sommes dans une relation parente
foreach (CInfoRelation relationFille in structure.RelationsFilles)
{
if (relationFille.RelationKey == RelationToParent.RelationKey)
{
defToParent = new CDefinitionProprieteDynamiqueDotNet(
relationFille.NomConvivial,
relationFille.Propriete,
new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(relationFille.TableFille), true),
true,
true,
"");
break;
}
}
if (defToParent == null)
{
Type tp = CContexteDonnee.GetTypeForTable(RelationToParent.TableFille);
defToParent = new CDefinitionProprieteDynamique(
DynamicClassAttribute.GetNomConvivial(tp) + "(" + RelationToParent.NomConvivial + ")",
RelationToParent.RelationKey,
new CTypeResultatExpression(tp, false),
true, true);
}
if (filtreDynamiqueParent == null)
{
filtreDynamiqueParent = new CFiltreDynamiqueParentTablePleine(NomTable, RelationToParent);
}
}
}
if (filtreDynamiqueParent != null && filtreDynamiqueParent.ComposantPrincipal != null)
{
filtreDynamiqueParent.ComposantPrincipal.InsereDefinitionToObjetFinal(defToParent);
if (FiltreDynamique == null || FiltreDynamique.ComposantPrincipal == null)
{
return(filtreDynamiqueParent);
}
CComposantFiltreDynamique composantEt = null;
if (!(filtreDynamiqueParent.ComposantPrincipal is CComposantFiltreDynamiqueEt))
{
composantEt = new CComposantFiltreDynamiqueEt();
composantEt.AddComposantFils(filtreDynamiqueParent.ComposantPrincipal);
}
else
{
composantEt = (CComposantFiltreDynamiqueEt)filtreDynamiqueParent.ComposantPrincipal;
}
composantEt.AddComposantFils(filtreFinal.ComposantPrincipal);
filtreFinal.ComposantPrincipal = composantEt;
}
if (filtreFinal.ComposantPrincipal == null)
{
return(null);
}
return(filtreFinal);
}
/// //////////////////////////////////////////
private void CreateChilds(TreeNode node)
{
CTagNode?tag = node.Tag as CTagNode?;
if (tag == null)
{
return;
}
Dictionary <string, TreeNode> dicFolders = new Dictionary <string, TreeNode>();
Type tpParent = tag.Value.Definition.TypeDonnee.TypeDotNetNatif;
IEnumerable <CDefinitionProprieteDynamique> defs =
from def in new CFournisseurPropDynStd(false).GetDefinitionsChamps(tpParent)
where def.GetDefinitionInverse(tpParent) != null
select def;
foreach (CDefinitionProprieteDynamique def in defs)
{
CDefinitionProprieteDynamiqueDotNet defDotNet = def as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
PropertyInfo info = tpParent.GetProperty(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null && info.GetCustomAttributes(typeof(NonCloneableAttribute), true).Length != 0)
{
continue;
}
}
TreeNode nodeFils = new TreeNode(def.Nom);
CTagNode tagFils = new CTagNode(tpParent, def);
nodeFils.Tag = tagFils;
TreeNodeCollection nodes = node.Nodes;
if (def.Rubrique.Trim() != "")
{
TreeNode parent = null;
if (!dicFolders.TryGetValue(def.Rubrique.Trim().ToUpper(), out parent))
{
parent = new TreeNode(def.Rubrique.Trim());
parent.Tag = node.Tag;
dicFolders[def.Rubrique.Trim().ToUpper()] = parent;
node.Nodes.Add(parent);
parent.ImageIndex = 0;
}
nodes = parent.Nodes;
}
nodes.Add(nodeFils);
nodeFils.ImageIndex = 1;
List <TreeNode> lst = null;
if (!m_dicIdDefToNode.TryGetValue(tagFils.GetKey(), out lst))
{
lst = new List <TreeNode>();
m_dicIdDefToNode[tagFils.GetKey()] = lst;
}
lst.Add(nodeFils);
m_bInCheck = true;
nodeFils.Checked = IsCheckByDic(nodeFils);
m_bInCheck = false;
nodeFils.Nodes.Add(new TreeNode());
}
}
/// ///////////////////////////////////////////////////////////
protected virtual void GetDefinitionsChamps(
Type tp,
int nProfondeur,
ArrayList lstProps,
string strCheminConvivial,
string strCheminReel,
CDefinitionProprieteDynamique definitionParente
)
{
/*ITraducteurNomChamps traducteur = null;
* if ( definitionParente is ITraducteurNomChamps )
* traducteur = (ITraducteurNomChamps)definitionParente;*/
if (nProfondeur < 0)
{
return;
}
if (tp == null)
{
return;
}
//Proprietes
foreach (PropertyInfo info in tp.GetProperties())
{
object[] attribs = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true);
if (attribs.Length == 1)
{
DynamicFieldAttribute attrib = (DynamicFieldAttribute)attribs[0];
bool bReadOnly = info.GetSetMethod() == null;
Type tpProp = info.PropertyType;
bool bIsArray = tpProp.IsArray;
if (bIsArray)
{
tpProp = tpProp.GetElementType();
}
bool bHasSubProprietes = HasSubProperties(tpProp);
if (m_bAvecReadOnly || !bReadOnly || bHasSubProprietes)
{
CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueDotNet(
strCheminConvivial + attrib.NomConvivial,
strCheminReel + info.Name,
new CTypeResultatExpression(tpProp, bIsArray),
bHasSubProprietes,
bReadOnly,
attrib.Rubrique);
if (AddDefinition(lstProps, def /*, traducteur*/))
{
GetDefinitionsChamps(info.PropertyType, nProfondeur - 1, lstProps, strCheminConvivial + attrib.NomConvivial + ".", strCheminReel + info.Name + ".", def);
}
}
}
attribs = info.GetCustomAttributes(typeof(DynamicChildsAttribute), true);
{
if (attribs.Length == 1)
{
DynamicChildsAttribute attrib = (DynamicChildsAttribute)attribs[0];
CDefinitionProprieteDynamique def = new CDefinitionProprieteDynamiqueDotNet(
strCheminConvivial + attrib.NomConvivial,
strCheminReel + info.Name,
new CTypeResultatExpression(attrib.TypeFils, true)
, true,
true,
attrib.Rubrique);
if (AddDefinition(lstProps, def /*, traducteur*/))
{
GetDefinitionsChamps(attrib.TypeFils, nProfondeur - 1, lstProps, strCheminConvivial + attrib.NomConvivial + ".", strCheminReel + info.Name + ".", def);
}
}
}
}
//Champs custom
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(tp);
if (role != null)
{
CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(ContexteDonneeCache, role.CodeRole);
foreach (CChampCustom champ in listeChamps)
{
CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
if (champ.Categorie.Trim() != "")
{
def.Rubrique = champ.Categorie;
}
else
{
def.Rubrique = I.T("Complementary informations|59");
}
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Champs calculés
if (AvecReadOnly)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CChampCalcule));
liste.Filtre = new CFiltreData(CChampCalcule.c_champTypeObjets + "=@1", tp.ToString());
foreach (CChampCalcule champ in liste)
{
CDefinitionProprieteDynamiqueChampCalcule def = new CDefinitionProprieteDynamiqueChampCalcule(champ);
def.HasSubProperties = HasSubProperties(def.TypeDonnee.TypeDotNetNatif);
def.Rubrique = I.T("Complementary informations|59");
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Méthodes
if (m_bAvecMethodes && AvecReadOnly)
{
//Va chercher les propriétés
foreach (MethodInfo methode in tp.GetMethods())
{
object[] attribs = methode.GetCustomAttributes(typeof(DynamicMethodAttribute), true);
if (attribs.Length == 1)
{
DynamicMethodAttribute attrib = (DynamicMethodAttribute)attribs[0];
CTypeResultatExpression typeRes = new CTypeResultatExpression(methode.ReturnType, false);
if (methode.ReturnType.HasElementType)
{
typeRes = new CTypeResultatExpression(methode.ReturnType.GetElementType(), true);
}
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
strCheminConvivial + methode.Name,
strCheminReel + methode.Name,
typeRes,
HasSubProperties(methode.ReturnType),
attrib.Descriptif,
attrib.InfosParametres);
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
GetDefinitionsChamps(methode.ReturnType, nProfondeur - 1, lstProps, strCheminConvivial + methode.Name + ".", strCheminReel + methode.Name + ".", def);
}
}
foreach (CMethodeSupplementaire methode in CGestionnaireMethodesSupplementaires.GetMethodsForType(tp))
{
CDefinitionProprieteDynamique def = new CDefinitionMethodeDynamique(
strCheminConvivial + methode.Name,
strCheminReel + methode.Name,
new CTypeResultatExpression(methode.ReturnType, methode.ReturnArrayOfReturnType),
HasSubProperties(methode.ReturnType));
def.Rubrique = I.T("Methods|58");
lstProps.Add(def);
GetDefinitionsChamps(methode.ReturnType, nProfondeur - 1, lstProps, strCheminConvivial + methode.Name + ".", strCheminReel + methode.Name + ".", def);
}
}
//Relations TypeID
foreach (RelationTypeIdAttribute relation in CContexteDonnee.RelationsTypeIds)
{
if (relation.NomConvivialPourParent != "" && relation.IsAppliqueToType(tp))
{
CDefinitionProprieteDynamiqueRelationTypeId def = new CDefinitionProprieteDynamiqueRelationTypeId(relation);
AddDefinition(lstProps, def /*, traducteur*/);
}
}
//Données ucmulées
if (m_bAvecReadOnly)
{
CTypeDonneeCumulee[] donnees = 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
if (m_bAvecReadOnly)
{
//Liens sur champs custom
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(ContexteDonneeCache, typeof(CChampCustom));
listeChamps.Filtre = new CFiltreData(
CChampCustom.c_champTypeObjetDonnee + "=@1",
tp.ToString());
foreach (CChampCustom champ in listeChamps)
{
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*/);
}
}
//Liens par CListeEntite
if (m_bAvecReadOnly)
{
CListeObjetsDonnees listeEntites = new CListeObjetsDonnees(ContexteDonneeCache, 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");
AddDefinition(lstProps, def /*, traducteur*/);
}
}
}
/// ///////////////////////////////////////////////////////////
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 CResultAErreurType <CObjetDonnee> FindObjet(
DataRow rowSource,
CContexteImportDonnee contexteImport,
CValeursImportFixe valeursFixes,
ref string strFiltre)
{
CResultAErreurType <CObjetDonnee> resObjet = new CResultAErreurType <CObjetDonnee>();
CResultAErreur res = CResultAErreur.True;
StringBuilder blFiltre = new StringBuilder();
if (valeursFixes != null)
{
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
blFiltre.Append(kv.Key);
blFiltre.Append("=");
blFiltre.Append(kv.Value == null ? "null" : kv.Value.ToString());
blFiltre.Append(";");
}
}
//Création du filtre
CComposantFiltreDynamiqueEt compoPrincipal = new CComposantFiltreDynamiqueEt();
//Recherche à partir des champs simples
foreach (CMappageChampSimple mapSimple in MappagesChampsSimples)
{
if (mapSimple.UseAsKey)
{
res = mapSimple.GetValue(rowSource, contexteImport);
if (!res)
{
res.EmpileErreur(I.T("Erreur while searching object|20093"));
resObjet.EmpileErreur(res.Erreur);
return(resObjet);
}
//Stockage valeur témoin
CSourceSmartImportField sourceField = mapSimple.Source as CSourceSmartImportField;
if (sourceField != null)
{
contexteImport.SetValeurTemoin(sourceField.NomChampSource, res.Data);
}
blFiltre.Append(mapSimple.Propriete.NomPropriete);
if (res.Data == null)
{
CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
testNull.Champ = mapSimple.Propriete;
testNull.TestNull = true;
compoPrincipal.AddComposantFils(testNull);
blFiltre.Append("=null;");
}
else
{
CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
testValeur.Champ = mapSimple.Propriete;
testValeur.IdOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
testValeur.ExpressionValeur = new C2iExpressionConstante(res.Data);
compoPrincipal.AddComposantFils(testValeur);
blFiltre.Append("=");
blFiltre.Append(res.Data.ToString());
blFiltre.Append(";");
}
}
}
//Recherche à partir des objets parents
foreach (CMappageEntiteParente mapParent in m_listeMappagesParents)
{
if (mapParent.UseAsKey)
{
CResultAErreurType <CObjetDonnee> resParent = mapParent.GetObjetAssocie(rowSource, contexteImport, false);
if (!resParent)
{
resObjet.EmpileErreur(resParent.Erreur);
return(resObjet);
}
CObjetDonneeAIdNumerique objetId = resParent.DataType as CObjetDonneeAIdNumerique;
CDefinitionProprieteDynamique defId = null;
object valeurTest = null;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
{
defId = new CDefinitionProprieteDynamiqueDotNet(
"Id",
"Id",
new CTypeResultatExpression(typeof(int), false),
false,
true, "");
defId.InsereParent(mapParent.Propriete);
valeurTest = objetId != null?objetId.Id:-1;
}
else if (CObjetDonnee.TypeManageIdUniversel(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
{
defId = new CDefinitionProprieteDynamiqueDotNet("Universal id",
"IdUniversel",
new CTypeResultatExpression(typeof(string), false),
false, true, "");
defId.InsereParent(mapParent.Propriete);
valeurTest = resParent.DataType != null ? resParent.DataType.IdUniversel : null;
}
else
{
resObjet.EmpileErreur(I.T("Can not search objet of type @1|20094",
DynamicClassAttribute.GetNomConvivial(mapParent.Propriete.TypeDonnee.TypeDotNetNatif)));
return(resObjet);
}
blFiltre.Append(defId.NomPropriete);
if (resParent.DataType == null)
{
CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
testNull.Champ = defId;
testNull.TestNull = true;
compoPrincipal.AddComposantFils(testNull);
blFiltre.Append("=null;");
}
else
{
CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
testValeur.Champ = defId;
testValeur.IdOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
testValeur.ExpressionValeur = new C2iExpressionConstante(valeurTest);
compoPrincipal.AddComposantFils(testValeur);
blFiltre.Append("=");
blFiltre.Append(valeurTest.ToString());
blFiltre.Append(";");
}
}
}
if (blFiltre.Length == 0)//Pas de filtre
{
return(resObjet);
}
strFiltre = blFiltre.ToString();
CObjetDonnee objet = contexteImport.GetEntiteForFiltre(TypeEntite, strFiltre);
if (objet != null)
{
resObjet.DataType = objet;
return(resObjet);
}
CFiltreDynamique filtre = new CFiltreDynamique(contexteImport.ContexteDonnee);
filtre.TypeElements = TypeEntite;
filtre.ComposantPrincipal = compoPrincipal;
res = filtre.GetFiltreData();
if (res && res.Data is CFiltreDataAvance)
{
if (valeursFixes != null)
{
CFiltreDataAvance filtreData = res.Data as CFiltreDataAvance;
StringBuilder blAdd = new StringBuilder();
int nParam = filtreData.Parametres.Count + 1;
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
if (kv.Value == null)
{
blAdd.Append("HasNo(");
blAdd.Append(kv.Key);
blAdd.Append(") and ");
}
else
{
blAdd.Append(kv.Key);
blAdd.Append("=@");
blAdd.Append((nParam++));
blAdd.Append(" and ");
filtreData.Parametres.Add(kv.Value);
}
}
blAdd.Remove(blAdd.Length - 5, 5);
if (filtreData.Filtre.Length > 0)
{
blAdd.Insert(0, " and ");
}
filtreData.Filtre += blAdd;
}
objet = Activator.CreateInstance(TypeEntite, new object[] { contexteImport.ContexteDonnee }) as CObjetDonnee;
if (objet.ReadIfExists(((CFiltreData)res.Data)))
{
contexteImport.SetEntiteForFiltre(strFiltre, objet);
resObjet.DataType = objet;
return(resObjet);
}
}
else
{
res.EmpileErreur(I.T("Erreur while searching object|20093"));
resObjet.EmpileErreur(res.Erreur);
return(resObjet);
}
return(resObjet);
}
