public async Task <PagedDto <ContactDetailsDto> > GetContacts(GetPagedItemsDto dto)
{
var query = new GetContactsQuery(dto);
var result = await _mediator.Send(query);
return(result);
}
public async Task <IEnumerable <ContactDto> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
return(await _context.Contacts
.Where(x => x.Id > 0)
.OrderBy(x => x.Name)
//.ProjectTo<ContactDto>(_mapper.ConfigurationProvider)
.ProjectToListAsync <ContactDto>(_mapper.ConfigurationProvider));
}
public async Task <PagedDto <ContactDetailsDto> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
var result = await Context.Contacts
.Include(c => c.ContactNumbers)
.GetPagedResultOf <Contact, ContactDetailsDto>(request.Dto, Mapper, cancellationToken);
return(result);
}
public async Task <List <ContactVm> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
var response = await _contactService.GetContactsAsync();
var viewModel = _mapper.Map <List <ContactVm> >(response);
return(await Task.FromResult(viewModel));
}
public async Task <Result <List <ContactDto> > > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
var contacts = (await _contactRepository.GetAll()).Select(x => new ContactDto(x.Id, x.Name)).ToList();
if (contacts.Count == 0)
{
return(Result.NoContent(contacts));
}
return(Result.Ok(contacts));
}
public async Task <IEnumerable <ContactDto> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var persons = applicationDataContext.Contacts
.Include(c => c.Source)
.AsQueryable();
return(mapper.ProjectTo <ContactDto>(persons));
}
public IEnumerable <Contact> Get()
{
QueriesOrCommands.Add(nameof(GetContactsQuery));
var query = new GetContactsQuery();
var result = GetContacts(query);
GetContactsQueryCount++;
return(result);
}
public async Task <IEnumerable <Domain.Entities.Contact> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
var excludeUsername = _currentUserService.UserId;
var result = await _userService.GetContacts(excludeUsername);
// TODO: what should we do with the result
if (!result.Result.Succeeded)
{
}
return(result.Contacts);
}
public async Task ContactHandler_Get_GetAllAsync()
{
//Arrange
var dateTimeNow = DateTime.Now;
var command = new GetContactsQuery();
var mockContactRepository = new Mock <ContactRepository>(null);
//Act
mockContactRepository.Setup(x => x.GetAsync(It.IsAny <CancellationToken>())).ReturnsAsync(It.IsAny <List <Contact> >);
var sut = new GetContactsQueryHandler(mockContactRepository.Object);
var result = await sut.Handle(command, CancellationToken.None);
//Act
mockContactRepository.Verify(x => x.GetAsync(It.IsAny <CancellationToken>()), Times.Once);
mockContactRepository.VerifyNoOtherCalls();
}
public async Task Sorted_Results()
{
using var factory = new AppDbContextFactory();
using var context = factory.CreateContext(true);
// Arrange
var sut = new GetContactsHandler(_logger, context);
var contact = context.Contacts.First();
var cmd = new GetContactsQuery {
SortBy = nameof(contact.Name), Ascending = false
};
// Act
var results = await sut.Handle(cmd);
// Assert
Assert.True(results.Last().Name == contact.Name);
Assert.True(results.Count() == 2);
}
public async Task Paged_Results()
{
using var factory = new AppDbContextFactory();
using var context = factory.CreateContext(true);
// Arrange
var sut = new GetContactsHandler(_logger, context);
var contact = context.Contacts.First();
var cmd = new GetContactsQuery {
Skip = 1, Take = 1
};
// Act
var results = await sut.Handle(cmd);
// Assert
Assert.DoesNotContain(results, r => r.Name == contact.Name);
Assert.True(results.Count() == 1);
}
public async Task <IListViewModel <ContactViewModel> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
var data = await context.Contacts
.Include(y => y.User)
.OrderBy(x => request.OrderBy)
.Where(x => x.UserId == request.UserId)
.ToPagedListAsync(request.Page, request.PageSize);
if (data.Count == 0)
{
throw new NotFoundException("Dados não econtrados.");
}
return(new ListViewModel <ContactViewModel>
{
Data = mapper.Map <IEnumerable <ContactViewModel> >(data),
HasNext = data.HasNextPage,
TotalItemCount = data.TotalItemCount
});
}
public void SearchCallsCollaborators()
{
var rnd = new Random();
var page = rnd.Next(1, 100);
var size = rnd.Next(1, 100);
var text = Faker.Lorem.GetFirstWord();
var contact = ContactEntityObjectMother.Random();
var toReturn = new SearchResults <ContactDto>(
rnd.Next(1, 100),
new List <ContactDto>()
{
new ContactDto()
{
FirstName = contact.Name.FirstName,
LastName = contact.Name.LastName,
ContactId = contact.Id.Value,
EmailsCount = contact.EmailAddresses.Count,
PhonesCount = contact.PhoneNumbers.Count
}
}
);
repo.Setup(
x => x.SearchByCriteria(It.Is <ContactSearchCriteria>(p => p.PageNumber == page && p.PageSize == size && p.Text == text)))
.Returns(toReturn);
var cmd = new GetContactsQuery(page, size, text);
var handler = new GetContactsQueryHandler(uow.Object, eventBus.Object, repo.Object);
var result = handler.Handle(cmd, new System.Threading.CancellationToken()).Result;
Assert.IsNotNull(result);
Assert.AreEqual(toReturn.Total, result.Total);
Assert.AreEqual(1, result.Results.Count());
Assert.AreEqual(contact.Id.Value, result.Results.First().ContactId);
Assert.AreEqual(contact.Name.FirstName, result.Results.First().FirstName);
Assert.AreEqual(contact.Name.LastName, result.Results.First().LastName);
Assert.AreEqual(contact.EmailAddresses.Count, result.Results.First().EmailsCount);
Assert.AreEqual(contact.PhoneNumbers.Count, result.Results.First().PhonesCount);
}
protected override async Task Handle(ConfirmInfectionCommand request, CancellationToken cancellationToken)
{
var profile = await repository.GetProfileAsync(request.ProfileId, request.DeviceId, cancellationToken);
if (profile == null)
{
throw new DomainException("Profile not found.");
}
if (profile.AuthToken != request.MfaToken)
{
throw new DomainException("Wrong maf token.");
}
if (profile.AuthToken == request.MfaToken)
{
if (profile.ConfirmedInfection == false)
{
profile.ConfirmInfection();
await repository.UnitOfWork.SaveChangesAsync(cancellationToken);
if (request.SendingNotificationsEnabled)
{
var query = new GetContactsQuery(profile.DeviceId, profile.Id);
var result = await mediator.Send(query, cancellationToken);
var groupedContacts = result.Contacts.GroupBy(x => x.ProfileId);
foreach (var contact in groupedContacts)
{
var firstContactFromGroup = contact.First();
var data = new { messageType = "CORONA_INFECTION_CONFIRMED" };
var command = new SendPushNotificationCommand(firstContactFromGroup.ProfileId, data);
await mediator.Send(command, cancellationToken);
}
}
}
}
}
async Task <IEnumerable <ContactView> > IQueryHandler <GetContactsQuery, IEnumerable <ContactView> > .Handle(GetContactsQuery query,
CancellationToken cancellationToken)
{
var result = await _db.QueryAsync <Entity.ContactView>(
new CommandDefinition(
commandText : Entity.ContactView.Sql,
parameters : new
{
OrganisationId = query.OrganisationId,
},
commandType : CommandType.Text,
cancellationToken : cancellationToken
));
return(result.Select(_ => new ContactView(
imgLink: _.ImgLink,
mdBody: _.MdBody,
contactType: _.Type
)));
}
public async Task <IEnumerable <ContactViewModel> > Get([FromQuery] GetContactsQuery query) => await _mediator.Send(query);
public async Task <List <GetContactsQueryDto> > Handle(GetContactsQuery request, CancellationToken cancellationToken)
{
var contacts = await contactRepository.GetAsync(cancellationToken);
return(contacts.Select(GetContactsQueryDto.MapToDto).ToList());
}
public async Task <ActionResult <List <ContactDto> > > Get([FromQuery] GetContactsQuery query)
{
return(await Sender.Send(query));
}
public async Task <ActionResult <IListViewModel <ContactViewModel> > > GetAll([FromQuery] GetContactsQuery query)
{
if (query is null)
{
BadRequest();
}
query.UserId = UserId;
return(Ok(await Mediator.Send(query)));
}