/// ////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 1)
{
//TESTDBKEYOK
serializer.ReadDbKeyFromOldId(ref m_dbKeyChamp, typeof(CChampCustom));
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(m_dbKeyChamp))
{
//Convertit le nom de propriété avec les DbKey
//ne pas appeller SetNomProprieteSansCleTypeChamp(GetKeyChamp()) car pour les filtres,
//le nom de propriété peut contenir un chemin
ConvertNomProprieteFromIdToDbKey();
}
}
else
{
//TESTDBKEYOK
serializer.TraiteDbKey(ref m_dbKeyChamp);
}
return(result);
}
//-----------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
//TESTDBKEYTODO : remplacer IdChamp par DbKey
CDbKey dbKeyChampWrite = ChampCustom != null ? ChampCustom.DbKey : null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyChampWrite, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref dbKeyChampWrite);
}
break;
case ModeSerialisation.Lecture:
CContexteDonnee contexte = serializer.GetObjetAttache(typeof(CContexteDonnee)) as CContexteDonnee;
if (contexte == null)
{
contexte = CContexteDonneeSysteme.GetInstance();
}
//TESTDBKEYTODO : remplacer IdChamp par DbKey
CDbKey dbKeyChampRead = null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyChampRead, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref dbKeyChampRead);
}
if (dbKeyChampRead == null)
{
m_champ = null;
}
else
{
m_champ = new CChampCustom(contexte);
if (!m_champ.ReadIfExists(dbKeyChampRead))
{
m_champ = null;
}
}
break;
}
return(result);
}
//---------------------------------------------------------------------------------
public static object GetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp)
{
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(GetValeurChamp(objet, champ.Id, DataRowVersion.Default));
}
return(null);
}
public static int GetIdFromDbKey(CDbKey dbKey)
{
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(dbKey))
{
return(champ.Id);
}
return(-1);
}
//------------------------------------------------------------
public override CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
result.Data = null;
string strIdChamp = null;
bool bEntiteToChamp = false;
if (
/*Pour compatibilité, avant modifs de décembre 2015, le nom du champ était en fait le même qu'une propriété champ custom.
* En décembre 2015, ajout de la possiblité de retourner les valeurs display de champ custom dans les requêtes,
* ce qui a changé le nom de la propriétés
* */
CInfoRelationEntiteToValeurChampCustom.DecomposeNomPropriete(strPropriete, ref strIdChamp) ||
/*fin pour compatiblité*/
CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bEntiteToChamp))
{
IElementAChamps eltAChamps = objet as IElementAChamps;
if (eltAChamps == null)
{
return(result);
}
result.Data = eltAChamps.GetValeurChamp(strIdChamp);
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (result.Data != null && champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
if (!champ.IsChoixParmis())
{
result.Data = result.Data.ToString();
}
else
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
if (valeur.Value.Equals(result.Data))
{
result.Data = valeur.Display;
return(result);
}
}
}
}
}
else if (CInfoRelationEValeurChampCustomToDisplay.DecomposeNomPropriete(strPropriete, ref strIdChamp))
{
//Rien de spécial, il s'agit de la navigation vers la valeur du champ qui a déjà été reprise par le composant filtre to champ entité
//car la propriété complète d'un definitionDisplayValue est donnée par GetKeyChamp qui ajoute un composant Element->ValeurChamp + ValeurChamp->Display value
result.Data = objet;
}
return(result);
}
public static object GetValeurChamp(this IElementAChamps elt, CDbKey key, DataRowVersion version)
{
if (key != null)
{
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(key))
{
return(elt.GetValeurChamp(champ.Id, version));
}
}
return(null);
}
//---------------------------------------------------------------------------------
public static CResultAErreur SetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp, object valeur)
{
CResultAErreur result = CResultAErreur.True;
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(SetValeurChamp(objet, champ.Id, valeur));
}
result.EmpileErreur("Invalid Custom Field Id in SetValeurChamps (Line 179)");
return(result);
}
public COptimiseurProprieteDynamiqueChampCustomDisplayValue(CDbKey keyChamp)
{
m_dbKeyChamp = keyChamp;
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(keyChamp))
{
if (champ.IsChoixParmis())
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
m_dicValeurs[valeur.Value] = valeur.Display;
}
}
}
}
//----------------------------------------------------------------
public CDefinitionProprieteDynamique GetProprieteInverse(Type typePortantLaPropriete, CDefinitionProprieteDynamique def)
{
CDefinitionProprieteDynamiqueChampCustomFils defFils = def as CDefinitionProprieteDynamiqueChampCustomFils;
if (defFils == null)
{
return(null);
}
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(defFils.KeyChamp))
{
return(new CDefinitionProprieteDynamiqueChampCustom(champ));
}
return(null);
}
//---------------------------------------------------------------
public IChampPourVersion GetChamp(IElementAChampPourVersion element)
{
if (element.TypeChamp == CChampCustomPourVersion.c_typeChamp)
{
try
{
int nIdChamp = Int32.Parse(element.FieldKey);
CChampCustom champ = new CChampCustom(element.ContexteDonnee);
if (champ.ReadIfExists(nIdChamp))
{
return(new CChampCustomPourVersion(champ));
}
}
catch { }
}
return(null);
}
//----------------------------------------------------------------------------------
public CResultAErreur CreateChampInTable(IChampDeTable champExport, DataTable table)
{
CResultAErreur result = CResultAErreur.True;
if (champExport is C2iChampExport && ((C2iChampExport)champExport).Origine is C2iOrigineChampExportChampCustom)
{
C2iOrigineChampExportChampCustom origineCustom = (C2iOrigineChampExportChampCustom)((C2iChampExport)champExport).Origine;
//Récupère les noms et les types des champs custom
CContexteDonnee ctx = null;
if (table.DataSet is CContexteDonnee)
{
ctx = (CContexteDonnee)table.DataSet;
}
else
{
ctx = new CContexteDonnee(0, true, false);
}
//Lit les champs custom
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(ctx, typeof(CChampCustom));
listeChamps.AssureLectureFaite();
foreach (int nIdChamp in origineCustom.IdsChampCustom)
{
CChampCustom champ = new CChampCustom(ctx);
if (champ.ReadIfExists(nIdChamp))
{
if (champ.TypeDonneeChamp.TypeDonnee != TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
{
DataColumn colChamp = new DataColumn(c_strPrefixeChampCustom + champ.Nom, champ.TypeDonnee.TypeDotNetNatif);
colChamp.AllowDBNull = true;
table.Columns.Add(colChamp);
}
}
}
return(result);
}
if (table.Columns.Contains(champExport.NomChamp))
{
return(result);
}
DataColumn col = new DataColumn(champExport.NomChamp, champExport.TypeDonnee);
table.Columns.Add(col);
return(result);
}
//-------------------------------------------------------------------
//S'il n'y a pas de paramètres, lit tous les champs custom
public static void ReadChampsCustom(CListeObjetsDonnees lstObjets, params int[] idsChamps)
{
if (lstObjets.Count == 0)
{
return;
}
IObjetDonneeAChamps eltAChamps = lstObjets[0] as IObjetDonneeAChamps;
if (eltAChamps == null)
{
return;
}
if (idsChamps.Length == 0)
{
lstObjets.ReadDependances("RelationsChampsCustom");
foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
{
SetTousChampsLus(eltAChamp);
}
return;
}
List <string> lstChamps = new List <string>();
foreach (int nIdChamp in idsChamps)
{
CChampCustom champ = new CChampCustom(eltAChamps.ContexteDonnee);
if (champ.ReadIfExists(nIdChamp))
{
CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
lstChamps.Add(def.NomPropriete);
}
}
lstObjets.ReadDependances(lstChamps.ToArray());
foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
{
foreach (int nIdChamp in idsChamps)
{
SetChampsLus(eltAChamp, nIdChamp);
}
}
}
public string GetCleRestrictionCompatible(string strAncienneCleRestriction)
{
if (strAncienneCleRestriction.Length > CChampCustom.c_prefixeCleRestriction.Length &&
strAncienneCleRestriction.Substring(
0, CChampCustom.c_prefixeCleRestriction.Length) == CChampCustom.c_prefixeCleRestriction)
{
// Lire l'Id du Champ Custom
int nIdChamp = -1;
string strExtractIdChamp = strAncienneCleRestriction.Substring(CChampCustom.c_prefixeCleRestriction.Length);
try
{
nIdChamp = Int32.Parse(strExtractIdChamp);
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(nIdChamp))
{
return(champ.CleRestriction);
}
}
catch { }
}
return(strAncienneCleRestriction);
}
public override object GetValeur(object obj, CCacheValeursProprietes cacheValeurs, CRestrictionUtilisateurSurType restriction)
{
IApplatisseurProprietes applatisseur = obj as IApplatisseurProprietes;
if (applatisseur != null)
{
obj = applatisseur.GetObjetParDefaut();
}
if (m_strCleRestriction == "")
{
if (m_champOrigine is CDefinitionProprieteDynamiqueChampCustom)
{
CDbKey keyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champOrigine).DbKeyChamp;
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(keyChamp))
{
m_strCleRestriction = champ.CleRestriction;
}
}
else if (m_champOrigine != null)
{
m_strCleRestriction = m_champOrigine.NomProprieteSansCleTypeChamp;
}
}
if (restriction != null && m_strCleRestriction != "" && (restriction.GetRestriction(m_strCleRestriction) & ERestriction.Hide) == ERestriction.Hide)
{
return(null);
}
if (!m_bOptimFaite && obj != null)
{
m_bOptimFaite = true;
if (obj is CObjetDonnee)
{
m_strChampOrigineOptim = "";
PropertyInfo info = obj.GetType().GetProperty(m_champOrigine.NomProprieteSansCleTypeChamp);
//Il faut absolument stocker le type, car si
//Le champ vient d'une interface, tous les éléments ne sont pas forcement
//du même type, et ne proviennent pas forcement du même champ
m_typeOptim = obj.GetType();
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(AccesDirectInterditAttribute), true);
if (attribs.Length == 0)
{
attribs = info.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true);
if (attribs != null && attribs.Length > 0)
{
m_strChampOrigineOptim = ((TableFieldPropertyAttribute)attribs[0]).NomChamp;
}
}
}
}
if (m_strChampOrigineOptim == "")
{
m_optimiseur = CInterpreteurProprieteDynamique.GetOptimiseur(obj.GetType(), m_champOrigine.NomPropriete);
}
}
if (m_strChampOrigineOptim != "" && obj is CObjetDonnee && obj.GetType() == m_typeOptim)
{
return(((CObjetDonnee)obj).Row[m_strChampOrigineOptim]);
}
else if (m_optimiseur != null)
{
return(m_optimiseur.GetValue(obj));
}
else
{
return(CInterpreteurProprieteDynamique.GetValue(obj, ChampOrigine, cacheValeurs).Data);
}
}
//-------------------------------------------------------------------
public static CResultAErreur SetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp, object valeur)
{
/*
* ///Stef 18052011, passage de la recherche de l'élément sous forme de fonction
*
* string strTableValeurs = objet.GetNomTableRelationToChamps();
* string strChampId = objet.GetChampId();
* object dummy = null;
* if (!objet.IsDependanceChargee(strTableValeurs, strChampId))
* dummy = objet.RelationsChampsCustom;
* DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];
*
* string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
* strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;
*
*
* //Stef 20/07/2010 : si on fait un set avec version à -1, on modifie la version Referentiel.
* //Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
* //ce qui peut ramener plus d'1 élément, du coup, applique version fonctionne de manière aléatoire
* //car parfois, on modifie bien la version référentiel, d'autres fois, on modifie
* //autre chose (suivant ce qui est dans le contexte de données).
* if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
* {
* strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
* CSc2iDataConst.c_champIsDeleted + "=0";
* }
* else
* {
* strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
* }
*
* DataRow[] rows = table.Select(strFiltre);
* if (rows.Length > 0)
* {
* CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
* rel.SetRow(rows[0]);
* rel.Valeur = valeur;
* return CResultAErreur.True;
* }*/
CRelationElementAChamp_ChampCustom rel = GetRelationToChamp(objet, nIdChamp);
if (rel != null)
{
rel.Valeur = valeur;
return(CResultAErreur.True);
}
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
CResultAErreur result = CResultAErreur.True;
if (champ.ReadIfExists(nIdChamp))
{
CRelationElementAChamp_ChampCustom relation = objet.GetNewRelationToChamp();
relation.CreateNewInCurrentContexte();
relation.ElementAChamps = objet;
relation.ChampCustom = champ;
relation.Valeur = valeur;
}
else
{
result.EmpileErreur(I.T("The field n°@1 doesn't exist|234", nIdChamp.ToString()));
}
return(result);
}
/// //////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteInt(ref m_nButtonHorizontalMargin);
serializer.TraiteInt(ref m_nMargeVertical);
serializer.TraiteInt(ref m_nButtonWidth);
serializer.TraiteInt(ref m_nButtonHeight);
if (nVersion < 2)
{
int nTmp = 0;
serializer.TraiteInt(ref nTmp);
}
CDbKey key = null;
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
if (m_champCustom != null)
{
key = m_champCustom.DbKey;
}
serializer.TraiteDbKey(ref key);
break;
case ModeSerialisation.Lecture:
if (nVersion < 4)
{
// TESTDBKEYOK
serializer.ReadDbKeyFromOldId(ref key, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref key);
}
if (key != null)
{
CContexteDonnee ctx = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
if (ctx == null)
{
ctx = CContexteDonneeSysteme.GetInstance();
}
m_champCustom = new CChampCustom(ctx);
if (!m_champCustom.ReadIfExists(key))
{
m_champCustom = null;
}
}
else
{
m_champCustom = null;
}
break;
}
if (nVersion >= 2)
{
int nTmp = m_buttonColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_buttonColor = Color.FromArgb(nTmp);
nTmp = m_buttonInvalidateColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_buttonInvalidateColor = Color.FromArgb(nTmp);
nTmp = m_buttonSelectedColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_buttonSelectedColor = Color.FromArgb(nTmp);
}
if (nVersion >= 3)
{
serializer.TraiteListString(m_listeLimitToValues);
}
return(result);
}
/// //////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
bool bHasChamp = m_champCustom != null;
serializer.TraiteBool(ref bHasChamp);
int nId = 0;
if (bHasChamp)
{
switch (serializer.Mode)
{
/* TESTDBKEYOK (XL) */
case ModeSerialisation.Ecriture:
CDbKey dbKeyW = m_champCustom.DbKey;
serializer.TraiteDbKey(ref dbKeyW);
break;
case ModeSerialisation.Lecture:
CDbKey dbKey = null;
if (nVersion < 4)
{
serializer.ReadDbKeyFromOldId(ref dbKey, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref dbKey);
}
CContexteDonnee ctx = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
if (ctx == null)
{
ctx = CContexteDonneeSysteme.GetInstance();
}
m_champCustom = new CChampCustom(ctx);
if (!m_champCustom.ReadIfExists(dbKey))
{
m_champCustom = null;
}
break;
}
}
else
{
m_champCustom = null;
}
if (nVersion > 0)
{
serializer.TraiteString(ref m_strLibelleWeb);
serializer.TraiteInt(ref m_nNumWeb);
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bUseCombo);
}
else
{
m_bUseCombo = false;
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bAutoSetValue);
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
CDbKey dbKeyIdChamp = null;
object valeurRetournee = null;
//TESTDBKEYOK : le premier paramètre peut être un Id ou un UniversalId de champ
if (listeParametres.Length == 2)
{
if (listeParametres[0] is int)
{
int nIdChamp = (int)listeParametres[0];
dbKeyIdChamp = CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nIdChamp);
}
else
{
dbKeyIdChamp = CDbKey.CreateFromStringValue((string)listeParametres[0]);
}
valeurRetournee = listeParametres[1];
}
if (listeParametres.Length == 1)
{
//1 seul paramètre, ce doit être une expression variable avec une variable champ
C2iExpressionChamp exChamp = Parametres2i[0] as C2iExpressionChamp;
if (exChamp != null)
{
CDefinitionProprieteDynamiqueChampCustom def = exChamp.DefinitionPropriete as CDefinitionProprieteDynamiqueChampCustom;
if (def != null)
{
dbKeyIdChamp = def.DbKeyChamp;
}
}
valeurRetournee = listeParametres[0];
}
if (valeurRetournee == null || dbKeyIdChamp == null)
{
result.Data = "";
return(result);
}
CContexteDonnee contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
if (contexteDonnee == null)
{
contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
}
CChampCustom champ = new CChampCustom(contexteDonnee);
if (champ.ReadIfExists(dbKeyIdChamp))
{
if (!champ.IsChoixParmis())
{
result.Data = valeurRetournee.ToString();
}
else
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
if (valeur.Value.Equals(valeurRetournee))
{
result.Data = valeur.Display;
return(result);
}
}
}
}
result.Data = "";
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, CDefinitionProprieteDynamique propriete)
{
//Récupère l'objet à interroger
string strProp = propriete.NomPropriete;
object valeur = m_cache.GetValeurCache(objetInterroge, strProp);
if (valeur != null)
{
return(valeur);
}
CContexteDonnee contexteForObjets = ContexteDonneeCache;
if (objetInterroge is IObjetAContexteDonnee)
{
contexteForObjets = ((IObjetAContexteDonnee)objetInterroge).ContexteDonnee;
}
if (contexteForObjets == null)
{
contexteForObjets = ContexteDonneeCache;
}
object objetFinal = objetInterroge;
int nPos = strProp.LastIndexOf('.');
if (nPos > 0 && !(propriete is CDefinitionProprieteDynamiqueDonneeCumulee) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustom) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustomFils) &&
!(propriete is CDefinitionProprieteDynamiqueFormule))
{
string strPropDebut;
strPropDebut = strProp.Substring(0, nPos);
strProp = strProp.Substring(nPos + 1);
objetFinal = m_cache.GetValeurCache(objetInterroge, strPropDebut);
if (objetFinal == null)
{
objetFinal = GetValue(objetInterroge, strPropDebut);
/*object objetAInterroger = null;
* MemberInfo membre = null;
* CInterpreteurTexteProptVariete.GetObjetFinalEtMemberInfo ( objetInterroge, strPropDebut, ref objetAInterroger, ref membre );
* if ( membre != null )
* {
* objetFinal = CInterpreteurTextePropriete.GetValue ( objetAInterroger, membre );
* }
* else
* {
* //On n'a pas trouvé le membre, il s'agit donc d'autre chose, il faut donc décomposer
* //Le champ
* }*/
//objetFinal = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
m_cache.StockeValeurEnCache(objetInterroge, strPropDebut, objetFinal);
}
if (objetFinal == null)
{
return(null);
}
valeur = m_cache.GetValeurCache(objetFinal, strProp);
if (valeur != null)
{
return(valeur);
}
}
if (propriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(objetFinal is IElementAChamps))
{
valeur = null;
}
else
{
//TESTDBKEYTODO qui ne peut pas marche
valeur = ((IElementAChamps)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)propriete).DbKeyChamp.InternalIdNumeriqueANeJamaisUtiliserSaufDansCDbKeyAddOn.Value, System.Data.DataRowVersion.Default);
/*if (m_bValeurAfficheeDeChampsCustom)
* {
* CChampCustom champ = new CChampCustom(ContexteDonneeCache);
* if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustom)propriete).IdChamp))
* {
* object valTmp = champ.DisplayFromValue(valeur);
* if (valTmp != null)
* valeur = valTmp;
* }
* }*/
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCustomFils && objetInterroge is CObjetDonneeAIdNumerique)
{
CChampCustom champ = new CChampCustom(ContexteDonneeCache);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustomFils)propriete).KeyChamp))
{
Type tp = champ.Role.TypeAssocie;
try
{
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexteForObjets });
CRelationElementAChamp_ChampCustom rel = elt.GetNewRelationToChamp();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForObjets, tp);
liste.Filtre = new CFiltreDataAvance(
elt.GetNomTable(),
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1 and " +
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurInt + "=@2 and " +
rel.GetNomTable() + "." +
CChampCustom.c_champId + "=@3",
objetInterroge.GetType().ToString(),
((CObjetDonneeAIdNumerique)objetInterroge).Id,
champ.Id);
valeur = liste.ToArray(tp);
}
catch
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueListeEntites)
{
CListeEntites liste = new CListeEntites(contexteForObjets);
try
{
if (liste.ReadIfExists(((CDefinitionProprieteDynamiqueListeEntites)propriete).DbKeyListeEntite))
{
CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetInterroge);
if (resultListe != null)
{
valeur = resultListe.ToArray(liste.TypeElements);
}
}
}
catch
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueRelationTypeId)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueRelationTypeId defRel = (CDefinitionProprieteDynamiqueRelationTypeId)propriete;
return(((CObjetDonneeAIdNumerique)objetFinal).GetDependancesRelationTypeId(
defRel.Relation.TableFille,
defRel.Relation.ChampType,
defRel.Relation.ChampId,
false));
}
}
else if (propriete is CDefinitionProprieteDynamiqueDonneeCumulee)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueDonneeCumulee defType = (CDefinitionProprieteDynamiqueDonneeCumulee)propriete;
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)objetFinal;
CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexteForObjets);
if (type.ReadIfExists(defType.DbKeyTypeDonnee))
{
valeur = type.GetDonneesCumuleesForObjet(objet);
}
else
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCalcule)
{
CChampCalcule champ = new CChampCalcule(contexteForObjets);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCalcule)propriete).DbKeyChamp))
{
valeur = champ.Calcule(objetFinal, new CFournisseurPropDynStd(true));
}
else
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueFormule)
{
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetInterroge);
contexte.AttacheObjet(typeof(CContexteDonnee), contexteForObjets);
CResultAErreur result = ((CDefinitionProprieteDynamiqueFormule)propriete).Formule.Eval(contexte);
if (result)
{
return(result.Data);
}
}
else if (propriete is CDefinitionProprieteDynamiqueVariableDynamique && objetFinal is IElementAVariables)
{
valeur = ((IElementAVariables)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
}
else
{
valeur = CInterpreteurTextePropriete.GetValue(objetFinal, strProp);
}
m_cache.StockeValeurEnCache(objetInterroge, propriete.Nom, valeur);
if (objetFinal != objetInterroge)
{
m_cache.StockeValeurEnCache(objetFinal, strProp, valeur);
}
return(valeur);
}
//---------------------------------------------------------------------------------
public static object GetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp, DataRowVersion version)
{
string strTableValeurs = objet.GetNomTableRelationToChamps();
string strChampId = objet.GetChampId();
if (!objet.IsDependanceChargee(strTableValeurs, strChampId) && !IsChampLu(objet, nIdChamp))
{
object dummy;
dummy = objet.RelationsChampsCustom;
SetTousChampsLus(objet);
}
DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];
string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;
//Stef 20/07/2010 : si on fait un get avec version à -1, on récupère la version Referentiel.
//Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
//ce qui peut ramener plus d'1 élément, du coup, GetValeur champ retourne
//n'importe quelle valeur, et pas forcement celle du référentiel
if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
{
if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
{
strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
CSc2iDataConst.c_champIsDeleted + "=0";
}
else
{
strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
}
}
DataRow[] rows = table.Select(strFiltre);
if (rows.Length > 0)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
DataRow row = rows[0];
if (row.HasVersion(version))
{
rel.SetRow(row);
rel.VersionToReturn = version;
return(rel.Valeur);
}
else
{
return(null);
}
}
/*CListeObjetsDonnees liste = GetRelationsToChamps(nIdChamp);
*
* if (liste.Count > 0)
* return ((CRelationElementAChamp_ChampCustom) liste[0]).Valeur;*/
//Changement le 12/10/03 :
/*Si l'objet n'a pas la relation du champ, mais qu'elle devrait (par ses groupes),
* retourne la valeur par défaut du champ
* si le champ ne doit pas apparaitre dans cet élément, retourne null
* */
// Lecture de la valeur par défaut du champ
/* le 3/2/04 pourquoi ? ça ralentit tout !!, annule cette modif*/
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(nIdChamp))
{
object valeurParDefaut = champ.ValeurParDefaut;
/*if ( valeurParDefaut == null )
* return null;
* //La valeur par défaut n'est pas null, regarde si cet élément doit avoir ce champ
* foreach ( CChampCustom champNormal in TousLesChamps )
* {
* if ( champNormal == champ )
* return valeurParDefaut;
* }*/
return(valeurParDefaut);
}
return(null);
}
//------------------------------------------------------------------------------------------
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);
}
}
