public async Task GetCustomer_ShouldReturnCustomer_GivenCustomer(
[Frozen] Mock <IMediator> mockMediator,
Core.Handlers.GetCustomer.StoreCustomerDto customer,
[Greedy] CustomerController sut,
GetCustomerQuery query
)
{
//Arrange
mockMediator.Setup(x => x.Send(
It.IsAny <GetCustomerQuery>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync(customer);
//Act
var actionResult = await sut.GetCustomer(query);
//Assert
var okObjectResult = actionResult as OkObjectResult;
okObjectResult.Should().NotBeNull();
var result = okObjectResult.Value as Core.Models.GetCustomer.Customer;
result.Should().NotBeNull();
}
public IActionResult Get(Guid id)
{
var query = new GetCustomerQuery(id);
var customer = _queryProcessor.Process(query);
return(View(customer));
}
public async Task <IEnumerable <CustomerResponseDto> > Handle(GetCustomerQuery request, CancellationToken cancellationToken)
{
using var dbContext = _dataContextFactory.SpawnDbContext();
var list = await dbContext.Customers.Include(x => x.Orders).ToListAsync(cancellationToken);
return(_mapper.Map <IEnumerable <CustomerResponseDto> >(list));
}
public async Task <IActionResult> GetAsync(int id)
{
var command = new GetCustomerQuery(id);
var result = await _mediatr.Send(command);
return(result != null ? (IActionResult)Ok(result) : NotFound(new { Message = "Customer not found" }));
}
public async Task <ActionResult <GetCustomerDto> > Get(int id)
{
var command = new GetCustomerQuery(id);
var result = await _mediatr.Send(command);
return(result != null ? (ActionResult)Ok(new { Message = "success", data = result }) : NotFound(new { Message = "not found" }));
}
public async Task <IActionResult> Get(int ID)
{
var result = new GetCustomerQuery(ID);
var wait = await meciater.Send(result);
return(wait != null ? (IActionResult)Ok(wait) : NotFound());
}
public async Task Handle_ExistentCustomer_CustomerReturned()
{
// Arrange
var customerId = Guid.Parse("835D6C36-215E-4F5B-8084-3B8C1B7C59EC");
var query = new GetCustomerQuery
{
Id = customerId
};
var customer = this.fixture
.Build <Customer>()
.With(c => c.Id, customerId)
.Create();
this.repositoryMock
.Setup(r => r.GetCustomerAsync(query.Id))
.ReturnsAsync(customer);
// Act
var result = await this.handler.Handle(query, CancellationToken.None);
// Assert
result.Should().NotBeNull();
result.Id.Should().Be(customerId);
this.repositoryMock.VerifyAll();
}
public async Task Handle_CustomerExists_ReturnCustomer(
[Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
GetCustomerQueryHandler sut,
GetCustomerQuery query,
Entities.StoreCustomer customer
)
{
//Arrange
customerRepoMock.Setup(_ => _.GetBySpecAsync(
It.IsAny <GetCustomerSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync(customer);
//Act
var result = await sut.Handle(query, CancellationToken.None);
//Assert
result.Should().NotBeNull();
customerRepoMock.Verify(x => x.GetBySpecAsync(
It.IsAny <GetCustomerSpecification>(),
It.IsAny <CancellationToken>()
));
result.Should().BeEquivalentTo(customer, opt => opt
.Excluding(_ => _.SelectedMemberPath.EndsWith("Id", StringComparison.InvariantCultureIgnoreCase))
);
}
public async Task <Result <CustomerToDetailDto> > Handle(GetCustomerQuery request, CancellationToken cancellationToken)
{
var customer = await _repo.GetCustomer(request.CustomerId);
var customerToDetailDto = _mapper.Map <CustomerToDetailDto>(customer);
return(Result <CustomerToDetailDto> .Success(customerToDetailDto));
}
public async Task <IActionResult> Get([FromQuery] GetCustomerQuery query)
{
var result = await _mediator.Send(query);
return(Ok(new HttpServiceResponseBase <CustomerDto> {
Data = result, Code = HttpStatusCode.OK
}));
}
public void Handle_WhenInValidRequest_ShouldThrowException()
{
var sut = new GetCustomerQueryHandler(_context);
var request = new GetCustomerQuery {
Id = Guid.NewGuid()
};
Assert.ThrowsAsync <ValidationException>(() => sut.Handle(request, CancellationToken.None));
}
public async Task <TimesheetResponse <CustomerDto> > Handle(GetCustomerQuery query,
CancellationToken cancellationToken)
{
var customers = await _repository.Get();
var response = new TimesheetResponse <CustomerDto>();
response.Timesheet.AddRange(_mapper.Map <List <CustomerDto> >(customers));
return(response);
}
public async Task <ResultWrapper <GetCustomerOutput> > Handle(GetCustomerQuery request, CancellationToken cancellationToken)
{
ResultWrapper <GetCustomerOutput> result = new ResultWrapper <GetCustomerOutput>();
TUser tUser = await _dbContext.TUser
.Include(x => x.TBodyType)
.Include(x => x.TRegionCity).ThenInclude(x => x.TRegionState).ThenInclude(x => x.TRegionCountry)
.Include(x => x.TActivityLevel)
.Include(x => x.TWeeklyGoal)
.FirstOrDefaultAsync(x => x.Id == request.Id);
result.Status = true;
result.Result = new GetCustomerOutput()
{
Email = tUser.Email,
FireBaseId = tUser.FireBaseId,
Enabled = tUser.Enabled,
FirstName = tUser.FirstName,
LastName = tUser.LastName,
BirthYear = tUser.BirthYear,
Phone = tUser.Phone,
Address = tUser.Address,
PostalCode = tUser.PostalCode,
RegionCityId = tUser.TRegionCityId.toInt(0),
RegionStateId = tUser.TRegionCity?.TRegionStateId.toInt(0) ?? 0,
RegionCountryId = tUser.TRegionCity?.TRegionState?.TRegionCountryId.toInt(0) ?? 0,
RegionCityName = tUser.TRegionCity?.Title ?? string.Empty,
RegionStateName = tUser.TRegionCity?.TRegionState?.Title ?? string.Empty,
RegionCountryName = tUser.TRegionCity?.TRegionState?.TRegionCountry?.Title ?? string.Empty,
Weight = tUser.Weight,
Height = tUser.Height,
Waist = tUser.Waist,
Hips = tUser.Hips,
Forearms = tUser.Forearms,
Fat = tUser.Fat,
BodyType = tUser.TBodyType == null ? new BodyTypeOutput() : new BodyTypeOutput()
{
Id = tUser.TBodyType.Id,
Title = tUser.TBodyType.Title,
Image = tUser.TBodyType.Image
},
ActivityLevelPalForMale = tUser.TActivityLevel?.PALForMale ?? 0,
ActivityLevelPalForFemale = tUser.TActivityLevel?.PALForFeMale ?? 0,
ActivityLevelCarb = tUser.TActivityLevel?.Carb ?? 0,
ActivityLevelProtein = tUser.TActivityLevel?.Protein ?? 0,
Gender = tUser.Gender,
TargetWeight = tUser.TargetWeight,
WeeklyGoalId = tUser.TWeeklyGoalId ?? 0,
WeeklyGoalCaloryPercent = tUser.TWeeklyGoal?.CaloryRequirePercent ?? 0,
GoalId = tUser.TWeeklyGoal?.TGoalId ?? 0,
ActivityLevelId = tUser.TActivityLevelId ?? 0
};
result.Result.BodyType.Image = result.Result.BodyType.Image.JoinWithCDNAddress();
return(result);
}
public void Handle_WhenValidRequest_ShouldReturnCustomer()
{
var sut = new GetCustomerQueryHandler(_context);
var request = new GetCustomerQuery {
Id = Guid.Parse("39aff1c2-5530-4112-bd3d-b72b52f4d69d")
};
var result = sut.Handle(request, CancellationToken.None).Result;
Assert.AreEqual(request.Id, result.Id);
}
public async Task <IActionResult> Get([FromQuery] GetCustomerQuery request)
{
var customerProfile = await mediator.Send(request);
if (customerProfile == null)
{
return(NotFound());
}
return(Json(customerProfile));
}
public IEnumerable<IResult> ShowCustomerDetail()
{
var getCustomer = new GetCustomerQuery {Id = Id}.AsResult();
yield return getCustomer;
yield return Show.Child<CustomerDetailViewModel>().In<IShell>()
.Configured(x => x.WithCustomer(getCustomer.Response));
}
public async Task <ActionResult <CustomerDto> > GetCustomerAsync(Guid id)
{
var customerQuery = new GetCustomerQuery(id);
var result = await mediator.Send(customerQuery);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IActionResult> Get(int Id)
{
FirebaseUser user = HttpContext.GetFirebaseUser();
GetCustomerQuery model = new GetCustomerQuery()
{
Id = Id
};
ResultWrapper <GetCustomerOutput> result = new ResultWrapper <GetCustomerOutput>();
result = await _mediator.Send(model);
return(Ok(result));
}
public async Task <List <Customer> > Handle(GetCustomerQuery request, CancellationToken cancellationToken)
{
var customers = new List <Customer>
{
new Customer {
id = 1
}
};
return(await _context.customers.ToListAsync());
//return customers;
}
public async Task ValidateAsync_InvalidQuery_ValidationResultIsNotValid()
{
// Arrange
var validator = new GetCustomerQueryValidator();
var query = new GetCustomerQuery();
// Act
var result = await validator.ValidateAsync(query);
// Assert
result.Should().NotBeNull();
result.IsValid.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
public Task <Result> Handle(GetCustomerQuery request, CancellationToken cancellationToken)
{
if (_repository.Customers.Count > 0)
{
_cache.Set(typeof(Customer).Name, _repository.Customers, new MemoryCacheEntryOptions
{
SlidingExpiration = TimeSpan.FromSeconds(30)
});
}
return(Task.FromResult(new Result {
Data = _repository.Customers
}));
}
public async Task <IActionResult> GetCustomer(long id)
{
var query = new GetCustomerQuery(id);
var result = await messages.Dispatch(query);
return(result.Match <IActionResult>(
(errors) => BadRequest(errors),
(customer) =>
{
var customerDto = mapper.Map <CustomerDto>(customer);
return Ok(customerDto);
}));
}
public Maybe <CustomerDto> Handle(GetCustomerQuery query)
{
var maybeCustomer = _archive.GetCustomer(query.CustomerId);
if (!maybeCustomer.HasValue())
{
return(new Maybe <CustomerDto>());
}
var customer = maybeCustomer.ValueOrDefault(null);
var dto = new CustomerDto(customer.Username, customer.Name);
return(new Maybe <CustomerDto>(dto));
}
public Task <IEnumerable <CustomerViewModel> > Handle(GetCustomerQuery request, CancellationToken cancellationToken)
{
var entities = _context.Customers
.AsNoTracking()
.Select(x => new CustomerViewModel
{
Id = x.Id,
Name = x.Name
});
if (entities != null)
{
return(Task.FromResult(entities.AsEnumerable()));
}
return(Task.FromResult(Enumerable.Empty <CustomerViewModel>()));
}
public async Task ValidateAsync_ValidQuery_ValidationResultIsValid()
{
// Arrange
var validator = new GetCustomerQueryValidator();
var query = new GetCustomerQuery
{
Id = Guid.Parse("00FBEE01-0E79-406A-B9BF-100AA0DC724C")
};
// Act
var result = await validator.ValidateAsync(query);
// Assert
result.Should().NotBeNull();
result.IsValid.Should().BeTrue();
result.Errors.Should().BeEmpty();
}
public async Task <IActionResult> Delete(string id)
{
var affiliate = await _affiliateService.GetAffiliateById(id);
if (affiliate == null)
{
//No affiliate found with the specified id
return(RedirectToAction("List"));
}
var customers = new GetCustomerQuery()
{
AffiliateId = affiliate.Id,
PageSize = 1,
};
var query_customer = (await _mediator.Send(customers)).Count();
if (query_customer > 0)
{
ModelState.AddModelError("", "There are exist customers related with affiliate");
}
var orders = new GetOrderQuery()
{
AffiliateId = affiliate.Id,
PageSize = 1,
};
var query_order = (await _mediator.Send(orders)).Count();
if (query_order > 0)
{
ModelState.AddModelError("", "There are exist orders related with affiliate");
}
if (ModelState.IsValid)
{
await _affiliateService.DeleteAffiliate(affiliate);
Success(_translationService.GetResource("Admin.Affiliates.Deleted"));
return(RedirectToAction("List"));
}
Error(ModelState);
return(RedirectToAction("Edit", new { id = id }));
}
static async Task MainAsync()
{
Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] On MainAsync");
var mediator = GetMediator();
var query = new GetCustomerQuery(Guid.NewGuid());
var customer = await mediator.Send(query);
// The default implementation of Publish loops through
// the notification handlers and awaits each one.
// This ensures each handler is run after one another.
await mediator.Publish(query);
Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Found customer '{customer.FullName}'");
Console.ReadLine();
}
//Get the Edit View.
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Get the Customer and the Customer only.
var customer = new GetCustomerQuery(Context)
.Execute(id: (int)id, includeRelatedEntities: false);
if (customer == null)
{
return(HttpNotFound());
}
return(View(customer));
}
public async Task <PutAssignmentByIdResponse> Handle(PutAssignmentByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetBoardQuery()
{
Id = request.BoardId
};
var query2 = new GetCustomerQuery()
{
Id = request.CustomerId,
CompanyId = request.AuthenticatorCompanyId
};
var query3 = new GetAssignmentQuery()
{
Id = request.Id
};
var board = await queryExecutor.Execute(query);
var customer = await queryExecutor.Execute(query2);
var assignment = await queryExecutor.Execute(query3);
if (board == null || customer == null || assignment == null)
{
return(new PutAssignmentByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var updateAssignment = mapper.Map <Assignment>(request);
var command = new PutAssignmentCommand
{
Parameter = updateAssignment
};
var updatedAssignment = await commandExecutor.Execute(command);
var response = mapper.Map <AssignmentDto>(updatedAssignment);
return(new PutAssignmentByIdResponse
{
Data = response
});
}
public async Task <PutCustomerByIdResponse> Handle(PutCustomerByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new PutCustomerByIdResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetCustomerQuery()
{
Id = request.Id,
CompanyId = request.AuthenticatorCompanyId
};
var customer = await queryExecutor.Execute(query);
if (customer == null)
{
return(new PutCustomerByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var updateCustomer = mapper.Map <Customer>(request);
updateCustomer.CompanyId = request.AuthenticatorCompanyId;
var command = new PutCustomerCommand
{
Parameter = updateCustomer
};
var updatedCustome = await commandExecutor.Execute(command);
var response = mapper.Map <CustomerDto>(updatedCustome);
return(new PutCustomerByIdResponse
{
Data = response
});
}
public void Handle_CustomerNotFound_ThrowArgumentNullException(
[Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
GetCustomerQueryHandler sut,
GetCustomerQuery query
)
{
// Arrange
customerRepoMock.Setup(x => x.GetBySpecAsync(
It.IsAny <GetCustomerSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync((Entities.Customer)null);
//Act
Func <Task> func = async() => await sut.Handle(query, CancellationToken.None);
//Assert
func.Should().Throw <ArgumentNullException>()
.WithMessage("Value cannot be null. (Parameter 'customer')");
}
