public async Task ListNetworkDomains_Paged_Success()
        {
            CloudControlClient client = CreateCloudControlClientWithUserAccount(request =>
            {
                MessageAssert.AcceptsMediaType(request,
                                               "application/json"
                                               );
                MessageAssert.HasRequestUri(request,
                                            CreateApiUri($"caas/2.4/{TestOrganizationId}/network/networkDomain?datacenterId=AU9&pageNumber=1&pageSize=250")
                                            );

                return(request.CreateResponse(HttpStatusCode.OK,
                                              responseBody: TestResponses.ListNetworkDomains_Success,
                                              mediaType: "application/json"
                                              ));
            });

            using (client)
            {
                NetworkDomainQuery query  = NetworkDomainQuery.ByDatacenter("AU9");
                Paging             paging = new Paging
                {
                    PageNumber = 1,
                    PageSize   = 250
                };

                NetworkDomains networkDomains = await client.ListNetworkDomains(query, paging);

                Assert.NotNull(networkDomains);
                Assert.Equal(2, networkDomains.TotalCount);
                Assert.Equal(2, networkDomains.Items.Count);
            }
        }
Example #2
0
        /// <summary>
        ///     Retrieve the first network domain in the specified datacenter with the specified name.
        /// </summary>
        /// <param name="client">
        ///     The CloudControl API client.
        /// </param>
        /// <param name="name">
        ///     The name of the network domain to retrieve.
        /// </param>
        /// <param name="datacenterId">
        ///     The Id of the datacenter containing the network domain to retrieve.
        /// </param>
        /// <param name="cancellationToken">
        ///     An optional cancellation token that can be used to cancel the request.
        /// </param>
        /// <returns>
        ///     A <see cref="NetworkDomain"/> representing the network domain, or <c>null</c> if no network domain was found with the specified Id.
        /// </returns>
        public static async Task <NetworkDomain> GetNetworkDomainByName(this CloudControlClient client, string name, string datacenterId, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (client == null)
            {
                throw new ArgumentNullException(nameof(client));
            }

            NetworkDomainQuery query = NetworkDomainQuery.ByNameAndDatacenter(name, datacenterId);
            NetworkDomains     matchingNetworkDomains = await client.ListNetworkDomains(query, cancellationToken : cancellationToken);

            return(matchingNetworkDomains.Items.FirstOrDefault());
        }
        public async Task Client_ListNetworkDomains_AU9()
        {
            CloudControlClient client = CloudControlClient.Create(
                baseUri: new Uri("https://api-au.dimensiondata.com/"),
                userName: Credentials.User,
                password: Credentials.Password
                );

            using (client)
            {
                Paging page = new Paging
                {
                    PageSize = 20
                };

                NetworkDomainQuery query          = NetworkDomainQuery.ByDatacenter("AU9");
                NetworkDomains     networkDomains = await client.ListNetworkDomains(query, page);

                int expectedTotalCount = networkDomains.TotalCount;
                int totalCount         = 0;
                while (!networkDomains.IsEmpty)
                {
                    totalCount += networkDomains.PageCount;

                    foreach (NetworkDomain networkDomain in networkDomains)
                    {
                        Console.WriteLine("NetworkDomain: " + networkDomain.Name);
                    }

                    page++;
                    networkDomains = await client.ListNetworkDomains(query, page);
                }

                Assert.Equal(expectedTotalCount, totalCount);
            }
        }
Example #4
0
        /// <summary>
        ///     Asynchronously perform Cmdlet processing.
        /// </summary>
        /// <param name="cancellationToken">
        ///     A <see cref="CancellationToken"/> that can be used to cancel Cmdlet processing.
        /// </param>
        /// <returns>
        ///     A <see cref="Task"/> representing the asynchronous operation.
        /// </returns>
        protected override async Task ProcessRecordAsync(CancellationToken cancellationToken)
        {
            CloudControlClient client = GetClient();

            switch (ParameterSetName)
            {
            case "By Datacenter":
            {
                Paging paging = GetPagingConfiguration();

                NetworkDomains networkDomains = await client.ListNetworkDomains(DatacenterId, paging, cancellationToken);

                WriteObject(networkDomains.Items,
                            enumerateCollection: true
                            );

                break;
            }

            case "By Id":
            {
                NetworkDomain networkDomain = await client.GetNetworkDomain(Id, cancellationToken);

                if (networkDomain == null)
                {
                    WriteError(
                        Errors.ResourceNotFoundById <NetworkDomain>(Id)
                        );
                }
                else
                {
                    WriteObject(networkDomain);
                }

                break;
            }

            case "By Name":
            {
                NetworkDomain networkDomain = await client.GetNetworkDomainByName(Name, DatacenterId);

                if (networkDomain == null)
                {
                    WriteError(
                        Errors.ResourceNotFoundByName <NetworkDomain>(Name,
                                                                      message: $"No network domain named '{Name}' was found in datacenter '{DatacenterId}'."
                                                                      )
                        );
                }
                else
                {
                    WriteObject(networkDomain);
                }

                break;
            }

            default:
            {
                ThrowTerminatingError(
                    Errors.UnrecognizedParameterSet(this)
                    );

                return;
            }
            }
        }