public async Task <IActionResult> CreateTenantAsyncAndInviteAdmin([FromBody] CreateTenantCmd createTenantCmd)
{
BackofficeWriteContext ctx = new BackofficeWriteContext(
new EFList <Tenant>(_dbContext.Tenant),
new EFList <TenantUser>(_dbContext.TenantUser),
new EFList <User>(_dbContext.User));
var dependencies = new BackofficeDependencies();
dependencies.GenerateInvitationToken = () => Guid.NewGuid().ToString();
dependencies.SendInvitationEmail = SendEmail;
var expr = from createTenantResult in BackofficeDomain.CreateTenant(createTenantCmd)
let adminUser = createTenantResult.SafeCast <CreateTenantResult.TenantCreated>().Select(p => p.AdminUser)
let inviteAdminCmd = new InviteTenantAdminCmd(adminUser)
from inviteAdminResult in BackofficeDomain.InviteTenantAdmin(inviteAdminCmd)
select new { createTenantResult, inviteAdminResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.SaveChanges();
return(r.createTenantResult.Match(
created => (IActionResult)Ok(created.Tenant.TenantId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Tenant could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateTenantAsyncAndInviteAdmin([FromBody] CreateTenantCmd createTenantCmd)
{
BackofficeWriteContext ctx = new BackofficeWriteContext(new List <Tenant>(), new List <TenantUser>(), new List <User>());
var dependencies = new BackofficeDependencies();
dependencies.GenerateInvitationToken = () => Guid.NewGuid().ToString();
dependencies.SendInvitationEmail = (InvitationLetter letter) => async() => new InvitationAcknowledgement(Guid.NewGuid().ToString());
var expr = from createTenantResult in BackofficeDomain.CreateTenant(createTenantCmd)
let adminUser = createTenantResult.SafeCast <CreateTenantResult.TenantCreated>().Select(p => p.AdminUser)
let inviteAdminCmd = new InviteTenantAdminCmd(adminUser)
from inviteAdminResult in BackofficeDomain.InviteTenantAdmin(inviteAdminCmd)
select new { createTenantResult, inviteAdminResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
_dbContext.Tenant.Add(new EF.Models.Tenant {
RowGuid = Guid.NewGuid(), OrganisationId = createTenantCmd.OrganisationId, Name = createTenantCmd.TenantName, Description = createTenantCmd.Description
});
//var reply = await _dbContext.QuestionModel.Where(r => r.Title == "intrebTest").SingleOrDefaultAsync();
//_dbContext.Question.Update(reply);
await _dbContext.SaveChangesAsync();
return(r.createTenantResult.Match(
created => (IActionResult)Ok(created.Tenant.TenantId),
notCreated => BadRequest("Tenant could not be created."),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateTenantAsyncAndInviteAdmin([FromBody] CreateTenantCmd createTenantCmd)
{
BackofficeWriteContext ctx = new BackofficeWriteContext(new List <Tenant>(), new List <TenantUser>(), new List <User>());
/* BackofficeWriteContext ctx = new BackofficeWriteContext(
* new EFList<Tenant>(_dbContext.Tenant),
* new EFList<TenantUser>(_dbContext.TenantUser),
* new EFList<User>(_dbContext.User));*/
var dependencies = new BackofficeDependencies();
dependencies.GenerateInvitationToken = () => Guid.NewGuid().ToString();
dependencies.SendInvitationEmail = (InvitationLetter letter) => async() => new InvitationAcknowledgement(Guid.NewGuid().ToString());
var expr = from createTenantResult in BackofficeDomain.CreateTenant(createTenantCmd)
let adminUser = createTenantResult.SafeCast <CreateTenantResult.TenantCreated>().Select(p => p.AdminUser)
let inviteAdminCmd = new InviteTenantAdminCmd(adminUser)
from inviteAdminResult in BackofficeDomain.InviteTenantAdmin(inviteAdminCmd)
select new { createTenantResult, inviteAdminResult };
var r = await _interpreter.Interpret(expr, ctx, dependencies);
return(r.createTenantResult.Match(
created => (IActionResult)Ok(created.Tenant.TenantId),
notCreated => BadRequest("Tenant could not be created."),
invalidRequest => BadRequest("Invalid request.")));
}
public async Task <IActionResult> CreateTenantAsyncAndInviteAdmin([FromBody] CreateTenantCmd createTenantCmd)
{
BackofficeWriteContext ctx = new BackofficeWriteContext(
new EFList <Tenant>(_dbContext.Tenant),
new EFList <User>(_dbContext.User));
var r = await _interpreter.Interpret(expr, dependencies);
_dbContext.SaveChanges();
return(r.createTenantResult.Match(
created => (IActionResult)Ok(created.Tenant.TenantId),
notCreated => StatusCode(StatusCodes.Status500InternalServerError, "Tenant could not be created."),//todo return 500 (),
invalidRequest => BadRequest("Invalid request.")));
}
public override async Task OnActivateAsync()
{
_dbContext = await _interpreter.Interpret(_dbContextFactory, Unit.Default);
_ctx = await _dbContext.LoadAsync("base.BackofficeGrain", new object(), async reader =>
{
var tenants = await reader.ReadAsync <Tenant>();
var tenantUsers = await reader.ReadAsync <TenantUser>();
var users = await reader.ReadAsync <User>();
_dbContext.AttachRange(tenants);
_dbContext.AttachRange(tenantUsers);
_dbContext.AttachRange(users);
return(new BackofficeWriteContext(
new EFList <Tenant>(_dbContext.Tenant),
new EFList <TenantUser>(_dbContext.TenantUser),
new EFList <User>(_dbContext.User)));
});
}
public override Task PostConditions(InviteTenantAdminCmd cmd, InviteTenantAdminResult.IInviteTenantAdminResult result, BackofficeWriteContext state)
{
result.Match(
invited =>
{
Assert.True(true);
Assert.True(cmd.ValidateObject());
return(invited);
},
notInvited =>
{
Assert.True(false);
return(notInvited);
},
invalidRequest =>
{
Assert.True(false);
Assert.False(cmd.ValidateObject());
return(invalidRequest);
}
);
return(Task.CompletedTask);
}
private Task OnInvalidInput(InviteTenantAdminCmd cmd, InviteTenantAdminResult.IInviteTenantAdminResult result, BackofficeWriteContext state)
{
result.Match(
invited =>
{
Assert.True(cmd.ValidateObject(), "The command is expected to be invalid");
Assert.True(false, "Somethin went wrong when creating the tenant");
return(invited);
},
notInvited =>
{
Assert.True(false, "Received 'NotInvited', expected InvalidRequest");
return(notInvited);
},
invalidRequest =>
{
Assert.True(true);
Assert.False(cmd.ValidateObject(), "The command should be invalid");
return(invalidRequest);
}
);
return(Task.CompletedTask);
}
private Task AssertionsOnInput(InviteTenantAdminCmdInput inputCase, BackofficeWriteContextInput stateCase, BackofficeWriteContext state, InviteTenantAdminCmd cmd, InviteTenantAdminResult.IInviteTenantAdminResult result)
{
var _ = (inputCase, stateCase) switch
{
(InviteTenantAdminCmdInput.Valid, _) => PostConditions(cmd, result, state),
_ => OnInvalidInput(cmd, result, state)
};
return(Task.CompletedTask);
}
public override Task Assertions(object[] path, InviteTenantAdminCmd cmd, InviteTenantAdminResult.IInviteTenantAdminResult result, BackofficeWriteContext state)
{
var withInput = from inputCase in path.OfType <InviteTenantAdminCmdInput>().HeadOrNone()
from stateCase in path.OfType <BackofficeWriteContextInput>().HeadOrNone()
select AssertionsOnInput(inputCase, stateCase, state, cmd, result);
return(Task.CompletedTask);
}
public override Task PostConditions(CreateTenantCmd op, CreateTenantResult.ICreateTenantResult result, BackofficeWriteContext state)
{
result.Match(created =>
{
Assert.True(true);
Assert.True(op.ValidateObject());
Assert.Contains(state.Tenants, tenant => tenant.OrganisationId.Equals(op.OrganisationId));
return(created);
}, notCreated =>
{
Assert.True(false);
Assert.DoesNotContain(state.Tenants, tenant => tenant.OrganisationId.Equals(op.OrganisationId));
return(notCreated);
},
invalidRequest =>
{
Assert.False(op.ValidateObject());
Assert.True(false);
return(invalidRequest);
});
return(Task.CompletedTask);
}
public Task OnInvalidInput(CreateTenantCmd op, CreateTenantResult.ICreateTenantResult result, BackofficeWriteContext state)
{
result.Match(created =>
{
Assert.True(op.ValidateObject(), "The command is expected to be invalid");
Assert.True(false, "We shouldn't create a tenant with invalid input");
return(created);
},
notCreated =>
{
Assert.True(false, "Received 'NotCreated', expected InvalidRequest");
return(notCreated);
}, invalidRequest =>
{
Assert.True(true);
Assert.False(op.ValidateObject(), "The command should be invalid");
return(invalidRequest);
});
return(Task.CompletedTask);
}
private Task AssertionsOnInput(CreateTenantCmdInput inputCase, BackofficeWriteContextInput stateCase, BackofficeWriteContext state, CreateTenantCmd op, CreateTenantResult.ICreateTenantResult result)
{
var _ = (inputCase, stateCase) switch
{
(CreateTenantCmdInput.Valid, BackofficeWriteContextInput.Empty) => PostConditions(op, result, state),
(CreateTenantCmdInput.Valid, BackofficeWriteContextInput.Nulls) => PostConditions(op, result, state),
_ => OnInvalidInput(op, result, state)
};
return(Task.CompletedTask);
}
