Nearly got custom importer working

InABox.Core/CoreTable/CoreTable.cs

@@ -73,92 +73,6 @@ namespace InABox.Core
             return result;
         }
 
-        /*
-        private void OnRowsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-        {
-            switch (e.Action)
-            {
-                case NotifyCollectionChangedAction.Add:
-                    this.InternalView.Insert(e.NewStartingIndex, ((DataRow)e.NewItems[0]).RowObject);
-                    break;
-                case NotifyCollectionChangedAction.Remove:
-                    this.InternalView.RemoveAt(e.OldStartingIndex);
-                    break;
-                case NotifyCollectionChangedAction.Replace:
-                    this.InternalView.Remove(((DataRow)e.OldItems[0]).RowObject);
-                    this.InternalView.Insert(e.NewStartingIndex, ((DataRow)e.NewItems[0]).RowObject);
-                    break;
-                case NotifyCollectionChangedAction.Reset:
-                default:
-                    this.InternalView.Clear();
-                    this.Rows.Select(r => r.RowObject).ToList().ForEach(o => this.InternalView.Add(o));
-                    break;
-            }
-        }
-        
-        private IList InternalView
-        {
-            get
-            {
-                if (this.internalView == null)
-                {
-                    this.CreateInternalView();
-                }
-
-                return this.internalView;
-            }
-        }
-
-        private void CreateInternalView()
-        {
-            this.internalView = (IList)Activator.CreateInstance(typeof(ObservableCollection<>).MakeGenericType(this.ElementType));
-            ((INotifyCollectionChanged)internalView).CollectionChanged += (s, e) => { this.OnCollectionChanged(e); };
-        }
-
-        internal Type ElementType
-        {
-            get
-            {
-                if (this.elementType == null)
-                {
-                    this.InitializeElementType();
-                }
-
-                return this.elementType;
-            }
-        }
-
-        private void InitializeElementType()
-        {
-            this.Seal();
-            this.elementType = DynamicObjectBuilder.GetDynamicObjectBuilderType(this.Columns);
-        }
-
-        private void Seal()
-        {
-            this.columns = new ReadOnlyCollection<DataColumn>(this.Columns);
-        }
-
-        public IEnumerator GetEnumerator()
-        {
-            return this.InternalView.GetEnumerator();
-        }
-
-        public IList ToList()
-        {
-            return this.InternalView;
-        }
-
-        protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
-        {
-            var handler = this.CollectionChanged;
-            if (handler != null)
-            {
-                handler(this, e);
-            }
-        }
-        */
-
         public void LoadColumns(Type T)
         {
             var iprops = DatabaseSchema.Properties(T);

InABox.Core/Editors/BaseCodeEditor.cs

@@ -13,6 +13,6 @@
 
         public string ValidChars { get; set; }
 
-        public EditorButton[] Buttons { get; set; }
+        public EditorButton[]? Buttons { get; set; }
     }
 }

InABox.Core/Entity.cs

@@ -231,14 +231,14 @@ namespace InABox.Core
         }
 
 
-        protected override void SetChanged(string name, object before, object after)
+        protected override void SetChanged(string name, object? before, object? after)
         {
             base.SetChanged(name, before, after);
 
             CheckTax(name, before, after);
         }
         
