/// <summary>
/// /// ///////////////////////////////////////
/// </summary>
/// <param name="obj"></param>
public CReferenceObjetDonnee(CObjetDonnee obj)
{
m_typeObjet = obj.GetType();
m_cles = obj.GetValeursCles();
if (obj.ManageIdUniversel)
{
m_keyObjet = obj.DbKey;
}
}
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 List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
foreach (CInfoRelation relation in structure.RelationsParentes)
{
Type tpParent = CContexteDonnee.GetTypeForTable(relation.TableParente);
if (manager.ConfigurationRecherche.IsIgnore(tpParent))
{
return(lst);
}
CObjetDonnee parent = objet.GetParent(relation.ChampsFille, tpParent);
bool bHasUniversalId = tpParent.GetCustomAttribute <NoIdUniverselAttribute>(true) == null;
string strNomProp = relation.NomConvivial;
if (strNomProp.Length == 0)
{
strNomProp = DynamicClassAttribute.GetNomConvivial(tpParent);
}
if (parent != null)
{
if (bHasUniversalId)
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpParent, parent.DbKey));
}
else
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpParent,
parent.GetValeursCles()));
}
}
}
return(lst);
}
private void m_textBox_DragDrop(object sender, DragEventArgs e)
{
CReferenceObjetDonnee refObj = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
if (m_typeObjets != null && m_typeObjets.IsAssignableFrom(refObj.TypeObjet))
{
CObjetDonnee objet = refObj.GetObjet(CSc2iWin32DataClient.ContexteCourant);
if (objet != null)
{
if (m_filtre == null)
{
ElementSelectionne = objet;
}
else
{
CFiltreData filtre = CFiltreData.GetAndFiltre(m_filtre,
objet.GetFiltreCles(objet.GetValeursCles()));
CListeObjetsDonnees lst = new CListeObjetsDonnees(objet.ContexteDonnee, m_typeObjets, filtre);
if (lst.Count == 1)
{
ElementSelectionne = objet;
}
}
}
}
}
//----------------------------------------------------------------------------
public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
foreach (CInfoRelation relation in structure.RelationsFilles)
{
Type tpFille = CContexteDonnee.GetTypeForTable(relation.TableFille);
if (manager.ConfigurationRecherche.IsIgnore(tpFille))
{
return(lst);
}
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.FiltreAAppliquer = CFiltreData.CreateFiltreAndSurValeurs(relation.ChampsFille, objet.GetValeursCles());
requete.TableInterrogee = relation.TableFille;
bool bHasUniversalId = tpFille.GetCustomAttribute <NoIdUniverselAttribute>(true) == null;
if (bHasUniversalId)
{
requete.ListeChamps.Add(new C2iChampDeRequete(CObjetDonnee.c_champIdUniversel,
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
}
else
{
CStructureTable sFille = CStructureTable.GetStructure(tpFille);
foreach (CInfoChampTable infoChamp in sFille.ChampsId)
{
requete.ListeChamps.Add(new C2iChampDeRequete(infoChamp.NomChamp,
new CSourceDeChampDeRequete(infoChamp.NomChamp),
infoChamp.TypeDonnee,
OperationsAgregation.None,
true));
}
}
string strNomProp = relation.NomConvivial;
if (strNomProp.Length == 0)
{
strNomProp = "List of " + DynamicClassAttribute.GetNomConvivial(tpFille);
}
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
foreach (DataRow row in table.Rows)
{
if (bHasUniversalId)
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpFille, CDbKey.GetNewDbKeyOnUniversalIdANePasUtiliserEnDehorsDeCDbKeyAddOn((string)row[0])));
}
else
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpFille,
row.ItemArray));
}
}
}
}
return(lst);
}
////////////////////////////////////////////////////////////
private void Init(
CObjetDonnee objetParent,
string strNomTableFille,
string[] strChampsFille,
bool bAppliquerFiltreParDefaut)
{
m_strNomTableFille = strNomTableFille;
m_strChampsFille = strChampsFille;
m_objetConteneur = objetParent;
if (!RemplissageProgressif)
{
objetParent.AssureDependances(strNomTableFille, strChampsFille);
}
/*Stef 26042012 : suppression de cette optimisation,
* le problème est que si on ajoute des fils, alors, le filtre ne les voit plus !
* DataTable tableFille = ContexteDonnee.GetTableSafe(strNomTableFille);
* if (!RemplissageProgressif && tableFille != null && tableFille.PrimaryKey.Length == 1 &&
* tableFille.PrimaryKey[0].DataType == typeof(int))
* {
* string strFK = ContexteDonnee.GetForeignKeyName(objetParent.GetNomTable(), strNomTableFille, strChampsFille);
* DataRow[] rows = objetParent.Row.Row.GetChildRows(strFK);
* if (rows.Length == 0)
* m_filtrePrincipal = new CFiltreDataImpossible();
* else
* {
* DataColumn colKey = tableFille.PrimaryKey[0];
* StringBuilder bl = new StringBuilder();
* foreach (DataRow row in rows)
* {
* bl.Append(row[colKey]);
* bl.Append(',');
* }
* bl.Remove(bl.Length - 1, 1);
* m_filtrePrincipal = new CFiltreData(colKey.ColumnName + " in (" + bl.ToString() + ")");
* }
* }
* else*/
m_filtrePrincipal = CFiltreData.CreateFiltreAndSurValeurs(strChampsFille, objetParent.GetValeursCles());
m_bAppliquerFiltreParDefaut = bAppliquerFiltreParDefaut;
#if PDA
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTableFille));
objet.ContexteDonnee = m_objetConteneur.ContexteDonnee;
#else
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTableFille), new object[] { m_objetConteneur.ContexteDonnee });
#endif
CFiltreData filtre = bAppliquerFiltreParDefaut?objet.FiltreStandard:null;
if (filtre != null)
{
m_filtrePrincipal = CFiltreData.GetAndFiltre(m_filtrePrincipal, filtre);
}
if (!RemplissageProgressif)
{
//Puisque les objets sont lus, il n'y a aucune raison d'aller relire cette liste depuis
//La base de données
InterditLectureInDB = true;
m_bIsToRead = false;
}
}
////////////////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (result)
{
result = base.Serialize(serializer);
}
if (!result)
{
return(result);
}
bool bHasConteneur;
serializer.TraiteString(ref m_strNomTableFille);
int nNbChampsFille = m_strChampsFille.Length;
serializer.TraiteInt(ref nNbChampsFille);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strChamp in m_strChampsFille)
{
string strTmp = strChamp;
serializer.TraiteString(ref strTmp);
}
break;
case ModeSerialisation.Lecture:
m_strChampsFille = new string[nNbChampsFille];
for (int nChamp = 0; nChamp < nNbChampsFille; nChamp++)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
m_strChampsFille[nChamp] = strTmp;
}
break;
}
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
bHasConteneur = m_objetConteneur != null;
serializer.TraiteBool(ref bHasConteneur);
if (bHasConteneur)
{
Type tp = m_objetConteneur.GetType();
serializer.TraiteType(ref tp);
object[] lstValeurs = m_objetConteneur.GetValeursCles();
int nNbValeurs = lstValeurs.Length;
serializer.TraiteInt(ref nNbValeurs);
foreach (object obj in lstValeurs)
{
object obj_tmp = obj;
serializer.TraiteObjetSimple(ref obj_tmp);
}
}
break;
case ModeSerialisation.Lecture:
bHasConteneur = false;
serializer.TraiteBool(ref bHasConteneur);
if (!bHasConteneur)
{
m_objetConteneur = null;
}
else
{
Type tp = null;
serializer.TraiteType(ref tp);
#if PDA
m_objetConteneur = (CObjetDonnee)Activator.CreateInstance(tp);
m_objetConteneur.ContexteDonnee = m_contexte;
#else
m_objetConteneur = (CObjetDonnee)Activator.CreateInstance(tp, new object[] { m_contexte });
#endif
int nNbCles = 0;
serializer.TraiteInt(ref nNbCles);
object[] lst = new object[nNbCles];
for (int nCle = 0; nCle < nNbCles; nCle++)
{
serializer.TraiteObjetSimple(ref lst[nCle]);
}
m_objetConteneur.PointeSurLigne(lst);
}
break;
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
Init(m_objetConteneur, m_strNomTableFille, m_strChampsFille, m_bAppliquerFiltreParDefaut);
}
return(result);
}
