Exemple #1
0
 public LobbyServices(IUsersStore usersStore, GameBuildersCache gameBuildersCache, UsersCache usersCache, Func <User, string, Player> playerResolver)
 {
     _gameBuildersCache = gameBuildersCache;
     _usersStore        = usersStore;
     _usersCache        = usersCache;
     _playerResolver    = playerResolver;
 }
        public UserModule(IUsersStore userStore, IEventStore eventStore) : base("/users")
        {
            _userStore = userStore;
            Post("/", _ =>
            {
                var newUser = this.Bind <LoyalProgramUser>();
                AddRegisteredUser(newUser);
                eventStore.PutEvent("UserAdded", newUser);
                return(CreatedResponse(newUser));
            });

            Put("/{userId:int}", parameter =>
            {
                int userId      = parameter.userId;
                var updatedUser = this.Bind <LoyalProgramUser>();
                _userStore.UpdateUser(userId, updatedUser);
                eventStore.PutEvent("UserUpdated", updatedUser);
                return(updatedUser);
            });

            Get("/{userId:int}", parameter =>
            {
                var userId = parameter.userId;
                var user   = _userStore.GetUser(userId);
                return(user != null ? user : HttpStatusCode.NotFound);
            });
        }
    public OrderType(IDataLoaderContextAccessor accessor, IUsersStore users, IOrdersStore orders)
    {
        Name = "Order";

        Field(x => x.OrderId);
        Field(x => x.OrderedOn);

        Field <UserType, User>()
        .Name("User")
        .ResolveAsync(ctx =>
        {
            var loader = accessor.Context.GetOrAddBatchLoader <int, User>("GetUsersById",
                                                                          users.GetUsersByIdAsync);

            return(loader.LoadAsync(ctx.Source.UserId));
        });

        Field <ListGraphType <OrderItemType>, IEnumerable <OrderItem> >()
        .Name("Items")
        .ResolveAsync(ctx =>
        {
            var loader = accessor.Context.GetOrAddCollectionBatchLoader <int, OrderItem>("GetOrderItemsById",
                                                                                         orders.GetItemsByOrderIdAsync);

            return(loader.LoadAsync(ctx.Source.OrderId));
        });
    }
