public async Task DeleteOwnerItemsAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreItemAdder>();
            var deleter     = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter  = provider.GetRequiredService <ScoreItemInfoGetter>();

            var ownerId = Guid.Parse("39b6bf0e-8c39-47ce-bae5-49c557f8d2fa");

            var ids = new (Guid scoreId, Guid[] itemIds)[]
Пример #2
0
        public async Task UpdateTitleAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();

            serviceCollection.AddScoped <ScoreTitleSetter>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreCreator>();


            var target = provider.GetRequiredService <ScoreTitleSetter>();

            var ownerId = Guid.Parse("27f30e40-bf83-427f-b53d-39b5d0f01ac7");
            var scoreId = Guid.Parse("4afded99-4070-4ba7-85ed-6c3776602895");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newTitle = "new test score";
            await target.UpdateTitleAsync(ownerId, scoreId, newTitle);
        }
Пример #3
0
        public ImageResizeHandler()
        {
            S3Client = new AmazonS3Client();
            remoteFileRepositoryFactory = logWriterFactory => new S3FileRepository(logWriterFactory);
            var system = new DefaultSystem(new SystemEnvironment(), new SystemTime());
            var dynamoDbClientFactory = new DynamoDbClientFactory(string.Empty);

            dataRepositoryFactory = logWriterFactory =>
                                    new DynamoDbPhotoRepository(
                new ScoreCalculator(system, logWriterFactory),
                new DynamoDbCore(dynamoDbClientFactory, logWriterFactory),
                system,
                logWriterFactory);


            photosServiceFactory = logWriterFactory => new PhotosService(
                dataRepositoryFactory(logWriterFactory),
                remoteFileRepositoryFactory(logWriterFactory),
                new TextSplitter(new HttpHelper(), logWriterFactory),
                logWriterFactory);
            imageScalerFactory      = logWriterFactory => new ImageScaler(logWriterFactory);
            logWriterFactoryFactory = lambdaLogger => new LambdaLogWriterFactory(lambdaLogger);

            AWSSDKHandler.RegisterXRayForAllServices();
        }
Пример #4
0
        public ScoringDependencies()
        {
            var            dynamoDbClientFactory = new DynamoDbClientFactory(string.Empty);
            Func <ISystem> systemFactory         = () => new DefaultSystem(new SystemEnvironment(), new SystemTime());

            lazyScoreCalculator = new Lazy <IScoreCalculator>(() =>
                                                              new ScoreCalculator(systemFactory(), this.LogWriterFactory));

            Func <ILogWriterFactory, IDynamoDbCore> dynamoDbCoreFactory = logWriterFactory => new DynamoDbCore(dynamoDbClientFactory, logWriterFactory);

            remoteFileRepositoryFactory = logWriterFactory => new S3FileRepository(logWriterFactory);
            dataRepositoryFactory       = logWriterFactory => new DynamoDbPhotoRepository(lazyScoreCalculator.Value, dynamoDbCoreFactory(logWriterFactory), new DefaultSystem(new SystemEnvironment(), new SystemTime()), logWriterFactory);


            lazyPhotosService = new Lazy <IPhotosService>(() =>
                                                          new PhotosService(
                                                              dataRepositoryFactory(this.LogWriterFactory),
                                                              remoteFileRepositoryFactory(this.LogWriterFactory),
                                                              new TextSplitter(new HttpHelper(), this.LogWriterFactory),
                                                              this.LogWriterFactory));

            lazySettingsService = new Lazy <ISettingsService>(()
                                                              => new SettingsService(
                                                                  new SettingsRepository(systemFactory(), dynamoDbCoreFactory(this.LogWriterFactory)),
                                                                  this.LogWriterFactory));

            system = new DefaultSystem(new SystemEnvironment(), new SystemTime());
        }
        public static IServiceCollection AddAppDatabase(this IServiceCollection services, IConfiguration configuration)
        {
            services.AddSingleton <IAmazonDynamoDB>(x => DynamoDbClientFactory.CreateClient());
            services.AddSingleton <IDatabaseClient, DatabaseClient>();

            services.AddScoped <IAppUserRepositoryAsync, AppUserRepositoryAsync>();
            services.AddScoped <IUnitOfWork, UnitOfWork>();

            return(services);
        }
