public void GetProfileFileText_passed_normal_product_entity_creates_expected_text()
{
var classNamespace = "Application.Mappings";
var entity = new FakeEntity().Generate();
entity.Name = "Product";
var fileText = ProfileBuilder.GetProfileFileText(classNamespace, entity);
var expectedText = @"namespace Application.Mappings
{
using Application.Dtos.Product;
using AutoMapper;
using Domain.Entities;
public class ProductProfile : Profile
{
public ProductProfile()
{
//createmap<to this, from this>
CreateMap<Product, ProductDto>()
.ReverseMap();
CreateMap<ProductForCreationDto, Product>();
CreateMap<ProductForUpdateDto, Product>()
.ReverseMap();
}
}
}";
fileText.Should().Be(expectedText);
}
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);
}
private static IEnumerable <User> DefaultUsers(Programme[] programmes)
{
var users = new List <User>();
for (var i = 1; i < 400; i++)
{
var user = generateUser(i, programmes.Where(p => !p.Hidden).ToArray());
user.Id = i;
users.Add(user);
}
CreatePasswordHash(defaultPassword, out var hash, out var salt);
var admin = new User
{
Student = new Student
{
Email = "*****@*****.**",
ProgrammeId = 1000,
Description = "I'm an admin, i dont need your opinion",
FirstName = "Admin",
LastName = "Adminsson",
Private = true,
Searching = false,
ProfilePicture = null,
Url = ProfileBuilder.NewProfileUrl(25)
},
Email = "*****@*****.**",
PasswordHash = hash,
PasswordSalt = salt,
Role = Role.Admin
};
users.Add(admin);
return(users);
}
public static void ScaffoldEntities(string srcDirectory,
string testDirectory,
string projectBaseName,
List <Entity> entities,
string dbContextName,
bool addSwaggerComments,
IFileSystem fileSystem)
{
foreach (var entity in entities)
{
// not worrying about DTOs, profiles, validators, fakers - they are all added by default
EntityBuilder.CreateEntity(srcDirectory, entity, projectBaseName, fileSystem);
DtoBuilder.CreateDtos(srcDirectory, entity, projectBaseName);
ValidatorBuilder.CreateValidators(srcDirectory, projectBaseName, entity);
ProfileBuilder.CreateProfile(srcDirectory, entity, projectBaseName);
ApiRouteModifier.AddRoutes(testDirectory, entity, projectBaseName); // api routes always added to testing by default. too much of a pain to scaffold
if (entity.Features.Count > 0)
{
ControllerBuilder.CreateController(srcDirectory, entity.Name, entity.Plural, projectBaseName);
}
// TODO refactor to factory?
foreach (var feature in entity.Features)
{
AddFeatureToProject(srcDirectory, testDirectory, projectBaseName, dbContextName, addSwaggerComments, feature.Policies, feature, entity, fileSystem);
}
// Shared Tests
FakesBuilder.CreateFakes(testDirectory, projectBaseName, entity);
}
}
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 ScaffoldEntities(string solutionDirectory,
string srcDirectory,
string testDirectory,
string projectBaseName,
List <Entity> entities,
string dbContextName,
bool addSwaggerComments,
bool useSoftDelete,
IFileSystem fileSystem)
{
foreach (var entity in entities)
{
// not worrying about DTOs, profiles, validators, fakers - they are all added by default
EntityBuilder.CreateEntity(solutionDirectory, srcDirectory, entity, projectBaseName, fileSystem);
DtoBuilder.CreateDtos(solutionDirectory, entity, projectBaseName);
ValidatorBuilder.CreateValidators(solutionDirectory, srcDirectory, projectBaseName, entity);
ProfileBuilder.CreateProfile(srcDirectory, entity, projectBaseName);
ApiRouteModifier.AddRoutes(testDirectory, entity, projectBaseName); // api routes always added to testing by default. too much of a pain to scaffold dynamically
var isProtected = entity.Features.Any(f => f.IsProtected); // <-- one more example of why it would be nice to have specific endpoints for each feature 😤
if (entity.Features.Count > 0)
{
ControllerBuilder.CreateController(solutionDirectory, srcDirectory, entity.Name, entity.Plural, projectBaseName, isProtected, fileSystem);
}
// TODO refactor to factory?
foreach (var feature in entity.Features)
{
AddFeatureToProject(solutionDirectory, srcDirectory, testDirectory, projectBaseName, dbContextName, addSwaggerComments, feature, entity, useSoftDelete, fileSystem);
}
// Shared Tests
FakesBuilder.CreateFakes(solutionDirectory, testDirectory, projectBaseName, entity, fileSystem);
}
}
static async Task Main(string[] args)
{
FileReader handler = new FileReader();
HtmlService htmlService = new HtmlService();
Console.WriteLine("Enter full path to file...");
string path = Console.ReadLine();
IEnumerable<string> companies = handler.ReadAllRows(path);
decimal counter = 0;
var itemList = new List<ProfileListItem>();
foreach (var companyName in companies)
{
Thread.Sleep(2000);
var html = await htmlService.GetDocument($"https://www.allabolag.se/what/{companyName}");
try
{
Result<ProfileListItem> item = new ProfileBuilder().Build(new ProfileListItemStrategy(html));
counter++;
Console.Clear();
Console.WriteLine($"{(counter / companies.Count()):P2}");
}
catch (AggregateException)
{
itemList.Add(new ProfileListItem { Header = companyName });
}
}
using (StreamWriter outputFile = new StreamWriter("C:\\Users\\F.Boethius-Fjarem\\source\\repos\\AllaBolag\\AllaBolag.Infrastructure.Tests\\Companies_Output.csv"))
{
outputFile.WriteLine($"Bolagsnamn\tOrg.Nr\tCEO\tTelefon\tAntal Anställda\tOmsättning(tkr)\tBRUTTOVINSTMARGINAL\tVINSTMARGINAL\tKASSALIKVIDITET\tSOLIDITET");
counter = 0;
foreach (ProfileListItem item in itemList.Where(i => !string.IsNullOrEmpty(i.ProfileLink)))
{
counter++;
Console.Clear();
Console.WriteLine($"{counter / itemList.Count:P4}");
try
{
Task<HtmlResult> document = htmlService.GetDocument(item.ProfileLink);
string result = new ProfileBuilder().Build(new ProfileItemStrategy(document.Result)).ToString();
outputFile.WriteLine(result);
}
catch (Exception)
{
outputFile.WriteLine(new ProfileItem { CompanyName = item.Header }.ToString());
}
Thread.Sleep(2000);
}
}
}
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 void LoadXMLValueSets(this ProfileBuilder builder, string filename)
{
XmlDocument document = new XmlDocument();
document.Load(filename);
ProfileReader reader = new ProfileReader();
List <ValueSet> valuesets = reader.ReadValueSets(document);
builder.Add(valuesets);
}
public async Task <string> GetNextProfileListPage()
{
// Là on récupère un dictionnaire en JSON
// puis on transforme avec un builder
string data = await this.TinderAPIClient.GetProfileList();
List <Profile> profiles = ProfileBuilder.BuildList(data);
this.Profiles.AddRange(profiles);
return(data);
}
public GeoLayoutBuildingService(WaypointsService waypointsService, GroupsService groupsService)
{
WaypointBuilder = new SingleWaypointBuilder(waypointsService, groupsService);
ProfileBuilder = new ProfileBuilder(waypointsService, groupsService);
GridBuilder = new GridBuilder(waypointsService, groupsService);
ShiftModifier = new ShiftModifier();
RotateModifier = new RotateModifier();
CropModifier = new CropModifier(waypointsService);
TdmLayoutBuilder = new TdmLayoutBuilder(waypointsService, groupsService);
}
public static void ScaffoldEntities(string srcDirectory,
string testDirectory,
string projectBaseName,
List <Entity> entities,
string dbContextName,
bool addSwaggerComments,
List <Policy> policies,
IFileSystem fileSystem,
Verbosity verbosity)
{
foreach (var entity in entities)
{
EntityBuilder.CreateEntity(srcDirectory, entity, projectBaseName, fileSystem);
DtoBuilder.CreateDtos(srcDirectory, entity, projectBaseName);
ValidatorBuilder.CreateValidators(srcDirectory, projectBaseName, entity);
ProfileBuilder.CreateProfile(srcDirectory, entity, projectBaseName);
QueryGetRecordBuilder.CreateQuery(srcDirectory, entity, dbContextName, projectBaseName);
QueryGetListBuilder.CreateQuery(srcDirectory, entity, dbContextName, projectBaseName);
CommandAddRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName);
CommandDeleteRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName);
CommandUpdateRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName);
CommandPatchRecordBuilder.CreateCommand(srcDirectory, entity, dbContextName, projectBaseName);
ControllerBuilder.CreateController(srcDirectory, entity, addSwaggerComments, policies, projectBaseName);
// Shared Tests
FakesBuilder.CreateFakes(testDirectory, projectBaseName, entity);
// Integration Tests
AddCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName);
DeleteCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName);
PatchCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName);
GetRecordQueryTestBuilder.CreateTests(testDirectory, entity, projectBaseName);
GetListQueryTestBuilder.CreateTests(testDirectory, entity, projectBaseName);
PutCommandTestBuilder.CreateTests(testDirectory, entity, projectBaseName);
// Functional Tests
CreateEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName);
DeleteEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName);
GetEntityRecordTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName);
GetEntityListTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName);
PatchEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName);
PutEntityTestBuilder.CreateTests(testDirectory, entity, policies, projectBaseName);
if (verbosity == Verbosity.More)
{
WriteHelpText($"{projectBaseName} '{entity.Name}' entity was scaffolded successfully.");
}
}
}
/// <summary>
/// To create a profile, you must have the CREATE PROFILE system privilege.
/// To specify resource limits for a user, you must:
/// Enable resource limits dynamically with the ALTER SYSTEM statement
/// or with the initialization parameter RESOURCE_LIMIT.
/// This parameter does not apply to password resources. Password resources are always enabled.
///
/// Create a profile that defines the limits using the CREATE PROFILE statement
/// Assign the profile to the user using the CREATE USER or ALTER USER statement
/// </summary>
private void SaveProfile()
{
Privilege privilege = new Privilege
{
Name = CREATE_PROFILE
};
Boolean rs = this.privilegeBLL.HasSystemPrivilege(this.currentUser.UserName, privilege);
if (rs)
{
ProfileBuilder builder = new ProfileBuilder(this.TxtName.Text);
Profile profile = builder
.SessionsPerUser(this.TxtSessionsPerUser.Text)
.CPUPerSession(this.TxtCPUPerSession.Text)
.CPUPerCall(this.TxtCPUPerCall.Text)
.ConnectTime(this.TxtConnectTime.Text)
.IdleTime(this.TxtIdleTime.Text)
.LogicalReadsPerSession(this.TxtLogicalReadsPerSession.Text)
.LogicalReadsPerCall(this.TxtLogicalReadsPerCall.Text)
.PrivateSGA(this.TxtPrivateSGA.Text)
.CompositeLimit(this.TxtCompositeLimit.Text)
.FailedLoginAttemps(this.TxtFailedLoginAttemps.Text)
.PasswordLifeTime(this.TxtPasswordLifeTime.Text)
.PasswordReuseTime(this.TxtPasswordReuseTime.Text)
.PasswordReuseMax(this.TxtPasswordReuseMax.Text)
.PasswordLockTime(this.TxtPasswordLockTime.Text)
.PasswordGraceTime(this.TxtPasswordGraceTime.Text)
.PasswordVerifyFunction(this.TxtPasswordVerifyFunction.Text)
.Build();
//Case: Update
if (this.profile != null)
{
this.SetEnable(false);
this.profileBLL.Update(profile);
MessageBox.Show(String.Join(" ", "Update profile", profile.Name, "sucessfull!"));
this.SetEnable(true);
}
else
{
this.SetEnable(false);
this.profileBLL.Add(profile);
MessageBox.Show(String.Join(" ", "Add profile", profile.Name, "sucessfull!"));
this.SetEnable(true);
}
this.profile = profile;
}
else
{
MessageBox.Show(String.Join(" ", "You don't have ", CREATE_PROFILE, "privilege!"));
}
}
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);
}
}
protected override Profile LoadProfile()
{
ProfileBuilder builder = new ProfileBuilder();
//profile.Add(ProfileFactory.MetaTypesProfile());
//profile.Add(ProfileFactory.DataTypesProfile());
// profile.Add(ProfileFactory.PrimitiveTypesProfile());
//profile.LoadXMLValueSets("Data\\valuesets.xml");
//profile.LoadXmlFile("Data\\type-HumanName.profile.xml");
//profile.LoadXmlFile("Data\\type-Identifier.profile.xml")
builder.LoadXmlFile("Data\\profile.profile.xml");
return(builder.ToProfile());
}
public void ItShould_return_not_null_contact_object()
{
// arrange
var expected = new Fixture()
.Build <Contact>()
.With(x => x.Phone, "89513423537")
.Create();
var sut = new ProfileBuilder(expected);
// act
// assert
Assert.NotNull(sut);
}
public IActionResult Display(string id)
{
UserAccount targetUser = ProfileBuilder.FromId(id);
UserAccount selfUser = GetCurrentUser();
if (targetUser == null)
{
return(NotFound());
}
if (targetUser.ID == selfUser.ID)
{
return(RedirectToAction("me"));
}
return(View("Display", targetUser));
}
public IActionResult Edit(string id)
{
UserAccount selfUser = ProfileBuilder.FromPrincipal(User);
UserAccount inspectedUser = ProfileBuilder.FromId(id);
if (inspectedUser == null)
{
return(NotFound());
}
if (!selfUser.Permissions.HasFlag(GlobalPermissions.ManageUsers) && selfUser.ID != inspectedUser.ID)
{
return(Forbid());
}
return(View(inspectedUser));
}
protected override Profile LoadProfile()
{
ProfileBuilder builder = new ProfileBuilder();
//profile.Add(ProfileFactory.MetaTypesProfile());
//profile.Add(ProfileFactory.DataTypesProfile());
builder.Add(StructureFactory.PrimitiveTypes());
builder.Add(StructureFactory.NonFhirNamespaces());
builder.LoadXMLValueSets("Data\\valuesets.xml");
builder.LoadXmlFile("Data\\type-Extension.profile.xml");
builder.LoadXmlFile("Data\\type-HumanName.profile.xml");
builder.LoadXmlFile("Data\\type-Identifier.profile.xml");
builder.LoadXmlFile("Data\\type-Narrative.profile.xml");
builder.LoadXmlFile("Data\\patient.profile.xml");
return(builder.ToProfile());
}
private void BtnDelete_Click(object sender, EventArgs e)
{
String name = null;
try
{
name = LvwProfile.SelectedItems?[0]?.Text;
}
catch { }
if (name != null)
{
DialogResult dr = MessageBox.Show("Are you sure?", "Delete", MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Warning);
if (dr == DialogResult.Yes)
{
ProfileBuilder builder = new ProfileBuilder(name);
this.profileBLL.Remove(builder.Build());
MessageBox.Show(String.Join(" ", "Delete profile ", name, "sucessfull!"));
this.LoadAll();
}
}
}
public static User NewUser(string email, string password, string firstname, string lastname, int programmeid,
string role)
{
CreatePasswordHash(password, out var hash, out var salt);
return(new User
{
Email = email,
PasswordHash = hash,
PasswordSalt = salt,
Role = role,
Student = new Student
{
Searching = false,
Private = false,
Description = "Skriv något om dig själv...",
Url = ProfileBuilder.NewProfileUrl(25),
ProgrammeId = programmeid,
FirstName = firstname,
LastName = lastname,
Email = email
}
});
}
public void SetUp()
{
_graph = new PluginGraph();
_builder = new ProfileBuilder(_graph);
}
public void SetUp()
{
_graph = new PluginGraph();
_builder = new ProfileBuilder(_graph);
}
public static void LoadXmlFile(this ProfileBuilder builder, string filename)
{
List <Structure> structures = LoadXmlFile(filename);
builder.Add(structures);
}
private static void RunMicroTemplateBuilders(string solutionDirectory, List <Microservice> microservices, List <Gateway> gateways, IFileSystem fileSystem)
{
// services path
var servicesPath = Path.Combine(solutionDirectory, "services");
fileSystem.Directory.CreateDirectory(servicesPath);
foreach (var micro in microservices)
{
// set micro path
var microPath = Path.Combine(servicesPath, micro.ProjectFolderName);
// add projects
SolutionBuilder.AddMicroServicesProjects(solutionDirectory, microPath, micro.DbContext.Provider, micro.ProjectFolderName, micro.AddJwtAuthentication, fileSystem);
// dbcontext
DbContextBuilder.CreateDbContext(microPath, micro.Entities, micro.DbContext.ContextName, micro.DbContext.Provider, micro.DbContext.DatabaseName);
//entities
foreach (var entity in micro.Entities)
{
EntityBuilder.CreateEntity(microPath, entity, fileSystem);
DtoBuilder.CreateDtos(microPath, entity);
RepositoryBuilder.AddRepository(microPath, entity, micro.DbContext);
ValidatorBuilder.CreateValidators(microPath, entity);
ProfileBuilder.CreateProfile(microPath, entity);
ControllerBuilder.CreateController(microPath, entity, micro.SwaggerConfig.AddSwaggerComments, micro.AuthorizationSettings.Policies);
FakesBuilder.CreateFakes(microPath, micro.ProjectFolderName, entity);
ReadTestBuilder.CreateEntityReadTests(microPath, micro.ProjectFolderName, entity, micro.DbContext.ContextName);
GetTestBuilder.CreateEntityGetTests(microPath, micro.ProjectFolderName, entity, micro.DbContext.ContextName, micro.AuthorizationSettings.Policies);
PostTestBuilder.CreateEntityWriteTests(microPath, entity, micro.ProjectFolderName, micro.AuthorizationSettings.Policies);
UpdateTestBuilder.CreateEntityUpdateTests(microPath, entity, micro.ProjectFolderName, micro.DbContext.ContextName, micro.AuthorizationSettings.Policies);
DeleteIntegrationTestBuilder.CreateEntityDeleteTests(microPath, entity, micro.ProjectFolderName, micro.DbContext.ContextName, micro.AuthorizationSettings.Policies);
DeleteTestBuilder.DeleteEntityWriteTests(microPath, entity, micro.ProjectFolderName, micro.DbContext.ContextName);
WebAppFactoryBuilder.CreateWebAppFactory(microPath, micro.ProjectFolderName, micro.DbContext.ContextName, micro.AddJwtAuthentication);
}
// environments
Utilities.AddStartupEnvironmentsWithServices(
microPath,
micro.ProjectFolderName,
micro.DbContext.DatabaseName,
micro.Environments,
micro.SwaggerConfig,
micro.Port,
micro.AddJwtAuthentication
);
//seeders
SeederBuilder.AddSeeders(microPath, micro.Entities, micro.DbContext.ContextName);
//services
SwaggerBuilder.AddSwagger(microPath, micro.SwaggerConfig, micro.ProjectFolderName, micro.AddJwtAuthentication, micro.AuthorizationSettings.Policies);
if (micro.AddJwtAuthentication)
{
InfrastructureIdentityServiceRegistrationBuilder.CreateInfrastructureIdentityServiceExtension(microPath, micro.AuthorizationSettings.Policies, fileSystem);
}
}
// gateway path
var gatewayPath = Path.Combine(solutionDirectory, "gateways");
fileSystem.Directory.CreateDirectory(gatewayPath);
foreach (var gateway in gateways)
{
SolutionBuilder.AddGatewayProject(solutionDirectory, gatewayPath, gateway.GatewayProjectName, fileSystem);
foreach (var env in gateway.EnvironmentGateways)
{
//TODO: run quality checks that profile name exists, gateway url is a valid path and https, Env Name
if (env.EnvironmentName != "Startup")
{
StartupBuilder.CreateGatewayStartup(gatewayPath, env.EnvironmentName, gateway.GatewayProjectName);
}
GatewayAppSettingsBuilder.CreateAppSettings(gatewayPath, env, gateway.GatewayProjectName, microservices);
GatewayLaunchSettingsModifier.AddProfile(gatewayPath, env, gateway.GatewayProjectName);
}
}
}
public ProfileItemTests()
{
_htmlService = new HtmlService();
_profileBuilder = new ProfileBuilder();
}
/// <summary> /// Returns the currently authenticated user. Returns a guest user if the no one is logged in. /// </summary> public UserAccount GetCurrentUser() => ProfileBuilder.FromPrincipal(User);
public IActionResult Edit(string id, [FromForm, Bind] UserAccount accountChanges, [FromForm] IFormFile avatar, [FromForm] bool clearAvatar)
{
UserAccount targetUser = ProfileBuilder.FromId(id);
UserAccount selfUser = GetCurrentUser();
bool isSelf = targetUser.ID == selfUser.ID;
bool canManageSelf = selfUser.Permissions.HasFlag(GlobalPermissions.ManageSelf);
bool canManageUsers = selfUser.Permissions.HasFlag(GlobalPermissions.ManageUsers);
if (!(isSelf && canManageSelf || canManageUsers))
{
return(Forbid());
}
// Collect the initial model errors
List <string> errorMessages = new List <string>();
if (!ModelState.IsValid)
{
errorMessages = ModelState.Values.SelectMany(value => value.Errors).Select(error => error.ErrorMessage).ToList();
}
// Perform additional validation
if (avatar != null)
{
if (avatar.ContentType != "image/png")
{
errorMessages.Add("You can only use PNG images as avatars.");
}
if (avatar.Length > 4194304)
{
errorMessages.Add("Avatar images can only be 4MB in size.");
}
using (var image = Image.Load(avatar.OpenReadStream()))
{
if (image.Width != image.Height)
{
errorMessages.Add("Avatar images must be in a square (1:1) aspect ratio.");
}
}
}
if (errorMessages.Count > 0)
{
// If validation errors occured, display them on the edit page.
ViewBag.ErrorMessages = errorMessages.ToArray();
return(Edit(id));
}
targetUser.Username = accountChanges.Username;
string userAvatarPath = System.IO.Path.Combine(Environment.WebRootPath, _avatarHelper.GetAbsoluteAvatarUrl(targetUser));
if (avatar != null)
{
using (var localFile = System.IO.File.OpenWrite(userAvatarPath))
using (var uploadedFile = avatar.OpenReadStream())
{
uploadedFile.CopyTo(localFile);
}
}
else
{
if (clearAvatar)
{
System.IO.File.Delete(userAvatarPath);
}
}
if (canManageUsers)
{
if (accountChanges.Permissions != targetUser.Permissions)
{
targetUser.Permissions = accountChanges.Permissions;
}
if (accountChanges.AccountBadge != targetUser.AccountBadge)
{
targetUser.AccountBadge = accountChanges.AccountBadge;
}
}
DatabaseHelpers.Context.UpdateAndSave(targetUser);
return(targetUser.ID == selfUser.ID
? RedirectToAction("me")
: RedirectToAction("display", new { id }));
}
