Added Custom Properties to avilable Import Field Mappings

InABox.Core/Imports/BaseImporter.cs

@@ -150,14 +150,15 @@ namespace InABox.Core
                     foreach (var property in values.Keys)
                     {
                         var value = values[property];
-                        var prop = CoreUtils.GetProperty(typeof(T), property);
-                        var type = prop.PropertyType;
+                        var p2 = DatabaseSchema.Property(typeof(T), property);
+                        //var prop = CoreUtils.GetProperty(typeof(T), property);
+                        var type = p2.PropertyType;
 
                         item.OriginalValues[property] = CoreUtils.GetPropertyValue(item, property);
 
                         if (type == typeof(string))
                         {
-                            if (prop.GetEditor() is UniqueCodeEditor || prop.GetEditor() is CodeEditor)
+                            if (p2.Editor is UniqueCodeEditor || p2.Editor is CodeEditor)
                                 CoreUtils.SetPropertyValue(item, property, value?.ToUpper());
                             else
                                 CoreUtils.SetPropertyValue(item, property, value);

InABox.Core/Imports/ImportFactory.cs

@@ -19,43 +19,34 @@ namespace InABox.Core
         public static IEnumerable<ImportMapping> ExtractMappings(Type type, ImportMappingType Import)
         {
             var results = new List<ImportMapping>();
-            var keys = CoreUtils.PropertyList(type, x => true, true).Keys.ToArray();
-            foreach (var key in keys)
+            
+            var props = DatabaseSchema.Properties(type).OrderBy(x=>x.Sequence);
+            
+            //var keys = CoreUtils.PropertyList(type, x => true, true).Keys.ToArray();
+            foreach (var prop in props)
             {
-                var prop = CoreUtils.GetProperty(type, key);
-                var editor = prop.GetEditor();
-                if (editor != null && editor is NullEditor == false && (!prop.IsCalculated() || Import == ImportMappingType.Export))
+
+                if (prop.Editor != null && prop.Editor is NullEditor == false && (!prop.IsCalculated || Import == ImportMappingType.Export))
                 {
                     var bOK = true;
 
-                    var bKey = editor is UniqueCodeEditor;
+                    var bKey = prop.Editor is UniqueCodeEditor;
 
                     var lookup = ImportLookupType.None;
                     if (Import == ImportMappingType.Import)
                     {
-                        var parentkey = string.Join(".", key.Split('.').Reverse().Skip(1).Reverse());
-                        var childkey = key.Split('.').Last();
-                        if (!string.IsNullOrEmpty(parentkey))
+                        var comps = prop.Name.Split('.');
+                        if (comps.Length > 1)
                         {
-                            var parentprop = CoreUtils.GetProperty(type, parentkey);
-                            if (parentprop.PropertyType.GetInterfaces().Contains(typeof(IEntityLink)))
-                            {
-                                if (!IsNestedEntityLink(type, parentkey))
-                                {
-                                    bOK = editor is CodeEditor;
-                                    lookup = ImportLookupType.Restrict;
-                                }
-                                else
-                                {
-                                    bOK = false;
-                                    lookup = ImportLookupType.None;
-                                }
-                            }
+                            if ((comps.Length == 2) && (prop.Editor is CodeEditor))
+                                lookup = ImportLookupType.Restrict;
+                            else
+                                bOK = false;
                         }
                     }
 
                     if (bOK)
-                        results.Add(new ImportMapping { Property = key, Field = "", Constant = "", Lookup = lookup, Key = bKey });
+                        results.Add(new ImportMapping { Property = prop.Name, Field = "", Constant = "", Lookup = lookup, Key = bKey });
                 }
             }
 

inabox.wpf/DynamicGrid/DynamicGrid.cs

@@ -998,7 +998,9 @@ namespace InABox.DynamicGrid
                     {
                         foreach (DataColumn lookupcol in lookups.Columns)
                         {
-                            var prop = String.Join(".", new String[] { prefix, lookupcol.ColumnName });
+                            var prop = String.IsNullOrWhiteSpace(prefix) 
+                                ? lookupcol.ColumnName 
+                                : String.Join(".", new String[] { prefix, lookupcol.ColumnName });
                             DynamicGridUtils.UpdateEditorValue(new BaseObject[] { inplaceeditor }, prop, lookuprow[lookupcol], changes);
                             //CoreUtils.SetPropertyValue(obj, prop, lookuprow[lookupcol]);
                         }

inabox.wpf/DynamicGrid/DynamicImportMappingGrid.cs

@@ -119,9 +119,11 @@ namespace InABox.DynamicGrid
         public void MatchFields()
         {
             foreach (var item in Items)
-                if (ImportFieldGenerator.Fields.Contains(item.Property))
+            {
+                var field = ImportFieldGenerator.Fields.FirstOrDefault(x => String.Equals(item.Property.ToUpper(), x.ToUpper()));
+                if (!String.IsNullOrWhiteSpace(field))
                 {
-                    item.Field = item.Property;
+                    item.Field = field;
                     if (item.Property.Equals(UniqueCode))
                         item.Key = true;
                 }
@@ -132,6 +134,7 @@ namespace InABox.DynamicGrid
                     item.Constant = "";
                     item.Lookup = item.Lookup == ImportLookupType.Create ? ImportLookupType.Restrict : item.Lookup;
                 }
+            }
 
             Refresh(false, true);
         }