public async Task PostAsyncTest(bool expectException)
{
// Arrange
CreateTenantModel tenantModel = new CreateTenantModel(TenantId);
CreateTenantModel result;
if (expectException)
{
this.mockTenantContainer.Setup(x => x.CreateTenantAsync(It.IsAny <string>(), It.IsAny <string>()))
.ThrowsAsync(new Exception());
}
else
{
this.mockTenantContainer.Setup(x => x.CreateTenantAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(tenantModel);
}
try
{
// Act
result = await this.controller.PostAsync();
// Assert
Assert.False(expectException);
}
catch (Exception)
{
Assert.True(expectException);
}
}
public int CreateDay1(CreateTenantModel domainModel)
{
var username = ClaimsPrincipal.Current.Identity.SplitName();
// Create repositories
var tenantRepository = new TenantRepository();
var userAccountRepository = new UserAccountRepository();
var creditCardRepository = new CreditCardRepository();
// Get the User
var user = userAccountRepository.Fetch(username);
// Create the Tenant
var tenantId = tenantRepository.Create(user.UserAccountId, domainModel.Tenant);
// Create the CreditCard
if (!string.IsNullOrEmpty(domainModel.CreditCard.CreditCardNumber))
{
creditCardRepository.Insert(tenantId, domainModel.CreditCard);
}
// Update the User
userAccountRepository.UpdatePesonalDetails(username, domainModel.UserAccount.Firstname, domainModel.UserAccount.Lastname);
return(tenantId);
}
public async Task <Operation <TTenant> > CreateAsync(CreateTenantModel model)
{
var tenant = (TTenant)FormatterServices.GetUninitializedObject(typeof(TTenant));
tenant.Name = model.Name;
tenant.ConcurrencyStamp = model.ConcurrencyStamp ?? $"{Guid.NewGuid()}";
var result = await _tenantManager.CreateAsync(tenant);
return(result.ToOperation(tenant));
}
public async Task <ActionResult <TenantDto> > CreateTenant(CreateTenantModel model)
{
var requestContext = await GetRequestContext();
var command = Mapper.Map <CreateTenantCommand>(model)
.WithRequestContext(requestContext);
var result = await Mediator.Send(command);
return(GetResponse(result));
}
public async Task <IActionResult> Create([FromBody] CreateTenantModel model)
{
if (!ValidModelState(out var error))
{
return(error);
}
var result = await _tenantService.CreateAsync(model);
return(result.Succeeded
? Created($"{_options.Value.RootPath ?? string.Empty}/tenants/{result.Data.Id}", result.Data)
: (IActionResult)BadRequest(result.Errors));
}
public async Task <IActionResult> Create(
[Bind(
nameof(CreateTenantModel.ParentTenantId),
nameof(CreateTenantModel.ConfirmPassword),
nameof(CreateTenantModel.Email),
nameof(CreateTenantModel.LoginDomain),
nameof(CreateTenantModel.Password),
nameof(CreateTenantModel.TenantName)
)]
CreateTenantModel model)
{
if (ModelState.IsValid)
{
var t = new Tenant
{
ParentTenantId = model.ParentTenantId.GetValueOrDefault(TenantId),
LoginDomain = model.LoginDomain,
TenantName = model.TenantName
};
Rdb.Tenants.Add(t);
Rdb.Apps.Add(new App
{
Tenant = t,
AppType = AppTypes.Portal,
AppName = "Portal"
});
await Rdb.SaveChangesAsync();
var role = ApplicationRole.CreateConfigurationMasterRole(t.TenantId);
Rdb.Roles.Add(role);
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, TenantId = t.TenantId, EmailConfirmed = true
};
var result = await UserManager.CreateAsync(user, model.Password);
await Rdb.SaveChangesAsync();
Rdb.UserRoles.Add(new ApplicationUserRole
{
RoleId = role.Id,
UserId = user.Id
});
await Rdb.SaveChangesAsync();
SetToast(AspHelpers.ToastMessages.Saved);
return(RedirectToAction(ActionNames.TenantsList));
}
return(View(ViewNames.TenantEdit, model));
}
public int CreateDay2(CreateTenantModel domainModel)
{
var username = ClaimsPrincipal.Current.Identity.SplitName();
// Create repositories
var tenantRepository = new TenantRepository();
var userAccountRepository = new UserAccountRepository();
// Get the User
var user = userAccountRepository.Fetch(username);
// Create the Tenant
var tenantId = tenantRepository.Create(user.UserAccountId, domainModel.Tenant);
return(tenantId);
}
public IHttpActionResult Post(
[FromBody] CreateTenantModel command)
{
if (command == null || !ModelState.IsValid)
{
return(this.Error().InvalidParameters("Tenant body parameters missing"));
}
var dbProviderConfig = CreateDBProviderConfiguration(command);
var tenant = Tenant.Create(0, command.Name, command.DefaultTheme, dbProviderConfig);
_tenantsRepository.Add(tenant);
_tenantsRepository.SaveChanges();
return(Ok(_mapper.Map <TenantModel>(tenant)));
}
public IHttpActionResult Put(
[FromUri] int id,
[FromBody] CreateTenantModel command)
{
if (command == null || !ModelState.IsValid)
{
return(this.Error().InvalidParameters("Tenant body parameters missing"));
}
if (command.TenantDbProvider == null || command.TenantDbConfiguration == null)
{
return(this.Error().InvalidParameters("Tenant Db information missing"));
}
var tenant = _tenantsRepository.GetById(id);
tenant.Change(command.Name,
command.DefaultTheme,
DatabaseProviderConfiguration.Create(command.TenantDbProvider, command.TenantDbConfiguration));
_tenantsRepository.Update(tenant);
_tenantsRepository.SaveChanges();
var tenantModel = _mapper.Map <TenantModel>(tenant);
return(Ok(tenantModel));
}
private DatabaseProviderConfiguration CreateDBProviderConfiguration(CreateTenantModel command)
=> String.IsNullOrEmpty(command.TenantDbConnectionString)
? DatabaseProviderConfiguration.CreateFromConfiguration(command.TenantDbProvider, command.TenantDbConfiguration)
: DatabaseProviderConfiguration.Create(command.TenantDbProvider, command.TenantDbConnectionString);
