public async Task <Function> CreateAsync(FunctionSubmit functionSubmit, Guid createdByGuid)
{
// Start transactions to allow complete rollback in case of an error
BeginAllTransactions();
try
{
var function = new FunctionModel();
function.Name = functionSubmit.Name;
function.Description = functionSubmit.Description;
function.FunctionPermissions = new List <FunctionPermissionModel>();
function.ChangedBy = createdByGuid;
await CheckForApplicationAndAssignToFunctionIfExists(function, functionSubmit);
await CheckThatPermissionsExistAndAssignToFunction(function, functionSubmit);
// All successful
CommitAllTransactions();
return(mapper.Map <Function>(await functionRepository.CreateAsync(function)));
}
catch (Exception ex)
{
logger.Error(ex);
RollbackAllTransactions();
throw;
}
}
public FunctionController_Tests()
{
functionService = Substitute.For <IFunctionService>();
orderByHelper = Substitute.For <IOrderByHelper>();
paginationHelper = Substitute.For <IPaginationHelper>();
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new FunctionResourceFunctionModelProfile());
});
mapper = config.CreateMapper();
functionModel = new Function()
{
Uuid = Guid.NewGuid(),
Name = "Test Function Name",
Description = "Test Function Description",
ApplicationId = new Guid(),
Permissions = new List <Permission>()
{
new Permission()
{
Uuid = Guid.NewGuid()
},
new Permission()
{
Uuid = Guid.NewGuid()
}
}
};
functionSubmitModel = new FunctionSubmit()
{
Uuid = functionModel.Uuid,
Name = functionModel.Name,
Description = functionModel.Description,
ApplicationId = functionModel.ApplicationId,
Permissions = new List <Guid>()
{
functionModel.Permissions[0].Uuid,
functionModel.Permissions[1].Uuid
}
};
}
public async Task <Function> UpdateAsync(FunctionSubmit functionSubmit, Guid updatedByGuid)
{
// Start transactions to allow complete rollback in case of an error
BeginAllTransactions();
try
{
var function = await functionRepository.GetByIdAsync(functionSubmit.Uuid);
if (function == null)
{
throw new ItemNotFoundException($"Function {functionSubmit.Uuid} not found!");
}
if (function.Name != functionSubmit.Name)
{
// Confirm the new name is available
var checkExistingNameModel = await functionRepository.GetByNameAsync(functionSubmit.Name);
if (checkExistingNameModel != null)
{
throw new ItemNotProcessableException($"Function with name '{functionSubmit.Name}' already exists.");
}
}
function.Name = functionSubmit.Name;
function.Description = functionSubmit.Description;
function.FunctionPermissions = new List <FunctionPermissionModel>();
function.ChangedBy = updatedByGuid;
await CheckForApplicationAndAssignToFunctionIfExists(function, functionSubmit);
await CheckThatPermissionsExistAndAssignToFunction(function, functionSubmit);
// All successful
CommitAllTransactions();
return(mapper.Map <Function>(await functionRepository.UpdateAsync(function)));
}
catch (Exception ex)
{
logger.Error(ex);
RollbackAllTransactions();
throw;
}
}
public async Task <Function> CreateAsync(FunctionSubmit functionSubmit, Guid createdByGuid)
{
// Start transactions to allow complete rollback in case of an error
InitSharedTransaction();
try
{
FunctionModel existingFunction = await functionRepository.GetByNameAsync(functionSubmit.Name);
if (existingFunction != null)
{
throw new ItemNotProcessableException($"Function with Name '{functionSubmit.Name}' already exist.");
}
var function = new FunctionModel
{
Name = functionSubmit.Name,
Description = functionSubmit.Description,
FunctionPermissions = new List <FunctionPermissionModel>(),
ChangedBy = createdByGuid
};
await CheckForApplicationAndAssignToFunctionIfExists(function, functionSubmit);
await CheckForSubRealmAndAssignToFunctionIfExists(function, functionSubmit);
await CheckThatPermissionsExistAndAssignToFunction(function, functionSubmit);
// All successful
CommitTransaction();
return(mapper.Map <Function>(await functionRepository.CreateAsync(function)));
}
catch
{
RollbackTransaction();
throw;
}
}
private async Task CheckThatPermissionsExistAndAssignToFunction(FunctionModel function, FunctionSubmit functionSubmit)
{
if (functionSubmit.Permissions != null && functionSubmit.Permissions.Count > 0)
{
foreach (var permissionId in functionSubmit.Permissions)
{
var permission = await permissionRepository.GetByIdWithApplicationAsync(permissionId);
if (permission == null)
{
throw new ItemNotFoundException($"Permission with UUID: '{permissionId}' not found. Not adding it to function '{functionSubmit.Name}'.");
}
// NB!! Must check that the permission actually attached to an application function where the application is the same as the Funciton
// application. Functions cannot be created from permissions across applications.
if (permission.ApplicationFunctionPermissions.First().ApplicationFunction.Application.Id != functionSubmit.ApplicationId)
{
throw new ItemNotProcessableException($"Permission with UUID: '{permissionId}' does not belong to application with ID: {functionSubmit.ApplicationId}. Not adding it to function '{functionSubmit.Name}'.");
}
PerformSubrealmCheck(function, permission);
function.FunctionPermissions.Add(new FunctionPermissionModel
{
Function = function,
Permission = permission
});
}
}
}
private async Task CheckForApplicationAndAssignToFunctionIfExists(FunctionModel function, FunctionSubmit functionSubmit)
{
var application = await applicationRepository.GetByIdAsync(functionSubmit.ApplicationId);
function.Application = application ?? throw new ItemNotFoundException($"Application with UUID: '{functionSubmit.ApplicationId}' not found. Cannot create function '{functionSubmit.Name}' with this application.");
}
private async Task CheckForSubRealmAndAssignToFunctionIfExists(FunctionModel function, FunctionSubmit functionSubmit)
{
// Recall that submit models with empty GUIDs will not be null but rather Guid.Empty.
if (functionSubmit.SubRealmId == null || functionSubmit.SubRealmId == Guid.Empty)
{
return;
}
var existingSubRealm = await subRealmRepository.GetByIdAsync(functionSubmit.SubRealmId, false);
function.SubRealm = existingSubRealm ?? throw new ItemNotFoundException($"Sub-realm with ID '{functionSubmit.SubRealmId}' does not exist.");
}
public FunctionService_Tests()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new FunctionResourceFunctionModelProfile());
cfg.AddProfile(new PermissionResourcePermisionModelProfile());
});
mapper = config.CreateMapper();
guid = Guid.NewGuid();
var applicationGuid = Guid.NewGuid();
var permissionsGuid = Guid.NewGuid();
mockedFunctionModel = new FunctionModel();
mockedFunctionModel.Id = guid;
mockedFunctionModel.Name = "Test function name";
mockedFunctionModel.Description = "Test description";
mockedFunctionModel.Application = new ApplicationModel
{
Name = "Test Application",
Id = applicationGuid
};
mockedFunctionModel.FunctionPermissions = new List <FunctionPermissionModel>
{
new FunctionPermissionModel
{
Function = mockedFunctionModel,
Permission = new PermissionModel
{
Name = "Test permission",
Description = "Test permissions description",
Id = permissionsGuid,
ApplicationFunctionPermissions = new List <ApplicationFunctionPermissionModel>()
{
new ApplicationFunctionPermissionModel()
{
ApplicationFunctionId = mockedFunctionModel.Application.Id,
PermissionId = permissionsGuid,
ApplicationFunction = new ApplicationFunctionModel()
{
Application = mockedFunctionModel.Application
}
}
}
}
}
};
mockedFunctionSubmitModel = new FunctionSubmit()
{
Uuid = mockedFunctionModel.Id,
Name = mockedFunctionModel.Name,
ApplicationId = mockedFunctionModel.Application.Id,
Permissions = new List <Guid>()
};
foreach (var permission in mockedFunctionModel.FunctionPermissions)
{
mockedFunctionSubmitModel.Permissions.Add(permission.PermissionId);
}
}
public async override Task <IActionResult> UpdateFunctionAsync([FromRoute, Required] Guid functionId, [FromBody] FunctionSubmit functionSubmit)
{
if (functionId == Guid.Empty || functionSubmit.Uuid == Guid.Empty)
{
return(BadRequest());
}
var loggedOnUser = ClaimsHelper.GetScalarClaimValue <Guid>(User, ClaimTypes.NameIdentifier, Guid.Empty);
return(Ok(await functionService.UpdateAsync(functionSubmit, loggedOnUser)));
}
public async override Task <IActionResult> CreateFunctionAsync([FromBody] FunctionSubmit functionSubmit)
{
var loggedOnUser = ClaimsHelper.GetScalarClaimValue <Guid>(User, ClaimTypes.NameIdentifier, Guid.Empty);
return(Ok(await functionService.CreateAsync(functionSubmit, loggedOnUser)));
}
public abstract Task <IActionResult> CreateFunctionAsync([FromBody] FunctionSubmit functionSubmit);
public abstract Task <IActionResult> UpdateFunctionAsync([FromRoute][Required] Guid functionId, [FromBody] FunctionSubmit functionSubmit);
