public OperationResult ValidateEmail()
{
var result = new OperationResult();
if (string.IsNullOrWhiteSpace(Email))
{
result.Success = false;
result.AddErrorMessage("Email must be valid format!");
}
var isValidFormat = true;
if (!isValidFormat)
{
result.Success = false;
result.AddErrorMessage("Email must be valid format!");
}
var isRealDomain = true;
if (!isRealDomain)
{
result.Success = false;
result.AddErrorMessage("Email must represent a valid domain!");
}
return(result);
}
public async Task CalculateTax_Should_Return_ValidationRuleEngine_Errors()
{
//Arrange
var calculationRequest = new TaxCalculationRequest();
var validationRuleEngineResult = new OperationResult <TaxCalculationResponse>();
const string expectedErrorKey1 = "1232";
const string expectedErrorMessage1 = "This is an error";
validationRuleEngineResult.AddErrorMessage(expectedErrorKey1, expectedErrorMessage1);
const string expectedErrorKey2 = "error2";
const string expectedErrorMessage2 = "This is an error number2";
validationRuleEngineResult.AddErrorMessage(expectedErrorKey2, expectedErrorMessage2);
const int expectedErrorCount = 2;
_validationRuleEngine.Setup(s => s.Validate(calculationRequest))
.Returns(validationRuleEngineResult);
//Act
var operationResult = await _calculatorManager.CalculateTax(calculationRequest);
//Assert
Assert.IsTrue(operationResult.HasErrors);
var actualErrors = operationResult.GetErrorMessages();
Assert.AreEqual(expectedErrorCount, actualErrors.Count);
Assert.IsTrue(actualErrors.Any(e => e.Key == expectedErrorKey1 && e.Value.Contains(expectedErrorMessage1)));
Assert.IsTrue(actualErrors.Any(e => e.Key == expectedErrorKey2 && e.Value.Contains(expectedErrorMessage2)));
}
public async Task <OperationResult <UserDTO> > Subscribing(Subscribe model)
{
try
{
var operRes = new OperationResult <UserDTO>(true);
var toUser = await _userManager.FindByIdAsync(model.ToUserId.ToString());
if (toUser == null)
{
operRes.AddErrorMessage("FromUserId", $"Не удалось найти пользователя с id = {model.ToUserId}");
}
var fromUser = await _userManager.FindByIdAsync(model.FromUserId.ToString());
if (fromUser == null)
{
operRes.AddErrorMessage("FromUserId", $"Не удалось найти пользователя с id = {model.FromUserId}");
}
if (model.FromUserId == model.ToUserId)
{
operRes.AddErrorMessage(null, "id пользователей не должны совпадать");
}
using (var connection = _factory.CreateConnection())
{
await Connect(connection);
var sub = await connection.QueryFirstOrDefaultAsync <Subscribe>($"select * from [{nameof(Subscribe)}] where [{nameof(Subscribe.FromUserId)}] = @{nameof(model.FromUserId)} and" +
$"[{nameof(Subscribe.ToUserId)}] = @{nameof(model.ToUserId)}", model);
if (sub != null)
{
operRes.AddErrorMessage(null, $"пользователь {model.FromUserId} уже подписан на {model.ToUserId}");
}
if (!operRes.Succeeded)
{
return(operRes);
}
await connection.ExecuteAsync(QueryBuilder.CreateQuery(model), model);
var res = new UserDTO {
Avatar = toUser.Avatar, Id = toUser.Id, UserName = toUser.UserName
};
operRes.Results.Add(res);
return(operRes);
}
}
catch (Exception ex)
{
throw new DatabaseException("Не удалось добавить данные", ex.Message);
}
}
public async Task <OperationResult <CommentInfoDTO> > UpdateCommentAsync(int id, CreateCommentDTO model)
{
try
{
var operRes = new OperationResult <CommentInfoDTO>(true);
var user = await _userManager.FindByIdAsync(model.UserId.ToString());
if (user == null)
{
operRes.AddErrorMessage("UserId", $"Не удалось найти пользователя с id = {model.UserId}");
}
using (var connection = _factory.CreateConnection())
{
connection.ConnectionString = _connectionString;
await connection.OpenAsync();
var pic = await uow.Pictures.FindByIdAsync(connection, model.PictureId);
if (pic == null)
{
operRes.AddErrorMessage("PictureId", $"Не удалось найти картину с id = {model.PictureId}");
}
var comm = await uow.Comments.FindByIdAsync(connection, id);
if (comm == null)
{
operRes.AddErrorMessage("id", $"Не удалось найти комментарий с id = {model.PictureId}");
}
if (!operRes.Succeeded)
{
return(operRes);
}
var entity = _mapper.Map <Comment>(model);
entity.Id = id;
entity.DateOfCreation = comm.DateOfCreation;
await uow.Comments.UpdateAsync(connection, entity);
var result = _mapper.Map <CommentInfoDTO>(entity);
result.UserName = user.UserName;
result.Avatar = user.Avatar;
operRes.Results.Add(result);
return(operRes);
}
}
catch (Exception ex)
{
throw new DatabaseException("Не удалось добавить данные", ex.Message);
}
}
public async Task <OperationResult <PictureInfoDTO> > UpdatePictureAsync(int id, CreatePictureDTO model)
{
try
{
var operRes = new OperationResult <PictureInfoDTO>(true);
var user = await _userManager.FindByIdAsync(model.UserId.ToString());
if (user == null)
{
operRes.AddErrorMessage("userId", $"Не удалось найти пользователя с id = {model.UserId}");
}
using (var connection = _factory.CreateConnection())
{
await Connect(connection);
var pic = await uow.Pictures.FindByIdAsync(connection, id);
if (pic == null)
{
operRes.AddErrorMessage("id", $"Не удалось найти картину с id = {id}");
}
if (!operRes.Succeeded)
{
return(operRes);
}
var entity = _mapper.Map <Picture>(model);
entity.Id = id;
entity.DateOfCreation = pic.DateOfCreation;
await uow.Pictures.UpdateAsync(connection, entity, model.TagIds);
var result = _mapper.Map <PictureInfoDTO>(entity);
result.UserName = user.UserName;
result.Avatar = user.Avatar;
operRes.Results.Add(result);
return(operRes);
}
}
catch (NotFoundException ex)
{
throw;
}
catch (Exception ex)
{
throw new DatabaseException("Не удалось удалить данные", ex.Message);
}
}
public async Task CalculateTax_Should_Return_Calculation_Errors()
{
//Arrange
var calculationRequest = new TaxCalculationRequest();
var taxCalculationResult = new OperationResult <decimal>();
const string expectedErrorKey1 = "calcError1";
const string expectedErrorMessage1 = "This is a calc error";
taxCalculationResult.AddErrorMessage(expectedErrorKey1, expectedErrorMessage1);
const string expectedErrorKey2 = "calcError2";
const string expectedErrorMessage2 = "This is calc error number2";
taxCalculationResult.AddErrorMessage(expectedErrorKey2, expectedErrorMessage2);
const int expectedErrorCount = 2;
_validationRuleEngine.Setup(s => s.Validate(calculationRequest))
.Returns(new OperationResult <TaxCalculationResponse>());
_calculationMappingRepository.Setup(f => f.GetByPostalCodeAsync(calculationRequest.PostalCode))
.ReturnsAsync(new PostalCodeCalculationTypeMapping());
_taxCalculatorFactory.Setup(f => f.GetCalculator(It.IsAny <TaxCalculationType>()))
.Returns(_taxCalculator.Object);
_taxYearRepository.Setup(t => t.GetTaxYearAsync(It.IsAny <DateTime>()))
.ReturnsAsync(new TaxYear());
_taxCalculator.Setup(t => t.CalculateTaxAsync(It.IsAny <TaxYear>(), calculationRequest.AnnualIncome))
.ReturnsAsync(taxCalculationResult);
//Act
var operationResult = await _calculatorManager.CalculateTax(calculationRequest);
//Assert
Assert.IsTrue(operationResult.HasErrors);
var actualErrors = operationResult.GetErrorMessages();
Assert.AreEqual(expectedErrorCount, actualErrors.Count);
Assert.IsTrue(actualErrors.Any(e => e.Key == expectedErrorKey1 && e.Value.Contains(expectedErrorMessage1)));
Assert.IsTrue(actualErrors.Any(e => e.Key == expectedErrorKey2 && e.Value.Contains(expectedErrorMessage2)));
}
public async Task <OperationResult <PictureFullInfoDTO> > GetPictureByIdAsync(int id, int userId)
{
try
{
var operRes = new OperationResult <PictureFullInfoDTO>(true);
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user == null)
{
operRes.AddErrorMessage("userId", $"Не удалось найти пользователя с id = {userId}");
}
using (var connection = _factory.CreateConnection())
{
await Connect(connection);
var pic = await uow.Pictures.FindByIdAsync(connection, id);
if (pic == null)
{
operRes.AddErrorMessage("id", $"Не удалось найти картину с id = {id}");
}
if (!operRes.Succeeded)
{
return(operRes);
}
var result = await connection.QueryFirstOrDefaultAsync <PictureFullInfoDTO>("GetPictureById", new { id, userId }, null, null, CommandType.StoredProcedure);
result.CommentList = await connection.QueryAsync <CommentInfoDTO>("GetCommentsForPicture", new { pictureId = id }, null, null, CommandType.StoredProcedure);
result.Tags = await uow.Tags.GetTagsForPicture(connection, id);
operRes.Results.Add(result);
return(operRes);
}
}
catch (Exception ex)
{
throw new DatabaseException("Не удалось извлечь данные", ex.Message);
}
}
protected override OperationResult <decimal> Validate()
{
var result = new OperationResult <decimal>();
if (TaxRateSettings?.Count > 1)
{
result.AddErrorMessage($"More than 1 Flat Rate Tax settings have been found for the year: {TaxYear}");
}
return(result);
}
private OperationResult <decimal> BaseValidation()
{
var result = new OperationResult <decimal>();
if (TaxRateSettings == null || !TaxRateSettings.Any())
{
result.AddErrorMessage($"No Tax Rate setting have been found for the tax year: {TaxYear}");
}
return(result);
}
public OperationResult Validate(ICoin currentCoin)
{
var operationResult = new OperationResult();
var currentOunces = _coinJar.GetTotalVolume();
if ((currentOunces + currentCoin.Volume) > _maxFluidOunces)
{
operationResult.AddErrorMessage("CoinJar", $"Coin Jar can only hold {_maxFluidOunces} fluid ounces. Current total fluid ounces: {currentOunces:N}, Coin Fluid Ounces: {currentCoin.Volume:N}");
}
return(operationResult);
}
public OperationResult <TaxCalculationResponse> Validate(TaxCalculationRequest request)
{
var operationResult = new OperationResult <TaxCalculationResponse>();
var taxYear = _taxYear.GetTaxYearAsync(_clock.GetCurrentDateTime()).Result;
if (taxYear == null)
{
operationResult.AddErrorMessage(string.Empty, "Tax year was not found for today's date.");
return(operationResult);
}
return(operationResult);
}
public OperationResult <TaxCalculationResponse> Validate(TaxCalculationRequest request)
{
var operationResult = new OperationResult <TaxCalculationResponse>();
var mapping = _calculationMappingRepository.GetByPostalCodeAsync(request.PostalCode).Result;
if (mapping == null)
{
operationResult.AddErrorMessage(nameof(request.PostalCode), $"Postal code: {request.PostalCode} was not found.");
return(operationResult);
}
return(operationResult);
}
public async Task <OperationResult <PictureInfoDTO> > CreatePictureAsync(CreatePictureDTO model)
{
try
{
var operRes = new OperationResult <PictureInfoDTO>(true);
if (!_file.IsExist(model.ImagePath))
{
operRes.AddErrorMessage("ImagePath", "Не удалось загрузить файл");
}
var user = await _userManager.FindByIdAsync(model.UserId.ToString());
if (user == null)
{
operRes.AddErrorMessage("UserId", $"Не удалось найти пользователя с id = {model.UserId}");
}
var entity = _mapper.Map <Picture>(model);
entity.DateOfCreation = DateTime.Now;
using (var connection = _factory.CreateConnection())
{
await Connect(connection);
entity = await uow.Pictures.CreateAsync(connection, entity, model.TagIds);
}
var result = _mapper.Map <PictureInfoDTO>(entity);
result.Avatar = user.Avatar;
result.UserName = user.UserName;
operRes.Results.Add(result);
return(operRes);
}
catch (NotFoundException)
{
throw;
}
catch (Exception ex)
{
throw new DatabaseException("Не удалось добавить данные", ex.Message);
}
}
public OperationResult Validate(T entity)
{
var operationResult = new OperationResult();
foreach (var validationRule in ValidationRules)
{
var validationResult = validationRule.Validate(entity);
if (validationResult.HasErrors)
{
foreach (var keyValuePair in validationResult.GetErrorMessages())
{
operationResult.AddErrorMessage(keyValuePair.Key, keyValuePair.Value);
}
}
}
return(operationResult);
}
public async Task Calculate_Should_Return_BadRequest_When_Manager_Returns_Errors()
{
//Arrange
const decimal annualIncome = 250000;
const string postalCode = "1234";
var expectedErrorMessage = "my errors";
var errorKey = "errorKey";
TaxCalculationRequestModel model = new TaxCalculationRequestModel
{
AnnualIncome = annualIncome,
PostalCode = postalCode
};
TaxCalculationRequest actualManagerRequest = null;
var managerResult = new OperationResult <TaxCalculationResponse>();
managerResult.AddErrorMessage(errorKey, expectedErrorMessage);
_manager.Setup(r => r.CalculateTax(It.IsAny <TaxCalculationRequest>()))
.Callback((TaxCalculationRequest r) => actualManagerRequest = r)
.ReturnsAsync(() => managerResult);
//Act
var result = await _controller.Calculate(model);
//Assert
Assert.IsInstanceOf <BadRequestObjectResult>(result.Result);
var
responseModel = (SerializableError)((BadRequestObjectResult)result.Result).Value;
Assert.AreEqual(expectedErrorMessage, ((string[])responseModel[errorKey])[0]);
_manager.Verify(f => f.CalculateTax(It.IsAny <TaxCalculationRequest>()), Times.Once);
Assert.AreEqual(annualIncome, actualManagerRequest.AnnualIncome);
Assert.AreEqual(postalCode, actualManagerRequest.PostalCode);
}
