initial try at reusing existing entities while generating code by gen…

…erating ForeignKey(typeof(SomeRow)) instead of ForeignKey("SomeTable", "SomeId")
serenity-is · Oct 18, 2023 · ce87569 · ce87569
1 parent cc295d7
commit ce87569
Show file tree

Hide file tree

Showing 13 changed files with 185 additions and 10 deletions.
diff --git a/src/Serenity.Net.CodeGenerator/Commands/GenerateCommand.cs b/src/Serenity.Net.CodeGenerator/Commands/GenerateCommand.cs
@@ -113,7 +113,7 @@ public ExitCodes Run(string csproj, string[] args)
                 ConnectionKey = connectionKey,
                 Config = config,
                 Schema = tableEntry.Schema,
-                Table = tableEntry.Tablename,
+                Table = tableEntry.Table,
                 Module = module,
                 Identifier = identifier,
                 PermissionKey = permissionKey
@@ -136,12 +136,25 @@ public ExitCodes Run(string csproj, string[] args)
             config.GenerateCustom = whatToGenerate.Contains("Custom", StringComparer.Ordinal);
         }
 
+        IApplicationMetadata application = null;
+        try
+        {
+            var assemblyFiles = ServerTypingsCommand.DetermineAssemblyFiles(fileSystem, csproj, config, (error) => { });
+            if (assemblyFiles != null && assemblyFiles.Length > 0)
+            {
+                application = new ApplicationMetadata(fileSystem, assemblyFiles);
+            }
+        }
+        catch { }
+
         foreach (var inputs in inputsList)
         {
             UpdateConfigTableFor(inputs, confConnection);
 
+            inputs.Application = application;
+
             var generator = CreateCodeGenerator(inputs, new EntityModelGenerator(),
-                csproj, fileSystem, sqlConnections, interactive: argsIdentifier is null);
+                csproj, fileSystem, sqlConnections, interactive: true);
 
             generator.Run();
         }

