/// <summary>
/// The add sub administrator account.
/// </summary>
/// <param name="account">
/// The account.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <Status> AddSubAdministratorAccount(AccountWithPhoneNumber account)
{
return
(await
_apiClient.PostAsync <AccountWithPhoneNumber, Status>(
ApiUris.AccountWithPhoneNumber(_apiClient.OrganizationId),
account));
}
/// <summary>
/// Deploys Virtual LAN on a network domain
/// </summary>
/// <param name="vlan">
/// Virtual LAN
/// </param>
/// <returns>
/// Operation status
/// </returns>
public async Task <ResponseType> DeployVlan(DeployVlanType vlan)
{
return
(await
_api.PostAsync <DeployVlanType, ResponseType>(
ApiUris.DeployVlan(_api.OrganizationId),
vlan));
}
/// <summary>
/// The enable backup.
/// </summary>
/// <param name="serverId">
/// The server id.
/// </param>
/// <param name="plan">
/// The plan.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <Status> EnableBackup(string serverId, ServicePlan plan)
{
return
(await
_apiClient.PostAsync <NewBackup, Status>(
ApiUris.EnableBackup(_apiClient.OrganizationId, serverId),
new NewBackup
{
servicePlan = plan
}));
}
/// <summary> Adds a public IP block. </summary>
/// <param name="networkDomainId"> Identifier for the network domain. </param>
/// <returns> The job from the API; </returns>
/// <seealso cref="M:DD.CBU.Compute.Api.Client.Interfaces.IIpam.AddPublicIpBlock(string)"/>
public async Task <ResponseType> AddPublicIpBlock(string networkDomainId)
{
return
(await
_apiClient.PostAsync <AddPublicIpBlockType, ResponseType>(
ApiUris.AddPublicIpBlock(_apiClient.OrganizationId),
new AddPublicIpBlockType
{
networkDomainId = networkDomainId
}));
}
/// <summary>
/// Add a SSL Domain Certificate and Key to a Network Domain
/// </summary>
/// <param name="sslDomainCertificate">Details regarding the SSL Domain Certificate</param>
/// <returns>Response Data</returns>
public async Task <ResponseType> AddSslDomainCertificate(importSslDomainCertificate sslDomainCertificate)
{
return
(await
_apiClient.PostAsync <importSslDomainCertificate, ResponseType>(
ApiUris.ImportSslDomainCertificate(_apiClient.OrganizationId), sslDomainCertificate));
}
/// <summary>
/// The import customer image.
/// </summary>
/// <param name="customerImageName">
/// The customer image name.
/// </param>
/// <param name="ovfPackageName">
/// The ovf package name.
/// </param>
/// <param name="networkLocation">
/// The network location.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <ServerImageWithStateType> ImportCustomerImage(
string customerImageName,
string ovfPackageName,
string networkLocation,
string description)
{
return
(await
_apiClient.PostAsync <NewImageImport, ServerImageWithStateType>(
ApiUris.ImportCustomerImage(_apiClient.OrganizationId),
new NewImageImport
{
name = customerImageName,
location = networkLocation,
ovfPackage = ovfPackageName,
description = description
}));
}
/// <summary>
/// The copy customer image
/// </summary>
/// <param name="imageId">
/// The source image id.
/// </param>
/// <param name="targetImageName">Target Image Name</param>
/// <param name="targetImageDescription">Target Image Description</param>
/// <param name="targetLocation">Target Location</param>
/// <param name="ovfPackagePrefix">OVF Package Prefix</param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <ImageCopyType> CopyCustomerServerImage(
string imageId,
string targetImageName,
string targetImageDescription,
string targetLocation,
string ovfPackagePrefix)
{
return(await _apiClient.PostAsync <NewImageCopy, ImageCopyType>(
ApiUris.CopyCustomerServerImage(_apiClient.OrganizationId),
new NewImageCopy
{
sourceImageId = imageId,
targetImageName = targetImageName,
targetImageDescription = targetImageDescription,
targetLocation = targetLocation,
ovfPackagePrefix = ovfPackagePrefix
}));
}
public async Task <Rastreamento> ObterRastreamento(string codigo)
{
try
{
return(await api.PostAsync <Rastreamento>(url, codigo));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// The create network.
/// </summary>
/// <param name="networkName">
/// The network name.
/// </param>
/// <param name="dataCentreLocation">
/// The data centre location.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <Status> CreateNetwork(string networkName, string dataCentreLocation, string description = null)
{
return
(await
_apiClient.PostAsync <NewNetworkWithLocationType, Status>(
ApiUris.CreateNetwork(_apiClient.OrganizationId),
new NewNetworkWithLocationType
{
name = networkName,
location = dataCentreLocation,
description = description
}));
}
/// <summary>
/// The modify server.
/// </summary>
/// <param name="serverId">
/// The server id.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <param name="memory">
/// The memory.
/// </param>
/// <param name="cpucount">
/// The CPU count.
/// </param>
/// <param name="privateIp">
/// The private IP.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <Status> ModifyServer(
string serverId,
string name,
string description,
int memory,
int cpucount,
string privateIp)
{
// build que query string paramenters
var parameters = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(name))
{
parameters.Add("name", name);
}
if (!string.IsNullOrEmpty(description))
{
parameters.Add("description", description);
}
if (memory > 0)
{
parameters.Add("memory", memory.ToString());
}
if (cpucount > 0)
{
parameters.Add("cpuCount", cpucount.ToString());
}
if (!string.IsNullOrEmpty(privateIp))
{
parameters.Add("privateIp", privateIp);
}
// build the query string
string poststring = parameters.ToQueryString();
return(await _apiClient.PostAsync <Status>(ApiUris.ModifyServer(_apiClient.OrganizationId, serverId), poststring));
}
/// <summary>
/// Creates a Node on a Network Domain in an MCP 2.0 data center location.
/// </summary>
/// <param name="node">The create node.</param>
/// <returns>The async task of <see cref="ResponseType"/></returns>
public async Task <ResponseType> CreateNode(CreateNodeType node)
{
return(await _api.PostAsync <CreateNodeType, ResponseType>(ApiUris.AddVipNode(_api.OrganizationId), node));
}
/// <summary>
/// The Create Consistency Group
/// </summary>
/// <param name="createConsistencyGroup">The create consistency group type.</param>
/// <returns>The <see cref="ResponseType"/></returns>
public async Task <ResponseType> CreateConsistencyGroup(CreateConsistencyGroupType createConsistencyGroup)
{
return(await _apiClient.PostAsync <CreateConsistencyGroupType, ResponseType>(ApiUris.CreateConsistencyGroups(_apiClient.OrganizationId), createConsistencyGroup));
}
/// <summary>The create tag key.</summary>
/// <param name="createTagKey">The create tag key.</param>
/// <returns>The <see cref="Task"/>.</returns>
public async Task <ResponseType> CreateTagKey(createTagKeyType createTagKey)
{
return(await _apiClient.PostAsync <createTagKeyType, ResponseType>(ApiUris.CreateTagKey(_apiClient.OrganizationId), createTagKey));
}
/// <summary>
/// Edit Customer Image Metadata
/// </summary>
/// <param name="editImageMetadata">Edit Image Metadata</param>
/// <returns>Response Data</returns>
public async Task <ResponseType> EditCustomerImageMetadata(EditImageMetadataType editImageMetadata)
{
return(await _apiClient.PostAsync <EditImageMetadataType, ResponseType>(
ApiUris.EditMcp2CustomerImageMetadata(_apiClient.OrganizationId), editImageMetadata));
}
/// <summary>The Create Snapshot Preview Server.</summary>
/// <param name="request">The Create Snapshot Preview Server Request</param>
/// <returns>The <see cref="Task"/>.</returns>
public async Task <ResponseType> CreateSnapshotPreviewServer(CreateSnapshotPreviewServerType request)
{
return(await _apiClient.PostAsync <CreateSnapshotPreviewServerType, ResponseType>(ApiUris.CreateSnapShotPreviewServer(_apiClient.OrganizationId), request));
}
/// <summary>
/// Creates a Pool on a Network Domain in an MCP 2.0 data center location.
/// </summary>
/// <param name="pool">The create pool.</param>
/// <returns>The async task of <see cref="ResponseType"/></returns>
public async Task <ResponseType> CreatePool(createPool pool)
{
return(await _api.PostAsync <createPool, ResponseType>(ApiUris.CreatePool(_api.OrganizationId), pool));
}
/// <summary>
/// This function create a new custom static route.
/// </summary>
/// <param name="networkDomain">
/// The network Domain.
/// </param>
/// <returns>
/// Response containing status.
/// </returns>
public async Task <ResponseType> CreateStaticRoute(CreateStaticRouteType networkDomain)
{
return(await _apiClient.PostAsync <CreateStaticRouteType, ResponseType>(
ApiUris.CreateStaticRoute(_apiClient.OrganizationId),
networkDomain));
}
/// <summary>
/// Creates a firewall rule.
/// </summary>
/// <param name="createFirewallRule">The firewall rule details.</param>
/// <returns>The response details.</returns>
public async Task <ResponseType> CreateFirewallRule(CreateFirewallRuleType createFirewallRule)
{
return(await _api.PostAsync <CreateFirewallRuleType, ResponseType>(
ApiUris.CreateFirewallRule(_api.OrganizationId),
createFirewallRule));
}
/// <summary>
/// Enables server monitoring.
/// </summary>
/// <param name="enableServerMonitoring">The monitoring settings.</param>
/// <returns>The status response</returns>
public async Task <ResponseType> EnableServerMonitoring(EnableServerMonitoringType enableServerMonitoring)
{
return(await _apiClient.PostAsync <EnableServerMonitoringType, ResponseType>(
ApiUris.EnableServerMonitoring(_apiClient.OrganizationId),
enableServerMonitoring));
}
/// <summary>
/// This function deploys a new network domains to Cloud
/// </summary>
/// <param name="networkDomain">
/// The network Domain.
/// </param>
/// <returns>
/// Response containing status.
/// </returns>
public async Task <ResponseType> DeployNetworkDomain(DeployNetworkDomainType networkDomain)
{
return(await _apiClient.PostAsync <DeployNetworkDomainType, ResponseType>(
ApiUris.CreateNetworkDomain(_apiClient.OrganizationId),
networkDomain));
}
/// <summary>
/// Set Re-IP rules for a DRS Target Server to override replicated network settings when entering DRS Preview mode.
/// </summary>
/// <param name="setDrsReIpAddressRules">Drs Target Server Re-IP details</param>
/// <returns>The <see cref="ResponseType"/></returns>
public async Task <ResponseType> SetDrsReIpAddressRules(SetDrsReIpAddressRulesType setDrsReIpAddressRules)
{
return(await _apiClient.PostAsync <SetDrsReIpAddressRulesType, ResponseType>(ApiUris.SetDrsReIpAddressRules(_apiClient.OrganizationId), setDrsReIpAddressRules));
}
/// <summary>
/// Creates a NAT Rule on a Network Domain in an MCP 2.0 data center location.
/// </summary>
/// <param name="natRule">
/// The NAT Rule.
/// </param>
/// <returns>
/// Operation status
/// </returns>
public async Task <ResponseType> CreateNatRule(createNatRule natRule)
{
return
(await _api.PostAsync <createNatRule, ResponseType>(ApiUris.CreateNatRule(_api.OrganizationId), natRule));
}
/// <summary>
/// Creates a VirtualListener on a Network Domain in an MCP 2.0 data center location.
/// </summary>
/// <param name="virtualListener">The create virtual listener.</param>
/// <returns>The async task of <see cref="ResponseType"/></returns>
public async Task <ResponseType> CreateVirtualListener(createVirtualListener virtualListener)
{
return(await _api.PostAsync <createVirtualListener, ResponseType>(ApiUris.CreateVirtualListener(_api.OrganizationId), virtualListener));
}
/// <summary>
/// The Set Vpn Access.
/// </summary>
/// <param name="request">The Set VPN access request.</param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <ResponseType> SetVpnAccess(setVpnAccess request)
{
return(await _apiClient.PostAsync <setVpnAccess, ResponseType>(ApiUris.SetVpnAccess(_apiClient.OrganizationId), request));
}
/// <summary> Deletes the server described by serverId. </summary>
/// <param name="serverId"> The server id. </param>
/// <returns> A standard CaaS response. </returns>
/// <seealso cref="M:DD.CBU.Compute.Api.Client.Interfaces.Server20.IServerAccessor.DeleteServer(Guid)"/>
public async Task <ResponseType> DeleteServer(Guid serverId)
{
return(await _apiClient.PostAsync <DeleteServerType, ResponseType>(ApiUris.DeleteServer(_apiClient.OrganizationId),
new DeleteServerType { id = serverId.ToString() }));
}
/// <summary>
/// Creates the Security group
/// </summary>
/// <param name="securityGroup">Security group</param>
/// <returns>Response Data</returns>
public async Task <ResponseType> CreateSecurityGroup(createSecurityGroup securityGroup)
{
return(await _api.PostAsync <createSecurityGroup, ResponseType>(ApiUris.CreateSecurityGroup(_api.OrganizationId), securityGroup));
}