public FillResult FillData(FillDataMode mode, DataTable rawData, Mediachase.MetaDataPlus.Import.Rule rule, int maximumErrors)
        {
            using (DbTransaction tran = DbTransaction.Begin())
            {
                FillResult retVal = FillData(mode, rawData, rule, Security.CurrentUser.UserID, DateTime.UtcNow, DbContext.Current.Transaction);
                if (maximumErrors == -1 || retVal.ErrorRows <= maximumErrors)
                {
                    tran.Commit();
                }
                else
                {
                    tran.Rollback();
                }

                return(retVal);
            }
        }
Exemple #2
0
        private void ShowStep(int step)
        {
            for (int i = 0; i <= _stepCount + 1; i++)
            {
                ((Panel)steps[i]).Visible = false;
            }
            ((Panel)steps[step - 1]).Visible = true;

            //if(step==1)
            //{
            //    pastStep.Value="1";
            //}

            #region step2
            if (step == 2)
            {
                if (pastStep.Value == "1" && fSourceFile.PostedFile != null && fSourceFile.PostedFile.ContentLength > 0)
                {
                    ProcessFileCache(Server.MapPath(CommonHelper.ChartPath));
                    String dir     = CommonHelper.ChartPath;
                    string wwwpath = dir + Guid.NewGuid().ToString();
                    switch (rbSourceType.SelectedValue)
                    {
                    case "0":
                        //wwwpath += ".xls";
                        // OZ: Added XLS and XLSX extensions
                        wwwpath += Path.GetExtension(fSourceFile.PostedFile.FileName);
                        break;

                    case "1":
                        wwwpath += ".xml";
                        break;

                    default:
                        break;
                    }
                    wwwPath.Value = wwwpath;
                    using (Stream sw = File.Create(Server.MapPath(wwwpath)))
                    {
                        fSourceFile.PostedFile.InputStream.Seek(0, SeekOrigin.Begin);
                        System.IO.BinaryReader br = new System.IO.BinaryReader(fSourceFile.PostedFile.InputStream);
                        int    iBufferSize        = 655360;               // 640 KB
                        byte[] outbyte            = br.ReadBytes(iBufferSize);

                        while (outbyte.Length > 0)
                        {
                            sw.Write(outbyte, 0, outbyte.Length);
                            outbyte = br.ReadBytes(iBufferSize);
                        }
                        br.Close();
                    }

                    IIncomingDataParser parser  = null;
                    DataSet             rawData = null;
                    switch (rbSourceType.SelectedIndex)
                    {
                    case 0:
                        IMCOleDBHelper helper = (IMCOleDBHelper)Activator.GetObject(typeof(IMCOleDBHelper), ConfigurationManager.AppSettings["McOleDbServiceString"]);
                        rawData = helper.ConvertExcelToDataSet(Server.MapPath(wwwPath.Value));
                        break;

                    case 1:
                        parser  = new XmlIncomingDataParser();
                        rawData = parser.Parse(Server.MapPath(wwwPath.Value), null);
                        break;
                    }

                    try
                    {
                        //rawData = parser.Parse(Server.MapPath(wwwPath.Value), null);
                        DataTable dtSource = rawData.Tables[0];
                        DataTable dt       = new DataTable();
                        dt.Columns.Add(new DataColumn("SourceField", typeof(string)));
                        dt.Columns.Add(new DataColumn("IBNField", typeof(string)));
                        dt.Columns.Add(new DataColumn("realIBNFieldName", typeof(string)));
                        dt.Columns.Add(new DataColumn("IsIn", typeof(bool)));
                        DataRow          dr;
                        MappingMetaClass mc = null;
                        mc = new IncidentMappingMetaClass();
                        foreach (ColumnInfo ci in mc.ColumnInfos)
                        {
                            dr = dt.NewRow();
                            dr["SourceField"] = LocRM.GetString("imNotSet");
                            if (ci.Field.IsSystem)
                            {
                                dr["IBNField"]         = LocRM.GetString("tw" + ci.FieldName);
                                dr["realIBNFieldName"] = ci.FieldName;
                            }
                            else
                            {
                                dr["IBNField"]         = ci.FieldFriendlyName;
                                dr["realIBNFieldName"] = ci.FieldName;
                            }
                            dr["IsIn"] = true;
                            dt.Rows.Add(dr);
                        }

                        DataTable dtColumns = new DataTable();
                        dtColumns.Columns.Add(new DataColumn("SourceField", typeof(string)));
                        dtColumns.Columns.Add(new DataColumn("IsIn", typeof(bool)));
                        foreach (DataColumn dc in dtSource.Columns)
                        {
                            dr = dtColumns.NewRow();
                            dr["SourceField"] = dc.ColumnName;
                            dr["IsIn"]        = true;
                            dtColumns.Rows.Add(dr);
                        }
                        ViewState["Fields"]       = dt;
                        ViewState["SourceFields"] = dtColumns;
                        BindDG();
                    }
                    catch
                    {
                        step2.Visible = false;
                        step4.Visible = false;
                        step5.Visible = false;
                        step6.Visible = true;
                        ((WizardTemplate)Page.Controls[0]).btnNext.Visible = false;
                        ((WizardTemplate)Page.Controls[0]).btnBack.Visible = false;
                        lblFinalResult.Text = String.Format(LocRM.GetString("imErrorListText"),
                                                            String.Format("<a href='mailto:{0}'>{0}</a>", GlobalResourceManager.Strings["SupportEmail"]));
                        return;
                    }
                }
                ((WizardTemplate)Page.Controls[0]).btnNext.Disabled = false;
                if (ViewState["Fields"] != null)
                {
                    BindDG();
                }
                else
                {
                    ((WizardTemplate)Page.Controls[0]).btnNext.Disabled = true;
                    grdFields.DataSource = null;
                    grdFields.DataBind();
                }

                pastStep.Value = "2";
            }
            #endregion

            #region step3 - not Lists
            if (step == 3)
            {
                DataTable           dtFields = (DataTable)ViewState["Fields"];
                IIncomingDataParser parser   = null;
                DataSet             rawData  = null;
                switch (rbSourceType.SelectedIndex)
                {
                case 0:
                    IMCOleDBHelper helper = (IMCOleDBHelper)Activator.GetObject(typeof(IMCOleDBHelper), ConfigurationManager.AppSettings["McOleDbServiceString"]);
                    rawData = helper.ConvertExcelToDataSet(Server.MapPath(wwwPath.Value));
                    break;

                case 1:
                    parser  = new XmlIncomingDataParser();
                    rawData = parser.Parse(Server.MapPath(wwwPath.Value), null);
                    break;
                }

                //DataSet rawData = parser.Parse(Server.MapPath(wwwPath.Value), null);
                DataTable        dtSource = rawData.Tables[0];
                MappingMetaClass mc       = null;
                mc = new IncidentMappingMetaClass();
                MetaDataPlus.Import.Rule mapping = mc.CreateClassRule();
                DataTable dtColumns = (DataTable)ViewState["SourceFields"];
                foreach (DataRow dr in dtColumns.Rows)
                {
                    string     srcColumnName = dr["SourceField"].ToString();
                    DataColumn dc            = dtSource.Columns[srcColumnName];
                    DataRow[]  drF           = dtFields.Select("SourceField = '" + srcColumnName + "'");
                    if (drF.Length > 0)
                    {
                        string    realIBNField = drF[0]["realIBNFieldName"].ToString();
                        MetaField mf           = mc.GetColumnInfo(realIBNField).Field;
                        if (mf != null)
                        {
                            mapping.Add(new RuleItem(srcColumnName, dc.DataType, mf, FillTypes.CopyValue));
                        }
                    }
                    else
                    {
                        mapping.Add(new RuleItem(srcColumnName, dc.DataType));
                    }
                }

                try
                {
                    FillResult fr = null;
                    fr = ((IncidentMappingMetaClass)mc).FillData(FillDataMode.New, dtSource, mapping, 0);
                    if (fr.ErrorRows > 0)
                    {
                        string sText = String.Format(LocRM.GetString("imSomeErrors"), fr.SuccessfulRows.ToString(), fr.ErrorRows.ToString());
                        int    index = 0;
                        foreach (string sError in fr.Errors)
                        {
                            if ((++index) > 5)
                            {
                                break;
                            }
                            else
                            {
                                sText += "<br>&nbsp;&nbsp;<li>" + sError + "</li>";
                            }
                        }
                        lblFirstResult.Text = sText;
                    }
                    else
                    {
                        lblFirstResult.Text = String.Format(LocRM.GetString("imWasDone"), fr.SuccessfulRows.ToString());
                        lblFinalResult.Text = String.Format(LocRM.GetString("imWasDone"), fr.SuccessfulRows.ToString());
                        ((WizardTemplate)Page.Controls[0]).btnNext.Visible = false;
                        ((WizardTemplate)Page.Controls[0]).btnBack.Visible = false;
                        //Page.RegisterStartupScript("onfourthload","<script language='javascript'>"+
                        //"NextStep();"+
                        //"function NextStep(){var obj = document.getElementById('"+((WizardTemplate)Page.Controls[0]).btnNext.ClientID+"'); obj.click();}</script>");
                    }
                }
                catch (Exception ex)
                {
                    lblFirstResult.Text = LocRM.GetString("imSimpleError") + " " + ex.Message;
                }
                pastStep.Value = "3";
            }
            #endregion

            #region step4 - not Lists
            if (step == 4)
            {
                DataTable           dtFields = (DataTable)ViewState["Fields"];
                IIncomingDataParser parser   = null;
                DataSet             rawData  = null;
                switch (rbSourceType.SelectedIndex)
                {
                case 0:
                    IMCOleDBHelper helper = (IMCOleDBHelper)Activator.GetObject(typeof(IMCOleDBHelper), ConfigurationManager.AppSettings["McOleDbServiceString"]);
                    rawData = helper.ConvertExcelToDataSet(Server.MapPath(wwwPath.Value));
                    break;

                case 1:
                    parser  = new XmlIncomingDataParser();
                    rawData = parser.Parse(Server.MapPath(wwwPath.Value), null);
                    break;
                }

                //DataSet rawData = parser.Parse(Server.MapPath(wwwPath.Value), null);
                DataTable        dtSource = rawData.Tables[0];
                MappingMetaClass mc       = null;
                mc = new IncidentMappingMetaClass();
                MetaDataPlus.Import.Rule mapping = mc.CreateClassRule();
                foreach (DataRow dr in dtFields.Rows)
                {
                    string     srcColumnName = dr["SourceField"].ToString();
                    DataColumn dc            = dtSource.Columns[srcColumnName];
                    string     realIBNField  = dr["realIBNFieldName"].ToString();
                    if (realIBNField.Length > 0)
                    {
                        MetaField mf = mc.GetColumnInfo(realIBNField).Field;
                        if (mf != null)
                        {
                            mapping.Add(new RuleItem(srcColumnName, dc.DataType, mf, FillTypes.CopyValue));
                        }
                    }
                    else
                    {
                        mapping.Add(new RuleItem(srcColumnName, dc.DataType));
                    }
                }

                try
                {
                    FillResult fr = null;
                    fr = ((IncidentMappingMetaClass)mc).FillData(FillDataMode.New, dtSource, mapping, -1);
                    lblFinalResult.Text = String.Format(LocRM.GetString("imWasDone"), fr.SuccessfulRows.ToString());
                }
                catch (Exception ex)
                {
                    lblFinalResult.Text = LocRM.GetString("imSimpleError") + " " + ex.Message;
                }
                pastStep.Value = "5";
            }
            #endregion
        }
        /// <summary>
        /// Processes the import button event.
        /// </summary>
        protected void DoImport(Guid appId)
        {
            AppContext.Current.ApplicationId = appId;

            try
            {
                string filePath        = SelectedFilePath;
                string mappingFilePath = SelectedMappingFilePath;

                if (String.IsNullOrEmpty(filePath))
                {
                    throw new Exception("No selected file.");
                }

                if (!String.IsNullOrEmpty(mappingFilePath))
                {
                    MetaDataPlus.Import.Rule mapping = MetaDataPlus.Import.Rule.XmlDeserialize(CatalogContext.MetaDataContext, mappingFilePath);
                    char chTextQualifier             = '\0';
                    if (mapping.Attribute["TextQualifier"].ToString() != "")
                    {
                        chTextQualifier = char.Parse(mapping.Attribute["TextQualifier"]);
                    }

                    string sEncoding = "Default";
                    try
                    {
                        sEncoding = mapping.Attribute["Encoding"];
                    }
                    catch { }
                    IIncomingDataParser parser  = null;
                    DataSet             rawData = null;
                    try
                    {
                        parser  = new CsvIncomingDataParser(SourcePath, true, char.Parse(mapping.Attribute["Delimiter"].ToString()), chTextQualifier, true, GetEncoding(sEncoding));
                        rawData = parser.Parse(Path.GetFileName(filePath), null);
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    DataTable dtSource = rawData.Tables[0];

                    MappingMetaClass mc = null;
                    try
                    {
                        int        CatalogId = 0;
                        FillResult fr        = null;
                        switch (mapping.Attribute["TypeName"])
                        {
                        case "Category":
                            if (!String.IsNullOrEmpty(ListCatalogs.SelectedValue))
                            {
                                CatalogId = Int32.Parse(ListCatalogs.SelectedValue);
                            }

                            CatalogContext.MetaDataContext.UseCurrentUICulture = false;
                            CatalogContext.MetaDataContext.Language            = mapping.Attribute["Language"];

                            mc = new CategoryMappingMetaClass(CatalogContext.MetaDataContext, mapping.ClassName, CatalogId);

                            fr = ((CategoryMappingMetaClass)mc).FillData(FillDataMode.All, dtSource, mapping, -1, DateTime.UtcNow);

                            CatalogContext.MetaDataContext.UseCurrentUICulture = true;
                            break;

                        case "Entry":
                            if (!String.IsNullOrEmpty(ListCatalogs.SelectedValue))
                            {
                                CatalogId = Int32.Parse(ListCatalogs.SelectedValue);
                            }

                            CatalogContext.MetaDataContext.UseCurrentUICulture = false;
                            CatalogContext.MetaDataContext.Language            = mapping.Attribute["Language"];

                            mc = new EntryMappingMetaClass(CatalogContext.MetaDataContext, mapping.ClassName, CatalogId);

                            fr = ((EntryMappingMetaClass)mc).FillData(FillDataMode.All, dtSource, mapping, -1, DateTime.UtcNow);

                            CatalogContext.MetaDataContext.UseCurrentUICulture = true;
                            break;

                        case "EntryRelation":
                            mc = new EntryRelationMappingMetaClass(CatalogContext.MetaDataContext, CatalogId);
                            fr = ((EntryRelationMappingMetaClass)mc).FillData(FillDataMode.All, dtSource, mapping, -1, DateTime.UtcNow);
                            break;

                        case "EntryAssociation":
                            mc = new EntryAssociationMappingMetaClass(CatalogContext.MetaDataContext, CatalogId);
                            fr = ((EntryAssociationMappingMetaClass)mc).FillData(FillDataMode.All, dtSource, mapping, -1, DateTime.UtcNow);
                            break;

                        case "Variation":
                            mc = new VariationMappingMetaClass(CatalogContext.MetaDataContext, CatalogId);
                            fr = ((VariationMappingMetaClass)mc).FillData(FillDataMode.All, dtSource, mapping, -1, DateTime.UtcNow);
                            break;

                        case "SalePrice":
                            mc = new PricingMappingMetaClass(CatalogContext.MetaDataContext, CatalogId);
                            fr = ((PricingMappingMetaClass)mc).FillData(FillDataMode.All, dtSource, mapping, -1, DateTime.UtcNow);
                            break;
                        }

                        if (fr != null)
                        {
                            if (fr.ErrorRows > 0)
                            {
                                foreach (Exception expt in fr.Exceptions)
                                {
                                    string exMessage = expt.Message;
                                    if (expt is MDPImportException)
                                    {
                                        MDPImportException mdpEx = (MDPImportException)expt;
                                        if (mdpEx.RowIndex > -1)
                                        {
                                            exMessage = String.Format("Import error. Line {0}: {1}", mdpEx.RowIndex + 1, exMessage);
                                        }
                                    }

                                    ProgressControl1.AddProgressMessageText(exMessage, true, 0);
                                }
                            }

                            if (fr.Warnings.Length > 0)
                            {
                                foreach (MDPImportWarning MDPWarn in fr.Warnings)
                                {
                                    ProgressControl1.AddProgressMessageText(String.Format("Line {0}: {1}", MDPWarn.RowIndex + 1, MDPWarn.Message), false, 0);
                                }
                            }

                            string msgSuccessful = RM.GetString("IMPORT_MSG_SUCCESSFUL") + ". " + string.Format(RM.GetString("IMPORT_MSG_RESULT"), fr.SuccessfulRows.ToString(), fr.TotalRows.ToString());
                            ProgressControl1.AddProgressMessageText(msgSuccessful, false, 100);
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                }
            }
            catch (Exception ex)
            {
                ProgressControl1.AddProgressMessageText(ex.Message, true, 100);
            }
            finally
            {
            }
        }