/// <summary>
/// Business object for updating existing facility configuration
/// </summary>
/// <param name="facilityConfiguration"></param>
/// <returns></returns>
public async Task <BusinessResponse> UpdateFacilityConfigAsync(TransactionQueueConfigurationRequest facilityConfiguration)
{
if (facilityConfiguration == null || facilityConfiguration.FacilityKey == Guid.Empty)
{
var message = new BusinessResponse()
{
IsSuccess = false, Message = BusinessError.InvalidInput
};
return(message);
}
var facilityData = await GetFacilityConfigurationAsync(facilityConfiguration.FacilityKey);
if (facilityData != null)
{
_mapper.Map(facilityConfiguration, facilityData, typeof(TransactionQueueConfigurationRequest), typeof(FacilityLogisticsConfig));
_repository.Update(facilityData);
await _unitOfWork.CommitChangesAsync();
var result = new BusinessResponse()
{
IsSuccess = true, Message = BusinessResponseMessages.LogisticsConfigurationUpdated
};
return(result);
}
else
{
var message = new BusinessResponse()
{
IsSuccess = false, Message = BusinessError.RecordNotFound
};
return(message);
}
}
public void FacilitySpecificConfigurationLogic_UpdateFacilityConfigAsync_ShouldReturnBusinessResponseWithIsSuccess()
{
//Arrange
TransactionQueueConfigurationRequest facilityExtensions = new TransactionQueueConfigurationRequest()
{
FacilityKey = Guid.Parse("f37613a6-2bb9-4282-845e-1c6100dd3f6c")
};
//Act
FacilityLogisticsConfig facilitykeyNotExist = new FacilityLogisticsConfig();
_mockFacilitySpecificConfigurationRepository.Setup(r => r.GetAsync(It.IsAny <Guid>())).ReturnsAsync(facilitykeyNotExist);
_mockFacilitySpecificConfigurationRepository.Setup(f => f.Update(It.IsAny <FacilityLogisticsConfig>())).Verifiable();
_unitOfWorkMock.Setup(u => u.CommitChangesAsync()).ReturnsAsync(1);
var result = _facilitySpecificConfigurationLogic.UpdateFacilityConfigAsync(facilityExtensions).Result;
//Assert
Assert.NotNull(result);
Assert.True(result.IsSuccess);
Assert.Equal(BusinessResponseMessages.LogisticsConfigurationUpdated, result.Message);
_mockFacilitySpecificConfigurationRepository.Verify(f => f.Update(It.IsAny <FacilityLogisticsConfig>()), Times.Once);
_unitOfWorkMock.Verify(w => w.CommitChangesAsync(), Times.Once);
}
public void FacilitySpecificConfigurationLogic_CreateFacilitySpecificConfigurationAsync_ShouldThrowArgumentNulExceptionOnNullInput()
{
//Arrange
TransactionQueueConfigurationRequest transactionQueueConfigurationRequest = null;
//Act
Assert.ThrowsAsync <ArgumentNullException>(() => _facilitySpecificConfigurationLogic.CreateFacilitySpecificConfigurationAsync(transactionQueueConfigurationRequest));
//Assert
}
public void FacilitySpecificConfigurationLogic_UpdateFacilityConfigAsync_ShouldBusinessResponseWithIsSuccessFalseOnNullParameter()
{
//Arrange
TransactionQueueConfigurationRequest facilityExtensions = null;
//Act
var result = _facilitySpecificConfigurationLogic.UpdateFacilityConfigAsync(facilityExtensions).Result;
//Assert
Assert.NotNull(result);
Assert.False(result.IsSuccess);
}
/// <summary>
/// CreateFacilitySpecificConfigurationAsync
/// </summary>
/// <param name="facilityConfiguration"></param>
/// <returns></returns>
public async Task CreateFacilitySpecificConfigurationAsync(TransactionQueueConfigurationRequest facilityConfiguration)
{
if (facilityConfiguration == null || facilityConfiguration.FacilityKey == Guid.Empty)
{
throw new ArgumentNullException();
}
var model = _mapper.Map <FacilityLogisticsConfig>(facilityConfiguration);
PopulateAuditData(model);
_repository.Add(model);
await _unitOfWork.CommitChangesAsync();
}
public void FacilitySpecificConfigurationLogic_UpdateFacilityConfigAsync_ShouldReturnBusinessResponseWithIsSuccessFalseWhenFacilityNotExists()
{
//Arrange
TransactionQueueConfigurationRequest facilityExtensions = new TransactionQueueConfigurationRequest()
{
FacilityKey = Guid.Parse("f37613a6-2bb9-4282-845e-1c6100dd3f6c")
};
//Act
FacilityLogisticsConfig facilitykeyNotExist = null;
_mockFacilitySpecificConfigurationRepository.Setup(r => r.GetAsync(It.IsAny <Guid>())).ReturnsAsync(facilitykeyNotExist);
var result = _facilitySpecificConfigurationLogic.UpdateFacilityConfigAsync(facilityExtensions).Result;
//Assert
Assert.NotNull(result);
Assert.False(result.IsSuccess);
Assert.Equal(BusinessError.RecordNotFound, result.Message);
}
public async Task FacilitySpecificConfigurationLogic_CreateFacilitySpecificConfigurationAsync_ShouldAddAndCommitRecordOnProperInput()
{
_unitOfWorkMock.Setup(u => u.CommitChangesAsync()).ReturnsAsync(1);
Guid facilityKey = Guid.Parse("BEC05D78-2F6C-4034-8FB9-ACE3417F83E8");
Guid tenantKey = Guid.Parse("7ecfe81c-cfbe-42c1-8158-047c899fb862");
SiteConfiguration.API.FacilityConfiguration.Models.FacilityLogisticsConfig existingfacilitySpecificConfiguration = null;
_mockFacilitySpecificConfigurationRepository.Setup(f => f.GetAsync(facilityKey)).ReturnsAsync(existingfacilitySpecificConfiguration);
_mockFacilitySpecificConfigurationRepository.Setup(f => f.Add(It.IsAny <SiteConfiguration.API.FacilityConfiguration.Models.FacilityLogisticsConfig>())).Verifiable();
TransactionQueueConfigurationRequest facilitySpecificConfigurationToBeAdded = new TransactionQueueConfigurationRequest()
{
FacilityKey = facilityKey
};
await _facilitySpecificConfigurationLogic.CreateFacilitySpecificConfigurationAsync(facilitySpecificConfigurationToBeAdded);
// Assert
_mockFacilitySpecificConfigurationRepository.Verify(f => f.Add(It.IsAny <SiteConfiguration.API.FacilityConfiguration.Models.FacilityLogisticsConfig>()), Times.Once);
_unitOfWorkMock.Verify(w => w.CommitChangesAsync(), Times.Once);
}
public async Task<ActionResult<TransactionQueueConfigurationRequest>> CreateAsync(TransactionQueueConfigurationRequest facilityConfiguration)
{
try
{
facilityConfiguration.FacilityKey = Guid.Parse(_accessor.Current.Facility.FacilityKey);
if (ModelState.IsValid)
{
await _business.CreateFacilitySpecificConfigurationAsync(facilityConfiguration);
_logger.LogInformation("Created Successfully : {CreatedResult}", facilityConfiguration);
return Created(new Uri($"{Request.Path}", UriKind.Relative), new { Message = "Created Successfully.", Model = facilityConfiguration });
}
else
{
_logger.LogError("Bad Request:", ModelState.ValidationState);
return BadRequestErrorMessage();
}
}
catch (ArgumentNullException ex)
{
_logger.LogError(ex.Message);
return BadRequestErrorMessage();
}
catch (DbUpdateException ex)
{
_logger.LogError(ex.Message);
return BadRequestErrorMessage();
}
}
public async Task<ActionResult<TransactionQueueConfigurationRequest>> PutfacilityConfigurationAsync(TransactionQueueConfigurationRequest transactionQueueConfigurationRequest)
{
try
{
transactionQueueConfigurationRequest.FacilityKey = Guid.Parse(_accessor.Current.Facility.FacilityKey);
if (ModelState.IsValid)
{
BusinessResponse businessResponse = await _business.UpdateFacilityConfigAsync(transactionQueueConfigurationRequest);
if (businessResponse.IsSuccess == false)
{
_logger.LogError("Bad Request:", ModelState.ValidationState);
return BadRequest(businessResponse.Message);
}
else
{
_logger.LogInformation("Updated Successfully : {UpdateResult}", transactionQueueConfigurationRequest);
return Ok(businessResponse.Message);
}
}
else
{
_logger.LogError("Bad Request:", ModelState.ValidationState);
return BadRequestErrorMessage();
}
}
catch (ArgumentNullException ex)
{
_logger.LogError(ex.Message);
return BadRequestErrorMessage();
}
catch (DbUpdateException ex)
{
_logger.LogError(ex.Message);
return BadRequestErrorMessage();
}
}
