internal Task <DatabaseResponse> CreateDatabaseResponseAsync(
     CosmosDatabase database,
     Task <CosmosResponseMessage> cosmosResponseMessageTask)
 {
     return(this.ProcessMessageAsync(cosmosResponseMessageTask, (cosmosResponseMessage) =>
     {
         CosmosDatabaseProperties settings = this.ToObjectInternal <CosmosDatabaseProperties>(cosmosResponseMessage, this.settingsSerializer);
         return new DatabaseResponse(
             cosmosResponseMessage.StatusCode,
             cosmosResponseMessage.Headers,
             settings,
             database);
     }));
 }
        internal Task <DatabaseResponse> CreateDatabaseAsync(
            CosmosDatabaseProperties databaseSettings,
            int?requestUnitsPerSecond           = null,
            RequestOptions requestOptions       = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            Task <CosmosResponseMessage> response = this.CreateDatabaseStreamInternalAsync(
                streamPayload: this.ClientContext.SettingsSerializer.ToStream <CosmosDatabaseProperties>(databaseSettings),
                requestUnitsPerSecond: requestUnitsPerSecond,
                requestOptions: requestOptions,
                cancellationToken: cancellationToken);

            return(this.ClientContext.ResponseFactory.CreateDatabaseResponseAsync(this.GetDatabase(databaseSettings.Id), response));
        }
        internal CosmosDatabaseProperties PrepareCosmosDatabaseSettings(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            CosmosDatabaseProperties databaseSettings = new CosmosDatabaseProperties()
            {
                Id = id
            };

            this.ClientContext.ValidateResource(databaseSettings.Id);
            return(databaseSettings);
        }
        /// <summary>
        /// Send a request for creating a database.
        ///
        /// A database manages users, permissions and a set of containers.
        /// Each Azure Cosmos DB Database Account is able to support multiple independent named databases,
        /// with the database being the logical container for data.
        ///
        /// Each Database consists of one or more containers, each of which in turn contain one or more
        /// documents. Since databases are an administrative resource, the Service Master Key will be
        /// required in order to access and successfully complete any action using the User APIs.
        /// </summary>
        /// <param name="databaseSettings">The database settings</param>
        /// <param name="requestUnitsPerSecond">(Optional) The throughput provisioned for a database in measurement of Request Units per second in the Azure Cosmos DB service.</param>
        /// <param name="requestOptions">(Optional) A set of options that can be set.</param>
        /// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
        /// <returns>A <see cref="Task"/> containing a <see cref="DatabaseResponse"/> which wraps a <see cref="CosmosDatabaseProperties"/> containing the resource record.</returns>
        /// <remarks>
        /// <seealso href="https://docs.microsoft.com/azure/cosmos-db/request-units"/> for details on provision throughput.
        /// </remarks>
        public virtual Task <CosmosResponseMessage> CreateDatabaseStreamAsync(
            CosmosDatabaseProperties databaseSettings,
            int?requestUnitsPerSecond           = null,
            RequestOptions requestOptions       = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if (databaseSettings == null)
            {
                throw new ArgumentNullException(nameof(databaseSettings));
            }

            this.ClientContext.ValidateResource(databaseSettings.Id);
            Stream streamPayload = this.ClientContext.SettingsSerializer.ToStream <CosmosDatabaseProperties>(databaseSettings);

            return(this.CreateDatabaseStreamInternalAsync(streamPayload, requestUnitsPerSecond, requestOptions, cancellationToken));
        }
        /// <summary>
        /// Send a request for creating a database.
        ///
        /// A database manages users, permissions and a set of containers.
        /// Each Azure Cosmos DB Database Account is able to support multiple independent named databases,
        /// with the database being the logical container for data.
        ///
        /// Each Database consists of one or more containers, each of which in turn contain one or more
        /// documents. Since databases are an administrative resource, the Service Master Key will be
        /// required in order to access and successfully complete any action using the User APIs.
        /// </summary>
        /// <param name="id">The database id.</param>
        /// <param name="requestUnitsPerSecond">(Optional) The throughput provisioned for a database in measurement of Request Units per second in the Azure Cosmos DB service.</param>
        /// <param name="requestOptions">(Optional) A set of options that can be set.</param>
        /// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
        /// <returns>A <see cref="Task"/> containing a <see cref="DatabaseResponse"/> which wraps a <see cref="CosmosDatabaseProperties"/> containing the resource record.</returns>
        /// <remarks>
        /// <seealso href="https://docs.microsoft.com/azure/cosmos-db/request-units"/> for details on provision throughput.
        /// </remarks>
        public virtual Task <DatabaseResponse> CreateDatabaseAsync(
            string id,
            int?requestUnitsPerSecond           = null,
            RequestOptions requestOptions       = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if (string.IsNullOrEmpty(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            CosmosDatabaseProperties databaseSettings = this.PrepareCosmosDatabaseSettings(id);

            return(this.CreateDatabaseAsync(
                       databaseSettings: databaseSettings,
                       requestUnitsPerSecond: requestUnitsPerSecond,
                       requestOptions: requestOptions,
                       cancellationToken: cancellationToken));
        }