//-----------------------------------------------------------------
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);
}
}
//----------------------------------------------------
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 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;
}
}
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;
}
}
//----------------------------------------------------------------------------------------
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);
}
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 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);
}
//------------------------------------------------
private CResultAErreur UpdateObjet(
DataRow row,
CObjetDonnee objet,
bool bIsNewObject,
CContexteImportDonnee contexteImport,
CValeursImportFixe valeursFixes)
{
CResultAErreur result = CResultAErreur.True;
foreach (CMappageChampSimple mappage in MappagesChampsSimples)
{
if (mappage.Source != null && mappage.Source.ShouldImport(row, contexteImport))
{
try
{
contexteImport.PushChamp(mappage.Propriete);
result = mappage.GetValue(row, contexteImport);
if (!result)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
mappage.Source.LibelleSource,
contexteImport,
result.Erreur.ToString()));
return(result);
}
try
{
CInterpreteurProprieteDynamique.SetValue(objet, mappage.Propriete, result.Data);
//Stockage valeur témoin
CSourceSmartImportField sourceField = mappage.Source as CSourceSmartImportField;
if (sourceField != null)
{
result = CInterpreteurProprieteDynamique.GetValue(objet, mappage.Propriete);
if (result)
{
contexteImport.SetValeurTemoin(sourceField.NomChampSource, result.Data);
}
result = CResultAErreur.True;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097",
result.Data == null ? "null" : result.Data.ToString()));
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
mappage.Source.LibelleSource,
contexteImport,
result.Erreur.ToString()));
return(result);
}
}
finally
{
contexteImport.PopChamp();
}
}
}
foreach (CMappageEntiteParente mapParent in MappagesEntitesParentes)
{
if (mapParent.Source != null && mapParent.Source.ShouldImport(row, contexteImport))
{
try
{
contexteImport.PushChamp(mapParent.Propriete);
CResultAErreurType <CObjetDonnee> resObjet = mapParent.GetObjetAssocie(row, contexteImport, true);
if (!resObjet)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
mapParent.Source.LibelleSource,
contexteImport,
resObjet.MessageErreur));
}
else
{
try
{
if (mapParent.AlternativeSetMethodInfo != null)
{
mapParent.AlternativeSetMethodInfo.Invoke(objet, new object[] { resObjet.DataType });
}
else
{
result = CInterpreteurProprieteDynamique.SetValue(objet, mapParent.Propriete, resObjet.DataType);
if (!result && mapParent.Propriete is CDefinitionProprieteDynamiqueDotNet)
{
//Tente affectation via fonction spécifique
PropertyInfo info = objet.GetType().GetProperty(mapParent.Propriete.NomProprieteSansCleTypeChamp);
if (info != null)
{
SpecificImportSetAttribute spec = info.GetCustomAttribute <SpecificImportSetAttribute>(true);
if (spec != null)
{
MethodInfo method = objet.GetType().GetMethod(spec.NomMethodeSetSpecifique);
if (method != null)
{
method.Invoke(objet, new object[] { resObjet.DataType });
}
mapParent.AlternativeSetMethodInfo = method;
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097",
result.Data == null ? "null" : result.Data.ToString()));
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
mapParent.Source.LibelleSource,
contexteImport,
result.Erreur.ToString()));
return(result);
}
}
}
finally
{
contexteImport.PopChamp();
}
}
}
if (valeursFixes != null)
{
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
objet.Row[kv.Key] = kv.Value == null ? DBNull.Value : kv.Value;
}
}
foreach (CMappageEntitesFilles mapFille in m_listeMappagesFilles)
{
try
{
contexteImport.PushChamp(mapFille.Propriete);
result = mapFille.ImportRow(row, contexteImport, objet);
if (!result)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
"",
contexteImport,
result.Erreur.ToString()));
result = CResultAErreur.True;
}
}
finally
{
contexteImport.PopChamp();
}
}
return(result);
}
//----------------------------------------------------------------------------------
public virtual CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANePasCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
if (tableParente != null && nValeursCle.Length == 0)
{
return(result);
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
indicateur.SetInfo(I.T("Table @1|115", NomTable));
if (nValeursCle.Length > 1 &&
relationToObjetParent == null)
{
result.EmpileErreur(I.T("Error: Multiple child table loading without knowing the relation indicating how the parental link is established|117"));
return(result);
}
DataColumn colFilleDeContrainte = null;
DataTable tableFilleDeContrainte = null;
if (tableParente != null)
{
if (ChampOrigine.TypeDonnee.IsArrayOfTypeNatif || !bAvecOptimisation ||
ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
//On est dans une relation fille
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
if (fkConst.RelatedTable.TableName == tableParente.NomTable)
{
colFilleDeContrainte = fkConst.Columns[0];
break;
}
}
}
tableFilleDeContrainte = table;
}
else
{
//On est dans une relation parente
DataTable tblP = ds.Tables[tableParente.NomTable];
foreach (Constraint contraint in tblP.Constraints)
{
if (contraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fk = (ForeignKeyConstraint)contraint;
if (fk.RelatedTable.TableName == table.TableName)
{
colFilleDeContrainte = fk.Columns[0];
tableFilleDeContrainte = tblP;
break;
}
}
}
}
}
if (list == null)
{
return(result);
}
//Désactive les ids auto sur les objetDonneeAIdNumerique.
//Car on utilise alors les valeurs de clé des éléments
bool bUtiliserIdObjets = false;
if (bAvecOptimisation && (ChampOrigine == null || ChampOrigine.NomPropriete.IndexOf('.') < 0 || !ChampOrigine.TypeDonnee.IsArrayOfTypeNatif))
{
if (list is CListeObjetsDonnees && (tableParente == null || colFilleDeContrainte == null))
{
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(((CListeObjetsDonnees)list).TypeObjets))
{
table.PrimaryKey[0].AutoIncrement = false;
bUtiliserIdObjets = true;
}
}
if (list is ArrayList)
{
ArrayList arrL = (ArrayList)list;
if (arrL.Count > 0 &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(arrL[0].GetType()))
{
table.PrimaryKey[0].AutoIncrement = false;
bUtiliserIdObjets = true;
}
}
}
if (FiltreAAppliquer != null)
{
CListeObjetsDonnees listeObjetsDonnee = list as CListeObjetsDonnees;
if (listeObjetsDonnee == null)//Tente de convertir en liste d'objets
{
//Récupère le contexte de données
CContexteDonnee ctx = null;
foreach (object obj in list)
{
IObjetAContexteDonnee objACtx = obj as IObjetAContexteDonnee;
if (objACtx != null)
{
ctx = objACtx.ContexteDonnee;
break;
}
}
listeObjetsDonnee = CListeObjetsDonnees.CreateListFrom(ctx, list);
}
if (listeObjetsDonnee != null)
{
list = listeObjetsDonnee;
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in the filter of the table @1|119", NomTable));
return(result);
}
try
{
if (result.Data != null)
{
listeObjetsDonnee.Filtre = CFiltreData.GetAndFiltre(listeObjetsDonnee.Filtre, (CFiltreData)result.Data);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during combination of table @1 filter|120", NomTable));
return(result);
}
}
}
//Table fille->
//si relation : Attribut relation (parente) représentant le lien entre la relation fille et cette tablle
//Si donnée cumulée : true
Hashtable tableTablesFillesToDependanceDirecte = new Hashtable();
//Table parente->Champ fille contenant l'id
Hashtable tableParentsCharges = new Hashtable();
#region Optimisations des CListeObjetsDonnees
if (bAvecOptimisation && list is CListeObjetsDonnees)
{
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
if (bUtiliserIdObjets)
{
#region Identifie les tables filles qui peuvent être remplies en une seule requête.
//Identifie les sous tables qui peuvent être chargées en une seule fois :
//Il s'agit des sous tables liée directement à une propriété par
//des relations (attribut RelationFille ou Relation).
foreach (ITableExport tableFille in TablesFilles)
{
Type tpAnalyse = listeObjets.TypeObjets;
if (tableFille != tableFilleANePasCharger && (tableFille is C2iTableExportATableFille || tableFille is C2iTableExportCumulee))
{
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine != null)
{
string strPropOrigine = tableFille.ChampOrigine.NomProprieteSansCleTypeChamp;
if (strPropOrigine.IndexOf('.') < 0)
{
//Seules les propriétés directes sont optimisées (pour le moment et peut être que ça suffit)
PropertyInfo info = tpAnalyse.GetProperty(strPropOrigine);
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length > 0)
{
RelationFilleAttribute attrFille = (RelationFilleAttribute)attribs[0];
tpAnalyse = attrFille.TypeFille;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpAnalyse))
{
info = tpAnalyse.GetProperty(attrFille.ProprieteFille);
if (info != null)
{
attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
if (attribs.Length > 0)
{
RelationAttribute attrParent = (RelationAttribute)attribs[0];
if (attrParent.ChampsFils.Length == 1)
{
tableTablesFillesToDependanceDirecte[tableFille] = attrParent;
}
}
}
}
}
}
}
}
}
}
#endregion
#region Charges les tables parentes qui peuvent être chargées
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeObjets.TypeObjets))
{
string strNomTableFille = listeObjets.NomTable;
foreach (ITableExport tableParenteAOptimiser in TablesFilles)
{
if (tableParenteAOptimiser != tableFilleANePasCharger && tableParenteAOptimiser.ChampOrigine != null && !tableParenteAOptimiser.ChampOrigine.TypeDonnee.IsArrayOfTypeNatif)
{
if (IsOptimisable(tableParenteAOptimiser, TypeSource))
{
CListeObjetsDonnees listeMere = listeObjets.GetDependances(tableParenteAOptimiser.ChampOrigine.NomProprieteSansCleTypeChamp);
if (listeMere != null)
{
result = tableParenteAOptimiser.InsertDataInDataSet(
listeMere,
ds,
null,
0,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
//Trouve le champ fille de lien
foreach (Constraint contrainte in table.Constraints)
{
if (contrainte is ForeignKeyConstraint)
{
ForeignKeyConstraint fk = (ForeignKeyConstraint)contrainte;
if (fk.RelatedTable.TableName == tableParenteAOptimiser.NomTable)
{
tableParentsCharges[tableParenteAOptimiser] = fk.Columns[0].ColumnName;
break;
}
}
}
}
}
}
}
}
#endregion
}
#region Identification des dépendances
if (m_strDependancesToOptim == null)
{
Hashtable tableDependances = new Hashtable();
AddProprietesOrigineDesChampsToTable(tableDependances, "", listeObjets.ContexteDonnee);
foreach (ITableExport tableFille in TablesFilles)
{
if (tableFille != tableFilleANePasCharger &&
!tableTablesFillesToDependanceDirecte.Contains(tableFille) &&
!tableParentsCharges.Contains(tableFille))
{
string strChemin = "";
if (ChampOrigine != null)
{
strChemin = ChampOrigine.NomPropriete;
}
if (tableFille.FiltreAAppliquer == null)
{
tableFille.AddProprietesOrigineDesChampsToTable(tableDependances, strChemin, listeObjets.ContexteDonnee);
}
}
}
m_strDependancesToOptim = new string[tableDependances.Count];
int nDep = 0;
foreach (string strOrigine in tableDependances.Keys)
{
m_strDependancesToOptim[nDep++] = strOrigine;
}
}
#endregion
}
#endregion
indicateur.SetInfo(I.T("Table @1|115", NomTable));
CFiltreData filtreDeBase = null;
if (list is CListeObjetsDonnees)
{
filtreDeBase = ((CListeObjetsDonnees)list).Filtre;
}
ArrayList listeIds = new ArrayList();
string strColonneCle = table.PrimaryKey[0].ColumnName;
indicateur.SetBornesSegment(0, nValeursCle.Length);
indicateur.SetValue(0);
//Lecture par paquets de 1000 clés
for (int n = 0; n < nValeursCle.Length; n += c_nNbLectureParLotFils)
{
if (bAvecOptimisation && (list is CListeObjetsDonnees) && relationToObjetParent != null)
{
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
StringBuilder blCles = new StringBuilder();
char cSepIn = ',';
if (filtreDeBase is CFiltreDataAvance)
{
cSepIn = ';';
}
for (int nCle = n; nCle < Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length); nCle++)
{
blCles.Append(nValeursCle[nCle]);
blCles.Append(cSepIn);
}
if (blCles.Length > 0)
{
blCles.Remove(blCles.Length - 1, 1);
string strCles = blCles.ToString();
if (filtreDeBase is CFiltreDataAvance)
{
listeObjets.Filtre = CFiltreData.GetAndFiltre(
filtreDeBase, new CFiltreDataAvance(
listeObjets.NomTable,
relationToObjetParent.ChampsFils[0] + " in {" + strCles + "}"));
}
else
{
listeObjets.Filtre = CFiltreData.GetAndFiltre(
filtreDeBase,
new CFiltreData(
relationToObjetParent.ChampsFils[0] + " in (" + strCles.Replace(';', ',') + ")"));
}
}
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (list is CListeObjetsDonnees && m_strDependancesToOptim != null && m_strDependancesToOptim.Length > 0)
{
((CListeObjetsDonnees)list).ReadDependances(m_strDependancesToOptim);
}
int nCountTotal = 1;
if (list is IList)
{
nCountTotal = ((IList)list).Count;
}
else if (list is Array)
{
nCountTotal = ((Array)list).Length;
}
indicateur.PushSegment(n, Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length));
int nNbElements = 0;
indicateur.SetBornesSegment(0, nCountTotal);
int nFrequence = Math.Min(nCountTotal / 20, 500) + 1;
CSessionClient session = CSessionClient.GetSessionUnique();
IInfoUtilisateur infoUser = session != null?session.GetInfoUtilisateur() : null;
///AJOUT DES LIGNES DANS LA TABLE
foreach (object obj in list)
{
CRestrictionUtilisateurSurType restriction = null;
if (infoUser != null && obj != null)
{
restriction = infoUser.GetRestrictionsSur(obj.GetType(), obj is IObjetAContexteDonnee?((IObjetAContexteDonnee)obj).ContexteDonnee.IdVersionDeTravail:null);
}
nNbElements++;
if (nNbElements % nFrequence == 0)
{
indicateur.SetValue(nNbElements);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
bool bShouldImporte = true;
DataRow row = null;
if (bUtiliserIdObjets)
{
row = table.Rows.Find(((CObjetDonneeAIdNumerique)obj).Id);
bShouldImporte = row == null;
}
if (bShouldImporte)
{
row = table.NewRow();
if (bUtiliserIdObjets)
{
int nId = ((CObjetDonneeAIdNumerique)obj).Id;
row[strColonneCle] = nId;
listeIds.Add(nId);
}
//Ajoute les valeurs de champs propres à cette table
result = InsereValeursChamps(obj, row, cacheValeurs, restriction);
if (!result)
{
return(result);
}
if (colFilleDeContrainte != null && nValeursCle.Length > 0)
{
DataRow rowFille = row;
if (tableFilleDeContrainte == table)
{
if (relationToObjetParent == null)
{
rowFille[colFilleDeContrainte] = nValeursCle[0];
}
else
{
rowFille[colFilleDeContrainte] = ((CObjetDonnee)obj).Row[relationToObjetParent.ChampsFils[0]];
}
}
}
table.Rows.Add(row);
}
//Dans tous les cas, met à jour la table dépendante si besoin est !
if (colFilleDeContrainte != null && nValeursCle.Length > 0)
{
DataRow rowFille = row;
if (tableFilleDeContrainte != table)
{
rowFille = tableFilleDeContrainte.Rows.Find(nValeursCle[0]);
rowFille[colFilleDeContrainte] = row[strColonneCle];
}
}
if (bShouldImporte)
{
//AJout des données des sous tables non optimisées
foreach (ITableExport tbl in TablesFilles)
{
if (tbl.ChampOrigine != null && !tableTablesFillesToDependanceDirecte.Contains(tbl) && tbl != tableFilleANePasCharger)
{
bool bChildIsOptimisable = IsOptimisable(tbl, TypeSource);
//Impossible de lire en direct
object objet = null;
if (tbl.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
objet = obj;
}
else
{
objet = CInterpreteurProprieteDynamique.GetValue(obj, tbl.ChampOrigine, cacheValeurs).Data;
}
string strNomCol = (string)tableParentsCharges[tbl];
if (strNomCol != null)
{
if (objet != null)
{
row[strNomCol] = ((CObjetDonneeAIdNumerique)objet).Id;
}
else
{
row[strNomCol] = DBNull.Value;
}
}
else
{
indicateur.PushSegment(nNbElements, nNbElements + 1);
if (objet != null)
{
IEnumerable tempList;
if (objet is IEnumerable)
{
tempList = (IEnumerable)objet;
}
else
{
ArrayList listeObjetUnique = new ArrayList();
listeObjetUnique.Add(objet);
tempList = listeObjetUnique;
}
if (tempList != null)
{
result = tbl.InsertDataInDataSet(
tempList,
ds,
this,
(int)row[table.PrimaryKey[0]],
elementAVariablePourFiltres,
cacheValeurs,
this,
bChildIsOptimisable,
indicateur);
if (!result)
{
return(result);
}
}
}
indicateur.PopSegment();
}
}
}
//vide le cache après chaque objet de la table principale
if (tableParente == null)
{
cacheValeurs.ResetCache();
}
}
}
indicateur.PopSegment();
}
indicateur.SetValue(nValeursCle.Length);
///Chargement des relations optimisées
int nTable = 0;
foreach (DictionaryEntry entry in tableTablesFillesToDependanceDirecte)
{
nTable++;
ITableExport tableFille = (ITableExport)entry.Key;
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
CDefinitionProprieteDynamiqueDonneeCumulee defCum = (CDefinitionProprieteDynamiqueDonneeCumulee)tableFille.ChampOrigine;
//Trouve les données cumulées correspondants aux éléments
CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
CTypeDonneeCumulee typeCumule = new CTypeDonneeCumulee(listeInit.ContexteDonnee);
if (!typeCumule.ReadIfExists(
defCum.DbKeyTypeDonnee))
{
result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|122", defCum.DbKeyTypeDonnee.ToString()));
return(result);
}
RelationAttribute attr = typeCumule.GetRelationAttributeToType(listeInit.TypeObjets);
string strChampIdOuDbKey = "";
if (defCum.DbKeyTypeDonnee.IsNumericalId())
{
strChampIdOuDbKey = CTypeDonneeCumulee.c_champId;
}
else
{
strChampIdOuDbKey = CObjetDonnee.c_champIdUniversel;
}
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
listeInit.ContexteDonnee,
typeof(CDonneeCumulee),
new CFiltreData(strChampIdOuDbKey + " = @1 ", defCum.DbKeyTypeDonnee.GetValeurInDb()));
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attr,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
CDefinitionProprieteDynamiqueRelationTypeId defTypeId = (CDefinitionProprieteDynamiqueRelationTypeId)tableFille.ChampOrigine;
RelationTypeIdAttribute relTpIdAttr = defTypeId.Relation;
//Trouve les données cumulées correspondants aux éléments
CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
if (listeInit.Count != 0)
{
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
listeInit.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relTpIdAttr.TableFille),
new CFiltreData(relTpIdAttr.ChampType + "=@1", listeInit.TypeObjets.ToString()));
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
RelationAttribute attrTmp = new RelationAttribute(
listeInit.NomTable,
((CObjetDonneeAIdNumerique)listeInit[0]).GetChampId(),
relTpIdAttr.ChampId, false, false);
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attrTmp,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
CListeObjetsDonnees listeInit = new CListeObjetsDonnees(
((CListeObjetsDonnees)list).ContexteDonnee,
tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
listeInit.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
string strChampId = listeInit.ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(listeInit.TypeObjets)).PrimaryKey[0].ColumnName;
RelationAttribute attrTmp = new RelationAttribute(
listeInit.NomTable,
strChampId,
strChampId,
false, false);
//Copie les clés dans la clé et dans la valeur de champ externe
result = tableFille.InsertDataInDataSet(
listeInit,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attrTmp,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else if (tableFille.ChampOrigine != null)
{
RelationAttribute attr = (RelationAttribute)entry.Value;
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
((CListeObjetsDonnees)list).ContexteDonnee,
tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attr,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else
{
result = tableFille.InsertDataInDataSet(
null,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
null,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
}
return(result);
}
//----------------------------------
public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (!def.IsReadOnly && strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", def.Nom), true));
}
}
}
}
if (objet is CElementAChamp)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((CElementAChamp)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == rel.ChampCustom.Id);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
this.AddValeur(mv);
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", rel.ChampCustom.Nom), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == champCustom.Id);
}
}
if (def != null && !def.IsReadOnly)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (!FillMacroValeurWithValue(mv, valeur.GetValeur(), dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", valeur.NomChampConvivial), true));
}
else
{
AddValeur(mv);
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
//---------------------------------------------------------------
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 CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
CStructureTable structure = CStructureTable.GetStructure(vo.TypeElement);
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut ForceSetOnMacro, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(strNom);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length != 0)
{
bAdd = true;
}
}
if (bAdd)
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", def.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
if (objet is IObjetDonneeAChamps)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((IObjetDonneeAChamps)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == rel.ChampCustom.DbKey);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", rel.ChampCustom.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
if (def == null)
{
CInfoRelation relation = structureObjet.RelationsParentes.FirstOrDefault(i => i.ChampsFille.Length == 1 && i.ChampsFille[0] == strNomChamp);
if (relation != null)
{
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == relation.Propriete);
}
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == champCustom.DbKey);
}
}
if (def != null)
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut TiagRelation, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(def.NomProprieteSansCleTypeChamp);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length > 0)
{
bAdd = true;
}
}
if (bAdd)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
object val = valeur.GetValeur();
if (val != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(def.TypeDonnee.TypeDotNetNatif) && valeur.TypeValeur == typeof(int))
{
CObjetDonneeAIdNumerique objetParent = Activator.CreateInstance(def.TypeDonnee.TypeDotNetNatif, new object[] { objet.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (objetParent.ReadIfExists((int)valeur.GetValeur()))
{
val = objetParent;
}
else
{
val = null;
}
}
if (!FillMacroValeurWithValue(mv, val, dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of @2 in macro", valeur.NomChampConvivial,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
else
{
AddValeur(mv);
}
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
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;
}
}
}
}
//-----------------------------------------------------------
private CResultAErreurType <CObjetDonneeAIdNumeriqueAuto> CloneObjet(
CContexteDonnee contexte,
CObjetDonneeAIdNumeriqueAuto source,
Dictionary <CObjetDonneeAIdNumeriqueAuto, CObjetDonneeAIdNumeriqueAuto> dicClones)
{
CResultAErreurType <CObjetDonneeAIdNumeriqueAuto> result = new CResultAErreurType <CObjetDonneeAIdNumeriqueAuto>();
if (dicClones.ContainsKey(source))
{
result.DataType = dicClones[source];
return(result);
}
if (dicClones.ContainsValue(source))
{
//C'est un objet qu'on a cloné, on ne va as le recloner encore
result.DataType = source;
return(result);
}
CObjetDonneeAIdNumeriqueAuto clone = Activator.CreateInstance(source.GetType(), new object[] { contexte }) as CObjetDonneeAIdNumeriqueAuto;
clone.CreateNewInCurrentContexte();
dicClones[source] = clone;
//Copie la ligne
DataTable table = source.Row.Table;
if (table == null)
{
return(result);
}
List <string> keys = new List <string>();
foreach (DataColumn col in table.PrimaryKey)
{
keys.Add(col.ColumnName);
}
clone.ContexteDonnee.CopyRow(source.Row, clone.Row, keys.ToArray());
//Copie toutes les valeurs de champ custom
IElementAChamps eltChampsDest = clone as IElementAChamps;
IElementAChamps eltChampsSource = source as IElementAChamps;
if (eltChampsDest != null && eltChampsSource != null)
{
foreach (CRelationElementAChamp_ChampCustom relation in eltChampsSource.RelationsChampsCustom)
{
eltChampsDest.SetValeurChamp(relation.ChampCustom, relation.Valeur);
}
}
//Copie les relations filles sélectionnées
List <CDefinitionProprieteDynamique> lst = null;
if (TryGetValue(source.GetType(), out lst))
{
foreach (CDefinitionProprieteDynamique def in lst)
{
CDefinitionProprieteDynamique defInverse = def.GetDefinitionInverse(source.GetType());
if (defInverse != null)//On sait affecter le parent
{
CResultAErreur resTmp = CInterpreteurProprieteDynamique.GetValue(source, def);
if (resTmp && result.Data is IEnumerable)
{
IEnumerable en = result.Data as IEnumerable;
foreach (object obj in en)
{
CObjetDonneeAIdNumeriqueAuto objDonnee = obj as CObjetDonneeAIdNumeriqueAuto;
if (objDonnee != null)
{
result = CloneObjet(contexte, objDonnee, dicClones);
if (result)
{
resTmp = CInterpreteurProprieteDynamique.SetValue(result.DataType, defInverse, clone);
if (!resTmp)
{
result.EmpileErreur(resTmp.Erreur);
return(result);
}
}
/*???? else
* return result;*/
}
}
}
}
}
}
result.DataType = clone;
return(result);
}
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);
}
}