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(); }