//-----------------------------------------------------------------
public static string GetDonneeDynamiqueString(object obj, string strPropriete, string strValeurSiNull)
{
string strSuite = "";
CDefinitionProprieteDynamique defProp = GetDefinitionProprieteDynamique(strPropriete, ref strSuite);
if (defProp != null)
{
try
{
object retour = CInterpreteurProprieteDynamique.GetValue(obj, defProp).Data;
if (retour == null)
{
return(strValeurSiNull);
}
if (strSuite != "")
{
return(GetDonneeDynamiqueString(retour, strSuite, strValeurSiNull));
}
return(retour.ToString());
}
catch
{
return(strValeurSiNull);
}
}
try
{
return(CInterpreteurTextePropriete.GetStringValue(obj, strPropriete, strValeurSiNull));
}
catch
{
return(strValeurSiNull);
}
}
//------------------------------------------------------------
public object GetValeurPropriete(object objetInterroge, CDefinitionProprieteDynamique propriete)
{
if (objetInterroge is CProcess && propriete is CDefinitionProprieteDynamiqueVariableDynamique)
{
byte[] bt = m_process.GetSerialisationValeurVariable(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
if (bt == null)
{
return(null);
}
MemoryStream stream = new MemoryStream(bt);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire serializer = new CSerializerReadBinaire(reader);
object valeur = null;
CVariableDynamique variable = m_process.GetVariable(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
CResultAErreur result = CSerializerValeursVariablesProcess.SerializeValeurVariable(ref valeur, variable, serializer, m_contexte);
if (result)
{
return(valeur);
}
return(null);
}
else
{
return(CInterpreteurProprieteDynamique.GetValue(objetInterroge, propriete.NomPropriete).Data);
}
}
protected override CResultAErreur MyMajChamps(bool bAvecVerification)
{
if (EditedElement != null && WndTextBox != null && WndTextBox.Property != null && !LockEdition)
{
return(CInterpreteurProprieteDynamique.SetValue(EditedElement, WndTextBox.Property, m_textBox.Text));
}
return(CResultAErreur.True);
}
//----------------------------------------------------
public int Compare(IElementDeGantt elt1, IElementDeGantt elt2)
{
int nResult = 0;
if (m_propriete == null)
{
if (elt1 != null && elt2 != null)
{
nResult = elt1.IndexTri.CompareTo(elt2.IndexTri);
}
if (nResult == 0)
{
nResult = elt1.DateDebut.CompareTo(elt2.DateDebut);
}
}
else
{
if (!m_bOptimiseurSet)
{
m_optimiseur = CInterpreteurProprieteDynamique.GetOptimiseur(elt1.GetType(), m_propriete.NomPropriete);
m_bOptimiseurSet = true;
}
try
{
object val1 = null;
object val2 = null;
if (m_optimiseur != null)
{
val1 = m_optimiseur.GetValue(elt1);
val2 = m_optimiseur.GetValue(elt2);
}
else
{
val1 = CInterpreteurProprieteDynamique.GetValue(elt1, m_propriete);
val2 = CInterpreteurProprieteDynamique.GetValue(elt2, m_propriete);
}
if (val1 == val2)
{
if (m_parametreSuivant != null)
{
return(m_parametreSuivant.Compare(elt1, elt2));
}
return(0);
}
nResult = 0;
if (val1 is IComparable)
{
nResult = ((IComparable)val1).CompareTo(val2);
}
}
catch { }
}
if (m_bDecroissant)
{
nResult = -nResult;
}
return(nResult);
}
public object GetObjectValueForGrid(object element)
{
if (m_property != null)
{
CResultAErreur result = CInterpreteurProprieteDynamique.GetValue(element, m_property);
return(result.Data);
}
return(null);
}
protected override CResultAErreur MyMajChamps(bool bControlerLesValeursAvantValidation)
{
if (EditedElement != null)
{
if (WndFiltreRapide != null && WndFiltreRapide.Property != null && !LockEdition)
{
return(CInterpreteurProprieteDynamique.SetValue(EditedElement, WndFiltreRapide.Property, m_selectionneur.ElementSelectionne));
}
}
return(CResultAErreur.True);
}
//----------------------------------------------------------
protected override void OnChangeElementEdite(object element)
{
if (element != null && WndDateTime != null &&
WndDateTime.Property != null &&
m_dateTimeEx != null)
{
DateTime?valeur = CInterpreteurProprieteDynamique.GetValue(element, WndDateTime.Property).Data as DateTime?;
m_dateTimeEx.Value = valeur;
}
}
//----------------------------------------------------------------------------------------
public void SetValeurDynamiqueDeportee(string strPropriete, object valeur)
{
if (m_controleAssocie == null)
{
return;
}
try{
CInterpreteurProprieteDynamique.SetValue(m_controleAssocie, strPropriete, valeur);
}
catch {}
}
//----------------------------------------------------------
protected override CResultAErreur MyMajChamps(bool bControlerLesValeursAvantValidation)
{
DateTime?dateValue = m_dateTimeEx.Value;
if (WndDateTime != null && WndDateTime.Property != null &&
m_dateTimeEx != null && EditedElement != null && !LockEdition)
{
return(CInterpreteurProprieteDynamique.SetValue(EditedElement, WndDateTime.Property, dateValue));
}
return(CResultAErreur.True);
}
protected override void OnChangeElementEdite(object element)
{
if (element != null &&
WndTextBox != null &&
WndTextBox.Property != null &&
m_textBoxNumerique != null)
{
int?nValue = CInterpreteurProprieteDynamique.GetValue(element, WndTextBox.Property).Data as int?;
m_textBoxNumerique.IntValue = nValue;
}
}
//----------------------------------------------------------
protected override void OnChangeElementEdite(object element)
{
if (element != null &&
m_textBoxNumerique != null &&
WndTextBoxDecimal != null &&
WndTextBoxDecimal.Property != null)
{
double?fValeur = CInterpreteurProprieteDynamique.GetValue(EditedElement, WndTextBoxDecimal.Property).Data as double?;
m_textBoxNumerique.DoubleValue = fValeur;
}
}
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 object GetValeurDynamiqueDeportee(string strPropriete)
{
if (m_controleAssocie == null)
{
return(null);
}
CResultAErreur result = CInterpreteurProprieteDynamique.GetValue(m_controleAssocie, strPropriete);
if (result)
{
return(result.Data);
}
return(null);
}
/// <summary>
/// //////////////////////////////////////////////////
/// </summary>
/// <param name="tableOrigines"></param>
public override void AddProprietesOrigineToTable(
Type typeSource,
Hashtable tableOrigines,
string strChemin,
CContexteDonnee contexteDonnee)
{
if (strChemin.Length > 0)
{
strChemin += ".";
}
string[] strProps = CInterpreteurProprieteDynamique.GetProprietesAccedees(typeSource, ChampOrigine.NomPropriete);
if (strProps != null)
{
foreach (string strProp in strProps)
{
tableOrigines[strChemin + strProp] = true;
}
}
else
{
string strOrigine = ChampOrigine.NomPropriete;
tableOrigines[strChemin + strOrigine] = true;
}
/*
* if (ChampOrigine is CDefinitionProprieteDynamiqueChampCalcule)
* {
* if (contexteDonnee != null)
* {
* CDefinitionProprieteDynamiqueChampCalcule defCal = (CDefinitionProprieteDynamiqueChampCalcule)ChampOrigine;
* CChampCalcule champCal = new CChampCalcule(contexteDonnee);
* if (champCal.ReadIfExists(defCal.IdChamp))
* {
* C2iExpression expression = champCal.Formule;
* if (expression != null)
* {
* CArbreDefinitionsDynamiques arbre = new CArbreDefinitionsDynamiques(null);
* expression.GetArbreProprietesAccedees(arbre);
* CDefinitionProprieteDynamiqueChampCalcule.DetailleSousArbres(arbre, contexteDonnee);
* AddProprietesArbre(arbre, tableOrigines, strChemin);
* }
* }
* }
* }
* else
* {
* string strOrigine = ChampOrigine.NomPropriete;
* tableOrigines[strChemin + strOrigine] = true;
* }*/
}
protected override void OnChangeElementEdite(object element)
{
if (WndTextBox != null && WndTextBox.Property != null)
{
string strValue = CInterpreteurProprieteDynamique.GetValue(element, WndTextBox.Property).Data as string;
if (strValue != null)
{
m_textBox.Text = strValue;
}
else
{
m_textBox.Text = "";
}
}
}
protected override void OnChangeElementEdite(object element)
{
if (
EditedElement != null &&
WndCheckBox != null &&
WndCheckBox.Property != null &&
m_checkBox != null)
{
object valeur = CInterpreteurProprieteDynamique.GetValue(EditedElement, WndCheckBox.Property).Data;
if (valeur is bool)
{
m_checkBox.Checked = (bool)valeur;
}
}
}
//--------------------------------------
public CResultAErreur AffecteProprietes(
object elementToModif,
object sourceElement,
IFournisseurProprietesDynamiques fournisseurProprietes)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(sourceElement);
CResultAErreur resTmp;
foreach (KeyValuePair <CDefinitionProprieteDynamique, C2iExpression> aff in m_dicAffectations)
{
if (aff.Value != null)
{
resTmp = aff.Value.Eval(ctx);
if (!resTmp)
{
result += resTmp;
}
else
{
resTmp = CInterpreteurProprieteDynamique.SetValue(elementToModif, aff.Key.NomPropriete, resTmp.Data);
if (!resTmp)
{
result += resTmp;
}
}
}
}
if (m_formuleGlobale != null)
{
CDefinitionMultiSourceForExpression def = new CDefinitionMultiSourceForExpression(sourceElement,
new CSourceSupplementaire("NewElement", elementToModif));
ctx = new CContexteEvaluationExpression(def);
if (elementToModif is IAllocateurSupprimeurElements)
{
ctx.AttacheObjet(typeof(IAllocateurSupprimeurElements), elementToModif);
}
resTmp = m_formuleGlobale.Eval(ctx);
if (!resTmp)
{
result += resTmp;
}
}
return(result);
}
protected override CResultAErreur MyMajChamps(bool bControlerLesValeursAvantValidation)
{
CResultAErreur result = CResultAErreur.True;
if (EditedElement != null &&
WndTextBox != null &&
WndTextBox.Property != null &&
m_textBoxNumerique != null &&
!LockEdition)
{
try
{
int?nValue = m_textBoxNumerique.IntValue;
return(CInterpreteurProprieteDynamique.SetValue(EditedElement, WndTextBox.Property, nValue));
}
catch
{
result.EmpileErreur(I.T("Incorrect numerical value|30000"));
}
}
return(result);
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonnee objetDonnee = objet as CObjetDonnee;
if (objetDonnee == null)
{
result.Data = null;
return(result);
}
int nIdSmartField = -1;
try
{
nIdSmartField = Int32.Parse(strPropriete);
}
catch
{
result.EmpileErreur(I.T("Bad SmartField field format (@1)|20059", strPropriete));
return(result);
}
CContexteDonnee contexte = objetDonnee.ContexteDonnee;
CSmartField smartField = new CSmartField(contexte);
if (!smartField.ReadIfExists(nIdSmartField))
{
result.EmpileErreur(I.T("Smart field @1 doesn't exists|20060", strPropriete));
return(result);
}
if (smartField.Definition != null)
{
return(CInterpreteurProprieteDynamique.GetValue(objet, smartField.Definition));
}
result.Data = null;
return(result);
}
public static void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(CDefinitionProprieteDynamiqueChampEntiteSnmp.c_cleType,
typeof(CIntepreteurProprieteDynamiqueChampEntiteSnmp));
}
public static new void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(c_strCleType, typeof(CInterpreteurProprieteDynamiqueDeportee));
}
//-----------------------------------------------
public static new void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(c_strCleType, typeof(CInterpreteurProprieteDynamiqueDotNet));
CComposantFiltreChamp.FindRelationComplementaire += new FindRelationDelegate(FindRelation);
}
//-----------------------------------------------------------------
public static void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(
CDefinitionProprieteDynamiqueSnmpTable.c_cleType,
typeof(CInterpreteurProprieteDynamicSnmpTable));
}
protected override void OnChangeElementEdite(object element)
{
if (element != null &&
WndFiltreRapide != null)
{
CFiltreData filtreData;
if (WndFiltreRapide.Filter != null)
{
CElementAVariablesDynamiques eltAVar = new CElementAVariablesDynamiques();
CVariableDynamiqueStatique var = new CVariableDynamiqueStatique(eltAVar);
var.Nom = "EditedElement";
var.IdVariable = "0";
var.SetTypeDonnee(new CTypeResultatExpression(element.GetType(), false));
eltAVar.AddVariable(var);
eltAVar.SetValeurChamp(var, element);
CFiltreDynamique filtreDyn = WndFiltreRapide.Filter;
filtreDyn.ElementAVariablesExterne = eltAVar;
filtreData = (CFiltreData)filtreDyn.GetFiltreData().Data;
}
else
{
filtreData = null;
}
Type typePropriete = null;
if (WndFiltreRapide.Property != null)
{
typePropriete = WndFiltreRapide.Property.TypeDonnee.TypeDotNetNatif;
}
else if (WndFiltreRapide.Filter != null)
{
typePropriete = WndFiltreRapide.Filter.TypeElements;
}
if (typePropriete != null)
{
string strDesc = DescriptionFieldAttribute.GetDescriptionField(typePropriete, "DescriptionElement");
C2iTextBoxFiltreRapide txtRapide = m_selectionneur as C2iTextBoxFiltreRapide;
if (txtRapide != null)
{
txtRapide.InitAvecFiltreDeBase(typePropriete, strDesc, filtreData, true);
}
else
{
CComboBoxListeObjetsDonnees cmb = m_selectionneur as CComboBoxListeObjetsDonnees;
cmb.NullAutorise = true;
cmb.TextNull = I.T("None|19");
if (cmb != null)
{
cmb.Init(
typePropriete,
filtreData,
strDesc,
true);
}
}
if (WndFiltreRapide.Property != null)
{
CObjetDonnee valeur = CInterpreteurProprieteDynamique.GetValue(EditedElement, WndFiltreRapide.Property).Data as CObjetDonnee;
m_selectionneur.ElementSelectionne = valeur;
}
}
}
}
//-----------------------------------------------------------------
public static void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(
CDefinitionCurrentItemMapPoint.c_cleType,
typeof(CInterpreteurProprieteCurrentItemMapPoint));
}
//----------------------------------------------------------------------------------
public static void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(CDefinitionProprieteDynamiqueTrapFieldSupplementaire.c_cleType, typeof(CInterpreteurProprieteDynamiqueTrapFieldSupplementaire));
}
//-----------------------------------------------------------------
public static void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(
CDefinitionProprieteDynamicDataTableCell.c_cleType,
typeof(CInterpreteurProprieteDynamiqueDataTableCell));
}
//---------------------------------------------------------------
private void CalculeValeurs(IEnumerable <CDefinitionProprieteDynamique> lstChamps)
{
m_dicValeursSimples = new Dictionary <CDefinitionProprieteDynamique, object>();
m_dicValeursParentes = new Dictionary <CDefinitionProprieteDynamique, CValeursProprietes>();
m_dicValeursFilles = new Dictionary <CDefinitionProprieteDynamique, List <CValeursProprietes> >();
if (m_objetAssocie == null)
{
return;
}
DataRowVersion oldVers = m_objetAssocie.VersionToReturn;
m_objetAssocie.VersionToReturn = m_versionObjetStocke;
m_strLibelleObjet = m_objetAssocie.DescriptionElement;
HashSet <CDbKey> dicChampsAffectes = new HashSet <CDbKey>();
//Optimisation des champs custom
IElementAChamps eltAChamps = m_objetAssocie as IElementAChamps;
if (eltAChamps != null)
{
foreach (CRelationElementAChamp_ChampCustom rel in eltAChamps.RelationsChampsCustom)
{
dicChampsAffectes.Add(rel.ChampCustom.DbKey);
}
}
CResultAErreur res = CResultAErreur.True;
foreach (CDefinitionProprieteDynamique def in lstChamps)
{
if (IsChampCompatibleImport(m_objetAssocie.GetType(), def))
{
try
{
bool bInterprete = true;
CDefinitionProprieteDynamiqueChampCustom defCust = def as CDefinitionProprieteDynamiqueChampCustom;
if (defCust != null)
{
bInterprete = dicChampsAffectes.Contains(defCust.DbKeyChamp);
}
if (bInterprete)
{
DateTime dt = DateTime.Now;
res = CInterpreteurProprieteDynamique.GetValue(m_objetAssocie, def);
TimeSpan sp = DateTime.Now - dt;
if (sp.TotalMilliseconds > 400)
{
dt = DateTime.Now;
}
if (res)
{
object obj = res.Data;
if (obj is CObjetDonnee)
{
CValeursProprietes val = new CValeursProprietes((CObjetDonnee)obj, m_bAvecValeursOriginales);
m_dicValeursParentes[def] = val;
}
else if (obj is IEnumerable && !(obj is string))
{
List <CValeursProprietes> lst = new List <CValeursProprietes>();
foreach (object valDeListe in (IEnumerable)obj)
{
if (valDeListe is CObjetDonnee)
{
lst.Add(new CValeursProprietes((CObjetDonnee)valDeListe, m_bAvecValeursOriginales));
}
}
if (lst.Count > 0)
{
m_dicValeursFilles[def] = lst;
}
}
else if (obj != null && C2iSerializer.IsObjetSimple(obj))
{
m_dicValeursSimples[def] = obj;
}
}
}
}
catch { }
}
}
if (m_bAvecValeursOriginales && m_objetAssocie.Row.RowState == DataRowState.Modified)
{
m_objetAssocie.VersionToReturn = DataRowVersion.Original;
m_valeursOriginales = new CValeursProprietes(m_objetAssocie, false);
}
m_objetAssocie.VersionToReturn = oldVers;
}
//------------------------------------
private CResultAErreur ImporteRow(DataRow row, CFiltreData filtreCle, CContexteDonnee contexteDestination)
{
CResultAErreur result = CResultAErreur.True;
Dictionary <CDefinitionProprieteDynamique, object> dicValeurs = new Dictionary <CDefinitionProprieteDynamique, object>();
List <object> lstValeurs = new List <object>();
if (filtreCle != null)
{
filtreCle.Parametres.Clear();
}
foreach (CMappageChampImport mappage in Mappages)
{
object valeur = mappage.Origine.GetValeur(row);
if (mappage.IsCle && filtreCle != null)
{
if (valeur == null)
{
result.EmpileErreur("Can not import field @1 as key, because imported value is null|20045", mappage.ProprieteDestination.Nom);
return(result);
}
filtreCle.Parametres.Add(valeur);
}
dicValeurs[mappage.ProprieteDestination] = valeur;
}
CObjetDonnee objet = Activator.CreateInstance(m_typeCible, new object[] { contexteDestination }) as CObjetDonnee;
bool bCreate = true;
//Cherche si l'objet exite
if (filtreCle != null)
{
bCreate = !objet.ReadIfExists(filtreCle, !m_bChargerTouteLaCible);
}
if (bCreate && (OptionImport & EOptionImport.Create) != EOptionImport.Create)
{
return(result);
}
if (!bCreate && (OptionImport & EOptionImport.Update) != EOptionImport.Update)
{
return(result);
}
if (bCreate)
{
objet.CreateNewInCurrentContexte(null);
}
bool bUpdate = false;
foreach (KeyValuePair <CDefinitionProprieteDynamique, object> kv in dicValeurs)
{
object val = kv.Value;
if (kv.Value is int && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(kv.Key.TypeDonnee.TypeDotNetNatif))
{
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(kv.Key.TypeDonnee.TypeDotNetNatif, new object[] { contexteDestination }) as CObjetDonneeAIdNumerique;
if (!obj.ReadIfExists((int)kv.Value, !m_bChargerTouteLaCible))
{
obj = null;
}
val = obj;
}
result = CInterpreteurProprieteDynamique.GetValue(objet, kv.Key);
if (result)
{
object valeurOrigine = result.Data;
if ((val == null && valeurOrigine != null) ||
(valeurOrigine == null && val != null) ||
(val != null && valeurOrigine != null && !val.Equals(valeurOrigine)))
{
result = CInterpreteurProprieteDynamique.SetValue(objet, kv.Key, val);
if (!result)
{
return(result);
}
bUpdate = true;
}
}
}
if (bCreate)
{
m_nNbCreated++;
}
else if (bUpdate)
{
m_nNbUpdated++;
}
return(result);
}
//-----------------------------------------------
public static new void Autoexec()
{
CInterpreteurProprieteDynamique.RegisterTypeDefinition(c_strCleType, typeof(CInterperteurProprieteDynamiqueChampCustomDisplayValue));
}