Пример #6
0
        public async Task SaveObjectAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreItemAdder>();
            var deleter     = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter  = provider.GetRequiredService <ScoreItemInfoGetter>();


            var ownerId = Guid.Parse("f2240c15-0f2d-41ce-941d-6b173bae94c0");
            var scoreId = Guid.Parse("0d9fb491-43ae-44a1-9056-55bb25b21187");
            var itemId  = Guid.Parse("cc42d1b1-c6b0-4895-ba74-de6e89d853a1");

            var imageRelativeResourceName = "Resources.pexels-cottonbro-4709821.jpg";

            await using var imageStream = ResourceUtils.CreateResourceStream(imageRelativeResourceName);

            var data = new byte[imageStream.Length];
            await imageStream.ReadAsync(data, 0, data.Length);

            await creator.SaveObjectAsync(ownerId, scoreId, itemId, data, ScoreObjectAccessControls.Public);
        }
Пример #7
0
        public static void AddDatabaseDependencies(this IServiceCollection services)
        {
            services.AddSingleton <IDynamoDBContext>(ctx =>
            {
                var settings       = ctx.GetRequiredService <DynamoDbSettings>();
                var dynamoDbClient = DynamoDbClientFactory.Create(settings);

                return(new DynamoDBContext(dynamoDbClient,
                                           new DynamoDBOperationConfig {
                    OverrideTableName = settings.TableName
                }));
            });
        }
Пример #8
0
        public async Task CreateTableAsync(string tableName)
        {
            var endpoint = Endpoint;

            using var client = new DynamoDbClientFactory().SetEndpointUrl(endpoint).Create();

            await client.CreateTableAsync(new CreateTableRequest()
            {
                TableName            = tableName,
                AttributeDefinitions = new List <AttributeDefinition>()
                {
                    new()
                    {
                        AttributeName = "o",
                        AttributeType = ScalarAttributeType.S
                    },
                    new()
                    {
                        AttributeName = "s",
                        AttributeType = ScalarAttributeType.S
                    }
                },
Пример #9
0
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc()
            .AddNewtonsoftJson(options => options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore);
            services.Configure <AppConfig>(Configuration);
            services.AddLogging(x => x.AddFilter("Microsoft", LogLevel.Warning));

            services.AddSingleton <IAmazonSQS>(x => SqsClientFactory.CreateClient(_appConfig));
            services.AddSingleton <ISqsClient, SqsClient>();
            services.AddSingleton <ISqsConsumerService, SqsConsumerService>();

            services.AddSingleton <IAmazonDynamoDB>(x => DynamoDbClientFactory.CreateClient(_appConfig));
            services.AddSingleton <IDatabaseClient, DatabaseClient>();
            services.AddSingleton <IDynamoDBContext, DynamoDBContext>();
            services.AddSingleton <IActorsRepository, ActorsRepository>();
            services.AddSingleton <IMoviesRepository, MoviesRepository>();

            services.AddScoped <IMessageProcessor, ActorMessageProcessor>();
            services.AddScoped <IMessageProcessor, MovieMessageProcessor>();
            services.AddScoped <IMessageProcessor, LogEntryMessageProcessor>();

            services.AddHealthChecks()
            .AddCheck <SqsHealthCheck>("SQS Health Check");
        }
Пример #10
0
        public async Task SetAccessAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();
            serviceCollection.AddScoped <ScoreSnapshotDetailGetter>();
            serviceCollection.AddScoped <ScoreSnapshotSummaryGetter>();
            serviceCollection.AddScoped <ScoreAccessSetter>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer           = provider.GetRequiredService <Initializer>();
            var creator               = provider.GetRequiredService <ScoreCreator>();
            var deleter               = provider.GetRequiredService <ScoreDeleter>();
            var getter                = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder             = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover           = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder       = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover     = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer    = provider.GetRequiredService <ScoreAnnotationReplacer>();
            var snapshotCreator       = provider.GetRequiredService <ScoreSnapshotCreator>();
            var snapshotRemover       = provider.GetRequiredService <ScoreSnapshotRemover>();
            var snapshotDetailGetter  = provider.GetRequiredService <ScoreSnapshotDetailGetter>();
            var snapshotSummaryGetter = provider.GetRequiredService <ScoreSnapshotSummaryGetter>();
            var accessSetter          = provider.GetRequiredService <ScoreAccessSetter>();



            var ownerId = Guid.Parse("721be298-bf3f-40f1-9f75-0679c4d06147");
            var scoreId = Guid.Parse("6884c1c3-55ab-4c62-b515-a039d18b14e9");

            var title       = "test score";
            var description = "楽譜の説明(set access)";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            await accessSetter.SetAccessAsync(ownerId, scoreId, ScoreAccesses.Public);
        }
Пример #11
0
        public async Task AddPagesAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreCreator>();

            var target = provider.GetRequiredService <ScorePageAdder>();

            var ownerId = Guid.Parse("13eff3dd-beb9-4471-adc4-dc4540ee3445");
            var scoreId = Guid.Parse("0d9fb491-43ae-44a1-9056-55bb25b21187");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                }
            };
            await target.AddPagesAsync(ownerId, scoreId, newPages);
        }
