From 0058324fd1190819dfc048a0f55fd1944401efcc Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Wed, 20 Jan 2016 12:35:17 +0100 Subject: [PATCH 001/453] Import profiles: Minor improvements --- .../201512151526290_ImportFramework.cs | 6 --- .../Controllers/ExportController.cs | 3 +- .../Controllers/ImportController.cs | 13 +++--- .../Models/DataExchange/ImportProfileModel.cs | 4 -- .../Views/Import/_ColumnMappings.cshtml | 4 +- .../Views/Import/_CreateOrUpdate.cshtml | 44 ++++++++----------- .../Views/Shared/CsvConfiguration.cshtml | 6 +-- 7 files changed, 34 insertions(+), 46 deletions(-) diff --git a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs index f8004635ad..aa7b580bb9 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs @@ -102,12 +102,6 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) "Specifies the name of the import profile.", "Legt den Namen des Importprofils fest."); - builder.AddOrUpdate("Admin.DataExchange.Import.FileType", - "File type", - "Dateityp", - "The file type of the import file(s).", - "Der Dateityp der Importdatei(en)."); - builder.AddOrUpdate("Admin.DataExchange.Import.ProgressInfo", "{0} of {1} records processed", "{0} von {1} Datensätzen verarbeitet"); diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs index 39579caa57..47149316a0 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Net.Mime; using System.Web; using System.Web.Mvc; using SmartStore.Admin.Extensions; @@ -1061,7 +1062,7 @@ public ActionResult DownloadLogFile(int id) var path = profile.GetExportLogPath(); var stream = new FileStream(path, FileMode.Open); - var result = new FileStreamResult(stream, "text/plain; charset=utf-8"); + var result = new FileStreamResult(stream, MediaTypeNames.Text.Plain); result.FileDownloadName = profile.Name.ToValidFileName() + "-log.txt"; return result; diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs index c56638c2a1..42ee75b525 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs @@ -3,6 +3,7 @@ using System.Globalization; using System.IO; using System.Linq; +using System.Net.Mime; using System.Web.Mvc; using SmartStore.Admin.Extensions; using SmartStore.Admin.Models.DataExchange; @@ -134,14 +135,12 @@ private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile if (forEdit) { model.AvailableEntityTypes = ImportEntityType.Product.ToSelectList(false).ToList(); - model.AvailableFileTypes = ImportFileType.CSV.ToSelectList(false).ToList(); } if (profile != null) { model.Id = profile.Id; model.Name = profile.Name; - model.FileType = profile.FileType; model.EntityType = profile.EntityType; model.Enabled = profile.Enabled; model.Skip = profile.Skip; @@ -485,7 +484,7 @@ public ActionResult DownloadLogFile(int id) var path = profile.GetImportLogPath(); var stream = new FileStream(path, FileMode.Open); - var result = new FileStreamResult(stream, "text/plain; charset=utf-8"); + var result = new FileStreamResult(stream, MediaTypeNames.Text.Plain); result.FileDownloadName = profile.Name.ToValidFileName() + "-log.txt"; return result; @@ -521,8 +520,12 @@ public ActionResult DeleteImportFile(int id, string name) var profile = _importService.GetImportProfileById(id); if (profile != null) { - var path = Path.Combine(profile.GetImportFolder(true), name); - FileSystemHelper.Delete(path); + var importFiles = profile.GetImportFiles(); + if (importFiles.Count > 1) + { + var path = Path.Combine(profile.GetImportFolder(true), name); + FileSystemHelper.Delete(path); + } } } return RedirectToAction("Edit", new { id = id }); diff --git a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs index 7310512284..43ab03c475 100644 --- a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs +++ b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs @@ -15,10 +15,6 @@ public partial class ImportProfileModel : EntityModelBase [SmartResourceDisplayName("Admin.DataExchange.Import.Name")] public string Name { get; set; } - [SmartResourceDisplayName("Admin.DataExchange.Import.FileType")] - public ImportFileType FileType { get; set; } - public List AvailableFileTypes { get; set; } - [SmartResourceDisplayName("Admin.Common.ImportFiles")] public List ExistingFileNames { get; set; } diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml index 9e15de2aef..59562815dc 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml @@ -21,7 +21,7 @@ @T("Admin.DataExchange.ColumnMapping.ImportField") @T("Common.Language") - @T("Admin.DataExchange.ColumnMapping.EntityProperty") + @T("Admin.DataExchange.ColumnMapping.EntityProperty") @T("Admin.DataExchange.ColumnMapping.DefaultValue") @@ -54,7 +54,7 @@ } - @foreach (var prop in Model.AvailableEntityProperties) { diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml index a771ca6b3c..93e4c4051e 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml @@ -50,9 +50,12 @@ @Html.IconForFileExtension(Path.GetExtension(fileName), false) @fileName - + @if (Model.ExistingFileNames.Count > 1) + { + + }

} @@ -71,6 +74,15 @@   + + + @Html.SmartLabelFor(x => x.Enabled) + + + @Html.EditorFor(x => x.Enabled) + @Html.ValidationMessageFor(x => x.Enabled) + + @Html.SmartLabelFor(x => x.EntityType) @@ -97,24 +109,6 @@ @if (Model.Id != 0) { - - - @Html.SmartLabelFor(x => x.FileType) - - - @Html.DropDownListFor(x => x.FileType, Model.AvailableFileTypes) - @Html.ValidationMessageFor(x => x.FileType) - - - - - @Html.SmartLabelFor(x => x.Enabled) - - - @Html.EditorFor(x => x.Enabled) - @Html.ValidationMessageFor(x => x.Enabled) - - @Html.SmartLabelFor(x => x.Skip) @@ -204,8 +198,6 @@ // init column mappings select $('#ImportColumnMappings').find('select').select2({ allowClear: true, - width: 'resolve', - //dropdownAutoWidth: true, minimumResultsForSearch: 16, formatResult: columnMappingSelectItemFormatting, formatSelection: columnMappingSelectItemFormatting @@ -216,11 +208,13 @@ if (item.text.length > 0) { var option = $(item.element); - var html = '
' + item.text; + var html = '
'; + if (option.length !== 0) { html += ' (' + option.val() + ')'; } - html += '
'; + + html += '' + item.text + '
'; return html; } diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Shared/CsvConfiguration.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Shared/CsvConfiguration.cshtml index 2eeac64bc4..9a1a8f1622 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Shared/CsvConfiguration.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Shared/CsvConfiguration.cshtml @@ -43,7 +43,7 @@ @Html.SmartLabelFor(x => x.Delimiter) - @Html.EditorFor(x => x.Delimiter) + @Html.TextBoxFor(x => x.Delimiter, new { style = "width: 30px;", maxlength = "2" }) @Html.ValidationMessageFor(x => x.Delimiter) @@ -52,7 +52,7 @@ @Html.SmartLabelFor(x => x.Quote) - @Html.EditorFor(x => x.Quote) + @Html.TextBoxFor(x => x.Quote, new { style = "width: 30px;", maxlength = "2" }) @Html.ValidationMessageFor(x => x.Quote) @@ -61,7 +61,7 @@ @Html.SmartLabelFor(x => x.Escape) - @Html.EditorFor(x => x.Escape) + @Html.TextBoxFor(x => x.Escape, new { style = "width: 30px;", maxlength = "2" }) @Html.ValidationMessageFor(x => x.Escape) From 717db5d674e9913741442e1d28ada7579cd34111 Mon Sep 17 00:00:00 2001 From: Murat Cakir Date: Wed, 20 Jan 2016 20:38:17 +0100 Subject: [PATCH 002/453] Changed some icons --- src/Libraries/SmartStore.Services/Stores/StoreService.cs | 2 ++ .../SmartStore.Web/Administration/Views/Export/List.cshtml | 2 +- .../SmartStore.Web/Administration/Views/Import/Create.cshtml | 2 +- .../SmartStore.Web/Administration/Views/Import/Edit.cshtml | 2 +- .../SmartStore.Web/Administration/Views/Import/List.cshtml | 2 +- .../SmartStore.Web/Administration/sitemap.config | 5 +++-- .../Views/Product/ProductTemplate.Simple.cshtml | 2 +- .../_ProductTemplate.Grouped.AssociatedProduct.cshtml | 2 +- 8 files changed, 11 insertions(+), 8 deletions(-) diff --git a/src/Libraries/SmartStore.Services/Stores/StoreService.cs b/src/Libraries/SmartStore.Services/Stores/StoreService.cs index 16daad6591..a773079402 100644 --- a/src/Libraries/SmartStore.Services/Stores/StoreService.cs +++ b/src/Libraries/SmartStore.Services/Stores/StoreService.cs @@ -177,6 +177,8 @@ public virtual bool IsStoreDataValid(Store store) { case "www.yourstore.com": case "yourstore.com": + case "www.mystore.com": + case "mystore.com": case "www.mein-shop.de": case "mein-shop.de": return false; diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml index 520d95b0a1..146fbde86f 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml @@ -8,7 +8,7 @@
- + @T("Common.Export")
diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml index 57aaf80b7a..90e616e0b8 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml @@ -10,7 +10,7 @@
- + @title - @Model.Name @Html.ActionLink("(" + T("Admin.Common.BackToList") + ")", "List")
diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/Edit.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/Edit.cshtml index 79250bb6dd..c7f22b312b 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/Edit.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/Edit.cshtml @@ -10,7 +10,7 @@
- + @title - @Model.Name @Html.ActionLink("(" + T("Admin.Common.BackToList") + ")", "List")
diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml index 2e1eeaaeb0..daf2bc7dc1 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml @@ -8,7 +8,7 @@
- + @T("Common.Import")
diff --git a/src/Presentation/SmartStore.Web/Administration/sitemap.config b/src/Presentation/SmartStore.Web/Administration/sitemap.config index ac42790f6b..62881a6d45 100644 --- a/src/Presentation/SmartStore.Web/Administration/sitemap.config +++ b/src/Presentation/SmartStore.Web/Administration/sitemap.config @@ -127,8 +127,9 @@ - - + + + diff --git a/src/Presentation/SmartStore.Web/Views/Product/ProductTemplate.Simple.cshtml b/src/Presentation/SmartStore.Web/Views/Product/ProductTemplate.Simple.cshtml index 037fdd3a73..bf2f4ffe79 100644 --- a/src/Presentation/SmartStore.Web/Views/Product/ProductTemplate.Simple.cshtml +++ b/src/Presentation/SmartStore.Web/Views/Product/ProductTemplate.Simple.cshtml @@ -257,7 +257,7 @@ { diff --git a/src/Presentation/SmartStore.Web/Views/Product/_ProductTemplate.Grouped.AssociatedProduct.cshtml b/src/Presentation/SmartStore.Web/Views/Product/_ProductTemplate.Grouped.AssociatedProduct.cshtml index 75dda35f87..429aae896f 100644 --- a/src/Presentation/SmartStore.Web/Views/Product/_ProductTemplate.Grouped.AssociatedProduct.cshtml +++ b/src/Presentation/SmartStore.Web/Views/Product/_ProductTemplate.Grouped.AssociatedProduct.cshtml @@ -168,7 +168,7 @@ } From 4965a4d33c25c95253e9335f11002c68f47ddd4d Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Wed, 20 Jan 2016 21:31:08 +0100 Subject: [PATCH 003/453] More intuitive creation and editing of import profiles --- .../Domain/DataExchange/ImportProfile.cs | 5 + .../SmartStore.Core/Logging/TraceLogger.cs | 17 +- .../Mapping/DataExchange/ImportProfileMap.cs | 1 + .../201512151526290_ImportFramework.cs | 2 +- ...1601201138510_ImportFramework1.Designer.cs | 29 +++ .../201601201138510_ImportFramework1.cs | 59 +++++ .../201601201138510_ImportFramework1.resx | 126 ++++++++++ .../SmartStore.Data/SmartStore.Data.csproj | 7 + .../Import/DataTable/LightweightDataTable.cs | 2 +- .../Controllers/ExportController.cs | 2 +- .../Controllers/ImportController.cs | 33 ++- .../DataExchange/ImportProfileListModel.cs | 17 ++ .../Models/DataExchange/ImportProfileModel.cs | 3 +- .../Administration/SmartStore.Admin.csproj | 1 + .../Administration/Views/Export/List.cshtml | 10 +- .../Administration/Views/Import/List.cshtml | 56 ++++- .../Views/Import/_CreateOrUpdate.cshtml | 226 ++++++++++-------- 17 files changed, 463 insertions(+), 133 deletions(-) create mode 100644 src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs create mode 100644 src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs create mode 100644 src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx create mode 100644 src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileListModel.cs diff --git a/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs b/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs index 73e94b5c72..6d68a4a134 100644 --- a/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs +++ b/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs @@ -80,6 +80,11 @@ public ImportEntityType EntityType /// public string ColumnMapping { get; set; } + /// + /// XML with information about the last import + /// + public string ResultInfo { get; set; } + /// /// The scheduling task identifier /// diff --git a/src/Libraries/SmartStore.Core/Logging/TraceLogger.cs b/src/Libraries/SmartStore.Core/Logging/TraceLogger.cs index 7cb7b6e7de..20767d0095 100644 --- a/src/Libraries/SmartStore.Core/Logging/TraceLogger.cs +++ b/src/Libraries/SmartStore.Core/Logging/TraceLogger.cs @@ -1,10 +1,10 @@ using System; using System.Collections.Generic; -using System.Linq; +using System.Diagnostics; +using System.IO; using System.Text; -using SmartStore.Core.Domain.Logging; using SmartStore.Core.Domain.Customers; -using System.Diagnostics; +using SmartStore.Core.Domain.Logging; using SmartStore.Utilities; namespace SmartStore.Core.Logging @@ -12,6 +12,7 @@ namespace SmartStore.Core.Logging public class TraceLogger : DisposableObject, ILogger { private readonly TraceSource _traceSource; + private readonly StreamWriter _streamWriter; public TraceLogger() : this(CommonHelper.MapPath("~/App_Data/SmartStore.log")) { @@ -33,6 +34,12 @@ public TraceLogger(string fileName) textListener.Filter = new EventTypeFilter(SourceLevels.All); textListener.TraceOutputOptions = TraceOptions.DateTime; + // force UTF-8 encoding (even if the text just contains ANSI characters) + var append = File.Exists(fileName); + + _streamWriter = new StreamWriter(fileName, append, Encoding.UTF8); + textListener.Writer = _streamWriter; + _traceSource.Listeners.Add(console); _traceSource.Listeners.Add(textListener); @@ -132,7 +139,11 @@ public void Flush() protected override void OnDispose(bool disposing) { _traceSource.Flush(); + + _streamWriter.Close(); _traceSource.Close(); + + _streamWriter.Dispose(); } } } diff --git a/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs b/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs index 4cb2485f9e..ba36daf467 100644 --- a/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs +++ b/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs @@ -14,6 +14,7 @@ public ImportProfileMap() this.Property(x => x.FolderName).IsRequired().HasMaxLength(100); this.Property(x => x.FileTypeConfiguration).IsMaxLength(); this.Property(x => x.ColumnMapping).IsMaxLength(); + this.Property(x => x.ResultInfo).IsMaxLength(); this.Ignore(x => x.FileType); this.Ignore(x => x.EntityType); diff --git a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs index aa7b580bb9..55e9476965 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs @@ -112,7 +112,7 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) builder.AddOrUpdate("Enums.SmartStore.Core.Domain.DataExchange.ImportEntityType.NewsLetterSubscription", "Newsletter Subscriber", "Newsletter Abonnent"); builder.AddOrUpdate("Enums.SmartStore.Core.Domain.DataExchange.ImportEntityType.Category", "Category", "Warengruppe"); - builder.AddOrUpdate("Enums.SmartStore.Core.Domain.DataExchange.ImportFileType.CSV", "Delimiter separated values (.csv)", "Trennzeichen getrennte Werte (.csv)"); + builder.AddOrUpdate("Enums.SmartStore.Core.Domain.DataExchange.ImportFileType.CSV", "Delimiter separated values (.csv, .txt, .tab)", "Trennzeichen getrennte Werte (.csv, .txt, .tab)"); builder.AddOrUpdate("Enums.SmartStore.Core.Domain.DataExchange.ImportFileType.XLSX", "Excel (.xlsx)", "Excel (.xlsx)"); builder.AddOrUpdate("Admin.DataExchange.Import.FileUpload", diff --git a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs new file mode 100644 index 0000000000..feb3e12eaf --- /dev/null +++ b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs @@ -0,0 +1,29 @@ +// +namespace SmartStore.Data.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.1.3-40302")] + public sealed partial class ImportFramework1 : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(ImportFramework1)); + + string IMigrationMetadata.Id + { + get { return "201601201138510_ImportFramework1"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs new file mode 100644 index 0000000000..ed3d65e00d --- /dev/null +++ b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs @@ -0,0 +1,59 @@ +namespace SmartStore.Data.Migrations +{ + using System.Data.Entity.Migrations; + using Setup; + + public partial class ImportFramework1 : DbMigration, ILocaleResourcesProvider, IDataSeeder + { + public override void Up() + { + AddColumn("dbo.ImportProfile", "ResultInfo", c => c.String()); + } + + public override void Down() + { + DropColumn("dbo.ImportProfile", "ResultInfo"); + } + + public bool RollbackOnFailure + { + get { return false; } + } + + public void Seed(SmartObjectContext context) + { + context.MigrateLocaleResources(MigrateLocaleResources); + } + + public void MigrateLocaleResources(LocaleResourcesBuilder builder) + { + builder.AddOrUpdate("Admin.DataExchange.Import.MultipleFilesSameFileTypeNote", + "For multiple import files please make sure that they are of the same file type and that the content follows the same pattern (e.g. same column headings).", + "Bei mehreren Importdateien ist darauf zu achten, dass diese vom selben Dateityp sind und deren Inhalt demselben Schema folgt (z.B. gleiche Spaltenüberschriften)."); + + builder.AddOrUpdate("Admin.DataExchange.Import.ProfileEntitySelectNote", + "Please select the entity that you want to import.", + "Wählen Sie bitte die Entität aus, die Sie importieren möchten."); + + builder.AddOrUpdate("Admin.DataExchange.Import.ProfileCreationNote", + "Please upload an import file, enter a meaningful name for the import profile and save.", + "Laden Sie bitte eine Importdatei hoch, legen Sie einen aussagekräftigen Namen für das Importprofil fest und speichern Sie."); + + builder.AddOrUpdate("Admin.DataExchange.Import.AddAnotherFile", + "Add import file...", + "Importdatei hinzufügen..."); + + builder.AddOrUpdate("Admin.DataExchange.Import.RunNowNote", + "The task is now running in the background. You will receive an email as soon as it is completed. The progress can be tracked in the import profile list.", + "Die Aufgabe wird jetzt im Hintergrund ausgeführt. Sie erhalten eine E-Mail, sobald sie abgeschlossen ist. Den Fortschritt können Sie in der Importprofilliste verfolgen."); + + builder.AddOrUpdate("Admin.DataExchange.Export.RunNowNote", + "The task is now running in the background. You will receive an email as soon as it is completed. The progress can be tracked in the export profile list.", + "Die Aufgabe wird jetzt im Hintergrund ausgeführt. Sie erhalten eine E-Mail, sobald sie abgeschlossen ist. Den Fortschritt können Sie in der Exportprofilliste verfolgen."); + + builder.AddOrUpdate("Admin.DataExchange.Import.DefaultProfileNames", + "My product import;My category import;My customer import;My newsletter subscription import", + "Mein Produktimport;Mein Warengruppenimport;Mein Kundenimport;Mein Newsletter-Abonnement-Import"); + } + } +} diff --git a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx new file mode 100644 index 0000000000..28dccfe1e0 --- /dev/null +++ b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/src/Libraries/SmartStore.Data/SmartStore.Data.csproj b/src/Libraries/SmartStore.Data/SmartStore.Data.csproj index 951d5703c5..1d812573b2 100644 --- a/src/Libraries/SmartStore.Data/SmartStore.Data.csproj +++ b/src/Libraries/SmartStore.Data/SmartStore.Data.csproj @@ -376,6 +376,10 @@ 201512151526290_ImportFramework.cs + + + 201601201138510_ImportFramework1.cs + @@ -703,6 +707,9 @@ 201512151526290_ImportFramework.cs + + 201601201138510_ImportFramework1.cs + diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/DataTable/LightweightDataTable.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/DataTable/LightweightDataTable.cs index 99d3f4db48..ce80303706 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/DataTable/LightweightDataTable.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/DataTable/LightweightDataTable.cs @@ -128,7 +128,7 @@ public static IDataTable FromFile( break; } - var table = LightweightDataTable.FromDataReader(dataReader); + var table = LightweightDataTable.FromDataReader(dataReader, skip, take); if (table.Columns.Count == 0 || table.Rows.Count == 0) { diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs index 47149316a0..85f517749f 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ExportController.cs @@ -1015,7 +1015,7 @@ public ActionResult Execute(int id, string selectedIds) _taskScheduler.RunSingleTask(profile.SchedulingTaskId, taskParams); - NotifyInfo(T("Admin.System.ScheduleTasks.RunNow.Progress")); + NotifyInfo(T("Admin.DataExchange.Export.RunNowNote")); return RedirectToAction("List"); } diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs index 42ee75b525..056f49a03f 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs @@ -1,6 +1,5 @@ using System; using System.Collections.Generic; -using System.Globalization; using System.IO; using System.Linq; using System.Net.Mime; @@ -132,11 +131,6 @@ private void PrepareColumnMappingModels(ImportProfile profile, ImportProfileMode private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile, bool forEdit, ColumnMap invalidMap = null) { - if (forEdit) - { - model.AvailableEntityTypes = ImportEntityType.Product.ToSelectList(false).ToList(); - } - if (profile != null) { model.Id = profile.Id; @@ -174,7 +168,13 @@ private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile } else { - model.Name = model.EntityType.GetLocalizedEnum(_services.Localization, _services.WorkContext); + if (model.Name.IsEmpty()) + { + var defaultNames = T("Admin.DataExchange.Import.DefaultProfileNames").Text.SplitSafe(";"); + + model.Name = defaultNames.SafeGet((int)model.EntityType); + } + model.ExistingFileNames = new List(); } } @@ -191,8 +191,13 @@ public ActionResult List() if (!_services.Permissions.Authorize(StandardPermissionProvider.ManageImports)) return AccessDeniedView(); + var model = new ImportProfileListModel + { + Profiles = new List(), + AvailableEntityTypes = ImportEntityType.Product.ToSelectList(false).ToList() + }; + var profiles = _importService.GetImportProfiles().ToList(); - var model = new List(); foreach (var profile in profiles) { @@ -202,18 +207,22 @@ public ActionResult List() profileModel.TaskModel = profile.ScheduleTask.ToScheduleTaskModel(_services.Localization, _dateTimeHelper, Url); - model.Add(profileModel); + model.Profiles.Add(profileModel); } return View(model); } - public ActionResult Create() + public ActionResult Create(ImportEntityType entityType) { if (!_services.Permissions.Authorize(StandardPermissionProvider.ManageImports)) return AccessDeniedView(); - var model = new ImportProfileModel(); + var model = new ImportProfileModel + { + EntityType = entityType + }; + PrepareProfileModel(model, null, true); return View(model); @@ -467,7 +476,7 @@ public ActionResult Execute(int id) _taskScheduler.RunSingleTask(profile.SchedulingTaskId, taskParams); - NotifyInfo(T("Admin.System.ScheduleTasks.RunNow.Progress")); + NotifyInfo(T("Admin.DataExchange.Import.RunNowNote")); return RedirectToAction("List"); } diff --git a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileListModel.cs b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileListModel.cs new file mode 100644 index 0000000000..af9f7af39e --- /dev/null +++ b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileListModel.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using System.Web.Mvc; +using SmartStore.Core.Domain.DataExchange; +using SmartStore.Web.Framework; +using SmartStore.Web.Framework.Modelling; + +namespace SmartStore.Admin.Models.DataExchange +{ + public partial class ImportProfileListModel : EntityModelBase + { + [SmartResourceDisplayName("Admin.Common.Entity")] + public ImportEntityType EntityType { get; set; } + public List AvailableEntityTypes { get; set; } + + public List Profiles { get; set; } + } +} \ No newline at end of file diff --git a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs index 43ab03c475..ce2f6942dc 100644 --- a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs +++ b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs @@ -20,8 +20,9 @@ public partial class ImportProfileModel : EntityModelBase [SmartResourceDisplayName("Admin.Common.Entity")] public ImportEntityType EntityType { get; set; } + + [SmartResourceDisplayName("Admin.Common.Entity")] public string EntityTypeName { get; set; } - public List AvailableEntityTypes { get; set; } [SmartResourceDisplayName("Common.Enabled")] public bool Enabled { get; set; } diff --git a/src/Presentation/SmartStore.Web/Administration/SmartStore.Admin.csproj b/src/Presentation/SmartStore.Web/Administration/SmartStore.Admin.csproj index 300a287121..a2fb42096d 100644 --- a/src/Presentation/SmartStore.Web/Administration/SmartStore.Admin.csproj +++ b/src/Presentation/SmartStore.Web/Administration/SmartStore.Admin.csproj @@ -254,6 +254,7 @@ + diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml index 520d95b0a1..d66687d129 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Export/List.cshtml @@ -12,7 +12,9 @@ @T("Common.Export")
@@ -113,14 +115,14 @@ else {
- + @T("Admin.DataExchange.Export.NoProfiles")
} @@ -20,7 +22,7 @@ -@if(Model.Count > 0) +@if(Model.Profiles.Any()) { @@ -35,7 +37,7 @@ - @foreach (var profile in Model) + @foreach (var profile in Model.Profiles) { @@ -43,11 +41,11 @@ @@ -55,10 +53,10 @@ @@ -83,7 +81,7 @@ var index = Model.ColumnMappings.IndexOf(mapping) + 1; - diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml index 43182afc84..d8ce552221 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml @@ -136,6 +136,15 @@ else if (Model.ExistingFileNames.Count > 1) @Html.ValidationMessageFor(x => x.Take) + + + + }
@@ -91,14 +93,58 @@ else {
- + @T("Admin.DataExchange.Import.NoProfiles")
} + + \ No newline at end of file From a1bf022fa0c7c8fa0222de2b05ac9e7068b049b2 Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Wed, 27 Jan 2016 15:47:19 +0100 Subject: [PATCH 013/453] New import column mapping (part 2) --- .../Domain/DataExchange/ImportProfile.cs | 10 + .../Mapping/DataExchange/ImportProfileMap.cs | 1 + .../201512151526290_ImportFramework.cs | 10 +- .../201601201138510_ImportFramework1.resx | 126 ----------- ...601262000441_ImportFramework1.Designer.cs} | 2 +- ...cs => 201601262000441_ImportFramework1.cs} | 24 ++- .../201601262000441_ImportFramework1.resx | 126 +++++++++++ .../SmartStore.Data/SmartStore.Data.csproj | 10 +- .../Catalog/Importer/CategoryImporter.cs | 6 + .../Catalog/Importer/ProductImporter.cs | 6 + .../Customers/Importer/CustomerImporter.cs | 5 + .../Import/ColumnMapping/ColumnMap.cs | 7 +- .../DataExchange/Import/DataImporter.cs | 1 + .../Import/ImportExecuteContext.cs | 7 + .../NewsLetterSubscriptionImporter.cs | 5 + .../Controllers/ImportController.cs | 197 ++++++++---------- .../Models/DataExchange/ImportProfileModel.cs | 14 +- .../Views/Import/_ColumnMappings.cshtml | 31 ++- .../Views/Import/_CreateOrUpdate.cshtml | 106 ++++++---- 19 files changed, 376 insertions(+), 318 deletions(-) delete mode 100644 src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx rename src/Libraries/SmartStore.Data/Migrations/{201601201138510_ImportFramework1.Designer.cs => 201601262000441_ImportFramework1.Designer.cs} (92%) rename src/Libraries/SmartStore.Data/Migrations/{201601201138510_ImportFramework1.cs => 201601262000441_ImportFramework1.cs} (75%) create mode 100644 src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.resx diff --git a/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs b/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs index 6d68a4a134..b642e3d50d 100644 --- a/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs +++ b/src/Libraries/SmartStore.Core/Domain/DataExchange/ImportProfile.cs @@ -70,6 +70,16 @@ public ImportEntityType EntityType /// public int Take { get; set; } + /// + /// Whether to only update existing data + /// + public bool UpdateOnly { get; set; } + + /// + /// Name of key fields to identify existing records during import + /// + public string KeyFieldNames { get; set; } + /// /// File type specific configuration /// diff --git a/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs b/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs index ba36daf467..eb06973c22 100644 --- a/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs +++ b/src/Libraries/SmartStore.Data/Mapping/DataExchange/ImportProfileMap.cs @@ -12,6 +12,7 @@ public ImportProfileMap() this.Property(x => x.Name).IsRequired().HasMaxLength(100); this.Property(x => x.FolderName).IsRequired().HasMaxLength(100); + this.Property(x => x.KeyFieldNames).HasMaxLength(1000); this.Property(x => x.FileTypeConfiguration).IsMaxLength(); this.Property(x => x.ColumnMapping).IsMaxLength(); this.Property(x => x.ResultInfo).IsMaxLength(); diff --git a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs index ee02792a67..8add6b447f 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs @@ -199,16 +199,16 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) builder.AddOrUpdate("Admin.Promotions.NewsLetterSubscriptions.Fields.NewsLetterSubscriptionGuid", "Subscription GUID", "Abonnement GUID"); builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Note", - "For each field of the import file you can optionally set whether and to which object property the data is to be imported. Not yet selected properties are highlighted in the selection list. It is also possible to define a default value which is applied when the import field is empty. Through Clear all made assignments are reset to their original values.", - "Sie können optional für jedes Feld der Importdatei festlegen, ob und nach welcher Objekteigenschaft dessen Daten importiert werden sollen. Noch nicht ausgewählte Eigenschaften sind dabei in der Auswahlliste hervorgehoben. Zudem ist die Angabe eines Standardwertes möglich, der angewendet wird, wenn das Importfeld leer ist. Über Zurücksetzen werden alle getätigten Zuordnungen auf ihre Ursprungswerte zurückgesetzt."); + "You can optionally set for each field of the import file whether and for which object property the data should be imported. Fields with equal names are always imported as long as they are not explicitly ignored. Not yet selected properties are highlighted in the selection list. It is also possible to define a default value which is applied when the import field is empty.", + "Sie können optional für jedes Feld der Importdatei festlegen, ob und nach welcher Objekteigenschaft dessen Daten zu importieren sind. Gleichnamige Felder werden grundsätzlich immer importiert, sofern sie nicht explizit ignoriert werden sollen. Noch nicht ausgewählte Eigenschaften sind in der Auswahlliste hervorgehoben. Zudem ist die Angabe eines Standardwertes möglich, der angewendet wird, wenn das Importfeld leer ist."); builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.ImportField", "Import Field", "Importfeld"); builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.EntityProperty", "Object property", "Eigenschaft des Objektes"); builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.DefaultValue", "Default Value", "Standardwert"); - builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.EntityMultipleMapped", - "The object property \"{0}\" was assigned several times. Please assign each property only once.", - "Die Objekteigenschaft \"{0}\" wurde mehrfach zugeodnet. Bitte ordnen Sie jede Eigenschaft nur einmal zu."); + builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.MultipleMappedIgnored", + "The following object properties were multiple assigned and thus ignored: {0}", + "Die folgenden Objekteigenschaft wurden mehrfach zugeodnet und deshalb ignoriert: {0}"); builder.Delete( diff --git a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx b/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx deleted file mode 100644 index 28dccfe1e0..0000000000 --- a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.resx +++ /dev/null @@ -1,126 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - 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 - - - dbo - - \ No newline at end of file diff --git a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.Designer.cs similarity index 92% rename from src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs rename to src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.Designer.cs index feb3e12eaf..b8d27247a3 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.Designer.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.Designer.cs @@ -13,7 +13,7 @@ public sealed partial class ImportFramework1 : IMigrationMetadata string IMigrationMetadata.Id { - get { return "201601201138510_ImportFramework1"; } + get { return "201601262000441_ImportFramework1"; } } string IMigrationMetadata.Source diff --git a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs similarity index 75% rename from src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs rename to src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs index 1758b1e4c6..2e12f482bf 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201601201138510_ImportFramework1.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs @@ -7,12 +7,16 @@ public partial class ImportFramework1 : DbMigration, ILocaleResourcesProvider, I { public override void Up() { + AddColumn("dbo.ImportProfile", "UpdateOnly", c => c.Boolean(nullable: false)); + AddColumn("dbo.ImportProfile", "KeyFieldNames", c => c.String(maxLength: 1000)); AddColumn("dbo.ImportProfile", "ResultInfo", c => c.String()); } public override void Down() { DropColumn("dbo.ImportProfile", "ResultInfo"); + DropColumn("dbo.ImportProfile", "KeyFieldNames"); + DropColumn("dbo.ImportProfile", "UpdateOnly"); } public bool RollbackOnFailure @@ -75,12 +79,28 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) "Import von Profil \"{0}\" ist abgeschlossen"); builder.AddOrUpdate("Admin.DataExchange.Import.ColumnMapping", - "Mapping of import fields", + "Assignment of import fields", "Zuordnung der Importfelder"); builder.AddOrUpdate("Admin.DataExchange.Import.SelectTargetProperty", - "Create new mapping here", + "Create new assignment here", "Hier neue Zuordnung vornehmen"); + + builder.AddOrUpdate("Admin.DataExchange.Import.UpdateOnly", + "Only update", + "Nur aktualisieren", + "If this option is enabled, only existing data is updated but no new records are added.", + "Ist diese Option aktiviert, werden nur vorhandene Daten aktualisiert, aber keine neue Datensätze hinzugefügt."); + + builder.AddOrUpdate("Admin.DataExchange.Import.KeyFieldNames", + "Key fields", + "Schlüsselfelder", + "Existing records can be identified on the basis of key fields. The key fields are processed in the order that is defined here.", + "Anhand von Schlüsselfeldern können vorhandene Datensätze identifiziert werden. Die Schlüsselfelder werden in der hier festgelegten Reihenfolge verarbeitet."); + + builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.OneMappingRequired", + "At least one field assignment is required.", + "Es ist mindestens eine Feldzuordnung erforderlich."); } } } diff --git a/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.resx b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.resx new file mode 100644 index 0000000000..4e7843d120 --- /dev/null +++ b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/src/Libraries/SmartStore.Data/SmartStore.Data.csproj b/src/Libraries/SmartStore.Data/SmartStore.Data.csproj index 1d812573b2..dcc06c964a 100644 --- a/src/Libraries/SmartStore.Data/SmartStore.Data.csproj +++ b/src/Libraries/SmartStore.Data/SmartStore.Data.csproj @@ -376,9 +376,9 @@ 201512151526290_ImportFramework.cs - - - 201601201138510_ImportFramework1.cs + + + 201601262000441_ImportFramework1.cs @@ -707,8 +707,8 @@ 201512151526290_ImportFramework.cs - - 201601201138510_ImportFramework1.cs + + 201601262000441_ImportFramework1.cs diff --git a/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs b/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs index 08e43b0448..84e63554c9 100644 --- a/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs +++ b/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs @@ -223,6 +223,12 @@ private int ProcessCategories(IImportExecuteContext context, context.Result.AddError("The 'Name' field is required for new categories. Skipping row.", row.GetRowInfo(), "Name"); continue; } + + if (context.UpdateOnly) + { + continue; + } + category = new Category { CategoryTemplateId = defaultTemplateId diff --git a/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs b/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs index c4321349f6..f6d2c06b01 100644 --- a/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs +++ b/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs @@ -412,6 +412,12 @@ private int ProcessProducts(IImportExecuteContext context, ImportRow[] context.Result.AddError("The 'Name' field is required for new products. Skipping row.", row.GetRowInfo(), "Name"); continue; } + + if (context.UpdateOnly) + { + continue; + } + product = new Product(); } diff --git a/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs b/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs index f148f2cd6b..faec6634ba 100644 --- a/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs +++ b/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs @@ -192,6 +192,11 @@ private int ProcessCustomers(IImportExecuteContext context, if (customer == null) { + if (context.UpdateOnly) + { + continue; + } + customer = new Customer { CustomerGuid = new Guid(), diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/ColumnMapping/ColumnMap.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/ColumnMapping/ColumnMap.cs index 724253209c..e807079e9b 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/ColumnMapping/ColumnMap.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/ColumnMapping/ColumnMap.cs @@ -73,7 +73,10 @@ public bool AddMapping(string sourceColumn, string index, string entityProperty, { Guard.ArgumentNotEmpty(() => sourceColumn); - var isPropertyMultipleMapped = (entityProperty.HasValue() && _map.Any(x => x.Value.Property.IsCaseInsensitiveEqual(entityProperty))); + var isAlreadyMapped = (entityProperty.HasValue() && _map.Any(x => x.Value.Property.IsCaseInsensitiveEqual(entityProperty))); + + if (isAlreadyMapped) + return false; _map[CreateSourceName(sourceColumn, index)] = new ColumnMappingValue { @@ -81,7 +84,7 @@ public bool AddMapping(string sourceColumn, string index, string entityProperty, Default = defaultValue }; - return !isPropertyMultipleMapped; + return true; } /// diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs index 9f835fe9f6..b040a587a5 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs @@ -352,6 +352,7 @@ private void ImportCoreOuter(DataImporterContext ctx) ctx.Request.CustomerId = _services.WorkContext.CurrentCustomer.Id; // fallback to system background task customer ctx.ExecuteContext.CustomerId = ctx.Request.CustomerId; + ctx.ExecuteContext.UpdateOnly = ctx.Request.Profile.UpdateOnly; { var mapConverter = new ColumnMapConverter(); diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs index 6d59e4e27b..add9321ff3 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs @@ -13,6 +13,11 @@ public interface IImportExecuteContext /// int CustomerId { get; } + /// + /// Whether to only update existing data + /// + bool UpdateOnly { get; } + /// /// Use this dictionary for any custom data required along the export /// @@ -70,6 +75,8 @@ public ImportExecuteContext( public int CustomerId { get; internal set; } + public bool UpdateOnly { get; internal set; } + /// /// Use this dictionary for any custom data required along the import /// diff --git a/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs b/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs index 17f3c10ed0..b01a2bb480 100644 --- a/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs +++ b/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs @@ -78,6 +78,11 @@ public void Execute(IImportExecuteContext context) if (subscription == null) { + if (context.UpdateOnly) + { + continue; + } + subscription = new NewsLetterSubscription { Active = active, diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs index 416b55e0cf..e28ae3c1f6 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs @@ -3,7 +3,6 @@ using System.IO; using System.Linq; using System.Net.Mime; -using System.Text.RegularExpressions; using System.Web.Mvc; using SmartStore.Admin.Extensions; using SmartStore.Admin.Models.DataExchange; @@ -11,7 +10,6 @@ using SmartStore.Core.Domain; using SmartStore.Core.Domain.DataExchange; using SmartStore.Core.IO; -using SmartStore.Core.Localization; using SmartStore.Services; using SmartStore.Services.DataExchange.Csv; using SmartStore.Services.DataExchange.Import; @@ -55,44 +53,47 @@ public ImportController( private void PrepareColumnMappingModels(ImportProfile profile, ImportProfileModel model, CsvConfiguration csvConfiguration, ColumnMap invalidMap = null) { model.AvailableSourceColumns = new List(); - model.AvailableEntityProperties = new List(); try { var mapConverter = new ColumnMapConverter(); - var map = (invalidMap != null ? invalidMap : mapConverter.ConvertFrom(profile.ColumnMapping)); - var hasMappings = (map != null && map.Mappings.Any()); + var storedMap = mapConverter.ConvertFrom(profile.ColumnMapping); + var hasStoredMappings = (storedMap != null && storedMap.Mappings.Any()); + var map = (invalidMap ?? storedMap) ?? new ColumnMap(); + + // property name to localized property name + var allProperties = _importService.GetImportableEntityProperties(profile.EntityType); + + model.AvailableEntityProperties = allProperties + .Select(x => new SelectListItem { Value = x.Key, Text = x.Value }) + .OrderBy(x => x.Text) + .ToList(); - if (hasMappings) - { - model.ColumnMappings = map.Mappings - .Select(x => new ColumnMappingItemModel + model.ColumnMappings = map.Mappings + .Select(x => + { + var mapping = new ColumnMappingItemModel { - Column = x.Key, - Property = x.Value.Property, - IsNilProperty = x.Value.Property.IsEmpty(), + Column = (x.Value.Property.IsEmpty() ? null : x.Key), + Property = (x.Value.Property.IsEmpty() ? x.Key : x.Value.Property), Default = x.Value.Default - }) - .ToList(); - } - else - { - model.ColumnMappings = new List(); - } + }; + + // add localized to make mappings sortable + if (allProperties.ContainsKey(mapping.Property)) + { + mapping.ColumnLocalized = allProperties[mapping.Property]; + } + + return mapping; + }) + .ToList(); var files = profile.GetImportFiles(); if (!files.Any()) return; var filePath = files.First(); - var allLanguages = _languageService.GetAllLanguages(true); - - var destProperties = _importService.GetImportableEntityProperties(profile.EntityType); - - model.AvailableEntityProperties = destProperties - .Select(x => new SelectListItem { Value = x.Key, Text = x.Value }) - .OrderBy(x => x.Text) - .ToList(); using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { @@ -108,37 +109,32 @@ private void PrepareColumnMappingModels(ImportProfile profile, ImportProfileMode Index = dataTable.Columns.IndexOf(column), Column = column.Name, ColumnWithoutIndex = columnWithoutIndex, - ColumnIndex = columnIndex + ColumnIndex = columnIndex, + ColumnLocalized = (allProperties.ContainsKey(column.Name) ? allProperties[column.Name] : column.Name) }; - if (destProperties.ContainsKey(column.Name)) - { - mapModel.ColumnLocalized = destProperties[column.Name]; - } + model.AvailableSourceColumns.Add(mapModel); - if (columnIndex.HasValue()) - { - var language = allLanguages.FirstOrDefault(x => x.UniqueSeoCode.IsCaseInsensitiveEqual(columnIndex)); - if (language != null) + // auto map where field equals property name + if (!hasStoredMappings && !model.ColumnMappings.Any(x => x.Column == column.Name) && allProperties.Any(x => x.Key == column.Name)) + { + model.ColumnMappings.Add(new ColumnMappingItemModel { - mapModel.LanguageDescription = LocalizationHelper.GetLanguageNativeName(language.LanguageCulture); - mapModel.FlagImageFileName = language.FlagImageFileName; - } + Column = column.Name, + Property = column.Name, + ColumnLocalized = (allProperties.ContainsKey(column.Name) ? allProperties[column.Name] : null) + }); } + } - //if (hasMappings) - //{ - // var mapping = map.Mappings.FirstOrDefault(x => x.Key == column.Name); - // if (mapping.Value != null) - // { - // mapModel.Property = mapping.Value.Property; - // mapModel.Default = mapping.Value.Default; - // mapModel.IsNilProperty = mapping.Value.Property.IsEmpty(); - // } - //} + // sorting + model.AvailableSourceColumns = model.AvailableSourceColumns + .OrderBy(x => x.ColumnLocalized) + .ToList(); - model.AvailableSourceColumns.Add(mapModel); - } + model.ColumnMappings = model.ColumnMappings + .OrderBy(x => x.ColumnLocalized) + .ToList(); } } catch (Exception exception) @@ -157,6 +153,8 @@ private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile model.Enabled = profile.Enabled; model.Skip = profile.Skip; model.Take = profile.Take; + model.UpdateOnly = profile.UpdateOnly; + model.KeyFieldNames = profile.KeyFieldNames.SplitSafe(","); model.ScheduleTaskId = profile.SchedulingTaskId; model.ScheduleTaskName = profile.ScheduleTask.Name.NaIfEmpty(); model.IsTaskRunning = profile.ScheduleTask.IsRunning; @@ -166,6 +164,7 @@ private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile model.UnspecifiedString = T("Common.Unspecified"); model.AddNewString = T("Common.AddNew"); model.DeleteString = T("Common.Delete"); + model.IgnoreString = T("Admin.Common.Ignore"); model.ExistingFileNames = profile.GetImportFiles() .Select(x => Path.GetFileName(x)) @@ -329,82 +328,44 @@ public ActionResult Edit(ImportProfileModel model, bool continueEditing, FormCol if (profile == null) return RedirectToAction("List"); - var hasErrors = false; + var multipleMapped = new List(); var map = new ColumnMap(); - var mapConverter = new ColumnMapConverter(); - CsvConfiguration csvConfig = null; - - if (!ModelState.IsValid) - { - PrepareProfileModel(model, profile, true, map); - return View(model); - } + var hasErrors = false; try { - if (model.CsvConfiguration != null) - { - csvConfig = model.CsvConfiguration.Clone(); - } - var propertyKeyPrefix = "ColumnMapping.Property."; var allPropertyKeys = form.AllKeys.Where(x => x.HasValue() && x.StartsWith(propertyKeyPrefix)); - foreach (var key in allPropertyKeys) + if (allPropertyKeys.Any()) { - var index = key.Substring(propertyKeyPrefix.Length); - var property = form[key]; - var column = form["ColumnMapping.Column." + index]; - var defaultValue = form["ColumnMapping.Default." + index]; + var entityProperties = _importService.GetImportableEntityProperties(profile.EntityType); - string columnWithoutIndex, columnIndex; - - if (ColumnMap.ParseSourceColumn(column, out columnWithoutIndex, out columnIndex)) + foreach (var key in allPropertyKeys) { - var result = map.AddMapping(column, columnIndex, property, defaultValue); + var index = key.Substring(propertyKeyPrefix.Length); + var property = form[key]; + var column = form["ColumnMapping.Column." + index]; + var defaultValue = form["ColumnMapping.Default." + index]; + var result = true; + + // ignored properties: column is empty means swap column and property + if (column.IsEmpty()) + result = map.AddMapping(property, null, null); + else + result = map.AddMapping(column, null, property, defaultValue); if (!result) { - // add model state error for multiple mapped properties - ModelState.AddModelError("", T("Admin.DataExchange.ColumnMapping.Validate.EntityMultipleMapped", property)); + // add warning for ignored, multiple mapped properties + multipleMapped.Add("{0} ({1})".FormatInvariant(entityProperties.ContainsKey(property) ? entityProperties[property] : "".NaIfEmpty(), property)); } } } - - //var filePath = profile.GetImportFiles().First(); - //using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) - //{ - // var dataTable = LightweightDataTable.FromFile(Path.GetFileName(filePath), stream, stream.Length, csvConfig ?? CsvConfiguration.ExcelFriendlyConfiguration, 0, 1); - - // foreach (var column in dataTable.Columns.Where(x => x.Name.HasValue())) - // { - // var index = dataTable.Columns.IndexOf(column); - // var key = "ColumnMapping.Property." + index.ToString(); - - // if (form.AllKeys.Contains(key)) - // { - // // allow to nil an entity property name to explicitly ignore a column - // var entityProperty = form[key]; - // var defaultValue = form["ColumnMapping.Default." + index.ToString()]; - - // map.AddMapping(column.Name, null, entityProperty, defaultValue); - // } - // } - - // // add model state error for invalid mappings - // foreach (var invalidMapping in map.GetInvalidMappings()) - // { - // // do not mark columns as invalid where column name equals entity property name - // if (invalidMapping.Key != invalidMapping.Value.Property) - // { - // var column = dataTable.Columns.First(x => x.Name == invalidMapping.Key); - // var index = dataTable.Columns.IndexOf(column); - // var key = "ColumnMapping.Property." + index.ToString(); - - // ModelState.AddModelError(key, T("Admin.DataExchange.ColumnMapping.Validate.EntityMultipleMapped", invalidMapping.Value.Property)); - // } - // } - //} + else + { + ModelState.AddModelError("", T("Admin.DataExchange.ColumnMapping.Validate.OneMappingRequired")); + } } catch (Exception exception) { @@ -412,7 +373,7 @@ public ActionResult Edit(ImportProfileModel model, bool continueEditing, FormCol NotifyError(exception, true, false); } - if (!ModelState.IsValid) + if (!ModelState.IsValid || hasErrors) { PrepareProfileModel(model, profile, true, map); return View(model); @@ -423,16 +384,19 @@ public ActionResult Edit(ImportProfileModel model, bool continueEditing, FormCol profile.Enabled = model.Enabled; profile.Skip = model.Skip; profile.Take = model.Take; + profile.UpdateOnly = model.UpdateOnly; + profile.KeyFieldNames = (model.KeyFieldNames == null ? null : string.Join(",", model.KeyFieldNames)); profile.FileTypeConfiguration = null; try { + var mapConverter = new ColumnMapConverter(); profile.ColumnMapping = mapConverter.ConvertTo(map); - if (profile.FileType == ImportFileType.CSV && csvConfig != null) + if (profile.FileType == ImportFileType.CSV && model.CsvConfiguration != null) { var csvConverter = new CsvConfigurationConverter(); - profile.FileTypeConfiguration = csvConverter.ConvertTo(csvConfig); + profile.FileTypeConfiguration = csvConverter.ConvertTo(model.CsvConfiguration.Clone()); } } catch (Exception exception) @@ -446,6 +410,11 @@ public ActionResult Edit(ImportProfileModel model, bool continueEditing, FormCol _importService.UpdateImportProfile(profile); NotifySuccess(T("Admin.Common.DataSuccessfullySaved")); + + if (multipleMapped.Any()) + { + NotifyWarning(T("Admin.DataExchange.ColumnMapping.Validate.MultipleMappedIgnored", "

