/// <summary>Returns the <see cref="IResolveEventStreamContext"/> typed as an <see cref="IResolveEventStreamContext{TSource}"/></summary>
/// <exception cref="ArgumentException">Thrown if the <see cref="IResolveEventStreamContext.Source"/> property cannot be cast to the specified type</exception>
public static IResolveEventStreamContext <T> As <T>(this IResolveEventStreamContext context)
{
if (context is IResolveEventStreamContext <T> typedContext)
{
return(typedContext);
}
return(new ResolveEventStreamContext <T>(context));
}
public IObservable <object> Subscribe(IResolveEventStreamContext context)
{
var result = base.Resolve(context);
if (result is Task <object> )
{
result = (result as Task <object>).Result;
}
return((IObservable <object>)result);
}
private IObservable <OrderEvent> Subscribe(IResolveEventStreamContext context)
{
IList <OrderStatuses> statusList = context.GetArgument <IList <OrderStatuses> >("statuses",
new List <OrderStatuses>());
if (statusList.Count <= 0)
{
return(_events.EventStream());
}
OrderStatuses statuses = statusList.Aggregate <OrderStatuses, OrderStatuses>(0, (current, status) => current | status);
return(_events.EventStream().Where(e => (e.Status & statuses) == e.Status));
}
private IObservable <Message> Subscribe(IResolveEventStreamContext context)
{
var messageContext = (MessageHandlingContext)context.UserContext;
var user = messageContext.Get <ClaimsPrincipal>("user");
string sub = "Anonymous";
if (user != null)
{
sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
}
return(_chat.Messages(sub));
}
private IObservable <Message> SubscribeById(IResolveEventStreamContext context)
{
var messageContext = (MessageHandlingContext)context.UserContext;
var user = messageContext.Get <ClaimsPrincipal>("user");
string sub = "Anonymous";
if (user != null)
{
sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
}
var messages = _chat.Messages(sub);
string id = context.GetArgument <string>("id");
return(messages.Where(message => message.From.Id == id));
}
private IObservable <OrderEvent> Subscribe(IResolveEventStreamContext context)
{
var statusList = context.GetArgument <IList <OrderStatuses> >("statuses",
new List <OrderStatuses>());
if (statusList.Count > 0)
{
OrderStatuses statuses = 0;
foreach (var status in statusList)
{
statuses |= status;
}
return(_events.EventStream().Where(e => (e.Status & statuses) == e.Status));
}
else
{
return(_events.EventStream());
}
}
private IObservable <MovieEvent> Subscribe(IResolveEventStreamContext 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(a => (a.MovieRating & ratings) == a.MovieRating));
}
else
{
return(_movieEventService.EventStream());
}
}
private IObservable <MovieEvent> Subscripte(IResolveEventStreamContext arg)
{
var ratingList = arg.GetArgument <IList <MovieRating> >($"{nameof(MovieRating)}s", new List <MovieRating>());
if (ratingList.Any())
{
MovieRating ratings = MovieRating.Unrated;
foreach (var rating in ratingList)
{
ratings = ratings | rating;
}
return(_eventService.EventStream().Where(e => (e.MovieRating & ratings) == e.MovieRating));
}
else
{
return(_eventService.EventStream());
}
}
private IObservable <object> Subscribe(IResolveEventStreamContext context)
{
var messageHandlingContext = (MessageHandlingContext)context.UserContext;
var tenantContext = messageHandlingContext.Get <ITenantContext>(Statics.TenantContext);
var ckId = context.FieldDefinition.GetMetadata <string>(Statics.CkId);
var rtId = context.GetArgument <OspObjectId?>(Statics.RtIdArg, null);
var updateTypeDtoList = context.GetArgument <ICollection <UpdateTypesDto> >(Statics.UpdateTypesArg);
UpdateTypes updateType = UpdateTypes.Undefined;
foreach (var updateTypeDto in updateTypeDtoList)
{
updateType |= (UpdateTypes)updateTypeDto;
}
var updateStreamFilter = new UpdateStreamFilter
{
UpdateTypes = updateType,
RtId = rtId
};
var messages = tenantContext.Repository.SubscribeToRtEntities(ckId, updateStreamFilter, context.CancellationToken);
var observable = messages.GetUpdates().Select(x => new DynamicUpdateMessageDto <RtEntityUpdateItemDto>
{
Items = new List <RtEntityUpdateItemDto>
{
new RtEntityUpdateItemDto
{
UserContext = x.Document, UpdateState = (UpdateTypesDto)x.UpdateType
}
}
});
return(observable);
}
public IObservable <T> Subscribe(IResolveEventStreamContext context)
{
Console.WriteLine($" User --------------------------- IsAuthenticated {_httpContextAccessor.HttpContext.User?.Identity?.IsAuthenticated}");
if (_httpContextAccessor.HttpContext.User?.Identity == null || !_httpContextAccessor.HttpContext.User.Identity.IsAuthenticated)
{
context.Errors.Add(new ExecutionError($"Missing Bearer Token"));
return(new List <T>().ToObservable());
}
string field = context.GetArgument <string>("field");
int value = context.GetArgument <int>("value");
string stringValue = context.GetArgument <string>("string_value");
IHandleMsg <T> service = (IHandleMsg <T>)_httpContextAccessor.HttpContext.RequestServices.GetService(typeof(IHandleMsg <T>));
var objs = service.ObservableObj();
if (!string.IsNullOrEmpty(field) && (value > 0 || !string.IsNullOrEmpty(stringValue)))
{
var pi = typeof(T).GetProperty(field);
if (pi != null)
{
if (!string.IsNullOrEmpty(stringValue))
{
return(objs.Where(x => (string)pi.GetValue(x) == stringValue));
}
return(objs.Where(x => (int)pi.GetValue(x) == value));
}
else
{
context.Errors.Add(new ExecutionError($"Bad params"));
return(new List <T>().ToObservable());
}
}
return(objs);
}
private IObservable <Human> Subscribe(IResolveEventStreamContext 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());
}
public ResolveEventStreamContext(IResolveEventStreamContext context) : base(context)
{
}
private IObservable <RouteNetworkEditOperationOccuredEvent> SubscribeEvents(IResolveEventStreamContext context)
{
return(_toposTypedEventObserable.OnEvent);
}
private IObservable <Pizza> Subscribe(IResolveEventStreamContext context)
{
return(_eventsService.ListenPizzaChanges());
}
public Task <IObservable <T> > SubscribeAsync(IResolveEventStreamContext context)
{
return(_subscriber(context));
}
private IObservable <Message> Subscribe(IResolveEventStreamContext context)
{
return(_chat.Messages());
}
private IObservable <CustomerEvent> Subscribe(IResolveEventStreamContext context)
{
return(_events.EventStream());
}
private IObservable <Message> Subscibe(IResolveEventStreamContext context)
{
return(Data.AllMessages());
}
public IObservable <Message> SubscribeMessageAddedByUser(IResolveEventStreamContext context, string id)
{
var messages = SubscriptionSchemaWithReflection.Chat.Messages();
return(messages.Where(message => message.From.Id == id));
}
private IObservable <OrderEvent> SubscribeClosed(IResolveEventStreamContext context)
{
return(_events.EventStream());
}
private IObservable <Order> Subscribe(IResolveEventStreamContext context)
{
return(ordersStore.GetOrderObservable());
}
IObservable <object> IEventStreamResolver.Subscribe(IResolveEventStreamContext context)
{
return((IObservable <object>)Subscribe(context));
}
public Task <IObservable <T?> > SubscribeAsync(IResolveEventStreamContext context) => _subscriber(context);
public Task <IObservable <Message> > SubscribeMessageAddedAsync(IResolveEventStreamContext context)
{
return(SubscriptionSchemaWithReflection.Chat.MessagesAsync());
}
public IObservable <T?> Subscribe(IResolveEventStreamContext context) => _subscriber(context);
private Task <IObservable <Message> > SubscribeAsync(IResolveEventStreamContext context)
{
return(_chat.MessagesAsync());
}
IObservable <object?> IEventStreamResolver.Subscribe(IResolveEventStreamContext context) => (IObservable <object?>)Subscribe(context);
public IObservable <List <Message> > SubscribeMessageGetAll(IResolveEventStreamContext context)
{
return(SubscriptionSchemaWithReflection.Chat.MessagesGetAll());
}
async Task <IObservable <object?> > IAsyncEventStreamResolver.SubscribeAsync(IResolveEventStreamContext context)
{
var result = await SubscribeAsync(context).ConfigureAwait(false);
return((IObservable <object?>)result);
}
private IObservable <Human> ThrowNotImplementedException(IResolveEventStreamContext context)
{
throw new NotImplementedException("This API purposely throws a NotImplementedException");
}
