public static bool DecomposeNomPropriete(string strNomPropriete, ref string strKeyChamp)
{
string strCleDef = "";
string strPropDef = "";
if (CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strNomPropriete, ref strCleDef, ref strPropDef))
{
if (strCleDef != CDefinitionProprieteDynamiqueChampCustomDisplayValue.c_strCleType)
{
return(false);
}
strNomPropriete = strPropDef;
}
string[] strZones = strNomPropriete.Split('¤');
if (strZones[0] != c_cleChamp)
{
return(false);
}
//Oui, c'en est une
try
{
strKeyChamp = strZones[1];
return(true);
}
catch
{ }
return(false);
}
public static IDependanceListeObjetsDonneesReader GetReader(string strPropriete)
{
string strCleType = "";
string strProprieteSansCle = "";
if (CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strPropriete, ref strCleType, ref strProprieteSansCle))
{
Type typeReader = null;
if (m_dicTypeReader.TryGetValue(strCleType, out typeReader))
{
return(Activator.CreateInstance(typeReader, new object[0]) as IDependanceListeObjetsDonneesReader);
}
}
return(null);
}
/// ////////////////////////////////////////////////////////////////
public static void FindRelation(string strTable, Type type, ref CInfoRelationComposantFiltre relationTrouvee)
{
if (relationTrouvee != null)
{
return;
}
string strPropDef = "";
string strCleDef = "";
if (CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strTable, ref strCleDef, ref strPropDef))
{
if (strCleDef != c_strCleType)
{
return;
}
CStructureTable structure = CStructureTable.GetStructure(type);
foreach (CInfoRelation relation in structure.RelationsFilles)
{
if (relation.Propriete == strPropDef)
{
relationTrouvee = new CInfoRelationComposantFiltreStd(
relation,
true, 0);
return;
}
}
foreach (CInfoRelation relation in structure.RelationsParentes)
{
if (relation.Propriete == strPropDef)
{
relationTrouvee = new CInfoRelationComposantFiltreStd(
relation,
false, 0);
return;
}
}
}
}
public void ReadArbre(
CListeObjetsDonnees listeSource,
CListeObjetsDonnees.CArbreProps arbre,
List <string> lstPaquetsALire)
{
string strCle = "";
string strPropriete = "";
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
strPropriete = arbre.ProprietePrincipale;//Mode sans DefinitionProprieteDynamique
}
Type typeObjets = listeSource.TypeObjets;
Hashtable sousArbresToRemove = new Hashtable();
PropertyInfo info = typeObjets.GetProperty(strPropriete);
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(OptimiseReadDependanceAttribute), true);
if (attribs.Length != 0)
{
string strProp = ((OptimiseReadDependanceAttribute)attribs[0]).ProprieteALire;
if (strProp.IndexOf('.') > 0)
{
string strSuite = strProp.Substring(strProp.IndexOf('.') + 1);
strProp = strProp.Substring(0, strProp.IndexOf('.'));
arbre.GetArbreSousProp(strSuite, true);
}
strPropriete = strProp;
}
}
CStructureTable structure = CStructureTable.GetStructure(typeObjets);
//Cherche la relation liée à la propriete
bool bRelationTrouvee = false;
foreach (CInfoRelation relation in structure.RelationsFilles)
{
if (relation.Propriete == strPropriete)
{
ReadDependanceFille(
strPropriete,
listeSource,
arbre,
relation,
lstPaquetsALire);
lstPaquetsALire = null;
bRelationTrouvee = true; break;
}
}
if (!bRelationTrouvee)
{
foreach (CInfoRelation relation in structure.RelationsParentes)
{
if (relation.Propriete == strPropriete)
{
ReadDependanceParente(strPropriete, listeSource, arbre, relation);
bRelationTrouvee = true;
}
}
}
if (!bRelationTrouvee)
{
sousArbresToRemove[arbre] = true;
}
foreach (CListeObjetsDonnees.CArbreProps arbreTmp in sousArbresToRemove.Keys)
{
arbre.SousArbres.Remove(arbreTmp);
}
}
//------------------------------------------
private void InitChamps()
{
m_txtNomTable.Text = m_tableExport.NomTable;
//Indicateur de filtre
m_imageFiltre.Image = m_imagesFiltre.Images[m_tableExport.FiltreAAppliquer == null ? 1 : 0];
m_wndListeChamps.Items.Clear();
m_wndListeChamps.BeginUpdate();
if (m_tableExport.ChampOrigine is CDefinitionProprieteDynamiqueFormule)
{
m_imageFormuleTable.Visible = true;
}
else
{
m_imageFormuleTable.Visible = false;
}
m_imageFiltre.Visible = m_imageFiltre.Visible && !m_imageFormuleTable.Visible;
foreach (C2iChampExport champ in m_tableExport.Champs)
{
ListViewItem item = new ListViewItem();
FillItemForChamp(item, champ);
m_wndListeChamps.Items.Add(item);
}
m_wndListeChamps.EndUpdate();
//Peut-on appliquer un filtre sur cette table ?
m_imageFiltre.Visible = false;
if (m_structureExport.IsStructureComplexe && m_tableExport.ChampOrigine != null &&
m_tableExport.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee ||
m_tableExport.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
m_imageFiltre.Visible = true;
}
if (!m_imageFiltre.Visible && m_tableParente != null)
{
Type typeParent = m_structureExport.TypeSource;
if (m_tableParente != null && m_tableParente.ChampOrigine != null)
{
typeParent = m_tableParente.ChampOrigine.TypeDonnee.TypeDotNetNatif;
}
string strProp = m_tableExport.ChampOrigine.NomPropriete;
string[] strProps = strProp.Split('.');
PropertyInfo info = null;
string strTmp = "";
foreach (string strSousProp in strProps)
{
string strSousPropDecomposee = strSousProp;
CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strSousProp, ref strTmp, ref strSousPropDecomposee);
info = typeParent.GetProperty(strSousPropDecomposee);
if (info != null)
{
typeParent = info.PropertyType;
}
else
{
break;
}
}
if (info != null)
{
m_imageFiltre.Visible = typeof(CListeObjetsDonnees).IsAssignableFrom(info.PropertyType);
}
}
// Est-ce une structure simple ?
if (!m_structureExport.IsStructureComplexe)
{
m_imageFiltre.Visible = false;
Type tp = m_structureExport.TypeSource;
if (m_tableExport.ChampOrigine != null)
{
tp = m_tableExport.ChampOrigine.TypeDonnee.TypeDotNetNatif;
}
CStructureTable structure = CStructureTable.GetStructure(tp);
m_wndListeChamps.BeginUpdate();
foreach (CInfoChampTable info in structure.Champs)
{
ListViewItem item = new ListViewItem(info.NomChamp);
item.Tag = info;
m_wndListeChamps.Items.Add(item);
}
m_wndListeChamps.EndUpdate();
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
object elementToModif = Process.GetValeurChamp(VariableAModifier.IdVariable);
if (elementToModif is CObjetDonnee)
{
elementToModif = ((CObjetDonnee)elementToModif).GetObjetInContexte(contexte.ContexteDonnee);
}
if (elementToModif == null)
{
return(result);
}
object nouvelleValeur = null;
if (!(ExpressionValeur is C2iExpressionNull))
{
//Calcule la nouvelle valeur
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionValeur.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionValeur.ToString()));
return(result);
}
nouvelleValeur = result.Data;
}
if (m_definitionPropriete.NomPropriete.Length > 1 &&
m_definitionPropriete.NomPropriete[0] == CDefinitionProprieteDynamique.c_strCaractereStartCleType)
{
result = CInterpreteurProprieteDynamique.SetValue(elementToModif, m_definitionPropriete, nouvelleValeur);
}
else
{
//Ancienne méthode
//Si modif de champ custom
if (m_definitionPropriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(elementToModif is IElementAChamps))
{
result.EmpileErreur(I.T("@1 : Incorrect custom field or invalid target|217", m_definitionPropriete.Nom));
return(result);
}
result = ((IElementAChamps)elementToModif).SetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)m_definitionPropriete).DbKeyChamp.StringValue, nouvelleValeur);
return(result);
}
//récupère les éléments à modifier
string[] strProps = m_definitionPropriete.NomPropriete.Split('.');
ArrayList lstElementsAModifier = new ArrayList();
lstElementsAModifier.Add(elementToModif);
for (int nProp = 0; nProp < strProps.Length - 1; nProp++)
{
string strProp = strProps[nProp];
string strTmp = "";
CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strProp, ref strTmp, ref strProp);
ArrayList newListe = new ArrayList();
foreach (object objet in lstElementsAModifier)
{
object newToModif = CInterpreteurTextePropriete.GetValue(objet, strProp);
if (newToModif != null)
{
newListe.Add(newToModif);
}
}
lstElementsAModifier = newListe;
}
string strLastProp = strProps[strProps.Length - 1];
MethodInfo fonctionFinale = null;
//Modifie la valeur
foreach (object obj in lstElementsAModifier)
{
try
{
if (fonctionFinale == null)
{
object dummy = null;
MemberInfo membre = null;
string strTmp = "";
CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strLastProp, ref strTmp, ref strLastProp);
CInterpreteurTextePropriete.GetObjetFinalEtMemberInfo(obj, strLastProp, ref dummy, ref membre);
if (membre == null || !(membre is PropertyInfo))
{
result.EmpileErreur(I.T("The @1 property cannot be find|218", strLastProp));
return(result);
}
fonctionFinale = ((PropertyInfo)membre).GetSetMethod(true);
if (fonctionFinale == null)
{
result.EmpileErreur(I.T("The @1 property is in reading only|219", strLastProp));
return(result);
}
}
fonctionFinale.Invoke(obj, new object[] { nouvelleValeur });
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
}
}
return(result);
}
//**********************************************************************************
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
if (listeSource.Count == 0)
{
return;
}
CObjetDonneeAIdNumerique objExemple = listeSource[0] as CObjetDonneeAIdNumerique;
if (objExemple == null)
{
return;
}
string strCle = "";
string strPropSansCle = "";
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropSansCle))
{
return;
}
//trouve la relation correspondante à l'identifiant de la propriété
RelationTypeIdAttribute relation = null;
foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
{
if (relTest.IdRelation == strPropSansCle)
{
relation = relTest;
break;
}
}
if (relation == null)
{
return;
}
string strNomColDep = relation.GetNomColDepLue();
DataColumn col = objExemple.Table.Columns[strNomColDep];
if (col == null)
{
col = new DataColumn(strNomColDep, typeof(bool));
col.DefaultValue = false;
col.AllowDBNull = false;
objExemple.Table.Columns.Add(col);
}
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(objExemple.GetChampId(), col);
}
foreach (string strPaquet in lstPaquetsALire)
{
if (strPaquet != null && strPaquet.Trim().Length > 0)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relation.TableFille));
lst.Filtre = new CFiltreData(
relation.ChampType + "=@1 and " +
relation.ChampId + " in " + strPaquet,
listeSource.TypeObjets.ToString());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
foreach (CObjetDonneeAIdNumerique obj in listeSource)
{
CContexteDonnee.ChangeRowSansDetectionModification(obj.Row, strNomColDep, true);
}
}
//------------------------------------------------------------------------------------------
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
string strIdChamp = "";
string strPropriete = "";
string strCle = "";
if (listeSource.Count == 0)
{
return;
}
bool bFromEntiteToChamp = false;
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
return;
}
if (!CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bFromEntiteToChamp))
{
//c'est une relation vers des valeurs de champ qui pointent sur cette valeur.
//Ignore, et traite tout dans le composant suivant qui est un Entité to champ à l'envers
listeSource.ReadDependances(arbre);
return;
}
//On a affaire à une liste source qui contient des valeurs qui sont pointées
//par des valeurs de champs, et on veut les éléments qui pointent sur ces valeurs de champs
CChampCustom champ = new CChampCustom(listeSource.ContexteDonnee);
CDbKey dbKeyChamp = CDbKey.CreateFromStringValue(strIdChamp);
if (!champ.ReadIfExists(dbKeyChamp))
{
return;
}
//Vérifie que la liste source est bien du type de données du champ custom
if (champ.TypeDonnee.TypeDotNetNatif != listeSource.TypeObjets)
{
return;
}
IObjetDonneeAIdNumerique obj = listeSource[0] as IObjetDonneeAIdNumerique;
if (obj == null)
{
return;
}
string strChampId = obj.GetChampId();
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(strChampId, null);
}
//Trouve le type des éléments à champs
Type typeElementsFinaux = champ.Role.TypeAssocie;
//Trouve le type des relations aux elementAchamp_ChampCustom
IObjetDonneeAChamps elt = Activator.CreateInstance(typeElementsFinaux, new object[] { listeSource.ContexteDonnee }) as IObjetDonneeAChamps;
if (elt == null)
{
return;
}
string strNomTableRelToChamp = elt.GetNomTableRelationToChamps();
Type tpRelToChamp = CContexteDonnee.GetTypeForTable(strNomTableRelToChamp);
if (tpRelToChamp == null)
{
return;
}
foreach (string strPaquet in lstPaquetsALire)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee, typeElementsFinaux);
//TESTDBKEYTODO
string strChampCustomId = dbKeyChamp.IsNumericalId() ? CChampCustom.c_champId : CObjetDonnee.c_champIdUniversel;
lst.Filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(typeElementsFinaux),
strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
strPaquet,
dbKeyChamp.GetValeurInDb());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