Пример #12
0
        public async Task RemovePagesAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreCreator>();
            var deleter     = provider.GetRequiredService <ScoreDeleter>();
            var getter      = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder   = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover = provider.GetRequiredService <ScorePageRemover>();



            var ownerId = Guid.Parse("806dcb04-eaba-4233-9069-0beead6cb075");
            var scoreId = Guid.Parse("727679a2-c1eb-4089-9817-9a9bfb7a23b1");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "3",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "4",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "5",
                    ItemId = Guid.NewGuid(),
                }
            };

            try
            {
                await pageAdder.AddPagesAsync(ownerId, scoreId, newPages);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            var pageIds = new List <long>()
            {
                1, 3
            };
            await pageRemover.RemovePagesAsync(ownerId, scoreId, pageIds);
        }
        public async Task DeleteAllAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreDeleter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreSnapshotCreator>();
            var deleter     = provider.GetRequiredService <ScoreDeleter>();

            var ownerId = Guid.Parse("e9ca7322-9dd6-4429-b1d8-d3c9244a68ed");
            var scoreId = Guid.Parse("eea7e8c1-15ec-4f69-a675-364f24099267");

            var snapshotIds = new[]
            {
                Guid.Parse("0ea2f185-8355-439c-a427-d5734c17f886"),
                Guid.Parse("18be42eb-de3c-4899-bdc3-7ed512ce07ae"),
                Guid.Parse("7569ad9a-1bb4-4c33-9cb8-11e5c680a404"),
            };

            var data = new ScoreSnapshotDetail()
            {
                Name = "スナップショット名(delete all)",
                Data = new ScoreData()
                {
                    Title           = "楽譜",
                    DescriptionHash = "楽譜の説明",
                    Annotations     = new [] {
                        new ScoreAnnotation()
                        {
                            Id          = 0,
                            ContentHash = "hash00",
                        },
                        new ScoreAnnotation()
                        {
                            Id          = 1,
                            ContentHash = "hash01",
                        },
                    },
                    Pages = new []
                    {
                        new ScorePage()
                        {
                            Id     = 0,
                            Page   = "page1",
                            ItemId = new Guid("3b74ca20-0e47-49b4-941f-45176766ae7d"),
                        },
                        new ScorePage()
                        {
                            Id     = 1,
                            Page   = "page2",
                            ItemId = new Guid("e3c0a4a6-344d-4247-9932-070ae822186b"),
                        },
                    },
                },
                HashSet = new Dictionary <string, string>()
                {
                    ["hash00"] = "アノテーション1",
                    ["hash01"] = "アノテーション2",
                },
            };

            try
            {
                foreach (var snapshotId in snapshotIds)
                {
                    data.Id = snapshotId;
                    await creator.CreateSnapshotItemAsync(ownerId, scoreId, data, ScoreObjectAccessControls.Public);
                }
            }
            catch
            {
                // 握りつぶす
            }

            await deleter.DeleteAllSnapshotAsync(ownerId, scoreId);
        }
