public CodeOutput GenerateFakeDbSet()
{
var filename = "FakeDbSet" + Settings.FileExtension;
if (!CanWriteFakeContext())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var data = new FakeDbSetModel
{
DbContextClassModifiers = Settings.DbContextClassModifiers,
DbContextClassIsPartial = Settings.DbContextClassIsPartial(),
IsEfCore2 = Settings.IsEfCore2(),
IsEfCore3 = Settings.IsEfCore3(),
IsEfCore5 = Settings.IsEfCore5(),
IsEfCore3Plus = Settings.IsEfCore3Plus()
};
var co = new CodeOutput(string.Empty, filename, "Fake DbSet", _globalUsings);
co.AddUsings(_template.FakeDbSetUsings(data));
co.AddCode(Template.Transform(_template.FakeDbSet(), data));
return(co);
}
public CodeOutput GenerateFakeContext()
{
var filename = "Fake" + Settings.DbContextName + Settings.FileExtension;
if (!CanWriteFakeContext())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var data = new FakeContextModel
{
DbContextClassModifiers = Settings.DbContextClassModifiers, DbContextName = Settings.DbContextName, DbContextBaseClass = Settings.DbContextBaseClass,
contextInterface = string.IsNullOrWhiteSpace(Settings.DbContextInterfaceName) ? "" : " : " + Settings.DbContextInterfaceName,
DbContextClassIsPartial = Settings.DbContextClassIsPartial(),
tables = _tables,
storedProcs = _storedProcs,
hasStoredProcs = _hasStoredProcs,
tableValuedFunctions = _tableValuedFunctions,
scalarValuedFunctions = _scalarValuedFunctions,
hasTableValuedFunctions = _hasTableValuedFunctions && _filter.IncludeTableValuedFunctions,
hasScalarValuedFunctions = _hasScalarValuedFunctions && _filter.IncludeScalarValuedFunctions,
};
var co = new CodeOutput(string.Empty, filename, "Fake Database context", Settings.ContextFolder, _globalUsings);
co.AddUsings(_template.FakeDatabaseContextUsings(data, _filter));
co.AddCode(Template.Transform(_template.FakeDatabaseContext(), data));
return(co);
}
public static Generator Create(FileManagementService fileManagementService, Type fileManagerType, string singleDbContextSubNamespace = null)
{
Generator generator;
switch (Settings.GeneratorType)
{
case GeneratorType.Ef6:
generator = new GeneratorEf6(fileManagementService, fileManagerType);
break;
case GeneratorType.EfCore:
generator = new GeneratorEfCore(fileManagementService, fileManagerType);
break;
case GeneratorType.Custom:
generator = new GeneratorCustom(fileManagementService, fileManagerType);
break;
default:
throw new ArgumentOutOfRangeException();
}
generator.Init(singleDbContextSubNamespace);
return(generator);
}
public CodeOutput GenerateInterface()
{
var filename = Settings.DbContextInterfaceName + Settings.FileExtension;
if (!CanWriteInterface())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var data = new InterfaceModel
{
interfaceModifier = Settings.DbContextInterfaceModifiers ?? "public partial",
DbContextInterfaceName = Settings.DbContextInterfaceName,
DbContextInterfaceBaseClasses = Settings.DbContextInterfaceBaseClasses,
DbContextName = Settings.DbContextName,
tables = _tables.Where(x => x.DbSetModifier == "public").ToList(),
AdditionalContextInterfaceItems = Settings.AdditionalContextInterfaceItems.Where(x => !string.IsNullOrEmpty(x)).Distinct().ToList(),
addSaveChanges = !Settings.UseInheritedBaseInterfaceFunctions,
storedProcs = _storedProcs,
hasStoredProcs = _hasStoredProcs,
tableValuedFunctions = _tableValuedFunctions,
scalarValuedFunctions = _scalarValuedFunctions,
hasTableValuedFunctions = _hasTableValuedFunctions && _filter.IncludeTableValuedFunctions,
hasScalarValuedFunctions = _hasScalarValuedFunctions && _filter.IncludeScalarValuedFunctions,
};
var co = new CodeOutput(string.Empty, filename, "Database context interface", Settings.InterfaceFolder, _globalUsings);
co.AddUsings(_template.DatabaseContextInterfaceUsings(data));
co.AddCode(Template.Transform(_template.DatabaseContextInterface(), data));
return(co);
}
public void OneTimeSetUp()
{
var fileManagement = new FileManagementService(new GeneratedTextTransformation());
var databaseReader = new FakeDatabaseReader();
_rawTables = new List <RawTable>();
_sut = new GeneratorCustom(fileManagement, typeof(NullFileManager));
_sut.Init(databaseReader, string.Empty);
}
public static void initialize()
{
session = new Teamcenter.ClientX.Session(serverHost);
dmService = DataManagementService.getService(Teamcenter.ClientX.Session.getConnection());
//prefService = PreferenceManagementService.getService(Session.getConnection());
sessionService = SessionService.getService(Teamcenter.ClientX.Session.getConnection());
queryService = SavedQueryService.getService(Teamcenter.ClientX.Session.getConnection());
fileMgtService = FileManagementService.getService(Teamcenter.ClientX.Session.getConnection());
}
public static Generator Create(FileManagementService fileManagementService, Type fileManagerType, string singleDbContextSubNamespace = null)
{
Generator generator;
switch (Settings.GeneratorType)
{
case GeneratorType.Ef6:
generator = new GeneratorEf6(fileManagementService, fileManagerType);
break;
case GeneratorType.EfCore:
generator = new GeneratorEfCore(fileManagementService, fileManagerType);
break;
case GeneratorType.Custom:
generator = new GeneratorCustom(fileManagementService, fileManagerType);
break;
default:
throw new ArgumentOutOfRangeException();
}
var providerName = "unknown";
try
{
providerName = DatabaseProvider.GetProvider(Settings.DatabaseType);
var factory = DbProviderFactories.GetFactory(providerName);
var databaseReader = DatabaseReaderFactory.Create(factory);
generator.Init(databaseReader, singleDbContextSubNamespace);
return(generator);
}
catch (Exception x)
{
var error = x.Message.Replace("\r\n", "\n").Replace("\n", " ");
Console.WriteLine(error);
fileManagementService.Error(generator.GetPreHeaderInfo());
fileManagementService.Error(string.Empty);
fileManagementService.Error("// ------------------------------------------------------------------------------------------------");
fileManagementService.Error(string.Format("// WARNING: Failed to load provider \"{0}\" - {1}", providerName, error));
fileManagementService.Error("// Allowed providers:");
foreach (DataRow fc in DbProviderFactories.GetFactoryClasses().Rows)
{
var s = string.Format("// \"{0}\"", fc[2]);
fileManagementService.Error(s);
}
fileManagementService.Error(string.Empty);
fileManagementService.Error("/*" + x.StackTrace + "*/");
fileManagementService.Error("// ------------------------------------------------------------------------------------------------");
fileManagementService.Error(string.Empty);
}
return(null);
}
public FileContentProvider(HttpContext context, string[] searchPatterns, string[] viewPaths, string[] uploadPaths, string[] deletePaths, string selectedUrl, string selectedItemTag)
: base(context, searchPatterns, viewPaths, uploadPaths, deletePaths, selectedUrl, selectedItemTag)
{
this.dataServer = new BusinessLogicalService(System.Configuration.ConfigurationManager.ConnectionStrings["TelerikConnectionString"].ConnectionString);
this.fileService = new FileManagementService(System.Configuration.ConfigurationManager.ConnectionStrings["TelerikConnectionString"].ConnectionString);
this.itemHandlerPath = System.Configuration.ConfigurationManager.AppSettings["Telerik.FileApp.ItemHandler"];
if (itemHandlerPath.StartsWith("~/"))
{
itemHandlerPath = HttpContext.Current.Request.ApplicationPath.TrimEnd('/') + itemHandlerPath.Substring(1);
}
}
public void Ef6ModelBuilder()
{
// Arrange
var fileManagement = new FileManagementService(new GeneratedTextTransformation());
var sut = new GeneratorEf6(fileManagement, typeof(NullFileManager));
// Act
var list = new List <string>();
foreach (var column in _orderDetails.Columns)
{
var s = sut.IndexModelBuilder(column);
list.Add(s);
Console.WriteLine(s);
}
// Assert
Assert.AreEqual(3, list.Count);
Assert.AreEqual(@"modelBuilder.Entity<OrderDetails>()
.Property(e => e.OrderID)
.HasColumnAnnotation(
IndexAnnotation.AnnotationName,
new IndexAnnotation(new[]
{
new IndexAttribute(""OrderID"", 1),
new IndexAttribute(""OrdersOrder_Details"", 1),
new IndexAttribute(""PK_Order_Details"", 1) { IsUnique = true, IsClustered = true }
}));", list[0].Trim());
Assert.AreEqual(@"modelBuilder.Entity<OrderDetails>()
.Property(e => e.ProductID)
.HasColumnAnnotation(
IndexAnnotation.AnnotationName,
new IndexAnnotation(new[]
{
new IndexAttribute(""PK_Order_Details"", 2) { IsUnique = true, IsClustered = true },
new IndexAttribute(""ProductID"", 1),
new IndexAttribute(""ProductsOrder_Details"", 1)
}));", list[1].Trim());
Assert.AreEqual(@"modelBuilder.Entity<OrderDetails>()
.Property(e => e.test)
.HasColumnAnnotation(
IndexAnnotation.AnnotationName,
new IndexAnnotation(new IndexAttribute(""PK_test"", 1) { IsUnique = true, IsClustered = true })
);", list[2].Trim());
}
public CodeOutput GenerateEnum(Enumeration enumeration)
{
var filename = enumeration.EnumName + Settings.FileExtension;
if (!CanWriteEnums())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var co = new CodeOutput(enumeration.EnumName, filename, null, null);
co.AddUsings(_template.EnumUsings());
co.AddCode(Template.Transform(_template.Enums(), enumeration));
return(co);
}
public UploadDownloadFsc3(User user)
{
// String[] FMS_Bootstrap_Urls = new string[] { host };
// String cacheDir = "c:\\work\\";
dservice = DataManagementService.getService(PDMConnection.ClientX.Session.getConnection());
fmservice = FileManagementService.getService(PDMConnection.ClientX.Session.getConnection());
fmsFileManagement = new FileManagementUtility(PDMConnection.ClientX.Session.getConnection(), null, null, new[] { "" }, "C:\\WORK\\");
try {
homeFolder = user.Home_folder;
} catch (NotLoadedException e) {
Console.WriteLine(e.StackTrace);
}
setObjectPolicy();
}
public void EfCoreModelBuilder()
{
// Arrange
var fileManagement = new FileManagementService(new GeneratedTextTransformation());
var sut = new GeneratorEfCore(fileManagement, typeof(NullFileManager));
// Act
var list = sut.IndexModelBuilder(_orderDetails);
foreach (var str in list)
{
Console.WriteLine(str);
}
// Assert
Assert.AreEqual(4, list.Count);
Assert.AreEqual(@"builder.HasIndex(x => x.OrderID).HasName(""OrderID"");", list[0]);
Assert.AreEqual(@"builder.HasIndex(x => x.OrderID).HasName(""OrdersOrder_Details"");", list[1]);
Assert.AreEqual(@"builder.HasIndex(x => x.ProductID).HasName(""ProductID"");", list[2]);
Assert.AreEqual(@"builder.HasIndex(x => x.ProductID).HasName(""ProductsOrder_Details"");", list[3]);
}
public CodeOutput GenerateFactory()
{
var filename = Settings.DbContextName + "Factory" + Settings.FileExtension;
if (!CanWriteFactory())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var data = new FactoryModel
{
classModifier = Settings.DbContextClassModifiers,
contextName = Settings.DbContextName
};
var co = new CodeOutput(string.Empty, filename, "Database context factory", _globalUsings);
co.AddUsings(_template.DatabaseContextFactoryUsings(data));
co.AddCode(Template.Transform(_template.DatabaseContextFactory(), data));
return(co);
}
public CodeOutput GenerateStoredProcReturnModel(StoredProcedure sp)
{
var filename = sp.WriteStoredProcReturnModelName(_filter) + Settings.FileExtension;
if (!CanWriteStoredProcReturnModel())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var multipleModelReturnColumns = new List <MultipleModelReturnColumns>();
var model = 0;
foreach (var returnModel in sp.ReturnModels)
{
multipleModelReturnColumns.Add(new MultipleModelReturnColumns(++model, returnModel.Select(sp.WriteStoredProcReturnColumn).ToList()));
}
var data = new StoredProcReturnModel
{
ResultClassModifiers = Settings.ResultClassModifiers,
WriteStoredProcReturnModelName = sp.WriteStoredProcReturnModelName(_filter),
SingleModel = sp.ReturnModels.Count == 1,
SingleModelReturnColumns = sp.ReturnModels
.First()
.Select(sp.WriteStoredProcReturnColumn)
.ToList(),
MultipleModelReturnColumns = multipleModelReturnColumns
};
var co = new CodeOutput(sp.DbName, filename, null, _globalUsings);
co.AddUsings(_template.StoredProcReturnModelUsings());
co.AddCode(Template.Transform(_template.StoredProcReturnModels(), data));
return(co);
}
public CodeOutput GeneratePocoConfiguration(Table table)
{
var filename = table.NameHumanCaseWithSuffix() + Settings.ConfigurationClassName + Settings.FileExtension;
if (!CanWritePocoConfiguration())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var columns = table.Columns
.Where(x => !x.Hidden && !string.IsNullOrEmpty(x.Config))
.OrderBy(x => x.Ordinal)
.ToList();
var isEfCore3Plus = Settings.IsEfCore3Plus();
var foreignKeys = columns.SelectMany(x => x.ConfigFk).OrderBy(o => o).ToList();
var primaryKey = _generator.PrimaryKeyModelBuilder(table);
var indexes = _generator.IndexModelBuilder(table);
var hasIndexes = indexes != null && indexes.Any();
var data = new PocoConfigurationModel
{
UseHasNoKey = isEfCore3Plus && table.IsView && !table.HasPrimaryKey,
Name = table.DbName,
ToTableOrView = (isEfCore3Plus && table.IsView && !table.HasPrimaryKey) ? "ToView" : "ToTable",
ConfigurationClassName = table.NameHumanCaseWithSuffix() + Settings.ConfigurationClassName,
NameHumanCaseWithSuffix = table.NameHumanCaseWithSuffix(),
Schema = table.Schema.DbName,
PrimaryKeyNameHumanCase = primaryKey ?? table.PrimaryKeyNameHumanCase(),
HasSchema = !string.IsNullOrEmpty(table.Schema.DbName),
ClassModifier = Settings.ConfigurationClassesModifiers,
ClassComment = table.WriteComments(),
Columns = columns.Select(x => x.Config).ToList(),
HasReverseNavigation = table.ReverseNavigationProperty.Count > 0,
ReverseNavigationProperty = table.ReverseNavigationProperty
.OrderBy(x => x.Definition)
.Select(x => new PocoReverseNavigationPropertyModel
{
ReverseNavHasComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments),
ReverseNavComment = Settings.IncludeComments != CommentsStyle.None ? x.Comments : string.Empty,
AdditionalReverseNavigationsDataAnnotations = Settings.AdditionalReverseNavigationsDataAnnotations,
AdditionalDataAnnotations = x.AdditionalDataAnnotations,
Definition = x.Definition
})
.ToList(),
HasForeignKey = foreignKeys.Any(),
ForeignKeys = foreignKeys,
MappingConfiguration = table.MappingConfiguration,
ConfigurationClassesArePartial = Settings.ConfigurationClassesArePartial(),
Indexes = indexes,
HasIndexes = hasIndexes
};
var co = new CodeOutput(table.DbName, filename, null, _globalUsings);
co.AddUsings(_template.PocoConfigurationUsings(data));
co.AddCode(Template.Transform(_template.PocoConfiguration(), data));
return(co);
}
public CodeOutput GeneratePoco(Table table)
{
var filename = table.NameHumanCaseWithSuffix() + Settings.FileExtension;
if (!CanWritePoco())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var isEfCore3Plus = Settings.IsEfCore3Plus();
var data = new PocoModel
{
UseHasNoKey = isEfCore3Plus && table.IsView && !table.HasPrimaryKey,
HasNoPrimaryKey = !table.HasPrimaryKey,
Name = table.DbName,
NameHumanCaseWithSuffix = table.NameHumanCaseWithSuffix(),
ClassModifier = Settings.EntityClassesModifiers,
ClassComment = table.WriteComments(),
ExtendedComments = table.WriteExtendedComments(),
ClassAttributes = table.WriteClassAttributes(),
BaseClasses = table.BaseClasses,
InsideClassBody = Settings.WriteInsideClassBody(table),
Columns = table.Columns
.Where(x => !x.Hidden && !x.ExistsInBaseClass)
.OrderBy(x => x.Ordinal)
.Select((col, index) => new PocoColumnModel
{
AddNewLineBefore = index > 0 && (((Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock || Settings.IncludeComments == CommentsStyle.InSummaryBlock) && !string.IsNullOrEmpty(col.SummaryComments)) || (col.Attributes != null && col.Attributes.Any())),
HasSummaryComments = (Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock || Settings.IncludeComments == CommentsStyle.InSummaryBlock) && !string.IsNullOrEmpty(col.SummaryComments),
SummaryComments = !string.IsNullOrEmpty(col.SummaryComments) ? SecurityElement.Escape(col.SummaryComments) : null,
Attributes = col.Attributes,
OverrideModifier = col.OverrideModifier,
WrapIfNullable = col.WrapIfNullable(),
NameHumanCase = col.NameHumanCase,
PrivateSetterForComputedColumns = Settings.UsePrivateSetterForComputedColumns && col.IsComputed ? "private " : string.Empty,
PropertyInitialisers = Settings.UsePropertyInitialisers ? (string.IsNullOrWhiteSpace(col.Default) ? string.Empty : string.Format(" = {0};", col.Default)) : string.Empty,
InlineComments = col.InlineComments
})
.ToList(),
HasReverseNavigation = table.ReverseNavigationProperty.Count > 0,
ReverseNavigationProperty = table.ReverseNavigationProperty
.OrderBy(x => x.Definition)
.Select(x => new PocoReverseNavigationPropertyModel
{
ReverseNavHasComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments),
ReverseNavComment = Settings.IncludeComments != CommentsStyle.None ? x.Comments : string.Empty,
AdditionalReverseNavigationsDataAnnotations = Settings.AdditionalReverseNavigationsDataAnnotations,
AdditionalDataAnnotations = x.AdditionalDataAnnotations,
Definition = x.Definition
})
.ToList(),
HasForeignKey = table.HasForeignKey,
ForeignKeyTitleComment = Settings.IncludeComments != CommentsStyle.None && table.Columns.SelectMany(x => x.EntityFk).Any() ? " // Foreign keys" + Environment.NewLine : string.Empty,
ForeignKeys = table.Columns
.SelectMany(x => x.EntityFk)
.OrderBy(o => o.Definition)
.Select(x => new PocoForeignKeyModel
{
HasFkComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments),
FkComment = x.Comments,
AdditionalForeignKeysDataAnnotations = Settings.AdditionalForeignKeysDataAnnotations,
AdditionalDataAnnotations = x.AdditionalDataAnnotations,
Definition = x.Definition
})
.ToList(),
CreateConstructor = !Settings.UsePropertyInitialisers &&
(
table.Columns.Any(c => c.Default != string.Empty && !c.Hidden) ||
table.ReverseNavigationCtor.Any() ||
Settings.EntityClassesArePartial()
),
ColumnsWithDefaults = table.Columns
.Where(c => c.Default != string.Empty && !c.Hidden && Settings.IncludeColumnsWithDefaults)
.OrderBy(x => x.Ordinal)
.Select(x => new PocoColumnsWithDefaultsModel {
NameHumanCase = x.NameHumanCase, Default = x.Default
})
.ToList(),
ReverseNavigationCtor = table.ReverseNavigationCtor,
EntityClassesArePartial = Settings.EntityClassesArePartial()
};
var co = new CodeOutput(table.DbName, filename, null, _globalUsings);
co.AddUsings(_template.PocoUsings(data));
co.AddCode(Template.Transform(_template.Poco(), data));
return(co);
}
public CodeOutput GenerateContext()
{
var filename = Settings.DbContextName + Settings.FileExtension;
if (!CanWriteContext())
{
FileManagementService.DeleteFile(filename);
return(null);
}
var indexes = new List <string>();
var hasSpatialTypes = false;
foreach (var table in _tables)
{
var columns = table.Table.Columns
.Where(x => !x.Hidden && !string.IsNullOrEmpty(x.Config))
.OrderBy(x => x.Ordinal)
.ToList();
if (!Settings.DisableGeographyTypes && !hasSpatialTypes)
{
hasSpatialTypes = columns.Any(x => x.IsSpatial);
}
indexes.AddRange(columns
.Select(_generator.IndexModelBuilder)
.Where(x => !string.IsNullOrWhiteSpace(x)));
}
var isEfCore3Plus = Settings.IsEfCore3Plus();
var data = new ContextModel
{
DbContextClassModifiers = Settings.DbContextClassModifiers,
DbContextName = Settings.DbContextName,
DbContextBaseClass = Settings.DbContextBaseClass,
AddParameterlessConstructorToDbContext = Settings.AddParameterlessConstructorToDbContext,
HasDefaultConstructorArgument = !string.IsNullOrEmpty(Settings.DefaultConstructorArgument),
DefaultConstructorArgument = Settings.DefaultConstructorArgument,
ConfigurationClassName = Settings.ConfigurationClassName,
ConnectionString = Settings.ConnectionString,
ConnectionStringName = Settings.ConnectionStringName,
ConnectionStringActions = hasSpatialTypes && Settings.TemplateType != TemplateType.Ef6 ? ", x => x.UseNetTopologySuite()" : "",
contextInterface = string.IsNullOrWhiteSpace(Settings.DbContextInterfaceName) ? "" : ", " + Settings.DbContextInterfaceName,
setInitializer = string.Format("<{0}>(null);", Settings.DbContextName),
DbContextClassIsPartial = Settings.DbContextClassIsPartial(),
SqlCe = Settings.DatabaseType == DatabaseType.SqlCe,
tables = _tables,
hasTables = _hasTables,
indexes = indexes,
hasIndexes = indexes.Any(),
storedProcs = _storedProcs,
hasStoredProcs = _hasStoredProcs,
tableValuedFunctionComplexTypes = _tableValuedFunctionComplexTypes,
hasTableValuedFunctionComplexTypes = _hasTableValuedFunctionComplexTypes,
AdditionalContextInterfaceItems = Settings.AdditionalContextInterfaceItems.Where(x => !string.IsNullOrEmpty(x)).Distinct().ToList(),
addSaveChanges = !Settings.UseInheritedBaseInterfaceFunctions,
tableValuedFunctions = _tableValuedFunctions,
scalarValuedFunctions = _scalarValuedFunctions,
Sequences = _filter.Sequences,
hasSequences = _filter.Sequences.Any(),
hasTableValuedFunctions = _hasTableValuedFunctions && _filter.IncludeTableValuedFunctions,
hasScalarValuedFunctions = _hasScalarValuedFunctions && _filter.IncludeScalarValuedFunctions,
IncludeObjectContextConstructor = !Settings.DbContextBaseClass.Contains("IdentityDbContext"),
QueryString = isEfCore3Plus ? "Set" : "Query",
FromSql = isEfCore3Plus ? "FromSqlRaw" : "FromSql",
ExecuteSqlCommand = isEfCore3Plus ? "ExecuteSqlRaw" : "ExecuteSqlCommand",
StoredProcModelBuilderCommand = isEfCore3Plus ? "Entity" : "Query",
StoredProcModelBuilderPostCommand = isEfCore3Plus ? ".HasNoKey()" : string.Empty,
OnConfigurationUsesConfiguration = Settings.OnConfiguration == OnConfiguration.Configuration,
OnConfigurationUsesConnectionString = Settings.OnConfiguration == OnConfiguration.ConnectionString,
DefaultSchema = Settings.DefaultSchema,
UseDatabaseProvider = Settings.DatabaseProvider(),
SqlParameter = Settings.SqlParameter(),
};
var co = new CodeOutput(string.Empty, filename, "Database context", _globalUsings);
co.AddUsings(_template.DatabaseContextUsings(data));
co.AddCode(Template.Transform(_template.DatabaseContext(), data));
return(co);
}
public void Run(string filename, string singleDbContextSubNamespace, Type fileManagerType, string subFolder)
{
Inflector.PluralisationService = new EnglishPluralizationService();
Settings.GenerateSingleDbContext = true;
var path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
if (!string.IsNullOrEmpty(subFolder))
{
path = Path.Combine(path, subFolder);
}
Settings.Root = path;
var fullPath = Path.Combine(path, $"{filename}_{Settings.DatabaseType}_{Settings.TemplateType}_Fk{Settings.ForeignKeyNamingStrategy}.cs");
// Delete old generated files
if (File.Exists(fullPath))
{
File.Delete(fullPath);
}
if (!string.IsNullOrEmpty(subFolder))
{
foreach (var old in Directory.GetFiles(Settings.Root))
{
File.Delete(old);
}
}
var outer = new GeneratedTextTransformation();
var fileManagement = new FileManagementService(outer);
var generator = GeneratorFactory.Create(fileManagement, fileManagerType, singleDbContextSubNamespace);
// Turn on everything for testing
Assert.IsNotNull(generator);
Assert.IsNotNull(generator.FilterList);
var filters = generator.FilterList.GetFilters();
Assert.IsNotNull(filters);
foreach (var filter in filters)
{
filter.Value.IncludeViews = true;
filter.Value.IncludeSynonyms = true;
filter.Value.IncludeStoredProcedures = true;
filter.Value.IncludeTableValuedFunctions = true;
filter.Value.IncludeScalarValuedFunctions = true;
}
var stopwatch = new Stopwatch();
var stopwatchGenerator = new Stopwatch();
stopwatch.Start();
generator.ReadDatabase();
stopwatchGenerator.Start();
generator.GenerateCode();
stopwatchGenerator.Stop();
stopwatch.Stop();
Console.WriteLine("Duration: {0:F1} seconds, Generator {1:F1} seconds", stopwatch.ElapsedMilliseconds / 1000.0, stopwatchGenerator.ElapsedMilliseconds / 1000.0);
Console.WriteLine($"Writing to {fullPath}");
Console.WriteLine();
if (outer.FileData.Length > 0)
{
using (var sw = new StreamWriter(fullPath))
{
sw.Write(outer.FileData.ToString());
}
}
fileManagement.Process(true);
}
public void Run(string filename, Type fileManagerType, string subFolder)
{
Inflector.PluralisationService = new EnglishPluralizationService();
var path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
if (!string.IsNullOrEmpty(subFolder))
{
path = Path.Combine(path, subFolder);
}
Settings.Root = path;
var outer = new GeneratedTextTransformation();
var fileManagement = new FileManagementService(outer);
var generator = GeneratorFactory.Create(fileManagement, fileManagerType);
Assert.IsNotNull(generator);
List <MultiContextSettings> multiDbSettings;
if (string.IsNullOrWhiteSpace(Settings.MultiContextSettingsPlugin))
{
multiDbSettings = generator.FilterList.GetMultiContextSettings();
}
else
{
var plugin = (IMultiContextSettingsPlugin)AssemblyHelper.LoadPlugin(Settings.MultiContextSettingsPlugin);
multiDbSettings = plugin.ReadSettings();
}
Assert.IsNotNull(multiDbSettings);
var filters = generator.FilterList.GetFilters();
Assert.IsNotNull(filters);
var keys = filters.Select(x => x.Key).ToArray();
_generatedFileNames = keys.Select(x => $"{filename}_{Settings.DatabaseType}_{Settings.TemplateType}_{x}.cs").ToArray();
_generatedFullPaths = _generatedFileNames.Select(x => Path.Combine(path, x)).ToArray();
// Set the fileManager to generate these filenames for testing
for (var n = 0; n < keys.Length; n++)
{
fileManagement.UseFileManager(keys[n]);
fileManagement.StartNewFile(_generatedFileNames[n]);
}
// Delete old generated files
foreach (var fullPath in _generatedFullPaths)
{
Console.WriteLine($"Deleting {fullPath}");
if (File.Exists(fullPath))
{
File.Delete(fullPath);
}
}
if (!string.IsNullOrEmpty(subFolder))
{
foreach (var old in Directory.GetFiles(Settings.Root))
{
File.Delete(old);
}
}
// Turn on everything for testing
foreach (var filter in generator.FilterList.GetFilters())
{
filter.Value.IncludeViews = true;
filter.Value.IncludeSynonyms = true;
filter.Value.IncludeStoredProcedures = true;
filter.Value.IncludeTableValuedFunctions = true;
filter.Value.IncludeScalarValuedFunctions = true;
}
var stopwatch = new Stopwatch();
var stopwatchGenerator = new Stopwatch();
stopwatch.Start();
generator.ReadDatabase();
stopwatchGenerator.Start();
generator.GenerateCode();
stopwatchGenerator.Stop();
stopwatch.Stop();
Console.WriteLine("Duration: {0:F1} seconds, Generator {1:F1} seconds", stopwatch.ElapsedMilliseconds / 1000.0, stopwatchGenerator.ElapsedMilliseconds / 1000.0);
foreach (var file in _generatedFullPaths)
{
Console.WriteLine($"Writing to {file}");
}
Console.WriteLine();
if (outer.FileData.Length > 0 && _generatedFullPaths.Length == 1)
{
using (var sw = new StreamWriter(_generatedFullPaths[0]))
{
sw.Write(outer.FileData.ToString());
}
}
fileManagement.Process(true);
}
public GeneratorEf6(FileManagementService fileManagementService, Type fileManagerType)
: base(fileManagementService, fileManagerType)
{
}
public PayrollController(FileManagementService fileManagementService) =>
