Calculate Refund - Post

Référence

Service:: Reserved VM Instances

Version d'API:: 2022-11-01

Calculez le montant de remboursement d’une commande de réservation.
Calculez le prix de retour Reservations s’il n’y a pas d’erreur de stratégie.

POST https://management.azure.com/providers/Microsoft.Capacity/reservationOrders/{reservationOrderId}/calculateRefund?api-version=2022-11-01

Paramètres URI

Nom	Dans	Obligatoire	Type	Description
reservationOrderId	path	True	string	ID de commande de la réservation
api-version	query	True	string	Version prise en charge.

Corps de la demande

Nom	Type	Description
id	string	Identificateur complet de l’ordre de réservation retourné
properties	CalculateRefundRequestProperties	Propriétés nécessaires pour calculer le remboursement, y compris l’étendue et la réservation à retourner.

Réponses

Nom	Type	Description
200 OK	CalculateRefundResponse	Informations détaillées sur le remboursement d’une réservation
Other Status Codes	Error	Erreur inattendue

Exemples

CalculateRefund

Exemple de requête

POST https://management.azure.com/providers/Microsoft.Capacity/reservationOrders/276e7ae4-84d0-4da6-ab4b-d6b94f3557da/calculateRefund?api-version=2022-11-01

{
  "id": "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004",
  "properties": {
    "scope": "Reservation",
    "reservationToReturn": {
      "reservationId": "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000",
      "quantity": 1
    }
  }
}


import com.azure.resourcemanager.reservations.models.CalculateRefundRequest;
import com.azure.resourcemanager.reservations.models.CalculateRefundRequestProperties;
import com.azure.resourcemanager.reservations.models.ReservationToReturn;