Exemple #4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UsersManager"/> class
 /// </summary>
 /// <param name="usersStore">Users store</param>
 /// <param name="pushNotificationsManager">Push notifications manager</param>
 /// <param name="popularUsersManager">Popular users manager</param>
 /// <param name="searchQueue">Search queue</param>
 public UsersManager(IUsersStore usersStore, IPushNotificationsManager pushNotificationsManager, IPopularUsersManager popularUsersManager, ISearchQueue searchQueue)
 {
     this.usersStore               = usersStore;
     this.popularUsersManager      = popularUsersManager;
     this.pushNotificationsManager = pushNotificationsManager;
     this.searchQueue              = searchQueue;
 }
 public TransactionSummaryBuilder(ITransactionStore transactionStore,
                                  IUsersStore usersStore,
                                  ITransactionsImporter transactionsImporter)
 {
     this.transactionStore     = transactionStore;
     this.usersStore           = usersStore;
     this.transactionsImporter = transactionsImporter;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="PopularTopicsManager"/> class
 /// </summary>
 /// <param name="topicsStore">Topics store</param>
 /// <param name="usersStore">Users store</param>
 /// <param name="appsStore">Apps store</param>
 public PopularTopicsManager(
     ITopicsStore topicsStore,
     IUsersStore usersStore,
     IAppsStore appsStore)
 {
     this.topicsStore = topicsStore;
     this.usersStore  = usersStore;
     this.appsStore   = appsStore;
 }
Exemple #7
0
 public BanHostedService(
     IUsersStore usersStore,
     ILogger <BanHostedService> logger,
     ITelegramBotClient telegramBot)
 {
     _usersStore  = usersStore;
     _logger      = logger;
     _telegramBot = telegramBot;
 }
 public WelcomeService(
     AppSettings settings,
     IUsersStore usersStore,
     ILogger <WelcomeService> logger,
     ITelegramBotClient telegramBot)
 {
     _settings    = settings;
     _usersStore  = usersStore;
     _logger      = logger;
     _telegramBot = telegramBot;
 }
Exemple #9
0
 public TransactionsImporter(ITransactionStore transactionsStore,
                             IBankDataProvider bankDataProvider,
                             IOptionsMonitor <DataImportOptions> dataImportOptions,
                             IClock clock,
                             IUsersStore usersStore)
 {
     this.transactionsStore = transactionsStore;
     this.bankDataProvider  = bankDataProvider;
     this.clock             = clock;
     this.usersStore        = usersStore;
     this.dataImportOptions = dataImportOptions.CurrentValue;
 }
Exemple #10
0
        public static User CreateComputer(this IUsersStore store)
        {
            Interlocked.Increment(ref lastNumber);

            return(new User()
            {
                Id = Guid.NewGuid().ToString(),
                Name = $"Computer #{lastNumber}",
                Money = 250,
                IsHuman = false
            });
        }
Exemple #11
0
        public QueryType(IDataLoaderContextAccessor accessor, IUsersStore users, IOrdersStore orders)
        {
            Name = "Query";

            Field <ListGraphType <UserType>, IEnumerable <User> >()
            .Name("Users")
            .Description("Get all Users")
            .Returns <IEnumerable <User> >()
            .ResolveAsync(ctx =>
            {
                var loader = accessor.Context.GetOrAddLoader("GetAllUsers",
                                                             users.GetAllUsersAsync);

                return(loader.LoadAsync());
            });

            Field <ListGraphType <UserType>, IEnumerable <User> >()
            .Name("UsersWithDelay")
            .Description("Get all Users")
            .Returns <IEnumerable <User> >()
            .ResolveAsync(async ctx =>
            {
                await System.Threading.Tasks.Task.Delay(20);

                var loader = accessor.Context.GetOrAddLoader("GetAllUsersWithDelay",
                                                             users.GetAllUsersAsync);

                return(loader.LoadAsync());
            });

            Field <OrderType, Order>()
            .Name("Order")
            .Description("Get Order by ID")
            .Argument <NonNullGraphType <IntGraphType> >("orderId", "")
            .ResolveAsync(ctx =>
            {
                var loader = accessor.Context.GetOrAddBatchLoader <int, Order>("GetOrderById",
                                                                               orders.GetOrderByIdAsync, x => x.OrderId);

                return(loader.LoadAsync(ctx.GetArgument <int>("orderId")));
            });

            Field <ListGraphType <OrderType>, IEnumerable <Order> >()
            .Name("Orders")
            .Description("Get all Orders")
            .ResolveAsync(ctx =>
            {
                var loader = accessor.Context.GetOrAddLoader("GetAllOrders",
                                                             orders.GetAllOrdersAsync);

                return(loader.LoadAsync());
            });
        }
Exemple #12
0
        public static User CreateUser(this IUsersStore store, ClaimsPrincipal current)
        {
            var user = new User()
            {
                Id        = current.GetId(),
                Name      = current.Identity.Name,
                AvatarUrl = current.FindFirst("Photo").Value,
                Money     = 250,
                IsHuman   = true
            };

            return(user);
        }
Exemple #13
0
        public static User RegisterAsGuest(this IUsersStore store, string connectionId)
        {
            Interlocked.Increment(ref lastNumber);

            var user = new User()
            {
                Id      = Guid.NewGuid().ToString(),
                Name    = $"Guest #{lastNumber}",
                Money   = 250,
                IsHuman = true
            };

            return(user);
        }
Exemple #14
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LikesManager"/> class
 /// </summary>
 /// <param name="likesStore">Likes store</param>
 /// <param name="topicsStore">Topics store</param>
 /// <param name="usersStore">Users store</param>
 /// <param name="likesQueue">Likes queue</param>
 /// <param name="fanoutActivitiesQueue"><c>Fanout</c> activities queue</param>
 /// <param name="popularTopicsManager">Popular topics manager</param>
 /// <param name="notificationsManager">Notifications manager</param>
 public LikesManager(
     ILikesStore likesStore,
     ITopicsStore topicsStore,
     IUsersStore usersStore,
     ILikesQueue likesQueue,
     IFanoutActivitiesQueue fanoutActivitiesQueue,
     IPopularTopicsManager popularTopicsManager,
     INotificationsManager notificationsManager)
 {
     this.likesStore            = likesStore;
     this.topicsStore           = topicsStore;
     this.usersStore            = usersStore;
     this.likesQueue            = likesQueue;
     this.fanoutActivitiesQueue = fanoutActivitiesQueue;
     this.popularTopicsManager  = popularTopicsManager;
     this.notificationsManager  = notificationsManager;
 }
Exemple #15
0
        public GameContext(Player[] players, Guid gameId, Func <ComputerBrain> computerBrain, Func <GameResult> gameResultResolve, IUsersStore usersStore)
        {
            Table              = Enumerable.Range(0, 4).Select(suit => new bool[15]).ToArray();
            Id                 = gameId;
            Players            = players;
            _computerBrain     = computerBrain;
            _gameResultResolve = gameResultResolve;
            _usersStore        = usersStore;
            BankMoney          = 150;

            foreach (var p in Players)
            {
                p.Money -= 50;

                p.Lobby.RefreshMoney(p.Money);
                _usersStore.UpdateMoney(p);
            }

            SetFirstPlayer();
        }
        public UsersActivity(IReactionHubProxy reactionHubProxy, IUsersStore usersStore)
        {
            this.ReactionHubProxy = reactionHubProxy;
            this.UsersStore       = usersStore;

            this.ReactionHubProxy.Connected += () =>
            {
                this.ReactionHubProxy
                .OnReceiveReaction()
                .Subscribe(x =>
                {
                    var user = this.SelectedUser.Value;
                    if (user == null)
                    {
                        return;
                    }
                    lock ( user ) {
                        switch (x.Item1)
                        {
                        case Models.eReactionType.Good:
                            user.GoodCount++;
                            break;

                        case Models.eReactionType.Nice:
                            user.NiceCount++;
                            break;

                        case Models.eReactionType.Fun:
                            user.FunCount++;
                            break;
                        }
                    }
                })
                .AddTo(this.Disposable);
            };

            this.SelectedUser = new ReactivePropertySlim <IUser>();
            this.Users        = new ReactiveCollection <IUser>();

            this.Load();
        }
Exemple #17
0
 public GameService(GamesCache gameCache, IUsersStore userStore, UsersCache usersCache)
 {
     _gameCache  = gameCache;
     _userStore  = userStore;
     _usersCache = usersCache;
 }
 public UsersController(IUsersStore usersStore)
 {
     _usersStore = usersStore;
 }
Exemple #19
0
        public QueryType(IDataLoaderContextAccessor accessor, IUsersStore users, IOrdersStore orders)
        {
            Name = "Query";

            Field <ListGraphType <UserType>, IEnumerable <User> >()
            .Name("Users")
            .Description("Get all Users")
            .Returns <IEnumerable <User> >()
            .ResolveAsync(ctx =>
            {
                var loader = accessor.Context.GetOrAddLoader("GetAllUsers",
                                                             users.GetAllUsersAsync);

                return(loader.LoadAsync());
            });

            Field <ListGraphType <UserType>, IEnumerable <User> >()
            .Name("UsersWithDelay")
            .Description("Get all Users")
            .Returns <IEnumerable <User> >()
            .ResolveAsync(async ctx =>
            {
                await System.Threading.Tasks.Task.Delay(20);

                var loader = accessor.Context.GetOrAddLoader("GetAllUsersWithDelay",
                                                             users.GetAllUsersAsync);

                return(loader.LoadAsync());
            });

            Field <OrderType, Order>()
            .Name("Order")
            .Description("Get Order by ID")
            .Argument <NonNullGraphType <IntGraphType> >("orderId", "")
            .ResolveAsync(ctx =>
            {
                var loader = accessor.Context.GetOrAddBatchLoader <int, Order>("GetOrderById",
                                                                               orders.GetOrderByIdAsync, x => x.OrderId);

                return(loader.LoadAsync(ctx.GetArgument <int>("orderId")));
            });

            Field <ListGraphType <OrderType>, IEnumerable <Order> >()
            .Name("Orders")
            .Description("Get all Orders")
            .ResolveAsync(ctx =>
            {
                var loader = accessor.Context.GetOrAddLoader("GetAllOrders",
                                                             orders.GetAllOrdersAsync);

                return(loader.LoadAsync());
            });

            Field <NonNullGraphType <ListGraphType <UserType> >, IEnumerable <IDataLoaderResult <User> > >()
            .Name("SpecifiedUsers")
            .Description("Get Users by ID")
            .Argument <NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > > >("ids")
            .Resolve(ctx =>
            {
                var loader = accessor.Context.GetOrAddBatchLoader <int, User>("GetUserById",
                                                                              users.GetUsersByIdAsync);

                var ids = ctx.GetArgument <IEnumerable <int> >("ids");
                var ret = ids.Select(id => loader.LoadAsync(id));
                return(ret);
            });

            Field <NonNullGraphType <ListGraphType <NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > > > > >()
            .Name("ExerciseListsOfLists")
            .Argument <ListGraphType <ListGraphType <IntGraphType> > >("values")
            .Resolve(ctx =>
            {
                var ret  = ctx.GetArgument <IEnumerable <IEnumerable <int?> > >("values"); //new int?[][] { new int?[] { 1, 2 }, new int?[] { 4, 5, 6 } };
                var ret2 = ret.Select(x => new SimpleDataLoader <IEnumerable <SimpleDataLoader <int?> > >(_ => Task.FromResult(x.Select(y => new SimpleDataLoader <int?>(_ => Task.FromResult(y))))));
                return(ret2);
            });
        }
 public WelcomeService(IUsersStore usersStore, ILogger <WelcomeService> logger, ITelegramBotClient telegramBot)
 {
     _usersStore  = usersStore;
     _logger      = logger;
     _telegramBot = telegramBot;
 }
        public MultiUsersViewModel(IUsersActivity usersActivity,
                                   IUsersStore usersStore,
                                   IThemeService themeService,
                                   IStatusService statusService)
        {
            this.UsersActivity = usersActivity;
            this.UserStore     = usersStore;
            this.ThemeService  = themeService;
            this.StatusService = statusService;

            this.NewUserName  = new ReactiveProperty <string>();
            this.SelectedUser = this.UsersActivity
                                .SelectedUser
                                .ToReactivePropertyAsSynchronized(x => x.Value)
                                .AddTo(this.Disposable);
            this.Users = this.UsersActivity
                         .Users
                         .ToReadOnlyReactiveCollection()
                         .AddTo(this.Disposable);
            this.FilePath = this.UserStore
                            .ToReactivePropertyAsSynchronized(x => x.FilePath)
                            .AddTo(this.Disposable);

            this.AddUserCommand = this.NewUserName
                                  .Select(x => !string.IsNullOrWhiteSpace(x))
                                  .ToReactiveCommand()
                                  .AddTo(this.Disposable);
            this.RemoveUserCommand = this.SelectedUser
                                     .Select(x => x != null)
                                     .ToReactiveCommand()
                                     .AddTo(this.Disposable);
            this.UnselectCommand = this.SelectedUser
                                   .Select(x => x != null)
                                   .ToReactiveCommand()
                                   .AddTo(this.Disposable);
            this.ResetUserCount = this.SelectedUser
                                  .Select(x => x != null)
                                  .ToReactiveCommand()
                                  .AddTo(this.Disposable);
            this.SaveCommand = this.FilePath
                               .Select(x => !string.IsNullOrWhiteSpace(x))
                               .ToReactiveCommand()
                               .AddTo(this.Disposable);
            this.LoadCommand = this.FilePath
                               .Select(x => !string.IsNullOrWhiteSpace(x))
                               .ToReactiveCommand()
                               .AddTo(this.Disposable);

            this.AddUserCommand
            .Subscribe(_ =>
            {
                this.UsersActivity.AddUser(this.NewUserName.Value);
                this.NewUserName.Value = string.Empty;
            });
            this.RemoveUserCommand
            .Subscribe(_ =>
            {
                this.UsersActivity.RemoveUser(this.SelectedUser.Value);
                this.SelectedUser.Value = null;
            });
            this.UnselectCommand
            .Subscribe(_ =>
            {
                this.SelectedUser.Value = null;
            });
            this.ResetUserCount
            .Subscribe(_ =>
            {
                this.UsersActivity.CountReset();
            });
            this.SaveCommand
            .Subscribe(_ =>
            {
                this.UsersActivity.Save();
            });
            this.LoadCommand
            .Subscribe(_ =>
            {
                this.UsersActivity.Load();
            });

            this.SelectedUser
            .Select(x => x != null)
            .Subscribe(x =>
            {
                this.ThemeService.IsBusy = x;
            })
            .AddTo(this.Disposable);
            this.SelectedUser
            .Select(x => x != null ? $"発表者:{x.Name}" : "準備完了")
            .Subscribe(x =>
            {
                this.StatusService.SetStatus(x);
            })
            .AddTo(this.Disposable);

            this.Title.Value = "Multi Users";
        }
Exemple #22
0
    public QueryType(IDataLoaderContextAccessor accessor, IUsersStore users, IOrdersStore orders)
    {
        Name = "Query";

        Field <ListGraphType <UserType>, IEnumerable <User> >()
        .Name("Users")
        .Description("Get all Users")
        .Returns <IEnumerable <User> >()
        .ResolveAsync(ctx =>
        {
            var loader = accessor.Context.GetOrAddLoader("GetAllUsers",
                                                         users.GetAllUsersAsync);

            return(loader.LoadAsync());
        });

        Field <ListGraphType <UserType>, IEnumerable <User> >()
        .Name("UsersWithDelay")
        .Description("Get all Users")
        .Returns <IEnumerable <User> >()
        .ResolveAsync(async ctx =>
        {
            await System.Threading.Tasks.Task.Delay(20).ConfigureAwait(false);

            var loader = accessor.Context.GetOrAddLoader("GetAllUsersWithDelay",
                                                         users.GetAllUsersAsync);

            return(loader.LoadAsync());
        });

        Field <OrderType, Order>()
        .Name("Order")
        .Description("Get Order by ID")
        .Argument <NonNullGraphType <IntGraphType> >("orderId", "")
        .ResolveAsync(ctx =>
        {
            var loader = accessor.Context.GetOrAddBatchLoader <int, Order>("GetOrderById",
                                                                           orders.GetOrderByIdAsync, x => x.OrderId);

            return(loader.LoadAsync(ctx.GetArgument <int>("orderId")));
        });

        Field <ListGraphType <OrderType>, IEnumerable <Order> >()
        .Name("Orders")
        .Description("Get all Orders")
        .ResolveAsync(ctx =>
        {
            var loader = accessor.Context.GetOrAddLoader("GetAllOrders",
                                                         orders.GetAllOrdersAsync);

            return(loader.LoadAsync());
        });

        Field <NonNullGraphType <ListGraphType <UserType> >, IEnumerable <IDataLoaderResult <User> > >()
        .Name("SpecifiedUsers")
        .Description("Get Users by ID")
        .Argument <NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > > >("ids")
        .Resolve(ctx =>
        {
            var loader = accessor.Context.GetOrAddBatchLoader <int, User>("GetUserById",
                                                                          users.GetUsersByIdAsync);

            var ids = ctx.GetArgument <IEnumerable <int> >("ids");
            var ret = ids.Select(id => loader.LoadAsync(id));
            return(ret);
        });

        Field <NonNullGraphType <ListGraphType <UserType> >, IDataLoaderResult <IEnumerable <User> > >()
        .Name("SpecifiedUsersWithThen")
        .Description("Get Users by ID skipping null matches")
        .Argument <NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > > >("ids")
        .Resolve(ctx =>
        {
            var loader = accessor.Context.GetOrAddBatchLoader <int, User>("GetUserById",
                                                                          users.GetUsersByIdAsync);

            var ids = ctx.GetArgument <IEnumerable <int> >("ids");
            // note: does not work properly without ToList, because LoadAsync would not have
            // been called, so the ids would not have been queued for execution prior to the
            // first call to GetResultAsync
            var ret  = ids.Select(id => loader.LoadAsync(id)).ToList();
            var ret2 = ret.Then(values => values.Where(x => x != null));
            return(ret2);
        });

        Field <NonNullGraphType <ListGraphType <NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > > > > >()
        .Name("ExerciseListsOfLists")
        .Argument <ListGraphType <ListGraphType <IntGraphType> > >("values")
        .Resolve(ctx =>
        {
            var ret  = ctx.GetArgument <IEnumerable <IEnumerable <int?> > >("values"); //new int?[][] { new int?[] { 1, 2 }, new int?[] { 4, 5, 6 } };
            var ret2 = ret.Select(x => new SimpleDataLoader <IEnumerable <SimpleDataLoader <int?> > >(_ => Task.FromResult(x.Select(y => new SimpleDataLoader <int?>(_ => Task.FromResult(y))))));
            return(ret2);
        });
    }
Exemple #23
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PopularUsersManager"/> class
 /// </summary>
 /// <param name="usersStore">Users store</param>
 public PopularUsersManager(IUsersStore usersStore)
 {
     this.usersStore = usersStore;
 }
 public UsersRepository(IUsersStore context)
 {
     this.Context = context;
 }
 public UserController(IUsersStore usersStore)
 {
     this.usersStore = usersStore;
 }