diff --git a/src/Serenity.Net.CodeGenerator/Generator/EntityModelGenerator.cs b/src/Serenity.Net.CodeGenerator/Generator/EntityModelGenerator.cs
@@ -394,7 +394,13 @@ void makeUniquePropertyName(EntityField f)
             if (!string.IsNullOrEmpty(tableField.PKTable))
             {
                 var pkTable = string.IsNullOrEmpty(tableField.PKSchema) ? tableField.PKTable : ("[" + tableField.PKSchema + "].[" + tableField.PKTable + "]");
-                attrs.Add(new("Serenity.Data.Mapping.ForeignKey", pkTable, tableField.PKColumn));
+                var pkRow = inputs.Application?.GetRowByTablename(pkTable);
+                if (pkRow != null)
+                {
+                    attrs.Add(new("Serenity.Data.Mapping.ForeignKey", new TypeOfRef(pkRow.FullName)));
+                }
+                else
+                    attrs.Add(new("Serenity.Data.Mapping.ForeignKey", pkTable, tableField.PKColumn));
 
                 object alias = model.DeclareJoinConstants ?
                     new RawCode(tableField.ForeignJoinAlias) : tableField.ForeignJoinAlias;

diff --git a/src/Serenity.Net.CodeGenerator/Models/AttributeTypeRef.cs b/src/Serenity.Net.CodeGenerator/Models/AttributeTypeRef.cs
@@ -24,7 +24,7 @@ public string ToString(CodeWriter cw)
             if (i > 0)
                 s += ", ";
 
-            if (value is TypeNameRef tr)
+            if (value is TypeOfRef tr)
                 s += tr.ToString(cw);
             else if (value is string str)
                 s += StringHelper.ToDoubleQuoted(str);

diff --git a/src/Serenity.Net.CodeGenerator/Models/EntityModelInputs.cs b/src/Serenity.Net.CodeGenerator/Models/EntityModelInputs.cs
@@ -1,7 +1,8 @@
-namespace Serenity.CodeGenerator;
+namespace Serenity.CodeGenerator;
 
 public class EntityModelInputs : IEntityModelInputs
 {
+    public IApplicationMetadata Application { get; set; }
     public GeneratorConfig Config { get; set; }
     public string ConnectionKey { get; set; }
     public IEntityDataSchema DataSchema { get; set; }

diff --git a/src/Serenity.Net.CodeGenerator/Models/IEntityModelInputs.cs b/src/Serenity.Net.CodeGenerator/Models/IEntityModelInputs.cs
@@ -1,7 +1,8 @@
-namespace Serenity.CodeGenerator;
+namespace Serenity.CodeGenerator;
 
 public interface IEntityModelInputs
 {
+    public IApplicationMetadata Application { get; }
     string ConnectionKey { get; }
     string Identifier { get; }
     GeneratorConfig Config { get; }

diff --git a/src/Serenity.Net.CodeGenerator/Models/Metadata/ApplicationMetadata.cs b/src/Serenity.Net.CodeGenerator/Models/Metadata/ApplicationMetadata.cs
@@ -0,0 +1,118 @@
+using Serenity.CodeGeneration;
+
+namespace Serenity.CodeGenerator;
+
+public class ApplicationMetadata : IApplicationMetadata
+{
+    private class Scanner : ServerTypingsGenerator
+    {
+        public List<TypeDefinition> RowTypes { get; } = new();
+
+        public Scanner(IGeneratorFileSystem fileSystem, params string[] assemblyLocations)
+            : base(fileSystem, assemblyLocations)
+        {
+        }
+
+        protected override void GenerateCodeFor(TypeDefinition type)
+        {
+            if (TypingsUtils.IsSubclassOf(type, "Serenity.Data", "Row") ||
+                TypingsUtils.IsSubclassOf(type, "Serenity.Data", "Row`1"))
+            {
+                RowTypes.Add(type);
+            }
+        }
+
+        protected override void HandleMemberType(TypeReference memberType, string codeNamespace, bool module)
+        {
+        }
+    }
+
+    private readonly Scanner scanner;
+
+    public ApplicationMetadata(IGeneratorFileSystem fileSystem, params string[] assemblyLocations)
+    {
+        scanner = new Scanner(fileSystem, assemblyLocations);
+        scanner.Run();
+    }
+
+    string DefaultSchema { get; set; }
+
+    private string ParseSchemaAndName(string objectName, out string schema)
+    {
+        if (objectName is null)
+            throw new ArgumentNullException(nameof(objectName));
+
+        schema = DefaultSchema;
+        var parts = objectName.Split('.');
+        if (parts.Length <= 0 || parts.Length > 2)
+            return null;
+
+        if (parts.Length == 1)
+            return SqlSyntax.Unquote(parts[0]);
+
+        schema = SqlSyntax.Unquote(parts[0]);
+        return SqlSyntax.Unquote(parts[1]);
+    }
+
+    private string NormalizeTablename(string objectName)
+    {
+        var table = ParseSchemaAndName(objectName, out var schema);
+        return table + "." + schema;
+    }
+
+    private bool IsEqualIgnoreCase(string objectName1, string objectName2)
+    {
+        return !string.IsNullOrEmpty(objectName1) &&
+            !string.IsNullOrEmpty(objectName2) &&
+            string.Equals(NormalizeTablename(objectName1), 
+                NormalizeTablename(objectName2), StringComparison.OrdinalIgnoreCase);
+    }
+
+    public IRowMetadata GetRowByTablename(string tablename)
+    {
+        foreach (var type in scanner.RowTypes)
+        {
+            var attr = type.GetAttributes().FirstOrDefault(x =>
+                x.AttributeType().Name == "TableNameAttribute" &&
+                x.AttributeType().NamespaceOf() == "Serenity.Data.Mapping");
+
+            if (attr != null)
+            {
+                if (IsEqualIgnoreCase(tablename, attr?.ConstructorArguments?.FirstOrDefault().Value as string))
+                    return new RowMetadata(type);
+
+                continue;
+            }
+
+            var name = type.Name;
+            if (name.EndsWith("Row", StringComparison.Ordinal))
+                name = name[..^3];
+
+            if (IsEqualIgnoreCase(tablename, name))
+                return new RowMetadata(type);
+        }
+
+        return null;
+    }
+
+    private class RowMetadata : IRowMetadata
+    {
+        private readonly TypeDefinition type;
+
+        public RowMetadata(TypeDefinition type)
+        {
+            this.type = type ?? throw new ArgumentNullException(nameof(type));
+        }
+
+        public string Namespace => type.NamespaceOf();
+
+        public string ClassName => type.Name;
+
+        public string FullName => type.FullNameOf();
+
+        public IRowPropertyMetadata GetTableField(string columnName)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/Serenity.Net.CodeGenerator/Models/Metadata/IApplicationMetadata.cs b/src/Serenity.Net.CodeGenerator/Models/Metadata/IApplicationMetadata.cs
@@ -0,0 +1,6 @@
+namespace Serenity.CodeGenerator;
+
+public interface IApplicationMetadata
+{
+    IRowMetadata GetRowByTablename(string tablename);
+}
diff --git a/src/Serenity.Net.CodeGenerator/Models/Metadata/IClassMetadata.cs b/src/Serenity.Net.CodeGenerator/Models/Metadata/IClassMetadata.cs
@@ -0,0 +1,8 @@
+namespace Serenity.CodeGenerator;
+
+public interface IClassMetadata
+{
+    string Namespace { get; }
+    string ClassName { get; }
+    string FullName => string.IsNullOrEmpty(Namespace) ? ClassName : Namespace + "." + ClassName;
+}
diff --git a/src/Serenity.Net.CodeGenerator/Models/Metadata/IPropertyMetadata.cs b/src/Serenity.Net.CodeGenerator/Models/Metadata/IPropertyMetadata.cs
@@ -0,0 +1,6 @@
+namespace Serenity.CodeGenerator;
+
+public interface IPropertyMetadata
+{
+    string PropertyName { get; }
+}
diff --git a/src/Serenity.Net.CodeGenerator/Models/Metadata/IRowMetadata.cs b/src/Serenity.Net.CodeGenerator/Models/Metadata/IRowMetadata.cs
@@ -0,0 +1,6 @@
+namespace Serenity.CodeGenerator;
+
+public interface IRowMetadata : IClassMetadata
+{
+    IRowPropertyMetadata GetTableField(string columnName);
+}
diff --git a/src/Serenity.Net.CodeGenerator/Models/Metadata/IRowPropertyMetadata.cs b/src/Serenity.Net.CodeGenerator/Models/Metadata/IRowPropertyMetadata.cs
@@ -0,0 +1,5 @@
+namespace Serenity.CodeGenerator;
+
+public interface IRowPropertyMetadata : IPropertyMetadata
+{
+}
diff --git a/...y.Net.CodeGenerator/Models/TypeNameRef.cs → ...ity.Net.CodeGenerator/Models/TypeOfRef.cs b/...y.Net.CodeGenerator/Models/TypeNameRef.cs → ...ity.Net.CodeGenerator/Models/TypeOfRef.cs
@@ -1,10 +1,10 @@
 namespace Serenity.CodeGenerator;
 
-public class TypeNameRef
+public class TypeOfRef
 {
     public string TypeName { get; }
 
-    public TypeNameRef(string typeName)
+    public TypeOfRef(string typeName)
     {
         TypeName = typeName ?? throw new ArgumentNullException(nameof(typeName));
     }

diff --git a/src/Serenity.Net.Core/Reflection/CodeWriter.cs b/src/Serenity.Net.Core/Reflection/CodeWriter.cs
@@ -351,8 +351,13 @@ public string ShortTypeName(string ns, string typeName)
 
         if (Using(ns))
             return typeName;
-        else
-            return ns + "." + typeName;
+        else if (CurrentNamespace != null)
+        {
+            var idx = CurrentNamespace.IndexOf('.', StringComparison.Ordinal);
+            if (idx >= 0 && ns.StartsWith(CurrentNamespace[..(idx + 1)], StringComparison.Ordinal))
+                ns = ns[(idx + 1)..];
+        }
+        return ns + "." + typeName;
     }
 
     /// <summary>