Пример #14
0
        public async Task ReplacePagesAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScorePageReplacer>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer  = provider.GetRequiredService <Initializer>();
            var creator      = provider.GetRequiredService <ScoreCreator>();
            var deleter      = provider.GetRequiredService <ScoreDeleter>();
            var getter       = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder    = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover  = provider.GetRequiredService <ScorePageRemover>();
            var pageReplacer = provider.GetRequiredService <ScorePageReplacer>();

            var ownerId = Guid.Parse("f9aa6c43-aab0-485e-a5a7-f6dbf592b0a4");
            var scoreId = Guid.Parse("9db807b1-42fe-4e1a-b85c-61905b176616");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "3",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "4",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "5",
                    ItemId = Guid.NewGuid(),
                }
            };

            try
            {
                await pageAdder.AddPagesAsync(ownerId, scoreId, newPages);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            var pages = new List <PatchScorePage>()
            {
                new PatchScorePage()
                {
                    TargetPageId = 1,
                    Page         = "replaced " + Guid.NewGuid(),
                    ItemId       = Guid.NewGuid()
                },
                new PatchScorePage()
                {
                    TargetPageId = 3,
                    Page         = "replaced " + Guid.NewGuid(),
                    ItemId       = Guid.NewGuid()
                },
            };
            await pageReplacer.ReplacePagesAsync(ownerId, scoreId, pages);
        }
Пример #15
0
        public async Task CreateAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreSnapshotCreator>();
            var deleter     = provider.GetRequiredService <ScoreSnapshotRemover>();



            var ownerId    = Guid.Parse("80b16bc7-5258-441f-9a2a-d6d95fc16c4a");
            var scoreId    = Guid.Parse("fc4ac609-0914-4cd6-9caa-cada12c7b03d");
            var snapshotId = Guid.Parse("3dd43d78-ff83-46f5-8ed3-fddbc06ec943");

            var data = new ScoreSnapshotDetail()
            {
                Id   = snapshotId,
                Name = "スナップショット名",
                Data = new ScoreData()
                {
                    Title           = "楽譜",
                    DescriptionHash = "楽譜の説明",
                    Annotations     = new [] {
                        new ScoreAnnotation()
                        {
                            Id          = 0,
                            ContentHash = "hash00",
                        },
                        new ScoreAnnotation()
                        {
                            Id          = 1,
                            ContentHash = "hash01",
                        },
                    },
                    Pages = new []
                    {
                        new ScorePage()
                        {
                            Id     = 0,
                            Page   = "page1",
                            ItemId = new Guid("3b74ca20-0e47-49b4-941f-45176766ae7d"),
                        },
                        new ScorePage()
                        {
                            Id     = 1,
                            Page   = "page2",
                            ItemId = new Guid("e3c0a4a6-344d-4247-9932-070ae822186b"),
                        },
                    },
                },
                HashSet = new Dictionary <string, string>()
                {
                    ["hash00"] = "アノテーション1",
                    ["hash01"] = "アノテーション2",
                },
            };
            await creator.CreateSnapshotItemAsync(ownerId, scoreId, data, ScoreObjectAccessControls.Public);
        }
Пример #16
0
        public async Task CreateAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreItemAdder>();
            var deleter     = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter  = provider.GetRequiredService <ScoreItemInfoGetter>();

            var ownerId = Guid.Parse("5a56be69-af15-41a1-a879-08b6efd40eef");
            var scoreId = Guid.Parse("79867694-f52d-406c-b519-9091153cf5d3");
            var itemId  = Guid.Parse("8228a9dd-d752-43f1-be84-31fce6b088d9");

            try
            {
                await initializer.InitializeScoreItemAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            try
            {
                await deleter.DeleteAsync(ownerId, scoreId, itemId);
            }
            catch
            {
                // 握りつぶす
            }

            var objName = ScoreItemStorageConstant.JpegFileName;
            var orgName = "origin_image.jpg";
            var size    = 1024 * 1024;

            var thumbnailObjName = ScoreItemStorageConstant.ThumbnailFileName;
            var thumbnailSize    = 1024;

            var itemData = new ScoreItemDatabaseItemDataImage()
            {
                OwnerId   = ownerId,
                ScoreId   = scoreId,
                ItemId    = itemId,
                ObjName   = objName,
                OrgName   = orgName,
                Size      = size,
                Thumbnail = new ScoreItemDatabaseItemDataImageThumbnail()
                {
                    ObjName = thumbnailObjName,
                    Size    = thumbnailSize,
                }
            };
            await creator.CreateAsync(itemData);
        }
        public async Task ReplaceAnnotationsAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer        = provider.GetRequiredService <Initializer>();
            var creator            = provider.GetRequiredService <ScoreCreator>();
            var deleter            = provider.GetRequiredService <ScoreDeleter>();
            var getter             = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder          = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover        = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder    = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover  = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer = provider.GetRequiredService <ScoreAnnotationReplacer>();



            var ownerId = Guid.Parse("5f2dc1b1-bc2c-4ba5-a188-05e1c37307ad");
            var scoreId = Guid.Parse("9fc3f5e5-66b6-4443-be68-1cc96155550f");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
            };

            try
            {
                await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            var anns = new List <PatchScoreAnnotation>()
            {
                new PatchScoreAnnotation()
                {
                    TargetAnnotationId = 1, Content = "replaced " + Guid.NewGuid()
                },
                new PatchScoreAnnotation()
                {
                    TargetAnnotationId = 3, Content = "replaced " + Guid.NewGuid()
                },
            };
            await annotationReplacer.ReplaceAnnotationsAsync(ownerId, scoreId, anns);
        }
