public void WhenDtoIsBlank_ShouldThrow_InputValidationException()
{
var command = new CreatePartnerCommand();
FluentActions.Invoking(() => TestFramework.SendAsync(command))
.Should().Throw <InputValidationException>();
}
public async Task WhenDtoIsValid_ShouldCreatePartner()
{
var command = new CreatePartnerCommand()
{
Address = new AddressDto()
{
City = "Toronto",
Country = "Canada",
Street = "Street 123",
ZipCode = "1234XX"
},
Name = "Test Name"
};
// Act.
var partnerId = await TestFramework.SendAsync(command);
var partner = await TestFramework.Data.FindAsync <Partner>(partnerId, x => x.Transactions);
partner.Should().NotBeNull();
partner.Id.Should().Be(partnerId);
partner.CreatedAt.Should().BeCloseTo(DateTime.Now, 10000);
partner.CreatedBy.Should().NotBeNullOrWhiteSpace();
partner.LastModifiedAt.Should().BeNull();
partner.DeletedAt.Should().BeNull();
partner.Transactions.Should().BeEmpty();
partner.Name.Should().Be(command.Name);
partner.Address.Should().NotBeNull();
partner.Address.Should().BeEquivalentTo(command.Address,
o => o.ComparingByMembers <AddressDto>());
}
public async Task <PartnerDTO> CreatePartner(CreatePartnerCommand command)
{
var partner = new Partner
{
DocumentNumber = command.pdv.document,
Name = command.pdv.name,
Owner = new OwnerEmployee
{
FirstName = command.owner.firstName,
LastName = command.owner.lastName
},
Address = new Address
{
Location = command.pdv.address
},
CoverageArea = new CoverageArea
{
Location = command.pdv.coverageArea
}
};
_partnerRepository.Insert(partner);
await _unitOfWork.CommitAsync();
return(ConvertEntityToDTO(partner));
}
public async Task <IActionResult> Post([FromBody] Partner partner)
{
CreatePartnerCommand command = new CreatePartnerCommand(partner);
await partnerCommandHandler.ExecuteAsync(command);
return(this.HandleNotification(partnerCommandHandler, partner));
}
public async Task <IActionResult> CreatePartner([FromBody] CreatePartnerCommand command)
{
var result = await _appService.CreatePartner(command);
if (result == null)
{
return(UnprocessableEntity());
}
return(Ok(result));
}
public async Task <IActionResult> Create([FromBody] CreatePartnerCommand request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var partner = await _mediator.Send(request);
return(CreatedAtAction(nameof(GetById), new { id = partner.Id }, partner));
}
public async Task <ActionResult <PartnerViewModel> > CreatePartner([FromBody] CreatePartnerCommand command)
{
var newId = await _Mediator.Send(command);
var newPartner = await _Mediator.Send(new GetPartnerQuery()
{
Id = newId
});
return(StatusCode(200, newPartner));
}
public async Task Create()
{
var command = new CreatePartnerCommand();
_mockMediator.Setup(x => x.Send(command, It.IsAny <CancellationToken>()))
.ReturnsAsync(123);
var result = await _sut.Create(command);
Assert.IsAssignableFrom <OkObjectResult>(result.Result);
Assert.AreEqual(123, ((OkObjectResult)result.Result).Value);
}
public async Task Create_WhenRequestInvalid_ShouldReturnBadRequest()
{
// Arrange
var request = new CreatePartnerCommand();
_controller.ModelState.AddModelError("any error", "any message");
// Act
var response = await _controller.Create(request);
// Assert
response.Should().NotBeNull().And.BeOfType <BadRequestObjectResult>();
}
public async Task Create_WhenRequestIsValid_ShouldReturnCreatedAtActionResult()
{
// Arrange
var request = new CreatePartnerCommand();
Partner partner = CreatePartner();
_mediator.Send(Arg.Any <CreatePartnerCommand>()).Returns(partner);
// Act
var response = await _controller.Create(request);
// Assert
response.Should().NotBeNull().And.BeOfType <CreatedAtActionResult>();
var createdAtActionResponse = response as CreatedAtActionResult;
createdAtActionResponse.ActionName.Should().Be(nameof(_controller.GetById));
}
public async Task ExecuteAsync(CreatePartnerCommand command)
{
if (!command.Validate())
{
AddNotification(command.GetNotifications());
return;
}
try
{
await partnerRepository.AddAsync(command.Partner);
}
catch (Exception ex)
{
logger.LogError(ex.Message, ex);
AddNotification(ex.Message, System.Net.HttpStatusCode.InternalServerError);
}
}
public async Task Handle_ShouldCreatePartner()
{
// Arrange
var command = new CreatePartnerCommand()
{
Address = new Geolocalization.Application.Command.Commands.Point(),
CoverageArea = new Geolocalization.Application.Command.Commands.MultiPolygon()
};
var generatedId = ObjectId.GenerateNewId().ToString();
_repository.Create(Arg.Any <Partner>()).Returns(generatedId);
// Act
var response = await _handler.Handle(command, default(CancellationToken));
// Assert
await _repository.Received(1).Create(Arg.Any <Partner>());
}
public async Task <BaseApiResponse> Add(AddPartnerRequest request)
{
request.CheckNotNull(nameof(request));
var userInfo = _userQueryService.FindUser(request.Mobile);
if (userInfo == null)
{
return(new BaseApiResponse {
Code = 400, Message = "没找到该用户"
});
}
var newpartnerid = GuidUtil.NewSequentialId();
var command = new CreatePartnerCommand(
newpartnerid,
userInfo.Id,
userInfo.WalletId,
request.Mobile,
request.Region,
request.Level,
request.Persent,
request.CashPersent,
request.BalanceInterval,
request.Remark,
request.IsLocked
);
var result = await ExecuteCommandAsync(command);
if (!result.IsSuccess())
{
return(new BaseApiResponse {
Code = 400, Message = "命令没有执行成功：{0}".FormatWith(result.GetErrorMessage())
});
}
//添加操作记录
var currentAdmin = _contextService.GetCurrentAdmin(HttpContext.Current);
RecordOperat(currentAdmin.AdminId.ToGuid(), "添加代理", newpartnerid, "{0}代理地区{1}".FormatWith(userInfo.Mobile, request.Region));
return(new BaseApiResponse());
}
public async Task <BaseApiResponse> Add([FromBody] AddPartnerRequest request)
{
request.CheckNotNull(nameof(request));
var userInfo = _userQueryService.FindUser(request.Mobile);
if (userInfo == null)
{
return(new BaseApiResponse {
Code = 400, Message = "没找到该用户"
});
}
var command = new CreatePartnerCommand(
GuidUtil.NewSequentialId(),
userInfo.Id,
userInfo.WalletId,
request.Mobile,
request.Region,
request.Level,
request.Persent,
request.CashPersent,
request.BalanceInterval,
request.Remark,
request.IsLocked
);
var result = await ExecuteCommandAsync(command);
if (!result.IsSuccess())
{
return(new BaseApiResponse {
Code = 400, Message = "命令没有执行成功：{0}".FormatWith(result.GetErrorMessage())
});
}
return(new BaseApiResponse());
}
