public async Task <IActionResult> SearchAsync(string term)
{
var queryModel = new GetSearchQueryModel
{
Term = term
};
GetSearchResultModel resultModel;
try
{
resultModel = await _queryHandler.HandleAsync(queryModel);
}
catch (QueryModelException ex)
{
// When Query model validation fails.
_logger.LogError(ex.Message, ex);
throw;
}
catch (FailedApiRequestException ex)
{
// When Panviva API results in a error.
_logger.LogError(ex.Message, ex);
throw;
}
return(Ok(resultModel));
}
public async Task <ActionResult <GameFollowResponse> > GetGameAsync(Guid gameId)
{
var query = new GetGameQuery(gameId);
var game = await _getGameQueryHandler.HandleAsync(query);
return(Ok(game));
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_UserOutputQuery_When_InputQuery_Is_Null()
{
var user = User.Builder()
.SetId(Guid.NewGuid())
.SetEmail("*****@*****.**")
.SetServiceActive(DefaultUserSettings.ServiceActive)
.SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit)
.SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency)
.Build();
var users = new List <User> {
user
};
var userOutputQueries = users.Select(x => new UserOutputQuery(user.Id, user.Email, user.Picture,
user.ServiceActive, user.AnnouncementPreferenceLimit, user.AnnouncementSendingFrequency,
new List <RoomForRentAnnouncementPreferenceOutputQuery>(),
new List <FlatForRentAnnouncementPreferenceOutputQuery>())).ToList();
var expectedResult = new CollectionOutputQuery <UserOutputQuery>(userOutputQueries.Count(), userOutputQueries);
_userRepositoryMock.Setup(x => x.GetAllAsync()).ReturnsAsync(users);
_userRepositoryMock.Setup(x => x.CountAsync()).ReturnsAsync(users.Count);
_mapperMock.Setup(x => x.Map <List <User>, IEnumerable <UserOutputQuery> >(It.IsAny <List <User> >()))
.Returns(userOutputQueries);
var result = await _queryHandler.HandleAsync(null);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_GetAccountsOutputQuery_When_Input_Is_Not_Null()
{
var getAccountsInputQuery = new GetAccountsInputQuery(1, 100, "email:asc", "*****@*****.**", true);
var account = Account.Builder()
.SetId(Guid.NewGuid())
.SetEmail(getAccountsInputQuery.Email)
.SetConfirmed(true)
.SetPasswordHash("PasswordHash")
.SetSecurityStamp(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetRoles(new List <Guid> {
Guid.NewGuid()
})
.Build();
var accounts = new List <Account> {
account
};
var getAccountsOutputQueries = accounts
.Select(x => new GetAccountsOutputQuery(x.Id, x.Email, x.Confirmed, x.Created,
!string.IsNullOrWhiteSpace(x.PasswordHash), x.LastLogin)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <GetAccountsOutputQuery>(getAccountsOutputQueries.Count, getAccountsOutputQueries);
_accountRepositoryMock.Setup(x => x.FindAsync(It.IsAny <int?>(), It.IsAny <int?>(), It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <bool>())).ReturnsAsync(accounts);
_accountRepositoryMock.Setup(x => x.CountAsync(It.IsAny <string>(), It.IsAny <bool>())).ReturnsAsync(accounts.Count);
_mapperMock.Setup(x => x.Map <List <Account>, IEnumerable <GetAccountsOutputQuery> >(It.IsAny <List <Account> >()))
.Returns(getAccountsOutputQueries);
var result = await _queryHandler.HandleAsync(getAccountsInputQuery);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_CityDistrictOutputQuery_When_Input_Is_Null()
{
var cityDistricts = new List <CityDistrict>
{
CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.Build()
};
var cityDistrictOutputQueries = cityDistricts.Select(x =>
new CityDistrictOutputQuery(x.Id, x.RowVersion, x.Name, x.PolishName, x.CityId, x.ParentId, x.NameVariants)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <CityDistrictOutputQuery>(cityDistricts.Count, cityDistrictOutputQueries);
_cityDistrictRepositoryMock.Setup(x => x.GetAllAsync()).ReturnsAsync(cityDistricts);
_cityDistrictRepositoryMock.Setup(x => x.CountAsync()).ReturnsAsync(cityDistricts.Count);
_mapperMock
.Setup(x => x.Map <List <CityDistrict>, IEnumerable <CityDistrictOutputQuery> >(It.IsAny <List <CityDistrict> >()))
.Returns(cityDistrictOutputQueries);
var result = await _queryHandler.HandleAsync(null);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task <IActionResult> GetFlatForRentAnnouncementAsync(Guid id)
{
var getFlatForRentAnnouncementOutputQuery = await _getFlatForRentAnnouncementQueryHandler.HandleAsync(new GetFlatForRentAnnouncementInputQuery(id));
var getFlatForRentAnnouncementResponse = _mapper.Map <FlatForRentAnnouncementOutputQuery, FlatForRentAnnouncementResponse>(getFlatForRentAnnouncementOutputQuery);
return(Ok(getFlatForRentAnnouncementResponse));
}
public async Task <IActionResult> GetStateAsync([FromRoute] Guid id)
{
var getStateOutputQuery = await _getStateQueryHandler.HandleAsync(new GetStateInputQuery(id));
var stateResponse = _mapper.Map <StateOutputQuery, StateResponse>(getStateOutputQuery);
return(Ok(stateResponse));
}
public async Task <IActionResult> GetCityAsync([FromRoute] Guid id)
{
var getCityOutputQuery = await _getCityQueryHandler.HandleAsync(new GetCityInputQuery(id));
var cityResponse = _mapper.Map <CityOutputQuery, CityResponse>(getCityOutputQuery);
return(Ok(cityResponse));
}
public async Task <ModifiedDocumentModel> GetAsync(string id)
{
var getDocumentQueryModel = new GetDocumentQueryModel
{
Id = id
};
var getDocumentContainersQueryModel = new GetDocumentContainersQueryModel
{
Id = id
};
var getDocumentTranslationsQueryModel = new GetDocumentTranslationsQueryModel
{
Id = id
};
var getDocumentContainerRelationshipsQueryModel = new GetDocumentContainerRelationshipsQueryModel
{
Id = id
};
var getContainersTask = _queryHandler.HandleAsync(getDocumentContainersQueryModel);
var getContainerRelationships = _queryHandler.HandleAsync(getDocumentContainerRelationshipsQueryModel);
var getTranslationsTask = _queryHandler.HandleAsync(getDocumentTranslationsQueryModel);
GetDocumentResultModel mainDocument;
try
{
// Execute calls to Panviva through SDK.
mainDocument = await _queryHandler.HandleAsync(getDocumentQueryModel);
Task.WaitAll(getTranslationsTask, getContainerRelationships, getContainersTask);
}
catch (QueryModelException ex)
{
// When Query model validation fails.
_logger.LogError(ex.Message, ex);
throw;
}
catch (FailedApiRequestException ex)
{
// When Panviva API results in a error.
_logger.LogError(ex.Message, ex);
throw;
}
var finalResult = Mapper.Map(mainDocument);
finalResult.Containers = getContainersTask.Result.Containers;
finalResult.Translations = getTranslationsTask.Result.Translations;
finalResult.Origin = getTranslationsTask.Result.Origin;
finalResult.Relationships = getContainerRelationships.Result.Relationships;
return(finalResult);
}
public async Task <TResult> HandleAsync(TQuery query)
{
var info = _queryCacheManager.GetInfo <TQuery, TResult>(query);
if (info.NoCache)
{
return(await _innerQueryHandler.HandleAsync(query));
}
var cacheService = _queryCacheManager.GetCacheService();
return(await cacheService.GetOrCreateAsync(info, async() => await _innerQueryHandler.HandleAsync(query)));
}
public async Task HandleAsync_Should_Return_RoleOutputQuery()
{
var role = new Role(Guid.NewGuid(), Array.Empty <byte>(), DefaultRoleEnumeration.Administrator.DisplayName);
var getRoleResult = GetResult <Role> .Ok(role);
var roleOutputQuery = new RoleOutputQuery(role.Id, role.RowVersion, role.Name);
_roleGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getRoleResult);
_mapperMock.Setup(x => x.Map <Role, RoleOutputQuery>(It.IsAny <Role>())).Returns(roleOutputQuery);
var result = await _queryHandler.HandleAsync(new GetRoleInputQuery(role.Id));
result.Should().BeEquivalentTo(roleOutputQuery);
}
public async Task <IActionResult> GetUserAsync([FromRoute] Guid id)
{
var authResult = await _authorizationService.AuthorizeAsync(User, id, ResourceOwnerPolicy.ResourceOwnerPolicyName);
if (!authResult.Succeeded)
{
return(CreateErrorResult(HttpStatusCode.Forbidden));
}
var getUserOutputQuery = await _getUserQueryHandler.HandleAsync(new GetUserInputQuery(id));
var userResponse = _mapper.Map <UserOutputQuery, UserResponse>(getUserOutputQuery);
return(Ok(userResponse));
}
public async Task <IActionResult> GetConnections(
[FromQuery] string clientType,
[FromQuery] string clientId,
[FromQuery] string channelType,
[FromQuery] string channelId
)
{
var query = new FindConnectionsByClientTypeClientIdChannelTypeChannelId();
if (!string.IsNullOrEmpty(clientType))
{
query.ClientType = ClientType.Create(clientType);
}
if (!string.IsNullOrEmpty(clientId))
{
query.ClientId = ClientId.Create(clientId);
}
if (!string.IsNullOrEmpty(channelType))
{
query.ChannelType = ChannelType.Create(channelType);
}
if (!string.IsNullOrEmpty(channelId))
{
query.ChannelId = ChannelId.Create(channelId);
}
IEnumerable <Connection> connections;
try
{
connections =
await _findConnectionsByClientTypeClientIdChannelTypeChannelIdQueryHandler.HandleAsync(query);
}
catch (ValidationException validationException)
{
return(StatusCode(
(int)HttpStatusCode.UnprocessableEntity,
new { message = validationException.MessageToUser }
));
}
var connectionDtos = connections.Select(ConnectionDto.CreateFromConnection);
return(Ok(new ItemsEnvelope <ConnectionDto>(connectionDtos)));
}
public async Task <ActionResult <ICollection <PlayerResponse> > > GetTeamsPlayersAsync(Guid teamId)
{
var query = new GetTeamsPlayersQuery(teamId);
var players = await _getTeamsPlayersQueryHandler.HandleAsync(query);
return(Ok(players));
}
public async Task <ActionResult <ICollection <TeamResponse> > > GetAsync()
{
var query = new GetTeamsQuery();
var teams = await _getTeamsQueryHandler.HandleAsync(query);
return(Ok(teams));
}
public async Task <ActionResult <ICollection <GoalStatsResponse> > > GetGamesGoalStatsAsync(Guid gameId)
{
var query = new GetGamesGoalStatsQuery(gameId);
var stats = await _getGamesGoalStatsQueryHandler.HandleAsync(query);
return(Ok(stats));
}
public async Task <ActionResult <ICollection <TournamentResponse> > > GetTournamentsByYearAsync(int year)
{
var query = new GetTournamentsByYearQuery(year);
var tournaments = await _getTournamentsByYearQueryHandler.HandleAsync(query);
return(Ok(tournaments));
}
private void UpdateUsers()
{
var query = AllUsersQuery.Create();
var result = _allUsersQueryHandler.HandleAsync(query).Result;
Users = result.UserDtos;
}
public async Task <ActionResult <ICollection <GameFollowResponse> > > GetTournamentGamesAsync(Guid?tournamentId)
{
var query = new GetGamesByTournamentIdQuery(tournamentId);
var games = await _getGamesByTournamentIdQueryHandler.HandleAsync(query);
return(Ok(games));
}
public async Task <ActionResult <ICollection <GameResponse> > > GetGamesAsync(int year, int month)
{
var query = new GetNonTournamentGamesByTimeLimitQuery(year, month);
var games = await _getNonTournamentGamesByTimeLimitQueryHandler.HandleAsync(query);
return(Ok(games));
}
public Task <TResult> HandleAsync(TQuery query, CancellationToken cancellationToken = default)
{
string queryJson = JsonSerializer.Serialize(query);
Console.WriteLine($"Query of type {query.GetType().Name}: {queryJson}");
return(_handler.HandleAsync(query, cancellationToken));
}
public async Task HandleAsync(PublishJokeCommand command, CancellationToken cancellationToken = default)
{
IList <Flag> flags = command.Flags != null && command.Flags.Any() ? await _getFlagsByNamesQuery.HandleAsync(new GetFlagsByNamesQuery(command.Flags), cancellationToken) : null;
IList <Category> categories = await _getCategoriesByNamesQuery.HandleAsync(new GetCategoriesByNamesQuery(new List <string> {
command.Category
}), cancellationToken);
Joke joke = new Joke
{
CategoryId = categories.First().Id,
CreateDate = DateTime.Now,
JokeFlags = flags?.Select(f => new JokeFlag()
{
FlagId = f.Id,
}).ToList(),
Parts = command.Parts.Select((p, i) => new Part()
{
JokePart = p,
Order = i + 1
}).ToList()
};
await _context.Jokes.AddAsync(joke, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
}
public async Task <ActionResult> Risks_Read([DataSourceRequest] DataSourceRequest request)
{
var query = new FindRisksForPolicyQuery()
{
PolicyId = policyId
};
var result =
await
findRisksForPolicyHandler.HandleAsync(new FindPagedQuery <FindRisksForPolicyQuery, Risk>()
{
Query = query,
PageNumber = request.Page,
PageSize = request.PageSize
});
int total = result.Total;
var risks = result.Result;
//var viewModelCollection = Mapper.Map<IEnumerable<RiskViewModel>>(risks);
return(Json(new
{
Data = risks,
Total = total
}));
}
private async Task <IDictionary <string, int> > ContestRanking(IEnumerable <string> userIds)
{
var userRanking = new Dictionary <string, int>();
foreach (var userId in userIds)
{
var contestScoreQuery = ContestScoreQuery.Create(userId, ContestId);
var contestScore = await _contestScoreQueryHandler.HandleAsync(contestScoreQuery);
userRanking.Add(userId, contestScore.Score);
}
int position = 0;
userRanking = userRanking
.OrderByDescending(k => k.Value)
.Select(v =>
{
++position;
return(v.Key, position);
})
.ToDictionary(v => v.Key, v => v.position);
return(userRanking);
}
public Task <TResult> HandleAsync(TQuery query)
{
string queryJson = JsonConvert.SerializeObject(query);
Console.WriteLine($"Query of type {query.GetType().Name}: {queryJson}");
return(_handler.HandleAsync(query));
}
public async Task HandleAsync_Should_Return_RoomForRentAnnouncementOutputQuery()
{
var roomForRentAnnouncement = RoomForRentAnnouncement.Builder()
.SetId(Guid.NewGuid())
.SetTitle("Title")
.SetSourceUrl("http://source")
.SetCityId(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetDescription("Description")
.SetPrice(1000)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.SetRoomTypes(new List <RoomTypeEnumeration> {
RoomTypeEnumeration.Double
})
.Build();
var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement);
var roomForRentAnnouncementOutputQuery = new RoomForRentAnnouncementOutputQuery(roomForRentAnnouncement.Id,
roomForRentAnnouncement.Title, roomForRentAnnouncement.SourceUrl, roomForRentAnnouncement.CityId,
roomForRentAnnouncement.Created, roomForRentAnnouncement.Description, roomForRentAnnouncement.Price,
roomForRentAnnouncement.RoomTypes, roomForRentAnnouncement.CityDistricts);
_roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getRoomForRentAnnouncementResult);
_mapperMock
.Setup(x => x.Map <RoomForRentAnnouncement, RoomForRentAnnouncementOutputQuery>(It.IsAny <RoomForRentAnnouncement>()))
.Returns(roomForRentAnnouncementOutputQuery);
var result = await _queryHandler.HandleAsync(new GetRoomForRentAnnouncementInputQuery(roomForRentAnnouncement.Id));
result.Should().BeEquivalentTo(roomForRentAnnouncementOutputQuery);
}
public async Task HandleAsync_Should_Return_FlatForRentAnnouncementOutputQuery()
{
var flatForRentAnnouncement = FlatForRentAnnouncement.Builder()
.SetId(Guid.NewGuid())
.SetTitle("Title")
.SetSourceUrl("http://source")
.SetCityId(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetDescription("Description")
.SetNumberOfRooms(NumberOfRoomsEnumeration.One)
.SetPrice(1000)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.Build();
var getFlatForRentAnnouncementResult = GetResult <FlatForRentAnnouncement> .Ok(flatForRentAnnouncement);
var flatForRentAnnouncementOutputQuery = new FlatForRentAnnouncementOutputQuery(flatForRentAnnouncement.Id,
flatForRentAnnouncement.Title, flatForRentAnnouncement.SourceUrl, flatForRentAnnouncement.CityId,
flatForRentAnnouncement.Created, flatForRentAnnouncement.Description, flatForRentAnnouncement.Price,
flatForRentAnnouncement.NumberOfRooms, flatForRentAnnouncement.CityDistricts);
_flatForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getFlatForRentAnnouncementResult);
_mapperMock
.Setup(x => x.Map <FlatForRentAnnouncement, FlatForRentAnnouncementOutputQuery>(It.IsAny <FlatForRentAnnouncement>()))
.Returns(flatForRentAnnouncementOutputQuery);
var result = await _queryHandler.HandleAsync(new GetFlatForRentAnnouncementInputQuery(flatForRentAnnouncement.Id));
result.Should().BeEquivalentTo(flatForRentAnnouncementOutputQuery);
}
public async Task <ActionResult <RetailGroupDto> > Get([FromRoute] string id)
{
Console.WriteLine("Received request");
var retailGroupDto = await _getRetailGroupHandler.HandleAsync(new GetRetailGroup()
{
Id = id
});
if (retailGroupDto == null)
{
Console.WriteLine("Couldn't find retail group");
return(NotFound());
}
return(retailGroupDto);
}
private void UpdateContestSolutions()
{
var query = AggregateContestSolutionsQuery.Create(ContestId);
var queryResult = _aggregateContestSolutionsQueryHandler.HandleAsync(query).Result;
ContestSolutions = queryResult.Aggregate;
}
public async Task <T> ExecuteHandlerAsync <T>(IQueryHandler <T> handler, CancellationToken token)
{
var cmd = this.BuildCommand(handler);
using var reader = await Database.ExecuteReaderAsync(cmd, token).ConfigureAwait(false);
return(await handler.HandleAsync(reader, this, token).ConfigureAwait(false));
}
public async Task ShouldReturnCustomerListForValidCountry(IQueryHandler<CustomersQuery, Customer[]> queryHandler)
{
var query = new CustomersQuery { Country = "Germany" };
var result = await queryHandler.HandleAsync(query);
result.ShouldNotBeEmpty();
}
public async Task ShouldReturnEmptyListForUnknownCountry(IQueryHandler<CustomersQuery, Customer[]> queryHandler)
{
var query = new CustomersQuery { Country = "Fantasyland" };
var result = await queryHandler.HandleAsync(query);
result.ShouldBeEmpty();
}
