private CResultAErreur PrepareImport(
ref CConfigMappagesSmartImport config,
ref DataTable tableSource)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CConfigMappagesSmartImport> resConfig = m_ctrlSetup.GetConfigFinale();
if (!resConfig)
{
result.EmpileErreur(resConfig.Erreur);
return(result);
}
config = resConfig.DataType;
if (m_sessionImport.TableSource != null)
{
tableSource = m_sessionImport.TableSource;
}
else if (m_parametreLectureFichier != null)
{
result = m_parametreLectureFichier.LectureFichier(m_strNomFichierExemple);
if (!result)
{
return(result);
}
tableSource = result.Data as DataTable;
}
return(result);
}
//-------------------------------------------------------------------------------
public override CResultAErreur MajConfig(CConfigMappagesSmartImport config)
{
CResultAErreur result = CResultAErreur.True;
if (!(Source is CSourceSmartImportObjet))
{
return(result);
}
if (ConfigMappage == null)
{
result.EmpileErreur(I.T("Can not calculate import setup|20121"));
return(result);
}
config.IdMappage = ConfigMappage.IdMappage;
config.TypeEntite = ConfigMappage.TypeEntite;
config.KeyEntite = ConfigMappage.KeyEntite;
config.OptionCreation = ConfigMappage.OptionCreation;
foreach (CSetupSmartImportItem child in ChildItems)
{
result = child.MajConfig(config);
if (!result)
{
return(result);
}
}
return(result);
}
private void m_btnSaveSession_Click(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable tableSource = null;
CResultAErreur res = PrepareImport(ref config, ref tableSource);
if (!res)
{
CFormAlerte.Afficher(res.Erreur);
return;
}
m_sessionImport.ConfigMappage = config;
m_sessionImport.TableSource = tableSource;
SaveFileDialog dlg = new SaveFileDialog();
dlg.Filter = I.T("Import session(*.futimpses)|*.futimpses|All files|*.*|20148");
if (dlg.ShowDialog() == DialogResult.OK)
{
m_lblImportSession.Text = dlg.FileName;
CResultAErreur result = CSerializerObjetInFile.SaveToFile(m_sessionImport, "IMPORT_SESSION", dlg.FileName);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
return;
}
private void Init(CValeursProprietes valeurRoot)
{
m_rootValues = valeurRoot;
CConfigMappagesSmartImport conf = new CConfigMappagesSmartImport();
conf.KeyEntite = valeurRoot.DbKeyObjet;
conf.TypeEntite = valeurRoot.TypeObjet;
m_ctrlSetup.Fill(valeurRoot, conf, m_sourceTable);
}
//-------------------------------------------------------------------------------
public override CResultAErreur MajConfig(CConfigMappagesSmartImport config)
{
CResultAErreur result = CResultAErreur.True;
if (Source == null)
{
return(result);
}
List <CMappageChampSimple> lst = new List <CMappageChampSimple>(config.MappagesChampsSimples);
lst.Add(MappageSimple);
config.MappagesChampsSimples = lst;
return(result);
}
//-----------------------------------------------------------
private void m_btnSetupSource_Click(object sender, EventArgs e)
{
IParametreLectureFichier parametre = CAssistantLectureFichier.CreateParametreLectureFichier(ref m_strNomFichierExemple);
if (parametre != null)
{
m_sessionImport.TableSource = null;
m_parametreLectureFichier = parametre;
CreateSourceTable();
CResultAErreurType <CConfigMappagesSmartImport> resConf = m_ctrlSetup.GetConfigFinale();
CConfigMappagesSmartImport conf = resConf.DataType;
m_ctrlSetup.Fill(m_rootValues, conf, m_sourceTable);
}
}
private void m_lnkEditerSession_LinkClicked(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable tableSource = null;
CResultAErreur res = PrepareImport(ref config, ref tableSource);
if (!res)
{
CFormAlerte.Afficher(res.Erreur);
return;
}
m_sessionImport.ConfigMappage = config;
m_sessionImport.TableSource = tableSource;
CFormEditionSessionImport.EditeSession(m_sessionImport);
}
//-------------------------------------------------------------------
public CSetupSmartImportChampEntiteItem(
CSetupSmartImportItem itempParent,
CValeursProprietes valeursExemple,
CSourceSmartImport source,
CConfigMappagesSmartImport config,
int nColorIndex)
: base(itempParent, null, nColorIndex)
{
m_valeursExemple = valeursExemple;
m_config = config;
m_source = source;
if (m_config == null && valeursExemple != null)
{
m_config = new CConfigMappagesSmartImport();
m_config.KeyEntite = valeursExemple.DbKeyObjet;
m_config.TypeEntite = valeursExemple.TypeObjet;
}
}
//-------------------------------------------------------------------------------
public void Fill(
CValeursProprietes valeurs,
CConfigMappagesSmartImport configMappage,
DataTable sourceTable)
{
using (CWaitCursor waiter = new CWaitCursor())
{
List <CSetupSmartImportItem> lst = new List <CSetupSmartImportItem>();
lst.Add(new CSetupSmartImportChampEntiteItem(null,
valeurs,
new CSourceSmartImportObjet(),
configMappage,
0));
((CControleSetupSmartImportField)ItemControl).SourceTable = sourceTable;
Items = lst.ToArray();
ExpandItemsWithData(Items[0] as CSetupSmartImportItem);
}
}
//-----------------------------------------------------------------
private void m_btnPaste_Click(object sender, EventArgs e)
{
I2iSerializable ser = null;
CResultAErreur res = CSerializerObjetInClipBoard.Paste(ref ser, typeof(CConfigMappagesSmartImport).ToString());
if (!res)
{
CFormAlerte.Afficher(res.Erreur);
return;
}
CConfigMappagesSmartImport conf = ser as CConfigMappagesSmartImport;
if (conf != null && MessageBox.Show(I.T("Current import structure will be replaced. Continue ?|20123"),
"",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
m_ctrlSetup.Fill(m_rootValues, conf, m_sourceTable);
}
}
//-------------------------------------------------------------------------------
public override CResultAErreur MajConfig(CConfigMappagesSmartImport config)
{
CResultAErreur result = CResultAErreur.True;
if (Source == null || Source is CSourceSmartImportNoImport)
{
return(result);
}
CMappageEntiteParente mappage = new CMappageEntiteParente();
mappage.Propriete = MappageEntiteParente.Propriete;
mappage.UseAsKey = MappageEntiteParente.UseAsKey;
mappage.Source = MappageEntiteParente.Source;
mappage.ConfigEntiteParente = new CConfigMappagesSmartImport();
mappage.ConfigEntiteParente.IdMappage = MappageEntiteParente.ConfigEntiteParente.IdMappage;
mappage.ConfigEntiteParente.TypeEntite = MappageEntiteParente.ConfigEntiteParente.TypeEntite;
mappage.ConfigEntiteParente.KeyEntite = MappageEntiteParente.ConfigEntiteParente.KeyEntite;
mappage.ConfigEntiteParente.OptionCreation = MappageEntiteParente.ConfigEntiteParente.OptionCreation;
List <CMappageEntiteParente> lstParents = new List <CMappageEntiteParente>(config.MappagesEntitesParentes);
lstParents.Add(mappage);
config.MappagesEntitesParentes = lstParents;
if (Source is CSourceSmartImportFixedValue)//Dans ce cas, rien à faire de la suite
{
return(result);
}
foreach (CSetupSmartImportItem child in ChildItems)
{
result = child.MajConfig(mappage.ConfigEntiteParente);
if (!result)
{
return(result);
}
}
return(result);
}
//-------------------------------------------------------------------------------
public CResultAErreurType <CConfigMappagesSmartImport> GetConfigFinale()
{
MajChamps();
CResultAErreurType <CConfigMappagesSmartImport> resFinal = new CResultAErreurType <CConfigMappagesSmartImport>();
if (Items.Count() == 0 || !(Items[0] is CSetupSmartImportChampEntiteItem))
{
resFinal.EmpileErreur(I.T("Can not calculate import setup|20121"));
return(resFinal);
}
CSetupSmartImportChampEntiteItem root = Items[0] as CSetupSmartImportChampEntiteItem;
CConfigMappagesSmartImport config = new CConfigMappagesSmartImport();
CResultAErreur result = root.MajConfig(config);
if (!result)
{
resFinal.EmpileErreur(result.Erreur);
return(resFinal);
}
resFinal.DataType = config;
return(resFinal);
}
//--------------------------------------------------------------------------------------------------------
public static bool ShowImportResult(
CContexteDonnee contexteDonnee,
CContexteImportDonnee contexteImport,
CConfigMappagesSmartImport config,
CValeursProprietes valeurs,
DataTable tableSource)
{
using (CFormResultatSmartImport form = new CFormResultatSmartImport())
{
form.m_contexteDonnee = contexteDonnee;
form.m_contexteImport = contexteImport;
form.FillListeRésumée();
form.FillLog();
form.FillComparaisons();
form.m_ctrlSetup.Fill(valeurs, config, tableSource);
if (form.ShowDialog() == DialogResult.OK)
{
return(true);
}
return(false);
}
}
//-------------------------------------------------------------------------------
public override CResultAErreur MajConfig(CConfigMappagesSmartImport config)
{
CResultAErreur result = CResultAErreur.True;
CMappageEntitesFilles mappage = new CMappageEntitesFilles();
mappage.Propriete = MappageEntitesFilles.Propriete;
List <CMappageEntiteFille> lstMapsFilles = new List <CMappageEntiteFille>();
foreach (CSetupSmartImportItem child in ChildItems)
{
CSetupSmartImportChampEntiteItem itemEntite = child as CSetupSmartImportChampEntiteItem;
if (itemEntite != null)
{
if (itemEntite.Source != null)
{
CConfigMappagesSmartImport conf = new CConfigMappagesSmartImport();
result = itemEntite.MajConfig(conf);
if (!result)
{
return(result);
}
CMappageEntiteFille mapFille = new CMappageEntiteFille();
mapFille.ConfigMappage = conf;
mapFille.Source = itemEntite.Source;
lstMapsFilles.Add(mapFille);
}
}
}
mappage.MappagesEntitesFilles = lstMapsFilles;
if (lstMapsFilles.Count > 0)
{
List <CMappageEntitesFilles> lst = new List <CMappageEntitesFilles>(config.MappagesEntitesFilles);
lst.Add(mappage);
config.MappagesEntitesFilles = lst;
}
return(result);
}
//--------------------------------------------------------------
private void m_btnImporter_Click(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable table = null;
CResultAErreur result = PrepareImport(ref config, ref table);
if (!result || table == null)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
if (!CFormOptionsImport.EditeOptions(m_optionsExecution))
{
return;
}
IIndicateurProgression indicateur = null;
indicateur = CFormProgression.GetNewIndicateurAndPopup(I.T("Importing data|20245"));
CResultAErreurType <CSessionImport> resSession;
resSession = config.DoImportSurServeur(CSc2iWin32DataClient.ContexteCourant.IdSession,
table,
m_optionsExecution,
indicateur);
CFormProgression.EndIndicateur(indicateur);
if (m_optionsExecution.NomFichierSauvegarde != null &&
m_optionsExecution.NomFichierSauvegarde.Length > 0)
{
result = CSerializerObjetInFile.SaveToFile(resSession.DataType, "IMPORT_SESSION", m_optionsExecution.NomFichierSauvegarde);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
SetSessionEnCours(resSession.DataType);
CFormEditionSessionImport.EditeSession(m_sessionImport);
}
//-----------------------------------------------------------
private void m_btnOpen_Click(object sender, EventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = I.T("Import structure(*.futimp)|*.futimp|All files|*.*|20122");
if (dlg.ShowDialog() == DialogResult.OK)
{
CConfigMappagesSmartImport config = new CConfigMappagesSmartImport();
CResultAErreur result = CSerializerObjetInFile.ReadFromFile(config, "IMPORT_STRUCT", dlg.FileName);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
if (MessageBox.Show(I.T("Current import structure will be replaced. Continue ?|20123"),
"",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
m_ctrlSetup.Fill(m_rootValues, config, m_sourceTable);
}
}
}
}
private void m_btnTesterImport_Click(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable table = null;
CResultAErreur result = PrepareImport(ref config, ref table);
if (!result || table == null)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult dr = MessageBox.Show(I.T("Would you like to save configuration first ?|20225"), "",
MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Question);
if (dr == DialogResult.Cancel)
{
return;
}
if (dr == DialogResult.Yes)
{
if (!SaveConfig())
{
return;
}
}
if (!CFormOptionsSimulation.EditeOptions(m_optionsSimulation))
{
return;
}
using (CContexteDonnee ctx = new CContexteDonnee(CSc2iWin32DataClient.ContexteCourant.IdSession, true, false))
{
CContexteImportDonnee contexteImport = new CContexteImportDonnee(ctx);
contexteImport.StartLine = m_optionsSimulation.StartLine;
contexteImport.EndLine = m_optionsSimulation.EndLine;
contexteImport.BestEffort = true;
IIndicateurProgression indicateur = null;
indicateur = CFormProgression.GetNewIndicateurAndPopup(I.T("Testing import|20246"));
result = config.ImportTable(table, contexteImport, indicateur);
CFormProgression.EndIndicateur(indicateur);
indicateur = null;
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
if (m_optionsSimulation.TestDbWriting)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ctx.IdSession);
session.BeginTrans();
result = ctx.SaveAll(false);
session.RollbackTrans();
if (!result)
{
if (CFormAlerte.Afficher(result.Erreur, EFormAlerteBoutons.ContinuerAnnuler, EFormAlerteType.Info) == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
}
}
if (CFormResultatSmartImport.ShowImportResult(ctx, contexteImport, config, m_rootValues, table))
{
result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
}
}
//---------------------------------------------------------------------------------
public CResultAErreurType <CSessionImport> DoSmartImport(
DataTable tableSource,
CConfigMappagesSmartImport config,
COptionExecutionSmartImport options,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CSessionImport sessionImport = new CSessionImport();
sessionImport.TableSource = tableSource;
sessionImport.ConfigMappage = config;
CResultAErreurType <CSessionImport> resSession = new CResultAErreurType <CSessionImport>();
resSession.DataType = sessionImport;
int nTaillePaquet = options.TaillePaquets == null ? tableSource.Rows.Count : options.TaillePaquets.Value;
int nStartLigne = options.StartLine == null ? 0 : options.StartLine.Value;
int nEndLigne = options.EndLine == null ? tableSource.Rows.Count - 1 : Math.Min(options.EndLine.Value, tableSource.Rows.Count - 1);
int nNbToDo = nEndLigne - nStartLigne + 1;
int nNbDone = 0;
int?nIdVersionDonnees = null;
if (options.UtiliserVersionDonnee)
{
using (CContexteDonnee ctx = new CContexteDonnee(IdSession, true, false))
{
CVersionDonnees version = new CVersionDonnees(ctx);
version.CreateNew();
version.TypeVersion = new CTypeVersion(CTypeVersion.TypeVersion.Previsionnelle);
version.Libelle = I.T("Import data @1|20013", DateTime.Now.ToString("G"));
result = version.CommitEdit();
if (!result)
{
resSession.EmpileErreur(result.Erreur);
return(resSession);
}
nIdVersionDonnees = version.Id;
}
}
if (nStartLigne > 0)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
0,
nStartLigne - 1,
"Lines 0 to " + (nStartLigne - 1) + " are ignored"));
sessionImport.SetNonImportees(0, nStartLigne - 1);
}
if (nEndLigne < tableSource.Rows.Count - 1)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
nEndLigne + 1,
tableSource.Rows.Count - 1,
"Lines " + (nEndLigne + 1) + " to " + (tableSource.Rows.Count - 1) + " are ignored"));
sessionImport.SetNonImportees(nEndLigne + 1, tableSource.Rows.Count - 1);
}
//Ajoute dans la liste des lignes non importées, les lignes ignorées
using (C2iSponsor sponsor = new C2iSponsor())
{
if (indicateur != null)
{
sponsor.Register(indicateur);
indicateur.SetBornesSegment(0, nNbToDo);
}
try
{
while (nStartLigne <= nEndLigne)
{
using (CContexteDonnee ctxDonnees = new CContexteDonnee(IdSession, true, false))
{
if (m_nIdSession != null)
{
ctxDonnees.SetVersionDeTravail(nIdVersionDonnees, false);
}
CContexteImportDonnee ctxImport = new CContexteImportDonnee(ctxDonnees);
ctxImport.BestEffort = options.BestEffort;
ctxImport.StartLine = nStartLigne;
ctxImport.EndLine = Math.Min(nStartLigne + nTaillePaquet - 1, tableSource.Rows.Count - 1);
if (ctxImport.EndLine > nEndLigne)
{
ctxImport.EndLine = nEndLigne;
}
if (indicateur != null)
{
indicateur.PushSegment(nNbDone, nNbDone + ctxImport.EndLine.Value - ctxImport.StartLine.Value);
}
result = config.ImportTable(
tableSource,
ctxImport,
indicateur);
sessionImport.AddLogs(ctxImport.Logs);
if (indicateur != null)
{
indicateur.PopSegment();
}
if (result)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Saving|20012"));
}
result = ctxDonnees.SaveAll(true);
if (!result)
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
sessionImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
null,
"",
ctxImport.StartLine.Value,
ctxImport.EndLine.Value,
"Error saving lines " + ctxImport.StartLine.Value + " to " + ctxImport.EndLine.Value + " " +
result.Erreur.ToString()));
}
if (!result && !ctxImport.BestEffort)
{
return(resSession);
}
if (result)
{
sessionImport.SetImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
}
else
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
if (!result && !options.BestEffort)
{
return(resSession);
}
nStartLigne += nTaillePaquet;
nNbDone += nTaillePaquet;
if (indicateur != null)
{
indicateur.SetValue(nNbDone);
}
}
}
}
catch (Exception e)
{
resSession.EmpileErreur(new CErreurException(e));
}
finally
{
if (!result && !options.BestEffort)
{
resSession.EmpileErreur(result.Erreur);
}
}
return(resSession);
}
}
//-------------------------------------------------------------------------------
private void CreateChilds(CSetupSmartImportEntiteFilleItem itemFille)
{
int nIndex = itemFille.Index;
int nColIndex = itemFille.ColorIndex;
HashSet <CDbKey> keysDone = new HashSet <CDbKey>();
if (itemFille.ValeursDeFilles != null)
{
foreach (CValeursProprietes val in itemFille.ValeursDeFilles)
{
CMappageEntiteFille mappage = itemFille.MappageEntitesFilles != null?
itemFille.MappageEntitesFilles.GetMappageForEntite(val.DbKeyObjet) :
null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappage != null && mappage.Source != null;
}
if (bCreate)
{
nColIndex++;
if (CSetupSmartImportItem.GetCouleur(nColIndex) == itemFille.BackColor)
{
nColIndex++;
}
CSetupSmartImportChampEntiteItem item = new CSetupSmartImportChampEntiteItem(
itemFille,
val,
mappage != null ? mappage.Source : null,
mappage != null ? mappage.ConfigMappage : null,
nColIndex);
InsertItem(++nIndex, item, false);
if (val.DbKeyObjet != null)
{
keysDone.Add(val.DbKeyObjet);
}
}
}
}
if (itemFille.MappageEntitesFilles != null)
{
IEnumerable <CMappageEntiteFille> mapsFilles = itemFille.MappageEntitesFilles.MappagesEntitesFilles;
foreach (CMappageEntiteFille mapFille in mapsFilles)
{
if (mapFille.Source != null && mapFille.ConfigMappage != null)
{
CConfigMappagesSmartImport conf = mapFille.ConfigMappage;
if (conf.KeyEntite == null || !keysDone.Contains(conf.KeyEntite))
{
nColIndex++;
if (CSetupSmartImportItem.GetCouleur(nColIndex) == itemFille.BackColor)
{
nColIndex++;
}
CSetupSmartImportChampEntiteItem item = new CSetupSmartImportChampEntiteItem(
itemFille,
null,
mapFille.Source,
conf,
nColIndex);
InsertItem(++nIndex, item, false);
if (conf.KeyEntite != null)
{
keysDone.Add(conf.KeyEntite);
}
}
}
}
}
}
//-------------------------------------------------------------------------------
private void CreateChilds(CSetupSmartImportItem si, CValeursProprietes valeurs, CConfigMappagesSmartImport configMappage)
{
//Champs simples
HashSet <CDefinitionProprieteDynamique> set = new HashSet <CDefinitionProprieteDynamique>();
if (valeurs != null)
{
foreach (CDefinitionProprieteDynamique prop in valeurs.GetDefinitionsSimples())
{
if (prop != null)
{
set.Add(prop);
}
}
}
if (configMappage != null)
{
foreach (CMappageChampSimple mappage in configMappage.MappagesChampsSimples)
{
if (mappage.Propriete != null)
{
set.Add(mappage.Propriete);
}
}
}
List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>(set.ToArray());
lst.Sort((x, y) => x.Nom.CompareTo(y.Nom));
int nIndex = si.Index;
foreach (CDefinitionProprieteDynamique def in lst)
{
CMappageChampSimple mappageSimple = configMappage != null?
configMappage.GetMappageSimpleFor(def) :
null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappageSimple != null && mappageSimple.Source != null;
}
if (bCreate)
{
CSetupSmartImportChampSimpleItem item = new CSetupSmartImportChampSimpleItem(
si,
def,
valeurs != null ? valeurs.GetValeurSimple(def) : null,
mappageSimple,
si.ColorIndex);
InsertItem(++nIndex, item, false);
}
}
//Champs parents
int nColorIndex = si.ColorIndex;
set.Clear();
if (valeurs != null)
{
foreach (CDefinitionProprieteDynamique def in valeurs.GetDefinitionsParentes())
{
if (def != null)
{
set.Add(def);
}
}
}
if (configMappage != null)
{
foreach (CMappageEntiteParente map in configMappage.MappagesEntitesParentes)
{
if (map.Propriete != null)
{
set.Add(map.Propriete);
}
}
}
lst = new List <CDefinitionProprieteDynamique>(set.ToArray());
lst.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CDefinitionProprieteDynamique def in lst)
{
CMappageEntiteParente mappageParent = configMappage != null?configMappage.GetMappageParentFor(def) : null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappageParent != null && mappageParent.Source != null;
}
if (bCreate)
{
nColorIndex++;
if (CSetupSmartImportItem.GetCouleur(nColorIndex) == si.BackColor)
{
nColorIndex++;
}
CSetupSmartImportEntiteParentItem item = new CSetupSmartImportEntiteParentItem(
si,
def,
valeurs != null ? valeurs.GetValeurParente(def) : null,
mappageParent,
nColorIndex);
InsertItem(++nIndex, item, false);
}
}
set.Clear();
if (valeurs != null)
{
foreach (CDefinitionProprieteDynamique def in valeurs.GetDefinitionsFilles())
{
if (def != null)
{
set.Add(def);
}
}
}
if (configMappage != null)
{
foreach (CMappageEntitesFilles map in configMappage.MappagesEntitesFilles)
{
if (map.Propriete != null)
{
set.Add(map.Propriete);
}
}
}
lst = new List <CDefinitionProprieteDynamique>(set.ToArray());
lst.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CDefinitionProprieteDynamique def in lst)
{
CMappageEntitesFilles mappageFilles = configMappage != null?configMappage.GetMappageFilleFor(def) : null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappageFilles != null && mappageFilles.MappagesEntitesFilles.Count() > 0;
}
if (bCreate)
{
CSetupSmartImportEntiteFilleItem item = new CSetupSmartImportEntiteFilleItem(
si,
def,
valeurs,
mappageFilles,
si.ColorIndex
);
InsertItem(++nIndex, item, false);
}
}
}
//------------------------------------------------------------------------------- public abstract CResultAErreur MajConfig(CConfigMappagesSmartImport config);
