Exemple #1
0
        public async Task SeedAsync()
        {
            try
            {
                if (settings.MasterSeedEnabled)
                {
                    try
                    {
                        await settings.CosmosDb.ValidateObjectAsync();
                    }
                    catch (Exception ex)
                    {
                        throw new InvalidConfigException("The Cosmos DB configuration is required to create the master tenant documents.", ex);
                    }

                    var db = await repositoryClient.Client.CreateDatabaseIfNotExistsAsync(new Database { Id = repositoryClient.DatabaseId });

                    if (db.StatusCode == HttpStatusCode.Created)
                    {
                        var partitionKeyDefinition = new PartitionKeyDefinition {
                            Paths = new Collection <string> {
                                "/partition_id"
                            }
                        };
                        var documentCollection = new DocumentCollection {
                            Id = repositoryClient.CollectionId, PartitionKey = partitionKeyDefinition
                        };
                        var ttlDocumentCollection = new DocumentCollection {
                            Id = repositoryClient.TtlCollectionId, PartitionKey = partitionKeyDefinition, DefaultTimeToLive = -1
                        };
                        if (repositoryClient.CollectionId == repositoryClient.TtlCollectionId)
                        {
                            _ = await repositoryClient.Client.CreateDocumentCollectionIfNotExistsAsync(repositoryClient.DatabaseUri, ttlDocumentCollection);

                            logger.Trace("One Cosmos DB Document Collection created.");
                        }
                        else
                        {
                            _ = await repositoryClient.Client.CreateDocumentCollectionIfNotExistsAsync(repositoryClient.DatabaseUri, documentCollection);

                            _ = await repositoryClient.Client.CreateDocumentCollectionIfNotExistsAsync(repositoryClient.DatabaseUri, ttlDocumentCollection);

                            logger.Trace("Two Cosmos DB Document Collections created.");
                        }

                        await masterTenantDocumentsSeedLogic.SeedAsync();
                    }
                }
            }
            catch (Exception ex)
            {
                logger.CriticalError(ex, "Error seeding master documents.");
                throw;
            }
        }
        public async Task SeedAsync()
        {
            try
            {
                await CreateAndValidateMasterTenantDocumentAsync();

                await masterTenantLogic.CreateMasterTrackDocumentAsync(Constants.Routes.MasterTenantName);

                var mLoginUpParty = await masterTenantLogic.CreateMasterLoginDocumentAsync(Constants.Routes.MasterTenantName);

                await masterTenantLogic.CreateFirstAdminUserDocumentAsync(Constants.Routes.MasterTenantName, Constants.DefaultAdminAccount.Email, Constants.DefaultAdminAccount.Password, false);

                await masterTenantLogic.CreateMasterFoxIDsControlApiResourceDocumentAsync(Constants.Routes.MasterTenantName, includeMasterTenantScope : true);

                await masterTenantLogic.CreateMasterControlClientDocmentAsync(Constants.Routes.MasterTenantName, settings.FoxIDsControlEndpoint, mLoginUpParty, includeMasterTenantScope : true);
            }
            catch (Exception ex)
            {
                logger.CriticalError(ex, "Error seeding master tenant document.");
                throw;
            }
        }
Exemple #3
0
        public async Task SeedAsync()
        {
            try
            {
                if (settings.MasterSeedEnabled)
                {
                    try
                    {
                        await settings.CosmosDb.ValidateObjectAsync();
                    }
                    catch (Exception ex)
                    {
                        throw new InvalidConfigException("The Cosmos DB configuration is required to create the master tenant documents.", ex);
                    }

                    var databaseResponse = await repositoryClient.Client.CreateDatabaseIfNotExistsAsync(settings.CosmosDb.DatabaseId);

                    if (databaseResponse.StatusCode == HttpStatusCode.Created)
                    {
                        if (settings.CosmosDb.ContainerId == settings.CosmosDb.TtlContainerId)
                        {
                            var container = await databaseResponse.Database.CreateContainerIfNotExistsAsync(
                                new ContainerProperties
                            {
                                Id = settings.CosmosDb.TtlContainerId,
                                PartitionKeyPath  = Constants.Models.CosmosPartitionKeyPath,
                                DefaultTimeToLive = -1
                            });

                            logger.Trace("One Cosmos DB Document container created.");
                            (repositoryClient as RepositoryClientBase).SetContainers(container, container);
                        }
                        else
                        {
                            var container = await databaseResponse.Database.CreateContainerIfNotExistsAsync(new ContainerProperties
                            {
                                Id = settings.CosmosDb.ContainerId,
                                PartitionKeyPath = Constants.Models.CosmosPartitionKeyPath
                            });

                            var ttlContainer = await databaseResponse.Database.CreateContainerIfNotExistsAsync(
                                new ContainerProperties
                            {
                                Id = settings.CosmosDb.TtlContainerId,
                                PartitionKeyPath  = Constants.Models.CosmosPartitionKeyPath,
                                DefaultTimeToLive = -1
                            });

                            logger.Trace("Two Cosmos DB Document containers created.");
                            (repositoryClient as RepositoryClientBase).SetContainers(container, ttlContainer);
                        }

                        await masterTenantDocumentsSeedLogic.SeedAsync();

                        logger.Trace("Cosmos DB Document container(s) seeded.");
                    }
                }
            }
            catch (Exception ex)
            {
                logger.CriticalError(ex, "Error seeding master documents.");
                throw;
            }
        }