public static CSharpClassDefinition GetRequestModelExtensionsClassDefinition(this AspNetCoreProject project)
{
var classDefinition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
project.GetEntityLayerNamespace()
},
Namespace = project.GetRequestModelsNamespace(),
Name = "Extensions",
IsStatic = true
};
foreach (var table in project.Database.Tables)
{
if (!table.HasDefaultSchema())
{
classDefinition.Namespaces.AddUnique(project.GetEntityLayerNamespace(table.Schema));
}
classDefinition.Methods.Add(GetToEntityMethod(project, table));
classDefinition.Methods.Add(GetToRequestModelMethod(project, table));
}
return(classDefinition);
}
public void TestCSharpGenericClassGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
"System.Collections.Generic"
},
Namespace = "Mapping",
IsPartial = true,
Name = "GenericRepository",
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TEntity",
Constraint = "TEntity : class, new()"
}
},
Documentation = new Documentation
{
Summary = "Contains repository methos for entity",
Remarks = "This is an implementation according to design patterns."
}
};
definition.Methods.Add(new MethodDefinition("Int32", "CommitChanges"));
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public static CSharpClassDefinition GetPagedResponseClassDefinition(this AspNetCoreProject project)
{
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespaces.Add("System.Collections.Generic");
definition.Namespace = project.GetResponsesNamespace();
definition.Name = "PagedResponse";
definition.GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition {
Name = "TModel", Constraint = "TModel : class"
}
};
definition.Implements.Add("IListResponse<TModel>");
definition.Properties.Add(new PropertyDefinition("String", "Message"));
definition.Properties.Add(new PropertyDefinition("Boolean", "DidError"));
definition.Properties.Add(new PropertyDefinition("String", "ErrorMessage"));
definition.Properties.Add(new PropertyDefinition("IEnumerable<TModel>", "Model"));
definition.Properties.Add(new PropertyDefinition("Int32", "PageSize"));
definition.Properties.Add(new PropertyDefinition("Int32", "PageNumber"));
definition.Properties.Add(new PropertyDefinition("Int32", "ItemsCount"));
definition.Properties.Add(new PropertyDefinition("Int32", "PageCount")
{
IsReadOnly = true,
GetBody = new List <ILine>
{
new CodeLine("PageSize == 0 ? 0 : ItemsCount / PageSize;")
}
});
return(definition);
}
public static CSharpClassDefinition GetRepositoryBaseClassDefinition(this DapperProject project)
{
var classDefinition = new CSharpClassDefinition();
classDefinition.Namespaces.Add("System");
classDefinition.Namespaces.Add("System.Linq");
classDefinition.Namespaces.Add("System.Threading.Tasks");
classDefinition.Namespaces.Add("Microsoft.Extensions.Options");
classDefinition.Namespaces.Add(project.GetEntityLayerNamespace());
classDefinition.Namespace = project.GetDataLayerContractsNamespace();
classDefinition.Name = "Repository";
classDefinition.Constructors.Add(new ClassConstructorDefinition(new ParameterDefinition("IOptions<AppSettings>", "appSettings"))
{
Lines = new List <ILine>
{
new CodeLine("ConnectionString = appSettings.Value.ConnectionString;")
}
});
classDefinition.Properties.Add(new PropertyDefinition("String", "ConnectionString ")
{
AccessModifier = AccessModifier.Protected,
IsReadOnly = true
});
return(classDefinition);
}
public void ScaffoldingClassWithOnlyFields()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
Name = "Foo",
Fields =
{
new FieldDefinition(AccessModifier.Public, "string", "Bar")
{
IsReadOnly = true,
Value = "\"ABC\""
}
},
Constructors =
{
new ClassConstructorDefinition()
}
};
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public static CSharpClassDefinition GetListResponseClassDefinition(this AspNetCoreProject project)
{
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespaces.Add("System.Collections.Generic");
definition.Namespace = project.GetResponsesNamespace();
definition.Name = "ListResponse";
definition.GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition {
Name = "TModel", Constraint = "TModel : class"
}
};
definition.Implements.Add("IListResponse<TModel>");
definition.Properties.Add(new PropertyDefinition("String", "Message"));
definition.Properties.Add(new PropertyDefinition("Boolean", "DidError"));
definition.Properties.Add(new PropertyDefinition("String", "ErrorMessage"));
definition.Properties.Add(new PropertyDefinition("IEnumerable<TModel>", "Model"));
return(definition);
}
public void TestGetClass()
{
// Act
var interfaceDefinition = new CSharpInterfaceDefinition
{
Namespace = "Entities",
AccessModifier = AccessModifier.Public,
Name = "IEntity"
};
var classDefinition = new CSharpClassDefinition
{
Namespace = "Entities",
AccessModifier = AccessModifier.Public,
Name = "OrderHeader",
Implements =
{
"Entities.IEntity"
}
};
// Arrange
var classDef = TypeManager.GetItemByFullName(classDefinition.FullName);
// Assert
Assert.True(TypeManager.ObjectDefinitions.Count > 0);
Assert.True(classDef != null);
}
public static CSharpClassDefinition GetEntityClassDefinition(this EntityFrameworkCoreProject project, IView view)
{
var classDefinition = new CSharpClassDefinition();
classDefinition.Namespaces.Add("System");
if (project.Settings.UseDataAnnotations)
{
classDefinition.Namespaces.Add("System.ComponentModel.DataAnnotations");
classDefinition.Namespaces.Add("System.ComponentModel.DataAnnotations.Schema");
}
classDefinition.Namespace = view.HasDefaultSchema() ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(view.Schema);
classDefinition.Name = view.GetSingularName();
classDefinition.IsPartial = true;
classDefinition.Constructors.Add(new ClassConstructorDefinition());
if (!string.IsNullOrEmpty(view.Description))
{
classDefinition.Documentation.Summary = view.Description;
}
foreach (var column in view.Columns)
{
classDefinition.Properties.Add(new PropertyDefinition(column.GetClrType(), column.HasSameNameEnclosingType(view) ? column.GetNameForEnclosing() : column.GetPropertyName()));
}
if (project.Settings.SimplifyDataTypes)
{
classDefinition.SimplifyDataTypes();
}
return(classDefinition);
}
public static CSharpClassDefinition GetEntityMapperClassDefinition(this EntityFrameworkCoreProject project)
{
var classDefinition = new CSharpClassDefinition();
classDefinition.Namespaces.Add("System.Collections.Generic");
classDefinition.Namespaces.Add("Microsoft.EntityFrameworkCore");
classDefinition.Namespace = project.GetDataLayerConfigurationsNamespace();
classDefinition.Name = "EntityMapper";
classDefinition.Implements.Add("IEntityMapper");
classDefinition.Constructors.Add(new ClassConstructorDefinition());
classDefinition.Properties.Add(new PropertyDefinition("IEnumerable<IEntityTypeConfiguration>", "Configurations"));
classDefinition.Methods.Add(new MethodDefinition("void", "ConfigureEntities", new ParameterDefinition("ModelBuilder", "modelBuilder"))
{
Lines = new List <ILine>
{
new CodeLine("foreach (var item in Configurations)"),
new CodeLine("{"),
new CodeLine(1, "item.Configure(modelBuilder);"),
new CodeLine("}")
}
});
return(classDefinition);
}
public static EntityFrameworkCoreProject ScaffoldValueConversion(this EntityFrameworkCoreProject project)
{
var boolToStringConverters = new CSharpClassDefinition
{
Namespaces =
{
"Microsoft.EntityFrameworkCore.Storage.ValueConversion"
},
Namespace = "ValueConversion",
AccessModifier = AccessModifier.Public,
IsStatic = true,
Name = "BoolToStringConverters",
Fields =
{
new FieldDefinition
{
AccessModifier = AccessModifier.Private,
IsStatic = true,
IsReadOnly = true,
Type = "BoolToStringConverter",
Name = "bYN",
Value = "new BoolToStringConverter(\"N\", \"Y\")"
}
}
};
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerDirectory("ValueConversion"), true, boolToStringConverters);
return(project);
}
public static CSharpClassDefinition GetDatabaseEntityMapperClassDefinition(this EntityFrameworkCoreProject project)
{
var classDefinition = new CSharpClassDefinition();
classDefinition.Namespace = project.GetDataLayerConfigurationsNamespace();
classDefinition.Name = project.Database.GetDbEntityMapperName();
classDefinition.BaseClass = "EntityMapper";
var lines = new List <ILine>();
if (project.Settings.UseMefForEntitiesMapping)
{
classDefinition.Namespaces.Add("System.Composition.Hosting");
classDefinition.Namespaces.Add("System.Reflection");
lines.Add(new CommentLine(" Get current assembly"));
lines.Add(new CodeLine("var currentAssembly = typeof({0}).GetTypeInfo().Assembly;", project.Database.GetDbContextName()));
lines.Add(new CodeLine());
lines.Add(new CommentLine(" Get configuration for container from current assembly"));
lines.Add(new CodeLine("var configuration = new ContainerConfiguration().WithAssembly(currentAssembly);"));
lines.Add(new CodeLine());
lines.Add(new CommentLine(" Create container for exports"));
lines.Add(new CodeLine("using (var container = configuration.CreateContainer())"));
lines.Add(new CodeLine("{"));
lines.Add(new CommentLine(1, " Get all definitions that implement IEntityMap interface"));
lines.Add(new CodeLine(1, "Configurations = container.GetExports<IEntityTypeConfiguration>();"));
lines.Add(new CodeLine("}"));
}
else
{
classDefinition.Namespaces.Add("System.Collections.Generic");
lines.Add(new CodeLine("Configurations = new List<IEntityTypeConfiguration>()"));
lines.Add(new CodeLine("{"));
for (var i = 0; i < project.Database.Tables.Count; i++)
{
var table = project.Database.Tables[i];
lines.Add(new CodeLine(1, "new {0}(){1}", table.GetEntityTypeConfigurationName(), i == project.Database.Tables.Count - 1 ? string.Empty : ","));
}
lines.Add(new CodeLine("};"));
}
classDefinition.Constructors.Add(new ClassConstructorDefinition {
Lines = lines
});
return(classDefinition);
}
public void TestCsharpRepositoryClassGeneration()
{
// Arrange
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespaces.Add("System.Collections.Generic");
definition.Namespace = "Repositories";
definition.Name = "DboRepository";
definition.Implements.Add("IRepository");
definition.Fields.Add(new FieldDefinition(AccessModifier.Private, "DbContext", "m_dbContext"));
definition.Constructors.Add(new ClassConstructorDefinition());
definition.AddReadOnlyProperty("DbContext", "DbContext", new CodeLine("return m_dbContext;"));
definition.Properties.Add(new PropertyDefinition("IUserInfo", "UserInfo"));
definition.Methods.Add(new MethodDefinition("Task<Int32>", "CommitChangesAsync")
{
IsAsync = true,
Lines = new List <ILine>
{
new CommentLine("Save changes in async way"),
new CodeLine("return await DbContext.SaveChangesAsync();")
}
});
definition.Methods.Add(new MethodDefinition("IEnumerable<TEntity>", "GetAll")
{
Lines = new List <ILine>
{
new TodoLine("Check generic cast"),
new CodeLine("return DbContext.Set<TEntity>();")
}
});
definition.Methods.Add(new MethodDefinition("void", "Add", new ParameterDefinition("TEntity", "entity"))
{
Lines = new List <ILine>
{
new CommentLine("Check entry state"),
new CodeLine("DbContext.Set<TEntity>().Add(entity);"),
new CodeLine(),
new TodoLine("Save changes in async way"),
new CodeLine("DbContext.SaveChanges();")
}
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public static CSharpClassDefinition GetEntityClassDefinition(this EntityFrameworkCoreProject project, IView view)
{
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = project.Database.HasDefaultSchema(view) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(view.Schema),
Name = project.GetEntityName(view),
IsPartial = true,
Constructors =
{
new ClassConstructorDefinition()
}
};
if (!string.IsNullOrEmpty(view.Description))
{
definition.Documentation.Summary = view.Description;
}
var projectSelection = project.GetSelection(view);
if (projectSelection.Settings.UseDataAnnotations)
{
definition.Namespaces.Add("System.ComponentModel.DataAnnotations");
definition.Namespaces.Add("System.ComponentModel.DataAnnotations.Schema");
}
foreach (var column in view.Columns)
{
var propertyType = string.Empty;
if (project.Database.HasTypeMappedToClr(column))
{
var clrType = project.Database.GetClrMapForType(column);
propertyType = clrType.AllowClrNullable ? string.Format("{0}?", clrType.GetClrType().Name) : clrType.GetClrType().Name;
}
else
{
propertyType = "object";
}
definition.Properties.Add(new PropertyDefinition(propertyType, column.HasSameNameEnclosingType(view) ? column.GetNameForEnclosing() : view.GetPropertyNameHack(column)));
}
if (projectSelection.Settings.SimplifyDataTypes)
{
definition.SimplifyDataTypes();
}
return(definition);
}
public void ScaffoldingOrderClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System",
"System.ComponentModel.DataAnnotations",
"System.ComponentModel.DataAnnotations.Schema"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
Name = "Order"
};
definition.Attributes.Add(new MetadataAttribute("Table", "\"Orders\"")
{
Sets =
{
new MetadataAttributeSet("Schema", "\"dbo\"")
}
});
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("Int32?", "OrderID", attributes: new[]
{
new MetadataAttribute("Key"),
new MetadataAttribute("DatabaseGenerated", "DatabaseGeneratedOption.Identity")
})
);
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("DateTime?", "OrderDate", attributes: new[] { new MetadataAttribute("Column") })
);
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("String", "CustomerID", attributes: new[]
{
new MetadataAttribute("Column"),
new MetadataAttribute("StringLength", "5")
})
);
definition.Properties.Add(
CSharpClassDefinition.CreateAutomaticProperty("Int32?", "ShipperID", attributes: new[] { new MetadataAttribute("Column") })
);
definition.SimplifyDataTypes();
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
private static void GetGetAllMethod(this CSharpClassDefinition definition, ProjectFeature <EntityFrameworkCoreProjectSettings> projectFeature, IView view)
{
var efCoreProject = projectFeature.GetEntityFrameworkCoreProject();
definition.Methods.Add(new MethodDefinition(string.Format("IQueryable<{0}>", efCoreProject.GetEntityName(view)), efCoreProject.GetGetAllRepositoryMethodName(view))
{
Lines =
{
new CodeLine("return DbContext.{0};", efCoreProject.GetDbSetPropertyName(view))
}
});
}
public static CSharpClassDefinition GetRepositoryExtensionsClassDefinition(this EntityFrameworkCoreProject project)
{
var classDefinition = new CSharpClassDefinition();
classDefinition.Namespaces.Add("System");
classDefinition.Namespaces.Add("System.Linq");
classDefinition.Namespaces.Add(project.GetDataLayerNamespace());
classDefinition.Namespaces.Add(project.GetEntityLayerNamespace());
classDefinition.Namespace = project.GetDataLayerRepositoriesNamespace();
classDefinition.IsStatic = true;
classDefinition.Name = "RepositoryExtensions";
classDefinition.Methods.Add(new MethodDefinition("IQueryable<TEntity>", "Paging", new ParameterDefinition(project.Database.GetDbContextName(), "dbContext"), new ParameterDefinition("Int32", "pageSize", "0"), new ParameterDefinition("Int32", "pageNumber", "0"))
{
IsExtension = true,
IsStatic = true,
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TEntity",
Constraint = "TEntity : class"
}
},
Lines = new List <ILine>()
{
new CodeLine("var query = dbContext.Set<TEntity>().AsQueryable();"),
new CodeLine(),
new CodeLine("return pageSize > 0 && pageNumber > 0 ? query.Skip((pageNumber - 1) * pageSize).Take(pageSize) : query;")
}
});
classDefinition.Methods.Add(new MethodDefinition("IQueryable<TModel>", "Paging", new ParameterDefinition("IQueryable<TModel>", "query"), new ParameterDefinition("Int32", "pageSize", "0"), new ParameterDefinition("Int32", "pageNumber", "0"))
{
IsExtension = true,
IsStatic = true,
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TModel",
Constraint = "TModel : class"
}
},
Lines = new List <ILine>()
{
new CodeLine("return pageSize > 0 && pageNumber > 0 ? query.Skip((pageNumber - 1) * pageSize).Take(pageSize) : query;")
}
});
return(classDefinition);
}
private static void ScaffoldDataContracts(EntityFrameworkCoreProject project)
{
foreach (var table in project.Database.Tables)
{
if (!project.Settings.EntitiesWithDataContracts.Contains(table.FullName))
{
continue;
}
var classDefinition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System"
},
Namespace = project.GetDataLayerDataContractsNamespace(),
Name = table.GetDataContractName()
};
foreach (var column in table.Columns)
{
classDefinition.Properties.Add(new PropertyDefinition(column.GetClrType(), column.GetPropertyName()));
}
foreach (var foreignKey in table.ForeignKeys)
{
var foreignTable = project.Database.FindTableByFullName(foreignKey.References);
if (foreignTable == null)
{
continue;
}
var foreignKeyAlias = NamingConvention.GetCamelCase(foreignTable.GetEntityName());
foreach (var column in foreignTable?.GetColumnsWithOutPrimaryKey())
{
var target = string.Format("{0}{1}", foreignTable.GetEntityName(), column.GetPropertyName());
if (classDefinition.Properties.Where(item => item.Name == column.GetPropertyName()).Count() == 0)
{
classDefinition.Properties.Add(new PropertyDefinition(column.GetClrType(), target));
}
}
}
CSharpCodeBuilder.CreateFiles(project.OutputDirectory, project.GetDataLayerDataContractsDirectory(), project.Settings.ForceOverwrite, classDefinition);
}
}
private static void GetGetAllMethod(this CSharpClassDefinition classDefinition, ProjectFeature projectFeature, IView view)
{
var lines = new List <ILine>
{
new CodeLine("DbContext.Set<{0}>();", view.GetSingularName())
};
var parameters = new List <ParameterDefinition>
{
};
classDefinition.Methods.Add(new MethodDefinition(string.Format("IQueryable<{0}>", view.GetSingularName()), view.GetGetAllRepositoryMethodName(), parameters.ToArray())
{
Lines = lines
});
}
public void ScaffoldingBaseRepositoryClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
IsPartial = true,
Name = "Repository",
Implements =
{
"IRepository"
},
Constructors =
{
new ClassConstructorDefinition(AccessModifier.Public, new ParameterDefinition("NorthwindDbContext", "dbContext"))
{
Lines =
{
new CodeLine("DbContext = dbContext;")
}
}
},
Properties =
{
CSharpClassDefinition.CreateReadonlyProperty("NorthwindDbContext", "DbContext", accessModifier: AccessModifier.Protected),
},
Methods =
{
new MethodDefinition(AccessModifier.Public, "", "Dispose")
{
Lines =
{
new TodoLine("Implement dispose for DbContext")
}
}
}
};
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public void TestCsharpClassWithMethodsGeneration()
{
// Arrange
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespace = "Operations";
definition.Name = "Helpers";
definition.Methods.Add(new MethodDefinition("void", "Foo", new ParameterDefinition("int", "foo", "0"), new ParameterDefinition("int", "bar", "1"))
{
IsAsync = true
});
definition.Methods.Add(new MethodDefinition("void", "Bar", new ParameterDefinition("int", "a")));
definition.Methods.Add(new MethodDefinition("int", "Zaz")
{
Lines = new List <ILine>
{
new CodeLine("return 0;")
}
});
definition.Methods.Add(new MethodDefinition("int", "Qux")
{
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "T",
Constraint = "T : class"
}
},
Lines = new List <ILine>
{
new CodeLine("return 0;")
}
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public static CSharpClassDefinition GetResponsesExtensionsClassDefinition(this AspNetCoreProject project, ITable table)
{
var classDefinition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
"System.ComponentModel.DataAnnotations",
table.HasDefaultSchema() ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(table.Schema),
table.HasDefaultSchema() ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(table.Schema)
},
Namespace = project.GetRequestModelsNamespace(),
Name = table.GetRequestModelName()
};
var selection = project.GetSelection(table);
foreach (var column in table.Columns.Where(item => selection.Settings.ConcurrencyToken != item.Name).ToList())
{
var property = new PropertyDefinition(EfCore.DatabaseExtensions.ResolveType(project.Database, column), column.GetPropertyName());
if (table.PrimaryKey?.Key.Count > 0 && table.PrimaryKey?.Key.First() == column.Name)
{
property.Attributes.Add(new MetadataAttribute("Key"));
}
if (!column.Nullable && table.PrimaryKey?.Key.Count > 0 && table.PrimaryKey?.Key.First() != column.Name)
{
property.Attributes.Add(new MetadataAttribute("Required"));
}
if (project.Database.ColumnIsString(column) && column.Length > 0)
{
property.Attributes.Add(new MetadataAttribute("StringLength", column.Length.ToString()));
}
classDefinition.Properties.Add(property);
}
return(classDefinition);
}
public void ScaffoldingProductViewModelClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System",
"System.ComponentModel"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
IsPartial = true,
Name = "Product",
Implements =
{
"INotifyPropertyChanged"
},
Events =
{
new EventDefinition("PropertyChangedEventHandler", "PropertyChanged")
{
AccessModifier = AccessModifier.Public
}
}
};
definition.AddViewModelProperty("int?", "ProductID");
definition.AddViewModelProperty("string", "ProductName");
definition.AddViewModelProperty("int?", "SupplierID");
definition.AddViewModelProperty("int?", "CategoryID");
definition.AddViewModelProperty("string", "QuantityPerUnit");
definition.AddViewModelProperty("decimal?", "UnitPrice");
definition.AddViewModelProperty("short?", "UnitsInStock");
definition.AddViewModelProperty("short?", "UnitsOnOrder");
definition.AddViewModelProperty("short?", "ReorderLevel");
definition.AddViewModelProperty("bool?", "Discontinued");
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public void TestCSharpClassWithIndexerGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
"System.Collections.Generic"
},
Namespace = "Mapping",
Name = "DataSet"
};
definition.Indexers.Add(new IndexerDefinition
{
AccessModifier = AccessModifier.Public,
Type = "string",
Parameters = new List <ParameterDefinition>
{
new ParameterDefinition
{
Type = "int",
Name = "index"
}
},
GetBody = new List <ILine>
{
new CodeLine("return m_columns[index];")
},
SetBody = new List <ILine>
{
new CodeLine("m_columns = value;")
}
});
definition.AddPropertyWithField("List<string>", "Columns");
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public static CSharpClassDefinition CreateView(this DapperProject project, IView view)
{
var definition = new CSharpClassDefinition();
definition.Namespaces.Add("System");
definition.Namespace = view.HasDefaultSchema() ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(view.Schema);
definition.Name = view.GetEntityName();
definition.Constructors.Add(new ClassConstructorDefinition());
if (!string.IsNullOrEmpty(view.Description))
{
definition.Documentation.Summary = view.Description;
}
var selection = project.GetSelection(view);
foreach (var column in view.Columns)
{
if (selection.Settings.UseAutomaticPropertiesForEntities)
{
definition.Properties.Add(new PropertyDefinition(project.Database.ResolveType(column), column.GetPropertyName()));
}
else
{
definition.AddPropertyWithField(project.Database.ResolveType(column), column.GetPropertyName());
}
}
definition.Implements.Add("IEntity");
if (selection.Settings.SimplifyDataTypes)
{
definition.SimplifyDataTypes();
}
return(definition);
}
public void ScaffoldingClassWithConstants()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
IsStatic = true,
Name = "Tokens"
};
definition.Constants.Add(new ConstantDefinition(AccessModifier.Public, "int", "Foo", 1000));
definition.Constants.Add(new ConstantDefinition(AccessModifier.Public, "string", "Bar", "ABC"));
definition.Constants.Add(new ConstantDefinition(AccessModifier.Public, "bool", "Baz", true));
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
public void TestCSharpClassWithFinalizerGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System.Data.Common"
},
Namespace = "Infrastructure",
Name = "DbContext",
IsStatic = true
};
definition.Fields.Add(new FieldDefinition(AccessModifier.Private, "IDbConnection", "Connection")
{
IsStatic = true
});
definition.StaticConstructor = new ClassConstructorDefinition
{
Lines = new List <ILine>
{
new CodeLine("Connection = DbFactory.GetDefaultInstance();")
}
};
definition.Finalizer = new FinalizerDefinition
{
Lines = new List <ILine>
{
new CodeLine("Connection.Dispose();")
}
};
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public void TestScaffoldingCustOrderHistResultClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
Name = "CustOrderHist"
};
definition.Properties.Add(new PropertyDefinition(AccessModifier.Public, "string", "ProductName")
{
IsAutomatic = true
});
definition.Properties.Add(new PropertyDefinition(AccessModifier.Public, "int", "Total")
{
IsAutomatic = true
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.NetCore\\DesignPatterns", string.Empty, true, definition);
}
public void TestCSharpStaticClassWithExtensionMethodsGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System"
},
Namespace = "Helpers",
Name = "Extensions",
IsStatic = true
};
definition.Methods.Add(new MethodDefinition("void", "Foo", new ParameterDefinition("int", "foo", "0"), new ParameterDefinition("int", "bar", "1"))
{
IsStatic = true,
IsExtension = true
});
definition.Methods.Add(new MethodDefinition("String", "Bar", new ParameterDefinition("long", "x", "0"))
{
IsStatic = true,
IsExtension = true,
GenericTypes = new List <GenericTypeDefinition>
{
new GenericTypeDefinition
{
Name = "TModel",
Constraint = "TModel : class"
}
}
});
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public void TestPersonClassGeneration()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces = new List <string>
{
"System",
"System.ComponentModel"
},
Namespace = "ContactManager",
Name = "Person",
};
definition.Attributes.Add(new MetadataAttribute("Table", "\"Persons\"")
{
Sets = new List <MetadataAttributeSet>
{
new MetadataAttributeSet("Schema", "\"PersonalInfo\"")
}
});
definition.Properties.Add(new PropertyDefinition("Int32?", "ID", new MetadataAttribute("Key"))
{
IsVirtual = true
});
definition.Properties.Add(new PropertyDefinition("String", "FirstName", new MetadataAttribute("Required"), new MetadataAttribute("StringLength", "25")));
definition.Properties.Add(new PropertyDefinition("String", "MiddleName", new MetadataAttribute("StringLength", "25")));
definition.Properties.Add(new PropertyDefinition("String", "LastName", new MetadataAttribute("Required"), new MetadataAttribute("StringLength", "25")));
definition.Properties.Add(new PropertyDefinition("String", "Gender", new MetadataAttribute("Required"), new MetadataAttribute("StringLength", "1")));
definition.Properties.Add(new PropertyDefinition("DateTime?", "BirthDate", new MetadataAttribute("Required")));
definition.SimplifyDataTypes();
// Act
CSharpCodeBuilder.CreateFiles("C:\\Temp\\CatFactory.DotNetCore", string.Empty, true, definition);
}
public void ScaffoldingEntityExtensionsClass()
{
// Arrange
var definition = new CSharpClassDefinition
{
Namespaces =
{
"System"
},
Namespace = "DesignPatterns",
AccessModifier = AccessModifier.Public,
IsStatic = true,
Name = "EntityExtensions"
};
definition.Methods.Add(new MethodDefinition
{
AccessModifier = AccessModifier.Public,
IsStatic = true,
IsExtension = true,
Type = "string",
Name = "ToJson",
Parameters =
{
new ParameterDefinition("Order", "entity")
},
Lines =
{
new CodeLine("return string.Empty;")
}
});
definition.SimplifyDataTypes();
// Act
CSharpCodeBuilder.CreateFiles(@"C:\Temp\CatFactory.NetCore\DesignPatterns", string.Empty, true, definition);
}
