Esempio n. 1
0
        public async Task CanLoadMultiplePartialState()
        {
            var runner = Substitute.For <IGameRunner>();

            var fooSystem = new FooExportSystem(runner);

            runner.CreateEntityAsync().Returns(Task.FromResult(new SharperEntity()));

            var entity = await runner.CreateEntityAsync();

            var fooComponent = new FooExportableComponent(entity);

            await fooSystem.RegisterComponentAsync(fooComponent);

            var provider =
                new LiteDbProvider(new List <ISharperSystem> {
                fooSystem
            }, runner);


            var id = await provider.SaveAsync(new List <BaseSharperComponent>
            {
                fooComponent
            });

            Assert.DoesNotThrowAsync(async() =>
            {
                await provider.LoadPartialStateAsync(id, new List <string>()
                {
                    fooComponent.Entity.Id.ToString()
                }, true);
            });
        }
Esempio n. 2
0
        public async Task ThrowsOnMissingSystem()
        {
            var runner = Substitute.For <IGameRunner>();

            var barSystem = new BarExportSystem(runner);
            var fooSystem = new FooExportSystem(runner);

            runner.CreateEntityAsync().Returns(Task.FromResult(new SharperEntity()));

            var entity = await runner.CreateEntityAsync();

            var fooComponent = new FooExportableComponent(entity);
            var barComponent = new BarExportableComponent(entity);

            await fooSystem.RegisterComponentAsync(fooComponent);

            await barSystem.RegisterComponentAsync(barComponent);

            var provider =
                new LiteDbProvider(new List <ISharperSystem> {
                fooSystem
            }, runner);

            var id = await provider.SaveAsync(new List <BaseSharperComponent>()
            {
                fooComponent,
                barComponent
            });

            Assert.ThrowsAsync <InvalidSaveStateException>(() => provider.LoadAsync(id));
        }
Esempio n. 3
0
    public async Task FlushHitActivity()
    {
        Log.Information("Flushing HitActivity buffer");
        var metrics = LiteDbProvider.GetCollections <HitActivity>();

        var dateFormat    = "yyyy-MM-dd HH";
        var dateFormatted = DateTime.Now.ToString(dateFormat);

        Log.Debug("Filter last hour: {DateFormatted}", dateFormatted);
        var filteredMetrics = metrics.Find(x =>
                                           x.Timestamp.ToString(dateFormat) == dateFormatted).ToList();

        if (filteredMetrics.Count == 0)
        {
            Log.Debug("No HitActivity buffed need to flush");
            return;
        }

        Log.Debug("Flushing {Count} of {CountAll} data..", filteredMetrics.Count, metrics.Count());
        foreach (var hitActivity in filteredMetrics)
        {
            var data = new Dictionary <string, object>()
            {
                { "via_bot", hitActivity.ViaBot },
                { "update_type", hitActivity.UpdateType },
                { "from_id", hitActivity.FromId },
                { "from_first_name", hitActivity.FromFirstName },
                { "from_last_name", hitActivity.FromLastName },
                { "from_username", hitActivity.FromUsername },
                { "from_lang_code", hitActivity.FromLangCode },
                { "chat_id", hitActivity.ChatId },
                { "chat_username", hitActivity.ChatUsername },
                { "chat_type", hitActivity.ChatType },
                { "chat_title", hitActivity.ChatTitle },
                { "timestamp", hitActivity.Timestamp }
            };

            var insertHit = await _queryService
                            .CreateMySqlFactory()
                            .FromTable("hit_activity")
                            .InsertAsync(data);

            Log.Information("Insert Hit: {InsertHit}", insertHit);
        }

        Log.Debug("Clearing local data..");
        filteredMetrics.ForEach(x => {
            metrics.DeleteMany(y => y.Timestamp == x.Timestamp);
        });

        LiteDbProvider.Rebuild();

        Log.Information("Flush HitActivity done");
    }
Esempio n. 4
0
        public async Task CanSavePartialState()
        {
            var runner = Substitute.For <IGameRunner>();

            var fooSystem = new FooExportSystem(runner);

            runner.CreateEntityAsync().Returns(Task.FromResult(new SharperEntity()));

            var entity = await runner.CreateEntityAsync();


            var fooComponent = new FooExportableComponent(entity);

            var barComponent = new BarExportableComponent(entity);
            var barSystem    = new BarExportSystem(runner);

            await barSystem.RegisterComponentAsync(barComponent);

            await fooSystem.RegisterComponentAsync(fooComponent);

            var provider =
                new LiteDbProvider(new List <ISharperSystem> {
                fooSystem, barSystem
            }, runner);

            fooComponent.Foo = "foo";

            var id = await provider.SaveAsync(new List <BaseSharperComponent>
            {
                fooComponent
            });

            fooComponent.Foo = "bar";

            Assert.DoesNotThrowAsync(async() =>
            {
                await provider.ModifyAsync(id, new List <BaseSharperComponent>
                {
                    fooComponent,
                    barComponent
                });
            });

            Assert.AreEqual(fooSystem.GetComponents().First().Foo, "bar");
        }
