private static void RunEntityBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem)
{
//entities
foreach (var entity in template.Entities)
{
EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem);
DtoBuilder.CreateDtos(solutionDirectory, entity);
RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext);
ValidatorBuilder.CreateValidators(solutionDirectory, entity);
ProfileBuilder.CreateProfile(solutionDirectory, entity);
ControllerBuilder.CreateController(solutionDirectory, entity, template.SwaggerConfig.AddSwaggerComments);
FakesBuilder.CreateFakes(solutionDirectory, template, entity);
ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template, entity);
GetTestBuilder.CreateEntityGetTests(solutionDirectory, template, entity);
PostTestBuilder.CreateEntityWriteTests(solutionDirectory, template, entity);
UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, template, entity);
DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, template, entity);
}
//seeders & dbsets
SeederModifier.AddSeeders(solutionDirectory, template);
DbContextModifier.AddDbSet(solutionDirectory, template);
}
public static void CreateWebAppFactory(string solutionDirectory, ApiTemplate template, Entity entity)
{
try
{
var classPath = ClassPathHelper.TestWebAppFactoryClassPath(solutionDirectory, $"CustomWebApplicationFactory.cs", template.SolutionName);
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
if (File.Exists(classPath.FullClassPath))
{
File.Delete(classPath.FullClassPath); // saves me from having to make a remover!
}
using (FileStream fs = File.Create(classPath.FullClassPath))
{
var data = GetWebAppFactoryFileText(classPath, template, entity);
fs.Write(Encoding.UTF8.GetBytes(data));
}
GlobalSingleton.AddCreatedFile(classPath.FullClassPath.Replace($"{solutionDirectory}{Path.DirectorySeparatorChar}", ""));
}
catch (FileAlreadyExistsException e)
{
WriteError(e.Message);
throw;
}
catch (Exception e)
{
WriteError($"An unhandled exception occurred when running the API command.\nThe error details are: \n{e.Message}");
throw;
}
}
private static string GetSwaggerServiceExtensionText(ApiTemplate template)
{
var urlLine = "";
if (Uri.TryCreate(template.SwaggerConfig.ApiContact.Url, UriKind.Absolute, out var outUri) && (outUri.Scheme == Uri.UriSchemeHttp || outUri.Scheme == Uri.UriSchemeHttps))
{
urlLine = $@"Url = new Uri(""{ template.SwaggerConfig.ApiContact.Url }""),";
}
var swaggerText = $@"
public static void AddSwaggerExtension(this IServiceCollection services)
{{
services.AddSwaggerGen(config =>
{{
config.SwaggerDoc(""v1"", new OpenApiInfo
{{
Version = ""v1"",
Title = ""{template.SwaggerConfig.Title}"",
Description = ""{template.SwaggerConfig.Description}"",
Contact = new OpenApiContact
{{
Name = ""{template.SwaggerConfig.ApiContact.Name}"",
Email = ""{template.SwaggerConfig.ApiContact.Email}"",
{urlLine}
}}
}});
}});
}}";
var nswagText = @$ "
public static void CreateFakes(string solutionDirectory, ApiTemplate template, Entity entity)
{
try
{
// ****this class path will have an invalid FullClassPath. just need the directory
var classPath = ClassPathHelper.TestFakesClassPath(solutionDirectory, $"", entity.Name, template.SolutionName);
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
CreateFakerFile(solutionDirectory, entity.Name, entity, template);
CreateFakerFile(solutionDirectory, Utilities.GetDtoName(entity.Name, Dto.Creation), entity, template);
CreateFakerFile(solutionDirectory, Utilities.GetDtoName(entity.Name, Dto.Read), entity, template);
CreateFakerFile(solutionDirectory, Utilities.GetDtoName(entity.Name, Dto.Update), entity, template);
}
catch (FileAlreadyExistsException e)
{
WriteError(e.Message);
throw;
}
catch (Exception e)
{
WriteError($"An unhandled exception occurred when running the API command.\nThe error details are: \n{e.Message}");
throw;
}
}
private static string GetAppSettingsText(ApiEnvironment env, string dbName, ApiTemplate template)
{
var jwtSettings = "";
var mailSettings = "";
var serilogSettings = GetSerilogSettings(env.EnvironmentName);
if (template.AuthSetup.AuthMethod == "JWT")
{
jwtSettings = $@"
""JwtSettings"": {{
""Key"": ""{env.JwtSettings.Key}"",
""Issuer"": ""{env.JwtSettings.Issuer}"",
""Audience"": ""{env.JwtSettings.Audience}"",
""DurationInMinutes"": {env.JwtSettings.DurationInMinutes}
}},";
mailSettings = @$ "
" "MailSettings" ": {{
" "EmailFrom" ": " "{env.MailSettings.EmailFrom}" ",
" "SmtpHost" ": " "{env.MailSettings.SmtpHost}" ",
" "SmtpPort" ": " "{env.MailSettings.SmtpPort}" ",
" "SmtpUser" ": " "{env.MailSettings.SmtpUser}" ",
" "SmtpPass" ": " "{env.MailSettings.SmtpPass}" ",
" "DisplayName" ": " "{env.MailSettings.DisplayName}" "
}},";
}
if (env.EnvironmentName == "Development")
{
return(@$ "{{
" "AllowedHosts" ": " "*" ",
" "UseInMemoryDatabase" ": true,
{serilogSettings}{jwtSettings}{mailSettings}
}}
public static void RunSolutionNameAssignedGuard(ApiTemplate template)
{
if (template.SolutionName == null || template.SolutionName.Length <= 0)
{
throw new InvalidSolutionNameException();
}
}
public static void CreateEntityWriteTests(string solutionDirectory, ApiTemplate template, Entity entity)
{
try
{
var classPath = ClassPathHelper.TestRepositoryClassPath(solutionDirectory, $"Create{entity.Name}RepositoryTests.cs", entity.Name, template.SolutionName);
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
if (File.Exists(classPath.FullClassPath))
{
throw new FileAlreadyExistsException(classPath.FullClassPath);
}
using (FileStream fs = File.Create(classPath.FullClassPath))
{
var data = WriteRepositoryTestFileText(classPath, template, entity);
fs.Write(Encoding.UTF8.GetBytes(data));
}
GlobalSingleton.AddCreatedFile(classPath.FullClassPath.Replace($"{solutionDirectory}{Path.DirectorySeparatorChar}", ""));
}
catch (FileAlreadyExistsException e)
{
WriteError(e.Message);
throw;
}
catch (Exception e)
{
WriteError($"An unhandled exception occurred when running the API command.\nThe error details are: \n{e.Message}");
throw;
}
}
private static void CreateNewFoundation(ApiTemplate template, string directory)
{
var newDir = $"{directory}{Path.DirectorySeparatorChar}{template.SolutionName}";
if (Directory.Exists(newDir))
{
throw new DirectoryAlreadyExistsException(newDir);
}
//UninstallFoundation();
//InstallFoundation();
//UpdateFoundation();
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = "dotnet",
Arguments = @$ "new foundation -n {template.SolutionName}",
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = false,
WorkingDirectory = directory
}
};
process.Start();
process.WaitForExit();
}
public static void ScaffoldApi(string buildSolutionDirectory, ApiTemplate template, IFileSystem fileSystem)
{
var projectName = template.ProjectName;
AnsiConsole.Status()
.AutoRefresh(true)
.Spinner(Spinner.Known.Dots2)
.Start($"[yellow]Creating {template.ProjectName} [/]", ctx =>
{
FileParsingHelper.RunPrimaryKeyGuard(template.Entities);
FileParsingHelper.RunSolutionNameAssignedGuard(projectName);
FileParsingHelper.SolutionNameDoesNotEqualEntityGuard(projectName, template.Entities);
// add an accelerate.config.yaml file to the root?
var bcDirectory = $"{buildSolutionDirectory}{Path.DirectorySeparatorChar}{projectName}";
var srcDirectory = Path.Combine(bcDirectory, "src");
var testDirectory = Path.Combine(bcDirectory, "tests");
fileSystem.Directory.CreateDirectory(srcDirectory);
fileSystem.Directory.CreateDirectory(testDirectory);
ctx.Spinner(Spinner.Known.BouncingBar);
ctx.Status($"[bold blue]Building {projectName} Projects [/]");
SolutionBuilder.AddProjects(buildSolutionDirectory, srcDirectory, testDirectory, template.DbContext.Provider, template.DbContext.DatabaseName, projectName, template.AddJwtAuthentication, fileSystem);
// add all files based on the given template config
ctx.Status($"[bold blue]Scaffolding Files for {projectName} [/]");
RunTemplateBuilders(bcDirectory, srcDirectory, testDirectory, template, fileSystem);
WriteLogMessage($"File scaffolding for {template.ProjectName} was successful");
});
}
public static ApiTemplate ReadYaml(string yamlFile)
{
var deserializer = new Deserializer();
ApiTemplate templatefromYaml = deserializer.Deserialize <ApiTemplate>(File.ReadAllText(yamlFile));
return(templatefromYaml);
}
private static void RunEntityBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem)
{
//entities
foreach (var entity in template.Entities)
{
EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem);
DtoBuilder.CreateDtos(solutionDirectory, entity);
RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext);
ValidatorBuilder.CreateValidators(solutionDirectory, entity);
ProfileBuilder.CreateProfile(solutionDirectory, entity);
ControllerBuilder.CreateController(solutionDirectory, entity, template.SwaggerConfig.AddSwaggerComments, template.AuthorizationSettings.Policies);
InfrastructureIdentityServiceRegistrationModifier.AddPolicies(solutionDirectory, template.AuthorizationSettings.Policies);
FakesBuilder.CreateFakes(solutionDirectory, template.SolutionName, entity);
ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template.SolutionName, entity, template.DbContext.ContextName);
GetTestBuilder.CreateEntityGetTests(solutionDirectory, template.SolutionName, entity, template.DbContext.ContextName, template.AuthorizationSettings.Policies);
PostTestBuilder.CreateEntityWriteTests(solutionDirectory, entity, template.SolutionName, template.AuthorizationSettings.Policies);
UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, entity, template.SolutionName, template.DbContext.ContextName, template.AuthorizationSettings.Policies);
DeleteIntegrationTestBuilder.CreateEntityDeleteTests(solutionDirectory, entity, template.SolutionName, template.DbContext.ContextName, template.AuthorizationSettings.Policies);
DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, entity, template.SolutionName, template.DbContext.ContextName);
}
//seeders & dbsets
SeederModifier.AddSeeders(solutionDirectory, template.Entities, template.DbContext.ContextName);
DbContextModifier.AddDbSet(solutionDirectory, template.Entities, template.DbContext.ContextName);
}
public static void RunPrimaryKeyGuard(ApiTemplate template)
{
if (template.Entities.Where(e => e.PrimaryKeyProperty == null).ToList().Count > 0)
{
throw new MissingPrimaryKeyException("One of your entity properties is missing a primary key designation. " +
"Please make sure you have an `IsPrimaryKey: true` option on whichever property you want to be used as your prmary key.");
}
}
public static void AddSwagger(string solutionDirectory, ApiTemplate template)
{
if (!template.SwaggerConfig.IsSameOrEqualTo(new SwaggerConfig()))
{
AddSwaggerServiceExtension(solutionDirectory, template);
AddSwaggerAppExtension(solutionDirectory, template);
}
}
private static ApiTemplate SolutionGuard(string solutionDirectory, ApiTemplate template)
{
var slnName = GetSlnFile(solutionDirectory);
template.SolutionName = Path.GetFileNameWithoutExtension(slnName) ?? throw new SolutionNotFoundException();
return(template);
}
private static string GetSeederContextText(ApiTemplate template)
{
var seeders = "";
foreach (var entity in template.Entities)
{
seeders += @$ "
{Utilities.GetSeederName(entity)}.SeedSample{entity.Name}Data(app.ApplicationServices.GetService<{template.DbContext.ContextName}>());";
private static ApiTemplate GetDbContext(string solutionDirectory, ApiTemplate template)
{
var classPath = ClassPathHelper.DbContextClassPath(solutionDirectory, $"");
var contextClass = Directory.GetFiles(classPath.FullClassPath, "*.cs").FirstOrDefault();
template.DbContext.ContextName = Path.GetFileNameWithoutExtension(contextClass);
return(template);
}
private static void RunTemplateBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem)
{
// dbcontext
DbContextBuilder.CreateDbContext(solutionDirectory, template.Entities, template.DbContext.ContextName, template.DbContext.Provider, template.DbContext.DatabaseName);
//entities
foreach (var entity in template.Entities)
{
EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem);
DtoBuilder.CreateDtos(solutionDirectory, entity);
RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext);
ValidatorBuilder.CreateValidators(solutionDirectory, entity);
ProfileBuilder.CreateProfile(solutionDirectory, entity);
ControllerBuilder.CreateController(solutionDirectory, entity, template.SwaggerConfig.AddSwaggerComments, template.AuthorizationSettings.Policies);
FakesBuilder.CreateFakes(solutionDirectory, template.SolutionName, entity);
ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template.SolutionName, entity, template.DbContext.ContextName);
GetTestBuilder.CreateEntityGetTests(solutionDirectory, template.SolutionName, entity, template.DbContext.ContextName, template.AuthorizationSettings.Policies);
PostTestBuilder.CreateEntityWriteTests(solutionDirectory, entity, template.SolutionName, template.AuthorizationSettings.Policies);
UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, entity, template.SolutionName, template.DbContext.ContextName, template.AuthorizationSettings.Policies);
DeleteIntegrationTestBuilder.CreateEntityDeleteTests(solutionDirectory, entity, template.SolutionName, template.DbContext.ContextName, template.AuthorizationSettings.Policies);
DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, entity, template.SolutionName, template.DbContext.ContextName);
WebAppFactoryBuilder.CreateWebAppFactory(solutionDirectory, template.SolutionName, template.DbContext.ContextName, template.AddJwtAuthentication);
}
// environments
Utilities.AddStartupEnvironmentsWithServices(
solutionDirectory,
template.SolutionName,
template.DbContext.DatabaseName,
template.Environments,
template.SwaggerConfig,
template.Port,
template.AddJwtAuthentication
);
//seeders
SeederBuilder.AddSeeders(solutionDirectory, template.Entities, template.DbContext.ContextName);
//services
SwaggerBuilder.AddSwagger(solutionDirectory, template.SwaggerConfig, template.SolutionName, template.AddJwtAuthentication, template.AuthorizationSettings.Policies);
if (template.AddJwtAuthentication)
{
InfrastructureIdentityServiceRegistrationBuilder.CreateInfrastructureIdentityServiceExtension(solutionDirectory, template.AuthorizationSettings.Policies, fileSystem);
}
//final
ReadmeBuilder.CreateReadme(solutionDirectory, template.SolutionName, fileSystem);
if (template.AddGit)
{
GitSetup(solutionDirectory);
}
}
public static string GetContextFileText(string classNamespace, ApiTemplate template)
{
var nonAuth = @$ "namespace {classNamespace}
{{
using Application.Interfaces;
using Domain.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using System.Threading;
using System.Threading.Tasks;
private static string ReadRepositoryTestFileText(ClassPath classPath, ApiTemplate template, Entity entity)
{
var sortTests = "";
foreach (var prop in entity.Properties.Where(e => e.CanSort && e.Type != "Guid").ToList())
{
sortTests += GetEntitiesListSortedInAscOrder(template, entity, prop);
sortTests += GetEntitiesListSortedInDescOrder(template, entity, prop);
}
return(@$ "
private static string WriteRepositoryTestFileText(ClassPath classPath, ApiTemplate template, Entity entity)
{
var assertString = "";
foreach (var prop in entity.Properties)
{
var newLine = prop == entity.Properties.LastOrDefault() ? "" : $"{Environment.NewLine}";
assertString += @$ " {entity.Name.LowercaseFirstLetter()}ById.{prop.Name}.Should().Be(fake{entity.Name}.{prop.Name});{newLine}";
}
return(@$ "
public static string GetUsingString(ApiTemplate template)
{
var usingString = $@"using (var context = new {template.DbContext.ContextName}(dbOptions))";
if (template.AuthSetup.AuthMethod == "JWT")
{
usingString = $@"using (var context = new {template.DbContext.ContextName}(dbOptions, currentUserService, new DateTimeService()))";
}
return(usingString);
}
private static void AddSwaggerServiceExtension(string solutionDirectory, ApiTemplate template)
{
try
{
var classPath = ClassPathHelper.WebApiExtensionsClassPath(solutionDirectory, $"ServiceExtensions.cs");
if (!Directory.Exists(classPath.ClassDirectory))
{
throw new DirectoryNotFoundException($"The `{classPath.ClassDirectory}` directory could not be found.");
}
if (!File.Exists(classPath.FullClassPath))
{
throw new FileNotFoundException($"The `{classPath.FullClassPath}` file could not be found.");
}
var tempPath = $"{classPath.FullClassPath}temp";
using (var input = File.OpenText(classPath.FullClassPath))
{
using (var output = new StreamWriter(tempPath))
{
string line;
while (null != (line = input.ReadLine()))
{
var newText = $"{line}";
if (line.Contains("#region Swagger Region"))
{
newText += GetSwaggerServiceExtensionText(template);
}
output.WriteLine(newText);
}
}
}
// delete the old file and set the name of the new one to the original name
File.Delete(classPath.FullClassPath);
File.Move(tempPath, classPath.FullClassPath);
GlobalSingleton.AddUpdatedFile(classPath.FullClassPath.Replace($"{solutionDirectory}{Path.DirectorySeparatorChar}", ""));
}
catch (FileAlreadyExistsException e)
{
WriteError(e.Message);
throw;
}
catch (Exception e)
{
WriteError($"An unhandled exception occurred when running the API command.\nThe error details are: \n{e.Message}");
throw;
}
}
public static void ScaffoldApi(string buildSolutionDirectory, ApiTemplate template, IFileSystem fileSystem, Verbosity verbosity)
{
if (verbosity == Verbosity.More)
{
WriteHelpText($"{Environment.NewLine}Creating {template.SolutionName}...");
}
FileParsingHelper.RunPrimaryKeyGuard(template.Entities);
FileParsingHelper.RunSolutionNameAssignedGuard(template.SolutionName);
FileParsingHelper.SolutionNameDoesNotEqualEntityGuard(template.SolutionName, template.Entities);
// scaffold projects
// add an accelerate.config.yaml file to the root?
// solution level stuff
// ***********will add a root directory read from template here for the entire overarching whatever (Koi Katan Operations, LimsLite, ProfiseePlatform)
var solutionDirectory = $"{buildSolutionDirectory}{Path.DirectorySeparatorChar}{template.SolutionName}";
var srcDirectory = Path.Combine(solutionDirectory, "src");
var testDirectory = Path.Combine(solutionDirectory, "tests");
fileSystem.Directory.CreateDirectory(srcDirectory);
fileSystem.Directory.CreateDirectory(testDirectory);
SolutionBuilder.BuildSolution(solutionDirectory, template.SolutionName, fileSystem);
SolutionBuilder.AddProjects(solutionDirectory, srcDirectory, testDirectory, template.DbContext.Provider, template.DbContext.DatabaseName, template.SolutionName, template.AddJwtAuthentication, fileSystem);
if (verbosity == Verbosity.More)
{
WriteHelpText($"{template.SolutionName} projects were scaffolded successfully.");
}
// add all files based on the given template config
RunTemplateBuilders(solutionDirectory, srcDirectory, testDirectory, template, fileSystem, verbosity);
if (verbosity == Verbosity.More)
{
WriteHelpText($"{template.SolutionName} templates were scaffolded successfully.");
}
if (verbosity == Verbosity.More)
{
WriteHelpText($"Starting {template.SolutionName} database migrations.");
}
RunDbMigration(template, srcDirectory);
if (verbosity == Verbosity.More)
{
WriteHelpText($"{template.SolutionName} migrations are complete.");
}
if (verbosity == Verbosity.More)
{
WriteHelpText($"Completed {template.SolutionName}.");
}
}
private static void RunTemplateBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem)
{
// dbcontext
DbContextBuilder.CreateDbContext(solutionDirectory, template);
//entities
foreach (var entity in template.Entities)
{
EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem);
DtoBuilder.CreateDtos(solutionDirectory, entity);
RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext);
ValidatorBuilder.CreateValidators(solutionDirectory, entity);
ProfileBuilder.CreateProfile(solutionDirectory, entity);
ControllerBuilder.CreateController(solutionDirectory, entity);
FakesBuilder.CreateFakes(solutionDirectory, template, entity);
ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template, entity);
GetTestBuilder.CreateEntityGetTests(solutionDirectory, template, entity);
PostTestBuilder.CreateEntityWriteTests(solutionDirectory, template, entity);
UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, template, entity);
DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, template, entity);
WebAppFactoryBuilder.CreateWebAppFactory(solutionDirectory, template, entity);
}
// environments
AddStartupEnvironmentsWithServices(solutionDirectory, template);
//seeders
SeederBuilder.AddSeeders(solutionDirectory, template);
//services
SwaggerBuilder.AddSwagger(solutionDirectory, template);
if (template.AuthSetup.AuthMethod == "JWT")
{
IdentityServicesModifier.SetIdentityOptions(solutionDirectory, template.AuthSetup);
IdentitySeederBuilder.AddSeeders(solutionDirectory, template);
IdentityRoleBuilder.CreateRoles(solutionDirectory, template.AuthSetup.Roles);
RoleSeedBuilder.SeedRoles(solutionDirectory, template);
}
//final
ReadmeBuilder.CreateReadme(solutionDirectory, template, fileSystem);
if (template.AddGit)
{
GitSetup(solutionDirectory);
}
}
private static string GetSwaggerAppExtensionText(ApiTemplate template)
{
var swaggerText = $@"
public static void UseSwaggerExtension(this IApplicationBuilder app)
{{
app.UseSwagger();
app.UseSwaggerUI(c =>
{{
c.SwaggerEndpoint(""{template.SwaggerConfig.SwaggerEndpointUrl}"", ""{template.SwaggerConfig.SwaggerEndpointName}"");
}});
}}";
return(swaggerText);
}
public static string GetUserServiceString(ApiTemplate template)
{
var mockedUserString = "";
if (template.AuthSetup.AuthMethod == "JWT")
{
mockedUserString = $@"
var currentUser = new Mock<ICurrentUserService>();
currentUser.SetupGet(c => c.UserId).Returns(""testuser"");
var currentUserService = currentUser.Object;";
}
return(mockedUserString);
}
private static bool RunDbMigration(ApiTemplate template, string srcDirectory)
{
var webApiProjectClassPath = ClassPathHelper.WebApiProjectClassPath(srcDirectory, template.ProjectName);
return(ExecuteProcess(
"dotnet",
@$ "ef migrations add " "InitialMigration" " --project " "{webApiProjectClassPath.FullClassPath}" "",
srcDirectory,
new Dictionary <string, string>()
{
{ "ASPNETCORE_ENVIRONMENT", Guid.NewGuid().ToString() } // guid to not conflict with any given envs
},
20000,
$"{Emoji.Known.Warning} {template.ProjectName} Database Migrations timed out and will need to be run manually"));
}
public void RunPrimaryKeyGuard_throws_MissingPrimaryKeyException_with_no_pk_flag()
{
var template = new ApiTemplate()
{
Entities = new List <Entity>()
{
new Entity()
{
}
}
};
Action act = () => FileParsingHelper.RunPrimaryKeyGuard(template.Entities);
act.Should().Throw <MissingPrimaryKeyException>();
}
private static void RunDbMigration(ApiTemplate template, string srcDirectory)
{
var webApiProjectClassPath = ClassPathHelper.WebApiProjectClassPath(srcDirectory, template.SolutionName);
var infraProjectClassPath = ClassPathHelper.InfrastructureProjectClassPath(srcDirectory, template.SolutionName);
Utilities.ExecuteProcess(
"dotnet",
@$ "ef migrations add " "InitialMigration" " --project " "{infraProjectClassPath.FullClassPath}" " --startup-project " "{webApiProjectClassPath.FullClassPath}" " --output-dir Migrations",
srcDirectory,
new Dictionary <string, string>()
{
{ "ASPNETCORE_ENVIRONMENT", Guid.NewGuid().ToString() } // guid to not conflict with any given envs
},
20000,
"Db Migrations timed out and will need to be run manually.");
}
private static void RegisterAllSeeders(string solutionDirectory, ApiTemplate template)
{
//TODO move these to a dictionary to lookup and overwrite if I want
var repoTopPath = "WebApi";
var entityDir = Path.Combine(solutionDirectory, repoTopPath);
if (!Directory.Exists(entityDir))
{
throw new DirectoryNotFoundException($"The `{entityDir}` directory could not be found.");
}
var pathString = Path.Combine(entityDir, $"StartupDevelopment.cs");
if (!File.Exists(pathString))
{
throw new FileNotFoundException($"The `{pathString}` file could not be found.");
}
var tempPath = $"{pathString}temp";
using (var input = File.OpenText(pathString))
{
using (var output = new StreamWriter(tempPath))
{
string line;
while (null != (line = input.ReadLine()))
{
var newText = $"{line}";
if (line.Contains("#region Entity Context Region"))
{
newText += @$ "{Environment.NewLine}{GetSeederContextText(template)}";
}
output.WriteLine(newText);
}
}
}
// delete the old file and set the name of the new one to the original name
File.Delete(pathString);
File.Move(tempPath, pathString);
GlobalSingleton.AddUpdatedFile(pathString.Replace($"{solutionDirectory}{Path.DirectorySeparatorChar}", ""));
//WriteWarning($"TODO Need a message for the update of Startup.");
}
