public void Init(CProcess process, Type typeObjet, CActionImportFromTableRow.CMappageColonne mappage)
{
m_mappage = mappage;
CColonneTableParametrable col = new CColonneTableParametrable(CContexteDonneeSysteme.GetInstance());
col.ReadIfExists(mappage.IdColonne);
m_lblColonne.Text = col.Libelle;
Type tp = col.TypeDonneeChamp.TypeDotNetAssocie;
List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>();
foreach (CDefinitionProprieteDynamique def in new CFournisseurPropDynStd(false).GetDefinitionsChamps(typeObjet))
{
Type defType = def.TypeDonnee.TypeDotNetNatif;
if (defType.IsGenericType && defType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
defType = defType.GetGenericArguments()[0];
}
if (defType == tp && !def.TypeDonnee.IsArrayOfTypeNatif)
{
lst.Add(def);
}
}
m_cmbChamp.ListDonnees = lst;
m_cmbChamp.ProprieteAffichee = "Nom";
m_cmbChamp.SelectedValue = mappage.ProprieteCible;
m_txtFormuleCondition.Init(process, typeof(CProcess));
m_txtFormuleCondition.Formule = mappage.FormuleCondition;
}
private ListViewItem GetPKListViewItem(CColonneTableParametrable col)
{
foreach (ListViewItem itm in m_lvPks.Items)
{
if ((CColonneTableParametrable)itm.Tag == col)
{
return(itm);
}
}
return(null);
}
private void m_gestionnaireColonnes_InitChamp(object sender, CObjetDonneeResultEventArgs args)
{
if (args.Objet == null)
{
m_ctrlEditCol.Visible = false;
return;
}
CColonneTableParametrable col = (CColonneTableParametrable)args.Objet;
m_ctrlEditCol.Init(col);
m_panelCol.Visible = true;
m_ctrlEditCol.Visible = true;
}
private void AjouterPK(CColonneTableParametrable col)
{
if (col.PrimaryKeyPosition != null)
{
return;
}
m_typeTable.DefinirEnClePrimaire(col);
ListViewItem itm = new ListViewItem(col.Libelle);
itm.Tag = col;
m_lvPks.Items.Add(itm);
MAJComboBoxPKs();
}
private void SupprimerPK(CColonneTableParametrable col)
{
if (col.PrimaryKeyPosition == null)
{
return;
}
m_typeTable.DefinirSansClePrimaire(col);
ListViewItem itm = GetPKListViewItem(col);
if (itm == null)
{
return;
}
m_lvPks.Items.Remove(itm);
MAJComboBoxPKs();
}
public CResultAErreur Init(CColonneTableParametrable col)
{
m_bIsInitializing = false;
CResultAErreur result = CResultAErreur.True;
if (col == null)
{
return(result);
}
m_col = col;
//Chargement des types possibles
m_cmbTypesDonnees.Items.Clear();
m_cmbTypesDonnees.BeginUpdate();
m_cmbTypesDonnees.DisplayMember = "Libelle";
m_cmbTypesDonnees.ValueMember = "TypeDonnee";
foreach (C2iTypeDonnee tp in CChampCustom.TypePossibles)
{
if (tp.TypeDonnee != TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
{
m_cmbTypesDonnees.Items.Add(tp);
}
}
m_cmbTypesDonnees.EndUpdate();
//m_cmbTypesDonnees.DataSource = CChampCustom.TypePossibles;
//m_cmbTypesDonnees.Items.AddRange();
//for (int i = m_cmbTypesDonnees.Items.Count; i > 0; i--)
// if (m_cmbTypesDonnees.Items[i - 1].ToString() == "Entité")
// m_cmbTypesDonnees.Items.RemoveAt(i - 1);
m_cmbTypesDonnees.SelectedItem = m_col.TypeDonneeChamp;
m_txtNom.Text = m_col.Libelle;
m_chkNull.Checked = !col.AllowNull;
m_lblPK.Visible = m_col.IsPrimaryKey;
m_chkNull.Visible = !m_lblPK.Visible;
m_bIsInitializing = true;
return(result);
}
private void m_lnkSupprimer_LinkClicked(object sender, EventArgs e)
{
if (m_wndColonnes.SelectedItems.Count != 1)
{
return;
}
CColonneTableParametrable col = (CColonneTableParametrable)m_wndColonnes.SelectedItems[0].Tag;
int pos = col.Position;
if (col.PrimaryKeyPosition != null)
{
m_typeTable.DefinirSansClePrimaire(col);
}
m_gestionnaireColonnes.SetObjetEnCoursToNull();
CResultAErreur result = col.Delete();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
//On met à jour les positions des éléments restant
if (m_wndColonnes.SelectedItems.Count == 1)
{
if (m_wndColonnes.SelectedItems[0] != null)
{
m_wndColonnes.SelectedItems[0].Remove();
}
while (pos <= m_wndColonnes.Items.Count - 1)
{
CColonneTableParametrable coltmp = (CColonneTableParametrable)m_wndColonnes.Items[pos].Tag;
coltmp.Position = pos;
pos++;
}
}
MAJColonnesPks();
}
private void InitialiserAffichage()
{
if (IsColonneSource)
{
m_cmbNom.BeginUpdate();
m_cmbNom.Items.Clear();
m_itm = new CItemAucun("Aucune");
m_cmbNom.Items.Add(m_itm);
CColonneTableParametrable col = m_mappage.ColonneB;
foreach (CColonneTableParametrable c in m_tpTableSrc.Colonnes)
{
if (c.TypeDonneeChamp.TypeDotNetAssocie == col.TypeDonneeChamp.TypeDotNetAssocie)
{
m_cmbNom.Items.Add(c);
}
}
m_cmbNom.EndUpdate();
if (m_mappage.ColonneA == null)
{
m_cmbNom.SelectedItem = m_itm;
InfosColonnePossible = false;
}
else
{
m_cmbNom.SelectedItem = m_mappage.ColonneA;
}
}
else
{
m_lblNom.Text = m_mappage.ColonneB.Libelle;
m_ctrlEditVal.Valeur = GetDefaultVal();
m_chkNull.Checked = !m_mappage.ColonneB.AllowNull;
}
MAJInfosColonne();
ActualiserDefautPossible();
}
private void m_lnkAjouter_LinkClicked(object sender, EventArgs e)
{
CColonneTableParametrable col = new CColonneTableParametrable(TypeTableParametrable.ContexteDonnee);
col.CreateNewInCurrentContexte();
col.Libelle = I.T("New column|1242");
col.TypeDonneeChamp = new C2iTypeDonnee(TypeDonnee.tString);
col.TypeTable = TypeTableParametrable;
col.Position = m_wndColonnes.Items.Count;
ListViewItem item = new ListViewItem();
m_wndColonnes.Items.Add(item);
m_wndColonnes.UpdateItemWithObject(item, col);
foreach (ListViewItem itemSel in m_wndColonnes.SelectedItems)
{
itemSel.Selected = false;
}
item.Selected = true;
MAJComboBoxPKs();
}
public void MAJInfosColonne()
{
CColonneTableParametrable col = null;
if (IsColonneSource)
{
if (m_cmbNom.SelectedItem != m_itm)
{
col = (CColonneTableParametrable)m_cmbNom.SelectedItem;
}
}
else
{
col = m_mappage.ColonneB;
}
m_panKey.BackgroundImage = col != null && col.IsPrimaryKey ? Properties.Resources.cle : null;
m_panObligatoire.BackgroundImage = col != null && col.AllowNull ? Properties.Resources.ok : null;
if (col != null)
{
m_lblType.Text = col.TypeDonneeChamp.Libelle;
}
}
public void TestVersionsDeTables()
{
System.Console.WriteLine("-----------------------------------Test versions de tables----------------------");
System.Console.WriteLine("Initialisation");
ResetModifs();
string strNomTableTest = "TEST_NUNIT";
string[] strNomsCols = new string[] { "Cle", "Val1", "Val2" };
//Supprime les tables de test
m_contexteDonnee.SetVersionDeTravail(-1, false); //Toutes versions
CListeObjetsDonnees listeTables = new CListeObjetsDonnees(m_contexteDonnee, typeof(CTableParametrable));
listeTables.Filtre = new CFiltreData(CTableParametrable.c_champLibelle + "=@1",
strNomTableTest);
Assert.IsTrue(CObjetDonneeAIdNumerique.Delete(listeTables));
//Création du type de table
m_contexteDonnee.SetVersionDeTravail(null, false);
CTypeTableParametrable typeTable = new CTypeTableParametrable(m_contexteDonnee);
if (typeTable.ReadIfExists(new CFiltreData(CTypeTableParametrable.c_champLibelle + "=@1",
strNomTableTest)))
{
Assert.IsTrue(CObjetDonneeAIdNumerique.Delete(typeTable.Colonnes));
typeTable.BeginEdit();
}
else
{
typeTable.CreateNew();
}
typeTable.Libelle = strNomTableTest;
CColonneTableParametrable col1 = new CColonneTableParametrable(typeTable.ContexteDonnee);
col1.CreateNewInCurrentContexte();
col1.Libelle = strNomsCols[0];
col1.TypeDonneeChamp = new C2iTypeDonnee(TypeDonnee.tString);
col1.AllowNull = false;
col1.TypeTable = typeTable;
col1.PrimaryKeyPosition = 0;
col1.Position = 0;
CColonneTableParametrable col2 = new CColonneTableParametrable(typeTable.ContexteDonnee);
col2.CreateNewInCurrentContexte();
col2.Libelle = strNomsCols[1];
col2.TypeDonneeChamp = new C2iTypeDonnee(TypeDonnee.tString);
col2.TypeTable = typeTable;
col2.Position = 1;
CColonneTableParametrable col3 = new CColonneTableParametrable(typeTable.ContexteDonnee);
col3.CreateNewInCurrentContexte();
col3.Libelle = strNomsCols[2];
col3.TypeDonneeChamp = new C2iTypeDonnee(TypeDonnee.tString);
col3.TypeTable = typeTable;
col3.Position = 2;
Assert.IsTrue(typeTable.CommitEdit());
//Création d'une table dans le référentiel
CTableParametrable tableP = new CTableParametrable(m_contexteDonnee);
tableP.CreateNew();
tableP.Libelle = strNomTableTest;
tableP.TypeTable = typeTable;
DataTable table = tableP.DataTableObject;
/*Table dans le referentiel
* KEY | Val1 | Val2
* A1 | A2 | A3
* B1 | B2 | B3
* C1 | C2 | C3
* D1 | D2 | D3
* */
DataRow row = null;
for (int nRow = 0; nRow < 4; nRow++)
{
row = table.NewRow();
string strCleLigne = (new string[] { "A", "B", "C", "D" })[nRow];
for (int nCol = 1; nCol < table.Columns.Count; nCol++)
{
if (table.Columns[nCol].ColumnName != CTableParametrable.c_strColTimeStamp)
{
row[nCol] = strCleLigne + (nCol).ToString();
}
}
table.Rows.Add(row);
}
tableP.DataTableObject = table;
Assert.IsTrue(tableP.CommitEdit());
//---------------------------------------------------------
///Modification de la table en V1
System.Console.Write("Modif dans V1");
string strA2V1 = "A2 en V1";
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
table = tableP.DataTableObject;
row = table.Rows[0];
row[strNomsCols[1]] = strA2V1;
tableP.BeginEdit();
tableP.DataTableObject = table;
Assert.IsTrue(tableP.CommitEdit());
//La table n'a pas bougé en version référentiel
m_contexteDonnee.SetVersionDeTravail(null, false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", "A3" },
new string[] { "B1", "B2", "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table n'a pas bougé en V2
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", "A3" },
new string[] { "B1", "B2", "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table a bougé en V1
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V1, "A3" },
new string[] { "B1", "B2", "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table a bougé en V3
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V1, "A3" },
new string[] { "B1", "B2", "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//---------------------------------------------------------
//Modification de la table dans le référentiel :
//Modif ligne 1 et ligne 2.
System.Console.Write("Modif dans Ref");
m_contexteDonnee.SetVersionDeTravail(null, false);
table = tableP.DataTableObject;
row = table.Rows[0];
string strA3REF = "A3 ref";
row[strNomsCols[2]] = strA3REF;
row = table.Rows[1];
string strB2REF = "B2 ref";
row[strNomsCols[1]] = strB2REF;
tableP.BeginEdit();
tableP.DataTableObject = table;
Assert.IsTrue(tableP.CommitEdit());
//La table n'a pas bougé en version référentiel
m_contexteDonnee.SetVersionDeTravail(null, false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", strA3REF },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table n'a pas bougé en V2
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", strA3REF },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//la ligne A de V1 ne doit pas être modifiée,
//Par contre la ligne 2 oui
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V1, "A3" },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//V3 = V1
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V1, "A3" },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//---------------------------------------------------------
System.Console.Write("Modif dans V3");
//Modification de la ligne en V3
string strA2V3 = "A2 en V3";
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
table = tableP.DataTableObject;
row = table.Rows[0];
row[strNomsCols[1]] = strA2V3;
tableP.BeginEdit();
tableP.DataTableObject = table;
Assert.IsTrue(tableP.CommitEdit());
//La table n'a pas bougé en version référentiel
m_contexteDonnee.SetVersionDeTravail(null, false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", strA3REF },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table n'a pas bougé en V2
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", strA3REF },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table a bougé en V1
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V1, "A3" },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table a bougé en V3
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V3, "A3" },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//-----------------------------------------------
//Suppression de la ligne C en V1
System.Console.Write("Delete dans V1");
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
table = tableP.DataTableObject;
table.Rows[2].Delete();
tableP.BeginEdit();
tableP.DataTableObject = table;
Assert.IsTrue(tableP.CommitEdit());
//La table n'a pas bougé en version référentiel
m_contexteDonnee.SetVersionDeTravail(null, false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", strA3REF },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table n'a pas bougé en V2
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", "A2", strA3REF },
new string[] { "B1", strB2REF, "B3" },
new string[] { "C1", "C2", "C3" },
new string[] { "D1", "D2", "D3" }
});
//La table a bougé en V1 (plus de ligne C)
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V1, "A3" },
new string[] { "B1", strB2REF, "B3" },
new string[] { "D1", "D2", "D3" }
});
//La table a bougé en V3 (plus de ligne C)
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
table = tableP.DataTableObject;
VerifTable(table, strNomsCols, new string[][] {
new string[] { "A1", strA2V3, "A3" },
new string[] { "B1", strB2REF, "B3" },
new string[] { "D1", "D2", "D3" }
});
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
object elementCible = null;
if (FormuleElementCible != null)
{
result = FormuleElementCible.Eval(ctxEval);
if (result)
{
elementCible = result.Data;
}
}
if (elementCible == null)
{
result.EmpileErreur(I.T("Error in target element formula|20236"));
return(result);
}
else if (elementCible is CObjetDonnee)
{
elementCible = ((CObjetDonnee)elementCible).GetObjetInContexte(contexte.ContexteDonnee);
}
CLigneTableParametrable ligne = null;
if (FormuleRow != null)
{
result = FormuleRow.Eval(ctxEval);
if (result)
{
ligne = result.Data as CLigneTableParametrable;
}
}
if (ligne == null)
{
result.EmpileErreur(I.T("Error in table row formula|20238"));
return(result);
}
//Identifie les colonnes à importer
Dictionary <string, CDefinitionProprieteDynamique> dicMap = new Dictionary <string, CDefinitionProprieteDynamique>();
foreach (CMappageColonne mappage in Mappages)
{
if (mappage.ProprieteCible != null)
{
bool bPrendre = true;
CColonneTableParametrable col = new CColonneTableParametrable(contexte.ContexteDonnee);
if (col.ReadIfExists(mappage.IdColonne))
{
if (mappage.FormuleCondition != null)
{
result = mappage.FormuleCondition.Eval(ctxEval);
if (!result || result.Data == null)
{
bPrendre = false;
}
else
{
bool?bTmp = CUtilBool.BoolFromString(result.Data.ToString());
if (bTmp != null)
{
bPrendre = bTmp.Value;
}
else
{
bPrendre = false;
}
}
}
if (bPrendre)
{
object val = ligne.GetValue(col.Libelle);
if (val != null || !m_bIgnorerLesValeursVides)
{
try
{
CInterpreteurProprieteDynamique.SetValue(elementCible, mappage.ProprieteCible, ligne.GetValue(col.Libelle));
}
catch
{
}
}
}
}
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CProxyGED proxy = null;
try
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
if (FormuleFichierSource == null)
{
result.EmpileErreur(I.T("Incorrect source file formula|506"));
return(result);
}
result = FormuleFichierSource.Eval(ctxEval);
if (!result)
{
return(result);
}
string strFichier = "";
if (result.Data is CDocumentGED)
{
CDocumentGED doc = result.Data as CDocumentGED;
proxy = new CProxyGED(contexte.IdSession, doc.ReferenceDoc);
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
strFichier = proxy.NomFichierLocal;
}
else
{
strFichier = result.Data.ToString();
}
if (!File.Exists(strFichier))
{
result.EmpileErreur(I.T("Source file @1 doesn't exist |508", result.Data.ToString()));
return(result);
}
if (FormuleTableAImporter == null)
{
result.EmpileErreur(I.T("Incorrect destination table formula|505"));
return(result);
}
result = FormuleTableAImporter.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating destination table formula|510"));
return(result);
}
if (!(result.Data is CTableParametrable))
{
result.EmpileErreur(I.T("Destination table formula doesn't return a table|511"));
return(result);
}
CTableParametrable tableParametrable = (CTableParametrable)result.Data;
if (tableParametrable.TypeTable.ParametrageCSV == null)
{
result.EmpileErreur(I.T("Table type @1 doesn't contains import setup|20002", tableParametrable.TypeTable.Libelle));
return(result);
}
// Sélectionne le type de fichier Excel ou CSV (texte)
IParametreLectureFichier parametre;
int nPositionduPoint = strFichier.LastIndexOf('.');
string strExtension = strFichier.Substring(nPositionduPoint + 1, strFichier.Length - nPositionduPoint - 1);
if (strExtension.ToUpper() == "XLS" || strExtension.ToUpper() == "XLSX")
{
parametre = tableParametrable.TypeTable.ParametrageXLS;
}
else
{
parametre = tableParametrable.TypeTable.ParametrageCSV;
}
result = parametre.LectureFichier(strFichier);
if (!result || !(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error while reading text file|509"));
return(result);
}
DataTable tableSource = (DataTable)result.Data;
Dictionary <DataColumn, CColonneTableParametrable> mappage = new Dictionary <DataColumn, CColonneTableParametrable>();
int nNbChamps = Math.Min(parametre.Mappage.StringsA.Count, parametre.Mappage.StringsB.Count);
for (int nChamp = 0; nChamp < nNbChamps; nChamp++)
{
DataColumn col = tableSource.Columns[parametre.Mappage.StringsA[nChamp]];
if (col != null)
{
CColonneTableParametrable colRetenue = null;
foreach (CColonneTableParametrable colonne in tableParametrable.TypeTable.Colonnes)
{
if (colonne.Libelle == parametre.Mappage.StringsB[nChamp])
{
colRetenue = colonne;
break;
}
}
if (colRetenue != null)
{
mappage[col] = colRetenue;
}
}
}
// Réalise l'import
result = tableParametrable.ImportTable(tableSource, mappage, m_modeImport);
if (!result)
{
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (proxy != null)
{
proxy.Dispose();
}
}
return(result);
}
