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);