public static string GetStartupText(string solutionDirectory, string classNamespace, string envName, bool useJwtAuth, string projectBaseName)
{
var appAuth = "";
var apiExtensionsClassPath = ClassPathHelper.WebApiExtensionsClassPath(solutionDirectory, "", projectBaseName);
var infraClassPath = ClassPathHelper.InfrastructureProjectClassPath(solutionDirectory, projectBaseName);
var seederClassPath = ClassPathHelper.SeederClassPath(solutionDirectory, "", projectBaseName);
if (useJwtAuth)
{
appAuth = $@"
app.UseAuthentication();
app.UseAuthorization();";
}
var dbContextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
var corsName = $"{projectBaseName}CorsPolicy";
envName = envName == "Production" ? "" : envName;
if (envName == "Development")
{
return(@$ "namespace {classNamespace}
{{
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using {infraClassPath.ClassNamespace};
using {seederClassPath.ClassNamespace};
using {dbContextClassPath.ClassNamespace};
using {apiExtensionsClassPath.ClassNamespace};
using Serilog;
public static string GetCommandFileText(string classNamespace, Entity entity, string contextName, string solutionDirectory, string srcDirectory, string projectBaseName)
{
var className = Utilities.AddEntityFeatureClassName(entity.Name);
var addCommandName = Utilities.CommandAddName(entity.Name);
var readDto = Utilities.GetDtoName(entity.Name, Dto.Read);
var createDto = Utilities.GetDtoName(entity.Name, Dto.Creation);
var manipulationValidator = Utilities.ValidatorNameGenerator(entity.Name, Validator.Manipulation);
var entityName = entity.Name;
var entityNameLowercase = entity.Name.LowercaseFirstLetter();
var primaryKeyPropName = Entity.PrimaryKeyProperty.Name;
var commandProp = $"{entityName}ToAdd";
var newEntityProp = $"{entityNameLowercase}ToAdd";
var entityClassPath = ClassPathHelper.EntityClassPath(srcDirectory, "", entity.Plural, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.ExceptionsClassPath(srcDirectory, "");
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var validatorsClassPath = ClassPathHelper.ValidationClassPath(srcDirectory, "", entity.Plural, projectBaseName);
return(@$ "namespace {classNamespace};
using {entityClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {exceptionsClassPath.ClassNamespace};
using {contextClassPath.ClassNamespace};
using {validatorsClassPath.ClassNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System.Threading;
using System.Threading.Tasks;
public static string GetProducerRegistration(string classNamespace, Producer producer, string srcDirectory, string projectBaseName)
{
var context = Utilities.GetDbContext(srcDirectory, projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var dbReadOnly = producer.UsesDb ? @$ "{Environment.NewLine} private readonly {context} _db;" : "";
var dbProp = producer.UsesDb ? @$ "{context} db, " : "";
var assignDb = producer.UsesDb ? @$ "{Environment.NewLine} _db = db;" : "";
var contextUsing = producer.UsesDb ? $@"
using {contextClassPath.ClassNamespace};" : "";
var commandProp = "SomeContentToPutInMessage";
var commandPropLower = commandProp.LowercaseFirstLetter();
var propTypeToReturn = "bool";
var commandName = $"{producer.ProducerName}Command";
return(@$ "namespace {classNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using MassTransit;
using Messages;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System.Threading;
using System.Threading.Tasks;{contextUsing}
public static string GetCommandFileText(string classNamespace, string contextName, string srcDirectory,
string projectBaseName, Feature newFeature)
{
var featureClassName = newFeature.Name;
var commandName = newFeature.Command;
var returnPropType = newFeature.ResponseType;
var exceptionsClassPath = ClassPathHelper.ExceptionsClassPath(srcDirectory, "", projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var returnValue = GetReturnValue(returnPropType);
var handlerCtor = $@"private readonly {contextName} _db;
private readonly IMapper _mapper;
public Handler({contextName} db, IMapper mapper)
{{
_mapper = mapper;
_db = db;
}}";
return(@$ "namespace {classNamespace};
using {exceptionsClassPath.ClassNamespace};
using {contextClassPath.ClassNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
public static string GetCommandFileText(string classNamespace, Entity entity, string contextName, string srcDirectory, string projectBaseName)
{
var className = Utilities.PatchEntityFeatureClassName(entity.Name);
var patchCommandName = Utilities.CommandPatchName(entity.Name);
var updateDto = Utilities.GetDtoName(entity.Name, Dto.Update);
var manipulationValidator = Utilities.ValidatorNameGenerator(entity.Name, Validator.Manipulation);
var primaryKeyPropType = Entity.PrimaryKeyProperty.Type;
var primaryKeyPropName = Entity.PrimaryKeyProperty.Name;
var entityNameLowercase = entity.Name.LowercaseFirstLetter();
var updatedEntityProp = $"{entityNameLowercase}ToUpdate";
var patchedEntityProp = $"{entityNameLowercase}ToPatch";
var entityClassPath = ClassPathHelper.EntityClassPath(srcDirectory, "", entity.Plural, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(srcDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.ExceptionsClassPath(srcDirectory, "", projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var validatorsClassPath = ClassPathHelper.ValidationClassPath(srcDirectory, "", entity.Plural, projectBaseName);
return(@$ "namespace {classNamespace};
using {entityClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {exceptionsClassPath.ClassNamespace};
using {contextClassPath.ClassNamespace};
using {validatorsClassPath.ClassNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using FluentValidation.Results;
using MediatR;
using Microsoft.AspNetCore.JsonPatch;
using Microsoft.EntityFrameworkCore;
using System.Threading;
using System.Threading.Tasks;
public static string GetQueryFileText(string classNamespace, Entity entity, string contextName, string solutionDirectory, string srcDirectory, string projectBaseName)
{
var className = Utilities.GetEntityFeatureClassName(entity.Name);
var queryRecordName = Utilities.QueryRecordName(entity.Name);
var readDto = Utilities.GetDtoName(entity.Name, Dto.Read);
var primaryKeyPropType = Entity.PrimaryKeyProperty.Type;
var primaryKeyPropName = Entity.PrimaryKeyProperty.Name;
var primaryKeyPropNameLowercase = primaryKeyPropName.LowercaseFirstLetter();
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.ExceptionsClassPath(srcDirectory, "");
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace};
using {dtoClassPath.ClassNamespace};
using {exceptionsClassPath.ClassNamespace};
using {contextClassPath.ClassNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System.Threading;
using System.Threading.Tasks;
public static void CreateDbContext(string solutionDirectory, List <Entity> entities, string dbContextName, string dbProvider, string dbName, string projectBaseName)
{
try
{
var classPath = ClassPathHelper.DbContextClassPath(solutionDirectory, $"{dbContextName}.cs", projectBaseName);
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 = GetContextFileText(classPath.ClassNamespace, entities, dbContextName, solutionDirectory, projectBaseName);
fs.Write(Encoding.UTF8.GetBytes(data));
}
RegisterContext(solutionDirectory, dbProvider, dbContextName, dbName, projectBaseName);
}
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 string GetCommandFileText(string classNamespace, Entity entity, string contextName, string solutionDirectory, string srcDirectory, Feature feature, string projectBaseName)
{
var className = feature.Name;
var addCommandName = feature.Command;
var readDto = Utilities.GetDtoName(entity.Name, Dto.Read);
readDto = $"IEnumerable<{readDto}>";
var createDto = Utilities.GetDtoName(entity.Name, Dto.Creation);
createDto = $"IEnumerable<{createDto}>";
var featurePropNameLowerFirst = feature.BatchPropertyName.LowercaseFirstLetter();
var entityName = entity.Name;
var entityNameLowercase = entity.Name.LowercaseFirstLetter();
var entityNameLowercaseListVar = $"{entity.Name.LowercaseFirstLetter()}List";
var primaryKeyPropName = Entity.PrimaryKeyProperty.Name;
var commandProp = $"{entityName}ListToAdd";
var newEntityProp = $"{entityNameLowercaseListVar}ListToAdd";
var entityClassPath = ClassPathHelper.EntityClassPath(srcDirectory, "", entity.Plural, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.ExceptionsClassPath(srcDirectory, "");
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var validatorsClassPath = ClassPathHelper.ValidationClassPath(srcDirectory, "", entity.Plural, projectBaseName);
var batchFkCheck = !string.IsNullOrEmpty(feature.BatchPropertyDbSetName)
? @$ "var fkEntity = await _db.{feature.BatchPropertyDbSetName}.Where(x => x.Id == request.{feature.BatchPropertyName}).FirstOrDefaultAsync(cancellationToken);
if (fkEntity == null)
throw new NotFoundException($" "No {feature.BatchPropertyName} found with an id of '{{request.{feature.BatchPropertyName}}}'" ");{Environment.NewLine}{Environment.NewLine}"
public static string GetQueryFileText(string classNamespace, Entity entity, string contextName, string solutionDirectory, string projectBaseName)
{
var className = Utilities.GetEntityListFeatureClassName(entity.Name);
var queryListName = Utilities.QueryListName(entity.Name);
var readDto = Utilities.GetDtoName(entity.Name, Dto.Read);
var paramsDto = Utilities.GetDtoName(entity.Name, Dto.ReadParamaters);
var primaryKeyPropName = entity.PrimaryKeyProperty.Name;
var entityClassPath = ClassPathHelper.EntityClassPath(solutionDirectory, "", projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.CoreExceptionClassPath(solutionDirectory, "", projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
var wrapperClassPath = ClassPathHelper.WrappersClassPath(solutionDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace}
{{
using {entityClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {exceptionsClassPath.ClassNamespace};
using {contextClassPath.ClassNamespace};
using {wrapperClassPath.ClassNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using MediatR;
using Sieve.Models;
using Sieve.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
public static string GetCommandFileText(string classNamespace, Entity entity, string contextName, string solutionDirectory, string projectBaseName)
{
var className = Utilities.DeleteEntityFeatureClassName(entity.Name);
var deleteCommandName = Utilities.CommandDeleteName(entity.Name);
var primaryKeyPropType = entity.PrimaryKeyProperty.Type;
var primaryKeyPropName = entity.PrimaryKeyProperty.Name;
var entityNameLowercase = entity.Name.LowercaseFirstLetter();
var entityClassPath = ClassPathHelper.EntityClassPath(solutionDirectory, "", projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.CoreExceptionClassPath(solutionDirectory, "", projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace}
{{
using {entityClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {exceptionsClassPath.ClassNamespace};
using {contextClassPath.ClassNamespace};
using AutoMapper;
using AutoMapper.QueryableExtensions;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
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);
}
public static string GetServiceRegistrationText(string srcDirectory, string projectBaseName, string classNamespace)
{
var dbContextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var utilsClassPath = ClassPathHelper.WebApiResourcesClassPath(srcDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace};
using {dbContextClassPath.ClassNamespace};
using {utilsClassPath.ClassNamespace};
using Microsoft.EntityFrameworkCore;
public static string GetServiceRegistrationText(string solutionDirectory, string projectBaseName, string classNamespace)
{
var dbContextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace}
{{
using {dbContextClassPath.ClassNamespace};
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Sieve.Services;
public static void RemoveDirectory(string solutionDirectory)
{
var classPath = ClassPathHelper.DbContextClassPath(solutionDirectory, ""); // deleting directory, so I don't need to give a meaningful filename
if (!Directory.Exists(classPath.ClassDirectory))
{
throw new DirectoryNotFoundException($"The `{classPath.ClassDirectory}` directory could not be found.");
}
var dir = new DirectoryInfo(classPath.ClassDirectory);
dir.Delete(true);
}
public static void AddDbSet(string solutionDirectory, List <Entity> entities, string dbContextName, string projectBaseName)
{
var classPath = ClassPathHelper.DbContextClassPath(solutionDirectory, $"{dbContextName}.cs", projectBaseName);
var entitiesUsings = "";
foreach (var entity in entities)
{
var entityClassPath = ClassPathHelper.EntityClassPath(solutionDirectory, "", entity.Plural, projectBaseName);
entitiesUsings += $"using {entityClassPath.ClassNamespace};{Environment.NewLine}"; // note this foreach adds newline after where dbbuilder adds before
}
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
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 DbSet Region"))
{
newText += @$ "{Environment.NewLine}{DbContextBuilder.GetDbSetText(entities)}";
}
// TODO add test. assumes that this using exists and that the builder above adds a new line after the usings
if (line.Contains("using Microsoft.EntityFrameworkCore;"))
{
newText = $"{entitiesUsings}{line}";
}
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);
}
public static string GetFixtureText(string classNamespace, string solutionDirectory, string projectBaseName, string dbContextName, string dbName, string provider)
{
var apiClassPath = ClassPathHelper.WebApiProjectClassPath(solutionDirectory, projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
var testUtilsClassPath = ClassPathHelper.IntegrationTestUtilitiesClassPath(solutionDirectory, projectBaseName, "");
var utilsClassPath = ClassPathHelper.WebApiResourcesClassPath(solutionDirectory, "", projectBaseName);
var servicesClassPath = ClassPathHelper.WebApiServicesClassPath(solutionDirectory, "", projectBaseName);
var usingStatement = Enum.GetName(typeof(DbProvider), DbProvider.Postgres) == provider
? $@"
using Npgsql;"
: null;
var checkpoint = Enum.GetName(typeof(DbProvider), DbProvider.Postgres) == provider
? $@"_checkpoint = new Checkpoint
{{
TablesToIgnore = new[] {{ ""__EFMigrationsHistory"" }},
SchemasToExclude = new[] {{ ""information_schema"", ""pg_subscription"", ""pg_catalog"", ""pg_toast"" }},
DbAdapter = DbAdapter.Postgres
}};"
: $@"_checkpoint = new Checkpoint
{{
TablesToIgnore = new[] {{ ""__EFMigrationsHistory"" }},
}};";
var resetString = Enum.GetName(typeof(DbProvider), DbProvider.Postgres) == provider
? $@"using var conn = new NpgsqlConnection(Environment.GetEnvironmentVariable(""DB_CONNECTION_STRING""));
await conn.OpenAsync();
await _checkpoint.Reset(conn);"
: $@"await _checkpoint.Reset(Environment.GetEnvironmentVariable(""DB_CONNECTION_STRING""));";
return(@$ "namespace {classNamespace};
using {contextClassPath.ClassNamespace};
using {testUtilsClassPath.ClassNamespace};
using {apiClassPath.ClassNamespace};
using {utilsClassPath.ClassNamespace};
using {servicesClassPath.ClassNamespace};
using MediatR;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Moq;{usingStatement}
using NUnit.Framework;
using Respawn;
using System.IO;
using System.Security.Claims;
using System.Threading.Tasks;
private static void BuildInfrastructureProject(string solutionDirectory, string projectDirectory, string projectBaseName, string dbProvider, IFileSystem fileSystem)
{
var solutionFolder = projectDirectory.Replace(solutionDirectory, "").Replace(Path.DirectorySeparatorChar.ToString(), "");
var infrastructurePersistenceProjectClassPath = ClassPathHelper.InfrastructureProjectClassPath(projectDirectory, projectBaseName);
InfrastructureCsProjBuilder.CreateInfrastructurePersistenceCsProj(projectDirectory, projectBaseName, dbProvider);
Utilities.ExecuteProcess("dotnet", $@"sln add ""{infrastructurePersistenceProjectClassPath.FullClassPath}"" --solution-folder {solutionFolder}", solutionDirectory);
// base folders
Directory.CreateDirectory(ClassPathHelper.DbContextClassPath(projectDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.SeederClassPath(projectDirectory, "", projectBaseName).ClassDirectory);
InfrastructureServiceRegistrationBuilder.CreateInfrastructureServiceExtension(projectDirectory, projectBaseName, fileSystem);
}
private static void BuildInfrastructurePersistenceProject(string solutionDirectory, string dbProvider, IFileSystem fileSystem)
{
var infrastructurePersistenceProjectClassPath = ClassPathHelper.InfrastructurePersistenceProjectClassPath(solutionDirectory);
InfrastructurePersistenceCsProjBuilder.CreateInfrastructurePersistenceCsProj(solutionDirectory, dbProvider);
Utilities.ExecuteProcess("dotnet", $@"sln add ""{infrastructurePersistenceProjectClassPath.FullClassPath}"" --solution-folder {"Infrastructure"}", solutionDirectory);
// base folders
Directory.CreateDirectory(ClassPathHelper.DbContextClassPath(solutionDirectory, "").ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.RepositoryClassPath(solutionDirectory, "").ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.SeederClassPath(solutionDirectory, "").ClassDirectory);
InfrastructurePersistenceServiceRegistrationBuilder.CreateInfrastructurePersistenceServiceExtension(solutionDirectory, fileSystem);
}
private static string GetPolicyBuilderText(string classNamespace, string solutionDirectory, string srcDirectory, string projectBaseName)
{
var domainPolicyClassPath = ClassPathHelper.PolicyDomainClassPath(srcDirectory, "", projectBaseName);
var rolesClassPath = ClassPathHelper.SharedKernelDomainClassPath(solutionDirectory, "");
var dbContextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "UserPolicyHandler.cs", projectBaseName);
return(@$ "namespace {classNamespace};
using System.Security.Claims;
using {dbContextClassPath.ClassNamespace};
using {rolesClassPath.ClassNamespace};
using {domainPolicyClassPath.ClassNamespace};
using HeimGuard;
using Microsoft.EntityFrameworkCore;
public static string GetBaseText(string classNamespace, string solutionDirectory, string projectBaseName, string dbContextName)
{
var contextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
var apiClassPath = ClassPathHelper.WebApiProjectRootClassPath(solutionDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace};
using {contextClassPath.ClassNamespace};
using {apiClassPath.ClassNamespace};
using MediatR;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using NUnit.Framework;
using System.Threading.Tasks;
public static string GetEntitySeederFileText(string classNamespace, Entity entity, string dbContextName, string solutionDirectory, string projectBaseName)
{
var entitiesClassPath = ClassPathHelper.EntityClassPath(solutionDirectory, "", entity.Plural, projectBaseName);
var dbContextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
if (dbContextName is null)
{
throw new ArgumentNullException(nameof(dbContextName));
}
return(@$ "namespace {classNamespace};
using AutoBogus;
using {entitiesClassPath.ClassNamespace};
using {dbContextClassPath.ClassNamespace};
using System.Linq;
public static string GetDirectOrTopicConsumerRegistration(string classNamespace, Consumer consumer, string srcDirectory, string projectBaseName)
{
var context = Utilities.GetDbContext(srcDirectory, projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName);
var dbReadOnly = consumer.UsesDb ? @$ "{Environment.NewLine} private readonly {context} _db;" : "";
var dbProp = consumer.UsesDb ? @$ "{context} db, " : "";
var assignDb = consumer.UsesDb ? @$ "{Environment.NewLine} _db = db;" : "";
var contextUsing = consumer.UsesDb ? $@"
using {contextClassPath.ClassNamespace};" : "";
return(@$ "namespace {classNamespace};
using AutoMapper;
using MassTransit;
using Messages;
using System.Threading.Tasks;{contextUsing}
public static void CreateDbContext(string srcDirectory,
List <Entity> entities,
string dbContextName,
string dbProvider,
string dbName,
NamingConventionEnum namingConventionEnum,
string projectBaseName,
IFileSystem fileSystem
)
{
var classPath = ClassPathHelper.DbContextClassPath(srcDirectory, $"{dbContextName}.cs", projectBaseName);
var data = GetContextFileText(classPath.ClassNamespace, entities, dbContextName, srcDirectory, projectBaseName);
Utilities.CreateFile(classPath, data, fileSystem);
RegisterContext(srcDirectory, dbProvider, dbContextName, dbName, namingConventionEnum, projectBaseName);
}
private static string GetWebAppFactoryFileText(ClassPath classPath, string dbContextName, string solutionDirectory, string projectBaseName, bool addJwtAuthentication)
{
var webApiClassPath = ClassPathHelper.WebApiProjectRootClassPath(solutionDirectory, "", projectBaseName);
var contextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
var authUsing = addJwtAuthentication ? $@"
using WebMotions.Fake.Authentication.JwtBearer;" : "";
var authRegistration = addJwtAuthentication ? $@"
// add authentication using a fake jwt bearer
services.AddAuthentication(options =>
{{
options.DefaultAuthenticateScheme = FakeJwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = FakeJwtBearerDefaults.AuthenticationScheme;
}}).AddFakeJwtBearer();
" : "";
return(@$ "
public static void AddDbSet(string solutionDirectory, List <Entity> entities, string dbContextName)
{
var classPath = ClassPathHelper.DbContextClassPath(solutionDirectory, $"{dbContextName}.cs");
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
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 DbSet Region"))
{
newText += @$ "{Environment.NewLine}{DbContextBuilder.GetDbSetText(entities)}";
}
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}", ""));
}
private static void BuildWebApiProject(string solutionDirectory, string srcDirectory, string projectBaseName, bool useJwtAuth, string dbProvider, string dbName, IFileSystem fileSystem)
{
var solutionFolder = srcDirectory.GetSolutionFolder(solutionDirectory);
var webApiProjectClassPath = ClassPathHelper.WebApiProjectClassPath(srcDirectory, projectBaseName);
WebApiCsProjBuilder.CreateWebApiCsProj(srcDirectory, projectBaseName, dbProvider);
Utilities.ExecuteProcess("dotnet", $@"sln add ""{webApiProjectClassPath.FullClassPath}"" --solution-folder {solutionFolder}", solutionDirectory);
// base folders
Directory.CreateDirectory(ClassPathHelper.ControllerClassPath(srcDirectory, "", projectBaseName, "v1").ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.WebApiServiceExtensionsClassPath(srcDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.WebApiMiddlewareClassPath(srcDirectory, "", projectBaseName).ClassDirectory);
// additional from what was other projects
Directory.CreateDirectory(ClassPathHelper.DtoClassPath(solutionDirectory, "", "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.ExceptionsClassPath(srcDirectory, "").ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.WrappersClassPath(srcDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.SharedDtoClassPath(solutionDirectory, "").ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.DbContextClassPath(srcDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.DummySeederClassPath(srcDirectory, "", projectBaseName).ClassDirectory);
WebApiServiceExtensionsBuilder.CreateApiVersioningServiceExtension(srcDirectory, projectBaseName, fileSystem);
WebApiServiceExtensionsBuilder.CreateCorsServiceExtension(srcDirectory, projectBaseName, fileSystem);
WebApiServiceExtensionsBuilder.CreateWebApiServiceExtension(srcDirectory, projectBaseName, fileSystem);
ErrorHandlerFilterAttributeBuilder.CreateErrorHandlerFilterAttribute(srcDirectory, projectBaseName, fileSystem);
AppSettingsBuilder.CreateWebApiAppSettings(srcDirectory, dbName, projectBaseName);
WebApiLaunchSettingsBuilder.CreateLaunchSettings(srcDirectory, projectBaseName, fileSystem);
ProgramBuilder.CreateWebApiProgram(srcDirectory, projectBaseName, fileSystem);
StartupBuilder.CreateWebApiStartup(srcDirectory, useJwtAuth, projectBaseName, fileSystem);
LocalConfigBuilder.CreateLocalConfig(srcDirectory, projectBaseName, fileSystem);
LoggingConfigurationBuilder.CreateConfigFile(srcDirectory, projectBaseName, fileSystem);
InfrastructureServiceRegistrationBuilder.CreateInfrastructureServiceExtension(srcDirectory, projectBaseName, fileSystem);
BasePaginationParametersBuilder.CreateBasePaginationParameters(solutionDirectory, projectBaseName, fileSystem);
PagedListBuilder.CreatePagedList(srcDirectory, projectBaseName, fileSystem);
CoreExceptionsBuilder.CreateExceptions(solutionDirectory, projectBaseName, fileSystem);
Utilities.AddProjectReference(webApiProjectClassPath, @"..\..\..\SharedKernel\SharedKernel.csproj");
}
public static void CreateDbContext(string solutionDirectory, ApiTemplate template)
{
try
{
var classPath = ClassPathHelper.DbContextClassPath(solutionDirectory, $"{template.DbContext.ContextName}.cs");
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 = GetContextFileText(classPath.ClassNamespace, template);
fs.Write(Encoding.UTF8.GetBytes(data));
}
RegisterContext(solutionDirectory, template);
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;
}
}
