文件 AWS 開發套件範例 GitHub 儲存庫中有更多可用的 [AWS SDK 範例](https://github.com/awsdocs/aws-doc-sdk-examples)。 本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。 # AWS Marketplace 使用適用於 Python 的 SDK (Boto3) 的協議 API 範例 下列程式碼範例示範如何使用 適用於 Python (Boto3) 的 AWS SDK 搭配 AWS Marketplace 協議 API 來執行動作和實作常見案例。 每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。 **Topics** + [協議](#agreements) ## 協議 ### 接受協議取消請求 下列程式碼範例示範如何接受賣方啟動的協議取消請求。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class AcceptAgreementCancellationRequest: AGREEMENT_ID = "" AGREEMENT_CANCELLATION_REQUEST_ID = "" @staticmethod def accept_agreement_cancellation_request(): client = boto3.client("marketplace-agreement") response = client.accept_agreement_cancellation_request( agreementId=AcceptAgreementCancellationRequest.AGREEMENT_ID, agreementCancellationRequestId=AcceptAgreementCancellationRequest.AGREEMENT_CANCELLATION_REQUEST_ID, ) print("Agreement ID: " + response["agreementId"]) print("Cancellation Request ID: " + response["agreementCancellationRequestId"]) print("Status: " + str(response.get("status", ""))) print("Description: " + str(response.get("description", ""))) print("Reason Code: " + str(response.get("reasonCode", ""))) print("Created At: " + str(response.get("createdAt", ""))) print("Updated At: " + str(response.get("updatedAt", ""))) if __name__ == "__main__": AcceptAgreementCancellationRequest.accept_agreement_cancellation_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [AcceptAgreementCancellationRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/AcceptAgreementCancellationRequest)。 ### 接受協議付款請求 下列程式碼範例示範如何接受賣方啟動的協議付款請求。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class AcceptAgreementPaymentRequest: AGREEMENT_ID = "" PAYMENT_REQUEST_ID = "" PURCHASE_ORDER_REFERENCE = "" @staticmethod def accept_agreement_payment_request(): client = boto3.client("marketplace-agreement") response = client.accept_agreement_payment_request( agreementId=AcceptAgreementPaymentRequest.AGREEMENT_ID, paymentRequestId=AcceptAgreementPaymentRequest.PAYMENT_REQUEST_ID, purchaseOrderReference=AcceptAgreementPaymentRequest.PURCHASE_ORDER_REFERENCE, ) print("Payment Request ID: " + response["paymentRequestId"]) print("Agreement ID: " + response["agreementId"]) print("Status: " + str(response.get("status", ""))) print("Name: " + str(response.get("name", ""))) print("Charge Amount: " + str(response.get("chargeAmount", ""))) print("Currency Code: " + str(response.get("currencyCode", ""))) print("Created At: " + str(response.get("createdAt", ""))) print("Updated At: " + str(response.get("updatedAt", ""))) if __name__ == "__main__": AcceptAgreementPaymentRequest.accept_agreement_payment_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [AcceptAgreementPaymentRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/AcceptAgreementPaymentRequest)。 ### 修改 SaaS 合約協議續約期限 下列程式碼範例示範如何修改 SaaS 合約協議，以新增或更新其續約期間。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to create a SaaS agreement with CONTRACT pricing model and then turn on the auto-renewal setting using the AWS Marketplace Agreement Service APIs. Scenario: A buyer subscribes to a SaaS product using a public offer that supports auto-renewal. After acceptance, the buyer decides to amend the agreement to enable auto-renewal via the RenewalTerm configuration. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offer: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the offer. - Term IDs (starting with term-) — found in the offer's term list. - SELECTOR_VALUE — duration for the agreement (e.g., P1M for 1 month). - DIMENSION_1_KEY — the dimension key defined in the offer. """ import boto3 from utils.agreement_api_utils import ( format_output, generate_client_token, poll_until_entitlements_available, ) class AmendSaaSContractRenewalTerm: # The agreementProposalId from the offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the ConfigurableUpfrontPricingTerm in your offer. CONFIGURABLE_UPFRONT_PRICING_TERM_ID = "" # Duration for the agreement (e.g., "P1M" for 1 month, "P12M" for 1 year). SELECTOR_VALUE = "" # The dimension key defined in your offer. DIMENSION_1_KEY = "" # Quantity for the dimension. DIMENSION_1_VALUE = 1 # Term ID for the RenewalTerm in your offer. RENEWAL_TERM_ID = "" # Term ID for the LegalTerm in your offer. LEGAL_TERM_ID = "" # Term ID for the SupportTerm in your offer. SUPPORT_TERM_ID = "" @staticmethod def amend_saas_contract_agreement_renewal_term(): """ Full end-to-end flow: 1. Create a SaaS agreement with CONTRACT pricing model with auto-renewal disabled. 2. Wait for entitlements to become active. 3. Amend the agreement to enable auto-renewal. """ client = boto3.client("marketplace-agreement") cls = AmendSaaSContractRenewalTerm configurable_upfront_pricing_term = { "id": cls.CONFIGURABLE_UPFRONT_PRICING_TERM_ID, "configuration": { "configurableUpfrontPricingTermConfiguration": { "selectorValue": cls.SELECTOR_VALUE, "dimensions": [ { "dimensionKey": cls.DIMENSION_1_KEY, "dimensionValue": cls.DIMENSION_1_VALUE, }, ], } }, } # Initial agreement: auto-renewal disabled. renewal_term = { "id": cls.RENEWAL_TERM_ID, "configuration": { "renewalTermConfiguration": { "enableAutoRenew": False, } }, } legal_term = {"id": cls.LEGAL_TERM_ID} support_term = {"id": cls.SUPPORT_TERM_ID} # --- Create and accept the initial SaaS agreement request with CONTRACT pricing model --- create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[configurable_upfront_pricing_term, renewal_term, legal_term, support_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) agreement_id = accept_response["agreementId"] print("Agreement request accepted. AgreementId: " + agreement_id) # Wait for entitlements to become active before amending. print("Waiting for entitlements to become active...") entitlements_response = poll_until_entitlements_available(client, agreement_id) print("Entitlements are now active.") format_output(entitlements_response) # --- Amend: enable auto-renewal --- renewal_term_amended = { "id": cls.RENEWAL_TERM_ID, "configuration": { "renewalTermConfiguration": { "enableAutoRenew": True, } }, } # Use Intent.AMEND and sourceAgreementIdentifier to target the existing agreement. car_response = client.create_agreement_request( clientToken=generate_client_token(), intent="AMEND", requestedTerms=[configurable_upfront_pricing_term, renewal_term_amended, legal_term, support_term], sourceAgreementIdentifier=agreement_id, ) print("Amend agreement request created. AgreementRequestId: " + car_response["agreementRequestId"]) aar_response = client.accept_agreement_request( agreementRequestId=car_response["agreementRequestId"] ) print("Amendment accepted. Auto-renewal enabled. New AgreementId: " + aar_response["agreementId"]) if __name__ == "__main__": AmendSaaSContractRenewalTerm.amend_saas_contract_agreement_renewal_term() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 修改用量定價模型的 AMI ConfigurableUpfrontPricingTerm 下列程式碼範例示範如何更新用量定價模型的維度數量，以修改與 ConfigurableUpfrontPricingTerm 的 AMI 協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to create an AMI agreement with ConfigurableUpfrontPricingTerm and then amend the dimension quantity using the AWS Marketplace Agreement Service APIs. Scenario: An AMI product with USAGE pricing requires two agreements: 1. An agreement with usageBasedPricingTerm (UBPT) — accepted first to establish the base agreement. 2. An agreement with configurableUpfrontPricingTerm (CUPT) — accepted after the UBPT agreement entitlements are active. Once both agreement entitlements are available, this sample shows how to amend the agreement with configurableUpfrontPricingTerm (CUPT) to increase the dimension quantity. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offer: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the offer. - Term IDs (starting with term-) — found in the offer's term list. - SELECTOR_VALUE — duration for the agreement (e.g., P365D for one year). - DIMENSION_1_KEY — the dimension key defined in the offer (e.g., instance type). - DIMENSION_1_VALUE — initial quantity; NEW_DIMENSION_1_VALUE — amended quantity. """ import boto3 from utils.agreement_api_utils import ( format_output, generate_client_token, poll_until_entitlements_available, ) class AmendAmiConfigurableUpfrontPricingTermForUsagePricingModel: # The agreementProposalId from the offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the ConfigurableUpfrontPricingTerm in your offer. CONFIGURABLE_UPFRONT_PRICING_TERM_ID = "" # Duration for the agreement (e.g., "P365D" for 365 days). SELECTOR_VALUE = "" # The dimension key defined in your offer (e.g., an EC2 instance type like "c6gn.medium"). DIMENSION_1_KEY = "" # Initial quantity for the dimension. DIMENSION_1_VALUE = 1 # Term ID for the UsageBasedPricingTerm in your offer. USAGE_TERM_ID = "" # Term ID for the LegalTerm in your offer. LEGAL_TERM_ID = "" # Term ID for the ValidityTerm in your offer. VALIDITY_TERM_ID = "" # New quantity to use when amending the dimension of CUPT. NEW_DIMENSION_1_VALUE = 5 @staticmethod def amend_ami_cupt_agreement(): """ Full end-to-end flow: 1. Create and accept an agreement request with usageBasedPricingTerm. 2. Wait for entitlements to become active, then create and accept an agreement request with configurableUpfrontPricingTerm (CUPT). 3. Wait for CUPT entitlements to become active, then amend the dimension quantity. """ client = boto3.client("marketplace-agreement") cls = AmendAmiConfigurableUpfrontPricingTermForUsagePricingModel usage_term = {"id": cls.USAGE_TERM_ID} legal_term = {"id": cls.LEGAL_TERM_ID} validity_term = {"id": cls.VALIDITY_TERM_ID} # --- Agreement with UBPT --- create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[usage_term, legal_term, validity_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request with UBPT created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) agreement_id = accept_response["agreementId"] print("Agreement request with UBPT accepted. AgreementId: " + agreement_id) # Wait for entitlements to become active before creating the agreement with CUPT. print("Waiting for UBPT agreement entitlements to become active...") entitlements_response = poll_until_entitlements_available(client, agreement_id) print("UBPT agreement entitlements are now active.") format_output(entitlements_response) # --- Agreement with configurableUpfrontPricingTerm (CUPT) --- configurable_upfront_pricing_term = { "id": cls.CONFIGURABLE_UPFRONT_PRICING_TERM_ID, "configuration": { "configurableUpfrontPricingTermConfiguration": { "selectorValue": cls.SELECTOR_VALUE, "dimensions": [ { "dimensionKey": cls.DIMENSION_1_KEY, "dimensionValue": cls.DIMENSION_1_VALUE, }, ], } }, } car_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[configurable_upfront_pricing_term, legal_term, validity_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) print("Agreement request with CUPT created. AgreementRequestId: " + car_response["agreementRequestId"]) aar_response = client.accept_agreement_request( agreementRequestId=car_response["agreementRequestId"] ) cupt_agreement_id = aar_response["agreementId"] print("Agreement request with CUPT accepted. AgreementId: " + cupt_agreement_id) # Wait for entitlements to become active before amending. print("Waiting for CUPT agreement entitlements to become active...") cupt_entitlements_response = poll_until_entitlements_available(client, cupt_agreement_id) print("CUPT agreement entitlements are now active.") format_output(cupt_entitlements_response) # --- Amend Agreement with CUPT --- # Increase the dimension quantity using Intent.AMEND and sourceAgreementIdentifier. new_config = { "id": cls.CONFIGURABLE_UPFRONT_PRICING_TERM_ID, "configuration": { "configurableUpfrontPricingTermConfiguration": { "selectorValue": cls.SELECTOR_VALUE, "dimensions": [ { "dimensionKey": cls.DIMENSION_1_KEY, "dimensionValue": cls.NEW_DIMENSION_1_VALUE, # Increase quantity for this dimension key }, ], } }, } car_amend_response = client.create_agreement_request( clientToken=generate_client_token(), intent="AMEND", requestedTerms=[new_config, legal_term, validity_term], sourceAgreementIdentifier=cupt_agreement_id, ) print( "Amendment of CUPT agreement request created. AgreementRequestId: " + car_amend_response["agreementRequestId"] ) aar_amend_response = client.accept_agreement_request( agreementRequestId=car_amend_response["agreementRequestId"] ) print("Amendment accepted. New AgreementId: " + aar_amend_response["agreementId"]) if __name__ == "__main__": AmendAmiConfigurableUpfrontPricingTermForUsagePricingModel.amend_ami_cupt_agreement() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 建立新的 AMI 免費試用協議 下列程式碼範例示範如何建立新的 AMI 免費試用協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to create an AMI Free Trial agreement using the AWS Marketplace Agreement Service APIs. Scenario: A buyer subscribes to an AMI product that offers a free trial period. The free trial includes a FreeTrialPricingTerm alongside a UsageBasedPricingTerm. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offer: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the offer. - Term IDs (starting with term-) — found in the offer's term list. """ import boto3 from utils.agreement_api_utils import generate_client_token class NewAmiFreeTrial: # The agreementProposalId from the offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the FreeTrialPricingTerm in your offer. FREE_TRIAL_PRICING_TERM_ID = "" # Term ID for the UsageBasedPricingTerm in your offer (applies after the trial ends). USAGE_BASED_PRICING_TERM_ID = "" # Term ID for the SupportTerm in your offer. SUPPORT_TERM_ID = "" # Term ID for the LegalTerm in your offer. LEGAL_TERM_ID = "" @staticmethod def create_and_accept_ami_free_trial_agreement_request(): """ Create an AMI Free Trial agreement. The FreeTrialPricingTerm grants access at no cost for the trial period. The UsageBasedPricingTerm defines the charges that apply once the trial ends. """ client = boto3.client("marketplace-agreement") create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[ {"id": NewAmiFreeTrial.FREE_TRIAL_PRICING_TERM_ID}, {"id": NewAmiFreeTrial.USAGE_BASED_PRICING_TERM_ID}, {"id": NewAmiFreeTrial.SUPPORT_TERM_ID}, {"id": NewAmiFreeTrial.LEGAL_TERM_ID}, ], agreementProposalIdentifier=NewAmiFreeTrial.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) print( "Agreement request with freeTrialPricingTerm accepted. AgreementId: " + accept_response["agreementId"] ) if __name__ == "__main__": NewAmiFreeTrial.create_and_accept_ami_free_trial_agreement_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 使用預付款建立新的 SaaS 合約協議 下列程式碼範例示範如何使用預付款建立新的 SaaS 合約協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to create a SaaS agreement with CONTRACT pricing model with upfront payment using the AWS Marketplace Agreement Service APIs. Scenario: A buyer subscribes to a SaaS product using a ConfigurableUpfrontPricingTerm, selecting an agreement duration and specifying quantities for multiple dimensions. Tax estimation is enabled at the time of agreement creation. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offer: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the offer. - Term IDs (starting with term-) — found in the offer's term list. - SELECTOR_VALUE — duration for the agreement (e.g., P12M for 12 months). - DIMENSION_1_KEY, DIMENSION_2_KEY — dimension keys defined in the offer. - DIMENSION_1_VALUE, DIMENSION_2_VALUE — quantities for each dimension. """ import boto3 from utils.agreement_api_utils import generate_client_token class NewSaaSContractWithUpfrontPayment: # The agreementProposalId from the offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the ConfigurableUpfrontPricingTerm in your offer. CONFIGURABLE_UPFRONT_PRICING_TERM_ID = "" # Duration for the agreement (e.g., "P12M" for 12 months). SELECTOR_VALUE = "" # First dimension key and quantity defined in your offer. DIMENSION_1_KEY = "" DIMENSION_1_VALUE = 10 # Second dimension key and quantity defined in your offer. DIMENSION_2_KEY = "" DIMENSION_2_VALUE = 20 # Term ID for the LegalTerm in your offer. LEGAL_TERM_ID = "" # Tax estimation setting: "ENABLED" to include estimated taxes in the agreement. TAX_ESTIMATION = "ENABLED" @staticmethod def create_saas_contract_agreement(): """ Create a SaaS agreement with CONTRACT pricing model with configurable upfront pricing for multiple dimensions and tax estimation. """ client = boto3.client("marketplace-agreement") configurable_upfront_pricing_term = { "id": NewSaaSContractWithUpfrontPayment.CONFIGURABLE_UPFRONT_PRICING_TERM_ID, "configuration": { "configurableUpfrontPricingTermConfiguration": { "selectorValue": NewSaaSContractWithUpfrontPayment.SELECTOR_VALUE, "dimensions": [ { "dimensionKey": NewSaaSContractWithUpfrontPayment.DIMENSION_1_KEY, "dimensionValue": NewSaaSContractWithUpfrontPayment.DIMENSION_1_VALUE, }, { "dimensionKey": NewSaaSContractWithUpfrontPayment.DIMENSION_2_KEY, "dimensionValue": NewSaaSContractWithUpfrontPayment.DIMENSION_2_VALUE, }, ], } }, } legal_term = {"id": NewSaaSContractWithUpfrontPayment.LEGAL_TERM_ID} create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[configurable_upfront_pricing_term, legal_term], taxConfiguration={"taxEstimation": NewSaaSContractWithUpfrontPayment.TAX_ESTIMATION}, agreementProposalIdentifier=NewSaaSContractWithUpfrontPayment.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) print( "SaaS agreement request with CONTRACT pricing model accepted. AgreementId: " + accept_response["agreementId"] ) if __name__ == "__main__": NewSaaSContractWithUpfrontPayment.create_saas_contract_agreement() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 取得所有協議 ID 下列程式碼範例示範如何取得所有協議 ID。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get all agreement ids AG-09 """ import logging import boto3 from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) MAX_PAGE_RESULTS = 10 def get_agreements(): AgreementSummaryList = [] agreement_id_list = [] try: agreements = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, # Set PartyType filter to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. filters=[ {"name": "PartyType", "values": ["Proposer"]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreements["agreementViewSummaries"]) while "nextToken" in agreements and agreements["nextToken"] is not None: try: agreements = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreements["nextToken"], filters=[ {"name": "PartyType", "values": ["Proposer"]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreements["agreementViewSummaries"]) for agreement in AgreementSummaryList: agreement_id_list.append(agreement["agreementId"]) return agreement_id_list if __name__ == "__main__": agreement_id_list = get_agreements() print(agreement_id_list) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 取得所有協議 下列程式碼範例示範如何中取得所有協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get all agreements AG-01 """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) MAX_PAGE_RESULTS = 10 party_type_list = ["Acceptor"] agreement_type_list = ["PurchaseAgreement"] filter_list = [ {"name": "PartyType", "values": party_type_list}, {"name": "AgreementType", "values": agreement_type_list}, ] agreement_results_list = [] def get_agreements(filter_list=filter_list): try: agreements = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, filters=filter_list, ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e agreement_results_list.extend(agreements["agreementViewSummaries"]) while "nextToken" in agreements and agreements["nextToken"] is not None: try: agreements = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreements["nextToken"], filters=filter_list, ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e agreement_results_list.extend(agreements["agreementViewSummaries"]) return agreement_results_list if __name__ == "__main__": agreements_list = get_agreements(filter_list) helper.pretty_print_datetime(agreements_list) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 從協議取得客戶 ID 下列程式碼範例示範如何從協議取得客戶 ID。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get customer AWS account id from a given agreement AG-08 """ import argparse import logging import boto3 from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) def get_agreement_information(agreement_id): try: response = mp_client.describe_agreement(agreementId=agreement_id) except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", agreement_id) raise e else: logger.error("Unexpected error: %s", e) raise e return response if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--agreement-id", "-aid", help="Provide agreement ID to describe agreement status", required=True, ) args = parser.parse_args() response = get_agreement_information(agreement_id=args.agreement_id) print(f"Customer account: {response['acceptor']['accountId']}") ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 取得協議取消請求的詳細資訊 下列程式碼範例示範如何取得特定協議取消請求的詳細資訊。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class GetAgreementCancellationRequest: AGREEMENT_ID = "" AGREEMENT_CANCELLATION_REQUEST_ID = "" @staticmethod def get_agreement_cancellation_request(): client = boto3.client("marketplace-agreement") response = client.get_agreement_cancellation_request( agreementId=GetAgreementCancellationRequest.AGREEMENT_ID, agreementCancellationRequestId=GetAgreementCancellationRequest.AGREEMENT_CANCELLATION_REQUEST_ID, ) print("Agreement ID: " + response["agreementId"]) print("Cancellation Request ID: " + response["agreementCancellationRequestId"]) print("Status: " + str(response.get("status", ""))) print("Status Message: " + str(response.get("statusMessage", ""))) print("Reason Code: " + str(response.get("reasonCode", ""))) print("Created At: " + str(response.get("createdAt", ""))) print("Updated At: " + str(response.get("updatedAt", ""))) if __name__ == "__main__": GetAgreementCancellationRequest.get_agreement_cancellation_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [GetAgreementCancellationRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementCancellationRequest)。 ### 取得協議付款請求的詳細資訊 下列程式碼範例示範如何取得特定協議付款請求的詳細資訊。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class GetAgreementPaymentRequest: AGREEMENT_ID = "" PAYMENT_REQUEST_ID = "" @staticmethod def get_agreement_payment_request(): client = boto3.client("marketplace-agreement") response = client.get_agreement_payment_request( agreementId=GetAgreementPaymentRequest.AGREEMENT_ID, paymentRequestId=GetAgreementPaymentRequest.PAYMENT_REQUEST_ID, ) print("Payment Request ID: " + response["paymentRequestId"]) print("Agreement ID: " + response["agreementId"]) print("Status: " + str(response.get("status", ""))) print("Status Message: " + str(response.get("statusMessage", ""))) print("Name: " + str(response.get("name", ""))) print("Charge ID: " + str(response.get("chargeId", ""))) print("Charge Amount: " + str(response.get("chargeAmount", ""))) print("Currency Code: " + str(response.get("currencyCode", ""))) print("Created At: " + str(response.get("createdAt", ""))) print("Updated At: " + str(response.get("updatedAt", ""))) if __name__ == "__main__": GetAgreementPaymentRequest.get_agreement_payment_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [GetAgreementPaymentRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementPaymentRequest)。 ### 從協議取得財務詳細資訊 下列程式碼範例示範如何從協議取得財務詳細資訊。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain financial details, such as Total Contract Value of the agreementfrom a given agreement AG-14 Example Usage: python3 get_agreement_financial_details.py --agreement-id """ import argparse import logging import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) mp_client = boto3.client("marketplace-agreement") def get_agreement_information(agreement_id): try: agreement = mp_client.describe_agreement(agreementId=agreement_id) return agreement except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", agreement_id) else: logger.error("Unexpected error: %s", e) return None if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--agreement-id", "-aid", help="Provide agreement ID to describe agreement status", required=True, ) args = parser.parse_args() agreement = get_agreement_information(args.agreement_id) if agreement is not None: print(f"Agreement Id: {args.agreement_id}") print( f"Agreement Value: {agreement['estimatedCharges']['currencyCode']} {agreement['estimatedCharges']['agreementValue']}" ) else: print(f"Agreement with ID {args.agreement_id} is not found") ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 從協議取得免費試用詳細資訊 下列程式碼範例示範如何從協議取得免費試用詳細資訊。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the details from an agreement of a free trial I have provided to the customer AG-20 Example Usage: python3 get_agreement_free_trial_details.py --agreement-id """ import argparse import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) mp_client = boto3.client("marketplace-agreement") def get_agreement_terms(agreement_id): try: agreement = mp_client.get_agreement_terms(agreementId=agreement_id) return agreement except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", agreement_id) else: logger.error("Unexpected error: %s", e) return None if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--agreement-id", "-aid", help="Provide agreement ID to describe agreement status", required=True, ) args = parser.parse_args() agreement = get_agreement_terms(agreement_id=args.agreement_id) if agreement is not None: freetrial_found = False for term in agreement["acceptedTerms"]: if "freeTrialPricingTerm" in term.keys(): helper.pretty_print_datetime(term) freetrial_found = True if not freetrial_found: print(f"No free trial term found for agreement: {args.agreement_id}") ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 取得協議的相關資訊 下列程式碼範例示範如何取得協議的相關資訊。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get agreement information AG-07 """ import argparse import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) def get_agreement_information(agreement_id): try: response = mp_client.describe_agreement(agreementId=agreement_id) except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", agreement_id) raise e else: logger.error("Unexpected error: %s", e) raise e return response if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--agreement-id", "-aid", help="Provide agreement ID to describe agreement status", required=True, ) args = parser.parse_args() response = get_agreement_information(agreement_id=args.agreement_id) helper.pretty_print_datetime(response) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 從協議取得產品和優惠詳細資訊 下列程式碼範例示範如何從協議取得產品和優惠詳細資訊。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get product and offer details in a given agreement AG-10 """ import argparse import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError mpa_client = boto3.client("marketplace-agreement") mpc_client = boto3.client("marketplace-catalog") logger = logging.getLogger(__name__) def get_agreement_information(agreement_id): """ Returns information about a given agreement Args: agreement_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: agreement = mpa_client.describe_agreement(agreementId=agreement_id) return agreement except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", agreement_id) else: logger.error("Unexpected error: %s", e) def get_entity_information(entity_id): """ Returns information about a given entity Args: entity_id str: Entity to return Returns: dict: Dictionary of entity information """ try: response = mpc_client.describe_entity( Catalog="AWSMarketplace", EntityId=entity_id, ) return response except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Entity with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def get_agreement_components(agreement_id): agreement_component_list = [] agreement = get_agreement_information(agreement_id) if agreement is not None: productIds = [] for resource in agreement["proposalSummary"]["resources"]: productIds.append(resource["id"]) for product_id in productIds: product_document = get_entity_information(product_id) product_document_dict = {} product_document_dict["product_id"] = product_id product_document_dict["document"] = product_document agreement_component_list.append(product_document_dict) offerId = agreement["proposalSummary"]["offerId"] offer_document = get_entity_information(offerId) offer_document_dict = {} offer_document_dict["offer_id"] = offerId offer_document_dict["document"] = offer_document agreement_component_list.append(offer_document_dict) return agreement_component_list else: print("Agreement with ID " + args.agreement_id + " is not found") if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") parser = argparse.ArgumentParser() parser.add_argument( "--agreement_id", "-aid", help="Provide agreement ID to search for product and offer detail", required=True, ) args = parser.parse_args() product_offer_detail = get_agreement_components(agreement_id=args.agreement_id) helper.pretty_print_datetime(product_offer_detail) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 取得協議的 EULA 下列程式碼範例示範如何取得協議的 EULA。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the EULA I have entered into with my customer via the agreement AG-18 """ import json import logging import os import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-1111111111111111111111111" # to use sample file or not USE_SAMPLE_FILE = False SAMPLE_FILE_NAME = "mockup_agreement_terms.json" # attribute name ROOT_ELEM = "acceptedTerms" TERM_NAME = "legalTerm" CONFIG_ELEM = "configuration" ATTRIBUTE_NAME = "documents" def get_agreement_information(mp_client, entity_id): """ Returns customer AWS Account id about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: if USE_SAMPLE_FILE: sample_file = os.path.join(os.path.dirname(__file__), SAMPLE_FILE_NAME) terms = open_json_file(sample_file) else: terms = mp_client.get_agreement_terms(agreementId=entity_id) legalEulaArray = [] for term in terms[ROOT_ELEM]: if TERM_NAME in term and ATTRIBUTE_NAME in term[TERM_NAME]: docs = term[TERM_NAME][ATTRIBUTE_NAME] for doc in docs: if "type" in doc: legalEulaArray.append(doc) return legalEulaArray except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreement_information(mp_client, AGREEMENT_ID)) # open json file from path def open_json_file(filename): with open(filename, "r") as f: return json.load(f) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 取得協議的自動續約條款 下列程式碼範例示範如何取得協議的自動續約條款。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the auto-renewal status of the agreement AG-15 """ import json import logging import os import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-11111111111111111111" # to use sample file or not USE_SAMPLE_FILE = False SAMPLE_FILE_NAME = "mockup_agreement_terms.json" # attribute name ROOT_ELEM = "acceptedTerms" TERM_NAME = "renewalTerm" CONFIG_ELEM = "configuration" ATTRIBUTE_NAME = "enableAutoRenew" def get_agreement_information(mp_client, entity_id): """ Returns customer AWS Account id about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: if USE_SAMPLE_FILE: sample_file = os.path.join(os.path.dirname(__file__), SAMPLE_FILE_NAME) terms = open_json_file(sample_file) else: terms = mp_client.get_agreement_terms(agreementId=entity_id) auto_renewal = "No Auto Renewal" for term in terms[ROOT_ELEM]: if TERM_NAME in term: if CONFIG_ELEM in term[TERM_NAME]: auto_renewal = term[TERM_NAME][CONFIG_ELEM][ATTRIBUTE_NAME] break return auto_renewal except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") agreement = get_agreement_information(mp_client, AGREEMENT_ID) if agreement is not None: print(f"Auto Renewal is {agreement}") else: print("Agreement with ID " + AGREEMENT_ID + " is not found") # open json file from path def open_json_file(filename): with open(filename, "r") as f: return json.load(f) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 取得協議中購買的維度 下列程式碼範例示範如何取得協議中購買的維度。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the dimensions the buyer has purchased from me via the agreement AG-28 """ import json import logging import os import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-1111111111111111111111111" # to use sample file or not USE_SAMPLE_FILE = False SAMPLE_FILE_NAME = "mockup_agreement_terms.json" # attribute name ROOT_ELEM = "acceptedTerms" TERM_NAME = "configurableUpfrontPricingTerm" CONFIG_ELEM = "configuration" ATTRIBUTE_NAME = "selectorValue" def get_agreement_information(mp_client, entity_id): """ Returns customer AWS Account id about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: if USE_SAMPLE_FILE: sample_file = os.path.join(os.path.dirname(__file__), SAMPLE_FILE_NAME) terms = open_json_file(sample_file) else: terms = mp_client.get_agreement_terms(agreementId=entity_id) dimensionKeys = [] for term in terms[ROOT_ELEM]: if TERM_NAME in term: if CONFIG_ELEM in term[TERM_NAME]: confParam = term[TERM_NAME][CONFIG_ELEM] if ATTRIBUTE_NAME in confParam: if "dimensions" in confParam: for dimension in confParam["dimensions"]: if "dimensionKey" in dimension: dimensionKey = dimension["dimensionKey"] print(f"Dimension Key: {dimensionKey}") dimensionKeys.append(dimensionKey) return dimensionKeys except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreement_information(mp_client, AGREEMENT_ID)) # open json file from path def open_json_file(filename): with open(filename, "r") as f: return json.load(f) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 取得協議中購買的每個維度的執行個體 下列程式碼範例示範如何取得協議中購買的每個維度的執行個體。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain instances of each dimension that buyer has purchased in the agreement AG-30 """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-1111111111111111111111111" # attribute name ROOT_ELEM = "acceptedTerms" TERM_NAME = "configurableUpfrontPricingTerm" CONFIG_ELEM = "configuration" ATTRIBUTE_NAME = "selectorValue" logger = logging.getLogger(__name__) def get_agreement_information(mp_client, entity_id): """ Returns customer AWS Account id about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: terms = mp_client.get_agreement_terms(agreementId=entity_id) dimensionKeyValueMap = {} for term in terms[ROOT_ELEM]: if TERM_NAME in term: if CONFIG_ELEM in term[TERM_NAME]: confParam = term[TERM_NAME][CONFIG_ELEM] if ATTRIBUTE_NAME in confParam: selectValue = confParam["selectorValue"] dimensionKeyValueMap["selectorValue"] = selectValue if "dimensions" in confParam: dimensionKeyValueMap["dimensions"] = confParam["dimensions"] """ for dimension in confParam['dimensions']: if 'dimensionKey' in dimension: dimensionValue = dimension['dimensionValue'] dimensionKey = dimension['dimensionKey'] print(f"Selector: {selectValue}, Dimension Key: {dimensionKey}, Dimension Value: {dimensionValue}") dimensionKeyValueMap[dimensionKey] = dimensionValue """ return dimensionKeyValueMap except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreement_information(mp_client, AGREEMENT_ID)) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 取得協議的付費排程 下列程式碼範例示範如何取得協議的付費排程。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the payment schedule I have agreed to with the agreement, including the invoice date and invoice amount AG-17 """ import json import logging import os import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-1111111111111111111111111" # to use sample file or not USE_SAMPLE_FILE = False SAMPLE_FILE_NAME = "mockup_agreement_terms.json" # attribute name ROOT_ELEM = "acceptedTerms" TERM_NAME = "paymentScheduleTerm" CONFIG_ELEM = "configuration" ATTRIBUTE_NAME = "selectorValue" def get_agreement_information(mp_client, entity_id): """ Returns customer AWS Account id about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: if USE_SAMPLE_FILE: sample_file = os.path.join(os.path.dirname(__file__), SAMPLE_FILE_NAME) terms = open_json_file(sample_file) else: terms = mp_client.get_agreement_terms(agreementId=entity_id) paymentScheduleArray = [] currencyCode = "" for term in terms[ROOT_ELEM]: if TERM_NAME in term: paymentSchedule = term[TERM_NAME] if "currencyCode" in paymentSchedule: currencyCode = paymentSchedule["currencyCode"] if "schedule" in paymentSchedule: for sch in paymentSchedule["schedule"]: if "chargeDate" in sch: chargeDate = sch["chargeDate"] chargeAmount = sch["chargeAmount"] # print(f"chargeDate: {chargeDate}, chargeAmount: {chargeAmount}") schedule = { "currencyCode": currencyCode, "chargeDate": chargeDate, "chargeAmount": chargeAmount, } paymentScheduleArray.append(schedule) return paymentScheduleArray except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreement_information(mp_client, AGREEMENT_ID)) # open json file from path def open_json_file(filename): with open(filename, "r") as f: return json.load(f) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 取得協議中每個維度的定價 下列程式碼範例示範如何在協議中取得每個維度的定價。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain pricing per each dimension in the agreement AG-29 """ import json import logging import os import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-1111111111111111111111111" # to use sample file or not USE_SAMPLE_FILE = False SAMPLE_FILE_NAME = "mockup_agreement_terms.json" # attribute name ROOT_ELEM = "acceptedTerms" TERM_NAME = "configurableUpfrontPricingTerm" CONFIG_ELEM = "configuration" ATTRIBUTE_NAME = "selectorValue" TERMS_TO_SEARCH = [ "configurableUpfrontPricingTerm", "usageBasedPricingTerm", "fixedUpfrontPricingTerm", ] def get_agreement_information(mp_client, entity_id): """ Returns customer AWS Account id about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: if USE_SAMPLE_FILE: sample_file = os.path.join(os.path.dirname(__file__), SAMPLE_FILE_NAME) terms = open_json_file(sample_file) else: terms = mp_client.get_agreement_terms(agreementId=entity_id) dimentions = [] for term in terms[ROOT_ELEM]: for t in TERMS_TO_SEARCH: rateInfo = [] if t in term: if "type" in term[t]: rateInfo.append(term[t]["type"]) if "currencyCode" in term[t]: rateInfo.append(term[t]["currencyCode"]) if "rateCards" in term[t]: rateInfo.append(term[t]["rateCards"]) dimentions.append(rateInfo) return dimentions except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreement_information(mp_client, AGREEMENT_ID)) # open json file from path def open_json_file(filename): with open(filename, "r") as f: return json.load(f) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 取得協議的定價類型 下列程式碼範例示範如何取得協議的定價類型。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the pricing type of the agreement (contract, FPS, metered, free etc.) AG-16 """ import json import logging import boto3 from botocore.exceptions import ClientError # To search by offer id: OfferId; by product id: ResourceIdentifier; by product type: ResourceType idType = "OfferId" # replace id value as needed idValue = "offer-1111111111111" MAX_PAGE_RESULTS = 10 # catalog; switch to AWSMarketplace for release AWSMPCATALOG = "AWSMarketplace" # product types SaaSProduct = "SaaSProduct" AmiProduct = "AmiProduct" MLProduct = "MachineLearningProduct" ContainerProduct = "ContainerProduct" DataProduct = "DataProduct" ProServiceProduct = "ProfessionalServicesProduct" AiqProduct = "AiqProduct" # Define pricing types CCP = "CCP" Annual = "Annual" Contract = "Contract" SFT = "SaaS Free Trial" HMA = "Hourly and Monthly Agreements" Hourly = "Hourly" Monthly = "Monthly" AFPS = "Annual FPS" CFPS = "Contract FPS" CCPFPS = "CCP with FPS" BYOL = "BYOL" Free = "Free" FTH = "Free Trials and Hourly" # Define Agreement Term Types legal = ["LegalTerm"] config = ["ConfigurableUpfrontPricingTerm"] usage = ["UsageBasedPricingTerm"] config_usage = ["ConfigurableUpfrontPricingTerm", "UsageBasedPricingTerm"] freeTrial = ["FreeTrialPricingTerm"] recur = ["RecurringPaymentTerm"] usage_recur = ("UsageBasedPricingTerm", "RecurringPaymentTerm") fixed_payment = ["FixedUpfrontPricingTerm", "PaymentScheduleTerm"] fixed_payment_usage = [ "FixedUpfrontPricingTerm", "PaymentScheduleTerm", "UsageBasedPricingTerm", ] byol = ["ByolPricingTerm"] freeTrial_usage = ("FreeTrialPricingTerm", "UsageBasedPricingTerm") all_agreement_types_combination = ( legal, config, usage, config_usage, freeTrial, recur, usage_recur, fixed_payment, fixed_payment_usage, byol, freeTrial_usage, ) # get pricing type method given product type, agreement temr type and offer type if needed def get_pricing_type(product_type, agreement_term_type, offer_type): pricing_types = { (SaaSProduct, frozenset(config_usage), frozenset("")): CCP, (DataProduct, frozenset(config_usage), frozenset("")): CCP, (ContainerProduct, frozenset(config), frozenset(config_usage)): Annual, (AmiProduct, frozenset(config), frozenset(config_usage)): Annual, (MLProduct, frozenset(config), frozenset(config_usage)): Annual, (ContainerProduct, frozenset(config), frozenset(config)): Contract, (AmiProduct, frozenset(config), frozenset(config)): Contract, (SaaSProduct, frozenset(config), frozenset("")): Contract, (DataProduct, frozenset(config), frozenset("")): Contract, (AiqProduct, frozenset(config), frozenset("")): Contract, (ProServiceProduct, frozenset(config), frozenset("")): Contract, (SaaSProduct, frozenset(freeTrial), frozenset("")): SFT, (AmiProduct, frozenset(usage_recur), frozenset("")): HMA, (SaaSProduct, frozenset(usage), frozenset("")): Hourly, (AmiProduct, frozenset(usage), frozenset("")): Hourly, (ContainerProduct, frozenset(usage), frozenset("")): Hourly, (MLProduct, frozenset(usage), frozenset("")): Hourly, (ContainerProduct, frozenset(recur), frozenset("")): Monthly, (AmiProduct, frozenset(recur), frozenset("")): Monthly, ( ContainerProduct, frozenset(fixed_payment), frozenset(fixed_payment_usage), ): AFPS, (AmiProduct, frozenset(fixed_payment), frozenset(fixed_payment_usage)): AFPS, (MLProduct, frozenset(fixed_payment), frozenset("")): AFPS, (ContainerProduct, frozenset(fixed_payment), frozenset(fixed_payment)): CFPS, (AmiProduct, frozenset(fixed_payment), frozenset(fixed_payment)): CFPS, (SaaSProduct, frozenset(fixed_payment), frozenset("")): CFPS, (DataProduct, frozenset(fixed_payment), frozenset("")): CFPS, (AiqProduct, frozenset(fixed_payment), frozenset("")): CFPS, (ProServiceProduct, frozenset(fixed_payment), frozenset("")): CFPS, (SaaSProduct, frozenset(fixed_payment_usage), frozenset("")): CCPFPS, (DataProduct, frozenset(fixed_payment_usage), frozenset("")): CCPFPS, (AiqProduct, frozenset(fixed_payment_usage), frozenset("")): CCPFPS, (ProServiceProduct, frozenset(fixed_payment_usage), frozenset("")): CCPFPS, (AmiProduct, frozenset(byol), frozenset("")): BYOL, (SaaSProduct, frozenset(byol), frozenset("")): BYOL, (ProServiceProduct, frozenset(byol), frozenset("")): BYOL, (AiqProduct, frozenset(byol), frozenset("")): BYOL, (MLProduct, frozenset(byol), frozenset("")): BYOL, (ContainerProduct, frozenset(byol), frozenset("")): BYOL, (DataProduct, frozenset(byol), frozenset("")): BYOL, (ContainerProduct, frozenset(legal), frozenset("")): Free, (AmiProduct, frozenset(freeTrial_usage), frozenset("")): FTH, (ContainerProduct, frozenset(freeTrial_usage), frozenset("")): FTH, (MLProduct, frozenset(freeTrial_usage), frozenset("")): FTH, } key = (product_type, agreement_term_type, offer_type) if key in pricing_types: return pricing_types[key] else: return "Unknown" # Example usage for testing purpose """ product_type = SaaSProduct agreement_term_type = frozenset(config_usage) offer_type = frozenset('') pricing_type = get_pricing_type(product_type, agreement_term_type, offer_type) print("pricing type = " + pricing_type) # Output: CCP """ # check if offer term types are needed; if Y, needed def get_offer_term_type(product_type, agreement_term_type): offer_term_types = { (ContainerProduct, frozenset(config)): "Y", (AmiProduct, frozenset(config)): "Y", (ContainerProduct, frozenset(fixed_payment)): "Y", (AmiProduct, frozenset(fixed_payment)): "Y", (AmiProduct, frozenset(fixed_payment), frozenset(fixed_payment)): "Y", } key = (product_type, agreement_term_type) if key in offer_term_types: return offer_term_types[key] else: return logger = logging.getLogger(__name__) def get_agreements(mp_client): AgreementSummaryList = [] # Set PartyType to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. partyTypes = ["Proposer"] for value in partyTypes: try: agreement = mp_client.search_agreements( catalog=AWSMPCATALOG, maxResults=MAX_PAGE_RESULTS, filters=[ {"name": "PartyType", "values": [value]}, {"name": idType, "values": [idValue]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) while "nextToken" in agreement and agreement["nextToken"] is not None: try: agreement = mp_client.search_agreements( catalog=AWSMPCATALOG, maxResults=MAX_PAGE_RESULTS, nextToken=agreement["nextToken"], filters=[ {"name": "PartyType", "values": [value]}, {"name": idType, "values": [idValue]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) return AgreementSummaryList def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace Catalog.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") # find all agreements matching the specified idType and idValue agreements = get_agreements(mp_client) for item in agreements: pricingType = "" agreement_id = item["agreementId"] # get term types inside offer offer_term_types = get_offer_term_types(item) # even though multiple product types are allowed for one agreement, only need the first one productType = item["proposalSummary"]["resources"][0]["type"] # get agreement terms types agreementTerm = mp_client.get_agreement_terms(agreementId=agreement_id) agreementTermTypes = get_agreement_term_types(agreementTerm) # match with agreement term type group matchedTermType = getMatchedTermTypesCombination(agreementTermTypes) # check if offer term type is needed. offer_term_type_needed = get_offer_term_type( productType, frozenset(matchedTermType) ) # get pricing type given product type, agreement term types and offer type if needed; # one excpetion is Container with Legal term. LegalTerm needs to be the only term present if offer_term_type_needed is not None: matchedOfferTermTypes = getMatchedTermTypesCombination(offer_term_types) print(f"matchedOfferTermType = {matchedOfferTermTypes}") pricingType = get_pricing_type( productType, frozenset(matchedTermType), frozenset(matchedOfferTermTypes), ) elif set(matchedTermType) == set(legal): pricingType = Free else: pricingType = get_pricing_type( productType, frozenset(matchedTermType), frozenset("") ) print( f"agreementId={agreement_id};productType={productType}; agreementTermTypes={agreementTermTypes}; matchedTermType={matchedTermType}; offerTermTypeNeeded={offer_term_type_needed}; offer_term_types={offer_term_types}" ) print(f"pricing type={pricingType}") def getMatchedTermTypesCombination(agreementTermTypes): matchedCombination = () for element in all_agreement_types_combination: if check_elements(agreementTermTypes, element): matchedCombination = element return matchedCombination def get_offer_term_types(item): offer_id = item["proposalSummary"]["offerId"] mp_catalogAPI_client = boto3.client("marketplace-catalog") offer_document = get_entity_information(mp_catalogAPI_client, offer_id) offerDetail = offer_document["Details"] offerDetail_json_object = json.loads(offerDetail) offer_term_types = [term["Type"] for term in offerDetail_json_object["Terms"]] return offer_term_types # make sure all elements in array2 exist in array1 def check_elements(array1, array2): for element in array2: if element not in array1: return False return True def get_entity_information(mp_client, entity_id): """ Returns information about a given entity Args: entity_id str: Entity to return Returns: dict: Dictionary of entity information """ try: response = mp_client.describe_entity( Catalog="AWSMarketplace", EntityId=entity_id, ) return response except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Entity with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def get_agreement_term_types(agreementTerm): types = [] for term in agreementTerm["acceptedTerms"]: for value in term.values(): if isinstance(value, dict) and "type" in value: types.append(value["type"]) return types if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 取得協議的產品類型 下列程式碼範例示範如何取得協議的產品類型。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the Product Type of the product the agreement was created on AG-11 """ import logging import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) # agreement id AGREEMENT_ID = "agmt-1111111111111111111111111" def get_agreement_information(mp_client, entity_id): """ Returns information about a given agreement Args: entity_id str: Entity to return Returns: dict: Dictionary of agreement information """ try: agreement = mp_client.describe_agreement(agreementId=entity_id) return agreement except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", entity_id) else: logger.error("Unexpected error: %s", e) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for offer and product details in a given agreement by agreement id.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") agreement = get_agreement_information(mp_client, AGREEMENT_ID) if agreement is not None: for resource in agreement["proposalSummary"]["resources"]: print(f"Product ID: {resource['id']} | Product Type: {resource['type']}") else: print("Agreement with ID " + AGREEMENT_ID + " is not found") if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 取得協議的狀態 下列程式碼範例示範如何取得協議的狀態。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get all agreement status AG-13 Example Usage: python3 get_agreement_status.py --agreement-id """ import argparse import logging import boto3 from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) def get_agreement(agreement_id): try: response = mp_client.describe_agreement(agreementId=agreement_id) return response except ClientError as e: logger.error(f"Could not complete search_agreements request. {e}") return None if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--agreement-id", "-aid", help="Provide agreement ID to describe agreement status", required=True, ) args = parser.parse_args() response = get_agreement(agreement_id=args.agreement_id) if response is not None: print(f"Agreement status: {response['status']}") else: print(f"No agreement found for {args.agreement_id}") ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [DescribeAgreement](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/DescribeAgreement)。 ### 取得協議的支援條款 下列程式碼範例示範如何取得協議的支援條款。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Obtain the support and refund policy I have provided to the customer for an agreement AG-19 Example Usage: python3 get_agreement_support_terms.py --agreement-id """ import argparse import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError logger = logging.getLogger(__name__) mp_client = boto3.client("marketplace-agreement") def get_agreement_terms(agreement_id): try: agreement = mp_client.get_agreement_terms(agreementId=agreement_id) return agreement except ClientError as e: if e.response["Error"]["Code"] == "ResourceNotFoundException": logger.error("Agreement with ID %s not found.", agreement_id) else: logger.error("Unexpected error: %s", e) return None if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--agreement-id", "-aid", help="Provide agreement ID to describe agreement status", required=True, ) args = parser.parse_args() agreement = get_agreement_terms(agreement_id=args.agreement_id) if agreement is not None: support_found = False for term in agreement["acceptedTerms"]: if "supportTerm" in term.keys(): helper.pretty_print_datetime(term) support_found = True if not support_found: print(f"No support term found for agreement: {args.agreement_id}") ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [GetAgreementTerms](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/GetAgreementTerms)。 ### 列出協議取消請求 下列程式碼範例示範如何列出我以接受者身分參與之協議的協議取消請求。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class ListAgreementCancellationRequests: PARTY_TYPE = "Proposer" @staticmethod def list_agreement_cancellation_requests(): client = boto3.client("marketplace-agreement") next_token = None while True: kwargs = {"partyType": ListAgreementCancellationRequests.PARTY_TYPE} if next_token: kwargs["nextToken"] = next_token response = client.list_agreement_cancellation_requests(**kwargs) for summary in response.get("items", []): print("Cancellation Request ID: " + summary["agreementCancellationRequestId"]) print("Agreement ID: " + summary["agreementId"]) print("Status: " + str(summary.get("status", ""))) print("Reason Code: " + str(summary.get("reasonCode", ""))) print("Agreement Type: " + str(summary.get("agreementType", ""))) print("Catalog: " + str(summary.get("catalog", ""))) print("Created At: " + str(summary.get("createdAt", ""))) print("Updated At: " + str(summary.get("updatedAt", ""))) print("---") next_token = response.get("nextToken") if not next_token: break if __name__ == "__main__": ListAgreementCancellationRequests.list_agreement_cancellation_requests() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [ListAgreementCancellationRequests](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/ListAgreementCancellationRequests)。 ### 列出協議付款請求 下列程式碼範例示範如何列出我以接受者身分參與之協議的協議付款請求。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class ListAgreementPaymentRequests: PARTY_TYPE = "Proposer" @staticmethod def list_agreement_payment_requests(): client = boto3.client("marketplace-agreement") next_token = None while True: kwargs = {"partyType": ListAgreementPaymentRequests.PARTY_TYPE} if next_token: kwargs["nextToken"] = next_token response = client.list_agreement_payment_requests(**kwargs) for summary in response.get("items", []): print("Payment Request ID: " + summary["paymentRequestId"]) print("Agreement ID: " + summary["agreementId"]) print("Status: " + str(summary.get("status", ""))) print("Name: " + str(summary.get("name", ""))) print("Charge ID: " + str(summary.get("chargeId", ""))) print("Charge Amount: " + str(summary.get("chargeAmount", ""))) print("Currency Code: " + str(summary.get("currencyCode", ""))) print("Created At: " + str(summary.get("createdAt", ""))) print("Updated At: " + str(summary.get("updatedAt", ""))) print("---") next_token = response.get("nextToken") if not next_token: break if __name__ == "__main__": ListAgreementPaymentRequests.list_agreement_payment_requests() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [ListAgreementPaymentRequests](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/ListAgreementPaymentRequests)。 ### 拒絕協議取消請求 下列程式碼範例示範如何拒絕賣方啟動的協議取消請求。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class RejectAgreementCancellationRequest: AGREEMENT_ID = "" AGREEMENT_CANCELLATION_REQUEST_ID = "" REJECTION_REASON = "" @staticmethod def reject_agreement_cancellation_request(): client = boto3.client("marketplace-agreement") response = client.reject_agreement_cancellation_request( agreementId=RejectAgreementCancellationRequest.AGREEMENT_ID, agreementCancellationRequestId=RejectAgreementCancellationRequest.AGREEMENT_CANCELLATION_REQUEST_ID, rejectionReason=RejectAgreementCancellationRequest.REJECTION_REASON, ) print("Agreement ID: " + response["agreementId"]) print("Cancellation Request ID: " + response["agreementCancellationRequestId"]) print("Status: " + str(response.get("status", ""))) print("Status Message: " + str(response.get("statusMessage", ""))) print("Reason Code: " + str(response.get("reasonCode", ""))) print("Created At: " + str(response.get("createdAt", ""))) print("Updated At: " + str(response.get("updatedAt", ""))) if __name__ == "__main__": RejectAgreementCancellationRequest.reject_agreement_cancellation_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [RejectAgreementCancellationRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/RejectAgreementCancellationRequest)。 ### 拒絕協議付款請求 下列程式碼範例示範如何拒絕賣方啟動的協議付款請求。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import boto3 class RejectAgreementPaymentRequest: AGREEMENT_ID = "" PAYMENT_REQUEST_ID = "" REJECTION_REASON = "" @staticmethod def reject_agreement_payment_request(): client = boto3.client("marketplace-agreement") response = client.reject_agreement_payment_request( agreementId=RejectAgreementPaymentRequest.AGREEMENT_ID, paymentRequestId=RejectAgreementPaymentRequest.PAYMENT_REQUEST_ID, rejectionReason=RejectAgreementPaymentRequest.REJECTION_REASON, ) print("Payment Request ID: " + response["paymentRequestId"]) print("Agreement ID: " + response["agreementId"]) print("Status: " + str(response.get("status", ""))) print("Status Message: " + str(response.get("statusMessage", ""))) print("Name: " + str(response.get("name", ""))) print("Charge Amount: " + str(response.get("chargeAmount", ""))) print("Currency Code: " + str(response.get("currencyCode", ""))) print("Created At: " + str(response.get("createdAt", ""))) print("Updated At: " + str(response.get("updatedAt", ""))) if __name__ == "__main__": RejectAgreementPaymentRequest.reject_agreement_payment_request() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [RejectAgreementPaymentRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/RejectAgreementPaymentRequest)。 ### 將 SaaS 合約協議取代為以協議為基礎的優惠 下列程式碼範例示範如何以新的協議型優惠取代 SaaS 合約協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to replace an existing SaaS agreement with CONTRACT pricing model with a new Agreement-Based Offer (ABO) using the AWS Marketplace Agreement Service APIs. Scenario: A buyer has an active SaaS agreement with CONTRACT pricing model and receives a private Agreement-Based Offer from the seller. The buyer replaces the existing agreement with the new ABO offer, which may include updated pricing terms and payment schedule. Note: Unlike other Replace samples, this example starts from an already-active EXISTING_AGREEMENT_ID rather than creating a new agreement first. Use this pattern when you already have an agreement ID and want to replace it directly. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offers: - EXISTING_AGREEMENT_ID — the agreement ID of the active agreement to replace (starts with agmt-). - NEW_AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the new ABO offer. - Term IDs (starting with term-) — found in the new offer's term list. """ import boto3 from utils.agreement_api_utils import generate_client_token class ReplaceSaaSContractWithAgreementBasedOffer: # The agreement ID of the active SaaS agreement with CONTRACT pricing model to replace (starts with "agmt-"). EXISTING_AGREEMENT_ID = "" # The agreementProposalId from the new Agreement-Based Offer. NEW_AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the LegalTerm in the new offer. LEGAL_TERM_ID = "" # Term ID for the ValidityTerm in the new offer. VALIDITY_TERM_ID = "" # Term ID for the FixedUpfrontPricingTerm in the new offer. FIXED_UPFRONT_PRICING_TERM_ID = "" # Term ID for the PaymentScheduleTerm in the new offer. PAYMENT_SCHEDULE_TERM_ID = "" @staticmethod def replace_existing_agreement(): """ Replace an existing SaaS agreement with CONTRACT pricing model with a new Agreement-Based Offer. Uses Intent.REPLACE with sourceAgreementIdentifier set to the existing agreement ID. """ client = boto3.client("marketplace-agreement") cls = ReplaceSaaSContractWithAgreementBasedOffer legal_term = {"id": cls.LEGAL_TERM_ID} validity_term = {"id": cls.VALIDITY_TERM_ID} fixed_upfront_pricing_term = {"id": cls.FIXED_UPFRONT_PRICING_TERM_ID} payment_schedule_term = {"id": cls.PAYMENT_SCHEDULE_TERM_ID} # Replace the agreement with the new offer create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="REPLACE", requestedTerms=[fixed_upfront_pricing_term, payment_schedule_term, legal_term, validity_term], agreementProposalIdentifier=cls.NEW_AGREEMENT_PROPOSAL_IDENTIFIER, sourceAgreementIdentifier=cls.EXISTING_AGREEMENT_ID, ) agreement_request_id = create_response["agreementRequestId"] print("Replace agreement request created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) print("Agreement replaced with ABO. New AgreementId: " + accept_response["agreementId"]) if __name__ == "__main__": ReplaceSaaSContractWithAgreementBasedOffer.replace_existing_agreement() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 將 SaaS 免費試用取代為使用定價的合約 下列程式碼範例示範如何使用使用定價合約 (CCP) 取代 SaaS 免費試用。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to create a SaaS free trial agreement and then replace it with a paid Contract with Consumption Pricing (CCP) offer using the AWS Marketplace Agreement Service APIs. Scenario: A buyer first starts a free trial on a SaaS product. Once the trial is active, they decide to convert by replacing it with a paid offer that includes a FixedUpfrontPricingTerm, PaymentScheduleTerm, and UsageBasedPricingTerm. Flow: 1. Create a SaaS free trial agreement with freeTrialPricingTerm. 2. Wait for freeTrialPricingTerm agreement entitlements to become active. 3. Replace the free trial agreement with the paid CCP offer using Intent.REPLACE. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offers: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the free trial offer. - NEW_AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the paid CCP offer. - Term IDs (starting with term-) — found in each offer's term list. """ import boto3 from utils.agreement_api_utils import ( format_output, generate_client_token, poll_until_entitlements_available, ) class ReplaceSaaSFreeTrialWithCCP: # The agreementProposalId from the free trial offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the FreeTrialPricingTerm in the free trial offer. FREE_TRIAL_PRICING_TERM_ID = "" # Term ID for the LegalTerm in the free trial offer. LEGAL_TERM_ID = "" # The agreementProposalId from the paid CCP offer to convert to. NEW_AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the FixedUpfrontPricingTerm in the CCP offer. FIXED_UPFRONT_PRICING_TERM_ID = "" # Term ID for the PaymentScheduleTerm in the CCP offer. PAYMENT_SCHEDULE_TERM_ID = "" # Term ID for the UsageBasedPricingTerm in the CCP offer. USAGE_BASED_PRICING_TERM_ID = "" # Term ID for the ValidityTerm in the CCP offer. VALIDITY_TERM_ID = "" # Term ID for the LegalTerm in the CCP offer. NEW_LEGAL_TERM_ID = "" @staticmethod def create_saas_free_trial_and_replace_with_ccp(): """ Full end-to-end flow: 1. Create a SaaS free trial agreement with freeTrialPricingTerm. 2. Wait for freeTrialPricingTerm agreement entitlements to become active. 3. Replace the free trial agreement with the paid CCP offer. """ client = boto3.client("marketplace-agreement") cls = ReplaceSaaSFreeTrialWithCCP legal_term = {"id": cls.LEGAL_TERM_ID} free_trial_pricing_term = {"id": cls.FREE_TRIAL_PRICING_TERM_ID} # --- Step 1: Agreement with freeTrialPricingTerm --- create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[free_trial_pricing_term, legal_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request with freeTrialPricingTerm created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) agreement_id = accept_response["agreementId"] print("Agreement request with freeTrialPricingTerm accepted. AgreementId: " + agreement_id) # Wait for freeTrialPricingTerm agreement entitlements to become active before replacing. print("Waiting for freeTrialPricingTerm agreement entitlements to become active...") entitlements_response = poll_until_entitlements_available(client, agreement_id) print("freeTrialPricingTerm agreement entitlements are now active.") format_output(entitlements_response) # --- Step 2: Replace Agreement with freeTrialPricingTerm with Paid CCP Offer --- # Use Intent.REPLACE and sourceAgreementIdentifier to replace the free trial agreement. usage_based_pricing_term = {"id": cls.USAGE_BASED_PRICING_TERM_ID} fixed_upfront_pricing_term = {"id": cls.FIXED_UPFRONT_PRICING_TERM_ID} payment_schedule_term = {"id": cls.PAYMENT_SCHEDULE_TERM_ID} validity_term = {"id": cls.VALIDITY_TERM_ID} new_legal_term = {"id": cls.NEW_LEGAL_TERM_ID} car_response = client.create_agreement_request( clientToken=generate_client_token(), intent="REPLACE", requestedTerms=[ usage_based_pricing_term, fixed_upfront_pricing_term, payment_schedule_term, validity_term, new_legal_term, ], agreementProposalIdentifier=cls.NEW_AGREEMENT_PROPOSAL_IDENTIFIER, sourceAgreementIdentifier=agreement_id, ) print("Replace agreement request created. AgreementRequestId: " + car_response["agreementRequestId"]) aar_response = client.accept_agreement_request( agreementRequestId=car_response["agreementRequestId"] ) print( "Agreement with freeTrialPricingTerm replaced with paid CCP offer. New AgreementId: " + aar_response["agreementId"] ) if __name__ == "__main__": ReplaceSaaSFreeTrialWithCCP.create_saas_free_trial_and_replace_with_ccp() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 取代以 SaaS 用量為基礎的定價條款，並取消先前的協議 下列程式碼範例示範如何取代以 SaaS 用量為基礎的定價條款，並取消先前的協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to create a SaaS agreement with usageBasedPricingTerm (UBPT) and then replace it with a new offer using the AWS Marketplace Agreement Service APIs. Scenario: A buyer subscribes to a SaaS product with UsageBasedPricingTerm. The buyer then converts to a different offer by replacing the existing agreement. Flow: 1. Create and accept the initial agreement request with UBPT. 2. Wait for entitlements to become active. 3. Replace the agreement with a new offer using Intent.REPLACE. 4. Cancel the new agreement using CancelAgreement. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offers: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the initial offer. - NEW_AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the new offer to replace to. - Term IDs (starting with term-) — found in each offer's term list. """ import boto3 from utils.agreement_api_utils import ( format_output, generate_client_token, poll_until_entitlements_available, ) class ReplaceSaaSUsageBasedPricingTermAndCancel: # The agreementProposalId from the initial offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the UsageBasedPricingTerm in the initial offer. USAGE_BASED_PRICING_TERM_ID = "" # Term ID for the ValidityTerm in the initial offer. VALIDITY_TERM_ID = "" # Term ID for the LegalTerm in the initial offer. LEGAL_TERM_ID = "" # The agreementProposalId from the new offer to replace to. NEW_AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the UsageBasedPricingTerm in the new offer. NEW_USAGE_BASED_PRICING_TERM_ID = "" # Term ID for the ValidityTerm in the new offer. NEW_VALIDITY_TERM_ID = "" # Term ID for the LegalTerm in the new offer. NEW_LEGAL_TERM_ID = "" @staticmethod def replace_saas_ubpt_and_cancel(): """ Full end-to-end flow: 1. Create and accept the initial agreement request with UsageBasedPricingTerm. 2. Wait for entitlements to become active. 3. Replace the agreement with a new offer. 4. Cancel the new agreement. """ client = boto3.client("marketplace-agreement") cls = ReplaceSaaSUsageBasedPricingTermAndCancel usage_based_pricing_term = {"id": cls.USAGE_BASED_PRICING_TERM_ID} validity_term = {"id": cls.VALIDITY_TERM_ID} legal_term = {"id": cls.LEGAL_TERM_ID} # --- Step 1: Create and accept the initial UBPT agreement request --- create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[usage_based_pricing_term, validity_term, legal_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request with UBPT created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) agreement_id = accept_response["agreementId"] print("Agreement request with UBPT accepted. AgreementId: " + agreement_id) # Wait for entitlements to become active before replacing. print("Waiting for entitlements to become active...") entitlements_response = poll_until_entitlements_available(client, agreement_id) print("Entitlements are now active.") format_output(entitlements_response) # --- Step 2: Replace the UBPT agreement with a new offer --- # Use Intent.REPLACE and sourceAgreementIdentifier to replace the existing agreement. new_usage_based_pricing_term = {"id": cls.NEW_USAGE_BASED_PRICING_TERM_ID} new_validity_term = {"id": cls.NEW_VALIDITY_TERM_ID} new_legal_term = {"id": cls.NEW_LEGAL_TERM_ID} car_response = client.create_agreement_request( clientToken=generate_client_token(), intent="REPLACE", requestedTerms=[new_usage_based_pricing_term, new_validity_term, new_legal_term], agreementProposalIdentifier=cls.NEW_AGREEMENT_PROPOSAL_IDENTIFIER, sourceAgreementIdentifier=agreement_id, ) print("Replace agreement request created. AgreementRequestId: " + car_response["agreementRequestId"]) aar_response = client.accept_agreement_request( agreementRequestId=car_response["agreementRequestId"] ) agreement_id_with_new_offer = aar_response["agreementId"] print("UBPT agreement replaced. New AgreementId: " + agreement_id_with_new_offer) # --- Step 3: Cancel the new agreement --- client.cancel_agreement(agreementId=agreement_id_with_new_offer) print("The new agreement has been cancelled. AgreementId: " + agreement_id_with_new_offer) if __name__ == "__main__": ReplaceSaaSUsageBasedPricingTermAndCancel.replace_saas_ubpt_and_cancel() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 取代 AMI 用量型定價條款，但保留 ConfigurableUpfrontPricingTerm 下列程式碼範例示範如何取代 AMI 用量型定價條件，同時保留現有的 ConfigurableUpfrontPricingTerm。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to replace an AMI agreement with usageBasedPricingTerm with a new offer while the agreement with ConfigurableUpfrontPricingTerm (CUPT) is still active, using the AWS Marketplace Agreement Service APIs. Scenario: An AMI product with USAGE pricing requires two agreements: 1. An agreement with usageBasedPricingTerm — accepted first to establish the base agreement. 2. An agreement with configurableUpfrontPricingTerm (CUPT) — accepted after the usageBasedPricingTerm agreement entitlements are active. This sample shows how to replace only the agreement with usageBasedPricingTerm with a new offer without touching the existing agreement with configurableUpfrontPricingTerm (CUPT). Flow: 1. Create and accept the initial agreement request with usageBasedPricingTerm. 2. Create and accept the agreement request with configurableUpfrontPricingTerm (CUPT) (after usageBasedPricingTerm agreement entitlements are active). 3. Replace the agreement with usageBasedPricingTerm with a new offer using Intent.REPLACE. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offers: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the initial offer. - NEW_AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the new offer to replace to. - Term IDs (starting with term-) — found in each offer's term list. - SELECTOR_VALUE — duration for the agreement (e.g., P365D). - DIMENSION_1_KEY — dimension key defined in the CUPT term. """ import boto3 from utils.agreement_api_utils import ( format_output, generate_client_token, poll_until_entitlements_available, ) class ReplaceAmiUsageBasedPricingTermButNotCupt: # The agreementProposalId from the initial offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the ConfigurableUpfrontPricingTerm in the initial offer. CONFIGURABLE_UPFRONT_PRICING_TERM_ID = "" # Duration for the agreement (e.g., "P365D" for 365 days). SELECTOR_VALUE = "" # Dimension key defined in the CUPT term. DIMENSION_1_KEY = "" # Quantity for the dimension. DIMENSION_1_VALUE = 1 # Term ID for the UsageBasedPricingTerm in the initial offer. USAGE_TERM_ID = "" # Term ID for the LegalTerm in the initial offer. LEGAL_TERM_ID = "" # Term ID for the ValidityTerm in the initial offer. VALIDITY_TERM_ID = "" # The agreementProposalId from the new offer to replace to. NEW_AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the UsageBasedPricingTerm in the new offer. NEW_USAGE_TERM_ID = "" # Term ID for the LegalTerm in the new offer. NEW_LEGAL_TERM_ID = "" # Term ID for the ValidityTerm in the new offer. NEW_VALIDITY_TERM_ID = "" @staticmethod def replace_ami_usage_when_cupt_exists(): """ Full end-to-end flow: 1. Create and accept an agreement request with usageBasedPricingTerm, then wait for entitlements. 2. Create and accept an agreement request with CUPT, then wait for entitlements. 3. Replace the agreement with usageBasedPricingTerm with a new offer (agreement with CUPT is unaffected). """ client = boto3.client("marketplace-agreement") cls = ReplaceAmiUsageBasedPricingTermButNotCupt usage_term = {"id": cls.USAGE_TERM_ID} legal_term = {"id": cls.LEGAL_TERM_ID} validity_term = {"id": cls.VALIDITY_TERM_ID} # --- Step 1: Agreement with UBPT --- create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[usage_term, legal_term, validity_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request with UBPT created. AgreementRequestId: " + agreement_request_id) accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id ) usage_agreement_id = accept_response["agreementId"] print("Agreement request with UBPT accepted. AgreementId: " + usage_agreement_id) # Wait for UBPT agreement entitlements to become active before creating the agreement with CUPT. print("Waiting for UBPT agreement entitlements to become active...") entitlements_response = poll_until_entitlements_available(client, usage_agreement_id) print("UBPT agreement entitlements are now active.") format_output(entitlements_response) # --- Step 2: Agreement with configurableUpfrontPricingTerm (CUPT) --- configurable_upfront_pricing_term = { "id": cls.CONFIGURABLE_UPFRONT_PRICING_TERM_ID, "configuration": { "configurableUpfrontPricingTermConfiguration": { "selectorValue": cls.SELECTOR_VALUE, "dimensions": [ { "dimensionKey": cls.DIMENSION_1_KEY, "dimensionValue": cls.DIMENSION_1_VALUE, }, ], } }, } car_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[configurable_upfront_pricing_term, legal_term, validity_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) print("Agreement request with CUPT created. AgreementRequestId: " + car_response["agreementRequestId"]) aar_response = client.accept_agreement_request( agreementRequestId=car_response["agreementRequestId"] ) cupt_agreement_id = aar_response["agreementId"] print("Agreement request with CUPT accepted. AgreementId: " + cupt_agreement_id) # Wait for CUPT agreement entitlements to become active before replacing usage. print("Waiting for CUPT agreement entitlements to become active...") cupt_entitlements_response = poll_until_entitlements_available(client, cupt_agreement_id) print("CUPT agreement entitlements are now active.") format_output(cupt_entitlements_response) # --- Step 3: Replace Agreement with usageBasedPricingTerm with a new offer --- new_usage_term = {"id": cls.NEW_USAGE_TERM_ID} new_legal_term = {"id": cls.NEW_LEGAL_TERM_ID} new_validity_term = {"id": cls.NEW_VALIDITY_TERM_ID} # Use Intent.REPLACE and sourceAgreementIdentifier pointing to the usageBasedPricingTerm agreement only. # The agreement with configurableUpfrontPricingTerm (CUPT) is NOT affected by this replacement. car_replace_response = client.create_agreement_request( clientToken=generate_client_token(), intent="REPLACE", requestedTerms=[new_usage_term, new_legal_term, new_validity_term], agreementProposalIdentifier=cls.NEW_AGREEMENT_PROPOSAL_IDENTIFIER, sourceAgreementIdentifier=usage_agreement_id, ) print("Replace agreement request created. AgreementRequestId: " + car_replace_response["agreementRequestId"]) aar_replace_response = client.accept_agreement_request( agreementRequestId=car_replace_response["agreementRequestId"] ) print("Agreement with UBPT replaced. New AgreementId: " + aar_replace_response["agreementId"]) if __name__ == "__main__": ReplaceAmiUsageBasedPricingTermButNotCupt.replace_ami_usage_when_cupt_exists() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [CreateAgreementRequest](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/CreateAgreementRequest)。 ### 依帳戶 ID 搜尋協議 下列程式碼範例示範如何依帳戶 ID 搜尋協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to get agreement by customer AWS account ID AG-02 """ import argparse import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) MAX_PAGE_RESULTS = 10 def get_agreements(account_id): AgreementSummaryList = [] try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, # Set PartyType filter to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. filters=[ {"name": "PartyType", "values": ["Proposer"]}, {"name": "AcceptorId", "values": [account_id]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e AgreementSummaryList.extend(agreement["agreementViewSummaries"]) while "nextToken" in agreement and agreement["nextToken"] is not None: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreement["nextToken"], filters=[ {"name": "PartyType", "values": ["Proposer"]}, {"name": "AcceptorId", "values": [account_id]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e AgreementSummaryList.extend(agreement["agreementViewSummaries"]) return AgreementSummaryList if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--account_id", "-aid", help="Provide accepting account ID to search for agreements", required=True, ) args = parser.parse_args() response = get_agreements(account_id=args.account_id) helper.pretty_print_datetime(response) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 依協議 ID 搜尋協議 下列程式碼範例示範如何依協議 ID 搜尋協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to search for agreements give id information AG-02-A """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError # To search by offer id: OfferId; by product id: ResourceIdentifier; by product type: ResourceType idType = "ResourceType" # replace id value as needed idValue = "SaaSProduct" MAX_PAGE_RESULTS = 10 logger = logging.getLogger(__name__) def get_agreements(mp_client): AgreementSummaryList = [] # Set PartyType to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. partyTypes = ["Proposer"] for value in partyTypes: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, filters=[ {"name": "PartyType", "values": [value]}, {"name": idType, "values": [idValue]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e AgreementSummaryList.extend(agreement["agreementViewSummaries"]) while "nextToken" in agreement and agreement["nextToken"] is not None: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreement["nextToken"], filters=[ {"name": "PartyType", "values": [value]}, {"name": idType, "values": [idValue]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e AgreementSummaryList.extend(agreement["agreementViewSummaries"]) return AgreementSummaryList def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace Catalog.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreements(mp_client)) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 依結束日期搜尋協議 下列程式碼範例示範如何依結束日期搜尋協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to search for agreement information before or after end date AG-03 """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") # change to 'AfterEndTime' if after endtime is desired beforeOrAfterEndtimeFilterName = "BeforeEndTime" # Make sure to use the same date format as below cutoffDate = "2322-11-18T00:00:00Z" MAX_PAGE_RESULTS = 10 logger = logging.getLogger(__name__) def get_agreements(): AgreementSummaryList = [] try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, # Set PartyType filter to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. filters=[ {"name": "PartyType", "values": ["Proposer"]}, {"name": beforeOrAfterEndtimeFilterName, "values": [cutoffDate]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) while "nextToken" in agreement: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreement["nextToken"], filters=[ {"name": "PartyType", "values": ["Proposer"]}, { "name": beforeOrAfterEndtimeFilterName, "values": [cutoffDate], }, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) return AgreementSummaryList if __name__ == "__main__": agreements = get_agreements() helper.pretty_print_datetime(agreements) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 依優惠 ID 搜尋協議 下列程式碼範例示範如何依優惠 ID 搜尋協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to search for agreements by offer id AG-0 """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError # offer id to search by offerId = "1111111111111111111111111" MAX_PAGE_RESULTS = 10 logger = logging.getLogger(__name__) def get_agreements(mp_client): AgreementSummaryList = [] # Set PartyType to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. partyTypes = ["Proposer"] for value in partyTypes: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, filters=[ {"name": "PartyType", "values": [value]}, {"name": "OfferId", "values": [offerId]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) while "nextToken" in agreement and agreement["nextToken"] is not None: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreement["nextToken"], filters=[ {"name": "PartyType", "values": [value]}, {"name": "OfferId", "values": [offerId]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) return AgreementSummaryList def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement by offer id.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreements(mp_client)) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 依產品 ID 搜尋協議 下列程式碼範例示範如何依產品 ID 搜尋協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to search for agreement by product id AG-02 """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError # product id to search by resourceId = "prod-1111111111111" MAX_PAGE_RESULTS = 10 logger = logging.getLogger(__name__) def get_agreements(mp_client): AgreementSummaryList = [] # Set PartyType to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. partyTypes = ["Proposer"] for value in partyTypes: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, filters=[ {"name": "PartyType", "values": [value]}, {"name": "ResourceIdentifier", "values": [resourceId]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete list_entities request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) while "nextToken" in agreement: try: agreement = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreement["nextToken"], filters=[ {"name": "PartyType", "values": [value]}, {"name": "ResourceIdentifier", "values": [resourceId]}, {"name": "AgreementType", "values": ["PurchaseAgreement"]}, ], ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise AgreementSummaryList.extend(agreement["agreementViewSummaries"]) return AgreementSummaryList def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Looking for an agreement in the AWS Marketplace Catalog.") print("-" * 88) mp_client = boto3.client("marketplace-agreement") helper.pretty_print_datetime(get_agreements(mp_client)) if __name__ == "__main__": usage_demo() ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 依狀態搜尋協議 下列程式碼範例示範如何依狀態搜尋協議。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to use the AWS SDK for Python (Boto3) to filter agreements by status AG-04 Example Usage: python3 search_agreements_by_status.py """ import logging import boto3 import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "..")) import utils.helpers as helper from botocore.exceptions import ClientError mp_client = boto3.client("marketplace-agreement") logger = logging.getLogger(__name__) MAX_PAGE_RESULTS = 10 # Set PartyType to "Proposer" to return agreements where you are the proposer. # Change to "Acceptor" to return agreements where you are the acceptor. party_type_list = ["Proposer"] agreement_type_list = ["PurchaseAgreement"] # Accepted values: "ACTIVE", "TERMINATED", "CANCELED", "EXPIRED", "REPLACED", "RENEWED" status_list = ["ACTIVE"] filter_list = [ {"name": "PartyType", "values": party_type_list}, {"name": "AgreementType", "values": agreement_type_list}, {"name": "Status", "values": status_list}, ] agreement_results_list = [] def get_agreements(filter_list=filter_list): try: agreements = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, filters=filter_list, ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e agreement_results_list.extend(agreements["agreementViewSummaries"]) while "nextToken" in agreements and agreements["nextToken"] is not None: try: agreements = mp_client.search_agreements( catalog="AWSMarketplace", maxResults=MAX_PAGE_RESULTS, nextToken=agreements["nextToken"], filters=filter_list, ) except ClientError as e: logger.error("Could not complete search_agreements request.") raise e agreement_results_list.extend(agreements["agreementViewSummaries"]) helper.pretty_print_datetime(agreement_results_list) return agreement_results_list if __name__ == "__main__": agreements_list = get_agreements(filter_list) ``` + 如需 API 詳細資訊，請參閱《AWS SDK for Python (Boto3) API 參考》**中的 [SearchAgreements](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/SearchAgreements)。 ### 接受協議後更新採購訂單 下列程式碼範例示範如何在接受協議後更新採購訂單。 **適用於 Python 的 SDK (Boto3)** GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS Marketplace API 參考程式庫](https://github.com/aws-samples/aws-marketplace-reference-code/blob/main/python#agreement-api-reference-code)儲存庫中設定和執行。 ``` """ Demonstrates how to associate a purchase order reference with a SaaS agreement with CONTRACT pricing model using the AWS Marketplace Agreement Service APIs. Scenario: A buyer creates a SaaS agreement request with CONTRACT pricing model and provides a purchase order reference in AcceptAgreementRequest. After acceptance, the buyer lists the resulting charges via ListAgreementCharges and associates the purchase order reference with a specific charge via UpdatePurchaseOrders. Before running this sample, replace the placeholder constants below with values from your AWS Marketplace offer: - AGREEMENT_PROPOSAL_IDENTIFIER — the agreementProposalId from the offer. - Term IDs (starting with term-) — found in the offer's term list. - SELECTOR_VALUE — duration for the agreement. - DIMENSION_1_KEY — dimension key defined in the offer. - PURCHASE_ORDER_REFERENCE — your internal purchase order number (e.g., po-123456). """ import boto3 from utils.agreement_api_utils import format_output, generate_client_token class UpdatePurchaseOrdersAfterAgreementAcceptance: # Your internal purchase order reference number (e.g., "po-123456"). PURCHASE_ORDER_REFERENCE = "po-123456" # The agreementProposalId from the offer. AGREEMENT_PROPOSAL_IDENTIFIER = "" # Term ID for the ConfigurableUpfrontPricingTerm in your offer. CONFIGURABLE_UPFRONT_PRICING_TERM_ID = "" # Duration for the agreement (e.g., "P366D" for 366 days). SELECTOR_VALUE = "" # Dimension key and quantity defined in your offer. DIMENSION_1_KEY = "" DIMENSION_1_VALUE = 1 # Term ID for the LegalTerm in your offer. LEGAL_TERM_ID = "" # Term ID for the ValidityTerm in your offer. VALIDITY_TERM_ID = "" @staticmethod def list_agreement_charges_and_update_purchase_orders(): """ Full end-to-end flow: 1. Create a SaaS agreement with CONTRACT pricing model with a purchase order reference. 2. List charges to retrieve charge IDs and revisions. 3. Associate the purchase order reference with a specific charge via UpdatePurchaseOrders. 4. List charges again to confirm the update. """ client = boto3.client("marketplace-agreement") cls = UpdatePurchaseOrdersAfterAgreementAcceptance configurable_upfront_pricing_term = { "id": cls.CONFIGURABLE_UPFRONT_PRICING_TERM_ID, "configuration": { "configurableUpfrontPricingTermConfiguration": { "selectorValue": cls.SELECTOR_VALUE, "dimensions": [ { "dimensionKey": cls.DIMENSION_1_KEY, "dimensionValue": cls.DIMENSION_1_VALUE, }, ], } }, } legal_term = {"id": cls.LEGAL_TERM_ID} validity_term = {"id": cls.VALIDITY_TERM_ID} # --- Create Agreement --- create_response = client.create_agreement_request( clientToken=generate_client_token(), intent="NEW", requestedTerms=[configurable_upfront_pricing_term, legal_term, validity_term], agreementProposalIdentifier=cls.AGREEMENT_PROPOSAL_IDENTIFIER, ) agreement_request_id = create_response["agreementRequestId"] print("Agreement request created. AgreementRequestId: " + agreement_request_id) # --- Accept Agreement Request with Purchase Order --- # The chargeId is available from the CAR response's chargeSummary.expectedCharges. charge_id = create_response["chargeSummary"]["expectedCharges"][0]["id"] accept_response = client.accept_agreement_request( agreementRequestId=agreement_request_id, purchaseOrders=[ { "chargeId": charge_id, "purchaseOrderReference": cls.PURCHASE_ORDER_REFERENCE, } ], ) agreement_id = accept_response["agreementId"] print( "Agreement request accepted with purchase order reference '" + cls.PURCHASE_ORDER_REFERENCE + "'. AgreementId: " + agreement_id ) # --- List Agreement Charges --- list_charges_response = client.list_agreement_charges(agreementId=agreement_id) print("All charges for agreement " + agreement_id + ":") format_output(list_charges_response) # --- Update Purchase Order --- first_charge = list_charges_response["items"][0] client.update_purchase_orders( purchaseOrders=[ { "agreementId": agreement_id, "purchaseOrderReference": cls.PURCHASE_ORDER_REFERENCE, "chargeRevision": first_charge["revision"], "chargeId": first_charge["id"], } ], ) print( "Purchase order reference '" + cls.PURCHASE_ORDER_REFERENCE + "' updated for ChargeId: " + first_charge["id"] ) # --- Verify Update --- lac_response = client.list_agreement_charges(agreementId=agreement_id) print("Verified updated charge:") format_output(lac_response["items"][0]) if __name__ == "__main__": UpdatePurchaseOrdersAfterAgreementAcceptance.list_agreement_charges_and_update_purchase_orders() ``` + 如需 API 詳細資訊，請參閱《適用於 *AWS Python (Boto3) 的 SDK API 參考*》中的 [UpdatePurchaseOrders](https://docs.aws.amazon.com/goto/boto3/marketplace-agreement-2020-03-01/UpdatePurchaseOrders)。