IObservable <Company> Subscribe(ResolveEventStreamContext context, ContextFactory contextFactory, ILogger logger)
{
long lastId = 0;
var inner = Observable.Using(
token => Task.FromResult(contextFactory.BuildContext()),
async(ctx, token) =>
{
try
{
var companies = await GetCompanies(context, ctx, lastId, token: token);
if (companies.Any())
{
lastId = companies.Max(transaction => transaction.Id);
}
return(companies.ToObservable());
}
catch (OperationCanceledException)
{
logger.LogInformation("Companies subscription has been cancelled.");
return(Observable.Empty <Company>());
}
catch (Exception e)
{
logger.LogError(e, "Unable to get companies.");
return(Observable.Empty <Company>());
}
});
return(Observable.Interval(TimeSpan.FromSeconds(1)).SelectMany(_ => inner));
}
private IObservable <Device> deviceUpdatedSubscribe(ResolveEventStreamContext context)
{
var id = context.GetArgument <int>("id");
var deviceJson = context.GetArgument <string>("deviceJson");
return(_hd.ObservableDevices(d => true));
}
private async Task <IObservable <object> > Subscribe(FellowLibrary.Crawler.MarketProvidersConfiguration configuration,
ResolveEventStreamContext context)
{
if (context == null)
{
throw new ArgumentNullException();
}
var marketProvider = context.GetArgument <int?>("marketProvider");
if (!marketProvider.HasValue)
{
throw new ArgumentNullException();
}
var marketProviderConfiguration = configuration.FirstOrDefault(x => x.ID == marketProvider.Value);
if (marketProviderConfiguration == null)
{
throw new ArgumentException();
}
var tradingPair = context.GetArgument <String>("tradingPair");
if (String.IsNullOrEmpty(tradingPair))
{
throw new ArgumentNullException();
}
IObservable <object> observable = await FellowLibrary.Crawler.TradeEntrySubscription.Start(marketProviderConfiguration, tradingPair);
return(observable);
}
static IObservable <Company> Subscribe(ResolveEventStreamContext context, Func <SampleDbContext> contextFactory)
{
long lastId = 0;
var inner = Observable.Using(
token => Task.FromResult(contextFactory()),
async(dbContext, token) =>
{
try
{
var companies = await GetCompanies(context, dbContext, lastId, token: token);
if (companies.Any())
{
lastId = companies.Max(transaction => transaction.Id);
}
return(companies.ToObservable());
}
catch (OperationCanceledException)
{
Trace.Write("Companies subscription has been cancelled.");
return(Observable.Empty <Company>());
}
});
return(Observable.Interval(TimeSpan.FromSeconds(1)).SelectMany(_ => inner));
}
private IObservable <Contracts.Vehicle> GetVehicleChangeSubscription(ResolveEventStreamContext context)
{
var outputStream = new InMemoryGrpcStream <Contracts.Vehicle>();
_ = _vehicleReadService.GetVehicleUpdates(new Empty(), outputStream, new InMemoryGrpcServerCallContext());
return(outputStream.AsObservable());
}
private IObservable <SiteSettings> SubscribeById(ResolveEventStreamContext context)
{
var id = context.GetArgument <Guid>("id");
return(_siteService
.WhenSiteUpdated
.Where(x => x.Id == id));
}
private IObservable <Message> SubscribeById(ResolveEventStreamContext context)
{
var id = context.GetArgument <string>("id");
var messages = _chat.Messages();
return(messages.Where(message => message.From.Id == id));
}
private async Task <IObservable <Message> > SubscribeByIdAsync(ResolveEventStreamContext context)
{
var id = context.GetArgument <string>("id");
var messages = await _chat.MessagesAsync();
return(messages.Where(message => message.From.Id == id));
}
private IObservable <Device> SubscribeByStatus(ResolveEventStreamContext context)
{
var isOnline = context.GetArgument <bool>("isOnline");
// find all devices that has status match the "isOnline" input
var devices = _hd.ObservableDevices(d => d.IsOnline == isOnline);
return(devices);
}
public IObservable <object> Subscribe(ResolveEventStreamContext context)
{
var result = Resolve(context);
if (result is Task <object> )
{
result = (result as Task <object>).Result;
}
return((IObservable <object>)result);
}
public IObservable <Sinistrographico[]> Sinistroproduto(ResolveEventStreamContext context)
{
var conString = "Data Source=172.16.16.18;Initial Catalog=DBIS_DEV;User ID=sa;Password=snirdb@2019;MultipleActiveResultSets=True;";
using (var con = new SqlConnection(conString))
{
var sqlQuery = $"select COUNT(*) as QtdSinistro,LinhaProduto.Designacao as Produto from Sinistro,Pessoa,LinhaProduto,PlanoProduto where Sinistro.ParticipanteSinistroID=Pessoa.IdPessoa and Sinistro.PlanoProdutoId=PlanoProduto.IdPlano and PlanoProduto.LinhaProdutoID=LinhaProduto.IdLinhaProduto Group by LinhaProduto.Designacao";
var sinistrs = con.Query <Sinistrographico>(sqlQuery);
var casted = Observable.ToArray(sinistrs.ToObservable());
return(casted);
}
}
private IObservable <Message> Subscribe(ResolveEventStreamContext context)
{
var messageContext = context.UserContext.As <MessageHandlingContext>();
var user = messageContext.Get <ClaimsPrincipal>("user");
var sub = "Anonymous";
if (user != null)
{
sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
}
return(_chat.Messages(sub));
}
private IObservable <OrderEvent> Subscribe(ResolveEventStreamContext context)
{
var statusList = context.GetArgument <IList <OrderStatuses> >("statuses", new List <OrderStatuses>());
if (statusList.Any())
{
var statuses = statusList.Aggregate((finalStatuses, status) => finalStatuses | status);
return(_events.EventStream()
.Where(objectEvent => (objectEvent.Status & statuses) == objectEvent.Status));
}
return(_events.EventStream());
}
public IObservable <PlanoCormecialProdutoDto> QuaPlanoObjectivoComercial(ResolveEventStreamContext context)
{
#if !DEBUG
var conString = _configuration["ConnectionStrings:Connection"];
#else
var conString = _configuration["ConnectionStrings:DefaultConnection"];
#endif
using (var con = new SqlConnection(conString))
{
var sqlQuery = $"SELECT sum(Quantidade) as Quantidade,LinhaProduto.Designacao as Produto from PlanoObjectivoComercial ,LinhaProduto WHERE PlanoObjectivoComercial.LinhaProdutoId=LinhaProduto.IdLinhaProduto GROUP BY LinhaProduto.Designacao";
var planos = con.Query <PlanoCormecialProdutoDto>(sqlQuery);
return(planos.ToObservable());
}
}
public IObservable <PlanoObjectivoCormecialDto> PiPlanoObjectivoComercial(ResolveEventStreamContext context)
{
#if !DEBUG
var conString = _configuration["ConnectionStrings:Connection"];
#else
var conString = _configuration["ConnectionStrings:DefaultConnection"];
#endif
using (var con = new SqlConnection(conString))
{
var sqlQuery = $"select sum(Quantidade) as Quantidade,month(DataPlanoFim) as Mes from PlanoObjectivoComercial GROUP BY month(DataPlanoFim),Quantidade";
var planos = con.Query <PlanoObjectivoCormecialDto>(sqlQuery);
return(planos.ToObservable());
}
}
public IObservable <Sinistrographico> Sinistroproduto(ResolveEventStreamContext context)
{
#if !DEBUG
var conString = _configuration["ConnectionStrings:Connection"];
#else
var conString = _configuration["ConnectionStrings:DefaultConnection"];
#endif
using (var con = new SqlConnection(conString))
{
var sqlQuery = $"select COUNT(*) as QtdSinistro,LinhaProduto.Designacao as Produto from Sinistro,Pessoa,LinhaProduto,PlanoProduto where Sinistro.ParticipanteSinistroID=Pessoa.IdPessoa and Sinistro.PlanoProdutoId=PlanoProduto.IdPlano and PlanoProduto.LinhaProdutoID=LinhaProduto.IdLinhaProduto Group by LinhaProduto.Designacao";
var sinistrs = con.Query <Sinistrographico>(sqlQuery);
var casted = new ObservableCollection <Sinistrographico>(sinistrs).ToObservable();
return(casted);
}
}
public IObservable <ApoliceGraphico> Apoliceproduto(ResolveEventStreamContext context)
{
#if !DEBUG
var conString = _configuration["ConnectionStrings:Connection"];
#else
var conString = _configuration["ConnectionStrings:DefaultConnection"];
#endif
string id = context.Arguments["id"] as string;
using (var con = new SqlConnection(conString))
{
var sqlQuery = $"select COUNT(*) as QtdApolice,LinhaProduto.Designacao as Produto from {nameof(Apolice)},{nameof(Pessoa)},{nameof(LinhaProduto)},{nameof(PlanoProduto)} where Apolice.ProdutorID=Pessoa.IdPessoa and Apolice.PlanoProdutoId=PlanoProduto.IdPlano and PlanoProduto.LinhaProdutoID=LinhaProduto.IdLinhaProduto Group by LinhaProduto.Designacao";
var apolic = con.Query <ApoliceGraphico>(sqlQuery);
return(apolic.ToObservable());
}
}
private IObservable <MovieEvent> Subscribe(ResolveEventStreamContext context)
{
var ratingList = context.GetArgument <IList <MovieRating> >("movieRating", new List <MovieRating>());
if (ratingList.Any())
{
MovieRating ratings = 0;
foreach (var rating in ratingList)
{
ratings = rating | rating;
}
return(_movieEventService.EventStream().Where(e => (e.MovieRating & ratings) == e.MovieRating));
}
else
{
return(_movieEventService.EventStream());
}
}
private IObservable <Message> SubscribeById(ResolveEventStreamContext context)
{
var messageContext = context.UserContext.As <MessageHandlingContext>();
var user = messageContext.Get <ClaimsPrincipal>("user");
var sub = "Anonymous";
if (user != null)
{
sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
}
var messages = _chat.Messages(sub);
var id = context.GetArgument <string>("id");
return(messages.Where(message => message.From.Id == id));
}
private IObservable <OrderEvent> Subscribe(ResolveEventStreamContext context)
{
var statusList = context.GetArgument <IList <OrderStatuses> >("statuses", new List <OrderStatuses>());
if (statusList.Count > 0)
{
OrderStatuses statuses = 0;
foreach (var status in statusList)
{
statuses = statuses | status;
}
return(_events.EventStream().Where(e => (e.Status & statuses) == e.Status));
}
else
{
return(_events.EventStream());
}
}
private IObservable <OrderEvent> Subscribe(ResolveEventStreamContext context)
{
var statusList =
context.GetArgument <IList <OrderStatusesEnum> >("statuses", new List <OrderStatusesEnum>());
if (statusList.Count > 0)
{
OrderStatusesEnum statuses = 0;
foreach (var status in statusList)
{
statuses = statuses | status;
}
return(_eventService.EventStream().Where(x => (x.Status & statuses) == x.Status));
}
return(_eventService.EventStream());
}
async Task <List <Company> > GetCompanies(
ResolveEventStreamContext context,
MyDataContext ctx,
long lastId,
int take = 1,
CancellationToken token = default)
{
var returnType = ctx.Companies;
var document = new GraphQLDocumentBuilder().Build(SupposePersistedQuery());
var fieldContext = ResolveFieldContext(ctx, token, document, context.Schema);
var withArguments = returnType.ApplyGraphQlArguments(fieldContext);
var greaterThanLastIdAndPaged = withArguments
.Where(transaction => transaction.Id > lastId)
.Take(take);
return(await greaterThanLastIdAndPaged.ToListAsync(token));
}
private IObservable <PersonEvent> Subscribe(ResolveEventStreamContext arg)
{
var statusList = arg.GetArgument <IList <PersonStatusEnum> >(
"statuses",
new List <PersonStatusEnum>()
);
if (statusList.Count > 0)
{
PersonStatusEnum statuses = 0;
foreach (var status in statusList)
{
statuses = statuses | status;
}
return(_personEventService.EventStream()
.Where(e => (e.Status & statuses) == e.Status));
}
else
{
return(_personEventService.EventStream());
}
}
private IObservable <Human> Subscribe(ResolveEventStreamContext context)
{
List <Human> listOfHumans = new List <Human>();
var task = _starWarsData.GetHumanByIdAsync("1");
task.Wait();
var result = task.Result;
if (result != null)
{
listOfHumans.Add(task.Result);
}
task = _starWarsData.GetHumanByIdAsync("2");
task.Wait();
result = task.Result;
if (result != null)
{
listOfHumans.Add(task.Result);
}
return(listOfHumans.ToObservable());
}
protected virtual async Task <IObservable <ExecutionResult> > ResolveEventStreamAsync(ExecutionContext context, ExecutionNode node)
{
context.CancellationToken.ThrowIfCancellationRequested();
var arguments = GetArgumentValues(
context.Schema,
node.FieldDefinition.Arguments,
node.Field.Arguments,
context.Variables);
object source = (node.Parent != null)
? node.Parent.Result
: context.RootValue;
try
{
var resolveContext = new ResolveEventStreamContext
{
FieldName = node.Field.Name,
FieldAst = node.Field,
FieldDefinition = node.FieldDefinition,
ReturnType = node.FieldDefinition.ResolvedType,
ParentType = node.GetParentType(context.Schema),
Arguments = arguments,
Source = source,
Schema = context.Schema,
Document = context.Document,
Fragments = context.Fragments,
RootValue = context.RootValue,
UserContext = context.UserContext,
Operation = context.Operation,
Variables = context.Variables,
CancellationToken = context.CancellationToken,
Metrics = context.Metrics,
Errors = context.Errors,
Path = node.Path
};
var eventStreamField = node.FieldDefinition as EventStreamFieldType;
IObservable <object> subscription;
if (eventStreamField?.Subscriber != null)
{
subscription = eventStreamField.Subscriber.Subscribe(resolveContext);
}
else if (eventStreamField?.AsyncSubscriber != null)
{
subscription = await eventStreamField.AsyncSubscriber.SubscribeAsync(resolveContext).ConfigureAwait(false);
}
else
{
throw new InvalidOperationException($"Subscriber not set for field {node.Field.Name}");
}
return(subscription
.Select(value =>
{
var executionNode = BuildExecutionNode(node.Parent, node.GraphType, node.Field, node.FieldDefinition, node.IndexInParentNode);
executionNode.Source = value;
return executionNode;
})
.SelectMany(async executionNode =>
{
if (context.Listeners != null)
{
foreach (var listener in context.Listeners)
{
await listener.BeforeExecutionAsync(context)
.ConfigureAwait(false);
}
}
// Execute the whole execution tree and return the result
await ExecuteNodeTreeAsync(context, executionNode).ConfigureAwait(false);
if (context.Listeners != null)
{
foreach (var listener in context.Listeners)
{
await listener.AfterExecutionAsync(context)
.ConfigureAwait(false);
}
}
return new ExecutionResult
{
Data = new Dictionary <string, object>
{
{ executionNode.Name, executionNode.ToValue() }
}
}.With(context);
})
.Catch <ExecutionResult, Exception>(exception =>
Observable.Return(
new ExecutionResult
{
Errors = new ExecutionErrors
{
GenerateError(
context,
$"Could not subscribe to field '{node.Field.Name}' in query '{context.Document.OriginalQuery}'",
node.Field,
node.Path,
exception)
}
}.With(context))));
}
catch (Exception ex)
{
var message = $"Error trying to resolve {node.Field.Name}.";
var error = GenerateError(context, message, node.Field, node.Path, ex);
context.Errors.Add(error);
return(null);
}
}
async Task <IObservable <object> > IAsyncEventStreamResolver.SubscribeAsync(ResolveEventStreamContext context)
{
var result = await SubscribeAsync(context);
return((IObservable <object>)result);
}
public Task <IObservable <T> > SubscribeAsync(ResolveEventStreamContext context)
{
return(_subscriber(context));
}
protected virtual IObservable <ExecutionResult> ResolveEventStream(ExecutionContext context, ExecutionNode node)
{
context.CancellationToken.ThrowIfCancellationRequested();
var arguments = GetArgumentValues(
context.Schema,
node.FieldDefinition.Arguments,
node.Field.Arguments,
context.Variables);
object source = (node.Parent != null)
? node.Parent.Result
: context.RootValue;
try
{
var resolveContext = new ResolveEventStreamContext
{
FieldName = node.Field.Name,
FieldAst = node.Field,
FieldDefinition = node.FieldDefinition,
ReturnType = node.FieldDefinition.ResolvedType,
ParentType = node.GraphType as IObjectGraphType,
Arguments = arguments,
Source = source,
Schema = context.Schema,
Document = context.Document,
Fragments = context.Fragments,
RootValue = context.RootValue,
UserContext = context.UserContext,
Operation = context.Operation,
Variables = context.Variables,
CancellationToken = context.CancellationToken,
Metrics = context.Metrics,
Errors = context.Errors,
Path = node.Path
};
var eventStreamField = node.FieldDefinition as EventStreamFieldType;
if (eventStreamField?.Subscriber == null)
{
throw new InvalidOperationException($"Subscriber not set for field {node.Field.Name}");
}
var subscription = eventStreamField.Subscriber.Subscribe(resolveContext);
return(subscription
.Select(value =>
{
// Create new execution node
return new ObjectExecutionNode(null, node.GraphType, node.Field, node.FieldDefinition, node.Path)
{
Source = value
};
})
.SelectMany(async objectNode =>
{
// Execute the whole execution tree and return the result
await ExecuteNodeTreeAsync(context, objectNode)
.ConfigureAwait(false);
return new ExecutionResult
{
Data = new Dictionary <string, object>
{
{ objectNode.Name, objectNode.ToValue() }
}
};
})
.Catch <ExecutionResult, Exception>(exception =>
Observable.Return(
new ExecutionResult
{
Errors = new ExecutionErrors
{
new ExecutionError(
$"Could not subscribe to field '{node.Field.Name}' in query '{context.Document.OriginalQuery}'",
exception)
{
Path = node.Path
}
}
})));
}
catch (Exception ex)
{
GenerateError(context, node.Field, ex, node.Path);
return(null);
}
}
// new FuncFieldResolver<object>(c => GraphQlHelpers.GetFinalValue(property.GetValue(GraphQlHelpers.GetSourceInstance(c, type, false))))
private static IObservable <object> Subscribe(ResolveEventStreamContext c, PropertyInfo property, Type type)
{
var observable = property.GetValue(GraphQlHelpers.GetSourceInstance(c, type, true));
return(observable as IObservable <object>);
}
IObservable <object> IEventStreamResolver.Subscribe(ResolveEventStreamContext context)
{
return((IObservable <object>)Subscribe(context));
}
