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;
}
}
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}"
private static string WriteTestFileText(string solutionDirectory, string testDirectory, string srcDirectory, ClassPath classPath, string projectBaseName)
{
var testFixtureName = Utilities.GetIntegrationTestFixtureName();
var servicesClassPath = ClassPathHelper.WebApiServicesClassPath(srcDirectory, "", projectBaseName);
var policyDomainClassPath = ClassPathHelper.PolicyDomainClassPath(srcDirectory, "", projectBaseName);
var entityClassPath = ClassPathHelper.EntityClassPath(testDirectory, "", "RolePermissions", projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", "RolePermission", projectBaseName);
var rolesClassPath = ClassPathHelper.SharedKernelDomainClassPath(solutionDirectory, "");
return(@$ "namespace {classPath.ClassNamespace};
using {servicesClassPath.ClassNamespace};
using {policyDomainClassPath.ClassNamespace};
using {entityClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {rolesClassPath.ClassNamespace};
using Bogus;
using FluentAssertions;
using HeimGuard;
using Microsoft.AspNetCore.Http;
using Moq;
using NUnit.Framework;
using System.Threading.Tasks;
using System.Security.Claims;
using static {testFixtureName};
private static string WriteTestFileText(string solutionDirectory, string testDirectory, string srcDirectory, ClassPath classPath, Entity entity, Feature feature, string projectBaseName)
{
var featureName = Utilities.AddEntityFeatureClassName(entity.Name);
var testFixtureName = Utilities.GetIntegrationTestFixtureName();
var commandName = feature.Command;
var testUtilClassPath = ClassPathHelper.IntegrationTestUtilitiesClassPath(testDirectory, projectBaseName, "");
var dtoUtilClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var exceptionsClassPath = ClassPathHelper.ExceptionsClassPath(testDirectory, "");
var fakerClassPath = ClassPathHelper.TestFakesClassPath(testDirectory, "", entity.Name, projectBaseName);
var parentFakerClassPath = ClassPathHelper.TestFakesClassPath(testDirectory, "", feature.ParentEntity, projectBaseName);
var featuresClassPath = ClassPathHelper.FeaturesClassPath(srcDirectory, featureName, entity.Plural, projectBaseName);
var foreignEntityUsings = Utilities.GetForeignEntityUsings(testDirectory, entity, projectBaseName);
return(@$ "namespace {classPath.ClassNamespace};
using {dtoUtilClassPath.ClassNamespace};
using {fakerClassPath.ClassNamespace};
using {parentFakerClassPath.ClassNamespace};
using {testUtilClassPath.ClassNamespace};
using {featuresClassPath.ClassNamespace};
using {exceptionsClassPath.ClassNamespace};
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System.Threading.Tasks;
using static {testFixtureName};{foreignEntityUsings}
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 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;
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;
private static string WriteTestFileText(string solutionDirectory, string testDirectory, string srcDirectory, ClassPath classPath, Entity entity, string projectBaseName)
{
var featureName = Utilities.UpdateEntityFeatureClassName(entity.Name);
var testFixtureName = Utilities.GetIntegrationTestFixtureName();
var commandName = Utilities.CommandUpdateName(entity.Name);
var fakeEntity = Utilities.FakerName(entity.Name);
var fakeUpdateDto = Utilities.FakerName(Utilities.GetDtoName(entity.Name, Dto.Update));
var fakeCreationDto = Utilities.FakerName(Utilities.GetDtoName(entity.Name, Dto.Creation));
var updateDto = Utilities.GetDtoName(entity.Name, Dto.Update);
var fakeEntityVariableName = $"fake{entity.Name}One";
var lowercaseEntityName = entity.Name.LowercaseFirstLetter();
var lowercaseEntityPluralName = entity.Plural.LowercaseFirstLetter();
var pkName = Entity.PrimaryKeyProperty.Name;
var lowercaseEntityPk = pkName.LowercaseFirstLetter();
var testUtilClassPath = ClassPathHelper.IntegrationTestUtilitiesClassPath(testDirectory, projectBaseName, "");
var fakerClassPath = ClassPathHelper.TestFakesClassPath(testDirectory, "", entity.Name, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var featuresClassPath = ClassPathHelper.FeaturesClassPath(srcDirectory, featureName, entity.Plural, projectBaseName);
var fakeParent = Utilities.FakeParentTestHelpers(entity, out var fakeParentIdRuleFor);
var foreignEntityUsings = Utilities.GetForeignEntityUsings(testDirectory, entity, projectBaseName);
return(@$ "namespace {classPath.ClassNamespace};
using {fakerClassPath.ClassNamespace};
using {testUtilClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System.Threading.Tasks;
using Microsoft.AspNetCore.JsonPatch;
using {featuresClassPath.ClassNamespace};
using static {testFixtureName};{foreignEntityUsings}
private static string WriteTestFileText(string solutionDirectory, ClassPath classPath, Entity entity, string projectBaseName)
{
var featureName = Utilities.GetEntityListFeatureClassName(entity.Name);
var testFixtureName = Utilities.GetIntegrationTestFixtureName();
var fakerClassPath = ClassPathHelper.TestFakesClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var featuresClassPath = ClassPathHelper.FeaturesClassPath(solutionDirectory, featureName, entity.Plural, projectBaseName);
var sortTests = "";
var filterTests = "";
foreach (var prop in entity.Properties.Where(e => e.CanSort && e.Type != "Guid").ToList())
{
sortTests += GetEntitiesListSortedInAscOrder(entity, prop);
sortTests += GetEntitiesListSortedInDescOrder(entity, prop);
}
foreach (var prop in entity.Properties.Where(e => e.CanFilter).ToList())
{
filterTests += GetEntitiesListFiltered(entity, prop);
}
return(@$ "namespace {classPath.ClassNamespace}
{{
using {dtoClassPath.ClassNamespace};
using {fakerClassPath.ClassNamespace};
using FluentAssertions;
using NUnit.Framework;
using System;
using System.Linq;
using System.Threading.Tasks;
using static {featuresClassPath.ClassNamespace}.{featureName};
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;
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 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 GetCreationValidatorFileText(string solutionDirectory, string projectBaseName, string classNamespace, Entity entity)
{
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
return(@$ "namespace {classNamespace}
{{
using {dtoClassPath.ClassNamespace};
using FluentValidation;
private static void UpdateDtoFile(string solutionDirectory, string entityName, List <EntityProperty> props, Dto dto)
{
var dtoFileName = $"{Utilities.GetDtoName(entityName, dto)}.cs";
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, dtoFileName, entityName);
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;
var fkUsingStatements = "";
if (dto == Dto.Read)
{
foreach (var prop in props)
{
if (prop.IsForeignKey)
{
fkUsingStatements += DtoFileTextGenerator.GetForeignKeyUsingStatements(classPath, fkUsingStatements, prop, dto);
}
}
}
while (null != (line = input.ReadLine()))
{
var newText = $"{line}";
if (line.Contains($"add-on property marker"))
{
newText += @$ "{Environment.NewLine}{Environment.NewLine}{DtoFileTextGenerator.DtoPropBuilder(props, dto)}";
}
if (line.Contains("using System;"))
{
newText += fkUsingStatements;
}
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}", ""));
}
public static string GetProfileFileText(string classNamespace, Entity entity, string solutionDirectory, string projectBaseName)
{
var entitiesClassPath = ClassPathHelper.EntityClassPath(solutionDirectory, "", projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
return(@$ "namespace {classNamespace}
{{
using {dtoClassPath.ClassNamespace};
using AutoMapper;
using {entitiesClassPath.ClassNamespace};
private static string GetFakeFileText(string classNamespace, string objectToFakeClassName, Entity entity, string solutionDirectory, string testDirectory, string projectBaseName)
{
var entitiesClassPath = ClassPathHelper.EntityClassPath(testDirectory, "", entity.Plural, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
// this... is super fragile. Should really refactor this
var usingStatement = objectToFakeClassName.Contains("DTO", StringComparison.InvariantCultureIgnoreCase) ? @$ "using {dtoClassPath.ClassNamespace};" : $"using {entitiesClassPath.ClassNamespace};";
return(@$ "namespace {classNamespace};
using AutoBogus;
{usingStatement}
public static void RemoveDirectory(string solutionDirectory, string entityName)
{
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entityName); // 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 RemoveDtos(string solutionDirectory)
{
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", "Auth");
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 string GetControllerFileText(string classNamespace, string entityName, string entityPlural, string solutionDirectory, string srcDirectory, string projectBaseName, bool usesJwtAuth)
{
// TODO create an attribute factory that can order them how i want and work more dynamically
var endpointBase = Utilities.EndpointBaseGenerator(entityPlural);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entityName, projectBaseName);
var wrapperClassPath = ClassPathHelper.WrappersClassPath(srcDirectory, "", projectBaseName);
var featureClassPath = ClassPathHelper.FeaturesClassPath(srcDirectory, "", entityPlural, projectBaseName);
var permissionsClassPath = ClassPathHelper.PolicyDomainClassPath(srcDirectory, "", projectBaseName);
var rolesClassPath = ClassPathHelper.SharedKernelDomainClassPath(solutionDirectory, "");
var permissionsUsing = usesJwtAuth
? @$ "{Environment.NewLine}using {permissionsClassPath.ClassNamespace};
using {rolesClassPath.ClassNamespace};"
public static string GetControllerFileText(string classNamespace, Entity entity, bool AddSwaggerComments, List <Policy> policies, string solutionDirectory, string projectBaseName)
{
var lowercaseEntityVariable = entity.Name.LowercaseFirstLetter();
var entityName = entity.Name;
var entityNamePlural = entity.Plural;
var readDto = Utilities.GetDtoName(entityName, Dto.Read);
var readParamDto = Utilities.GetDtoName(entityName, Dto.ReadParamaters);
var creationDto = Utilities.GetDtoName(entityName, Dto.Creation);
var updateDto = Utilities.GetDtoName(entityName, Dto.Update);
var primaryKeyProp = entity.PrimaryKeyProperty;
var queryListMethodName = Utilities.QueryListName(entityName);
var queryRecordMethodName = Utilities.QueryRecordName(entityName);
var addRecordCommandMethodName = Utilities.CommandAddName(entityName);
var deleteRecordCommandMethodName = Utilities.CommandDeleteName(entityName);
var updateRecordCommandMethodName = Utilities.CommandUpdateName(entityName);
var patchRecordCommandMethodName = Utilities.CommandPatchName(entityName);
var pkPropertyType = primaryKeyProp.Type;
var listResponse = $@"Response<IEnumerable<{readDto}>>";
var singleResponse = $@"Response<{readDto}>";
var getListEndpointName = entity.Name == entity.Plural ? $@"Get{entityNamePlural}List" : $@"Get{entityNamePlural}";
var getRecordEndpointName = entity.Name == entity.Plural ? $@"Get{entityNamePlural}Record" : $@"Get{entity.Name}";
var endpointBase = Utilities.EndpointBaseGenerator(entityNamePlural);
var getListAuthorizations = BuildAuthorizations(policies, Endpoint.GetList, entity.Name);
var getRecordAuthorizations = BuildAuthorizations(policies, Endpoint.GetRecord, entity.Name);
var addRecordAuthorizations = BuildAuthorizations(policies, Endpoint.AddRecord, entity.Name);
var updateRecordAuthorizations = BuildAuthorizations(policies, Endpoint.UpdateRecord, entity.Name);
var updatePartialAuthorizations = BuildAuthorizations(policies, Endpoint.UpdatePartial, entity.Name);
var deleteRecordAuthorizations = BuildAuthorizations(policies, Endpoint.DeleteRecord, entity.Name);
var idParam = $@"{lowercaseEntityVariable}Id";
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entityName, projectBaseName);
var wrapperClassPath = ClassPathHelper.WrappersClassPath(solutionDirectory, "", projectBaseName);
var featureClassPath = ClassPathHelper.FeaturesClassPath(solutionDirectory, "", entity.Plural, projectBaseName);
return(@$ "namespace {classNamespace}
{{
using System;
using System.Collections.Generic;
using System.Text.Json;
using Microsoft.AspNetCore.JsonPatch;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
using System.Threading.Tasks;
using {dtoClassPath.ClassNamespace};
using {wrapperClassPath.ClassNamespace};
using System.Threading;
using MediatR;
using static {featureClassPath.ClassNamespace}.{Utilities.GetEntityListFeatureClassName(entity.Name)};
public static void CreateDtos(string solutionDirectory, Entity entity, string projectBaseName)
{
// ****this class path will have an invalid FullClassPath. just need the directory
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
if (!Directory.Exists(classPath.ClassDirectory))
{
Directory.CreateDirectory(classPath.ClassDirectory);
}
CreateDtoFile(solutionDirectory, entity, Dto.Read, projectBaseName);
CreateDtoFile(solutionDirectory, entity, Dto.Manipulation, projectBaseName);
CreateDtoFile(solutionDirectory, entity, Dto.Creation, projectBaseName);
CreateDtoFile(solutionDirectory, entity, Dto.Update, projectBaseName);
CreateDtoFile(solutionDirectory, entity, Dto.ReadParamaters, projectBaseName);
}
public static void CreateDtoFile(string solutionDirectory, Entity entity, Dto dto, string projectBaseName)
{
var dtoFileName = $"{Utilities.GetDtoName(entity.Name, dto)}.cs";
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, dtoFileName, entity.Name, projectBaseName);
if (File.Exists(classPath.FullClassPath))
{
throw new FileAlreadyExistsException(classPath.FullClassPath);
}
using (FileStream fs = File.Create(classPath.FullClassPath))
{
var data = GetDtoFileText(solutionDirectory, classPath, entity, dto, projectBaseName);
fs.Write(Encoding.UTF8.GetBytes(data));
}
}
private static string WriteTestFileText(string solutionDirectory, ClassPath classPath, Entity entity, string projectBaseName)
{
var featureName = Utilities.PatchEntityFeatureClassName(entity.Name);
var testFixtureName = Utilities.GetIntegrationTestFixtureName();
var commandName = Utilities.CommandPatchName(entity.Name);
var fakeEntity = Utilities.FakerName(entity.Name);
var updateDto = Utilities.GetDtoName(entity.Name, Dto.Update);
var fakeEntityVariableName = $"fake{entity.Name}One";
var lowercaseEntityName = entity.Name.LowercaseFirstLetter();
var lowercaseEntityPluralName = entity.Plural.LowercaseFirstLetter();
var pkName = entity.PrimaryKeyProperty.Name;
var lowercaseEntityPk = pkName.LowercaseFirstLetter();
var testUtilClassPath = ClassPathHelper.IntegrationTestUtilitiesClassPath(solutionDirectory, projectBaseName, "");
var fakerClassPath = ClassPathHelper.TestFakesClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var featuresClassPath = ClassPathHelper.FeaturesClassPath(solutionDirectory, featureName, entity.Plural, projectBaseName);
var myProp = entity.Properties.Where(e => e.Type == "string" && e.CanManipulate).FirstOrDefault();
var lookupVal = $@"""Easily Identified Value For Test""";
// if no string properties, do one with an int
if (myProp == null)
{
myProp = entity.Properties.Where(e => e.Type.Contains("int") && e.CanManipulate).FirstOrDefault();
lookupVal = "999999";
}
if (myProp == null)
{
return("// no patch tests were created");
}
return(@$ "namespace {classPath.ClassNamespace}
{{
using {fakerClassPath.ClassNamespace};
using {testUtilClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System.Threading.Tasks;
using Microsoft.AspNetCore.JsonPatch;
using System.Linq;
using static {featuresClassPath.ClassNamespace}.{featureName};
private static string WriteTestFileText(string solutionDirectory, string srcDirectory, ClassPath classPath, string projectBaseName)
{
var wrapperClassPath = ClassPathHelper.WrappersClassPath(srcDirectory, "", projectBaseName);
var domainPolicyClassPath = ClassPathHelper.PolicyDomainClassPath(srcDirectory, "", projectBaseName);
var entityClassPath = ClassPathHelper.EntityClassPath(srcDirectory, "", "RolePermissions", projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", "RolePermission", projectBaseName);
var rolesClassPath = ClassPathHelper.SharedKernelDomainClassPath(solutionDirectory, "");
return(@$ "namespace {classPath.ClassNamespace};
using {domainPolicyClassPath.ClassNamespace};
using {entityClassPath.ClassNamespace};
using {wrapperClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {rolesClassPath.ClassNamespace};
using Bogus;
using FluentAssertions;
using NUnit.Framework;
public static void CreateDtoFile(string solutionDirectory, Entity entity, Dto dto)
{
var dtoFileName = $"{Utilities.GetDtoName(entity.Name, dto)}.cs";
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, dtoFileName, entity.Name);
if (File.Exists(classPath.FullClassPath))
{
throw new FileAlreadyExistsException(classPath.FullClassPath);
}
using (FileStream fs = File.Create(classPath.FullClassPath))
{
var data = GetDtoFileText(classPath, entity, dto);
fs.Write(Encoding.UTF8.GetBytes(data));
GlobalSingleton.AddCreatedFile(classPath.FullClassPath.Replace($"{solutionDirectory}{Path.DirectorySeparatorChar}", ""));
}
}
public static string GetEntitySeederFileText(string classNamespace, Entity entity, string dbContextName, string solutionDirectory, string projectBaseName)
{
var entitiesClassPath = ClassPathHelper.EntityClassPath(solutionDirectory, "", entity.Plural, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var dbContextClassPath = ClassPathHelper.DbContextClassPath(solutionDirectory, "", projectBaseName);
var entityForCreationDto = $"{Utilities.GetDtoName(entity.Name, Dto.Creation)}";
if (dbContextName is null)
{
throw new ArgumentNullException(nameof(dbContextName));
}
return(@$ "namespace {classNamespace};
using AutoBogus;
using {entitiesClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {dbContextClassPath.ClassNamespace};
using System.Linq;
private static string WriteTestFileText(string solutionDirectory, string testDirectory, string srcDirectory, ClassPath classPath, Entity entity, string projectBaseName)
{
var featureName = Utilities.PatchEntityFeatureClassName(entity.Name);
var testFixtureName = Utilities.GetIntegrationTestFixtureName();
var commandName = Utilities.CommandPatchName(entity.Name);
var testUtilClassPath = ClassPathHelper.IntegrationTestUtilitiesClassPath(testDirectory, projectBaseName, "");
var fakerClassPath = ClassPathHelper.TestFakesClassPath(testDirectory, "", entity.Name, projectBaseName);
var exceptionClassPath = ClassPathHelper.ExceptionsClassPath(testDirectory, "");
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var featuresClassPath = ClassPathHelper.FeaturesClassPath(srcDirectory, featureName, entity.Plural, projectBaseName);
var myProp = entity.Properties.Where(e => e.Type == "string" && e.CanManipulate).FirstOrDefault();
var lookupVal = $@"""Easily Identified Value For Test""";
// if no string properties, do one with an int
if (myProp == null)
{
myProp = entity.Properties.Where(e => e.Type.Contains("int") && e.CanManipulate).FirstOrDefault();
lookupVal = "999999";
}
if (myProp == null)
{
return("// no patch tests were created");
}
var foreignEntityUsings = Utilities.GetForeignEntityUsings(testDirectory, entity, projectBaseName);
return(@$ "namespace {classPath.ClassNamespace};
using {fakerClassPath.ClassNamespace};
using {testUtilClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {exceptionClassPath.ClassNamespace};
using {featuresClassPath.ClassNamespace};
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System.Threading.Tasks;
using Microsoft.AspNetCore.JsonPatch;
using static {testFixtureName};{foreignEntityUsings}
private static void BuildCoreProject(string solutionDirectory, string projectDirectory, string projectBaseName, IFileSystem fileSystem)
{
var solutionFolder = projectDirectory.Replace(solutionDirectory, "").Replace(Path.DirectorySeparatorChar.ToString(), "");
var coreProjectClassPath = ClassPathHelper.CoreProjectClassPath(projectDirectory, projectBaseName);
CoreCsProjBuilder.CreateCoreCsProj(projectDirectory, projectBaseName);
Utilities.ExecuteProcess("dotnet", $@"sln add ""{coreProjectClassPath.FullClassPath}"" --solution-folder {solutionFolder}", solutionDirectory);
// dir won't show up in project until file is added
Directory.CreateDirectory(ClassPathHelper.EntityClassPath(projectDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.DtoClassPath(projectDirectory, "", "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.CoreExceptionClassPath(projectDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.WrappersClassPath(projectDirectory, "", projectBaseName).ClassDirectory);
Directory.CreateDirectory(ClassPathHelper.SharedDtoClassPath(projectDirectory, "", projectBaseName).ClassDirectory);
BasePaginationParametersBuilder.CreateBasePaginationParameters(projectDirectory, projectBaseName, fileSystem);
PagedListBuilder.CreatePagedList(projectDirectory, projectBaseName, fileSystem);
ResponseBuilder.CreateResponse(projectDirectory, projectBaseName, fileSystem);
CoreExceptionsBuilder.CreateExceptions(projectDirectory, projectBaseName);
}
private static string WriteTestFileText(string solutionDirectory, ClassPath classPath, Entity entity, List <Policy> policies, string projectBaseName)
{
var testUtilClassPath = ClassPathHelper.FunctionalTestUtilitiesClassPath(solutionDirectory, projectBaseName, "");
var fakerClassPath = ClassPathHelper.TestFakesClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var dtoClassPath = ClassPathHelper.DtoClassPath(solutionDirectory, "", entity.Name, projectBaseName);
var hasRestrictedEndpoints = policies.Count > 0;
var authOnlyTests = hasRestrictedEndpoints ? $@"
{EntityTestUnauthorized(entity)}
{EntityTestForbidden(entity)}" : "";
return(@$ "namespace {classPath.ClassNamespace};
using {fakerClassPath.ClassNamespace};
using {dtoClassPath.ClassNamespace};
using {testUtilClassPath.ClassNamespace};
using Microsoft.AspNetCore.JsonPatch;
using FluentAssertions;
using NUnit.Framework;
using System.Net;
using System.Threading.Tasks;
private static void UpdateDtoFile(string solutionDirectory, string entityName, List <EntityProperty> props, Dto dto, string projectBaseName)
{
var dtoFileName = $"{Utilities.GetDtoName(entityName, dto)}.cs";
var classPath = ClassPathHelper.DtoClassPath(solutionDirectory, dtoFileName, entityName, projectBaseName);
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($"add-on property marker"))
{
newText += @$ "{Environment.NewLine}{Environment.NewLine}{DtoFileTextGenerator.DtoPropBuilder(props, dto)}";
}
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);
}