-        private void CheckTax(string name, object before, object after)
+        private void CheckTax(string name, object? before, object? after)
         {
             if (this is ITaxable)
             {

InABox.Core/Filter.cs

@@ -535,7 +535,7 @@ namespace InABox.Core
             return Parent ?? this;
         }
 
-        private Filter<T> ApplyObjectOperator(Operator action, object value)
+        private Filter<T> ApplyObjectOperator(Operator action, object? value)
         {
             Operator = action;
             Value = value;
@@ -664,8 +664,8 @@ namespace InABox.Core
             where TEnum : struct 
             => IsEqualTo<TEnum>(value);
         
-        public Filter<T> IsEqualTo(object value) => ApplyObjectOperator(Operator.IsEqualTo, value);
-        IFilter IFilter.IsEqualTo(object value) => IsEqualTo(value);
+        public Filter<T> IsEqualTo(object? value) => ApplyObjectOperator(Operator.IsEqualTo, value);
+        IFilter IFilter.IsEqualTo(object? value) => IsEqualTo(value);
 
         #endregion
 

InABox.Core/Imports/BaseImporter.cs

@@ -4,6 +4,7 @@ using System.ComponentModel;
 using System.IO;
 using System.Linq;
 using InABox.Clients;
+using Newtonsoft.Json.Linq;
 
 namespace InABox.Core
 {
@@ -145,7 +146,16 @@ namespace InABox.Core
 
                 var item = new T();
                 Notify(string.Format("Parsing Row {0}", iRow));
-                var values = ReadLine();
+                Dictionary<string, string> values;
+                try
+                {
+                    values = ReadLine();
+                }
+                catch(Exception e)
+                {
+                    WriteError(iRow, $"Error reading line: {e.Message}");
+                    continue;
+                }
 
                 var bUpdatesOK = BeforeProcess != null ? BeforeProcess.Invoke(this, values) : true;
                 try
@@ -194,130 +204,131 @@ namespace InABox.Core
                     bUpdatesOK = false;
                     WriteError(iRow, string.Format("Unable to Update Values: {0}", e.Message));
                 }
-
-                if (bUpdatesOK)
+                if (!bUpdatesOK)
                 {
-                    var bLookupsOK = true;
+                    continue;
+                }
 
-                    if (keylookup != null)
-                    {
-                        try
-                        {
-                            var keyrows = keylookup.Results.Rows.ToList();
-                            foreach (var mapping in Mappings.Where(x => x.Key))
-                            {
-                                var keyvalue = CoreUtils.GetPropertyValue(item, mapping.Property);
-                                keyrows = keyrows.Where(r => string.Equals(r.Get<string>(mapping.Property)?.Trim(), keyvalue?.ToString().Trim()))
-                                    .ToList();
-                            }
+                var bLookupsOK = true;
 
-                            var keyid = keyrows.Any() ? keyrows.First().Get<Guid>("ID") : Guid.Empty;
-                            CoreUtils.SetPropertyValue(item, "ID", keyid);
-                        }
-                        catch (Exception e)
+                if (keylookup != null)
+                {
+                    try
+                    {
+                        var keyrows = keylookup.Results.Rows.ToList();
+                        foreach (var mapping in Mappings.Where(x => x.Key))
                         {
-                            bLookupsOK = false;
-                            WriteError(iRow, string.Format("Unable to set Primary Key: {0}", e.Message));
+                            var keyvalue = CoreUtils.GetPropertyValue(item, mapping.Property);
+                            keyrows = keyrows.Where(r => string.Equals(r.Get<string>(mapping.Property)?.Trim(), keyvalue?.ToString().Trim()))
+                                .ToList();
                         }
+
+                        var keyid = keyrows.Any() ? keyrows.First().Get<Guid>("ID") : Guid.Empty;
+                        CoreUtils.SetPropertyValue(item, "ID", keyid);
                     }
-                    else
+                    catch (Exception e)
                     {
-                        CoreUtils.SetPropertyValue(item, "ID", Guid.Empty);
+                        bLookupsOK = false;
+                        WriteError(iRow, string.Format("Unable to set Primary Key: {0}", e.Message));
                     }
+                }
+                else
+                {
+                    CoreUtils.SetPropertyValue(item, "ID", Guid.Empty);
+                }
 
-                    try
+                try
+                {
+                    foreach (var mapping in Mappings.Where(x => x.Lookup != ImportLookupType.None))
                     {
-                        foreach (var mapping in Mappings.Where(x => x.Lookup != ImportLookupType.None))
+                        var parentprop = string.Join(".", mapping.Property.Split('.').Reverse().Skip(1).Reverse());
+                        var parent = CoreUtils.GetProperty(typeof(T), parentprop);
+                        var childprop = mapping.Property.Split('.').Last();
+                        var bt = parent.PropertyType.BaseType;
+                        if (bt != null)
                         {
-                            var parentprop = string.Join(".", mapping.Property.Split('.').Reverse().Skip(1).Reverse());
-                            var parent = CoreUtils.GetProperty(typeof(T), parentprop);
-                            var childprop = mapping.Property.Split('.').Last();
-                            var bt = parent.PropertyType.BaseType;
-                            if (bt != null)
-                            {
-                                var lookuptype = bt.GetGenericArguments().FirstOrDefault();
+                            var lookuptype = bt.GetGenericArguments().FirstOrDefault();
 
-                                var lookup = lookups.FirstOrDefault(x => x.Type.Equals(lookuptype));
+                            var lookup = lookups.FirstOrDefault(x => x.Type.Equals(lookuptype));
 
-                                IEnumerable<CoreRow> lookuprows = lookup.Results.Rows;
-                                var lookupvalue = CoreUtils.GetPropertyValue(item, mapping.Property) as string;
-                                if (!string.IsNullOrWhiteSpace(lookupvalue))
+                            IEnumerable<CoreRow> lookuprows = lookup.Results.Rows;
+                            var lookupvalue = CoreUtils.GetPropertyValue(item, mapping.Property) as string;
+                            if (!string.IsNullOrWhiteSpace(lookupvalue))
+                            {
+                                lookuprows = lookuprows.Where(r => r.Get<string>(childprop).Equals(lookupvalue));
+                                var lookupid = lookuprows.Any() ? lookuprows.First().Get<Guid>("ID") : Guid.Empty;
+                                if (lookupid == Guid.Empty)
                                 {
-                                    lookuprows = lookuprows.Where(r => r.Get<string>(childprop).Equals(lookupvalue));
-                                    var lookupid = lookuprows.Any() ? lookuprows.First().Get<Guid>("ID") : Guid.Empty;
-                                    if (lookupid == Guid.Empty)
+                                    if (mapping.Lookup == ImportLookupType.Restrict)
                                     {
-                                        if (mapping.Lookup == ImportLookupType.Restrict)
-                                        {
-                                            bLookupsOK = false;
-                                            WriteError(iRow, string.Format("Lookup Value [{0}] not found", lookupvalue));
-                                        }
-                                        else if (mapping.Lookup == ImportLookupType.Create)
-                                        {
-                                            var newlookup = Activator.CreateInstance(lookuptype);
-                                            CoreUtils.SetPropertyValue(newlookup, childprop, lookupvalue);
-                                            ClientFactory.CreateClient(lookuptype).Save(newlookup, "Created by Import");
-                                            lookupid = (Guid?)CoreUtils.GetPropertyValue(newlookup, "ID") ?? Guid.Empty;
-                                            var newrow = lookup.Results.NewRow();
-                                            lookup.Results.LoadRow(newrow, newlookup);
-                                            lookup.Results.Rows.Add(newrow);
-                                            CoreUtils.SetPropertyValue(item, lookup.ID, lookupid);
-                                            var prefix = String.Join(".", lookup.ID.Split('.').Reverse().Skip(1).Reverse());
-                                            foreach (var field in lookup.Fields)
-                                                CoreUtils.SetPropertyValue(item, String.Join(".", new String[] { prefix, field }), newrow[field]);
-
-                                        }
+                                        bLookupsOK = false;
+                                        WriteError(iRow, string.Format("Lookup Value [{0}] not found", lookupvalue));
                                     }
-                                    else
+                                    else if (mapping.Lookup == ImportLookupType.Create)
                                     {
+                                        var newlookup = Activator.CreateInstance(lookuptype);
+                                        CoreUtils.SetPropertyValue(newlookup, childprop, lookupvalue);
+                                        ClientFactory.CreateClient(lookuptype).Save(newlookup, "Created by Import");
+                                        lookupid = (Guid?)CoreUtils.GetPropertyValue(newlookup, "ID") ?? Guid.Empty;
+                                        var newrow = lookup.Results.NewRow();
+                                        lookup.Results.LoadRow(newrow, newlookup);
+                                        lookup.Results.Rows.Add(newrow);
                                         CoreUtils.SetPropertyValue(item, lookup.ID, lookupid);
                                         var prefix = String.Join(".", lookup.ID.Split('.').Reverse().Skip(1).Reverse());
                                         foreach (var field in lookup.Fields)
-                                            CoreUtils.SetPropertyValue(item, String.Join(".", new String[] { prefix, field }), lookuprows.First()[field]);
+                                            CoreUtils.SetPropertyValue(item, String.Join(".", new String[] { prefix, field }), newrow[field]);
+
                                     }
                                 }
+                                else
+                                {
+                                    CoreUtils.SetPropertyValue(item, lookup.ID, lookupid);
+                                    var prefix = String.Join(".", lookup.ID.Split('.').Reverse().Skip(1).Reverse());
+                                    foreach (var field in lookup.Fields)
+                                        CoreUtils.SetPropertyValue(item, String.Join(".", new String[] { prefix, field }), lookuprows.First()[field]);
+                                }
                             }
                         }
                     }
-                    catch (Exception e)
-                    {
-                        bLookupsOK = false;
-                        WriteError(iRow, string.Format("Exception setting lookup values: {0}", e.Message));
-                    }
-
-                    if (bLookupsOK)
-                    {
-                        var bOK = AfterProcess != null ? AfterProcess.Invoke(this, item, values) : true;
-
-                        if (bOK && item.IsChanged())
-                            try
-                            {
-                                var bNewKey = keylookup != null && item.ID == Guid.Empty;
+                }
+                catch (Exception e)
+                {
+                    bLookupsOK = false;
+                    WriteError(iRow, string.Format("Exception setting lookup values: {0}", e.Message));
+                }
 
-                                if (OnSave != null)
-                                    OnSave?.Invoke(this, item);
-                                else
-                                    new Client<T>().Save(item, "");
+                if (bLookupsOK)
+                {
+                    var bOK = AfterProcess != null ? AfterProcess.Invoke(this, item, values) : true;
 
-                                if (bNewKey)
-                                {
-                                    var row = keylookup!.Results.NewRow();
-                                    keylookup.Results.LoadRow(row, item);
-                                    keylookup.Results.Rows.Add(row);
-                                }
+                    if (bOK && item.IsChanged())
+                        try
+                        {
+                            var bNewKey = keylookup != null && item.ID == Guid.Empty;
 
-                                var key = new List<object?>();
-                                foreach (var mapping in Mappings.Where(x => x.Key))
-                                    key.Add(CoreUtils.GetPropertyValue(item, mapping.Property));
-                                WriteLog(iRow, string.Format("Successfully Imported [{0}]", string.Join(" + ", key)));
+                            if (OnSave != null)
+                                OnSave?.Invoke(this, item);
+                            else
+                                new Client<T>().Save(item, "");
 
-                                iResult++;
-                            }
-                            catch (Exception e)
+                            if (bNewKey)
                             {
-                                WriteError(iRow, string.Format("Unable to Save Item: {0}", e.Message));
+                                var row = keylookup!.Results.NewRow();
+                                keylookup.Results.LoadRow(row, item);
+                                keylookup.Results.Rows.Add(row);
                             }
-                    }
+
+                            var key = new List<object?>();
+                            foreach (var mapping in Mappings.Where(x => x.Key))
+                                key.Add(CoreUtils.GetPropertyValue(item, mapping.Property));
+                            WriteLog(iRow, string.Format("Successfully Imported [{0}]", string.Join(" + ", key)));
+
+                            iResult++;
+                        }
+                        catch (Exception e)
+                        {
+                            WriteError(iRow, string.Format("Unable to Save Item: {0}", e.Message));
+                        }
                 }
             }
 

InABox.Core/Imports/ImportFactory.cs

@@ -118,7 +118,7 @@ namespace InABox.Core
         public static IImporter Create(ImportDefinition definition, Type type)
         {
             var importer = definition.Type.MakeGenericType(type);
-            var result = Activator.CreateInstance(importer) as IImporter;
+            var result = (Activator.CreateInstance(importer) as IImporter)!;
             return result;
         }
 

InABox.Core/Imports/Importer.cs

@@ -48,5 +48,8 @@ namespace InABox.Core
 
         [NullEditor]
         public string Script { get; set; }
+
+        [NullEditor]
+        public string? Settings { get; set; }
     }
 }

InABox.Core/Imports/SettingsImporter.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace InABox.Core
+{
+    public interface ISettingsImporter
+    {
+        Type SettingsType { get; }
+
+        void SetSettings(object settings);
+    }
+
+    public interface ISettingsImporter<TSettings> : ISettingsImporter
+        where TSettings : BaseObject, new()
+    {
+    }
+
+    public abstract class SettingsImporter<T, TSettings> : BaseImporter<T>, ISettingsImporter<TSettings>
+        where T : Entity, IRemotable, IPersistent, new()
+        where TSettings : BaseObject, new()
+    {
+        public TSettings Settings { get; set; } = new TSettings();
+
+        public Type SettingsType => typeof(TSettings);
+
+        public void SetSettings(object settings)
+        {
+            if(settings is TSettings tSettings)
+            {
+                Settings = tSettings;
+            }
+            else
+            {
+                throw new Exception($"{settings} is not a {typeof(TSettings)}");
+            }
+        }
+    }
+}

inabox.scripting/ScriptDocument.cs

@@ -275,7 +275,7 @@ namespace InABox.Scripting
             return CSharpObjectFormatter.Instance.FormatObject(o, PrintOptions);
         }
 