Пример #18
0
        public async Task SetAccessControlPolicyAsyncTest()
        {
            var factory = new S3ClientFactory()
                          .SetRegionSystemName(RegionSystemName);
            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var bucketName            = BucketName;
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = BucketName,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = BucketName,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();
            serviceCollection.AddScoped <ScoreAccessSetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer  = provider.GetRequiredService <Initializer>();
            var creator      = provider.GetRequiredService <ScoreItemAdder>();
            var deleter      = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter   = provider.GetRequiredService <ScoreItemInfoGetter>();
            var accessSetter = provider.GetRequiredService <ScoreAccessSetter>();

            var ownerId  = Guid.Parse("4935be9f-8b08-4de9-a615-96ec04c2e4c5");
            var scoreIds = new[]
            {
                Guid.Parse("b6538dd3-2e2d-47bf-8ad3-1cb23b982309"),
                Guid.Parse("2ee917b6-94fa-469f-a977-14f57d9a7b4e"),
            };
            var itemIds = new[]
            {
                new Guid("6cf18791-0058-426b-b5fb-8f553079a6f5"),
                new Guid("1e69d895-5487-4de6-ae8e-e0f57cd86954"),
            };

            var imageRelativeResourceName = "Resources.pexels-cottonbro-4709821.jpg";

            await using var imageStream = ResourceUtils.CreateResourceStream(imageRelativeResourceName);

            var data = new byte[imageStream.Length];
            await imageStream.ReadAsync(data, 0, data.Length);

            foreach (var scoreId in scoreIds)
            {
                foreach (var itemId in itemIds)
                {
                    await creator.SaveObjectAsync(ownerId, scoreId, itemId, data, ScoreObjectAccessControls.Private);
                }
            }

            await accessSetter.SetScoreItemAccessControlPolicyAsync(ownerId, scoreIds[0], ScoreObjectAccessControls.Public);
        }
        public async Task RemoveAnnotationsAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer        = provider.GetRequiredService <Initializer>();
            var creator            = provider.GetRequiredService <ScoreCreator>();
            var deleter            = provider.GetRequiredService <ScoreDeleter>();
            var getter             = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder          = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover        = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder    = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover  = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer = provider.GetRequiredService <ScoreAnnotationReplacer>();


            var ownerId = Guid.Parse("9e88f09f-eed7-441e-a0e2-224aea4a3fc0");
            var scoreId = Guid.Parse("27badfc9-372f-4423-aa41-cfa397c9b01d");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
            };

            try
            {
                await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            var annotationIds = new List <long>()
            {
                1, 3
            };
            await annotationRemover.RemoveAnnotationsAsync(ownerId, scoreId, annotationIds);
        }
        public async Task DeleteAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreItemAdder>();
            var deleter     = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter  = provider.GetRequiredService <ScoreItemInfoGetter>();

            var ownerId = Guid.Parse("a585178e-a477-4fb8-8e2a-c385a45c0d08");
            var scoreId = Guid.Parse("2533ffdd-9624-4c80-979f-95561edf5ed1");
            var itemId  = Guid.Parse("67ff2dbd-c6d4-41c1-a9e5-857b56a09361");

            try
            {
                await initializer.InitializeScoreItemAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var objName = ScoreItemStorageConstant.JpegFileName;
            var orgName = "origin_image.jpg";
            var size    = 1024 * 1024;

            var thumbnailObjName = ScoreItemStorageConstant.ThumbnailFileName;
            var thumbnailSize    = 1024;

            var itemData = new ScoreItemDatabaseItemDataImage()
            {
                OwnerId   = ownerId,
                ScoreId   = scoreId,
                ItemId    = itemId,
                ObjName   = objName,
                OrgName   = orgName,
                Size      = size,
                Thumbnail = new ScoreItemDatabaseItemDataImageThumbnail()
                {
                    ObjName = thumbnailObjName,
                    Size    = thumbnailSize,
                }
            };

            try
            {
                await creator.CreateAsync(itemData);
            }
            catch
            {
                // エラーは握りつぶす
            }

            await deleter.DeleteAsync(ownerId, scoreId, itemId);

            await Assert.ThrowsAsync <InvalidOperationException>(async() =>
                                                                 await infoGetter.GetItemAsync(ownerId, scoreId, itemId));
        }
        public async Task AddAnnotationsAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer        = provider.GetRequiredService <Initializer>();
            var creator            = provider.GetRequiredService <ScoreCreator>();
            var deleter            = provider.GetRequiredService <ScoreDeleter>();
            var getter             = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder          = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover        = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder    = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover  = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer = provider.GetRequiredService <ScoreAnnotationReplacer>();

            var ownerId = Guid.Parse("3c9e2b24-2ba0-4b22-8f1d-60dc5c60b555");
            var scoreId = Guid.Parse("90fcc364-2a67-42b8-8b93-15a84370b1e4");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = "アノテーション1"
                },
                new NewScoreAnnotation()
                {
                    Content = "アノテーション2"
                },
                new NewScoreAnnotation()
                {
                    Content = "アノテーション3"
                },
            };
            await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
        }