Esempio n. 5
0
        public async Task CanHandleMultipleComponentsOnSameEntity()
        {
            var runner = Substitute.For <IGameRunner>();

            var barSystem = new BarExportSystem(runner);
            var fooSystem = new FooExportSystem(runner);

            runner.CreateEntityAsync().Returns(Task.FromResult(new SharperEntity()));

            var entity = await runner.CreateEntityAsync();

            var fooComponentA = new FooExportableComponent(entity);
            var barComponentA = new BarExportableComponent(entity);
            var fooComponentB = new FooExportableComponent(entity);
            var barComponentB = new BarExportableComponent(entity);

            await fooSystem.RegisterComponentAsync(fooComponentA);

            await barSystem.RegisterComponentAsync(barComponentA);

            await fooSystem.RegisterComponentAsync(fooComponentB);

            await barSystem.RegisterComponentAsync(barComponentB);

            var provider =
                new LiteDbProvider(new List <ISharperSystem> {
                fooSystem, barSystem
            }, runner);

            var id = await provider.SaveAsync(new List <BaseSharperComponent>()
            {
                fooComponentA,
                barComponentA,
                fooComponentB,
                barComponentB
            });

            await provider.LoadAsync(id);

            Assert.IsTrue(fooSystem.EntityHasComponent(fooComponentA, entity));
            Assert.IsTrue(fooSystem.EntityHasComponent(fooComponentB, entity));
            Assert.IsTrue(barSystem.EntityHasComponent(barComponentA, entity));
            Assert.IsTrue(barSystem.EntityHasComponent(barComponentB, entity));
        }
Esempio n. 6
0
        public async Task NoExcessMemoryUsage()
        {
            var runner = Substitute.For <IGameRunner>();

            var barSystem = new BarExportSystem(runner);
            var fooSystem = new FooExportSystem(runner);

            runner.CreateEntityAsync().Returns(Task.FromResult(new SharperEntity()));

            var components = new List <BaseSharperComponent>();

            for (var i = 0; i < 1000; i++)
            {
                var entity = await runner.CreateEntityAsync();

                var fooComponent = new FooExportableComponent(entity);
                var barComponent = new BarExportableComponent(entity);

                await fooSystem.RegisterComponentAsync(fooComponent);

                await barSystem.RegisterComponentAsync(barComponent);
            }

            var provider =
                new LiteDbProvider(new List <ISharperSystem> {
                fooSystem, barSystem
            }, runner);


            GC.Collect();
            var memory = GC.GetTotalMemory(false);

            for (var i = 0; i < 20; i++)
            {
                var id = await provider.SaveAsync(components);

                await provider.LoadAsync(id);
            }

            GC.Collect();

            Assert.Less(GC.GetTotalMemory(false), memory + memory / 20);
        }
Esempio n. 7
0
    public static async Task SyncWordToLocalAsync(this QueryFactory factory)
    {
        var sw = Stopwatch.StartNew();

        Log.Information("Starting Sync Words filter");

        var wordFilters = (await factory.FromQuery(new Query("word_filter"))
                           .GetAsync <WordFilter>()).ToList();

        // var cloudQuery = (await new Query("word_filter")
        // .ExecForMysql()
        // .GetAsync()
        // ).ToList();

        // var cloudWords = cloudQuery.ToJson().MapObject<List<WordFilter>>();

        var collection = LiteDbProvider.GetCollections <WordFilter>();

        collection.DeleteAll();
        collection.Insert(wordFilters);

        // var jsonWords = "local-words".OpenJson();

        // Log.Debug("Getting Words Collections");
        // var wordCollection = jsonWords.GetCollection<WordFilter>();

        // Log.Debug("Deleting old Words");
        // await wordCollection.DeleteManyAsync(x => x.Word != null)
        // ;

        // Log.Debug("Inserting new Words");
        // await wordCollection.InsertManyAsync(cloudWords)
        // ;

        Log.Information("Sync {0} Words complete in {1}", wordFilters.Count, sw.Elapsed);

        // jsonWords.Dispose();
        // cloudQuery.Clear();
        // cloudWords.Clear();
        wordFilters.Clear();
        sw.Stop();
    }