" + string.Join("
", multipleMapped) + "

")); + } } return (continueEditing ? RedirectToAction("Edit", new { id = profile.Id }) : RedirectToAction("List")); diff --git a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs index 694591115d..c385ed872f 100644 --- a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs +++ b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs @@ -34,6 +34,13 @@ public partial class ImportProfileModel : EntityModelBase [SmartResourceDisplayName("Admin.Common.RecordsTake")] public int Take { get; set; } + [SmartResourceDisplayName("Admin.DataExchange.Import.UpdateOnly")] + public bool UpdateOnly { get; set; } + + [SmartResourceDisplayName("Admin.DataExchange.Import.KeyFieldNames")] + public string[] KeyFieldNames { get; set; } + public List AvailableKeyFieldNames { get; set; } + [SmartResourceDisplayName("Common.Execution")] public int ScheduleTaskId { get; set; } public string ScheduleTaskName { get; set; } @@ -48,6 +55,7 @@ public partial class ImportProfileModel : EntityModelBase public string UnspecifiedString { get; set; } public string AddNewString { get; set; } public string DeleteString { get; set; } + public string IgnoreString { get; set; } public CsvConfigurationModel CsvConfiguration { get; set; } @@ -66,10 +74,10 @@ public class ColumnMappingItemModel public string ColumnIndex { get; set; } public string ColumnLocalized { get; set; } - public string LanguageDescription { get; set; } - public string FlagImageFileName { get; set; } + //public string LanguageDescription { get; set; } + //public string FlagImageFileName { get; set; } - public bool IsNilProperty { get; set; } + //public bool IsNilProperty { get; set; } public string Property { get; set; } public string Default { get; set; } } diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml index a4d7a822fe..02ff000213 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml @@ -16,13 +16,11 @@ @Html.Raw(T("Admin.DataExchange.ColumnMapping.Note")) - @if (Model.ColumnMappings != null && Model.ColumnMappings.Any()) + @if (Model.ColumnMappings.Any()) { -
- -
+ }
- @foreach (var column in Model.AvailableSourceColumns) { - + } - -
- @foreach (var property in Model.AvailableEntityProperties) { @@ -93,21 +91,22 @@ - @foreach (var column in Model.AvailableSourceColumns) { - var select = column.Column.IsCaseInsensitiveEqual(mapping.Column); + var select = (mapping.Column.HasValue() && column.Column.IsCaseInsensitiveEqual(mapping.Column)); var text = (column.ColumnLocalized.HasValue() ? column.ColumnLocalized : column.Column); } - + - +
+ @Html.SmartLabelFor(x => x.UpdateOnly) + + @Html.EditorFor(x => x.UpdateOnly) + @Html.ValidationMessageFor(x => x.UpdateOnly) +
@@ -196,47 +205,53 @@ else if (Model.ExistingFileNames.Count > 1) return false; }); - // reset column mappings button + // reset column mappings $('#ResetColumnMappings').click(function (e) { e.preventDefault(); - if (confirm('@T("Admin.Common.AskToProceed")')) { var form = '
'; $('body').append(form); $('#ResetColumnMappingsForm').submit(); } - return false; }); // mapping row handling $('#ImportColumnMappings').on('change', '.mapping-control-property', function () { - var row = $(this).closest('tr'); - if (row.hasClass('column-mapping-new')) { - var property = $(this).val(), - hasProperty = !_.isEmpty(property); + var row = $(this).closest('tr'), + property = $(this).select2('val'), + hasProperty = !_.isEmpty(property); + if (row.hasClass('column-mapping-new')) { row.find('.mapping-control-column').select2('val', property).select2(hasProperty ? 'enable' : 'disable').prop('disabled', !hasProperty); - row.find('.mapping-control-default').prop('disabled', !hasProperty); var hasColumn = !_.isEmpty(row.find('.mapping-control-column').select2('val')); - row.find('.mapping-button-add').toggle(hasProperty && hasColumn); + row.find('.mapping-control-default').prop('disabled', !(hasProperty && hasColumn)); + row.find('.mapping-button-add').toggle(hasProperty); + } + else { + var hasColumn = !_.isEmpty(row.find('.mapping-control-column').select2('val')); + if (!hasColumn) { + row.find('.mapping-control-column').select2('val', property); + } } }).on('change', '.mapping-control-column', function () { - var row = $(this).closest('tr'); - if (row.hasClass('column-mapping-new')) { - var hasColumn = !_.isEmpty($(this).val()), - hasProperty = !_.isEmpty(row.find('.mapping-control-property').val()); + var row = $(this).closest('tr'), + hasColumn = !_.isEmpty($(this).select2('val')), + hasProperty = !_.isEmpty(row.find('.mapping-control-property').select2('val')); - row.find('.mapping-button-add').toggle(hasProperty && hasColumn); + if (row.hasClass('column-mapping-new')) { + row.find('.mapping-button-add').toggle(hasProperty); } + + row.find('.mapping-control-default').prop('disabled', !(hasProperty && hasColumn)); }).on('click', '.mapping-button-add', function () { var row = $(this).closest('tr'), table = row.closest('table'), index = parseInt(table.attr('data-maxindex')) + 1; row.find('.mapping-control-property').attr('name', 'ColumnMapping.Property.' + index); - row.find('.mapping-control-column').attr('name', 'ColumnMapping.Column.' + index);//.prop('disabled', false); + row.find('.mapping-control-column').attr('name', 'ColumnMapping.Column.' + index); row.find('.mapping-control-default').attr('name', 'ColumnMapping.Default.' + index); table.attr('data-maxindex', index); @@ -250,9 +265,40 @@ else if (Model.ExistingFileNames.Count > 1) $(this).closest('tr').remove(); }); + + initSelectBoxes($('#ImportColumnMappings')); appendNewMappingRow(); + function initSelectBoxes(context) { + var options = { + allowClear: true, + minimumResultsForSearch: 16, + matcher: function (term, text, opt) { + var searchFor = term.toUpperCase(); + + if (text.toUpperCase().indexOf(searchFor) >= 0) + return true; + + var val = $(opt).val(); + if (val && val.toUpperCase().indexOf(searchFor) >= 0) + return true; + + return false; + } + }; + + context.find('.mapping-control-property').select2($.extend({}, options, { + formatResult: selectPropertyFormatting, + formatSelection: selectPropertyFormatting + })); + + context.find('.mapping-control-column').select2($.extend({}, options, { + formatResult: selectColumnFormatting, + formatSelection: selectColumnFormatting + })); + } + function appendNewMappingRow() { var mappings = $('#ImportColumnMappings'); if (!mappings.length) @@ -263,22 +309,7 @@ else if (Model.ExistingFileNames.Count > 1) mappings.find('table:first tbody').append(html); var row = mappings.find('table:first tr:last'); - - row.find('.mapping-control-property').select2({ - allowClear: true, - minimumResultsForSearch: 16, - formatResult: selectPropertyFormatting, - formatSelection: selectPropertyFormatting, - matcher: selectMatcher - }); - - row.find('.mapping-control-column').select2({ - allowClear: true, - minimumResultsForSearch: 16, - formatResult: selectColumnFormatting, - formatSelection: selectColumnFormatting, - matcher: selectMatcher - }); + initSelectBoxes(row); } function selectPropertyFormatting(item, container, query) { @@ -364,18 +395,5 @@ else if (Model.ExistingFileNames.Count > 1) return item.text; } - function selectMatcher(term, text, opt) { - var searchFor = term.toUpperCase(); - - if (text.toUpperCase().indexOf(searchFor) >= 0) - return true; - - var val = $(opt).val(); - if (val && val.toUpperCase().indexOf(searchFor) >= 0) - return true; - - return false; - } - }); \ No newline at end of file From dca38fcee0578c6373aad23d89bc14984157c8a8 Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Wed, 27 Jan 2016 17:29:27 +0100 Subject: [PATCH 014/453] Minor change --- .../Migrations/201512151526290_ImportFramework.cs | 4 ---- .../Migrations/201601262000441_ImportFramework1.cs | 4 ++++ 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs index 8add6b447f..e315e7a4c4 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201512151526290_ImportFramework.cs @@ -206,10 +206,6 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.EntityProperty", "Object property", "Eigenschaft des Objektes"); builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.DefaultValue", "Default Value", "Standardwert"); - builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.MultipleMappedIgnored", - "The following object properties were multiple assigned and thus ignored: {0}", - "Die folgenden Objekteigenschaft wurden mehrfach zugeodnet und deshalb ignoriert: {0}"); - builder.Delete( "Admin.DataExchange.Export.LastExecution", diff --git a/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs index 2e12f482bf..296f0d470a 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs @@ -101,6 +101,10 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.OneMappingRequired", "At least one field assignment is required.", "Es ist mindestens eine Feldzuordnung erforderlich."); + + builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.MultipleMappedIgnored", + "The following object properties were multiple assigned and thus ignored: {0}", + "Die folgenden Objekteigenschaft wurden mehrfach zugeodnet und deshalb ignoriert: {0}"); } } } From 0c69e9d548a10ac113a4373e6738c55861917898 Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Thu, 28 Jan 2016 12:04:58 +0100 Subject: [PATCH 015/453] Option to define key field names to identify existing records during an import --- .../201601262000441_ImportFramework1.cs | 8 +- .../Catalog/IProductService.cs | 16 +- .../Catalog/Importer/CategoryImporter.cs | 44 +++++- .../Catalog/Importer/ProductImporter.cs | 54 +++++-- .../Catalog/ProductService.cs | 30 ++++ .../Customers/Importer/CustomerImporter.cs | 45 +++++- .../DataExchange/Import/DataImporter.cs | 1 + .../Import/IImportProfileService.cs | 5 + .../Import/ImportExecuteContext.cs | 9 +- .../Import/ImportProfileService.cs | 25 ++- .../NewsLetterSubscriptionImporter.cs | 35 +++- .../Controllers/ImportController.cs | 149 +++++++++++------- .../Models/DataExchange/ImportProfileModel.cs | 6 +- .../DataExchange/ImportProfileValidator.cs | 4 + .../Views/Import/_ColumnMappings.cshtml | 65 +------- .../Views/Import/_CreateOrUpdate.cshtml | 15 +- 16 files changed, 348 insertions(+), 163 deletions(-) diff --git a/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs index 296f0d470a..997181dc73 100644 --- a/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs +++ b/src/Libraries/SmartStore.Data/Migrations/201601262000441_ImportFramework1.cs @@ -95,8 +95,12 @@ public void MigrateLocaleResources(LocaleResourcesBuilder builder) builder.AddOrUpdate("Admin.DataExchange.Import.KeyFieldNames", "Key fields", "Schlüsselfelder", - "Existing records can be identified on the basis of key fields. The key fields are processed in the order that is defined here.", - "Anhand von Schlüsselfeldern können vorhandene Datensätze identifiziert werden. Die Schlüsselfelder werden in der hier festgelegten Reihenfolge verarbeitet."); + "Existing records can be identified for updates on the basis of key fields. The key fields are processed in the order how they are defined here.", + "Anhand von Schlüsselfeldern können vorhandene Datensätze zwecks Aktualisierung identifiziert werden. Die Schlüsselfelder werden in der hier festgelegten Reihenfolge verarbeitet."); + + builder.AddOrUpdate("Admin.DataExchange.Import.Validate.OneKeyFieldRequired", + "At least one key field is required.", + "Es ist mindestens ein Schlüsselfeld erforderlich."); builder.AddOrUpdate("Admin.DataExchange.ColumnMapping.Validate.OneMappingRequired", "At least one field assignment is required.", diff --git a/src/Libraries/SmartStore.Services/Catalog/IProductService.cs b/src/Libraries/SmartStore.Services/Catalog/IProductService.cs index 8db5ba4dcf..0b1f7649d5 100644 --- a/src/Libraries/SmartStore.Services/Catalog/IProductService.cs +++ b/src/Libraries/SmartStore.Services/Catalog/IProductService.cs @@ -108,7 +108,21 @@ public partial interface IProductService /// GTIN /// Product Product GetProductByGtin(string gtin); - + + /// + /// Gets a product by manufacturer part number (MPN) + /// + /// Manufacturer part number + /// Product + Product GetProductByManufacturerPartNumber(string manufacturerPartNumber); + + /// + /// Gets a product by name + /// + /// Product name + /// Product + Product GetProductByName(string name); + /// /// Adjusts inventory /// diff --git a/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs b/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs index 84e63554c9..fa0fdc9ca4 100644 --- a/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs +++ b/src/Libraries/SmartStore.Services/Catalog/Importer/CategoryImporter.cs @@ -209,23 +209,37 @@ private int ProcessCategories(IImportExecuteContext context, { Category category = null; var id = row.GetDataValue("Id"); + var name = row.GetDataValue("Name"); - if (id != 0) + foreach (var keyName in context.KeyFieldNames) { - category = _categoryRepository.GetById(id); + switch (keyName) + { + case "Id": + if (id != 0) + category = _categoryRepository.GetById(id); + break; + case "Name": + if (name.HasValue()) + category = _categoryRepository.Table.FirstOrDefault(x => x.Name == name); + break; + } + + if (category != null) + break; } if (category == null) { - // a Name is required with new categories - if (!row.Segmenter.HasColumn("Name")) + if (context.UpdateOnly) { - context.Result.AddError("The 'Name' field is required for new categories. Skipping row.", row.GetRowInfo(), "Name"); continue; } - if (context.UpdateOnly) + // a Name is required with new categories + if (!row.Segmenter.HasColumn("Name")) { + context.Result.AddError("The 'Name' field is required for new categories. Skipping row.", row.GetRowInfo(), "Name"); continue; } @@ -235,8 +249,6 @@ private int ProcessCategories(IImportExecuteContext context, }; } - var name = row.GetDataValue("Name"); - row.Initialize(category, name); if (!row.IsNew && !category.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) @@ -311,6 +323,22 @@ private int ProcessCategories(IImportExecuteContext context, return num; } + public static string[] SupportedKeyFields + { + get + { + return new string[] { "Id", "Name" }; + } + } + + public static string[] DefaultKeyFields + { + get + { + return new string[] { "Id" }; + } + } + public void Execute(IImportExecuteContext context) { var utcNow = DateTime.UtcNow; diff --git a/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs b/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs index f6d2c06b01..6567af0ca8 100644 --- a/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs +++ b/src/Libraries/SmartStore.Services/Catalog/Importer/ProductImporter.cs @@ -391,30 +391,44 @@ private int ProcessProducts(IImportExecuteContext context, ImportRow[] foreach (var row in batch) { - var id = row.GetDataValue("Id"); - var product = _productService.GetProductById(id); + Product product = null; - if (product == null) + foreach (var keyName in context.KeyFieldNames) { - product = _productService.GetProductBySku(row.GetDataValue("Sku")); - } + switch (keyName) + { + case "Id": + product = _productService.GetProductById(row.GetDataValue("Id")); + break; + case "Sku": + product = _productService.GetProductBySku(row.GetDataValue("Sku")); + break; + case "Gtin": + product = _productService.GetProductByGtin(row.GetDataValue("Gtin")); + break; + case "ManufacturerPartNumber": + product = _productService.GetProductByManufacturerPartNumber(row.GetDataValue("ManufacturerPartNumber")); + break; + case "Name": + product = _productService.GetProductByName(row.GetDataValue("Name")); + break; + } - if (product == null) - { - product = _productService.GetProductByGtin(row.GetDataValue("Gtin")); + if (product != null) + break; } if (product == null) { - // a Name is required with new products. - if (!row.Segmenter.HasColumn("Name")) + if (context.UpdateOnly) { - context.Result.AddError("The 'Name' field is required for new products. Skipping row.", row.GetRowInfo(), "Name"); continue; } - if (context.UpdateOnly) + // a Name is required with new products. + if (!row.Segmenter.HasColumn("Name")) { + context.Result.AddError("The 'Name' field is required for new products. Skipping row.", row.GetRowInfo(), "Name"); continue; } @@ -545,6 +559,22 @@ private int ProcessProducts(IImportExecuteContext context, ImportRow[] return num; } + public static string[] SupportedKeyFields + { + get + { + return new string[] { "Id", "Sku", "Gtin", "ManufacturerPartNumber", "Name" }; + } + } + + public static string[] DefaultKeyFields + { + get + { + return new string[] { "Id", "Sku", "Gtin" }; + } + } + public void Execute(IImportExecuteContext context) { using (var scope = new DbContextScope(ctx: _productRepository.Context, autoDetectChanges: false, proxyCreation: false, validateOnSave: false)) diff --git a/src/Libraries/SmartStore.Services/Catalog/ProductService.cs b/src/Libraries/SmartStore.Services/Catalog/ProductService.cs index 5ad3c8fc85..3f4f76cc20 100644 --- a/src/Libraries/SmartStore.Services/Catalog/ProductService.cs +++ b/src/Libraries/SmartStore.Services/Catalog/ProductService.cs @@ -1149,6 +1149,36 @@ orderby p.Id return product; } + public virtual Product GetProductByManufacturerPartNumber(string manufacturerPartNumber) + { + if (manufacturerPartNumber.IsEmpty()) + return null; + + manufacturerPartNumber = manufacturerPartNumber.Trim(); + + var product = _productRepository + .Where(x => !x.Deleted && x.ManufacturerPartNumber == manufacturerPartNumber) + .OrderBy(x => x.Id) + .FirstOrDefault(); + + return product; + } + + public virtual Product GetProductByName(string name) + { + if (name.IsEmpty()) + return null; + + name = name.Trim(); + + var product = _productRepository + .Where(x => !x.Deleted && x.Name == name) + .OrderBy(x => x.Id) + .FirstOrDefault(); + + return product; + } + /// /// Adjusts inventory /// diff --git a/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs b/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs index faec6634ba..a8dc5d814b 100644 --- a/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs +++ b/src/Libraries/SmartStore.Services/Customers/Importer/CustomerImporter.cs @@ -180,14 +180,32 @@ private int ProcessCustomers(IImportExecuteContext context, foreach (var row in batch) { + Customer customer = null; var id = row.GetDataValue("Id"); - var customer = _customerService.GetCustomerById(id); + var email = row.GetDataValue("Email"); - if (customer == null) + foreach (var keyName in context.KeyFieldNames) { - var guid = row.GetDataValue("CustomerGuid"); - if (guid.HasValue()) - customer = _customerService.GetCustomerByGuid(new Guid(guid)); + switch (keyName) + { + case "Id": + customer = _customerService.GetCustomerById(id); + break; + case "CustomerGuid": + var guid = row.GetDataValue("CustomerGuid"); + if (guid.HasValue()) + customer = _customerService.GetCustomerByGuid(new Guid(guid)); + break; + case "Email": + customer = _customerService.GetCustomerByEmail(email); + break; + case "Username": + customer = _customerService.GetCustomerByUsername(row.GetDataValue("Username")); + break; + } + + if (customer != null) + break; } if (customer == null) @@ -209,7 +227,6 @@ private int ProcessCustomers(IImportExecuteContext context, _customerRepository.Context.LoadCollection(customer, (Customer x) => x.CustomerRoles); } - var email = row.GetDataValue("Email"); var isGuest = row.GetDataValue("IsGuest"); var isRegistered = row.GetDataValue("IsRegistered"); var isAdmin = row.GetDataValue("IsAdministrator"); @@ -268,6 +285,22 @@ private int ProcessCustomers(IImportExecuteContext context, return num; } + public static string[] SupportedKeyFields + { + get + { + return new string[] { "Id", "CustomerGuid", "Email", "Username" }; + } + } + + public static string[] DefaultKeyFields + { + get + { + return new string[] { "Id", "CustomerGuid" }; + } + } + public void Execute(IImportExecuteContext context) { var utcNow = DateTime.UtcNow; diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs index b040a587a5..48acf48441 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/DataImporter.cs @@ -353,6 +353,7 @@ private void ImportCoreOuter(DataImporterContext ctx) ctx.ExecuteContext.CustomerId = ctx.Request.CustomerId; ctx.ExecuteContext.UpdateOnly = ctx.Request.Profile.UpdateOnly; + ctx.ExecuteContext.KeyFieldNames = ctx.Request.Profile.KeyFieldNames.SplitSafe(","); { var mapConverter = new ColumnMapConverter(); diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/IImportProfileService.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/IImportProfileService.cs index 0cb0ba8ef2..ecfc9e816e 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/IImportProfileService.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/IImportProfileService.cs @@ -42,6 +42,11 @@ public interface IImportProfileService /// Import profile ImportProfile GetImportProfileById(int id); + /// + /// Get all importable entity properties and their localized values + /// + /// Import entity type + /// Importable entity properties Dictionary GetImportableEntityProperties(ImportEntityType entityType); } } diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs index add9321ff3..9f5ba29006 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/ImportExecuteContext.cs @@ -14,10 +14,15 @@ public interface IImportExecuteContext int CustomerId { get; } /// - /// Whether to only update existing data + /// Whether to only update existing records /// bool UpdateOnly { get; } + /// + /// Name of key fields to identify existing records for updating + /// + string[] KeyFieldNames { get; } + /// /// Use this dictionary for any custom data required along the export /// @@ -77,6 +82,8 @@ public ImportExecuteContext( public bool UpdateOnly { get; internal set; } + public string[] KeyFieldNames { get; internal set; } + /// /// Use this dictionary for any custom data required along the import /// diff --git a/src/Libraries/SmartStore.Services/DataExchange/Import/ImportProfileService.cs b/src/Libraries/SmartStore.Services/DataExchange/Import/ImportProfileService.cs index e28f3ae6e7..80b3c34ccd 100644 --- a/src/Libraries/SmartStore.Services/DataExchange/Import/ImportProfileService.cs +++ b/src/Libraries/SmartStore.Services/DataExchange/Import/ImportProfileService.cs @@ -11,7 +11,10 @@ using SmartStore.Core.Domain.Tasks; using SmartStore.Core.Events; using SmartStore.Core.Localization; +using SmartStore.Services.Catalog.Importer; +using SmartStore.Services.Customers.Importer; using SmartStore.Services.Localization; +using SmartStore.Services.Messages.Importer; using SmartStore.Services.Tasks; using SmartStore.Utilities; @@ -136,6 +139,26 @@ public virtual ImportProfile InsertImportProfile(string fileName, string name, I else profile.FileType = ImportFileType.CSV; + string[] keyFieldNames = null; + + switch (entityType) + { + case ImportEntityType.Product: + keyFieldNames = ProductImporter.DefaultKeyFields; + break; + case ImportEntityType.Category: + keyFieldNames = CategoryImporter.DefaultKeyFields; + break; + case ImportEntityType.Customer: + keyFieldNames = CustomerImporter.DefaultKeyFields; + break; + case ImportEntityType.NewsLetterSubscription: + keyFieldNames = NewsLetterSubscriptionImporter.DefaultKeyFields; + break; + } + + profile.KeyFieldNames = string.Join(",", keyFieldNames); + profile.FolderName = SeoHelper.GetSeName(name, true, false) .ToValidPath() .Truncate(_dataExchangeSettings.MaxFileNameLength); @@ -255,7 +278,7 @@ public virtual Dictionary GetImportableEntityProperties(ImportEn foreach (var member in entitySet.ElementType.Members) { - if (member.BuiltInTypeKind.HasFlag(BuiltInTypeKind.EdmProperty)) + if (!member.Name.IsCaseInsensitiveEqual("Id") && member.BuiltInTypeKind.HasFlag(BuiltInTypeKind.EdmProperty)) { var localizedValue = GetLocalizedPropertyName(type, member.Name); diff --git a/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs b/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs index b01a2bb480..e1feb11f64 100644 --- a/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs +++ b/src/Libraries/SmartStore.Services/Messages/Importer/NewsLetterSubscriptionImporter.cs @@ -21,6 +21,22 @@ public NewsLetterSubscriptionImporter( _subscriptionRepository = subscriptionRepository; } + public static string[] SupportedKeyFields + { + get + { + return new string[] { "Email" }; + } + } + + public static string[] DefaultKeyFields + { + get + { + return new string[] { "Email" }; + } + } + public void Execute(IImportExecuteContext context) { var utcNow = DateTime.UtcNow; @@ -72,9 +88,22 @@ public void Execute(IImportExecuteContext context) continue; } - var subscription = _subscriptionRepository.Table - .OrderBy(x => x.Id) - .FirstOrDefault(x => x.Email == email && x.StoreId == storeId); + NewsLetterSubscription subscription = null; + + foreach (var keyName in context.KeyFieldNames) + { + switch (keyName) + { + case "Email": + subscription = _subscriptionRepository.Table + .OrderBy(x => x.Id) + .FirstOrDefault(x => x.Email == email && x.StoreId == storeId); + break; + } + + if (subscription != null) + break; + } if (subscription == null) { diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs index e28ae3c1f6..417d9f2e96 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs @@ -11,10 +11,13 @@ using SmartStore.Core.Domain.DataExchange; using SmartStore.Core.IO; using SmartStore.Services; +using SmartStore.Services.Catalog.Importer; +using SmartStore.Services.Customers.Importer; using SmartStore.Services.DataExchange.Csv; using SmartStore.Services.DataExchange.Import; using SmartStore.Services.Helpers; using SmartStore.Services.Localization; +using SmartStore.Services.Messages.Importer; using SmartStore.Services.Security; using SmartStore.Services.Tasks; using SmartStore.Utilities; @@ -50,25 +53,110 @@ public ImportController( #region Utilities - private void PrepareColumnMappingModels(ImportProfile profile, ImportProfileModel model, CsvConfiguration csvConfiguration, ColumnMap invalidMap = null) + private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile, bool forEdit, ColumnMap invalidMap = null) { + if (profile == null) + { + if (model.Name.IsEmpty()) + { + var defaultNames = T("Admin.DataExchange.Import.DefaultProfileNames").Text.SplitSafe(";"); + + model.Name = defaultNames.SafeGet((int)model.EntityType); + } + + model.ExistingFileNames = new List(); + return; + } + + model.Id = profile.Id; + model.Name = profile.Name; + model.EntityType = profile.EntityType; + model.Enabled = profile.Enabled; + model.Skip = profile.Skip; + model.Take = profile.Take; + model.UpdateOnly = profile.UpdateOnly; + model.KeyFieldNames = profile.KeyFieldNames.SplitSafe(",").Distinct().ToList(); + model.ScheduleTaskId = profile.SchedulingTaskId; + model.ScheduleTaskName = profile.ScheduleTask.Name.NaIfEmpty(); + model.IsTaskRunning = profile.ScheduleTask.IsRunning; + model.IsTaskEnabled = profile.ScheduleTask.Enabled; + model.LogFileExists = System.IO.File.Exists(profile.GetImportLogPath()); + model.EntityTypeName = profile.EntityType.GetLocalizedEnum(_services.Localization, _services.WorkContext); + model.UnspecifiedString = T("Common.Unspecified"); + model.AddNewString = T("Common.AddNew"); + model.DeleteString = T("Common.Delete"); + model.IgnoreString = T("Admin.Common.Ignore"); + + model.ExistingFileNames = profile.GetImportFiles() + .Select(x => Path.GetFileName(x)) + .ToList(); + + if (!forEdit) + return; + + CsvConfiguration csvConfiguration = null; + + if (profile.FileType == ImportFileType.CSV) + { + var csvConverter = new CsvConfigurationConverter(); + csvConfiguration = csvConverter.ConvertFrom(profile.FileTypeConfiguration) ?? CsvConfiguration.ExcelFriendlyConfiguration; + + model.CsvConfiguration = new CsvConfigurationModel(csvConfiguration); + } + else + { + csvConfiguration = CsvConfiguration.ExcelFriendlyConfiguration; + } + + // column mapping model.AvailableSourceColumns = new List(); try { + string[] availableKeyFieldNames = null; var mapConverter = new ColumnMapConverter(); var storedMap = mapConverter.ConvertFrom(profile.ColumnMapping); var hasStoredMappings = (storedMap != null && storedMap.Mappings.Any()); var map = (invalidMap ?? storedMap) ?? new ColumnMap(); - + // property name to localized property name var allProperties = _importService.GetImportableEntityProperties(profile.EntityType); + switch (profile.EntityType) + { + case ImportEntityType.Product: + availableKeyFieldNames = ProductImporter.SupportedKeyFields; + break; + case ImportEntityType.Category: + availableKeyFieldNames = CategoryImporter.SupportedKeyFields; + break; + case ImportEntityType.Customer: + availableKeyFieldNames = CustomerImporter.SupportedKeyFields; + break; + case ImportEntityType.NewsLetterSubscription: + availableKeyFieldNames = NewsLetterSubscriptionImporter.SupportedKeyFields; + break; + } + model.AvailableEntityProperties = allProperties .Select(x => new SelectListItem { Value = x.Key, Text = x.Value }) .OrderBy(x => x.Text) .ToList(); + model.AvailableKeyFieldNames = availableKeyFieldNames + .Select(x => + { + var item = new SelectListItem { Value = x, Text = x }; + + if (x == "Id") + item.Text = T("Admin.Common.Entity.Fields.Id"); + else if (allProperties.ContainsKey(x)) + item.Text = allProperties[x]; + + return item; + }) + .ToList(); + model.ColumnMappings = map.Mappings .Select(x => { @@ -117,7 +205,7 @@ private void PrepareColumnMappingModels(ImportProfile profile, ImportProfileMode // auto map where field equals property name if (!hasStoredMappings && !model.ColumnMappings.Any(x => x.Column == column.Name) && allProperties.Any(x => x.Key == column.Name)) - { + { model.ColumnMappings.Add(new ColumnMappingItemModel { Column = column.Name, @@ -143,61 +231,6 @@ private void PrepareColumnMappingModels(ImportProfile profile, ImportProfileMode } } - private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile, bool forEdit, ColumnMap invalidMap = null) - { - if (profile != null) - { - model.Id = profile.Id; - model.Name = profile.Name; - model.EntityType = profile.EntityType; - model.Enabled = profile.Enabled; - model.Skip = profile.Skip; - model.Take = profile.Take; - model.UpdateOnly = profile.UpdateOnly; - model.KeyFieldNames = profile.KeyFieldNames.SplitSafe(","); - model.ScheduleTaskId = profile.SchedulingTaskId; - model.ScheduleTaskName = profile.ScheduleTask.Name.NaIfEmpty(); - model.IsTaskRunning = profile.ScheduleTask.IsRunning; - model.IsTaskEnabled = profile.ScheduleTask.Enabled; - model.LogFileExists = System.IO.File.Exists(profile.GetImportLogPath()); - model.EntityTypeName = profile.EntityType.GetLocalizedEnum(_services.Localization, _services.WorkContext); - model.UnspecifiedString = T("Common.Unspecified"); - model.AddNewString = T("Common.AddNew"); - model.DeleteString = T("Common.Delete"); - model.IgnoreString = T("Admin.Common.Ignore"); - - model.ExistingFileNames = profile.GetImportFiles() - .Select(x => Path.GetFileName(x)) - .ToList(); - - if (forEdit) - { - CsvConfiguration csvConfiguration = null; - - if (profile.FileType == ImportFileType.CSV) - { - var csvConverter = new CsvConfigurationConverter(); - csvConfiguration = csvConverter.ConvertFrom(profile.FileTypeConfiguration) ?? CsvConfiguration.ExcelFriendlyConfiguration; - - model.CsvConfiguration = new CsvConfigurationModel(csvConfiguration); - } - - PrepareColumnMappingModels(profile, model, csvConfiguration ?? CsvConfiguration.ExcelFriendlyConfiguration, invalidMap); - } - } - else - { - if (model.Name.IsEmpty()) - { - var defaultNames = T("Admin.DataExchange.Import.DefaultProfileNames").Text.SplitSafe(";"); - - model.Name = defaultNames.SafeGet((int)model.EntityType); - } - - model.ExistingFileNames = new List(); - } - } - #endregion public ActionResult Index() diff --git a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs index c385ed872f..a5750accd8 100644 --- a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs +++ b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs @@ -38,7 +38,7 @@ public partial class ImportProfileModel : EntityModelBase public bool UpdateOnly { get; set; } [SmartResourceDisplayName("Admin.DataExchange.Import.KeyFieldNames")] - public string[] KeyFieldNames { get; set; } + public List KeyFieldNames { get; set; } public List AvailableKeyFieldNames { get; set; } [SmartResourceDisplayName("Common.Execution")] @@ -74,10 +74,6 @@ public class ColumnMappingItemModel public string ColumnIndex { get; set; } public string ColumnLocalized { get; set; } - //public string LanguageDescription { get; set; } - //public string FlagImageFileName { get; set; } - - //public bool IsNilProperty { get; set; } public string Property { get; set; } public string Default { get; set; } } diff --git a/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs b/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs index 044d217456..92c271e19c 100644 --- a/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs +++ b/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs @@ -11,6 +11,10 @@ public ImportProfileValidator(ILocalizationService localization) RuleFor(x => x.Name) .NotEmpty() .WithMessage(localization.GetResource("Admin.Validation.Name")); + + RuleFor(x => x.KeyFieldNames) + .NotEmpty() + .WithMessage(localization.GetResource("Admin.DataExchange.Import.Validate.OneKeyFieldRequired")); } } } \ No newline at end of file diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml index 02ff000213..d25d0dd4a4 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/_ColumnMappings.cshtml @@ -114,67 +114,4 @@ } -
- - -@*
- - - - - - - - - - - @foreach (var mapping in Model.ColumnMappings.OrderBy(x => x.ColumnWithoutIndex)) - { - - - - - - - } - -
@T("Admin.DataExchange.ColumnMapping.ImportField")@T("Common.Language")@T("Admin.DataExchange.ColumnMapping.EntityProperty")@T("Admin.DataExchange.ColumnMapping.DefaultValue")
- @if (mapping.ColumnLocalized.HasValue()) - { -
@mapping.ColumnLocalized
- } -
@mapping.Column
-
- @if (mapping.ColumnIndex.HasValue()) - { - if (mapping.LanguageDescription.HasValue()) - { - if (mapping.FlagImageFileName.HasValue()) - { - Icon - } - @mapping.LanguageDescription - } - else - { - @T("Common.Unknown") - } - } - - -
- @Html.ValidationMessage("ColumnMapping.Property." + mapping.Index.ToString()) -
- -
-
*@ +
\ No newline at end of file diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml index d8ce552221..31534c8da5 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/_CreateOrUpdate.cshtml @@ -118,6 +118,17 @@ else if (Model.ExistingFileNames.Count > 1) @if (Model.Id != 0) { + + + @Html.SmartLabelFor(model => model.KeyFieldNames) + + + @Html.ListBoxFor(model => model.KeyFieldNames, + new MultiSelectList(Model.AvailableKeyFieldNames, "Value", "Text"), + new { multiple = "multiple", @class = "control-large" }) + @Html.ValidationMessageFor(model => model.KeyFieldNames) + + @Html.SmartLabelFor(x => x.Skip) @@ -244,7 +255,7 @@ else if (Model.ExistingFileNames.Count > 1) row.find('.mapping-button-add').toggle(hasProperty); } - row.find('.mapping-control-default').prop('disabled', !(hasProperty && hasColumn)); + row.find('.mapping-control-default').prop('disabled', !(hasProperty && hasColumn)); }).on('click', '.mapping-button-add', function () { var row = $(this).closest('tr'), table = row.closest('table'), @@ -265,7 +276,7 @@ else if (Model.ExistingFileNames.Count > 1) $(this).closest('tr').remove(); }); - + initSelectBoxes($('#ImportColumnMappings')); appendNewMappingRow(); From 7fcd9fdbe195121198202c18a9ceaddd079058f4 Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Thu, 28 Jan 2016 18:55:58 +0100 Subject: [PATCH 016/453] Minor change --- .../SmartStore.PayPal/Localization/resources.de-de.xml | 8 ++++---- .../SmartStore.PayPal/Localization/resources.en-us.xml | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/Plugins/SmartStore.PayPal/Localization/resources.de-de.xml b/src/Plugins/SmartStore.PayPal/Localization/resources.de-de.xml index ba2d95cd8d..cca8f0f461 100644 --- a/src/Plugins/SmartStore.PayPal/Localization/resources.de-de.xml +++ b/src/Plugins/SmartStore.PayPal/Localization/resources.de-de.xml @@ -80,7 +80,7 @@
  • Auf den Register Mein Profil klicken.
  • Sofortige Zahlungsbestätigung klicken.
  • Einstellungen für sofortige Zahlungsbestätigungen wählen klicken.
  • -
  • Bei Benachrichtigungs-URL die URL Ihres IPN-Handlers (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalExpress/IPNHandler) eingeben.
  • +
  • Bei Benachrichtigungs-URL die URL Ihres IPN-Handlers (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalExpress/IPNHandler) eingeben.
  • Speichern klicken. Danach sollten Sie eine Nachricht über die erfolgreiche Aktivierung von IPN erhalten.
  • ]]> @@ -175,7 +175,7 @@
  • Auf den Register Mein Profil klicken.
  • Sofortige Zahlungsbestätigung klicken.
  • Einstellungen für sofortige Zahlungsbestätigungen wählen klicken.
  • -
  • Bei Benachrichtigungs-URL die URL Ihres IPN-Handlers (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalDirect/IPNHandler) eingeben.
  • +
  • Bei Benachrichtigungs-URL die URL Ihres IPN-Handlers (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalDirect/IPNHandler) eingeben.
  • Speichern klicken. Danach sollten Sie eine Nachricht über die erfolgreiche Aktivierung von IPN erhalten.
  • ]]> @@ -227,7 +227,7 @@
  • Klicken Sie auf den Register Mein Profil.
  • Klicken Sie unter Verkäufer/Händler auf Website-Einstellungen.
  • Aktivieren Sie Automatische Rückleitung.
  • -
  • Als Rückleitungs-URL geben Sie bitte die Seite Ihres Shops ein, die die Transaktions-ID von PayPal nach einer Kundenzahlung empfängt (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/PDTHandler).
  • +
  • Als Rückleitungs-URL geben Sie bitte die Seite Ihres Shops ein, die die Transaktions-ID von PayPal nach einer Kundenzahlung empfängt (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/PDTHandler).
  • Aktivieren Sie Übertragung der Zahlungsdaten.
  • Klicken Sie auf Speichern.
  • Klicken Sie unter Verkäufer/Händler auf Website-Einstellungen.
  • @@ -243,7 +243,7 @@
  • Auf den Register Mein Profil klicken.
  • Sofortige Zahlungsbestätigung klicken.
  • Einstellungen für sofortige Zahlungsbestätigungen wählen klicken.
  • -
  • Bei Benachrichtigungs-URL die URL Ihres IPN-Handlers (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/IPNHandler) eingeben.
  • +
  • Bei Benachrichtigungs-URL die URL Ihres IPN-Handlers (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/IPNHandler) eingeben.
  • Speichern klicken. Danach sollten Sie eine Nachricht über die erfolgreiche Aktivierung von IPN erhalten.
  • diff --git a/src/Plugins/SmartStore.PayPal/Localization/resources.en-us.xml b/src/Plugins/SmartStore.PayPal/Localization/resources.en-us.xml index a0143309c7..b71c907dcc 100644 --- a/src/Plugins/SmartStore.PayPal/Localization/resources.en-us.xml +++ b/src/Plugins/SmartStore.PayPal/Localization/resources.en-us.xml @@ -30,7 +30,7 @@
  • Click the Profile subtab.
  • Click Instant Payment Notification in the Selling Preferences column.
  • Click the Edit IPN Settings button to update your settings.
  • -
  • Select Receive IPN messages (enabled) and enter the URL of your IPN handler (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalExpress/IPNHandler).
  • +
  • Select Receive IPN messages (enabled) and enter the URL of your IPN handler (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalExpress/IPNHandler).
  • Click Save, and you should get a message that you have successfully activated IPN.
  • ]]> @@ -167,7 +167,7 @@
  • Click the Profile subtab.
  • Click Instant Payment Notification in the Selling Preferences column.
  • Click the Edit IPN Settings button to update your settings.
  • -
  • Select Receive IPN messages (enabled) and enter the URL of your IPN handler (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalDirect/IPNHandler).
  • +
  • Select Receive IPN messages (enabled) and enter the URL of your IPN handler (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalDirect/IPNHandler).
  • Click Save, and you should get a message that you have successfully activated IPN.
  • ]]> @@ -260,7 +260,7 @@
  • Click the Profile subtab.
  • Click Website Payment Preferences in the Seller Preferences column.
  • Under Auto Return for Website Payments, click the On radio button.
  • -
  • For the Return URL, enter the URL on your site that will receive the transaction ID posted by PayPal after a customer payment (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/PDTHandler).
  • +
  • For the Return URL, enter the URL on your site that will receive the transaction ID posted by PayPal after a customer payment (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/PDTHandler).
  • Under Payment Data Transfer, click the On radio button.
  • Click Save.
  • Click Website Payment Preferences in the Seller Preferences column.
  • @@ -276,7 +276,7 @@
  • Click the Profile subtab.
  • Click Instant Payment Notification in the Selling Preferences column.
  • Click the Edit IPN Settings button to update your settings.
  • -
  • Select Receive IPN messages (Enabled) and enter the URL of your IPN handler (http://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/IPNHandler).
  • +
  • Select Receive IPN messages (Enabled) and enter the URL of your IPN handler (https://www.yourStore.com/Plugins/SmartStore.PayPal/PayPalStandard/IPNHandler).
  • Click Save, and you should get a message that you have successfully activated IPN.
  • From 8fdacb3e6ae127762caf673070ff8a7cc3c6a6b9 Mon Sep 17 00:00:00 2001 From: Marcus Gesing Date: Fri, 29 Jan 2016 11:41:22 +0100 Subject: [PATCH 017/453] Testing import --- .../Controllers/ImportController.cs | 7 ++- .../Models/DataExchange/ImportProfileModel.cs | 2 +- .../DataExchange/ImportProfileValidator.cs | 1 + .../Administration/Views/Import/Create.cshtml | 2 +- .../Administration/Views/Import/List.cshtml | 61 +++++++++---------- 5 files changed, 35 insertions(+), 38 deletions(-) diff --git a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs index 417d9f2e96..cf38ff8b83 100644 --- a/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs +++ b/src/Presentation/SmartStore.Web/Administration/Controllers/ImportController.cs @@ -75,7 +75,7 @@ private void PrepareProfileModel(ImportProfileModel model, ImportProfile profile model.Skip = profile.Skip; model.Take = profile.Take; model.UpdateOnly = profile.UpdateOnly; - model.KeyFieldNames = profile.KeyFieldNames.SplitSafe(",").Distinct().ToList(); + model.KeyFieldNames = profile.KeyFieldNames.SplitSafe(",").Distinct().ToArray(); model.ScheduleTaskId = profile.SchedulingTaskId; model.ScheduleTaskName = profile.ScheduleTask.Name.NaIfEmpty(); model.IsTaskRunning = profile.ScheduleTask.IsRunning; @@ -290,7 +290,8 @@ public ActionResult ProfileListDetails(int profileId) return new EmptyResult(); } - public ActionResult Create(ImportEntityType entityType) + [HttpPost] + public ActionResult CreateUploadFile(ImportEntityType entityType) { if (!_services.Permissions.Authorize(StandardPermissionProvider.ManageImports)) return AccessDeniedView(); @@ -302,7 +303,7 @@ public ActionResult Create(ImportEntityType entityType) PrepareProfileModel(model, null, true); - return View(model); + return View("Create", model); } [HttpPost, ParameterBasedOnFormName("save-continue", "continueEditing"), FormValueRequired("save", "save-continue")] diff --git a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs index a5750accd8..49e8225de1 100644 --- a/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs +++ b/src/Presentation/SmartStore.Web/Administration/Models/DataExchange/ImportProfileModel.cs @@ -38,7 +38,7 @@ public partial class ImportProfileModel : EntityModelBase public bool UpdateOnly { get; set; } [SmartResourceDisplayName("Admin.DataExchange.Import.KeyFieldNames")] - public List KeyFieldNames { get; set; } + public string[] KeyFieldNames { get; set; } public List AvailableKeyFieldNames { get; set; } [SmartResourceDisplayName("Common.Execution")] diff --git a/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs b/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs index 92c271e19c..15fa25f6f6 100644 --- a/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs +++ b/src/Presentation/SmartStore.Web/Administration/Validators/DataExchange/ImportProfileValidator.cs @@ -14,6 +14,7 @@ public ImportProfileValidator(ILocalizationService localization) RuleFor(x => x.KeyFieldNames) .NotEmpty() + .When(x => x.Id != 0) .WithMessage(localization.GetResource("Admin.DataExchange.Import.Validate.OneKeyFieldRequired")); } } diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml index 90e616e0b8..08760e6e43 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/Create.cshtml @@ -5,7 +5,7 @@ ViewBag.Title = title; } -@using (Html.BeginForm()) +@using (Html.BeginForm("Create", "Import", new { area = "Admin" })) {
    diff --git a/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml b/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml index fbc6f67f06..ead4f798e5 100644 --- a/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml +++ b/src/Presentation/SmartStore.Web/Administration/Views/Import/List.cshtml @@ -107,35 +107,37 @@ else
    } -