//------------------------------------------------
public CResultAErreur ImportTable(
DataTable table,
CContexteImportDonnee contexteImport,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
Dictionary <DataRow, DataRow> m_dicSourceToDest = new Dictionary <DataRow, DataRow>();
contexteImport.TableSource = table;
int nNbDoTo = table.Rows.Count;
if (contexteImport.StartLine != null)
{
nNbDoTo -= contexteImport.StartLine.Value;
}
if (contexteImport.EndLine != null)
{
nNbDoTo -= (table.Rows.Count - contexteImport.EndLine.Value) - 1;
}
int nNbDone = 0;
if (indicateur != null)
{
indicateur.SetBornesSegment(0, nNbDoTo);
}
int nStart = contexteImport.StartLine == null ? 0 : contexteImport.StartLine.Value;
int nEnd = contexteImport.EndLine == null ? table.Rows.Count - 1 : Math.Min(contexteImport.EndLine.Value, table.Rows.Count - 1);
for (int nRowIndex = nStart; nRowIndex <= nEnd; nRowIndex++)
{
DataRow row = table.Rows[nRowIndex];
if (indicateur != null)
{
indicateur.SetInfo(I.T("Import line @1|20106", nRowIndex.ToString()));
}
contexteImport.StartImportRow(row, nRowIndex);
result = ImportRow(row, contexteImport, null, false);
nNbDone++;
if (indicateur != null)
{
indicateur.SetValue(nNbDone);
}
if (!result)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
null,
contexteImport,
I.T("Error on line import|20102")));
if (!contexteImport.BestEffort)
{
return(result);
}
result = CResultAErreur.True;
}
}
return(result);
}
//--------------------------------------------------------
public virtual bool ShouldImport(DataRow row, CContexteImportDonnee contexte)
{
switch (m_optionImport)
{
case EOptionImport.OnCreate:
if (row.RowState != DataRowState.Added)
{
return(false);
}
break;
case EOptionImport.Never:
return(false);
}
if (Condition != null && !(Condition is C2iExpressionVrai))
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(row);
CResultAErreur result = Condition.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error on condition formula '@1'|20103",
Condition.GetString()));
contexte.AddLog(new CLigneLogImport(ETypeLigneLogImport.Error,
row,
"",
contexte,
result.Erreur.ToString()));
return(false);
}
return(CUtilBool.BoolFromObject(result.Data));
}
return(true);
}
//------------------------------------------------
public CResultAErreur ImportRow(DataRow row, CContexteImportDonnee contexteImport, CObjetDonnee parent)
{
CResultAErreur result = CResultAErreur.True;
if (MappagesEntitesFilles.Count() == 0)
{
return(result);
}
CResultAErreurType <CValeursImportFixe> resFixe = GetValeursFixesPourFilles(parent);
if (!resFixe)
{
result.EmpileErreur(resFixe.Erreur);
return(resFixe);
}
foreach (CMappageEntiteFille mappage in MappagesEntitesFilles)
{
if (mappage.Source != null && mappage.ConfigMappage != null)
{
if (!mappage.Source.ShouldImport(row, contexteImport))
{
contexteImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Error,
row,
mappage.Source.LibelleSource,
contexteImport,
I.T("Line was not imported due to import options or condition|20104")));
}
else
{
result = mappage.ConfigMappage.ImportRow(row, contexteImport, resFixe.DataType, false);
if (!result)
{
return(result);
}
}
}
}
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 CResultAErreur ImportRow(
DataRow row,
CContexteImportDonnee contexteImport,
CValeursImportFixe valeursFixes,
bool bIsRoot)
{
CResultAErreur result = CResultAErreur.True;
contexteImport.PushIdConfigMappage(IdMappage);
try
{
string strFiltre = "";
CResultAErreurType <CObjetDonnee> resObjet = FindObjet(row, contexteImport, valeursFixes, ref strFiltre);
if (!resObjet)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
"",
contexteImport,
resObjet.Erreur.ToString()));
result.EmpileErreur(resObjet.Erreur);
return(result);
}
if (resObjet.DataType == null && this.OptionCreation == EOptionCreationElementImport.None)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Alert,
row,
"",
contexteImport,
I.T("Line not imported because creation is forbidden for this element|20095")));
return(result);
}
CObjetDonnee objet = resObjet.DataType;
bool bIsNew = false;
if (objet == null)
{
bIsNew = true;
//Création
try
{
objet = Activator.CreateInstance(TypeEntite, new object[] { contexteImport.ContexteDonnee }) as CObjetDonnee;
}
catch { }
if (objet == null)
{
result.EmpileErreur(I.T("Error while creating object @1|20096", DynamicClassAttribute.GetNomConvivial(TypeEntite)));
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
null,
contexteImport,
result.Erreur.ToString()));
return(result);
}
if (objet is CObjetDonneeAIdNumeriqueAuto)
{
((CObjetDonneeAIdNumeriqueAuto)objet).CreateNewInCurrentContexte();
}
else
{
objet.CreateNewInCurrentContexte(null);
}
contexteImport.AddElementQuiAEteAjoute(objet);
contexteImport.SetEntiteForFiltre(strFiltre, objet);
}
if (bIsRoot)
{
contexteImport.SetElementPourLigne(contexteImport.CurrentRowIndex, objet);
}
contexteImport.SetObjetImporteForIdMappage(IdMappage, objet);
result = UpdateObjet(row, objet, bIsNew, contexteImport, valeursFixes);
if (!result)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
"",
contexteImport,
result.Erreur.ToString()));
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
contexteImport.PopIdConfigMappage();
}
return(result);
}