Esempio n. 8
0
        public async Task CanSaveWithoutDuplicates()
        {
            var runner = Substitute.For <IGameRunner>();

            var barSystem = new BarExportSystem(runner);
            var fooSystem = new FooExportSystem(runner);

            runner.CreateEntityAsync().Returns(Task.FromResult(new SharperEntity()));

            var entity = await runner.CreateEntityAsync();


            var fooComponent = new FooExportableComponent(entity);
            var barComponent = new BarExportableComponent(entity);

            await fooSystem.RegisterComponentAsync(fooComponent);

            await barSystem.RegisterComponentAsync(barComponent);

            var provider =
                new LiteDbProvider(new List <ISharperSystem> {
                fooSystem, barSystem
            }, runner);

            var id = await provider.SaveAsync(new List <BaseSharperComponent>
            {
                fooComponent,
                barComponent
            });

            await provider.LoadAsync(id);

            var barComponents = barSystem.GetComponents();
            var fooComponents = fooSystem.GetComponents();

            Assert.AreSame(fooComponents.First().Entity, barComponents.First().Entity);
        }
Esempio n. 9
0
 public CreateStorageCommandRequestHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
Esempio n. 10
0
    public static async Task SyncWordToLocalAsync()
    {
        var sw = Stopwatch.StartNew();

        Log.Information("Starting Sync Words filter");
        var cloudQuery = (await new Query("word_filter")
                          .ExecForMysql()
                          .GetAsync()).ToList();

        var cloudWords = cloudQuery.ToJson().MapObject <List <WordFilter> >();

        var collection = LiteDbProvider.GetCollections <WordFilter>();

        collection.DeleteAll();
        collection.Insert(cloudWords);

        // var jsonWords = "local-words".OpenJson();

        // Log.Debug("Getting Words Collections");
        // var wordCollection = jsonWords.GetCollection<WordFilter>();

        // Log.Debug("Deleting old Words");
        // await wordCollection.DeleteManyAsync(x => x.Word != null)
        // ;

        // Log.Debug("Inserting new Words");
        // await wordCollection.InsertManyAsync(cloudWords)
        // ;

        Log.Information("Sync {0} Words complete in {1}", cloudWords.Count, sw.Elapsed);

        // jsonWords.Dispose();
        cloudQuery.Clear();
        cloudWords.Clear();
        sw.Stop();

        // var localQuery = (await new Query("word_filter")
        //     .ExecForSqLite()
        //     .GetAsync()
        //     ).ToList();
        // var localWords = localQuery.ToJson().MapObject<List<WordFilter>>();
        //
        //
        // var diffWords = cloudWords
        //     .Where(c => localWords.All(l => l.Word != c.Word)).ToList();
        // Log.Debug($"DiffWords: {diffWords.Count} item(s)");
        //
        // if (diffWords.Count == 0)
        // {
        //     Log.Debug("Seem not need sync words to Local storage");
        //     return;
        // }
        //
        // Log.Information("Starting sync Words to Local");
        // var clearData = await new Query("word_filter")
        //     .ExecForSqLite(true)
        //     .DeleteAsync()
        //     ;
        //
        // Log.Information($"Deleting local Word Filter: {clearData} rows");
        //
        // foreach (var row in cloudWords)
        // {
        //     var data = new Dictionary<string, object>()
        //     {
        //         {"word", row.Word},
        //         {"is_global", row.IsGlobal},
        //         {"deep_filter", row.DeepFilter},
        //         {"from_id", row.FromId},
        //         {"chat_id", row.ChatId},
        //         {"created_at", row.CreatedAt}
        //     };
        //
        //     var insert = await new Query("word_filter")
        //         .ExecForSqLite()
        //         .InsertAsync(data)
        //         ;
        // }
        //
        // Log.Information($"Synced {cloudWords.Count} row(s)");
    }
 public RemoveDuplicatesRequestHandler(LiteDbProvider liteDbProvider)
 {
     _liteDbProvider = liteDbProvider;
 }
Esempio n. 12
0
 public AddFilmToStorageRequestHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
Esempio n. 13
0
 public ListFilmsWithQueryRequestHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
 public CreateFilmHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
Esempio n. 15
0
 public ListFilmsQueryHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
Esempio n. 16
0
 public ListStorageRequestHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
 public ListFilmWithNoMediaRequestHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
 public AddMediaToFilmHandler(LiteDbProvider provider)
 {
     _provider = provider;
 }
 public MediatorPipeline(LiteDbProvider provider)
 {
     _provider = provider;
 }