public static void CreateProject(string solutionDirectory, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.WebApiProjectClassPath(solutionDirectory, projectBaseName);
var fileText = ProjectFileText();
Utilities.CreateFile(classPath, fileText, fileSystem);
}
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 void GetCurrentUserService(string srcDirectory, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.WebApiServicesClassPath(srcDirectory, "CurrentUserService.cs", projectBaseName);
var fileText = GetCurrentUserServiceText(classPath.ClassNamespace);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateTests(string solutionDirectory, Entity entity, string projectBaseName)
{
try
{
var classPath = ClassPathHelper.FeatureTestClassPath(solutionDirectory, $"Patch{entity.Name}CommandTests.cs", entity.Name, 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 = WriteTestFileText(solutionDirectory, classPath, entity, projectBaseName);
fs.Write(Encoding.UTF8.GetBytes(data));
}
}
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 CreateErrorHandlerMiddleware(string solutionDirectory, string projectBaseName, IFileSystem fileSystem)
{
try
{
var classPath = ClassPathHelper.WebApiMiddlewareClassPath(solutionDirectory, $"ErrorHandlerMiddleware.cs", projectBaseName);
if (!fileSystem.Directory.Exists(classPath.ClassDirectory))
{
fileSystem.Directory.CreateDirectory(classPath.ClassDirectory);
}
if (fileSystem.File.Exists(classPath.FullClassPath))
{
throw new FileAlreadyExistsException(classPath.FullClassPath);
}
using (var fs = fileSystem.File.Create(classPath.FullClassPath))
{
var data = "";
data = GetErrorHandlerMiddlewareText(solutionDirectory, projectBaseName, classPath.ClassNamespace);
fs.Write(Encoding.UTF8.GetBytes(data));
}
}
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 CreateEntity(string srcDirectory, Entity entity, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.EntityClassPath(srcDirectory, $"{entity.Name}.cs", entity.Plural, projectBaseName);
var fileText = GetEntityFileText(classPath.ClassNamespace, srcDirectory, entity, projectBaseName);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static string GetEntityFileText(string classNamespace, string srcDirectory, Entity entity, string projectBaseName)
{
var propString = EntityPropBuilder(entity.Properties);
var usingSieve = entity.Properties.Where(e => e.CanFilter || e.CanSort).ToList().Count > 0 ? @$ "{Environment.NewLine}using Sieve.Attributes;" : "";
var tableAnnotation = EntityAnnotationBuilder(entity);
var foreignEntityUsings = "";
var foreignProps = entity.Properties.Where(e => e.IsForeignKey).ToList();
foreach (var entityProperty in foreignProps)
{
var classPath = ClassPathHelper.EntityClassPath(srcDirectory, $"", entityProperty.ForeignEntityPlural, projectBaseName);
foreignEntityUsings += $@"
using {classPath.ClassNamespace};";
}
return(@$ "namespace {classNamespace};
using Newtonsoft.Json;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Runtime.Serialization;{usingSieve}{foreignEntityUsings}
{tableAnnotation}
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 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 void AddBus(Bus template, string srcDirectory, string testDirectory, string projectBaseName, string solutionDirectory, IFileSystem fileSystem)
{
var messagesDirectory = Path.Combine(solutionDirectory, "Messages");
var massTransitPackages = new Dictionary <string, string> {
{ "MassTransit", "7.2.4" },
{ "MassTransit.AspNetCore", "7.2.4" },
{ "MassTransit.Extensions.DependencyInjection", "7.2.4" },
{ "MassTransit.RabbitMQ", "7.2.4" }
};
var webApiClassPath = ClassPathHelper.WebApiProjectClassPath(srcDirectory, projectBaseName);
Utilities.AddPackages(webApiClassPath, massTransitPackages);
WebApiServiceExtensionsBuilder.CreateMassTransitServiceExtension(srcDirectory, projectBaseName, fileSystem);
foreach (var env in template.Environments)
{
WebApiAppSettingsModifier.AddRmq(srcDirectory, env, projectBaseName, fileSystem);
StartupModifier.RegisterMassTransitService(srcDirectory, env.EnvironmentName, projectBaseName);
}
IntegrationTestFixtureModifier.AddMassTransit(testDirectory, projectBaseName);
SolutionBuilder.BuildMessagesProject(solutionDirectory);
Utilities.AddProjectReference(webApiClassPath, @"..\..\..\Messages\Messages.csproj");
}
public static void CreateInfrastructurePersistenceCsProj(string solutionDirectory, string projectBaseName, string dbProvider)
{
try
{
var classPath = ClassPathHelper.InfrastructureProjectClassPath(solutionDirectory, 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 = "";
data = GetInfrastructurePersistenceCsProjFileText(solutionDirectory, projectBaseName, dbProvider);
fs.Write(Encoding.UTF8.GetBytes(data));
}
}
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 CreateTestModels(string projectDirectory, string authServerProjectName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.AuthServerSeederClassPath(projectDirectory, "TestUsers.cs", authServerProjectName);
var fileText = GetTestUserText(classPath.ClassNamespace);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateController(string solutionDirectory, Entity entity, bool AddSwaggerComments)
{
try
{
var classPath = ClassPathHelper.ControllerClassPath(solutionDirectory, $"{Utilities.GetControllerName(entity.Plural)}.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 = GetControllerFileText(classPath.ClassNamespace, entity, AddSwaggerComments);
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;
}
}
public static string GetTestsCsProjFileText(bool addJwtAuth, string solutionDirectory, string projectBaseName)
{
var coreClassPath = ClassPathHelper.CoreProjectClassPath(solutionDirectory, projectBaseName);
var webApiClassPath = ClassPathHelper.WebApiProjectClassPath(solutionDirectory, projectBaseName);
var infraClassPath = ClassPathHelper.InfrastructureProjectClassPath(solutionDirectory, projectBaseName);
var sharedTestClassPath = ClassPathHelper.SharedTestProjectClassPath(solutionDirectory, projectBaseName);
return(@$ "<Project Sdk=" "Microsoft.NET.Sdk" ">
<PropertyGroup>
<TargetFramework>net5.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=" "AutoBogus" " Version=" "2.12.0" " />
<PackageReference Include=" "Bogus" " Version=" "32.0.2" " />
<PackageReference Include=" "Docker.DotNet" " Version=" "3.125.4" " />
<PackageReference Include=" "FluentAssertions" " Version=" "5.10.3" " />
<PackageReference Include=" "Microsoft.AspNetCore.Mvc.Testing" " Version=" "5.0.1" " />
<PackageReference Include=" "MediatR" " Version=" "9.0.0" " />
<PackageReference Include=" "Moq" " Version=" "4.16.1" " />
<PackageReference Include=" "Newtonsoft.Json" " Version=" "12.0.3" " />
<PackageReference Include=" "NUnit" " Version=" "3.12.0" " />
<PackageReference Include=" "NUnit3TestAdapter" " Version=" "3.16.1" " />
<PackageReference Include=" "Microsoft.NET.Test.Sdk" " Version=" "16.8.3" " />
<PackageReference Include=" "Respawn" " Version=" "3.3.0" " />
<PackageReference Include=" "WebMotions.Fake.Authentication.JwtBearer" " Version=" "3.1.0" " />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=" "..\..\src\{coreClassPath.ClassNamespace}\{coreClassPath.ClassName}" " />
public static void CreateTests(string solutionDirectory, string testDirectory, string srcDirectory, Consumer consumer, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.FeatureTestClassPath(testDirectory, $"{consumer.ConsumerName}Tests.cs", "EventHandlers", projectBaseName);
var fileText = WriteTestFileText(solutionDirectory, testDirectory, srcDirectory, classPath, consumer, projectBaseName);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateConfigFile(string projectDirectory, string authServerProjectName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.WebApiHostExtensionsClassPath(projectDirectory, "LoggingConfiguration.cs", authServerProjectName);
var fileText = GetConfigText(classPath.ClassNamespace);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
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 void CreateClass(string solutionDirectory, string projectBaseName, string provider, IFileSystem fileSystem)
{
try
{
var classPath = ClassPathHelper.IntegrationTestUtilitiesClassPath(solutionDirectory, projectBaseName, "DockerDatabaseUtilities.cs");
if (!fileSystem.Directory.Exists(classPath.ClassDirectory))
{
fileSystem.Directory.CreateDirectory(classPath.ClassDirectory);
}
if (fileSystem.File.Exists(classPath.FullClassPath))
{
throw new FileAlreadyExistsException(classPath.FullClassPath);
}
using (var fs = fileSystem.File.Create(classPath.FullClassPath))
{
var data = "";
data = GetBaseText(classPath.ClassNamespace, provider, projectBaseName);
fs.Write(Encoding.UTF8.GetBytes(data));
}
}
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 CreateBaseEntity(string srcDirectory, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.EntityClassPath(srcDirectory, $"BaseEntity.cs", "", projectBaseName);
var fileText = GetBaseEntityFileText(classPath.ClassNamespace);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
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 CreateMessagesCsProj(string solutionDirectory, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.SharedKernelProjectClassPath(solutionDirectory);
var fileText = GetMessagesCsProjFileText();
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateEntity(string solutionDirectory, Entity entity, IFileSystem fileSystem)
{
try
{
var classPath = ClassPathHelper.EntityClassPath(solutionDirectory, $"{entity.Name}.cs");
if (!fileSystem.Directory.Exists(classPath.ClassDirectory))
{
fileSystem.Directory.CreateDirectory(classPath.ClassDirectory);
}
if (fileSystem.File.Exists(classPath.FullClassPath))
{
throw new FileAlreadyExistsException(classPath.FullClassPath);
}
using (var fs = fileSystem.File.Create(classPath.FullClassPath))
{
var data = GetEntityFileText(classPath.ClassNamespace, entity);
fs.Write(Encoding.UTF8.GetBytes(data));
}
GlobalSingleton.AddCreatedFile(classPath.FullClassPath.Replace($"{solutionDirectory}{fileSystem.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 string GetReadParameterDtoText(string solutionDirectory, string classNamespace, Entity entity, Dto dto, string projectBaseName)
{
var sharedDtoClassPath = ClassPathHelper.SharedDtoClassPath(solutionDirectory, "", projectBaseName);
return(@$ "namespace {classNamespace};
using {sharedDtoClassPath.ClassNamespace};
public static void CreateTests(string solutionDirectory, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.UnitTestWrapperTestsClassPath(solutionDirectory, $"CurrentUserServiceTests.cs", projectBaseName);
var fileText = WriteTestFileText(solutionDirectory, classPath, projectBaseName);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateCommand(string solutionDirectory, string srcDirectory, Entity entity, string contextName, string projectBaseName, Feature feature, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.FeaturesClassPath(srcDirectory, $"{feature.Name}.cs", entity.Plural, projectBaseName);
var fileText = GetCommandFileText(classPath.ClassNamespace, entity, contextName, solutionDirectory, srcDirectory, feature, projectBaseName);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateTests(string solutionDirectory, string testDirectory, Entity entity, Feature feature, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.FunctionalTestClassPath(testDirectory, $"{feature.Name}Tests.cs", entity.Name, projectBaseName);
var fileText = WriteTestFileText(solutionDirectory, testDirectory, classPath, entity, feature.IsProtected, feature, projectBaseName);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
public static void CreateDtos(string solutionDirectory, Entity entity)
{
try
{
// ****this class path will have an invalid FullClassPath. just need the directory
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name);
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
CreateDtoFile(solutionDirectory, entity, Dto.Read);
CreateDtoFile(solutionDirectory, entity, Dto.Manipulation);
CreateDtoFile(solutionDirectory, entity, Dto.Creation);
CreateDtoFile(solutionDirectory, entity, Dto.Update);
CreateDtoFile(solutionDirectory, entity, Dto.ReadParamaters);
}
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 WriteTestFileText(string solutionDirectory, string srcDirectory, ClassPath classPath, Entity entity, bool isProtected, Feature feature, string projectBaseName)
{
var dtoUtilClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var testUtilClassPath = ClassPathHelper.FunctionalTestUtilitiesClassPath(srcDirectory, projectBaseName, "");
var fakerClassPath = ClassPathHelper.TestFakesClassPath(srcDirectory, "", entity.Name, projectBaseName);
var parentFakerClassPath = ClassPathHelper.TestFakesClassPath(srcDirectory, "", feature.ParentEntity, projectBaseName);
var permissionsClassPath = ClassPathHelper.PolicyDomainClassPath(srcDirectory, "", projectBaseName);
var rolesClassPath = ClassPathHelper.SharedKernelDomainClassPath(solutionDirectory, "");
var permissionsUsing = isProtected
? $"{Environment.NewLine}using {permissionsClassPath.ClassNamespace};{Environment.NewLine}using {rolesClassPath.ClassNamespace};"
: string.Empty;
var authOnlyTests = isProtected ? $@"
{CreateEntityTestUnauthorized(entity)}
{CreateEntityTestForbidden(entity)}" : "";
return(@$ "namespace {classPath.ClassNamespace};
using {dtoUtilClassPath.ClassNamespace};
using {fakerClassPath.ClassNamespace};
using {parentFakerClassPath.ClassNamespace};
using {testUtilClassPath.ClassNamespace};{permissionsUsing}
using FluentAssertions;
using NUnit.Framework;
using System.Net;
using System.Threading.Tasks;
public static void DeleteEntityWriteTests(string solutionDirectory, Entity entity, string solutionName, string dbContextName)
{
try
{
var classPath = ClassPathHelper.TestRepositoryClassPath(solutionDirectory, $"Delete{entity.Name}RepositoryTests.cs", entity.Name, 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 = DeleteRepositoryTestFileText(classPath, entity, solutionName, dbContextName);
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;
}
}
public static void CreateTests(string solutionDirectory, string testDirectory, string srcDirectory, string projectBaseName, IFileSystem fileSystem)
{
var classPath = ClassPathHelper.UnitTestEntityTestsClassPath(testDirectory, $"RolePermissionTests.cs", "RolePermissions", projectBaseName);
var fileText = WriteTestFileText(solutionDirectory, srcDirectory, classPath, projectBaseName);
Utilities.CreateFile(classPath, fileText, fileSystem);
}