-        protected bool SetProperty<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
+        protected bool SetProperty<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
         {
             if (!EqualityComparer<T>.Default.Equals(field, value))
             {
@@ -288,7 +288,7 @@ namespace InABox.Scripting
             return false;
         }
 
-        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
         {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
         }

inabox.wpf/DigitalForms/DigitalFormGrid.cs

@@ -180,7 +180,7 @@ namespace InABox.DynamicGrid
             return false;
         }
 
-        private BitmapImage ReportImage(CoreRow arg)
+        private BitmapImage? ReportImage(CoreRow arg)
         {
             return arg != null ? Wpf.Resources.printer.AsBitmapImage() : null;
         }
@@ -271,7 +271,7 @@ namespace InABox.DynamicGrid
             return pages;
         }
 
-        public override bool EditItems(DigitalForm[] items, Func<Type, CoreTable>? PageDataHandler = null, bool PreloadPages = false)
+        public override bool EditItems(DigitalForm[] items, Func<Type, CoreTable?>? PageDataHandler = null, bool PreloadPages = false)
         {
             // Need to do this to make sure that the variables are available to the layouts (and vice versa?)
             return base.EditItems(items, PageDataHandler, true);
@@ -318,7 +318,7 @@ namespace InABox.DynamicGrid
                     new Client<DigitalForm>().Save(form, $"Imported from {dialog.FileName}");
 
                     progress.Report("Importing Data");
-                    DFLayout data = null;
+                    DFLayout data;
                     var variables = new List<DigitalFormVariable>();
                     
                     var layout = new DigitalFormLayout();

inabox.wpf/DigitalForms/DigitalFormUtils.cs

@@ -460,8 +460,7 @@ namespace InABox.DynamicGrid
             float startotal = 0F;
             for (int iStar = 0; iStar < values.Count; iStar++)
             {
-                float fstartotal = 0F;
-                if (values[iStar].Contains("*"))
+                if (values[iStar].Contains('*'))
                 {
                     if (!float.TryParse(values[iStar].Replace("*", ""), out float value))
                         value += 1;

inabox.wpf/DynamicGrid/DynamicImportForm.xaml

@@ -22,6 +22,11 @@
             <ComboBox x:Name="Type" DockPanel.Dock="Left" Width="200" DisplayMemberPath="Description"
                       SelectedValuePath="{Binding}" SelectionChanged="Type_SelectionChanged"
                       VerticalContentAlignment="Center" Margin="5,0,5,0" />
+            <Button x:Name="TypeSettings"
+                    Content="Settings"
+                    IsEnabled="False"
+                    Click="TypeSettings_Click"
+                    DockPanel.Dock="Right" Padding="10,0,10,0" Margin="5,0,0,0"/>
             <Label Content=" " DockPanel.Dock="Left" />
         </DockPanel>
 

inabox.wpf/DynamicGrid/DynamicImportForm.xaml.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Forms.Design;
+using FastReport.Editor.Syntax;
 using InABox.Core;
 using InABox.Wpf;
 using Microsoft.Win32;
@@ -90,12 +91,26 @@ namespace InABox.DynamicGrid
 
         private void OpenFile(string filename)
         {
-            var definition = Type.SelectedValue as ImportDefinition;
+            if(Type.SelectedValue is not ImportDefinition definition)
+            {
+                return;
+            }
 
             var importer = ImportFactory.Create(definition, _entitytype);
 
             if (importer is IFixedWidthImporter)
                 ((IFixedWidthImporter)importer).ColumnWidths = ExtractColumnWidths();
+            if (importer is ISettingsImporter settingsImporter)
+            {
+                if (!_importer.Settings.IsNullOrWhiteSpace())
+                {
+                    var settings = Serialization.Deserialize(settingsImporter.SettingsType, _importer.Settings);
+                    if (settings is not null)
+                    {
+                        settingsImporter.SetSettings(settings);
+                    }
+                }
+            }
 
             importer.HeaderRow = _importer.HeaderRows;
             try
@@ -162,6 +177,41 @@ namespace InABox.DynamicGrid
             CheckOKButton();
         }
 
+        private void OpenTypeSettings()
+        {
+            if(Type.SelectedValue is not ImportDefinition definition)
+            {
+                return;
+            }
+
+            var tSettings = definition.Type.GetInterfaceDefinition(typeof(ISettingsImporter<>))?.GenericTypeArguments[0];
+            if(tSettings is null)
+            {
+                return;
+            }
+
+            object? settings = null;
+            if (!_importer.Settings.IsNullOrWhiteSpace())
+            {
+                settings = Serialization.Deserialize(tSettings, _importer.Settings);
+            }
+            settings ??= Activator.CreateInstance(tSettings)!;
+
+            var grid = DynamicGridUtils.CreateDynamicGrid(typeof(DynamicGrid<>), tSettings);
+            if(grid.EditItems(new object[] { settings }))
+            {
+                _importer.Settings = Serialization.Serialize(settings);
+            }
+        }
+
+        private void TypeSettings_Click(object sender, RoutedEventArgs e)
+        {
+            OpenTypeSettings();
+
+            if (File.Exists(FileName.Text))
+                OpenFile(FileName.Text);
+        }
+
         private void Type_SelectionChanged(object sender, SelectionChangedEventArgs e)
         {
             if (!bLoading)
@@ -173,8 +223,22 @@ namespace InABox.DynamicGrid
             ColumnWidths.Visibility = _importdefinition != null && _importdefinition.Type == typeof(FixedWidthImporter<>)
                 ? Visibility.Visible
                 : Visibility.Hidden;
-            if (File.Exists(FileName.Text) && Type.SelectedValue as ImportDefinition != null)
-                OpenFile(FileName.Text);
+
+            TypeSettings.IsEnabled = false;
+            if (Type.SelectedValue is ImportDefinition definition)
+            {
+                if (definition.Type.HasInterface<ISettingsImporter>())
+                {
+                    TypeSettings.IsEnabled = true;
+                    if (!bLoading)
+                    {
+                        OpenTypeSettings();
+                    }
+                }
+
+                if (File.Exists(FileName.Text))
+                    OpenFile(FileName.Text);
+            }
             CheckOKButton();
         }
 

inabox.wpf/DynamicGrid/DynamicImportGrid.cs

@@ -59,6 +59,7 @@ namespace InABox.DynamicGrid
             HiddenColumns.Add(x => x.HeaderRows);
             HiddenColumns.Add(x => x.ColumnWidths);
             HiddenColumns.Add(x => x.Script);
+            HiddenColumns.Add(x => x.Settings);
         }
 
         protected override void DoReconfigure(FluentList<DynamicGridOption> options)
@@ -109,7 +110,7 @@ namespace InABox.DynamicGrid
             [NotNullWhen(true)]
             ref string? filename,
             [NotNullWhen(true)]
-            out IImporter iimporter,
+            out IImporter? iimporter,
             Action<CustomiseImportArgs>? customiseImport = null,
             Func<object, bool>? onImport = null)
         {
@@ -176,6 +177,17 @@ namespace InABox.DynamicGrid
                 iimporter = ImportFactory.Create(definition, entityType);
                 if (iimporter is IFixedWidthImporter fixedImporter)
                     fixedImporter.ColumnWidths = ExtractColumnWidths(importer.ColumnWidths);
+                if(iimporter is ISettingsImporter settingsImporter)
+                {
+                    if (!importer.Settings.IsNullOrWhiteSpace())
+                    {
+                        var settings = Serialization.Deserialize(settingsImporter.SettingsType, importer.Settings);
+                        if(settings is not null)
+                        {
+                            settingsImporter.SetSettings(settings);
+                        }
+                    }
+                }
 
                 iimporter.HasHeader = importer.HasHeader;
                 iimporter.HeaderRow = Math.Max(1, importer.HeaderRows);
@@ -196,8 +208,8 @@ namespace InABox.DynamicGrid
                     return bOK;
                 };
 
-                var settings = importer.Definition;
-                var mappings = Serialization.Deserialize<List<ImportMapping>>(settings);
+                var mappingDefinitions = importer.Definition;
+                var mappings = Serialization.Deserialize<List<ImportMapping>>(mappingDefinitions);
                 iimporter.Mappings.AddRange(mappings);
                 return true;
             }