public async Task <QueryResponse <GetAllResponse[]> > Handle(GetAllRequest query, CancellationToken cancellationToken) { try { if (!Validate(query)) { return(new QueryResponse <GetAllResponse[]>(MessageType.Validation, new QueryResponseError("Validate", Errors.First()))); } return(new QueryResponse <GetAllResponse[]>(await _dbContext.Set <UserSearchData>() .Where(item => item.UserId.Equals(query.UserId)) .OrderByDescending(item => item.SearchTime) .Select(item => new GetAllResponse() { CityName = item.CityName, Temperature = item.Temperature, Humidity = item.Humidity }) .AsNoTracking() .ToArrayAsync())); } catch (Exception ex) { return(new QueryResponse <GetAllResponse[]>(MessageType.Error, ex)); } }
public Query() { FieldAsync <OrderStateType>("orderState", arguments: new QueryArguments() { new QueryArgument <IntGraphType>() { Name = "id", Description = "Type Ids" }, }, resolve: async context => { var httpContext = context.RequestServices.GetRequiredService <IHttpContextAccessor>().HttpContext; if (!httpContext.User.Identity.IsAuthenticated) { throw new UnauthorizedAccessException(); } if (!httpContext.User.IsInRole("admin")) { throw new UnauthorizedAccessException(); } var authorizationService = context.RequestServices.GetRequiredService <IAuthorizationService>(); var authorizationResult = await authorizationService.AuthorizeAsync(httpContext.User, "PolicyName"); if (!authorizationResult.Succeeded) { throw new UnauthorizedAccessException(); } var service = context.RequestServices.GetRequiredService <IOrderStateService>(); var request = new GetOrderStateRequest(); request.Id = context.GetArgument <int>("id", default(int)); var item = await service.Get(request); return(item); }); FieldAsync <GetAllOrderStateResponseType>("orderStates", resolve: async context => { var service = context.RequestServices.GetRequiredService <IOrderStateService>(); var request = new GetAllRequest(); var items = await service.GetAll(request); return(items); }); FieldAsync <GetAllOrderResponseType>("orders", resolve: async context => { var service = context.RequestServices.GetRequiredService <IOrderService>(); var request = new GetAllRequest(); var items = await service.GetAll(request); return(items); }); }
public async Task <IEnumerable <TodayEventLookup> > GetEventsFromFileAsync() { string ServerAddress = Environment.GetEnvironmentVariable("SERVER_ADDRESS"); var channel = GrpcChannel.ForAddress(ServerAddress); var todayEvents = new TodayEventsService.TodayEventsServiceClient(channel); try { var request = new GetAllRequest(); var response = await todayEvents.GetAllAsync(request); foreach (var todayEvent in response.TodayEvents) { TodayEventLookups.Add(new TodayEventLookup() { Name = todayEvent.Name, Description = todayEvent.Description, Detail = todayEvent.Detail }); } } catch (RpcException e) { _dataProviderErrorMessage = $"{_dataProviderDefaultErrorMessage}{Environment.NewLine}{e.ToString()}"; _dataProviderErrorIsVisible = true; } return(TodayEventLookups); }
/// <summary> /// Retrieves and removes all tuples from the space matching the specified pattern. The operation is non-blocking. The operation will return an empty set if no elements match. /// </summary> public IEnumerable <ITuple> GetAll(params object[] pattern) { GetAllRequest request = new GetAllRequest(this.GetSource(), this.GetSessionId(), this.connectionString.Target, pattern); GetAllResponse response = this.GetMode()?.PerformRequest <GetAllResponse>(request); return(response.Result == null ? null : response.Result.Select(x => this.tupleFactory.Create(x))); }
public async Task <List <UserDto> > GetAll() { var request = new GetAllRequest(); var response = _mediator.Send(request); return(await response); }
/// <summary> /// /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <MessageResponse <GetAllResponse[]> > Handle(GetAllRequest request, CancellationToken cancellationToken) { try { var result = await _dbContext.Set <BookData>() .SelectMany(sm => sm.UserBooks .Where(ub => ub.UserId.Equals(request.UserId)) .DefaultIfEmpty(), (b, ub) => new GetAllResponse { Id = b.Id, Title = b.Title, Author = b.Author, IsAvailable = b.AvailableCopies > 0 && ub == null } ) .AsNoTracking() .ToArrayAsync(cancellationToken: cancellationToken); return(new MessageResponse <GetAllResponse[]>(result)); } catch (Exception e) { return(new MessageResponse <GetAllResponse[]>(MessageType.Error, e)); } }
/// <inheritdoc /> public override Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { Log.GetAll(_logger); var response = new GetAllResponse(); response.EventHandlers.AddRange(_eventHandlers.All.Select(_ => CreateStatusFromInfo(_, request.TenantId?.ToGuid()))); return(Task.FromResult(response)); }
public override Task <GetAllReply> GetAll(GetAllRequest request, ServerCallContext context) { logger.LogDebug("getting all todos"); var reply = new GetAllReply(); reply.Items.AddRange(repository.GetAll().Select(AsMessage)); return(Task.FromResult(reply)); }
private bool Validate(GetAllRequest query) { if (string.IsNullOrEmpty(query.UserId)) { Errors.Add("User Id can not be empty"); } return(Errors.Count == 0); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var series = await _seriesProvider.GetSeries(); return(new GetAllResponse { Series = { series } }); }
/// <summary> /// Retrieves allergens /// </summary> /// <remarks> /// Retrieves all allergens if no query parameters are specified /// </remarks> public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var allergens = await _mediator.Send(new GetAllergensQuery(), context.CancellationToken); return(new GetAllResponse() { Allergens = { _mapper.Map <IEnumerable <Allergen> >(allergens) } }); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var sessions = await _localSessionRepo.GetAll(); return(new GetAllResponse { Sessions = { sessions } }); }
public override Task <ContactsResponse> GetAllContacts(GetAllRequest request, ServerCallContext context) { ContactsResponse response = new ContactsResponse(); foreach (var contact in repository.Contacts) { response.Contact.Add(contact); } return(Task.FromResult(response)); }
public override async Task GetAll(GetAllRequest request, IServerStreamWriter <EmployeeResponse> responseStream, ServerCallContext context) { foreach (var e in Employees.employees) { await responseStream.WriteAsync(new EmployeeResponse() { Employee = e }); } }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var today = await _repository.GetEventsFromFileAsync(); var response = new GetAllResponse(); response.TodayEvents.AddRange(today.TodayEventList.Select(TodayEvent.FromRepositoryModel)); return(response); }
public async Task <IActionResult> GetAll([FromQuery] GetAllRequest request, CancellationToken cancellationToken) { var result = await _adService.GetPaged(new GetPaged.Request { Limit = request.Limit, Offset = request.Offset }, cancellationToken); return(Ok(result)); }
public override async Task GetAll(GetAllRequest request, IServerStreamWriter <UserResponse> responseStream, ServerCallContext context) { foreach (var u in Users.users) { await responseStream.WriteAsync(new UserResponse() { User = u }); } }
/// <summary> /// Server streaming /// </summary> /// <param name="request"></param> /// <param name="responseStream"></param> /// <param name="context"></param> /// <returns></returns> public override async Task GetAll(GetAllRequest request, IServerStreamWriter <EmployeeResponse> responseStream, ServerCallContext context) { Console.WriteLine("GetAll is invoked. Sending all employees as a stream"); foreach (var item in Employees.employees) { await responseStream.WriteAsync(new EmployeeResponse { Employee = item }); } Console.WriteLine("Finished GetAll method."); }
public override async Task GetAll(GetAllRequest request, IServerStreamWriter <NodeResponse> responseStream, ServerCallContext context) { foreach (var e in Nodes.nodes) { await responseStream.WriteAsync(new NodeResponse() { Node = e }); } }
public override async Task GetAll(GetAllRequest request, IServerStreamWriter <XprtResponse> responseStream, ServerCallContext context) { foreach (var x in await _repository.GetAllXprtz()) { await responseStream.WriteAsync(new XprtResponse() { Xprt = x }); } }
GetAll(GetAllRequest request, IServerStreamWriter <EmployeeResponse> responseStream, ServerCallContext context) { foreach (var employee in InMemoryData.Employees) { await responseStream.WriteAsync(new EmployeeResponse { Employee = employee }); } }
public override async Task GetAll(GetAllRequest request, IServerStreamWriter <EmployeeResponse> responseStream, ServerCallContext context) { foreach (var employee in _context.Employees) { await responseStream.WriteAsync(new EmployeeResponse { Employee = _mapper.Map <Employee>(employee) }); } }
public override async Task GetAll(GetAllRequest request, IServerStreamWriter <GetAllResponse> responseStream, ServerCallContext context) { Console.WriteLine("GetAll method invoked. Sending all known locations as a stream"); foreach (var item in repository.locationsCollection) { await responseStream.WriteAsync(new GetAllResponse { Location = item }); } Console.WriteLine("Finished reponse stream"); }
public override async Task GetALLStream(GetAllRequest request, IServerStreamWriter <GetResponce> responseStream, ServerCallContext context) { foreach (var person in _addressBookStorage.GetAll()) { await responseStream.WriteAsync(new GetResponce() { Person = person }); } }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var traderId = ValidateUser(request.TraderId, context); var portfolios = await _repository.GetAllAsync(traderId); var response = new GetAllResponse(); response.Portfolios.AddRange(portfolios.Select(Protos.Portfolio.FromRepositoryModel)); return(response); }
private IMessage PerformGetAll(IMessage request) { ISpace ts = this.repository.GetSpace(request.Target); if (ts != null) { GetAllRequest getReq = (GetAllRequest)request; IEnumerable <ITuple> tuples = ts.GetAll(new Pattern(getReq.Template)); return(new GetAllResponse(request.Source, request.Session, request.Target, tuples?.Select(x => x.Fields) ?? null, StatusCode.OK, StatusMessage.OK)); } return(new GetAllResponse(request.Source, request.Session, request.Target, null, StatusCode.NOT_FOUND, StatusMessage.NOT_FOUND)); }
public override async Task <GetAllResponse> GetAll(GetAllRequest request, ServerCallContext context) { var result = await _notificationService.GetAllNotifications(); var response = new GetAllResponse(); response.Notifications.AddRange(result.Select(n => new Notification() { Message = n.Message })); return(response); }
public override async Task GetAllLogs(GetAllRequest request, IServerStreamWriter <GetLogResponse> responseStream, ServerCallContext context) { List <LogMessage> logs = await db.GetAllLogs(); foreach (var log in logs) { await responseStream.WriteAsync(new GetLogResponse() { Log = log }); } }
/// <inheritdoc /> public async Task <IEnumerable <Dolittle.Runtime.Events.EventType> > GetAll(MicroserviceAddress runtime) { var client = _clients.CreateClientFor <EventTypesClient>(runtime); var request = new GetAllRequest(); var response = await client.GetAllAsync(request); if (response.Failure is not null) { throw new GetAllFailed(response.Failure.Reason); } return(response.EventTypes.Select(FromProtobuf)); }
/// <summary> /// Get. /// </summary> public virtual async Task <GetAllResponse <TEntity> > GetAll <TEntity>(GetAllRequest request) where TEntity : IEntity { if (request == null) { throw new ArgumentNullException(nameof(request)); } request.Connect = this.ApiConnect; request.Connect.Action = "index"; return(await HttpFacade <GetAllRequest, GetAllResponse <TEntity> > .instance.QueryAsync(request)); }