Пример #22
0
        public async Task GetSnapshotNamesAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();
            serviceCollection.AddScoped <ScoreSnapshotDetailGetter>();
            serviceCollection.AddScoped <ScoreSnapshotSummaryGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer           = provider.GetRequiredService <Initializer>();
            var creator               = provider.GetRequiredService <ScoreCreator>();
            var deleter               = provider.GetRequiredService <ScoreDeleter>();
            var getter                = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder             = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover           = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder       = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover     = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer    = provider.GetRequiredService <ScoreAnnotationReplacer>();
            var snapshotCreator       = provider.GetRequiredService <ScoreSnapshotCreator>();
            var snapshotRemover       = provider.GetRequiredService <ScoreSnapshotRemover>();
            var snapshotDetailGetter  = provider.GetRequiredService <ScoreSnapshotDetailGetter>();
            var snapshotSummaryGetter = provider.GetRequiredService <ScoreSnapshotSummaryGetter>();



            var ownerId = Guid.Parse("afd15615-99b6-46c1-92fe-3da242d57e9d");
            var scoreId = Guid.Parse("89405e01-67f1-42e6-8673-e932a4b20d26");

            var title       = "test score";
            var description = "楽譜の説明(スナップショット削除)";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
            };

            try
            {
                await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
            }
            catch (Exception)
            {
                // 握りつぶす
            }


            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "3",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "4",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "5",
                    ItemId = Guid.NewGuid(),
                }
            };

            try
            {
                await pageAdder.AddPagesAsync(ownerId, scoreId, newPages);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            var snapshotNames = new[]
        public async Task DeleteAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreSnapshotCreator>();
            var deleter     = provider.GetRequiredService <ScoreSnapshotRemover>();

            var ownerId    = Guid.Parse("31937be9-d1df-4076-b2b6-9cb5e2d94a17");
            var scoreId    = Guid.Parse("8a9aaa16-2ca2-4b22-9cf5-21e7b681dbc9");
            var snapshotId = Guid.Parse("f30cd5f5-b807-4273-9299-f95d0baf85b9");

            var data = new ScoreSnapshotDetail()
            {
                Id   = snapshotId,
                Name = "スナップショット名(delete)",
                Data = new ScoreData()
                {
                    Title           = "楽譜",
                    DescriptionHash = "楽譜の説明",
                    Annotations     = new [] {
                        new ScoreAnnotation()
                        {
                            Id          = 0,
                            ContentHash = "hash00",
                        },
                        new ScoreAnnotation()
                        {
                            Id          = 1,
                            ContentHash = "hash01",
                        },
                    },
                    Pages = new []
                    {
                        new ScorePage()
                        {
                            Id     = 0,
                            Page   = "page1",
                            ItemId = new Guid("3b74ca20-0e47-49b4-941f-45176766ae7d"),
                        },
                        new ScorePage()
                        {
                            Id     = 1,
                            Page   = "page2",
                            ItemId = new Guid("e3c0a4a6-344d-4247-9932-070ae822186b"),
                        },
                    },
                },
                HashSet = new Dictionary <string, string>()
                {
                    ["hash00"] = "アノテーション1",
                    ["hash01"] = "アノテーション2",
                },
            };

            try
            {
                await creator.CreateSnapshotItemAsync(ownerId, scoreId, data, ScoreObjectAccessControls.Public);
            }
            catch
            {
                // 握りつぶす
            }

            await deleter.DeleteSnapshotAsync(ownerId, scoreId, snapshotId);
        }
