public SavedModelFiles Save(ScaffoldedModel scaffoldedModel, string outputDir, string nameSpace)
{
Directory.CreateDirectory(outputDir);
var contextPath = Path.GetFullPath(Path.Combine(outputDir, scaffoldedModel.ContextFile.Path));
Directory.CreateDirectory(Path.GetDirectoryName(contextPath));
File.WriteAllText(contextPath, scaffoldedModel.ContextFile.Code, Encoding.UTF8);
var additionalFiles = new List <string>();
foreach (var entityTypeFile in scaffoldedModel.AdditionalFiles)
{
var additionalFilePath = Path.Combine(outputDir, entityTypeFile.Path);
Directory.CreateDirectory(Path.GetDirectoryName(additionalFilePath));
File.WriteAllText(additionalFilePath, entityTypeFile.Code, Encoding.UTF8);
additionalFiles.Add(additionalFilePath);
}
return(new SavedModelFiles(contextPath, additionalFiles));
}
public ScaffoldedModel ScaffoldModel(FunctionModel model, ModuleScaffolderOptions scaffolderOptions, ref List <string> errors)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var result = new ScaffoldedModel();
errors = model.Errors;
var dbContext = WriteFunctionsClass(scaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(scaffolderOptions.ContextDir, scaffolderOptions.ContextName + ".Functions.cs")),
};
return(result);
}
public Tempproj GenerateTempProject(ConectionData data, string ending, ScaffoldedModel models)
{
DiplomWork.Model.Context context = new Model.Context();
Model.TempProjects tempProject = new Model.TempProjects();
tempProject.ConnectionString = data.ConnectionString;
tempProject.ContextName = data.ContextName;
tempProject.ProjectName = data.ProjName;
Tempproj tempproj = new Tempproj();
context.Add(tempProject);
tempproj.Models = new List <string>();
tempproj.FileNames = new List <string>();
foreach (var file in models.AdditionalFiles)
{
DiplomWork.Model.Model model = new DiplomWork.Model.Model();
model.Tempproject = tempProject.Id;
model.Model1 = file.Code;
model.Filename = Path.GetFileName(file.Path);
model.TempprojectNavigation = tempProject;
context.Add(model);
context.SaveChanges();
tempproj.FileNames.Add(Path.GetFileName(file.Path));
tempproj.Models.Add(file.Code);
}
tempproj.FileNames.Add(Path.GetFileName(models.ContextFile.Path));
tempproj.Models.Add(models.ContextFile.Code);
DiplomWork.Model.Model Contextmodel = new DiplomWork.Model.Model();
Contextmodel.Tempproject = tempProject.Id;
Contextmodel.Model1 = models.ContextFile.Code;
Contextmodel.Filename = Path.GetFileName(models.ContextFile.Path);
context.Add(Contextmodel);
context.SaveChanges();
tempproj.Id = tempProject.Id;
tempproj.RandomEnding = ending;
tempproj.Data = data;
context.Dispose();
return(tempproj);
}
/// <summary>
/// Generates code for a model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="options">The model generatation options <see cref="ModelCodeGenerationOptions"/>.</param>
/// <returns></returns>
public ScaffoldedModel GenerateModel(IModel model, ModelCodeGenerationOptions options)
{
var files = new ScaffoldedModel();
var contextCode = this.dbContextGenerator.WriteCode(
model,
options.ContextNamespace,
options.ContextName,
options.ConnectionString,
options.UseDataAnnotations,
options.SuppressConnectionStringWarning
);
files.ContextFile = new ScaffoldedFile
{
Path = Path.Combine(options.ContextDir, options.ContextName + FileExtension),
Code = contextCode
};
foreach (var entityType in model.GetEntityTypes())
{
var entityCode = this.entityTypeGenerator.WriteCode(
entityType,
options.ContextNamespace,
options.UseDataAnnotations
);
var entityFile = new ScaffoldedFile
{
Path = entityType.DisplayName() + FileExtension,
Code = entityCode
};
files.AdditionalFiles.Add(entityFile);
}
return(files);
}
public ScaffoldedModel ScaffoldModel(ProcedureModel model, ModuleScaffolderOptions procedureScaffolderOptions, ref List <string> errors)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var result = new ScaffoldedModel();
errors = model.Errors;
foreach (var procedure in model.Procedures)
{
var name = GenerateIdentifierName(procedure, model) + "Result";
var classContent = WriteResultClass(procedure, procedureScaffolderOptions, name);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = procedureScaffolderOptions.UseSchemaFolders
? Path.Combine(procedure.Schema, $"{name}.cs")
: $"{name}.cs"
});
}
var dbContext = WriteProcedureDbContext(procedureScaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(procedureScaffolderOptions.ContextDir, procedureScaffolderOptions.ContextName + "Procedures.cs")),
};
return(result);
}
public SavedModelFiles Save(ScaffoldedModel scaffoldedModel, string outputDir, string nameSpaceValue, bool useAsyncCalls)
{
throw new NotSupportedException();
}
public override ScaffoldedModel GenerateModel(IModel model, ModelCodeGenerationOptions options)
{
var resultingFiles = new ScaffoldedModel();
var contextGenerator = new MyDbContextGenerator
{
Session = new Dictionary <string, object>
{
["Model"] = model,
["ModelNamespace"] = options.ModelNamespace,
["Namespace"] = options.ContextNamespace,
["ContextName"] = options.ContextName,
["ConnectionString"] = options.ConnectionString,
["SuppressConnectionStringWarning"] = options.SuppressConnectionStringWarning,
["UseDataAnnotations"] = options.UseDataAnnotations,
["Code"] = _csharpHelper,
["ProviderCode"] = _providerConfigurationCodeGenerator,
["AnnotationCode"] = _annotationCodeGenerator
}
};
contextGenerator.Initialize();
var generatedCode = contextGenerator.TransformText();
var dbContextFileName = options.ContextName + ".cs";
resultingFiles.ContextFile = new ScaffoldedFile
{
Path = Path.Combine(options.ContextDir, dbContextFileName),
Code = generatedCode
};
foreach (var entityType in model.GetEntityTypes())
{
var entityGenerator = new MyEntityTypeGenerator
{
Session = new Dictionary <string, object>
{
["EntityType"] = entityType,
["Namespace"] = options.ModelNamespace,
["UseDataAnnotations"] = options.UseDataAnnotations,
["Code"] = _csharpHelper
}
};
entityGenerator.Initialize();
generatedCode = entityGenerator.TransformText();
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile
{
Path = entityType.Name + ".cs",
Code = generatedCode
});
var configurationGenerator = new MyEntityTypeConfigurationGenerator
{
Session = new Dictionary <string, object>
{
["EntityType"] = entityType,
["ModelNamespace"] = options.ModelNamespace,
["Namespace"] = options.ContextNamespace,
["UseDataAnnotations"] = options.UseDataAnnotations,
["Code"] = _csharpHelper,
["AnnotationCode"] = _annotationCodeGenerator
}
};
configurationGenerator.Initialize();
generatedCode = configurationGenerator.TransformText();
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile
{
Path = Path.Combine(options.ContextDir, entityType.Name + "Configuration.cs"),
Code = generatedCode
});
}
return(resultingFiles);
}
/// <summary>Generates code for a model.</summary>
/// <param name="model"> The model. </param>
/// <param name="namespace"> The namespace. </param>
/// <param name="contextDir"> The directory of the <see cref="T:Microsoft.EntityFrameworkCore.DbContext" />. </param>
/// <param name="contextName"> The name of the <see cref="T:Microsoft.EntityFrameworkCore.DbContext" />. </param>
/// <param name="connectionString"> The connection string. </param>
/// <param name="options"> The options to use during generation. </param>
/// <returns> The generated model. </returns>
public override ScaffoldedModel GenerateModel(IModel model,
string @namespace,
string contextDir,
string contextName,
string connectionString,
ModelCodeGenerationOptions options)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (string.IsNullOrWhiteSpace(@namespace))
{
throw new ArgumentNullException(nameof(@namespace));
}
if (contextDir == null)
{
throw new ArgumentNullException(nameof(contextDir));
}
if (string.IsNullOrWhiteSpace(contextName))
{
throw new ArgumentNullException(nameof(contextName));
}
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException(nameof(connectionString));
}
if (contextDir == null)
{
throw new ArgumentNullException(nameof(contextDir));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
// Register Hbs helpers and partial templates
HandlebarsHelperService.RegisterHelpers();
DbContextTemplateService.RegisterPartialTemplates();
EntityTypeTemplateService.RegisterPartialTemplates();
var resultingFiles = new ScaffoldedModel();
string generatedCode;
if (!(CSharpDbContextGenerator is NullCSharpDbContextGenerator))
{
generatedCode = CSharpDbContextGenerator.WriteCode(model, @namespace, contextName, connectionString, options.UseDataAnnotations, options.SuppressConnectionStringWarning);
var dbContextFileName = contextName + FileExtension;
resultingFiles.ContextFile = new ScaffoldedFile {
Path = Path.Combine(contextDir, dbContextFileName), Code = generatedCode
};
}
if (!(CSharpEntityTypeGenerator is NullCSharpEntityTypeGenerator))
{
foreach (var entityType in model.GetEntityTypes())
{
generatedCode = CSharpEntityTypeGenerator.WriteCode(entityType, @namespace, options.UseDataAnnotations);
var transformedFileName = EntityTypeTransformationService.TransformEntityFileName(entityType.DisplayName());
var entityTypeFileName = transformedFileName + FileExtension;
resultingFiles.AdditionalFiles.Add(new ScaffoldedFile {
Path = entityTypeFileName, Code = generatedCode
});
}
}
return(resultingFiles);
}
/// <summary>
/// <summary>Generates code for a model.</summary>
/// </summary>
/// <param name="model"> The model.</param>
/// <param name="options"> The options to use during generation. </param>
/// <returns> The generated model. </returns>
public override ScaffoldedModel GenerateModel(IModel model, ModelCodeGenerationOptions options)
{
Check.NotNull(model, nameof(model));
Check.NotNull(options, nameof(options));
// Register Hbs helpers and partial templates
HandlebarsHelperService.RegisterHelpers();
HandlebarsBlockHelperService.RegisterBlockHelpers();
DbContextTemplateService.RegisterPartialTemplates();
EntityTypeTemplateService.RegisterPartialTemplates();
var resultingFiles = new ScaffoldedModel();
string generatedCode;
if (!(CSharpDbContextGenerator is NullCSharpDbContextGenerator))
{
generatedCode = CSharpDbContextGenerator.WriteCode(
model,
options.ContextName,
options.ConnectionString,
options.ContextNamespace,
options.ModelNamespace,
options.UseDataAnnotations,
options.SuppressConnectionStringWarning,
options.SuppressOnConfiguring);
var dbContextFileName = ContextTransformationService.TransformContextFileName(options.ContextName) + FileExtension;
resultingFiles.ContextFile = new ScaffoldedFile
{
Path = options.ContextDir != null
? Path.Combine(options.ContextDir, dbContextFileName)
: dbContextFileName,
Code = generatedCode
};
}
if (!(CSharpEntityTypeGenerator is NullCSharpEntityTypeGenerator))
{
foreach (var entityType in model.GetScaffoldEntityTypes(_options.Value))
{
generatedCode = CSharpEntityTypeGenerator.WriteCode(
entityType,
options.ModelNamespace,
options.UseDataAnnotations);
var transformedFileName = EntityTypeTransformationService.TransformEntityFileName(entityType.DisplayName());
var entityTypeFileName = _options?.Value?.EnableSchemaFolders == true
? Path.Combine(CSharpHelper.Namespace(entityType.GetSchema()), transformedFileName + FileExtension)
: transformedFileName + FileExtension;
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile
{
Path = entityTypeFileName,
Code = generatedCode
});
}
}
return(resultingFiles);
}
public override ScaffoldedModel GenerateModel(IModel model, ModelCodeGenerationOptions options)
{
if (options.ContextName == null)
{
throw new ArgumentException(
CoreStrings.ArgumentPropertyNull(nameof(options.ContextName), nameof(options)), nameof(options));
}
if (options.ConnectionString == null)
{
throw new ArgumentException(
CoreStrings.ArgumentPropertyNull(nameof(options.ConnectionString), nameof(options)), nameof(options));
}
var resultingFiles = new ScaffoldedModel();
var contextTemplate = Path.Combine(options.ProjectDir !, TemplatesDirectory, "DbContext.t4");
Check.DebugAssert(_host.Session == null, "Session is not null.");
_host.Session = _host.CreateSession();
try
{
_host.Session.Add("Model", model);
_host.Session.Add("Options", options);
_host.Session.Add("NamespaceHint", options.ContextNamespace ?? options.ModelNamespace);
_host.Session.Add("ProjectDefaultNamespace", options.RootNamespace);
var handler = new TextTemplatingCallback();
var generatedCode = ProcessTemplate(contextTemplate, handler);
var dbContextFileName = options.ContextName + handler.Extension;
resultingFiles.ContextFile = new ScaffoldedFile
{
Path = options.ContextDir != null
? Path.Combine(options.ContextDir, dbContextFileName)
: dbContextFileName,
Code = generatedCode
};
}
finally
{
_host.Session = null;
}
var entityTypeTemplate = Path.Combine(options.ProjectDir !, TemplatesDirectory, "EntityType.t4");
if (File.Exists(entityTypeTemplate))
{
foreach (var entityType in model.GetEntityTypes())
{
// TODO: Should this be handled inside the template?
if (CSharpDbContextGenerator.IsManyToManyJoinEntityType(entityType))
{
continue;
}
_host.Session = _host.CreateSession();
try
{
_host.Session.Add("EntityType", entityType);
_host.Session.Add("Options", options);
_host.Session.Add("NamespaceHint", options.ModelNamespace);
_host.Session.Add("ProjectDefaultNamespace", options.RootNamespace);
var handler = new TextTemplatingCallback();
var generatedCode = ProcessTemplate(entityTypeTemplate, handler);
if (string.IsNullOrWhiteSpace(generatedCode))
{
continue;
}
var entityTypeFileName = entityType.Name + handler.Extension;
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile {
Path = entityTypeFileName, Code = generatedCode
});
}
finally
{
_host.Session = null;
}
}
}
return(resultingFiles);
}
public override ScaffoldedModel GenerateModel(IModel model, ModelCodeGenerationOptions options)
{
var resultingFiles = new ScaffoldedModel();
var connectionString = options.ConnectionString;
// HACK: Work around dotnet/efcore#19799
if (File.Exists(connectionString))
{
connectionString = "Data Source=(local);Initial Catalog=" + (string)model["Scaffolding:DatabaseName"];
}
var configurationContextFolder = options.ContextName.Replace("Context", string.Empty);
var contextGenerator = new DbContextGenerator
{
Session = new Dictionary <string, object>
{
["Model"] = model,
["ContextNamespace"] = options.ContextNamespace,
["ModelNamespace"] = options.ModelNamespace,
["ContextName"] = options.ContextName,
["ConnectionString"] = connectionString,
["SuppressConnectionStringWarning"] = options.SuppressConnectionStringWarning,
["UseDataAnnotations"] = options.UseDataAnnotations,
["Code"] = _csharpHelper,
["ProviderCode"] = _providerConfigurationCodeGenerator,
["AnnotationCode"] = _annotationCodeGenerator,
["ConfigurationContextFolder"] = configurationContextFolder,
["GetEntityName"] = (Func <IEntityType, string>)GetEntityName,
["GetEntityClassName"] = (Func <IEntityType, string>)GetEntityClassName,
["GetEntityConfigurationName"] = (Func <IEntityType, string>)GetEntityConfigurationName,
}
};
contextGenerator.Initialize();
var generatedCode = contextGenerator.TransformText();
var dbContextFileName = options.ContextName + ".cs";
resultingFiles.ContextFile = new ScaffoldedFile
{
Path = Path.Combine(options.ContextDir, dbContextFileName),
Code = generatedCode
};
var entityPropertyInfos = new Dictionary <EntityPropertyInfo, IProperty>();
foreach (var entityType in model.GetEntityTypes())
{
var entityName = GetEntityName(entityType);
var entityClassName = GetEntityClassName(entityType);
var entityGenerator = new EntityTypeGenerator
{
Session = new Dictionary <string, object>
{
["EntityType"] = entityType,
["ModelNamespace"] = options.ModelNamespace,
["UseDataAnnotations"] = options.UseDataAnnotations,
["Code"] = _csharpHelper,
["EntityName"] = entityName,
["EntityClassName"] = entityClassName,
["GetEntityName"] = (Func <IEntityType, string>)GetEntityName,
["GetEntityClassName"] = (Func <IEntityType, string>)GetEntityClassName,
}
};
entityGenerator.Initialize();
generatedCode = entityGenerator.TransformText();
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile
{
Path = entityClassName + ".cs",
Code = generatedCode
});
var entityConfigurationName = GetEntityConfigurationName(entityType);
var configurationGenerator = new EntityTypeConfigurationGenerator
{
Session = new Dictionary <string, object>
{
["EntityType"] = entityType,
["ContextNamespace"] = options.ContextNamespace,
["ModelNamespace"] = options.ModelNamespace,
["UseDataAnnotations"] = options.UseDataAnnotations,
["Code"] = _csharpHelper,
["AnnotationCode"] = _annotationCodeGenerator,
["ConfigurationNamespace"] = string.Join(".", options.ModelNamespace, configurationContextFolder),
["EntityName"] = entityName,
["EntityClassName"] = entityClassName,
["EntityConfigurationName"] = entityConfigurationName,
}
};
configurationGenerator.Initialize();
generatedCode = configurationGenerator.TransformText();
var configurationContextDir = Path.Combine(options.ContextDir, configurationContextFolder);
var configurationContextDirectory = new DirectoryInfo(configurationContextDir);
if (!configurationContextDirectory.Exists)
{
configurationContextDirectory.Create();
}
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile
{
Path = Path.Combine(configurationContextDir, entityConfigurationName + ".cs"),
Code = generatedCode
});
foreach (var property in entityType.GetProperties())
{
var propertyComment = property.GetComment();
if (string.IsNullOrEmpty(propertyComment))
{
continue;
}
if (!EntityPropertyInfo.TryGetInfo(ref propertyComment, out var entityPropertyInfo))
{
continue;
}
entityPropertyInfos[entityPropertyInfo] = property;
}
}
if (entityPropertyInfos.Any())
{
foreach (var entityEnumInfo in entityPropertyInfos.Select(item => (item.Key.Enum, item.Value))
.Where(item => item.Enum != null && !string.IsNullOrEmpty(item.Enum.Name) && item.Enum.Values?.Any() == true).Distinct())
{
var enumTypeGenerator = new EntityEnumTypeGenerator
{
Session = new Dictionary <string, object>
{
["EntityEnumInfo"] = entityEnumInfo,
["ModelNamespace"] = options.ModelNamespace,
["Code"] = _csharpHelper,
}
};
enumTypeGenerator.Initialize();
generatedCode = enumTypeGenerator.TransformText();
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile
{
Path = entityEnumInfo.Enum.Name + ".cs",
Code = generatedCode
});
}
}
return(resultingFiles);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public override ScaffoldedModel GenerateModel(
IModel model,
ModelCodeGenerationOptions options)
{
if (options.ContextName == null)
{
throw new ArgumentException(
CoreStrings.ArgumentPropertyNull(nameof(options.ContextName), nameof(options)), nameof(options));
}
if (options.ConnectionString == null)
{
throw new ArgumentException(
CoreStrings.ArgumentPropertyNull(nameof(options.ConnectionString), nameof(options)), nameof(options));
}
var generatedCode = CSharpDbContextGenerator.WriteCode(
model,
options.ContextName,
options.ConnectionString,
options.ContextNamespace,
options.ModelNamespace,
options.UseDataAnnotations,
options.UseNullableReferenceTypes,
options.SuppressConnectionStringWarning,
options.SuppressOnConfiguring);
// output DbContext .cs file
var dbContextFileName = options.ContextName + FileExtension;
var resultingFiles = new ScaffoldedModel
{
ContextFile = new ScaffoldedFile
{
Path = options.ContextDir != null
? Path.Combine(options.ContextDir, dbContextFileName)
: dbContextFileName,
Code = generatedCode
}
};
foreach (var entityType in model.GetEntityTypes())
{
if (Internal.CSharpDbContextGenerator.IsManyToManyJoinEntityType(entityType))
{
continue;
}
generatedCode = CSharpEntityTypeGenerator.WriteCode(
entityType,
options.ModelNamespace,
options.UseDataAnnotations,
options.UseNullableReferenceTypes);
// output EntityType poco .cs file
var entityTypeFileName = entityType.Name + FileExtension;
resultingFiles.AdditionalFiles.Add(
new ScaffoldedFile {
Path = entityTypeFileName, Code = generatedCode
});
}
return(resultingFiles);
}
public ScaffoldedModel ScaffoldModel(RoutineModel model, ModuleScaffolderOptions scaffolderOptions, ref List <string> errors)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (errors == null)
{
throw new ArgumentNullException(nameof(errors));
}
if (scaffolderOptions == null)
{
throw new ArgumentNullException(nameof(scaffolderOptions));
}
var result = new ScaffoldedModel();
errors.AddRange(model.Errors);
foreach (var routine in model.Routines.Where(r => !(r is Function f) || !f.IsScalar))
{
int i = 1;
foreach (var resultSet in routine.Results)
{
if (routine.NoResultSet)
{
continue;
}
var suffix = string.Empty;
if (routine.Results.Count > 1)
{
suffix = $"{i++}";
}
var typeName = GenerateIdentifierName(routine, model) + "Result" + suffix;
var classContent = WriteResultClass(resultSet, scaffolderOptions, typeName);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = scaffolderOptions.UseSchemaFolders
? Path.Combine(routine.Schema, $"{typeName}.cs")
: $"{typeName}.cs",
});
}
}
var dbContextInterface = WriteDbContextInterface(scaffolderOptions, model);
if (!string.IsNullOrEmpty(dbContextInterface))
{
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = dbContextInterface,
Path = Path.GetFullPath(Path.Combine(scaffolderOptions.ContextDir, $"I{scaffolderOptions.ContextName}Procedures.cs")),
});
}
var dbContext = WriteDbContext(scaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(scaffolderOptions.ContextDir, scaffolderOptions.ContextName + $"{FileNameSuffix}.cs")),
};
return(result);
}
