private async Task UploadPhotoAsync(GoverningBodyDTO governingBody)
{
var oldImageName = (await _repoWrapper.GoverningBody.GetFirstOrDefaultAsync(i => i.ID == governingBody.Id))?.Logo;
var logoBase64 = governingBody.Logo;
if (!string.IsNullOrWhiteSpace(logoBase64) && logoBase64.Length > 0)
{
var logoBase64Parts = logoBase64.Split(',');
var extension = logoBase64Parts[0].Split(new[] { '/', ';' }, 3)[1];
if (!string.IsNullOrEmpty(extension))
{
extension = (extension[0] == '.' ? "" : ".") + extension;
}
var fileName = $"{_uniqueId.GetUniqueId()}{extension}";
await _governingBodyBlobStorage.UploadBlobForBase64Async(logoBase64Parts[1], fileName);
governingBody.Logo = fileName;
}
if (!string.IsNullOrEmpty(oldImageName))
{
await _governingBodyBlobStorage.DeleteBlobAsync(oldImageName);
}
}
public async Task <int> EditAsync(GoverningBodyDTO governingBody)
{
await UploadPhotoAsync(governingBody);
var createdGoveringBody = await CreateGoverningBodyAsync(governingBody);
_repoWrapper.GoverningBody.Attach(createdGoveringBody);
_repoWrapper.GoverningBody.Update(createdGoveringBody);
await _repoWrapper.SaveAsync();
return(createdGoveringBody.ID);
}
public async Task <IActionResult> Edit(GoverningBodyDTO governingBody)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _governingBodiesService.EditAsync(governingBody);
_logger.LogInformation($"Governing body {{{governingBody.GoverningBodyName}}} was edited.");
return(Ok());
}
public async Task <IActionResult> Create(GoverningBodyDTO governingBodyDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
governingBodyDTO.Id = await _governingBodiesService.CreateAsync(governingBodyDTO);
_logger.LogInformation($"Governing body {{{governingBodyDTO.GoverningBodyName}}} was created.");
return(Ok(governingBodyDTO.Id));
}
public async Task <int> CreateAsync(GoverningBodyDTO governingBodyDto)
{
await UploadPhotoAsync(governingBodyDto);
var governingBody = await CreateGoverningBodyAsync(governingBodyDto);
_repoWrapper.GoverningBody.Attach(governingBody);
await _repoWrapper.GoverningBody.CreateAsync(governingBody);
await _repoWrapper.SaveAsync();
return(governingBody.ID);
}
public async Task GetDecisionOrganizationAsyncWithRightParameterTest()
{
_decisionService = CreateDecisionService();
GoverningBodyDTO organization = GetTestOrganizationDtoList()[0];
_repository.Setup(rep => rep.GoverningBody.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <Organization, bool> > >(),
It.IsAny <Func <IQueryable <Organization>, IIncludableQueryable <Organization, object> > >())).ReturnsAsync(new Organization()
{
OrganizationName = organization.GoverningBodyName
});
var actualReturn = await _decisionService.GetDecisionOrganizationAsync(organization);
Assert.Equal(organization.GoverningBodyName, actualReturn.GoverningBodyName);
}
public async Task GetDecisionOrganizationAsyncWithEmptyOrNullParameterTest(string organizationName)
{
//Arrange
GoverningBodyDTO governingBody = GetTestOrganizationDtoList()[0];
governingBody.GoverningBodyName = organizationName;
_repository.Setup(rep => rep.GoverningBody.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <Organization, bool> > >(),
It.IsAny <Func <IQueryable <Organization>, IIncludableQueryable <Organization, object> > >())).ReturnsAsync(new Organization()
{
ID = governingBody.Id
});
//Act
var actualReturn = await _decisionService.GetDecisionOrganizationAsync(governingBody);
//Assert
Assert.AreEqual(governingBody.Id, actualReturn.Id);
}
public async Task GetDecisionOrganizationAsyncWithRightParameterTest()
{
//Arrange
GoverningBodyDTO organization = GetTestOrganizationDtoList()[0];
_repository.Setup(rep => rep.GoverningBody.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <Organization, bool> > >(),
It.IsAny <Func <IQueryable <Organization>, IIncludableQueryable <Organization, object> > >()))
.ReturnsAsync(new Organization()
{
OrganizationName = organization.GoverningBodyName
});
_mapper
.Setup(x => x.Map <GoverningBodyDTO>(It.IsAny <string>()))
.Returns(new GoverningBodyDTO()
{
GoverningBodyName = organization.GoverningBodyName
});
//Act
var actualReturn = await _service.GetMethodicDocumentOrganizationAsync(organization);
//Assert
Assert.AreEqual(organization.GoverningBodyName, actualReturn.GoverningBodyName);
}
private Task <Organization> CreateGoverningBodyAsync(GoverningBodyDTO governingBody)
{
return(Task.FromResult(_mapper.Map <GoverningBodyDTO, Organization>(governingBody)));
}
public async Task <GoverningBodyDTO> GetMethodicDocumentOrganizationAsync(GoverningBodyDTO governingBody)
{
return(_mapper.Map <GoverningBodyDTO>(string.IsNullOrEmpty(governingBody.GoverningBodyName)
? await _repoWrapper.GoverningBody.GetFirstAsync(x => x.ID == governingBody.Id)
: await _repoWrapper.GoverningBody.GetFirstAsync(x => x.OrganizationName.Equals(governingBody.GoverningBodyName))));
}
