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