D'autres exemples de AWS SDK sont disponibles dans le référentiel [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub . Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Exemples Partner Central avec le kit SDK pour Python (Boto3) Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour Python (Boto3) aide de Partner Central. Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés. Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS. Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte. **Topics** + [Actions](#actions) + [Scénarios](#scenarios) ## Actions ### `AssignOpportunity` L'exemple de code suivant montre comment utiliser`AssignOpportunity`. **Kit SDK for Python (Boto3)** Réattribuez une opportunité existante à un autre utilisateur. ``` #!/usr/bin/env python """ Purpose PC-API-07 Assigning a new owner """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def assign_opportunity(identifier): assign_opportunity_request ={ "Catalog": CATALOG_TO_USE, "Identifier": identifier, "Assignee": { "BusinessTitle": "OpportunityOwner", "Email": "test@test.com", "FirstName": "John", "LastName": "Doe" } } try: # Perform an API call response = partner_central_client.assign_opportunity(**assign_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): identifier = "O4236468" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Assigning a new owner to an opportunity.") print("-" * 88) helper.pretty_print_datetime(assign_opportunity(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [AssignOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/AssignOpportunity)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `AssociateOpportunity` L'exemple de code suivant montre comment utiliser`AssociateOpportunity`. **Kit SDK for Python (Boto3)** Créez une association officielle entre une opportunité et diverses entités connexes. ``` #!/usr/bin/env python """ Purpose PC-API -11 Associating a product PC-API -12 Associating a solution PC-API -13 Associating an offer """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def associate_opportunity(entity_type, entity_identifier, opportunityIdentifier): associate_opportunity_request ={ "Catalog": CATALOG_TO_USE, "OpportunityIdentifier" : opportunityIdentifier, "RelatedEntityType" : entity_type, "RelatedEntityIdentifier" : entity_identifier } try: # Perform an API call response = partner_central_client.associate_opportunity(**associate_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): #entity_type = Solutions | AWSProducts | AWSMarketplaceOffers entity_type = "Solutions" entity_identifier = "S-0059717" opportunityIdentifier = "O5465588" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Associate Opportunity.") print("-" * 88) helper.pretty_print_datetime(associate_opportunity(entity_type, entity_identifier, opportunityIdentifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [AssociateOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/AssociateOpportunity)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `CreateOpportunity` L'exemple de code suivant montre comment utiliser`CreateOpportunity`. **Kit SDK for Python (Boto3)** Créez une opportunité. ``` #!/usr/bin/env python import boto3 import logging import sys import os sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) import utils.helpers as helper import utils.stringify_details as sd from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" def create_opportunity(partner_central_client): create_opportunity_request = helper.remove_nulls(sd.stringify_json("src/create_opportunity/createOpportunity.json")) try: # Perform an API call response = partner_central_client.create_opportunity(**create_opportunity_request) helper.pretty_print_datetime(response) # Retrieve the opportunity details get_response = partner_central_client.get_opportunity( Identifier=response["Id"], Catalog=CATALOG_TO_USE ) helper.pretty_print_datetime(get_response) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Create Opportunity.") print("-" * 88) partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) create_opportunity(partner_central_client) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [CreateOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/CreateOpportunity)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `DisassociateOpportunity` L'exemple de code suivant montre comment utiliser`DisassociateOpportunity`. **Kit SDK for Python (Boto3)** Supprimez une association existante entre une opportunité et des entités associées. ``` #!/usr/bin/env python """ Purpose PC-API -14 Removing a Solution PC-API -15 Removing an offer PC-API -16 Removing a product """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def disassociate_opportunity(entity_type, entity_identifier, opportunityIdentifier): disassociate_opportunity_request ={ "Catalog": CATALOG_TO_USE, "OpportunityIdentifier" : opportunityIdentifier, "RelatedEntityType" : entity_type, "RelatedEntityIdentifier" : entity_identifier } try: # Perform an API call response = partner_central_client.disassociate_opportunity(**disassociate_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): #entity_type = Solutions | AWSProducts | AWSMarketplaceOffers entity_type = "Solutions" entity_identifier = "S-0049999" opportunityIdentifier = "O4397574" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Get updated Opportunity.") print("-" * 88) helper.pretty_print_datetime(disassociate_opportunity(entity_type, entity_identifier, opportunityIdentifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [DisassociateOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/DisassociateOpportunity)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `GetAwsOpportunitySummary` L'exemple de code suivant montre comment utiliser`GetAwsOpportunitySummary`. **Kit SDK for Python (Boto3)** Récupère le résumé d'une AWS opportunité. ``` #!/usr/bin/env python """ Purpose PC-API-25 Retrieves a summary of an AWS Opportunity. LifeCycle.ReviewStatus=Approved """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_opportunity(identifier): get_opportunity_request ={ "Catalog": CATALOG_TO_USE, "RelatedOpportunityIdentifier": identifier } try: # Perform an API call response = partner_central_client.get_aws_opportunity_summary(**get_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): identifier = "O5465588" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Get AWS Opportunity summary.") print("-" * 88) helper.pretty_print_datetime(get_opportunity(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [GetAwsOpportunitySummary](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/GetAwsOpportunitySummary)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `GetEngagementInvitation` L'exemple de code suivant montre comment utiliser`GetEngagementInvitation`. **Kit SDK for Python (Boto3)** Récupère les détails d'une invitation d'engagement partagée AWS par un partenaire. ``` #!/usr/bin/env python """ Purpose PC-API-22 GetOpportunityEngagementInvitation - Retrieves details of a specific engagement invitation. This operation allows partners to view the invitation and its associated information, such as the customer, project, and lifecycle details. """ import json import logging import boto3 import utils.helpers as helper from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_opportunity_engagement_invitation(identifier): get_opportunity_engagement_invitation_request ={ "Catalog": CATALOG_TO_USE, "Identifier": identifier } try: # Perform an API call response = partner_central_client.get_engagement_invitation(**get_opportunity_engagement_invitation_request) return response except Exception as err: # Catch all client exceptions print(json.dumps(err.response)) def usage_demo(): identifier = "arn:aws:partnercentral-selling:us-east-1:aws:catalog/Sandbox/engagement-invitation/engi-0000000IS0Qga" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Given the ARN identifier, retrieve details of Opportunity Engagement Invitation.") print("-" * 88) helper.pretty_print_datetime(get_opportunity_engagement_invitation(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [GetEngagementInvitation](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/GetEngagementInvitation)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `GetOpportunity` L'exemple de code suivant montre comment utiliser`GetOpportunity`. **Kit SDK for Python (Boto3)** Profitez d’une opportunité. ``` #!/usr/bin/env python """ Purpose PC-API -08 Get updated Opportunity given opportunity id """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_opportunity(identifier): get_opportunity_request ={ "Catalog": CATALOG_TO_USE, "Identifier": identifier } try: # Perform an API call response = partner_central_client.get_opportunity(**get_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): identifier = "O5465588" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Get updated Opportunity.") print("-" * 88) helper.pretty_print_datetime(get_opportunity(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [GetOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/GetOpportunity)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `ListEngagementInvitations` L'exemple de code suivant montre comment utiliser`ListEngagementInvitations`. **Kit SDK for Python (Boto3)** Extrait une liste des invitations d’engagement envoyées au partenaire. ``` #!/usr/bin/env python """ Purpose PC-API-21 ListEngagementInvitations - Retrieves a list of engagement invitations based on specified criteria. This operation allows partners to view all invitations to engagement. """ import json import logging import boto3 import utils.helpers as helper from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def list_engagement_invitations(): list_engagement_invitations_request ={ "Catalog": CATALOG_TO_USE, "MaxResults": 20 } try: # Perform an API call response = partner_central_client.list_engagement_invitations(**list_engagement_invitations_request) return response except Exception as err: # Catch all client exceptions print(json.dumps(err.response)) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Retrieve list of Engagement Invitations.") print("-" * 88) helper.pretty_print_datetime(list_engagement_invitations()) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [ListEngagementInvitations](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/ListEngagementInvitations)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `ListOpportunities` L'exemple de code suivant montre comment utiliser`ListOpportunities`. **Kit SDK for Python (Boto3)** Répertoriez les opportunités. ``` #!/usr/bin/env python """ Purpose PC-API -18 Getting list of Opportunities """ import json import logging import boto3 import utils.helpers as helper from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_list_of_opportunities(): opportunity_list = [] list_opportunities_request ={ "Catalog": CATALOG_TO_USE, "MaxResults": 20 } try: # Perform an API call response = partner_central_client.list_opportunities(**list_opportunities_request) opportunity_list.extend(response["OpportunitySummaries"]) while "NextToken" in response and response["NextToken"] is not None: list_opportunities_request["NextToken"] = response["NextToken"] response = partner_central_client.list_opportunities(**list_opportunities_request) opportunity_list.extend(response["OpportunitySummaries"]) return opportunity_list except Exception as err: # Catch all client exceptions print(json.dumps(err.response)) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Getting list of Opportunities.") print("-" * 88) helper.pretty_print_datetime(get_list_of_opportunities()) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [ListOpportunities](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/ListOpportunities)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `ListSolutions` L'exemple de code suivant montre comment utiliser`ListSolutions`. **Kit SDK for Python (Boto3)** Extrait la liste des solutions partenaires que le partenaire a enregistrées sur Partner Central. ``` #!/usr/bin/env python """ Purpose PC-API-10 Getting list of solutions """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_list_of_solutions(): list_solutions_request ={ "Catalog": CATALOG_TO_USE, "MaxResults": 20 } try: # Perform an API call response = partner_central_client.list_solutions(**list_solutions_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Getting list of solutions.") print("-" * 88) helper.pretty_print_datetime(get_list_of_solutions()) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [ListSolutions](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/ListSolutions)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `RejectEngagementInvitation` L'exemple de code suivant montre comment utiliser`RejectEngagementInvitation`. **Kit SDK for Python (Boto3)** Rejette toute EngagementInvitation annonce AWS partagée. ``` #!/usr/bin/env python """ Purpose PC-API-05 AWS Originated AO rejection - RejectOpportunityEngagementInvitation - Rejects a engagement invitation. This action indicates that the partner does not wish to participate in the engagement and provides a reason for the rejection. Upon rejection, a OpportunityEngagementInvitationRejected event is triggered. Subsequently, the invitation will no longer be available for the partner to act on. """ import json import logging import boto3 import utils.helpers as helper from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def reject_opportunity_engagement_invitation(identifier, reject_reason): reject_opportunity_engagement_invitation_request ={ "Catalog": CATALOG_TO_USE, "Identifier": identifier, "RejectionReason": reject_reason } try: # Perform an API call response = partner_central_client.reject_engagement_invitation(**reject_opportunity_engagement_invitation_request) return response except Exception as err: # Catch all client exceptions print(json.dumps(err.response)) def usage_demo(): identifier = "arn:aws:partnercentral:us-east-1::catalog/Sandbox/engagement-invitation/engi-0000002isviga" reject_reason = "Customer problem unclear" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Given the ARN identifier and reject reason, reject the Opportunity Engagement Invitation.") print("-" * 88) helper.pretty_print_datetime(reject_opportunity_engagement_invitation(identifier, reject_reason)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [RejectEngagementInvitation](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/RejectEngagementInvitation)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `StartEngagementByAcceptingInvitationTask` L'exemple de code suivant montre comment utiliser`StartEngagementByAcceptingInvitationTask`. **Kit SDK for Python (Boto3)** Commence l'engagement en acceptant un EngagementInvitation. ``` #!/usr/bin/env python """ Purpose PC-API -11 Associating a product PC-API -12 Associating a solution PC-API -13 Associating an offer """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_opportunity(identifier): get_opportunity_request ={ "Identifier": identifier, "Catalog": CATALOG_TO_USE } try: # Perform an API call response = partner_central_client.get_engagement_invitation(**get_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def start_engagement_by_accepting_invitation_task(identifier): response = get_opportunity(identifier) if ( response['Status'] == 'PENDING') : accept_opportunity_engagement_invitation_request ={ "Catalog": CATALOG_TO_USE, "Identifier" : identifier, "ClientToken": "test-123456" } try: # Perform an API call response = partner_central_client.start_engagement_by_accepting_invitation_task(**accept_opportunity_engagement_invitation_request) return response except ClientError as err: # Catch all client exceptions print(err.response) return None else: return None def usage_demo(): identifier = "arn:aws:partnercentral:us-east-1::catalog/Sandbox/engagement-invitation/engi-0000002isusga" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Get updated Opportunity.") print("-" * 88) helper.pretty_print_datetime(start_engagement_by_accepting_invitation_task(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [StartEngagementByAcceptingInvitationTask](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/StartEngagementByAcceptingInvitationTask)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `StartEngagementFromOpportunityTask` L'exemple de code suivant montre comment utiliser`StartEngagementFromOpportunityTask`. **Kit SDK for Python (Boto3)** Lance le processus d’engagement à partir d’une opportunité existante en acceptant l’invitation d’engagement et en créant une opportunité correspondante dans le système du partenaire. ``` #!/usr/bin/env python """ Purpose PC-API -11 Associating a product PC-API -12 Associating a solution PC-API -13 Associating an offer """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def start_engagement_from_opportunity_task(identifier): start_engagement_from_opportunity_task_request ={ "AwsSubmission": { "InvolvementType": "Co-Sell", "Visibility": "Full" }, "Catalog": CATALOG_TO_USE, "Identifier" : identifier, "ClientToken": "test-annjqwesdsd99" } try: # Perform an API call response = partner_central_client.start_engagement_from_opportunity_task(**start_engagement_from_opportunity_task_request) return response except ClientError as err: # Catch all client exceptions print(err.response) return None def usage_demo(): identifier = "O5465588" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Start Engagement from Opportunity Task.") print("-" * 88) helper.pretty_print_datetime(start_engagement_from_opportunity_task(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [StartEngagementFromOpportunityTask](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/StartEngagementFromOpportunityTask)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ### `UpdateOpportunity` L'exemple de code suivant montre comment utiliser`UpdateOpportunity`. **Kit SDK for Python (Boto3)** Mettez à jour une opportunité. ``` #!/usr/bin/env python """ Purpose PC-API-2 Updating Partner Originated Opportunity """ import logging import boto3 import sys import os sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) import utils.helpers as helper from botocore.client import ClientError import utils.stringify_details as sd from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def get_opportunity(identifier): get_opportunity_request ={ "Identifier": identifier, "Catalog": CATALOG_TO_USE } try: # Perform an API call response = partner_central_client.get_opportunity(**get_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def update_opportunity(): update_opportunity_request_orig = sd.stringify_json("src/update_opportunity/update_opportunity_technical_validation.json") update_opportunity_request = helper.remove_nulls(update_opportunity_request_orig) try: # Perform an API call response = partner_central_client.update_opportunity(**update_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def update_opportunity_if_eligible(identifier): response = get_opportunity(identifier) if response is not None: return update_opportunity() else: print("Failed to retrieve opportunity details") def usage_demo(): identifier = "O5465588" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Updating opportunity.") print("-" * 88) helper.pretty_print_datetime(update_opportunity_if_eligible(identifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l'API, consultez [UpdateOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/UpdateOpportunity)le *AWS manuel de référence de l'API SDK for Python (Boto3*). ## Scénarios ### Mise à jour de l’entité associée à une opportunité L’exemple de code suivant illustre comment : + dissocier une ancienne entité ; + associer une nouvelle entité. **Kit SDK for Python (Boto3)** Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/partner-central-api-sample-codes/python_preview/#code-examples). Mise à jour de l’entité associée à une opportunité ``` #!/usr/bin/env python """ Purpose PC-API -17 Replacing a solution """ import logging import boto3 import utils.helpers as helper from botocore.client import ClientError from utils.constants import CATALOG_TO_USE serviceName = "partnercentral-selling" partner_central_client = boto3.client( service_name=serviceName, region_name='us-east-1' ) def replace_solution(original_entity_identifier, new_entity_identifier, opportunityIdentifier): disassociate_opportunity_request ={ "Catalog": CATALOG_TO_USE, "OpportunityIdentifier" : opportunityIdentifier, "RelatedEntityType" : "Solutions", "RelatedEntityIdentifier" : original_entity_identifier } associate_opportunity_request ={ "Catalog": CATALOG_TO_USE, "OpportunityIdentifier" : opportunityIdentifier, "RelatedEntityType" : "Solutions", "RelatedEntityIdentifier" : new_entity_identifier } try: # Perform an API call response = partner_central_client.disassociate_opportunity(**disassociate_opportunity_request) response = partner_central_client.associate_opportunity(**associate_opportunity_request) return response except ClientError as err: # Catch all client exceptions print(err.response) def usage_demo(): original_entity_identifier = "S-0049999" new_entity_identifier = "S-0050014" opportunityIdentifier = "O4397574" logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") print("-" * 88) print("Replacing a solution.") print("-" * 88) helper.pretty_print_datetime(replace_solution(original_entity_identifier, new_entity_identifier, opportunityIdentifier)) if __name__ == "__main__": usage_demo() ``` + Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK for Python (Boto3)*. + [AssociateOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/AssociateOpportunity) + [DisassociateOpportunity](https://docs.aws.amazon.com/goto/boto3/partnercentral-selling-2022-07-26/DisassociateOpportunity)