Пример #24
0
        public async Task CreateSnapshotAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();
            serviceCollection.AddScoped <ScoreSnapshotDetailGetter>();
            serviceCollection.AddScoped <ScoreSnapshotSummaryGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer           = provider.GetRequiredService <Initializer>();
            var creator               = provider.GetRequiredService <ScoreCreator>();
            var deleter               = provider.GetRequiredService <ScoreDeleter>();
            var getter                = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder             = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover           = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder       = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover     = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer    = provider.GetRequiredService <ScoreAnnotationReplacer>();
            var snapshotCreator       = provider.GetRequiredService <ScoreSnapshotCreator>();
            var snapshotRemover       = provider.GetRequiredService <ScoreSnapshotRemover>();
            var snapshotDetailGetter  = provider.GetRequiredService <ScoreSnapshotDetailGetter>();
            var snapshotSummaryGetter = provider.GetRequiredService <ScoreSnapshotSummaryGetter>();


            var ownerId    = Guid.Parse("4f0d25c8-0b33-4c00-92dc-2e85c3ac58a5");
            var scoreId    = Guid.Parse("fd32d482-477d-4cb4-ab78-88e86a073a31");
            var snapshotId = Guid.Parse("6d1d0a52-8371-4f78-b61b-785522d2577d");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
            };

            try
            {
                await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
            }
            catch (Exception)
            {
                // 握りつぶす
            }


            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "3",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "4",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "5",
                    ItemId = Guid.NewGuid(),
                }
            };

            try
            {
                await pageAdder.AddPagesAsync(ownerId, scoreId, newPages);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            string snapshotName = "snapshot name";

            await snapshotCreator.CreateSnapshotAsync(ownerId, scoreId, snapshotId, snapshotName);
        }
        public async Task DeleteSnapshotAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();
            serviceCollection.AddScoped <ScoreSnapshotDetailGetter>();
            serviceCollection.AddScoped <ScoreSnapshotSummaryGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer           = provider.GetRequiredService <Initializer>();
            var creator               = provider.GetRequiredService <ScoreCreator>();
            var deleter               = provider.GetRequiredService <ScoreDeleter>();
            var getter                = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder             = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover           = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder       = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover     = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer    = provider.GetRequiredService <ScoreAnnotationReplacer>();
            var snapshotCreator       = provider.GetRequiredService <ScoreSnapshotCreator>();
            var snapshotRemover       = provider.GetRequiredService <ScoreSnapshotRemover>();
            var snapshotDetailGetter  = provider.GetRequiredService <ScoreSnapshotDetailGetter>();
            var snapshotSummaryGetter = provider.GetRequiredService <ScoreSnapshotSummaryGetter>();



            var ownerId    = Guid.Parse("3656f0fe-0068-4019-acc3-db042f6684b3");
            var scoreId    = Guid.Parse("aa917a9b-453e-4bc2-8381-b61404725d6a");
            var snapshotId = Guid.Parse("7a82b4e0-02aa-4b5e-b323-7f13f61302c7");

            var title       = "test score";
            var description = "楽譜の説明(スナップショット削除)";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
            };

            try
            {
                await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
            }
            catch (Exception)
            {
                // 握りつぶす
            }


            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "3",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "4",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "5",
                    ItemId = Guid.NewGuid(),
                }
            };

            try
            {
                await pageAdder.AddPagesAsync(ownerId, scoreId, newPages);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            string snapshotName = "snapshot name(delete)";

            try
            {
                await snapshotCreator.CreateSnapshotAsync(ownerId, scoreId, snapshotId, snapshotName);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            await snapshotRemover.DeleteSnapshotAsync(ownerId, scoreId, snapshotId);
        }
        public async Task UpdateDescriptionAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScoreDescriptionSetter>();


            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer = provider.GetRequiredService <Initializer>();
            var deleter     = provider.GetRequiredService <ScoreDeleter>();
            var getter      = provider.GetRequiredService <ScoreDetailGetter>();
            var creator     = provider.GetRequiredService <ScoreCreator>();

            var target = provider.GetRequiredService <ScoreDescriptionSetter>();

            var ownerId = Guid.Parse("4984ad41-4b7c-474d-953a-ac7c11081fbd");
            var scoreId = Guid.Parse("0d9fb491-43ae-44a1-9056-55bb25b21187");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await deleter.DeleteAsync(ownerId, scoreId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newDescription = "新しい楽譜の説明";
            await target.UpdateDescriptionAsync(ownerId, scoreId, newDescription);

            var(scoreData, hashSet) = await getter.GetDynamoDbScoreDataAsync(ownerId, scoreId);

            Assert.IsType <DynamoDbScoreDataV1>(scoreData.Data);

            var dataV1 = (DynamoDbScoreDataV1)scoreData.Data;

            Assert.Equal(newDescription, hashSet[dataV1.DescriptionHash]);
        }
Пример #27
0
        public async Task GetScoreDetailAsyncTest()
        {
            var factory       = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration = new ConfigurationBuilder()
                                .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreDeleter>();
            serviceCollection.AddScoped <ScoreDetailGetter>();
            serviceCollection.AddScoped <ScoreCreator>();
            serviceCollection.AddScoped <ScorePageAdder>();
            serviceCollection.AddScoped <ScorePageRemover>();
            serviceCollection.AddScoped <ScoreAnnotationAdder>();
            serviceCollection.AddScoped <ScoreAnnotationRemover>();
            serviceCollection.AddScoped <ScoreAnnotationReplacer>();

            await using var provider = serviceCollection.BuildServiceProvider();


            var initializer        = provider.GetRequiredService <Initializer>();
            var creator            = provider.GetRequiredService <ScoreCreator>();
            var deleter            = provider.GetRequiredService <ScoreDeleter>();
            var getter             = provider.GetRequiredService <ScoreDetailGetter>();
            var pageAdder          = provider.GetRequiredService <ScorePageAdder>();
            var pageRemover        = provider.GetRequiredService <ScorePageRemover>();
            var annotationAdder    = provider.GetRequiredService <ScoreAnnotationAdder>();
            var annotationRemover  = provider.GetRequiredService <ScoreAnnotationRemover>();
            var annotationReplacer = provider.GetRequiredService <ScoreAnnotationReplacer>();


            var ownerId = Guid.Parse("a5373d09-08f4-4dbd-be92-03bd4732b124");
            var scoreId = Guid.Parse("8127bf3d-0d80-4635-bdb7-9c544ccea46f");

            var title       = "test score";
            var description = "楽譜の説明";

            try
            {
                await initializer.InitializeScoreAsync(ownerId);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }
            try
            {
                await creator.CreateAsync(ownerId, scoreId, title, description);
            }
            catch
            {
                // 初期化のエラーは握りつぶす
            }

            var newAnnotations = new List <NewScoreAnnotation>()
            {
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
                new NewScoreAnnotation()
                {
                    Content = Guid.NewGuid().ToString()
                },
            };

            try
            {
                await annotationAdder.AddAnnotationsInnerAsync(ownerId, scoreId, newAnnotations);
            }
            catch (Exception)
            {
                // 握りつぶす
            }


            var newPages = new List <NewScorePage>()
            {
                new NewScorePage()
                {
                    Page   = "1",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "2",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "3",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "4",
                    ItemId = Guid.NewGuid(),
                },
                new NewScorePage()
                {
                    Page   = "5",
                    ItemId = Guid.NewGuid(),
                }
            };

            try
            {
                await pageAdder.AddPagesAsync(ownerId, scoreId, newPages);
            }
            catch (Exception)
            {
                // 握りつぶす
            }

            var record = await getter.GetDynamoDbScoreDataAsync(ownerId, scoreId);
        }