/**
 * Samples for CalculateRefund Post.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-11-01/examples/CalculateRefund.json
     */
    /**
     * Sample code: CalculateRefund.
     * 
     * @param manager Entry point to ReservationsManager.
     */
    public static void calculateRefund(com.azure.resourcemanager.reservations.ReservationsManager manager) {
        manager.calculateRefunds().postWithResponse("276e7ae4-84d0-4da6-ab4b-d6b94f3557da", new CalculateRefundRequest()
            .withId("/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004")
            .withProperties(new CalculateRefundRequestProperties().withScope("Reservation")
                .withReservationToReturn(new ReservationToReturn().withReservationId(
                    "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000")
                    .withQuantity(1))),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential
from azure.mgmt.reservations import AzureReservationAPI

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-reservations
# USAGE
    python calculate_refund.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = AzureReservationAPI(
        credential=DefaultAzureCredential(),
    )

    response = client.calculate_refund.post(
        reservation_order_id="276e7ae4-84d0-4da6-ab4b-d6b94f3557da",
        body={
            "id": "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004",
            "properties": {
                "reservationToReturn": {
                    "quantity": 1,
                    "reservationId": "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000",
                },
                "scope": "Reservation",
            },
        },
    )
    print(response)


# x-ms-original-file: specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-11-01/examples/CalculateRefund.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armreservations_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/reservations/armreservations/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/1e7b408f3323e7f5424745718fe62c7a043a2337/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-11-01/examples/CalculateRefund.json
func ExampleCalculateRefundClient_Post() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armreservations.NewClientFactory(cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewCalculateRefundClient().Post(ctx, "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", armreservations.CalculateRefundRequest{
		ID: to.Ptr("/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004"),
		Properties: &armreservations.CalculateRefundRequestProperties{
			ReservationToReturn: &armreservations.ReservationToReturn{
				Quantity:      to.Ptr[int32](1),
				ReservationID: to.Ptr("/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000"),
			},
			Scope: to.Ptr("Reservation"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.CalculateRefundResponse = armreservations.CalculateRefundResponse{
	// 	ID: to.Ptr("/providers/Microsoft.Capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000"),
	// 	Properties: &armreservations.RefundResponseProperties{
	// 		BillingInformation: &armreservations.RefundBillingInformation{
	// 			BillingCurrencyProratedAmount: &armreservations.Price{
	// 				Amount: to.Ptr[float64](3.28),
	// 				CurrencyCode: to.Ptr("GBP"),
	// 			},
	// 			BillingCurrencyRemainingCommitmentAmount: &armreservations.Price{
	// 				Amount: to.Ptr[float64](0),
	// 				CurrencyCode: to.Ptr("GBP"),
	// 			},
	// 			BillingCurrencyTotalPaidAmount: &armreservations.Price{
	// 				Amount: to.Ptr[float64](24),
	// 				CurrencyCode: to.Ptr("GBP"),
	// 			},
	// 			BillingPlan: to.Ptr(armreservations.ReservationBillingPlanUpfront),
	// 			CompletedTransactions: to.Ptr[int32](1),
	// 			TotalTransactions: to.Ptr[int32](1),
	// 		},
	// 		BillingRefundAmount: &armreservations.Price{
	// 			Amount: to.Ptr[float64](20.72),
	// 			CurrencyCode: to.Ptr("GBP"),
	// 		},
	// 		PolicyResult: &armreservations.RefundPolicyResult{
	// 			Properties: &armreservations.RefundPolicyResultProperty{
	// 				ConsumedRefundsTotal: &armreservations.Price{
	// 					Amount: to.Ptr[float64](83.69),
	// 					CurrencyCode: to.Ptr("USD"),
	// 				},
	// 				MaxRefundLimit: &armreservations.Price{
	// 					Amount: to.Ptr[float64](50000),
	// 					CurrencyCode: to.Ptr("USD"),
	// 				},
	// 				PolicyErrors: []*armreservations.RefundPolicyError{
	// 					{
	// 						Code: to.Ptr(armreservations.ErrorResponseCodeSelfServiceRefundNotSupported),
	// 						Message: to.Ptr("Self Service refunds are currently not supported for this resource, please contact support."),
	// 				}},
	// 			},
	// 		},
	// 		PricingRefundAmount: &armreservations.Price{
	// 			Amount: to.Ptr[float64](24.92),
	// 			CurrencyCode: to.Ptr("USD"),
	// 		},
	// 		Quantity: to.Ptr[int32](1),
	// 		SessionID: to.Ptr("10000000-aaaa-bbbb-cccc-200000000000"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { AzureReservationAPI } = require("@azure/arm-reservations");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Calculate price for returning `Reservations` if there are no policy errors.

 *
 * @summary Calculate price for returning `Reservations` if there are no policy errors.

 * x-ms-original-file: specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-11-01/examples/CalculateRefund.json
 */
async function calculateRefund() {
  const reservationOrderId = "276e7ae4-84d0-4da6-ab4b-d6b94f3557da";
  const body = {
    id: "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004",
    properties: {
      reservationToReturn: {
        quantity: 1,
        reservationId:
          "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000",
      },
      scope: "Reservation",
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new AzureReservationAPI(credential);
  const result = await client.calculateRefund.post(reservationOrderId, body);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Reservations.Models;
using Azure.ResourceManager.Reservations;

// Generated from example definition: specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-11-01/examples/CalculateRefund.json
// this example is just showing the usage of "CalculateRefund_Post" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ReservationOrderResource created on azure
// for more information of creating ReservationOrderResource, please refer to the document of ReservationOrderResource
Guid reservationOrderId = Guid.Parse("276e7ae4-84d0-4da6-ab4b-d6b94f3557da");
ResourceIdentifier reservationOrderResourceId = ReservationOrderResource.CreateResourceIdentifier(reservationOrderId);
ReservationOrderResource reservationOrder = client.GetReservationOrderResource(reservationOrderResourceId);

// invoke the operation
ReservationCalculateRefundContent content = new ReservationCalculateRefundContent
{
    Id = "/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004",
    Properties = new ReservationCalculateRefundRequestProperties
    {
        Scope = "Reservation",
        ReservationToReturn = new ReservationToReturn
        {
            ReservationId = new ResourceIdentifier("/providers/microsoft.capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000"),
            Quantity = 1,
        },
    },
};
ReservationCalculateRefundResult result = await reservationOrder.CalculateRefundAsync(content);

Console.WriteLine($"Succeeded: {result}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Exemple de réponse

Code d’état:: 200

{
  "id": "/providers/Microsoft.Capacity/reservationOrders/50000000-aaaa-bbbb-cccc-100000000004/reservations/40000000-aaaa-bbbb-cccc-100000000000",
  "properties": {
    "sessionId": "10000000-aaaa-bbbb-cccc-200000000000",
    "quantity": 1,
    "billingRefundAmount": {
      "currencyCode": "GBP",
      "amount": 20.72
    },
    "pricingRefundAmount": {
      "currencyCode": "USD",
      "amount": 24.92
    },
    "policyResult": {
      "properties": {
        "consumedRefundsTotal": {
          "currencyCode": "USD",
          "amount": 83.69
        },
        "maxRefundLimit": {
          "currencyCode": "USD",
          "amount": 50000
        },
        "policyErrors": [
          {
            "code": "SelfServiceRefundNotSupported",
            "message": "Self Service refunds are currently not supported for this resource, please contact support."
          }
        ]
      }
    },
    "billingInformation": {
      "billingPlan": "Upfront",
      "completedTransactions": 1,
      "totalTransactions": 1,
      "billingCurrencyTotalPaidAmount": {
        "currencyCode": "GBP",
        "amount": 24
      },
      "billingCurrencyProratedAmount": {
        "currencyCode": "GBP",
        "amount": 3.28
      },
      "billingCurrencyRemainingCommitmentAmount": {
        "currencyCode": "GBP",
        "amount": 0
      }
    }
  }
}

Définitions

Nom	Description
CalculateRefundRequest	Demande contenant des informations nécessaires pour calculer le remboursement.
CalculateRefundRequestProperties	Propriétés nécessaires pour calculer le remboursement, y compris l’étendue et la réservation à retourner.
CalculateRefundResponse	Réponse du calcul du remboursement contenant les informations de remboursement de réservation
Error	Informations sur l’erreur
ErrorResponseCode	Code d’erreur décrivant la raison pour laquelle le service n’est pas en mesure de traiter la demande entrante
ExtendedErrorInfo	Informations d’erreur étendues, notamment le code d’erreur et le message d’erreur
Price	Informations de tarification contenant le montant et le code monétaire
RefundBillingInformation	informations de facturation
RefundPolicyError	détails de l’erreur
RefundPolicyResult	Résultat de la stratégie de remboursement
RefundPolicyResultProperty	Propriété de résultat de la stratégie de remboursement
RefundResponseProperties	Propriétés de remboursement de la réservation
ReservationBillingPlan	Représentez les plans de facturation.
ReservationToReturn	Réservation à retourner

CalculateRefundRequest

Object

Demande contenant des informations nécessaires pour calculer le remboursement.

Nom	Type	Description
id	string	Identificateur complet de l’ordre de réservation retourné
properties	CalculateRefundRequestProperties	Propriétés nécessaires pour calculer le remboursement, y compris l’étendue et la réservation à retourner.

CalculateRefundRequestProperties

Object

Propriétés nécessaires pour calculer le remboursement, y compris l’étendue et la réservation à retourner.

Nom	Type	Description
reservationToReturn	ReservationToReturn	Réservation à retourner
scope	string	Étendue du remboursement, par exemple réservation

CalculateRefundResponse

Object

Réponse du calcul du remboursement contenant les informations de remboursement de réservation

Nom	Type	Description
id	string	Identificateur complet de la réservation retournée
properties	RefundResponseProperties	Propriétés de remboursement de la réservation

Error

Object

Informations sur l’erreur

Nom	Type	Description
error	ExtendedErrorInfo	Informations d’erreur étendues, notamment le code d’erreur et le message d’erreur

ErrorResponseCode

Énumération

Code d’erreur décrivant la raison pour laquelle le service n’est pas en mesure de traiter la demande entrante

Valeur	Description
ActivateQuoteFailed
AppliedScopesNotAssociatedWithCommerceAccount
AppliedScopesSameAsExisting
AuthorizationFailed
BadRequest
BillingCustomerInputError
BillingError
BillingPaymentInstrumentHardError
BillingPaymentInstrumentSoftError
BillingScopeIdCannotBeChanged
BillingTransientError
CalculatePriceFailed
CapacityUpdateScopesFailed
ClientCertificateThumbprintNotSet
CreateQuoteFailed
Forbidden
FulfillmentConfigurationError
FulfillmentError
FulfillmentOutOfStockError
FulfillmentTransientError
HttpMethodNotSupported
InternalServerError
InvalidAccessToken
InvalidFulfillmentRequestParameters
InvalidHealthCheckType
InvalidLocationId
InvalidRefundQuantity
InvalidRequestContent
InvalidRequestUri
InvalidReservationId
InvalidReservationOrderId
InvalidSingleAppliedScopesCount
InvalidSubscriptionId
InvalidTenantId
MissingAppliedScopesForSingle
MissingTenantId
NoValidReservationsToReRate
NonsupportedAccountId
NotSpecified
NotSupportedCountry
OperationCannotBePerformedInCurrentState
OperationFailed
PatchValuesSameAsExisting
PaymentInstrumentNotFound
PurchaseError
ReRateOnlyAllowedForEA
RefundLimitExceeded
ReservationIdNotInReservationOrder
ReservationOrderCreationFailed
ReservationOrderIdAlreadyExists
ReservationOrderNotEnabled
ReservationOrderNotFound
RiskCheckFailed
RoleAssignmentCreationFailed
SelfServiceRefundNotSupported
ServerTimeout
UnauthenticatedRequestsThrottled
UnsupportedReservationTerm

ExtendedErrorInfo

Object

Informations d’erreur étendues, notamment le code d’erreur et le message d’erreur

Nom	Type	Description
code	ErrorResponseCode	Code d’erreur décrivant la raison pour laquelle le service n’est pas en mesure de traiter la demande entrante
message	string

Price

Object

Informations de tarification contenant le montant et le code monétaire

Nom	Type	Description
amount	number (double)
currencyCode	string	Code monétaire iso 4217 3 lettres pour la devise utilisée par cet enregistrement d’achat.

RefundBillingInformation

Object

informations de facturation

Nom	Type	Description
billingCurrencyProratedAmount	Price	Informations de tarification contenant le montant et le code monétaire
billingCurrencyRemainingCommitmentAmount	Price	Informations de tarification contenant le montant et le code monétaire
billingCurrencyTotalPaidAmount	Price	Informations de tarification contenant le montant et le code monétaire
billingPlan	ReservationBillingPlan	Représentez les plans de facturation.
completedTransactions	integer (int32)	Nombre de transactions terminées dans le paiement de cette réservation
totalTransactions	integer (int32)	Nombre total de transactions dans le paiement de cette réservation

RefundPolicyError

Object

détails de l’erreur

Nom	Type	Description
code	ErrorResponseCode	Code d’erreur décrivant la raison pour laquelle le service n’est pas en mesure de traiter la demande entrante
message	string

RefundPolicyResult

Object

Résultat de la stratégie de remboursement

Nom	Type	Description
properties	RefundPolicyResultProperty	Propriété de résultat de la stratégie de remboursement

RefundPolicyResultProperty

Object

Propriété de résultat de la stratégie de remboursement

Nom	Type	Description
consumedRefundsTotal	Price	Informations de tarification contenant le montant et le code monétaire
maxRefundLimit	Price	Informations de tarification contenant le montant et le code monétaire
policyErrors	RefundPolicyError[]	Erreurs de stratégie de remboursement

RefundResponseProperties

Object

Propriétés de remboursement de la réservation

Nom	Type	Description
billingInformation	RefundBillingInformation	informations de facturation
billingRefundAmount	Price	Informations de tarification contenant le montant et le code monétaire
policyResult	RefundPolicyResult	Résultat de la stratégie de remboursement
pricingRefundAmount	Price	Informations de tarification contenant le montant et le code monétaire
quantity	integer (int32)	Quantité à retourner
sessionId	string	Identificateur de session de remboursement

ReservationBillingPlan

Énumération

Représentez les plans de facturation.

Valeur	Description
Monthly
Upfront

ReservationToReturn

Object

Réservation à retourner

Nom	Type	Description
quantity	integer (int32)	Quantité à retourner. Doit être supérieur à zéro.
reservationId	string	Identificateur complet de la réservation retournée