├── .gitignore ├── CHANGELOG.md ├── LICENSE ├── README.md ├── com ├── __init__.py └── alipay │ ├── __init__.py │ └── ams │ ├── __init__.py │ └── api │ ├── __init__.py │ ├── default_alipay_client.py │ ├── exception │ ├── __init__.py │ └── exception.py │ ├── model │ ├── DisputeJudgedResult.py │ ├── DisputeType.py │ ├── __init__.py │ ├── account_balance.py │ ├── account_holder_type.py │ ├── account_type.py │ ├── acquirer_info.py │ ├── address.py │ ├── agreement_info.py │ ├── amount.py │ ├── amount_limit.py │ ├── amount_limit_info.py │ ├── antom_path_constants.py │ ├── apple_pay_configuration.py │ ├── association_type.py │ ├── attachment.py │ ├── attachment_type.py │ ├── auth_code_form.py │ ├── auth_meta_data.py │ ├── authentication_channel_type.py │ ├── authentication_type.py │ ├── authorization_error.py │ ├── authorization_phase.py │ ├── available_payment_method.py │ ├── browser_info.py │ ├── business_info.py │ ├── business_type.py │ ├── buyer.py │ ├── cancellation_type.py │ ├── capture_mode.py │ ├── card_brand.py │ ├── card_brand_type.py │ ├── card_payment_method_detail.py │ ├── card_verification_result.py │ ├── certificate.py │ ├── certificate_type.py │ ├── challenge_action_form.py │ ├── challenge_trigger_source_type.py │ ├── challenge_type.py │ ├── china_extra_trans_info.py │ ├── class_type.py │ ├── clearing_channel.py │ ├── code_detail.py │ ├── code_value_type.py │ ├── company.py │ ├── companyType.py │ ├── company_unit_type.py │ ├── contact.py │ ├── contact_info.py │ ├── coupon_payment_method_detail.py │ ├── credit_pay_fee_type.py │ ├── credit_pay_plan.py │ ├── customer_belongs_to.py │ ├── customer_id_type.py │ ├── customs_info.py │ ├── declaration_record.py │ ├── delivery_method_type.py │ ├── disable_reason_type.py │ ├── discount.py │ ├── discount_payment_method_detail.py │ ├── display_type.py │ ├── dispute_accept_reason_type.py │ ├── dispute_evidence_format_type.py │ ├── dispute_evidence_type.py │ ├── dispute_judged_result.py │ ├── dispute_notification_type.py │ ├── entity_associations.py │ ├── env.py │ ├── extend_info.py │ ├── external_payment_method_detail.py │ ├── funding_type.py │ ├── gaming.py │ ├── goods.py │ ├── grant_type.py │ ├── http_method.py │ ├── identity_check_result.py │ ├── in_store_payment_scenario.py │ ├── individual.py │ ├── installment.py │ ├── interest_free.py │ ├── leg.py │ ├── legal_entity_type.py │ ├── lodging.py │ ├── logo.py │ ├── merchant.py │ ├── merchant_customs_info.py │ ├── merchant_info.py │ ├── merchant_registration_info.py │ ├── merchant_type.py │ ├── method_type.py │ ├── order.py │ ├── order_code_form.py │ ├── order_info.py │ ├── os_type.py │ ├── passengers.py │ ├── paymentOptionDetail.py │ ├── payment_detail.py │ ├── payment_factor.py │ ├── payment_method.py │ ├── payment_method_category_type.py │ ├── payment_method_detail.py │ ├── payment_method_detail_type.py │ ├── payment_method_info.py │ ├── payment_method_type.py │ ├── payment_method_type_item.py │ ├── payment_option.py │ ├── payment_result_info.py │ ├── payment_verification_data.py │ ├── period_rule.py │ ├── period_type.py │ ├── plan.py │ ├── presentment_mode.py │ ├── product_code_type.py │ ├── promotion_info.py │ ├── promotion_result.py │ ├── promotion_type.py │ ├── psp_customer_info.py │ ├── quote.py │ ├── redirect_action_form.py │ ├── refund_detail.py │ ├── refund_from_type.py │ ├── refund_record.py │ ├── registration_detail.py │ ├── result.py │ ├── result_status_type.py │ ├── risk_score_detail.py │ ├── risk_score_result.py │ ├── risk_score_type.py │ ├── scope_type.py │ ├── settle_to_type.py │ ├── settlement_bank_account.py │ ├── settlement_detail.py │ ├── settlement_info.py │ ├── settlement_strategy.py │ ├── shipping.py │ ├── stock_info.py │ ├── store.py │ ├── subscription_notification_type.py │ ├── subscription_status.py │ ├── support_bank.py │ ├── support_card_brand.py │ ├── terminal_type.py │ ├── three_ds_result.py │ ├── transaction.py │ ├── transaction_status_type.py │ ├── transaction_type.py │ ├── transfer_from_detail.py │ ├── transfer_to_detail.py │ ├── transit.py │ ├── transit_type.py │ ├── trial.py │ ├── user_identity_type.py │ ├── user_name.py │ ├── wallet_payment_method_type.py │ └── web_site.py │ ├── net │ ├── __init__.py │ └── default_http_rpc.py │ ├── request │ ├── __init__.py │ ├── alipay_request.py │ ├── auth │ │ ├── __init__.py │ │ ├── alipay_auth_apply_token_request.py │ │ ├── alipay_auth_consult_request.py │ │ ├── alipay_auth_create_session_request.py │ │ ├── alipay_auth_query_token_request.py │ │ └── alipay_auth_revoke_token_request.py │ ├── declare │ │ ├── __init__.py │ │ ├── alipay_customs_declare_request.py │ │ └── alipay_customs_query_request.py │ ├── dispute │ │ ├── __init__.py │ │ ├── alipay_accept_dispute_request.py │ │ ├── alipay_download_dispute_evidence_request.py │ │ └── alipay_supply_defense_document_request.py │ ├── marketplace │ │ ├── __init__.py │ │ ├── alipay_create_payout_request.py │ │ ├── alipay_create_transfer_request.py │ │ ├── alipay_inquire_balance_request.py │ │ ├── alipay_register_request.py │ │ ├── alipay_settle_request.py │ │ ├── alipay_settlement_info_update_request.py │ │ └── alipay_submit_attachment_request.py │ ├── merchant │ │ ├── __init__.py │ │ ├── alipay_merchant_registration_info_query_request.py │ │ ├── alipay_merchant_registration_request.py │ │ └── alipay_merchant_registration_status_query_request.py │ ├── notify │ │ ├── __init__.py │ │ ├── alipay_auth_notify.py │ │ ├── alipay_capture_result_notify.py │ │ ├── alipay_dispute_notify.py │ │ ├── alipay_notify.py │ │ ├── alipay_pay_result_notify.py │ │ ├── alipay_refund_notify.py │ │ ├── alipay_subscription_notify.py │ │ ├── alipay_subscription_pay_notify.py │ │ └── alipay_vaulting_notify.py │ ├── pay │ │ ├── __init__.py │ │ ├── alipay_capture_request.py │ │ ├── alipay_create_order_request.py │ │ ├── alipay_create_session_request.py │ │ ├── alipay_pay_cancel_request.py │ │ ├── alipay_pay_consult_request.py │ │ ├── alipay_pay_query_request.py │ │ ├── alipay_pay_request.py │ │ ├── alipay_refund_query_request.py │ │ ├── alipay_refund_request.py │ │ ├── alipay_upload_invoice_shipping_file_request.py │ │ ├── entry_code_payment_request.py │ │ ├── order_code_payment_request.py │ │ └── user_presented_code_payment_request.py │ ├── risks │ │ ├── __init__.py │ │ ├── inquiry_risk_score_request.py │ │ ├── risk_decide_request.py │ │ ├── risk_report_request.py │ │ ├── send_payment_result_request.py │ │ └── send_refund_result_request.py │ ├── subscription │ │ ├── __init__.py │ │ ├── alipay_subscription_cancel_request.py │ │ ├── alipay_subscription_change_request.py │ │ ├── alipay_subscription_create_request.py │ │ └── alipay_subscription_update_request.py │ ├── users │ │ ├── __init__.py │ │ ├── alipay_init_authentication_request.py │ │ ├── alipay_user_query_info_request.py │ │ └── alipay_verify_authentication_request.py │ └── vaulting │ │ ├── __init__.py │ │ ├── alipay_vaulting_payment_method_request.py │ │ ├── alipay_vaulting_query_request.py │ │ └── alipay_vaulting_session_request.py │ ├── response │ ├── __init__.py │ ├── alipay_response.py │ ├── auth │ │ ├── __init__.py │ │ ├── alipay_auth_apply_token_response.py │ │ ├── alipay_auth_consult_response.py │ │ ├── alipay_auth_create_session_response.py │ │ ├── alipay_auth_query_token_response.py │ │ └── alipay_auth_revoke_token_response.py │ ├── declare │ │ ├── __init__.py │ │ ├── alipay_customs_declare_response.py │ │ └── alipay_customs_query_response.py │ ├── dispute │ │ ├── __init__.py │ │ ├── alipay_accept_dispute_response.py │ │ ├── alipay_download_dispute_evidence_response.py │ │ └── alipay_supply_defense_document_response.py │ ├── marketplace │ │ ├── __init__.py │ │ ├── alipay_create_payout_response.py │ │ ├── alipay_create_transfer_response.py │ │ ├── alipay_inquire_balance_response.py │ │ ├── alipay_register_response.py │ │ ├── alipay_settle_response.py │ │ ├── alipay_settlement_info_update_response.py │ │ └── alipay_submit_attachment_response.py │ ├── merchant │ │ ├── __init__.py │ │ ├── alipay_merchant_registration_info_query_response.py │ │ ├── alipay_merchant_registration_response.py │ │ └── alipay_merchant_registration_status_query_response.py │ ├── pay │ │ ├── __init__.py │ │ ├── alipay_capture_response.py │ │ ├── alipay_create_order_response.py │ │ ├── alipay_create_session_response.py │ │ ├── alipay_pay_cancel_response.py │ │ ├── alipay_pay_consult_response.py │ │ ├── alipay_pay_query_response.py │ │ ├── alipay_pay_response.py │ │ ├── alipay_refund_query_response.py │ │ ├── alipay_refund_response.py │ │ └── alipay_upload_invoice_shipping_file_response.py │ ├── risks │ │ ├── __init__.py │ │ ├── inquiry_risk_score_response.py │ │ ├── risk_decide_response.py │ │ ├── risk_report_response.py │ │ ├── send_payment_result_response.py │ │ └── send_refund_result_response.py │ ├── subscription │ │ ├── __init__.py │ │ ├── alipay_subscription_cancel_response.py │ │ ├── alipay_subscription_change_response.py │ │ ├── alipay_subscription_create_response.py │ │ └── alipay_subscription_update_response.py │ ├── users │ │ ├── __init__.py │ │ ├── alipay_init_authentication_response.py │ │ ├── alipay_user_query_info_response.py │ │ └── alipay_verify_authentication_response.py │ └── vaulting │ │ ├── __init__.py │ │ ├── alipay_vaulting_payment_method_response.py │ │ ├── alipay_vaulting_query_response.py │ │ └── alipay_vaulting_session_response.py │ └── tools │ ├── __init__.py │ ├── constants.py │ ├── date_tools.py │ ├── signature_tool.py │ └── webhook_tool.py ├── example ├── __init__.py ├── auth.py ├── customsDeclare.py ├── dispute_demo.py ├── entry_code_payment_request_test.py ├── marketplace_demo.py ├── order_code_payment_request_test.py ├── payment.py ├── registration.py ├── subscription_demo.py ├── user_presented_code_payment_test.py ├── users.py └── vaulting_demo.py ├── setup.cfg └── setup.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | 106 | .iml 107 | .idea 108 | 109 | *.pem 110 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Alipay 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /com/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /com/alipay/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/exception/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/exception/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/exception/exception.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | 5 | class AlipayApiException(ValueError): 6 | pass 7 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/DisputeJudgedResult.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeJudgedResult(Enum): 6 | ACCEPT_BY_CUSTOMER = "ACCEPT_BY_CUSTOMER" 7 | ACCEPT_BY_MERCHANT = "ACCEPT_BY_MERCHANT" 8 | VALIDATE_SUCCESS = "VALIDATE_SUCCESS" 9 | VALIDATE_FAIL = "VALIDATE_FAIL" 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/DisputeType.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeJudgedResult(Enum): 6 | CHARGEBACK = "CHARGEBACK" 7 | RETRIEVAL_REQUEST = "RETRIEVAL_REQUEST" 8 | COMPLIANCE_REQUEST = "COMPLIANCE_REQUEST" 9 | def to_ams_dict(self): 10 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/model/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/model/account_balance.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.amount import Amount 4 | 5 | 6 | class AccountBalance: 7 | def __init__(self): 8 | self.__account_balance = None 9 | self.__currency = None 10 | self.__available_balance = None #type: Amount 11 | self.__frozen_balance = None #type: Amount 12 | self.__total_balance = None #type: Amount 13 | 14 | @property 15 | def account_balance(self): 16 | return self.__account_balance 17 | @property 18 | def currency(self): 19 | return self.__currency 20 | 21 | @property 22 | def available_balance(self): 23 | return self.__available_balance 24 | 25 | @property 26 | def frozen_balance(self): 27 | return self.__frozen_balance 28 | 29 | @property 30 | def total_balance(self): 31 | return self.__total_balance 32 | 33 | def parse_rsp_body(self, response_body): 34 | if type(response_body) == str: 35 | response_body = json.loads(response_body) 36 | 37 | if 'accountBalance' in response_body: 38 | self.__account_balance = response_body['accountBalance'] 39 | if 'currency' in response_body: 40 | self.__currency = response_body['currency'] 41 | if 'availableBalance' in response_body: 42 | self.__available_balance = Amount() 43 | self.__available_balance.parse_rsp_body(response_body['availableBalance']) 44 | if 'frozenBalance' in response_body: 45 | self.__frozen_balance = Amount() 46 | self.__frozen_balance.parse_rsp_body(response_body['frozenBalance']) 47 | if 'totalBalance' in response_body: 48 | self.__total_balance = Amount() 49 | self.__total_balance.parse_rsp_body(response_body['totalBalance']) 50 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/account_holder_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class AccountHolderType(Enum): 6 | INDIVIDUAL = "INDIVIDUAL" 7 | ENTERPRISE = "ENTERPRISE" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/account_type.py: -------------------------------------------------------------------------------- 1 | 2 | from enum import Enum, unique 3 | 4 | 5 | @unique 6 | class AccountType(Enum): 7 | CHECKING = "CHECKING" 8 | FIXED_DEPOSIT = "FIXED_DEPOSIT" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/agreement_info.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | 4 | class AgreementInfo(object): 5 | def __init__(self): 6 | self.__auth_state = None 7 | self.__user_login_id = None 8 | 9 | @property 10 | def auth_state(self): 11 | return self.__auth_state 12 | 13 | @auth_state.setter 14 | def auth_state(self, value): 15 | self.__auth_state = value 16 | 17 | @property 18 | def user_login_id(self): 19 | return self.__user_login_id 20 | 21 | @user_login_id.setter 22 | def user_login_id(self, value): 23 | self.__user_login_id = value 24 | 25 | def to_ams_json(self): 26 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 27 | return json_str 28 | 29 | def __to_ams_dict(self): 30 | params = dict() 31 | if self.__auth_state is not None: 32 | params['authState'] = self.__auth_state 33 | if self.__user_login_id is not None: 34 | params['userLoginId'] = self.__user_login_id 35 | return params 36 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/amount.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | 7 | class Amount(object): 8 | def __init__(self, currency=None, value=None): 9 | self.__currency = currency 10 | self.__value = value 11 | 12 | @property 13 | def currency(self): 14 | return self.__currency 15 | 16 | @property 17 | def value(self): 18 | return self.__value 19 | 20 | def to_ams_dict(self): 21 | params = dict() 22 | if hasattr(self, "currency") and self.currency: 23 | params['currency'] = self.currency 24 | 25 | if hasattr(self, "value") and self.value: 26 | params['value'] = self.value 27 | 28 | return params 29 | 30 | def parse_rsp_body(self, amount_body): 31 | if type(amount_body) == str: 32 | amount_body = json.loads(amount_body) 33 | 34 | if 'currency' in amount_body: 35 | self.__currency = amount_body['currency'] 36 | 37 | if 'value' in amount_body: 38 | self.__value = amount_body['value'] 39 | 40 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/amount_limit.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.amount import Amount 7 | 8 | 9 | class AmountLimit(object): 10 | def __init__(self): 11 | self.__max_amount = None 12 | self.__min_amount = None 13 | self.__remain_amount = None 14 | 15 | @property 16 | def max_amount(self): 17 | return self.__max_amount 18 | 19 | @property 20 | def min_amount(self): 21 | return self.__min_amount 22 | 23 | @property 24 | def remain_amount(self): 25 | return self.__remain_amount 26 | 27 | def parse_rsp_body(self, amount_limit_body): 28 | if type(amount_limit_body) == str: 29 | amount_limit_body = json.loads(amount_limit_body) 30 | 31 | if 'maxAmount' in amount_limit_body: 32 | max_amount = Amount() 33 | max_amount.parse_rsp_body(amount_limit_body['maxAmount']) 34 | self.__max_amount = max_amount 35 | 36 | if 'minAmount' in amount_limit_body: 37 | min_amount = Amount() 38 | min_amount.parse_rsp_body(amount_limit_body['minAmount']) 39 | self.__min_amount = min_amount 40 | 41 | if 'remainAmount' in amount_limit_body: 42 | remain_amount = Amount() 43 | remain_amount.parse_rsp_body(amount_limit_body['remainAmount']) 44 | self.__remain_amount = remain_amount 45 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/amount_limit_info.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.amount_limit import AmountLimit 7 | 8 | 9 | class AmountLimitInfo(object): 10 | def __init__(self): 11 | self.__single_limit = None 12 | self.__day_limit = None 13 | self.__month_limit = None 14 | 15 | @property 16 | def single_limit(self): 17 | return self.__single_limit 18 | 19 | @property 20 | def day_limit(self): 21 | return self.__day_limit 22 | 23 | @property 24 | def month_limit(self): 25 | return self.__month_limit 26 | 27 | def parse_rsp_body(self, amount_limit_info_body): 28 | if type(amount_limit_info_body) == str: 29 | amount_limit_info_body = json.loads(amount_limit_info_body) 30 | 31 | if 'singleLimit' in amount_limit_info_body: 32 | single_limit = AmountLimit() 33 | single_limit.parse_rsp_body(amount_limit_info_body['singleLimit']) 34 | self.__single_limit = single_limit 35 | 36 | if 'dayLimit' in amount_limit_info_body: 37 | day_amount = AmountLimit() 38 | day_amount.parse_rsp_body(amount_limit_info_body['dayLimit']) 39 | self.__day_limit = day_amount 40 | 41 | if 'monthLimit' in amount_limit_info_body: 42 | month_amount = AmountLimit() 43 | month_amount.parse_rsp_body(amount_limit_info_body['monthLimit']) 44 | self.__month_limit = month_amount 45 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/apple_pay_configuration.py: -------------------------------------------------------------------------------- 1 | import string 2 | 3 | 4 | class ApplePayConfiguration: 5 | def __init__(self): 6 | self.__required_billing_contact_fields = None #type: list[string] 7 | self.__required_shipping_contact_fields = None #type: list[string] 8 | self.__buttons_bundled = None #type: bool 9 | self.__apple_pay_token = None #type: string 10 | 11 | 12 | @property 13 | def required_billing_contact_fields(self): 14 | return self.__required_billing_contact_fields 15 | 16 | @required_billing_contact_fields.setter 17 | def required_billing_contact_fields(self, value): 18 | self.__required_billing_contact_fields = value 19 | 20 | @property 21 | def required_shipping_contact_fields(self): 22 | return self.__required_shipping_contact_fields 23 | 24 | @required_shipping_contact_fields.setter 25 | def required_shipping_contact_fields(self, value): 26 | self.__required_shipping_contact_fields = value 27 | 28 | 29 | @property 30 | def buttons_bundled(self): 31 | return self.__buttons_bundled 32 | 33 | @buttons_bundled.setter 34 | def buttons_bundled(self, value: bool): 35 | self.__buttons_bundled = value 36 | 37 | @property 38 | def apple_pay_token(self): 39 | return self.__apple_pay_token 40 | 41 | @apple_pay_token.setter 42 | def apple_pay_token(self, value: str): 43 | self.__apple_pay_token = value 44 | 45 | def to_ams_dict(self): 46 | params = dict() 47 | if hasattr(self, "required_billing_contact_fields") and self.required_billing_contact_fields: 48 | params['referenceBuyerId'] = self.required_shipping_contact_fields 49 | if hasattr(self, "required_shipping_contact_fields") and self.required_shipping_contact_fields: 50 | params['referenceBuyerId'] = self.required_shipping_contact_fields 51 | if hasattr(self, "buttons_bundled") and self.buttons_bundled: 52 | params['referenceBuyerId'] = self.buttons_bundled 53 | if hasattr(self, "apple_pay_token") and self.apple_pay_token: 54 | params['referenceBuyerId'] = self.apple_pay_token 55 | return params 56 | 57 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/association_type.py: -------------------------------------------------------------------------------- 1 | 2 | from enum import Enum, unique 3 | 4 | 5 | @unique 6 | class AssociationType(Enum): 7 | LEGAL_REPRESENTATIVE = "LEGAL_REPRESENTATIVE" 8 | UBO = "UBO" 9 | CONTACT = "CONTACT" 10 | DIRECTOR = "DIRECTOR" 11 | AUTHORIZER = "AUTHORIZER" 12 | BOARD_MEMBER = "BOARD_MEMBER" 13 | 14 | def to_ams_dict(self): 15 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/attachment.py: -------------------------------------------------------------------------------- 1 | class Attachment(object): 2 | def __init__(self): 3 | self.__attachment_type = None 4 | self.__file = None 5 | self.__attachment_name = None 6 | self.__file_key = None 7 | 8 | @property 9 | def attachment_type(self): 10 | return self.__attachment_type 11 | 12 | @attachment_type.setter 13 | def attachment_type(self, value): 14 | self.__attachment_type = value 15 | 16 | @property 17 | def file(self): 18 | return self.__file 19 | 20 | @file.setter 21 | def file(self, value): 22 | self.__file = value 23 | 24 | @property 25 | def attachment_name(self): 26 | return self.__attachment_name 27 | 28 | @attachment_name.setter 29 | def attachment_name(self, value): 30 | self.__attachment_name = value 31 | 32 | @property 33 | def file_key(self): 34 | return self.__file_key 35 | 36 | @file_key.setter 37 | def file_key(self, value): 38 | self.__file_key = value 39 | 40 | def to_ams_dict(self): 41 | params = dict() 42 | if hasattr(self, "attachment_type") and self.attachment_type: 43 | params['attachmentType'] = self.attachment_type 44 | 45 | if hasattr(self, "file") and self.file: 46 | params['file'] = self.file 47 | 48 | if hasattr(self, "attachment_name") and self.attachment_name: 49 | params['attachmentName'] = self.attachment_name 50 | 51 | if hasattr(self, "file_key") and self.file_key: 52 | params['fileKey'] = self.file_key 53 | 54 | return params 55 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/attachment_type.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class AttachmentType(Enum): 8 | SIGNATURE_AUTHORIZATION_LETTER = "SIGNATURE_AUTHORIZATION_LETTER" 9 | ARTICLES_OF_ASSOCIATION = "ARTICLES_OF_ASSOCIATION" 10 | LOGO = "LOGO" 11 | AUTHORIZER_SIGNATURE_CONFIRMATION_LETTER = "AUTHORIZER_SIGNATURE_CONFIRMATION_LETTER" 12 | ASSOCIATION_ARTICLE = "ASSOCIATION_ARTICLE" 13 | FINANCIAL_REPORT = "FINANCIAL_REPORT" 14 | OWNERSHIP_STRUCTURE_PIC = "OWNERSHIP_STRUCTURE_PIC" 15 | ADDRESS_PROOF = "ADDRESS_PROOF" 16 | UBO_PROVE = "UBO_PROVE" 17 | ENTERPRISE_REGISTRATION = "ENTERPRISE_REGISTRATION" 18 | LICENSE_INFO = "LICENSE_INFO" 19 | ID_CARD = "ID_CARD" 20 | PASSPORT = "PASSPORT" 21 | DRIVING_LICENSE = "DRIVING_LICENSE" 22 | CPF = "CPF" 23 | CNPJ = "CNPJ" 24 | 25 | def to_ams_dict(self): 26 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/auth_code_form.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.code_detail import CodeDetail 2 | 3 | 4 | class AuthCodeForm(object): 5 | def __init__(self): 6 | self.codeDetails = None # type: list[CodeDetail] 7 | 8 | @property 9 | def code_details(self): 10 | return self.codeDetails 11 | 12 | @code_details.setter 13 | def code_details(self, value): 14 | self.codeDetails = value 15 | 16 | def to_ams_dict(self): 17 | params = dict() 18 | if self.codeDetails is not None: 19 | params['codeDetails'] = [item.to_ams_dict() for item in self.codeDetails] 20 | return params 21 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/auth_meta_data.py: -------------------------------------------------------------------------------- 1 | 2 | class AuthMetaData: 3 | def __init__(self): 4 | self.__account_holder_name = None 5 | self.__account_holder_certNo = None 6 | 7 | 8 | @property 9 | def account_holder_name(self): 10 | return self.__account_holder_name 11 | 12 | @account_holder_name.setter 13 | def account_holder_name(self, value): 14 | self.__account_holder_name = value 15 | 16 | @property 17 | def account_holder_certNo(self): 18 | return self.__account_holder_certNo 19 | 20 | @account_holder_certNo.setter 21 | def account_holder_certNo(self, value): 22 | self.__account_holder_certNo = value 23 | 24 | 25 | def to_ams_dict(self): 26 | params = dict() 27 | if hasattr(self, "account_holder_name") and self.account_holder_name: 28 | params['accountHolderName'] = self.account_holder_name 29 | if hasattr(self, "account_holder_certNo") and self.account_holder_certNo: 30 | params['accountHolderCertNo'] = self.account_holder_certNo 31 | 32 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/authentication_channel_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class AuthenticationChannelType(Enum): 8 | EMAIL = "EMAIL" 9 | SMS = "SMS" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/authentication_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class AuthenticationType(Enum): 8 | OTP = "OTP" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/authorization_error.py: -------------------------------------------------------------------------------- 1 | 2 | class AuthorizationError: 3 | def __init__(self): 4 | self.__error_code = None 5 | self.__error_message = None 6 | 7 | @property 8 | def error_code(self): 9 | return self.__error_code 10 | @error_code.setter 11 | def error_code(self, value): 12 | self.__error_code = value 13 | @property 14 | def error_message(self): 15 | return self.__error_message 16 | @error_message.setter 17 | def error_message(self, value): 18 | self.__error_message = value 19 | 20 | def to_ams_dict(self): 21 | params = dict() 22 | if self.error_code is not None: 23 | params['errorCode'] = self.error_code 24 | if self.error_message is not None: 25 | params['errorMessage'] = self.error_message 26 | return params 27 | 28 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/authorization_phase.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class AuthorizationPhase(Enum): 6 | PRE_AUTHORIZATION = "PRE_AUTHORIZATION" 7 | POST_AUTHORIZATION = "POST_AUTHORIZATION" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/available_payment_method.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.payment_method_type_item import PaymentMethodTypeItem 2 | 3 | 4 | class AvailablePaymentMethod: 5 | 6 | def __init__(self): 7 | self.__payment_method_type_list = None #type: list[PaymentMethodTypeItem] 8 | self.__payment_method_meta_data = None #type: map[string,object] 9 | 10 | 11 | @property 12 | def payment_method_type_list(self): 13 | return self.__payment_method_type_list 14 | 15 | 16 | @payment_method_type_list.setter 17 | def payment_method_type_list(self, payment_method_type_list): 18 | if not isinstance(payment_method_type_list, list): 19 | raise TypeError("payment_method_type_list should be list[PaymentMethodTypeItem]") 20 | 21 | for item in payment_method_type_list: 22 | if not isinstance(item, PaymentMethodTypeItem): 23 | raise TypeError("item should be type of PaymentMethodTypeItem") 24 | 25 | self.__payment_method_type_list = payment_method_type_list 26 | 27 | 28 | @property 29 | def payment_method_meta_data(self): 30 | return self.__payment_method_meta_data 31 | @payment_method_meta_data.setter 32 | def payment_method_meta_data(self, payment_method_meta_data): 33 | self.__payment_method_meta_data = payment_method_meta_data 34 | 35 | 36 | def to_ams_dict(self): 37 | params = dict() 38 | if self.__payment_method_type_list is not None: 39 | params['paymentMethodTypeList'] = [item.to_ams_dict() for item in self.__payment_method_type_list] 40 | if self.__payment_method_meta_data is not None: 41 | params['paymentMethodMetaData'] = self.__payment_method_meta_data 42 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/browser_info.py: -------------------------------------------------------------------------------- 1 | class BrowserInfo(object): 2 | def __init__(self): 3 | self.__accept_header = None 4 | self.__java_enabled = None 5 | self.__java_script_enabled = None 6 | self.__language = None 7 | self.__user_agent = None 8 | 9 | @property 10 | def accept_header(self): 11 | return self.__accept_header 12 | 13 | @accept_header.setter 14 | def accept_header(self, value): 15 | self.__accept_header = value 16 | 17 | @property 18 | def java_enabled(self): 19 | return self.__java_enabled 20 | 21 | @java_enabled.setter 22 | def java_enabled(self, value): 23 | self.__java_enabled = value 24 | 25 | @property 26 | def java_script_enabled(self): 27 | return self.__java_script_enabled 28 | 29 | @java_script_enabled.setter 30 | def java_script_enabled(self, value): 31 | self.__java_script_enabled = value 32 | 33 | @property 34 | def language(self): 35 | return self.__language 36 | 37 | @language.setter 38 | def language(self, value): 39 | self.__language = value 40 | 41 | @property 42 | def user_agent(self): 43 | return self.__user_agent 44 | 45 | @user_agent.setter 46 | def user_agent(self, value): 47 | self.__user_agent = value 48 | 49 | def to_ams_dict(self): 50 | params = dict() 51 | if hasattr(self, "accept_header") and self.accept_header: 52 | params['acceptHeader'] = self.accept_header 53 | 54 | if hasattr(self, "java_enabled") and self.java_enabled: 55 | params['javaEnabled'] = self.java_enabled 56 | 57 | if hasattr(self, "java_script_enabled") and self.java_script_enabled: 58 | params['javaScriptEnabled'] = self.java_script_enabled 59 | 60 | if hasattr(self, "language") and self.language: 61 | params['language'] = self.language 62 | 63 | if hasattr(self, "user_agent") and self.user_agent: 64 | params['userAgent'] = self.user_agent 65 | return params 66 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/business_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | 5 | class BusinessType(object): 6 | HOTEL = "1" 7 | AIR_FLIGHT = "2" 8 | STUDAY_ABROAD = "3" 9 | TRADE = "4" 10 | OTHER = "5" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/buyer.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | 5 | class Buyer(object): 6 | 7 | def __init__(self): 8 | self.__reference_buyer_id = None 9 | self.__buyer_name = None 10 | self.__buyer_phone_no = None 11 | self.__buyer_email = None 12 | 13 | @property 14 | def reference_buyer_id(self): 15 | return self.__reference_buyer_id 16 | 17 | @reference_buyer_id.setter 18 | def reference_buyer_id(self, value): 19 | self.__reference_buyer_id = value 20 | 21 | @property 22 | def buyer_name(self): 23 | return self.__buyer_name 24 | 25 | @buyer_name.setter 26 | def buyer_name(self, value): 27 | self.__buyer_name = value 28 | 29 | @property 30 | def buyer_phone_no(self): 31 | return self.__buyer_phone_no 32 | 33 | @buyer_phone_no.setter 34 | def buyer_phone_no(self, value): 35 | self.__buyer_phone_no = value 36 | 37 | @property 38 | def buyer_email(self): 39 | return self.__buyer_email 40 | 41 | @buyer_email.setter 42 | def buyer_email(self, value): 43 | self.__buyer_email = value 44 | 45 | def to_ams_dict(self): 46 | params = dict() 47 | if hasattr(self, "reference_buyer_id") and self.reference_buyer_id: 48 | params['referenceBuyerId'] = self.reference_buyer_id 49 | 50 | if hasattr(self, "buyer_name") and self.buyer_name: 51 | params['buyerName'] = self.buyer_name 52 | 53 | if hasattr(self, "buyer_phone_no") and self.buyer_phone_no: 54 | params['buyerPhoneNo'] = self.buyer_phone_no 55 | 56 | if hasattr(self, "buyer_email") and self.buyer_email: 57 | params['buyerEmail'] = self.buyer_email 58 | 59 | return params 60 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/cancellation_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | class CancellationType(Enum): 5 | CANCEL = "CANCEL" 6 | TERMINATE = "TERMINATE" 7 | 8 | def to_ams_dict(self): 9 | return self.name 10 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/capture_mode.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class CaptureMode(Enum): 6 | AUTOMATIC = "AUTOMATIC" 7 | MANUAL = "MANUAL" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/card_brand.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class CardBrand(Enum): 8 | VISA = "VISA" 9 | MASTERCARD = "MASTERCARD" 10 | MAESTRO = "MAESTRO" 11 | AMEX = "AMEX" 12 | JCB = "JCB" 13 | DINERS = "DINERS" 14 | DISCOVER = "DISCOVER" 15 | CUP = "CUP" 16 | MIR = "MIR" 17 | ELO = "ELO" 18 | HIPERCARD = "HIPERCARD" 19 | TROY = "TROY" 20 | 21 | def to_ams_dict(self): 22 | return self.name 23 | 24 | @staticmethod 25 | def value_of(value): 26 | if not value: 27 | return None 28 | 29 | if CardBrand.VISA.value == value: 30 | return CardBrand.VISA 31 | elif CardBrand.MASTERCARD.value == value: 32 | return CardBrand.MASTERCARD 33 | elif CardBrand.MAESTRO.value == value: 34 | return CardBrand.MAESTRO 35 | elif CardBrand.AMEX.value == value: 36 | return CardBrand.AMEX 37 | elif CardBrand.JCB.value == value: 38 | return CardBrand.JCB 39 | elif CardBrand.DINERS.value == value: 40 | return CardBrand.DINERS 41 | elif CardBrand.DISCOVER.value == value: 42 | return CardBrand.DISCOVER 43 | elif CardBrand.CUP.value == value: 44 | return CardBrand.CUP 45 | elif CardBrand.MIR.value == value: 46 | return CardBrand.MIR 47 | elif CardBrand.ELO.value == value: 48 | return CardBrand.ELO 49 | elif CardBrand.HIPERCARD.value == value: 50 | return CardBrand.HIPERCARD 51 | elif CardBrand.TROY.value == value: 52 | return CardBrand.TROY 53 | else: 54 | return None 55 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/card_brand_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class CardBrandType(Enum): 6 | VISA = "VISA" 7 | MASTERCARD = "MASTERCARD" 8 | AMEX = "AMEX" 9 | HIPERCARD = "HIPERCARD" 10 | ELO = "ELO" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/certificate_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class CertificateType(Enum): 6 | ID_CARD = "ID_CARD" 7 | PASSPORT = "PASSPORT" 8 | ENTERPRISE_REGISTRATION = "ENTERPRISE_REGISTRATION" 9 | LICENSE_INFO = "LICENSE_INFO" 10 | DRIVING_LICENSE = "DRIVING_LICENSE" 11 | CPF = "CPF" 12 | CNPJ = "CNPJ" 13 | 14 | def to_ams_dict(self): 15 | return self.name 16 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/challenge_trigger_source_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from enum import Enum, unique 5 | 6 | 7 | @unique 8 | class ChallengeTriggerSourceType(Enum): 9 | AMS = "AMS" 10 | CHANNEL = "CHANNEL" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/challenge_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from enum import Enum, unique 5 | 6 | 7 | @unique 8 | class ChallengeType(Enum): 9 | SMS_OTP = "SMS_OTP" 10 | PLAINTEXT_CARD_NO = "PLAINTEXT_CARD_NO" 11 | CARD_EXPIRE_DATE = "CARD_EXPIRE_DATE" 12 | 13 | def to_ams_dict(self): 14 | return self.name 15 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/class_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class ClassType(Enum): 6 | FIRSTLEVEL = "FIRSTLEVEL" 7 | SECONDLEVEL = "SECONDLEVEL" 8 | THIRDLEVEL = "THIRDLEVEL" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/clearing_channel.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | 4 | class ClearingChannel(Enum): 5 | CUP = "1" 6 | NUCC = "2" 7 | OTHER = "3" 8 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/code_detail.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.code_value_type import CodeValueType 7 | from com.alipay.ams.api.model.display_type import DisplayType 8 | 9 | 10 | class CodeDetail(object): 11 | def __init__(self): 12 | self.__code_value_type = None # type:CodeValueType 13 | self.__code_value = None 14 | self.__display_type = None # type:DisplayType 15 | 16 | @property 17 | def code_value_type(self): 18 | return self.__code_value_type 19 | 20 | @code_value_type.setter 21 | def code_value_type(self, value): 22 | self.__code_value_type = value 23 | 24 | @property 25 | def code_value(self): 26 | return self.__code_value 27 | 28 | @code_value.setter 29 | def code_value(self, value): 30 | self.__code_value = value 31 | 32 | @property 33 | def display_type(self): 34 | return self.__display_type 35 | 36 | @display_type.setter 37 | def display_type(self, value): 38 | self.__display_type = value 39 | 40 | def parse_rsp_body(self, code_detail_body): 41 | if type(code_detail_body) == str: 42 | code_detail_body = json.loads(code_detail_body) 43 | 44 | if 'codeValueType' in code_detail_body: 45 | code_value_type = CodeValueType.value_of(code_detail_body['codeValueType']) 46 | self.__code_value_type = code_value_type 47 | 48 | if 'codeValue' in code_detail_body: 49 | self.__code_value = code_detail_body['codeValue'] 50 | 51 | if 'displayType' in code_detail_body: 52 | display_type = DisplayType.value_of(code_detail_body['displayType']) 53 | self.__display_type = display_type 54 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/code_value_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class CodeValueType(Enum): 8 | BARCODE = "BARCODE" 9 | QRCODE = "QRCODE" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | 14 | @staticmethod 15 | def value_of(value): 16 | if not value: 17 | return None 18 | 19 | if CodeValueType.BARCODE.value == value: 20 | return CodeValueType.BARCODE 21 | elif CodeValueType.QRCODE.value == value: 22 | return CodeValueType.QRCODE 23 | else: 24 | return None 25 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/companyType.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class CompanyType(Enum): 6 | ENTERPRISE = "ENTERPRISE" 7 | PARTNERSHIP = "PARTNERSHIP" 8 | SOLE_PROPRIETORSHIP = "SOLE_PROPRIETORSHIP" 9 | STATE_OWNED_BUSINESS = "STATE_OWNED_BUSINESS" 10 | PRIVATELY_OWNED_BUSINESS = "PRIVATELY_OWNED_BUSINESS" 11 | PUBLICLY_LISTED_BUSINESS = "PUBLICLY_LISTED_BUSINESS" 12 | LTDA = "LTDA" 13 | SA = "SA" 14 | EIRELI = "EIRELI" 15 | BOFC = "BOFC" 16 | MEI = "MEI" 17 | EI = "EI" 18 | 19 | def to_ams_dict(self): 20 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/company_unit_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class CompanyUnitType(Enum): 6 | HEADQUARTER = "HEADQUARTER" 7 | BRANCH = "BRANCH" 8 | 9 | def to_ams_dict(self): 10 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/contact.py: -------------------------------------------------------------------------------- 1 | 2 | class Contact: 3 | def __init__(self): 4 | self.__type = None 5 | self.__info = None 6 | 7 | def set_type(self, type): 8 | self.__type = type 9 | 10 | def get_type(self): 11 | return self.__type 12 | 13 | def set_info(self, info): 14 | self.__info = info 15 | 16 | def get_info(self): 17 | return self.__info 18 | 19 | def to_ams_dict(self): 20 | params = dict() 21 | if hasattr(self, 'type') and self.__type: 22 | params['type'] = self.__type 23 | 24 | if hasattr(self, 'info') and self.__info: 25 | params['info'] = self.__info 26 | 27 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/contact_info.py: -------------------------------------------------------------------------------- 1 | class ContactInfo(object): 2 | def __init__(self): 3 | self.__contact_no = None 4 | self.__contact_type = None 5 | 6 | @property 7 | def contact_no(self): 8 | return self.__contact_no 9 | 10 | @contact_no.setter 11 | def contact_no(self, value): 12 | self.__contact_no = value 13 | 14 | @property 15 | def contact_type(self): 16 | return self.__contact_type 17 | 18 | @contact_type.setter 19 | def contact_type(self, value): 20 | self.__contact_type = value 21 | 22 | def to_ams_dict(self): 23 | params = dict() 24 | if hasattr(self, "contact_no") and self.contact_no: 25 | params['contactNo'] = self.contact_no 26 | 27 | if hasattr(self, "contact_type") and self.contact_type: 28 | params['contactType'] = self.contact_type 29 | 30 | return params 31 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/credit_pay_fee_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class CreditPayFeeType(Enum): 6 | PERCENTAGE = "PERCENTAGE" 7 | 8 | def to_ams_dict(self): 9 | return self.name 10 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/credit_pay_plan.py: -------------------------------------------------------------------------------- 1 | class CreditPayPlan(object): 2 | def __init__(self): 3 | self.__installment_num = None 4 | self.__credit_pay_fee_type = None 5 | self.__fee_percentage = None 6 | 7 | @property 8 | def installment_num(self): 9 | return self.__installment_num 10 | 11 | @property 12 | def credit_pay_fee_type(self): 13 | return self.__credit_pay_fee_type 14 | 15 | @property 16 | def fee_percentage(self): 17 | return self.__fee_percentage 18 | 19 | @installment_num.setter 20 | def installment_num(self, value): 21 | self.__installment_num = value 22 | 23 | @credit_pay_fee_type.setter 24 | def credit_pay_fee_type(self, value): 25 | self.__credit_pay_fee_type = value 26 | 27 | @fee_percentage.setter 28 | def fee_percentage(self, value): 29 | self.__fee_percentage = value 30 | 31 | def to_ams_dict(self): 32 | params = dict() 33 | 34 | if hasattr(self, "installment_num") and self.installment_num: 35 | params['installmentNum'] = self.installment_num 36 | if hasattr(self, "credit_pay_fee_type") and self.credit_pay_fee_type: 37 | params['creditPayFeeType'] = self.credit_pay_fee_type 38 | if hasattr(self, "fee_percentage") and self.fee_percentage: 39 | params['feePercentage'] = self.fee_percentage 40 | 41 | return params 42 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/customer_belongs_to.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class CustomerBelongsTo(Enum): 8 | TRUEMONEY = "TRUEMONEY" 9 | ALIPAY_HK = "ALIPAY_HK" 10 | TNG = "TNG" 11 | ALIPAY_CN = "ALIPAY_CN" 12 | GCASH = "GCASH" 13 | DANA = "DANA" 14 | KAKAOPAY = "KAKAOPAY" 15 | BKASH = "BKASH" 16 | EASYPAISA = "EASYPAISA" 17 | 18 | RABBIT_LINE_PAY = "RABBIT_LINE_PAY" 19 | 20 | PAYPAY = "PAYPAY" 21 | 22 | BOOST = "BOOST" 23 | 24 | GRABPAY_MY = "GRABPAY_MY" 25 | 26 | MAYA = "MAYA" 27 | 28 | GRABPAY_PH = "GRABPAY_PH" 29 | 30 | GRABPAY_SG = "GRABPAY_SG" 31 | 32 | NAVERPAY = "NAVERPAY" 33 | 34 | JKOPAY = "JKOPAY" 35 | 36 | KPLUS = "KPLUS" 37 | 38 | DIRECT_DEBIT_SIAMCOMMERCIALBANK = "DIRECT_DEBIT_SIAMCOMMERCIALBANK" 39 | 40 | DIRECT_DEBIT_KRUNGTHAIBANK = "DIRECT_DEBIT_KRUNGTHAIBANK" 41 | 42 | ZALOPAY = "ZALOPAY" 43 | 44 | DIRECTDEBIT_YAPILY = "DIRECTDEBIT_YAPILY " 45 | 46 | def to_ams_dict(self): 47 | return self.name 48 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/customer_id_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class CustomerIdType(Enum): 8 | EMAIL = "EMAIL" 9 | USER_ID = "USER_ID" 10 | MOBILE_NO = "MOBILE_NO" 11 | AUTH_CODE = "AUTH_CODE" 12 | 13 | def to_ams_dict(self): 14 | return self.name 15 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/customs_info.py: -------------------------------------------------------------------------------- 1 | class CustomsInfo(object): 2 | def __init__(self): 3 | self.__customs_code = None 4 | self.__region = None 5 | 6 | @property 7 | def customs_code(self): 8 | return self.__customs_code 9 | 10 | @customs_code.setter 11 | def customs_code(self, value): 12 | self.__customs_code = value 13 | 14 | @property 15 | def region(self): 16 | return self.__region 17 | 18 | @region.setter 19 | def region(self, value): 20 | self.__region = value 21 | 22 | def to_ams_dict(self): 23 | params = dict() 24 | if hasattr(self, "customs_code") and self.customs_code: 25 | params['customsCode'] = self.customs_code 26 | if hasattr(self, "region") and self.region: 27 | params['region'] = self.region 28 | return params 29 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/delivery_method_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DeliveryMethodType(Enum): 6 | PHYSICAL = "PHYSICAL" 7 | DIGITAL = "DIGITAL" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/disable_reason_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisableReasonType(Enum): 6 | PAYMENT_ACCOUNT_NOT_AVAILABLE = "PAYMENT_ACCOUNT_NOT_AVAILABLE" 7 | EXCEED_CHANNEL_LIMIT_RULE = "EXCEED_CHANNEL_LIMIT_RULE" 8 | SERVICE_DEGRADE = "SERVICE_DEGRADE" 9 | CHANNEL_NOT_SUPPORT_CURRENCY = "CHANNEL_NOT_SUPPORT_CURRENCY" 10 | CHANNEL_DISABLE = "CHANNEL_DISABLE" 11 | CHANNEL_NOT_IN_SERVICE_TIME = "CHANNEL_NOT_IN_SERVICE_TIME" 12 | QUERY_IPP_INFO_FAILED = "QUERY_IPP_INFO_FAILED" 13 | LIMIT_CENTER_ACCESS_FAIL = "LIMIT_CENTER_ACCESS_FAIL" 14 | CURRENT_CHANNEL_NOT_EXIST = "CURRENT_CHANNEL_NOT_EXIST" 15 | 16 | def to_ams_dict(self): 17 | return self.name 18 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/display_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class DisplayType(Enum): 8 | TEXT = "TEXT" 9 | MIDDLEIMAGE = "MIDDLEIMAGE" 10 | SMALLIMAGE = "SMALLIMAGE" 11 | BIGIMAGE = "BIGIMAGE" 12 | IMAGE = "IMAGE" 13 | 14 | def to_ams_dict(self): 15 | return self.name 16 | 17 | @staticmethod 18 | def value_of(value): 19 | if not value: 20 | return None 21 | 22 | if DisplayType.TEXT.value == value: 23 | return DisplayType.TEXT 24 | elif DisplayType.MIDDLEIMAGE.value == value: 25 | return DisplayType.MIDDLEIMAGE 26 | elif DisplayType.SMALLIMAGE.value == value: 27 | return DisplayType.SMALLIMAGE 28 | elif DisplayType.BIGIMAGE.value == value: 29 | return DisplayType.BIGIMAGE 30 | elif DisplayType.IMAGE.value == value: 31 | return DisplayType.IMAGE 32 | else: 33 | return None 34 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/dispute_accept_reason_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeAcceptReasonType(Enum): 6 | MERCHANT_ACCEPTED = "MERCHANT_ACCEPTED" 7 | TIMEOUT = "TIMEOUT" 8 | MANUAL_PROCESSING_ACCEPTED = "MANUAL_PROCESSING_ACCEPTED" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/dispute_evidence_format_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeEvidenceFormatType(Enum): 6 | PDF = "PDF" 7 | WORD = "WORD" 8 | ZIP = "ZIP" 9 | JPG = "JPG" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/dispute_evidence_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeEvidenceType(Enum): 6 | DISPUTE_EVIDENCE_TEMPLATE = "DISPUTE_EVIDENCE_TEMPLATE" 7 | DISPUTE_EVIDENCE_FILE = "DISPUTE_EVIDENCE_FILE" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/dispute_judged_result.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeNotificationType(Enum): 6 | ACCEPT_BY_CUSTOMER = "ACCEPT_BY_CUSTOMER" 7 | ACCEPT_BY_MERCHANT = "ACCEPT_BY_MERCHANT" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/dispute_notification_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class DisputeNotificationType(Enum): 6 | DISPUTE_CREATED = "DISPUTE_CREATED" 7 | DISPUTE_JUDGED = "DISPUTE_JUDGED" 8 | DISPUTE_CANCELLED = "DISPUTE_CANCELLED" 9 | DEFENSE_SUPPLIED = "DEFENSE_SUPPLIED" 10 | DEFENSE_DUE_ALERT = "DEFENSE_DUE_ALERT" 11 | DISPUTE_ACCEPTED = "DISPUTE_ACCEPTED" 12 | RDR_RESOLVED = "RDR_RESOLVED" 13 | 14 | def to_ams_dict(self): 15 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/extend_info.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.china_extra_trans_info import ChinaExtraTransInfo 2 | 3 | 4 | class ExtendInfo(object): 5 | def __init__(self): 6 | self.__china_extra_trans_info = None # type:ChinaExtraTransInfo 7 | 8 | @property 9 | def china_extra_trans_info(self): 10 | return self.__china_extra_trans_info 11 | 12 | @china_extra_trans_info.setter 13 | def china_extra_trans_info(self, value): 14 | self.__china_extra_trans_info = value 15 | 16 | def to_ams_dict(self): 17 | params = dict() 18 | if hasattr(self, "china_extra_trans_info") and self.china_extra_trans_info: 19 | params['chinaExtraTransInfo'] = self.china_extra_trans_info 20 | 21 | return params 22 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/funding_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class FundingType(Enum): 6 | CREDIT = "CREDIT" 7 | DEBIT = "DEBIT" 8 | 9 | 10 | PREPAID = "PREPAID" 11 | CHARGE = "CHARGE" 12 | DEFERRED_DEBIT = "DEFERRED_DEBIT" 13 | 14 | 15 | def to_ams_dict(self): 16 | return self.name 17 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/gaming.py: -------------------------------------------------------------------------------- 1 | class Gaming(object): 2 | 3 | def __init__(self): 4 | self.__game_name = None 5 | self.__topped_up_user = None 6 | self.__topped_up_email = None 7 | self.__topped_up_phone_no = None 8 | 9 | @property 10 | def game_name(self): 11 | return self.__game_name 12 | 13 | @game_name.setter 14 | def game_name(self, value): 15 | self.__game_name = value 16 | 17 | @property 18 | def topped_up_user(self): 19 | return self.__topped_up_user 20 | 21 | @topped_up_user.setter 22 | def topped_up_user(self, value): 23 | self.__topped_up_user = value 24 | 25 | @property 26 | def topped_up_email(self): 27 | return self.__topped_up_email 28 | 29 | @topped_up_email.setter 30 | def topped_up_email(self, value): 31 | self.__topped_up_email = value 32 | 33 | @property 34 | def topped_up_phone_no(self): 35 | return self.__topped_up_phone_no 36 | 37 | @topped_up_phone_no.setter 38 | def topped_up_phone_no(self, value): 39 | self.__topped_up_phone_no = value 40 | 41 | def to_ams_dict(self): 42 | params = dict() 43 | if hasattr(self, "game_name") and self.game_name: 44 | params['gameName'] = self.game_name 45 | 46 | if hasattr(self, "topped_up_user") and self.topped_up_user: 47 | params['toppedUpUser'] = self.topped_up_user.to_ams_dict() 48 | 49 | if hasattr(self, "topped_up_email") and self.topped_up_email: 50 | params['toppedUpEmail'] = self.topped_up_email 51 | 52 | if hasattr(self, "topped_up_phone_no") and self.topped_up_phone_no: 53 | params['toppedUpPhoneNo'] = self.topped_up_phone_no 54 | 55 | return params 56 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/grant_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class GrantType(Enum): 8 | AUTHORIZATION_CODE = "AUTHORIZATION_CODE" 9 | REFRESH_TOKEN = "REFRESH_TOKEN" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/http_method.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class HttpMethod(Enum): 8 | POST = "POST" 9 | GET = "GET" 10 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/identity_check_result.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | 4 | class IdentityCheckResult(Enum): 5 | CHECK_PASSED = "CHECK_PASSED" 6 | CHECK_NOT_PASSED = "CHECK_NOT_PASSED" 7 | 8 | def to_ams_dict(self): 9 | return self.name 10 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/in_store_payment_scenario.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from enum import Enum, unique 5 | 6 | 7 | @unique 8 | class InStorePaymentScenario(Enum): 9 | PaymentCode = "PaymentCode" 10 | OrderCode = "OrderCode" 11 | EntryCode = "EntryCode" 12 | 13 | def to_ams_dict(self): 14 | return self.name 15 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/installment.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.plan import Plan 4 | from com.alipay.ams.api.model.support_card_brand import SupportCardBrand 5 | 6 | 7 | class Installment(object): 8 | def __init__(self): 9 | self.__support_card_brands = None # type: list[SupportCardBrand] 10 | self.__plans = None # type: list[Plan] 11 | 12 | @property 13 | def support_card_brands(self): 14 | return self.__support_card_brands 15 | 16 | @support_card_brands.setter 17 | def support_card_brands(self, value): 18 | self.__support_card_brands = value 19 | 20 | @property 21 | def plans(self): 22 | return self.__plans 23 | 24 | @plans.setter 25 | def plans(self, value): 26 | self.__plans = value 27 | 28 | def parse_rsp_body(self, installment_body): 29 | if type(installment_body) == str: 30 | installment_body = json.loads(installment_body) 31 | if 'supportCardBrand' in installment_body: 32 | self.support_card_brands = installment_body.get('supportCardBrand') 33 | for support_card_brand in self.support_card_brands: 34 | support_card_brand.parse_rsp_body(support_card_brand) 35 | self.support_card_brands = support_card_brand 36 | 37 | if 'plans' in installment_body: 38 | self.plans = installment_body.get('plans') 39 | for plan in self.plans: 40 | plan.parse_rsp_body(plan) 41 | self.plans = plan 42 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/legal_entity_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class LegalEntityType(Enum): 6 | COMPANY = "COMPANY" 7 | INDIVIDUAL = "INDIVIDUAL" 8 | 9 | def to_ams_dict(self): 10 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/logo.py: -------------------------------------------------------------------------------- 1 | class Logo(object): 2 | 3 | def __init__(self): 4 | self.__logo_name = None 5 | self.__logo_url = None 6 | 7 | @property 8 | def logo_name(self): 9 | return self.__logo_name 10 | 11 | @logo_name.setter 12 | def logo_name(self, value): 13 | self.__logo_name = value 14 | 15 | @property 16 | def logo_url(self): 17 | return self.__logo_url 18 | 19 | @logo_url.setter 20 | def logo_url(self, value): 21 | self.__logo_url = value 22 | 23 | def to_ams_dict(self): 24 | params = dict() 25 | if hasattr(self, "logo_name") and self.logo_name: 26 | params['logoName'] = self.logo_name 27 | 28 | if hasattr(self, "logo_url") and self.logo_url: 29 | params['logoUrl'] = self.logo_url 30 | 31 | return params 32 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/merchant_customs_info.py: -------------------------------------------------------------------------------- 1 | class MerchantCustomsInfo(object): 2 | def __init__(self): 3 | self.merchant_customs_code = None 4 | self.__merchant_customs_name = None 5 | 6 | @property 7 | def merchant_customs_code(self): 8 | return self.__merchant_customs_code 9 | 10 | @merchant_customs_code.setter 11 | def merchant_customs_code(self, value): 12 | self.__merchant_customs_code = value 13 | 14 | @property 15 | def merchant_customs_name(self): 16 | return self.__merchant_customs_name 17 | 18 | @merchant_customs_name.setter 19 | def merchant_customs_name(self, value): 20 | self.__merchant_customs_name = value 21 | 22 | def to_ams_dict(self): 23 | params = dict() 24 | if self.merchant_customs_code is not None: 25 | params['merchantCustomsCode'] = self.merchant_customs_code 26 | if self.merchant_customs_name is not None: 27 | params['merchantCustomsName'] = self.merchant_customs_name 28 | return params 29 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/merchant_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class MerchantType(Enum): 6 | INDIVIDUAL = "INDIVIDUAL" 7 | ENTERPRISE = "ENTERPRISE" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/method_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class MethodType(Enum): 6 | GET = "GET" 7 | POST = "POST" 8 | PUT = "PUT" 9 | DELETE = "DELETE" 10 | PATCH = "PATCH" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/order_code_form.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.code_detail import CodeDetail 7 | 8 | 9 | class OrderCodeForm(object): 10 | def __init__(self): 11 | self.__payment_method_type = None 12 | self.__expire_time = None 13 | self.__code_details = None # type: list[CodeDetail] 14 | self.__extend_info = None 15 | 16 | @property 17 | def payment_method_type(self): 18 | return self.__payment_method_type 19 | 20 | @payment_method_type.setter 21 | def payment_method_type(self, value): 22 | self.__payment_method_type = value 23 | 24 | @property 25 | def expire_time(self): 26 | return self.__expire_time 27 | 28 | @expire_time.setter 29 | def expire_time(self, value): 30 | self.__expire_time = value 31 | 32 | @property 33 | def code_details(self): 34 | return self.__code_details 35 | 36 | @code_details.setter 37 | def code_details(self, value): 38 | self.__code_details = value 39 | 40 | @property 41 | def extend_info(self): 42 | return self.__extend_info 43 | 44 | @extend_info.setter 45 | def extend_info(self, value): 46 | self.__extend_info = value 47 | 48 | def parse_rsp_body(self, order_code_form_body): 49 | if type(order_code_form_body) == str: 50 | order_code_form_body = json.loads(order_code_form_body) 51 | 52 | if 'paymentMethodType' in order_code_form_body: 53 | self.__payment_method_type = order_code_form_body['paymentMethodType'] 54 | 55 | if 'expireTime' in order_code_form_body: 56 | self.__expire_time = order_code_form_body['expireTime'] 57 | 58 | if 'codeDetails' in order_code_form_body: 59 | self.__code_details = [] 60 | for entry in order_code_form_body['codeDetails']: 61 | code_detail = CodeDetail() 62 | code_detail.parse_rsp_body(entry) 63 | self.__code_details.append(code_detail) 64 | 65 | if 'extendInfo' in order_code_form_body: 66 | self.__extend_info = order_code_form_body['extendInfo'] 67 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/order_info.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.amount import Amount 4 | 5 | 6 | class OrderInfo(object): 7 | def __init__(self): 8 | self.__order_amount = None #type: Amount 9 | 10 | @property 11 | def order_amount(self): 12 | return self.__order_amount 13 | 14 | @order_amount.setter 15 | def order_amount(self, value): 16 | self.__order_amount = value 17 | 18 | def to_ams_dict(self): 19 | params = dict() 20 | if self.order_amount is not None: 21 | params['orderAmount'] = self.order_amount.to_ams_dict() 22 | return params 23 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/os_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class OsType(Enum): 8 | IOS = "IOS" 9 | ANDROID = "ANDROID" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/passengers.py: -------------------------------------------------------------------------------- 1 | class Passengers(object): 2 | def __init__(self): 3 | self.__passenger_name = None 4 | self.__passenger_email = None 5 | self.__passenger_phoneNo = None 6 | 7 | @property 8 | def passenger_name(self): 9 | return self.__passenger_name 10 | 11 | @passenger_name.setter 12 | def passenger_name(self, value): 13 | self.__passenger_name = value 14 | 15 | @property 16 | def passenger_email(self): 17 | return self.__passenger_email 18 | 19 | @passenger_email.setter 20 | def passenger_email(self, value): 21 | self.__passenger_email = value 22 | 23 | @property 24 | def passenger_phoneNo(self): 25 | return self.__passenger_phoneNo 26 | 27 | @passenger_phoneNo.setter 28 | def passenger_phoneNo(self, value): 29 | self.__passenger_phoneNo = value 30 | 31 | def to_ams_dict(self): 32 | params = dict() 33 | if hasattr(self, "passenger_name") and self.passenger_name: 34 | params['passengerName'] = self.passenger_name 35 | if hasattr(self, "passenger_email") and self.passenger_email: 36 | params['passengerEmail'] = self.passenger_email 37 | if hasattr(self, "passenger_phoneNo") and self.passenger_phoneNo: 38 | params['passengerPhoneNo'] = self.passenger_phoneNo 39 | return params 40 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/paymentOptionDetail.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.funding_type import FundingType 2 | from com.alipay.ams.api.model.support_bank import SupportBank 3 | from com.alipay.ams.api.model.support_card_brand import SupportCardBrand 4 | 5 | 6 | class PaymentOptionDetail(object): 7 | 8 | def __init__(self): 9 | self.__support_card_brands = None # type:list[SupportCardBrand] 10 | self.__funding = None # type:list[FundingType] 11 | self.__support_banks = None # type:list[SupportBank] 12 | 13 | @property 14 | def support_card_brands(self): 15 | return self.__support_card_brands 16 | 17 | @support_card_brands.setter 18 | def support_card_brands(self, value): 19 | self.__support_card_brands = value 20 | 21 | @property 22 | def funding(self): 23 | return self.__funding 24 | 25 | @funding.setter 26 | def funding(self, value): 27 | self.__funding = value 28 | 29 | @property 30 | def support_banks(self): 31 | return self.__support_banks 32 | 33 | @support_banks.setter 34 | def support_banks(self, value): 35 | self.__support_banks = value 36 | 37 | def parse_rsp_body(self, payment_option_detail_body): 38 | if payment_option_detail_body.has_key("supportCardBrands"): 39 | self.support_card_brands = payment_option_detail_body["supportCardBrands"] 40 | if payment_option_detail_body.has_key("funding"): 41 | self.funding = payment_option_detail_body["funding"] 42 | if payment_option_detail_body.has_key("supportBanks "): 43 | self.support_banks = payment_option_detail_body["supportBanks"] 44 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_detail.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.amount import Amount 2 | from com.alipay.ams.api.model.payment_method import PaymentMethod 3 | 4 | 5 | class PaymentDetail: 6 | def __init__(self): 7 | self.__amount = None #type: Amount 8 | self.__payment_method = None #type: PaymentMethod 9 | 10 | @property 11 | def amount(self): 12 | return self.__amount 13 | 14 | @amount.setter 15 | def amount(self, value): 16 | self.__amount = value 17 | 18 | @property 19 | def payment_method(self): 20 | return self.__payment_method 21 | 22 | @payment_method.setter 23 | def payment_method(self, value): 24 | self.__payment_method = value 25 | 26 | def to_ams_dict(self): 27 | params = dict() 28 | if self.amount: 29 | params['amount'] = self.amount.to_ams_dict() 30 | if self.payment_method: 31 | params['paymentMethod'] = self.payment_method.to_ams_dict() 32 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_method_category_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class PaymentMethodCategoryType(Enum): 8 | WALLET = "WALLET" 9 | CARD = "CARD" 10 | ALIPAY_PLUS = "ALIPAY_PLUS" 11 | BANK_TRANSFER = "BANK_TRANSFER" 12 | MOBILE_BANKING_APP = "MOBILE_BANKING_APP" 13 | ONLINE_BANKING = "ONLINE_BANKING" 14 | OTC = "OTC" 15 | 16 | def to_ams_dict(self): 17 | return self.name 18 | 19 | @staticmethod 20 | def value_of(value): 21 | if not value: 22 | return None 23 | 24 | if PaymentMethodCategoryType.WALLET.value == value: 25 | return PaymentMethodCategoryType.WALLET 26 | elif PaymentMethodCategoryType.CARD.value == value: 27 | return PaymentMethodCategoryType.CARD 28 | else: 29 | return None 30 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_method_detail_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class PaymentMethodDetailType(Enum): 8 | CARD = "CARD" 9 | EXTERNALACCOUNT = "EXTERNALACCOUNT" 10 | COUPON = "COUPON" 11 | DISCOUNT = "DISCOUNT" 12 | 13 | def to_ams_dict(self): 14 | return self.name 15 | 16 | @staticmethod 17 | def value_of(value): 18 | if not value: 19 | return None 20 | 21 | if PaymentMethodDetailType.CARD.value == value: 22 | return PaymentMethodDetailType.CARD 23 | elif PaymentMethodDetailType.EXTERNALACCOUNT.value == value: 24 | return PaymentMethodDetailType.EXTERNALACCOUNT 25 | elif PaymentMethodDetailType.COUPON.value == value: 26 | return PaymentMethodDetailType.COUPON 27 | elif PaymentMethodDetailType.DISCOUNT.value == value: 28 | return PaymentMethodDetailType.DISCOUNT 29 | else: 30 | return None 31 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_method_info.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | 7 | class PaymentMethodInfo(object): 8 | 9 | def __init__(self): 10 | self.__payment_method_type = None 11 | self.__payment_method_detail = None 12 | self.__enabled = None 13 | self.__preferred = None 14 | self.__extend_info = None 15 | 16 | @property 17 | def payment_method_type(self): 18 | return self.__payment_method_type 19 | 20 | @property 21 | def payment_method_detail(self): 22 | return self.__payment_method_detail 23 | 24 | @property 25 | def enabled(self): 26 | return self.__enabled 27 | 28 | @property 29 | def preferred(self): 30 | return self.__preferred 31 | 32 | @property 33 | def extend_info(self): 34 | return self.__extend_info 35 | 36 | def parse_rsp_body(self, payment_method_info_body): 37 | if type(payment_method_info_body) == str: 38 | payment_method_info_body = json.loads(payment_method_info_body) 39 | 40 | if 'paymentMethodType' in payment_method_info_body: 41 | self.__payment_method_type = payment_method_info_body['paymentMethodType'] 42 | 43 | if 'paymentMethodDetail' in payment_method_info_body: 44 | self.__payment_method_detail = payment_method_info_body['paymentMethodDetail'] 45 | 46 | if 'enabled' in payment_method_info_body: 47 | self.__enabled = payment_method_info_body['enabled'] 48 | 49 | if 'preferred' in payment_method_info_body: 50 | self.__preferred = payment_method_info_body['preferred'] 51 | 52 | if 'extendInfo' in payment_method_info_body: 53 | self.__extend_info = payment_method_info_body['extendInfo'] 54 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_method_type.py: -------------------------------------------------------------------------------- 1 | 2 | from enum import Enum, unique 3 | 4 | 5 | @unique 6 | class PaymentMethodType(Enum): 7 | DISCOUNT = "DISCOUNT" 8 | INTEREST_FREE = "INTEREST_FREE" 9 | BALANCE_ACCOUNT = "BALANCE_ACCOUNT" 10 | SETTLEMENT_CARD = "SETTLEMENT_CARD" 11 | APPLEPAY = "APPLEPAY" 12 | UPI = "UPI" 13 | ONLINEBANKING_NETBANKING = "ONLINEBANKING_NETBANKING" 14 | 15 | def to_ams_dict(self): 16 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_method_type_item.py: -------------------------------------------------------------------------------- 1 | class PaymentMethodTypeItem: 2 | 3 | def __init__(self): 4 | self.__payment_method_type = None 5 | self.__payment_method_order = None 6 | self.__express_checkout = None 7 | 8 | @property 9 | def payment_method_type(self): 10 | return self.__payment_method_type 11 | 12 | @payment_method_type.setter 13 | def payment_method_type(self, value): 14 | self.__payment_method_type = value 15 | 16 | @property 17 | def payment_method_order(self): 18 | return self.__payment_method_order 19 | 20 | @payment_method_order.setter 21 | def payment_method_order(self, value): 22 | self.__payment_method_order = value 23 | 24 | @property 25 | def express_checkout(self): 26 | return self.__express_checkout 27 | 28 | @express_checkout.setter 29 | def express_checkout(self, value): 30 | self.__express_checkout = value 31 | 32 | def to_ams_dict(self): 33 | params = dict() 34 | if hasattr(self, "payment_method_type") and self.payment_method_type: 35 | params['paymentMethodType'] = self.payment_method_type 36 | if hasattr(self, "payment_method_order") and self.payment_method_order: 37 | params['paymentMethodOrder'] = self.payment_method_order 38 | if hasattr(self, "express_checkout") and self.express_checkout: 39 | params['expressCheckout'] = self.express_checkout.to_ams_dict() 40 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/payment_verification_data.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | 5 | class PaymentVerificationData(object): 6 | def __init__(self): 7 | self.__verify_request_id = None 8 | self.__authentication_code = None 9 | 10 | @property 11 | def verify_request_id(self): 12 | return self.__verify_request_id 13 | 14 | @verify_request_id.setter 15 | def verify_request_id(self, value): 16 | self.__verify_request_id = value 17 | 18 | @property 19 | def authentication_code(self): 20 | return self.__authentication_code 21 | 22 | @authentication_code.setter 23 | def authentication_code(self, value): 24 | self.__authentication_code = value 25 | 26 | def to_ams_dict(self): 27 | params = dict() 28 | if hasattr(self, "verify_request_id") and self.verify_request_id: 29 | params['verifyRequestId'] = self.verify_request_id 30 | 31 | if hasattr(self, "authentication_code") and self.authentication_code: 32 | params['authenticationCode'] = self.authentication_code 33 | 34 | return params 35 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/period_rule.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.period_type import PeriodType 4 | 5 | 6 | class PeriodRule(object): 7 | def __init__(self): 8 | self.__period_type = None #type: PeriodType 9 | self.__period_count = None 10 | 11 | @property 12 | def period_type(self): 13 | return self.__period_type 14 | 15 | @period_type.setter 16 | def period_type(self, value): 17 | self.__period_type = value 18 | 19 | @property 20 | def period_count(self): 21 | return self.__period_count 22 | 23 | @period_count.setter 24 | def period_count(self, value): 25 | self.__period_count = value 26 | 27 | 28 | def to_ams_dict(self): 29 | params = dict() 30 | if hasattr(self, "period_type") and self.period_type: 31 | params['periodType'] = self.period_type 32 | if hasattr(self, "period_count") and self.period_count: 33 | params['periodCount'] = self.period_count 34 | 35 | return params 36 | 37 | def parse_rsp_body(self, result_body): 38 | if type(result_body) == str: 39 | result_body = json.loads(result_body) 40 | 41 | if 'periodType' in result_body: 42 | self.__period_type = result_body['periodType'] 43 | if 'periodCount' in result_body: 44 | self.__period_count = result_body['periodCount'] 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/period_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class PeriodType(Enum): 6 | DAY = "DAY" 7 | WEEK = "WEEK" 8 | MONTH = "MONTH" 9 | YEAR = "YEAR" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/presentment_mode.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class PresentmentMode(Enum): 6 | BUNDLE = "BUNDLE" 7 | TILED = "TILED" 8 | UNIFIED = "UNIFIED" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/product_code_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class ProductCodeType(Enum): 8 | AGREEMENT_PAYMENT = "AGREEMENT_PAYMENT" 9 | IN_STORE_PAYMENT = "IN_STORE_PAYMENT" 10 | CASHIER_PAYMENT = "CASHIER_PAYMENT" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/promotion_result.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.discount import Discount 4 | from com.alipay.ams.api.model.promotion_type import PromotionType 5 | 6 | 7 | class PromotionResult(object): 8 | 9 | def __init__(self): 10 | self.__promotion_type = None # type:PromotionType 11 | self.__discount = None # type:Discount 12 | 13 | @property 14 | def promotion_type(self): 15 | return self.__promotion_type 16 | 17 | @promotion_type.setter 18 | def promotion_type(self, promotion_type): 19 | self.__promotion_type = promotion_type 20 | 21 | @property 22 | def discount(self): 23 | return self.__discount 24 | 25 | @discount.setter 26 | def discount(self, discount): 27 | self.__discount = discount 28 | 29 | def to_ams_dict(self): 30 | params = dict() 31 | if hasattr(self, "promotion_type") and self.promotion_type: 32 | params['promotionType'] = self.promotion_type 33 | 34 | if hasattr(self, "discount") and self.discount: 35 | params['discount'] = self.discount 36 | 37 | return params 38 | 39 | def parse_rsp_body(self, promotion_result_body): 40 | if type(promotion_result_body) == str: 41 | promotion_result_body = json.loads(promotion_result_body) 42 | 43 | if 'promotionType' in promotion_result_body: 44 | self.promotion_type = promotion_result_body['promotionType'] 45 | 46 | if 'discount' in promotion_result_body: 47 | discount_result = Discount() 48 | discount_result.parse_rsp_body(promotion_result_body['discount']) 49 | self.__promotion_result = discount_result 50 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/promotion_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class PromotionType(Enum): 6 | DISCOUNT = "DISCOUNT" 7 | INTEREST_FREE = "INTEREST_FREE" 8 | 9 | def to_ams_dict(self): 10 | return self.name 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/redirect_action_form.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.method_type import MethodType 7 | 8 | 9 | class RedirectActionForm(object): 10 | 11 | def __init__(self): 12 | self.__method = None # type:MethodType 13 | self.__parameters = None 14 | self.__redirect_url = None 15 | self.__action_form_type = None 16 | 17 | @property 18 | def method(self): 19 | return self.__method 20 | 21 | @method.setter 22 | def method(self, value): 23 | self.__method = value 24 | 25 | @property 26 | def parameters(self): 27 | return self.__parameters 28 | 29 | @parameters.setter 30 | def parameters(self, value): 31 | self.__parameters = value 32 | 33 | @property 34 | def redirect_url(self): 35 | return self.__redirect_url 36 | 37 | @redirect_url.setter 38 | def redirect_url(self, value): 39 | self.__redirect_url = value 40 | 41 | @property 42 | def action_form_type(self): 43 | return self.__action_form_type 44 | 45 | @action_form_type.setter 46 | def action_form_type(self, value): 47 | self.__action_form_type = value 48 | 49 | def parse_rsp_body(self, redirect_action_form_body): 50 | if type(redirect_action_form_body) == str: 51 | redirect_action_form_body = json.loads(redirect_action_form_body) 52 | 53 | if 'method' in redirect_action_form_body: 54 | self.__method = redirect_action_form_body['method'] 55 | 56 | if 'parameters' in redirect_action_form_body: 57 | self.__parameters = redirect_action_form_body['parameters'] 58 | 59 | if 'redirectUrl' in redirect_action_form_body: 60 | self.__redirect_url = redirect_action_form_body['redirectUrl'] 61 | 62 | if 'actionFormType' in redirect_action_form_body: 63 | self.__action_form_type = redirect_action_form_body['actionFormType'] 64 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/refund_detail.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.amount import Amount 4 | from com.alipay.ams.api.model.refund_from_type import RefundFromType 5 | 6 | 7 | class RefundDetail(object): 8 | def __init__(self): 9 | self.__refund_amount = None # type:Amount 10 | self.__refund_from = None # type:RefundFromType 11 | 12 | @property 13 | def refund_amount(self): 14 | return self.__refund_amount 15 | 16 | @refund_amount.setter 17 | def refund_amount(self, value): 18 | self.__refund_amount = value 19 | 20 | @property 21 | def refund_from(self): 22 | return self.__refund_from 23 | 24 | @refund_from.setter 25 | def refund_from(self, value): 26 | self.__refund_from = value 27 | 28 | def parse_rsp_body(self, quote_body): 29 | if type(quote_body) == str: 30 | quote_body = json.loads(quote_body) 31 | if 'refundAmount' in quote_body: 32 | self.__refund_amount = Amount() 33 | self.__refund_amount.parse_rsp_body(quote_body['refundAmount']) 34 | if 'refundFrom' in quote_body: 35 | self.__refund_from = quote_body['refundFrom'] 36 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/refund_from_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class RefundFromType(Enum): 6 | SELLER = "SELLER" 7 | MARKETPLACE = "MARKETPLACE" 8 | UNSETTLED_FUNDS = "UNSETTLED_FUNDS" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/refund_record.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.amount import Amount 2 | 3 | 4 | class RefundRecord: 5 | def __init__(self): 6 | self.__reference_order_id = None 7 | self.__reference_goods_id = None 8 | self.__amount = None #type: Amount 9 | self.__refund_reason = None 10 | self.__refund_time = None 11 | 12 | @property 13 | def reference_order_id(self): 14 | return self.__reference_order_id 15 | 16 | @reference_order_id.setter 17 | def reference_order_id(self, value): 18 | self.__reference_order_id = value 19 | 20 | @property 21 | def reference_goods_id(self): 22 | return self.__reference_goods_id 23 | 24 | @reference_goods_id.setter 25 | def reference_goods_id(self, value): 26 | self.__reference_goods_id = value 27 | 28 | @property 29 | def amount(self): 30 | return self.__amount 31 | 32 | @amount.setter 33 | def amount(self, value): 34 | self.__amount = value 35 | 36 | @property 37 | def refund_reason(self): 38 | return self.__refund_reason 39 | 40 | @refund_reason.setter 41 | def refund_reason(self, value): 42 | self.__refund_reason = value 43 | 44 | @property 45 | def refund_time(self): 46 | return self.__refund_time 47 | 48 | @refund_time.setter 49 | def refund_time(self, value ): 50 | self.__refund_time = value 51 | 52 | 53 | def to_ams_dict(self): 54 | params = dict() 55 | if self.__reference_order_id is not None: 56 | params['referenceOrderId'] = self.__reference_order_id 57 | if self.__reference_goods_id is not None: 58 | params['referenceGoodsId'] = self.__reference_goods_id 59 | if self.__amount is not None: 60 | params['amount'] = self.__amount.to_ams_dict() 61 | if self.__refund_reason is not None: 62 | params['refundReason'] = self.__refund_reason 63 | if self.__refund_time is not None: 64 | params['refundTime'] = self.__refund_time 65 | 66 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/result.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.result_status_type import ResultStatusType 7 | 8 | 9 | class Result(object): 10 | def __init__(self): 11 | self.__result_code = None 12 | self.__result_message = None 13 | self.__result_status = None 14 | 15 | @property 16 | def result_code(self): 17 | return self.__result_code 18 | 19 | @property 20 | def result_message(self): 21 | return self.__result_message 22 | 23 | @property 24 | def result_status(self): 25 | return self.__result_status 26 | 27 | def parse_rsp_body(self, result_body): 28 | if type(result_body) == str: 29 | result_body = json.loads(result_body) 30 | 31 | if 'resultCode' in result_body: 32 | self.__result_code = result_body['resultCode'] 33 | 34 | if 'resultMessage' in result_body: 35 | self.__result_message = result_body['resultMessage'] 36 | 37 | if 'resultStatus' in result_body: 38 | result_status = ResultStatusType.value_of(result_body['resultStatus']) 39 | self.__result_status = result_status 40 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/result_status_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class ResultStatusType(Enum): 8 | S = "S" 9 | F = "F" 10 | U = "U" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | 15 | @staticmethod 16 | def value_of(value): 17 | if not value: 18 | return None 19 | 20 | if ResultStatusType.S.value == value: 21 | return ResultStatusType.S 22 | elif ResultStatusType.F.value == value: 23 | return ResultStatusType.F 24 | elif ResultStatusType.U.value == value: 25 | return ResultStatusType.U 26 | else: 27 | return None 28 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/risk_score_detail.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | 7 | class RiskScoreDetail(object): 8 | 9 | def __init__(self): 10 | self.__risk_info_code = None 11 | self.__risk_info_code_result = None 12 | 13 | @property 14 | def risk_info_code(self): 15 | return self.__risk_info_code 16 | 17 | @risk_info_code.setter 18 | def risk_info_code(self, value): 19 | self.__risk_info_code = value 20 | 21 | @property 22 | def risk_info_code_result(self): 23 | return self.__risk_info_code_result 24 | 25 | @risk_info_code_result.setter 26 | def risk_info_code_result(self, value): 27 | self.__risk_info_code_result = value 28 | 29 | def parse_rsp_body(self, risk_score_detail_body): 30 | if type(risk_score_detail_body) == str: 31 | risk_score_detail_body = json.loads(risk_score_detail_body) 32 | 33 | if 'riskInfoCode' in risk_score_detail_body: 34 | self.__risk_info_code = risk_score_detail_body['riskInfoCode'] 35 | 36 | if 'riskInfoCodeResult' in risk_score_detail_body: 37 | self.__risk_info_code_result = risk_score_detail_body['riskInfoCodeResult'] 38 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/risk_score_result.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.risk_score_detail import RiskScoreDetail 7 | from com.alipay.ams.api.model.risk_score_type import RiskScoreType 8 | 9 | 10 | class RiskScoreResult(object): 11 | 12 | def __init__(self): 13 | self.__risk_score_type = None # type: RiskScoreType 14 | self.__risk_score = None 15 | self.__risk_score_details = None # type: list[RiskScoreDetail] 16 | 17 | @property 18 | def risk_score_type(self): 19 | return self.__risk_score_type 20 | 21 | @risk_score_type.setter 22 | def risk_score_type(self, value): 23 | self.__risk_score_type = value 24 | 25 | @property 26 | def risk_score(self): 27 | return self.__risk_score 28 | 29 | @risk_score.setter 30 | def risk_score(self, value): 31 | self.__risk_score = value 32 | 33 | @property 34 | def risk_score_details(self): 35 | return self.__risk_score_details 36 | 37 | @risk_score_details.setter 38 | def risk_score_details(self, value): 39 | self.__risk_score_details = value 40 | 41 | def parse_rsp_body(self, risk_score_result_body): 42 | if type(risk_score_result_body) == str: 43 | risk_score_result_body = json.loads(risk_score_result_body) 44 | 45 | if 'riskScoreType' in risk_score_result_body: 46 | risk_score_type = RiskScoreType.value_of(risk_score_result_body['riskScoreType']) 47 | self.__risk_score_type = risk_score_type 48 | 49 | if 'riskScore' in risk_score_result_body: 50 | self.__risk_score = risk_score_result_body['riskScore'] 51 | 52 | if 'riskScoreDetails' in risk_score_result_body: 53 | self.__risk_score_details = [] 54 | for entry in risk_score_result_body['riskScoreDetails']: 55 | risk_score_detail = RiskScoreDetail() 56 | risk_score_detail.parse_rsp_body(entry) 57 | self.__risk_score_details.append(risk_score_detail) 58 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/risk_score_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class RiskScoreType(Enum): 8 | NSF_SCORE = "NSF_SCORE" 9 | FRAUD_SCORE = "FRAUD_SCORE" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | 14 | @staticmethod 15 | def value_of(value): 16 | if not value: 17 | return None 18 | 19 | if RiskScoreType.NSF_SCORE.value == value: 20 | return RiskScoreType.NSF_SCORE 21 | elif RiskScoreType.FRAUD_SCORE.value == value: 22 | return RiskScoreType.FRAUD_SCORE 23 | else: 24 | return None 25 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/scope_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class ScopeType(Enum): 8 | BASE_USER_INFO = "BASE_USER_INFO" 9 | AGREEMENT_PAY = "AGREEMENT_PAY" 10 | USER_INFO = "USER_INFO" 11 | USER_LOGIN_ID = "USER_LOGIN_ID" 12 | HASH_LOGIN_ID = "HASH_LOGIN_ID" 13 | SEND_OTP = "SEND_OTP" 14 | TAOBAO_REBIND = "TAOBAO_REBIND" 15 | 16 | def to_ams_dict(self): 17 | return self.name 18 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/settle_to_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class SettleToType(Enum): 6 | SELLER = "SELLER" 7 | MARKETPLACE = "MARKETPLACE" 8 | 9 | def to_ams_dict(self): 10 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/settlement_detail.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.amount import Amount 2 | from com.alipay.ams.api.model.settle_to_type import SettleToType 3 | 4 | 5 | class SettlementDetail: 6 | def __init__(self): 7 | self.__settle_to = None #type: SettleToType 8 | self.__settlement_amount = None #type: Amount 9 | 10 | @property 11 | def settle_to(self): 12 | return self.__settle_to 13 | 14 | @settle_to.setter 15 | def settle_to(self, value): 16 | self.__settle_to = value 17 | 18 | @property 19 | def settlement_amount(self): 20 | return self.__settlement_amount 21 | 22 | @settlement_amount.setter 23 | def settlement_amount(self, value): 24 | self.__settlement_amount = value 25 | 26 | def to_ams_dict(self): 27 | params = dict() 28 | if hasattr(self, 'settle_to') and self.settle_to: 29 | params['settleTo'] = self.settle_to.value 30 | if hasattr(self, 'settlement_amount') and self.settlement_amount: 31 | params['settlementAmount'] = self.settlement_amount.to_ams_dict() 32 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/settlement_info.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.settlement_bank_account import SettlementBankAccount 2 | 3 | 4 | class SettlementInfo: 5 | def __init__(self): 6 | self.__settlement_currency = None 7 | self.__settlement_bank_account = None #type: SettlementBankAccount 8 | 9 | @property 10 | def settlement_currency(self): 11 | return self.__settlement_currency 12 | 13 | @settlement_currency.setter 14 | def settlement_currency(self, value): 15 | self.__settlement_currency = value 16 | 17 | @property 18 | def settlement_bank_account(self): 19 | return self.__settlement_bank_account 20 | 21 | @settlement_bank_account.setter 22 | def settlement_bank_account(self, value): 23 | self.__settlement_bank_account = value 24 | 25 | def to_ams_dict(self): 26 | params = dict() 27 | if hasattr(self, 'settlement_currency') and self.settlement_currency: 28 | params['settlementCurrency'] = self.settlement_currency 29 | if hasattr(self, 'settlement_bank_account') and self.settlement_bank_account: 30 | params['settlementBankAccount'] = self.settlement_bank_account.to_ams_dict() 31 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/settlement_strategy.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | 5 | class SettlementStrategy(object): 6 | def __init__(self): 7 | self.__settlement_currency = None 8 | 9 | @property 10 | def settlement_currency(self): 11 | return self.__settlement_currency 12 | 13 | @settlement_currency.setter 14 | def settlement_currency(self, value): 15 | self.__settlement_currency = value 16 | 17 | def to_ams_dict(self): 18 | params = dict() 19 | if hasattr(self, "settlement_currency") and self.settlement_currency: 20 | params['settlementCurrency'] = self.settlement_currency 21 | 22 | return params 23 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/shipping.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from com.alipay.ams.api.model.address import Address 4 | from com.alipay.ams.api.model.user_name import UserName 5 | 6 | 7 | class Shipping(object): 8 | 9 | def __init__(self): 10 | self.__shipping_name = None # type:UserName 11 | self.__shipping_address = None # type:Address 12 | self.__shipping_carrier = None 13 | self.__shipping_phone_no = None 14 | 15 | @property 16 | def shipping_name(self): 17 | return self.__shipping_name 18 | 19 | @shipping_name.setter 20 | def shipping_name(self, value): 21 | self.__shipping_name = value 22 | 23 | @property 24 | def shipping_address(self): 25 | return self.__shipping_address 26 | 27 | @shipping_address.setter 28 | def shipping_address(self, value): 29 | self.__shipping_address = value 30 | 31 | @property 32 | def shipping_carrier(self): 33 | return self.__shipping_carrier 34 | 35 | @shipping_carrier.setter 36 | def shipping_carrier(self, value): 37 | self.__shipping_carrier = value 38 | 39 | @property 40 | def shipping_phone_no(self): 41 | return self.__shipping_phone_no 42 | 43 | @shipping_phone_no.setter 44 | def shipping_phone_no(self, value): 45 | self.__shipping_phone_no = value 46 | 47 | def to_ams_dict(self): 48 | params = dict() 49 | if hasattr(self, "shipping_name") and self.shipping_name: 50 | params['shippingName'] = self.shipping_name 51 | 52 | if hasattr(self, "shipping_address") and self.shipping_address: 53 | params['shippingAddress'] = self.shipping_address 54 | 55 | if hasattr(self, "shipping_carrier") and self.shipping_carrier: 56 | params['shippingCarrier'] = self.shipping_carrier 57 | 58 | if hasattr(self, "shipping_phone_no") and self.shipping_phone_no: 59 | params['shippingPhoneNo'] = self.shipping_phone_no 60 | 61 | return params 62 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/stock_info.py: -------------------------------------------------------------------------------- 1 | 2 | class StockInfo: 3 | def __init__(self): 4 | self.__listed_region = None 5 | self.__ticker_symbol = None 6 | 7 | def get_listed_region(self): 8 | return self.__listed_region 9 | 10 | def set_listed_region(self, listed_region): 11 | self.__listed_region = listed_region 12 | 13 | def get_ticker_symbol(self): 14 | return self.__ticker_symbol 15 | 16 | def set_ticker_symbol(self, ticker_symbol): 17 | self.__ticker_symbol = ticker_symbol 18 | 19 | 20 | def to_ams_dict(self): 21 | params = dict() 22 | if hasattr(self, 'listed_region') and self.listed_region: 23 | params['listedRegion'] = self.listed_region 24 | if hasattr(self, 'ticker_symbol') and self.ticker_symbol: 25 | params['tickerSymbol'] = self.ticker_symbol 26 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/model/subscription_notification_type.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class SubscriptionNotificationType(Enum): 8 | CREATE = "CREATE" 9 | CHANGE = "CHANGE" 10 | CANCEL = "CANCEL" 11 | TERMINATE = "TERMINATE" 12 | 13 | def to_ams_dict(self): 14 | return self.name -------------------------------------------------------------------------------- /com/alipay/ams/api/model/subscription_status.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class SubscriptionStatus(Enum): 8 | ACTIVE = "ACTIVE" 9 | TERMINATED = "TERMINATED" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/support_bank.py: -------------------------------------------------------------------------------- 1 | class SupportBank(object): 2 | def __init__(self): 3 | self.__bank_identifier_code = None 4 | self.__bank_short_name = None 5 | self.__bank_logo = None 6 | 7 | @property 8 | def bank_identifier_code(self): 9 | return self.__bank_identifier_code 10 | 11 | @bank_identifier_code.setter 12 | def bank_identifier_code(self, value): 13 | self.__bank_identifier_code = value 14 | 15 | @property 16 | def bank_short_name(self): 17 | return self.__bank_short_name 18 | 19 | @bank_short_name.setter 20 | def bank_short_name(self, value): 21 | self.__bank_short_name = value 22 | 23 | @property 24 | def bank_logo(self): 25 | return self.__bank_logo 26 | 27 | @bank_logo.setter 28 | def bank_logo(self, value): 29 | self.__bank_logo = value 30 | 31 | def to_ams_dict(self): 32 | params = dict() 33 | if self.__bank_identifier_code is not None: 34 | params['bankIdentifierCode'] = self.__bank_identifier_code 35 | if self.__bank_short_name is not None: 36 | params['bankShortName'] = self.__bank_short_name 37 | if self.__bank_logo is not None: 38 | params['bankLogo'] = self.__bank_logo 39 | return params 40 | 41 | def parse_rsp_body(self, support_bank_body): 42 | if support_bank_body is None: 43 | return 44 | if 'bankIdentifierCode' in support_bank_body: 45 | self.bank_identifier_code = support_bank_body['bankIdentifierCode'] 46 | if 'bankShortName' in support_bank_body: 47 | self.bank_short_name = support_bank_body['bankShortName'] 48 | if 'bankLogo' in support_bank_body: 49 | self.bank_logo = support_bank_body['bankLogo'] 50 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/support_card_brand.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.card_brand_type import CardBrandType 2 | from com.alipay.ams.api.model.logo import Logo 3 | 4 | 5 | class SupportCardBrand(object): 6 | def __init__(self): 7 | self.__card_brand = None # type: CardBrandType 8 | self.__logo = None # type: Logo 9 | 10 | @property 11 | def card_brand(self): 12 | return self.__card_brand 13 | 14 | @card_brand.setter 15 | def card_brand(self, value): 16 | self.__card_brand = value 17 | 18 | @property 19 | def logo(self): 20 | return self.__logo 21 | 22 | @logo.setter 23 | def logo(self, value): 24 | self.__logo = value 25 | 26 | def to_ams_dict(self): 27 | params = dict() 28 | if hasattr(self, "card_brand") and self.card_brand: 29 | params['cardBrandType'] = self.card_brand.value 30 | if hasattr(self, "logo") and self.logo: 31 | params['logo'] = self.logo.to_ams_dict() 32 | return params 33 | 34 | def parse_rsp_body(self, support_card_brand_body): 35 | if support_card_brand_body.get('cardBrandType'): 36 | self.card_brand = CardBrandType(support_card_brand_body.get('cardBrandType')) 37 | if support_card_brand_body.get('logo'): 38 | self.logo = Logo() 39 | self.logo.to_ams_dict() 40 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/terminal_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class TerminalType(Enum): 8 | WEB = "WEB" 9 | WAP = "WAP" 10 | APP = "APP" 11 | 12 | def to_ams_dict(self): 13 | return self.name 14 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/transaction_status_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class TransactionStatusType(Enum): 8 | SUCCESS = "SUCCESS" 9 | FAIL = "FAIL" 10 | PROCESSING = "PROCESSING" 11 | CANCELLED = "CANCELLED" 12 | PENDING = "PENDING" 13 | 14 | def to_ams_dict(self): 15 | return self.name 16 | 17 | @staticmethod 18 | def value_of(value): 19 | if not value: 20 | return None 21 | 22 | if TransactionStatusType.SUCCESS.value == value: 23 | return TransactionStatusType.SUCCESS 24 | elif TransactionStatusType.FAIL.value == value: 25 | return TransactionStatusType.FAIL 26 | elif TransactionStatusType.PROCESSING.value == value: 27 | return TransactionStatusType.PROCESSING 28 | elif TransactionStatusType.CANCELLED.value == value: 29 | return TransactionStatusType.CANCELLED 30 | elif TransactionStatusType.PENDING.value == value: 31 | return TransactionStatusType.PENDING 32 | else: 33 | return None 34 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/transaction_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class TransactionType(Enum): 8 | PAYMENT = "PAYMENT" 9 | REFUND = "REFUND" 10 | CAPTURE = "CAPTURE" 11 | CANCEL = "CANCEL" 12 | AUTHORIZATION = "AUTHORIZATION" 13 | VOID = "VOID" 14 | 15 | def to_ams_dict(self): 16 | return self.name 17 | 18 | @staticmethod 19 | def value_of(value): 20 | if not value: 21 | return None 22 | 23 | if TransactionType.PAYMENT.value == value: 24 | return TransactionType.PAYMENT 25 | elif TransactionType.REFUND.value == value: 26 | return TransactionType.REFUND 27 | elif TransactionType.CAPTURE.value == value: 28 | return TransactionType.CAPTURE 29 | elif TransactionType.CANCEL.value == value: 30 | return TransactionType.CANCEL 31 | elif TransactionType.AUTHORIZATION.value == value: 32 | return TransactionType.AUTHORIZATION 33 | elif TransactionType.VOID.value == value: 34 | return TransactionType.VOID 35 | else: 36 | return None 37 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/transfer_from_detail.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.amount import Amount 4 | from com.alipay.ams.api.model.payment_method import PaymentMethod 5 | 6 | 7 | class TransferFromDetail: 8 | def __init__(self): 9 | self.__transfer_from_method = None #type: PaymentMethod 10 | self.__transfer_from_amount = None #type: Amount 11 | 12 | 13 | @property 14 | def transfer_from_method(self): 15 | return self.__transfer_from_method 16 | 17 | @property 18 | def transfer_from_amount(self): 19 | return self.__transfer_from_amount 20 | 21 | @transfer_from_method.setter 22 | def transfer_from_method(self, value): 23 | self.__transfer_from_method = value 24 | 25 | @transfer_from_amount.setter 26 | def transfer_from_amount(self, value): 27 | self.__transfer_from_amount = value 28 | 29 | def to_ams_dict(self): 30 | params = dict() 31 | if hasattr(self, "transfer_from_method") and self.transfer_from_method: 32 | params['transferFromMethod'] = self.transfer_from_method.to_ams_dict() 33 | if hasattr(self, "transfer_from_amount") and self.transfer_from_amount: 34 | params['transferFromAmount'] = self.transfer_from_amount.to_ams_dict() 35 | return params 36 | 37 | def parse_rsp_body(self, response_body): 38 | if type(response_body) == str: 39 | response_body = json.loads(response_body) 40 | 41 | if 'transferFromMethod' in response_body: 42 | self.transfer_from_method.parse_rsp_body(response_body['transferFromMethod']) 43 | if 'transferFromAmount' in response_body: 44 | self.transfer_from_amount.parse_rsp_body(response_body['transferFromAmount']) 45 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/transit.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.transit_type import TransitType 2 | 3 | 4 | class Transit: 5 | 6 | def __init__(self): 7 | self.__transit_type = None # type: TransitType 8 | self.__legs = None 9 | self.__passengers = None 10 | 11 | @property 12 | def transit_type(self): 13 | return self.__transit_type 14 | 15 | @transit_type.setter 16 | def transit_type(self, value): 17 | self.__transit_type = value 18 | 19 | @property 20 | def legs(self): 21 | return self.__legs 22 | 23 | @legs.setter 24 | def legs(self, value): 25 | self.__legs = value 26 | 27 | @property 28 | def passengers(self): 29 | return self.__passengers 30 | 31 | @passengers.setter 32 | def passengers(self, value): 33 | self.__passengers = value 34 | 35 | def to_ams_dict(self): 36 | params = dict() 37 | if hasattr(self, "transit_type") and self.transit_type: 38 | params['transitType'] = self.transit_type 39 | 40 | if hasattr(self, "legs") and self.legs: 41 | params['legs'] = self.legs 42 | 43 | if hasattr(self, "passengers") and self.passengers: 44 | params['passengers'] = self.passengers 45 | 46 | return params 47 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/transit_type.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, unique 2 | 3 | 4 | @unique 5 | class TransitType(Enum): 6 | FLIGHT = "FLIGHT" 7 | TRAIN = "TRAIN" 8 | CRUISE = "CRUISE" 9 | COACH = "COACH" 10 | 11 | def to_ams_dict(self): 12 | return self.name 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/trial.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | 4 | class Trial(object): 5 | def __init__(self): 6 | self.__trial_start_period = None 7 | self.__trial_amount = None 8 | self.__trial_end_period = None 9 | 10 | @property 11 | def trial_start_period(self): 12 | return self.__trial_start_period 13 | 14 | @trial_start_period.setter 15 | def trial_start_period(self, value): 16 | self.__trial_start_period = value 17 | 18 | @property 19 | def trial_amount(self): 20 | return self.__trial_amount 21 | 22 | @trial_amount.setter 23 | def trial_amount(self, value): 24 | self.__trial_amount = value 25 | 26 | @property 27 | def trial_end_period(self): 28 | return self.__trial_end_period 29 | 30 | @trial_end_period.setter 31 | def trial_end_period(self, value): 32 | self.__trial_end_period = value 33 | 34 | def to_ams_json(self): 35 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 36 | return json_str 37 | 38 | def __to_ams_dict(self): 39 | params = dict() 40 | if self.__trial_start_period is not None: 41 | params['trialStartPeriod'] = self.__trial_start_period 42 | if self.__trial_amount is not None: 43 | params['trialAmount'] = self.__trial_amount 44 | if self.__trial_end_period is not None: 45 | params['trialEndPeriod'] = self.__trial_end_period 46 | 47 | return params 48 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/user_identity_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class UserIdentityType(Enum): 8 | WALLET_TOKEN = "WALLET_TOKEN" 9 | 10 | def to_ams_dict(self): 11 | return self.name 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/wallet_payment_method_type.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from enum import Enum, unique 4 | 5 | 6 | @unique 7 | class WalletPaymentMethodType(Enum): 8 | TRUEMONEY = "TRUEMONEY" 9 | ALIPAY_HK = "ALIPAY_HK" 10 | TNG = "TNG" 11 | ALIPAY_CN = "ALIPAY_CN" 12 | GCASH = "GCASH" 13 | DANA = "DANA" 14 | KAKAOPAY = "KAKAOPAY" 15 | BKASH = "BKASH" 16 | EASYPAISA = "EASYPAISA" 17 | CONNECT_WALLET = "CONNECT_WALLET" 18 | 19 | def to_ams_dict(self): 20 | return self.name 21 | -------------------------------------------------------------------------------- /com/alipay/ams/api/model/web_site.py: -------------------------------------------------------------------------------- 1 | class WebSite(object): 2 | def __init__(self): 3 | self.__name = None 4 | self.__url = None 5 | self.__desc = None 6 | self.__type = None 7 | 8 | @property 9 | def name(self): 10 | return self.__name 11 | 12 | @name.setter 13 | def name(self, value): 14 | self.__name = value 15 | 16 | @property 17 | def url(self): 18 | return self.__url 19 | 20 | @url.setter 21 | def url(self, value): 22 | self.__url = value 23 | 24 | @property 25 | def desc(self): 26 | return self.__desc 27 | 28 | @desc.setter 29 | def desc(self, value): 30 | self.__desc = value 31 | 32 | @property 33 | def type(self): 34 | return self.__type 35 | 36 | @type.setter 37 | def type(self, value): 38 | self.__type = value 39 | 40 | def to_ams_dict(self): 41 | params = dict() 42 | if hasattr(self, "name") and self.name: 43 | params['name'] = self.name 44 | 45 | if hasattr(self, "url") and self.url: 46 | params['url'] = self.url 47 | 48 | if hasattr(self, "desc") and self.desc: 49 | params['desc'] = self.desc 50 | 51 | if hasattr(self, "type") and self.type: 52 | params['type'] = self.type 53 | 54 | return params 55 | -------------------------------------------------------------------------------- /com/alipay/ams/api/net/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/net/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/net/default_http_rpc.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import ssl 5 | 6 | ''' 7 | python2中是httplib，python3中是http.client 8 | ''' 9 | try: 10 | import http.client as http_client 11 | except ImportError: 12 | import httplib as http_client 13 | 14 | ''' 15 | python2中是urlparse，python3中是urllib.parse 16 | ''' 17 | try: 18 | import urllib.parse as url_parse 19 | except ImportError: 20 | import urlparse as url_parse 21 | 22 | from com.alipay.ams.api.tools.constants import * 23 | from com.alipay.ams.api.exception.exception import AlipayApiException 24 | 25 | 26 | def __get_http_connection(url, timeout=DEFAULT_TIMEOUT): 27 | url_parse_result = url_parse.urlparse(url) 28 | host_name = url_parse_result.hostname 29 | port = 443 30 | context = ssl._create_unverified_context() 31 | connection = http_client.HTTPSConnection(host=host_name, port=port, timeout=timeout, context=context) 32 | return connection 33 | 34 | 35 | def do_post(url, headers=None, req_body=None, charset=DEFAULT_CHARSET): 36 | connection = __get_http_connection(url) 37 | try: 38 | connection.connect() 39 | except Exception as e: 40 | raise AlipayApiException('connect failed. ' + str(e)) 41 | 42 | try: 43 | connection.request("POST", url, body=req_body.encode(charset), headers=headers) 44 | except Exception as e: 45 | raise AlipayApiException('request failed. ' + str(e)) 46 | 47 | response = connection.getresponse() 48 | if response.status != 200: 49 | raise AlipayApiException('invalid http status ' + str(response.status) + ',detail body:' + response.read()) 50 | headers = response.getheaders() 51 | result = response.read() 52 | try: 53 | response.close() 54 | connection.close() 55 | except Exception as e: 56 | raise AlipayApiException('close failed. ' + str(e)) 57 | 58 | return headers, result 59 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/alipay_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.model.http_method import HttpMethod 5 | 6 | 7 | class AlipayRequest(object): 8 | 9 | # def __init__(self, path): 10 | # self.__path = path 11 | # self.__key_version = None 12 | # self.__http_method = HttpMethod.POST 13 | 14 | def __init__(self, *args, **kwargs): 15 | self.__path = args[0].value if len(args) > 0 else None 16 | self.__key_version = kwargs.get('key_version', None) 17 | self.__http_method = kwargs.get('http_method', HttpMethod.POST) 18 | 19 | @property 20 | def path(self): 21 | return self.__path 22 | 23 | @path.setter 24 | def path(self, value): 25 | self.__path = value 26 | 27 | @property 28 | def key_version(self): 29 | return self.__key_version 30 | 31 | @key_version.setter 32 | def key_version(self, value): 33 | self.__key_version = value 34 | 35 | @property 36 | def http_method(self): 37 | return self.__http_method 38 | 39 | @http_method.setter 40 | def http_method(self, value): 41 | self.__http_method = value 42 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/auth/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/auth/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/auth/alipay_auth_query_token_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 7 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 8 | 9 | 10 | class AlipayAuthQueryTokenRequest(AlipayRequest): 11 | 12 | def __init__(self): 13 | super(AlipayAuthQueryTokenRequest, self).__init__(AntomPathConstants.AUTH_QUERY_PATH) 14 | self.__access_token = None 15 | 16 | @property 17 | def access_token(self): 18 | return self.__access_token 19 | 20 | @access_token.setter 21 | def access_token(self, value): 22 | self.__access_token = value 23 | 24 | def to_ams_json(self): 25 | json_str = json.dumps(obj=self.__to_ams_dict(), indent=3) 26 | return json_str 27 | 28 | def __to_ams_dict(self): 29 | params = dict() 30 | if hasattr(self, "access_token") and self.access_token: 31 | params['accessToken'] = self.access_token 32 | return params 33 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/auth/alipay_auth_revoke_token_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 7 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 8 | 9 | 10 | class AlipayAuthRevokeTokenRequest(AlipayRequest): 11 | 12 | def __init__(self): 13 | super(AlipayAuthRevokeTokenRequest, self).__init__(AntomPathConstants.AUTH_REVOKE_PATH) 14 | self.__access_token = None 15 | self.__extend_info = None 16 | 17 | @property 18 | def access_token(self): 19 | return self.__access_token 20 | 21 | @access_token.setter 22 | def access_token(self, value): 23 | self.__access_token = value 24 | 25 | @property 26 | def extend_info(self): 27 | return self.__extend_info 28 | 29 | @extend_info.setter 30 | def extend_info(self, value): 31 | self.__extend_info = value 32 | 33 | def to_ams_json(self): 34 | json_str = json.dumps(obj=self.__to_ams_dict(), indent=3) 35 | return json_str 36 | 37 | def __to_ams_dict(self): 38 | params = dict() 39 | if hasattr(self, "access_token") and self.access_token: 40 | params['accessToken'] = self.access_token 41 | if hasattr(self, "extend_info") and self.extend_info: 42 | params['extendInfo'] = self.extend_info 43 | return params 44 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/declare/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/declare/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/declare/alipay_customs_query_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayCustomsQueryRequest(AlipayRequest): 8 | def __init__(self): 9 | super(AlipayCustomsQueryRequest, self).__init__(AntomPathConstants.INQUIRY_DECLARE_PATH) 10 | self.__declaration_request_ids = None # type: list[str] 11 | 12 | @property 13 | def declaration_request_ids(self): 14 | return self.__declaration_request_ids 15 | 16 | @declaration_request_ids.setter 17 | def declaration_request_ids(self, value): 18 | self.__declaration_request_ids = value 19 | 20 | def to_ams_json(self): 21 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 22 | return json_str 23 | 24 | def __to_ams_dict(self): 25 | params = dict() 26 | if self.__declaration_request_ids is not None: 27 | params['declarationRequestIds'] = self.__declaration_request_ids 28 | return params 29 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/dispute/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/dispute/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/dispute/alipay_accept_dispute_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayAcceptDisputeRequest(AlipayRequest): 8 | def __init__(self): 9 | super(AlipayAcceptDisputeRequest, self).__init__(AntomPathConstants.ACCEPT_DISPUTE_PATH) 10 | self.__dispute_id = None 11 | 12 | @property 13 | def dispute_id(self): 14 | return self.__dispute_id 15 | 16 | @dispute_id.setter 17 | def dispute_id(self, value): 18 | self.__dispute_id = value 19 | 20 | def to_ams_json(self): 21 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 22 | return json_str 23 | 24 | def __to_ams_dict(self): 25 | params = dict() 26 | if self.__dispute_id is not None: 27 | params['disputeId'] = self.__dispute_id 28 | 29 | return params 30 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/dispute/alipay_download_dispute_evidence_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.model.dispute_evidence_type import DisputeEvidenceType 5 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 6 | 7 | 8 | class AlipayDownloadDisputeEvidenceRequest(AlipayRequest): 9 | def __init__(self): 10 | super(AlipayDownloadDisputeEvidenceRequest, self).__init__(AntomPathConstants.DOWNLOAD_DISPUTE_EVIDENCE_PATH) 11 | self.__dispute_id = None 12 | self.__dispute_evidence_type = None # type:DisputeEvidenceType 13 | 14 | @property 15 | def dispute_id(self): 16 | return self.__dispute_id 17 | 18 | @dispute_id.setter 19 | def dispute_id(self, value): 20 | self.__dispute_id = value 21 | 22 | @property 23 | def dispute_evidence_type(self): 24 | return self.__dispute_evidence_type 25 | 26 | @dispute_evidence_type.setter 27 | def dispute_evidence_type(self, value): 28 | self.__dispute_evidence_type = value 29 | 30 | def to_ams_json(self): 31 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 32 | return json_str 33 | 34 | def __to_ams_dict(self): 35 | params = dict() 36 | if self.__dispute_id is not None: 37 | params['disputeId'] = self.__dispute_id 38 | if self.__dispute_evidence_type is not None: 39 | params['disputeEvidenceType'] = self.__dispute_evidence_type 40 | return params 41 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/dispute/alipay_supply_defense_document_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipaySupplyDefenseDocumentRequest(AlipayRequest): 8 | def __init__(self): 9 | super(AlipaySupplyDefenseDocumentRequest, self).__init__(AntomPathConstants.SUPPLY_DEFENCE_DOC_PATH) 10 | self.__dispute_id = None 11 | self.__dispute_evidence = None 12 | 13 | @property 14 | def dispute_id(self): 15 | return self.__dispute_id 16 | 17 | @dispute_id.setter 18 | def dispute_id(self, value): 19 | self.__dispute_id = value 20 | 21 | @property 22 | def dispute_evidence(self): 23 | return self.__dispute_evidence 24 | 25 | @dispute_evidence.setter 26 | def dispute_evidence(self, value): 27 | self.__dispute_evidence = value 28 | 29 | def to_ams_json(self): 30 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 31 | return json_str 32 | 33 | def __to_ams_dict(self): 34 | params = dict() 35 | if self.__dispute_id is not None: 36 | params['disputeId'] = self.__dispute_id 37 | if self.__dispute_evidence is not None: 38 | params['disputeEvidence'] = self.__dispute_evidence 39 | return params 40 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/marketplace/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/marketplace/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/marketplace/alipay_create_payout_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.model.transfer_from_detail import TransferFromDetail 5 | from com.alipay.ams.api.model.transfer_to_detail import TransferToDetail 6 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 7 | 8 | 9 | class AlipayCreatePayoutRequest(AlipayRequest): 10 | 11 | def __init__(self): 12 | super(AlipayCreatePayoutRequest, self).__init__(AntomPathConstants.MARKETPLACE_CREATEPAYOUT_PATH) 13 | self.__transfer_requestId = None 14 | self.__transfer_from_detail = None # type: TransferFromDetail 15 | self.__transfer_to_detail = None # type: TransferToDetail 16 | 17 | @property 18 | def transfer_requestId(self): 19 | return self.__transfer_requestId 20 | 21 | @transfer_requestId.setter 22 | def transfer_requestId(self, value): 23 | self.__transfer_requestId = value 24 | 25 | @property 26 | def transfer_from_detail(self): 27 | return self.__transfer_from_detail 28 | 29 | @transfer_from_detail.setter 30 | def transfer_from_detail(self, value): 31 | self.__transfer_from_detail = value 32 | 33 | @property 34 | def transfer_to_detail(self): 35 | return self.__transfer_to_detail 36 | 37 | @transfer_to_detail.setter 38 | def transfer_to_detail(self, value): 39 | self.__transfer_to_detail = value 40 | 41 | def to_ams_json(self): 42 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 43 | return json_str 44 | 45 | def __to_ams_dict(self): 46 | params = dict() 47 | if self.__transfer_requestId is not None: 48 | params['transferRequestId'] = self.__transfer_requestId 49 | if self.__transfer_from_detail is not None: 50 | params['transferFromDetail'] = self.__transfer_from_detail.to_ams_dict() 51 | if self.__transfer_to_detail is not None: 52 | params['transferToDetail'] = self.__transfer_to_detail.to_ams_dict() 53 | return params 54 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/marketplace/alipay_create_transfer_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.model.transfer_from_detail import TransferFromDetail 5 | from com.alipay.ams.api.model.transfer_to_detail import TransferToDetail 6 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 7 | 8 | 9 | class AlipayCreateTransferRequest(AlipayRequest): 10 | 11 | def __init__(self): 12 | super(AlipayCreateTransferRequest, self).__init__(AntomPathConstants.MARKETPLACE_CREATETRANSFER_PATH) 13 | self.__transfer_request_id = None 14 | self.__transfer_from_detail = None # type: TransferFromDetail 15 | self.__transfer_to_detail = None # type: TransferToDetail 16 | 17 | @property 18 | def transfer_request_id(self): 19 | return self.__transfer_request_id 20 | 21 | @transfer_request_id.setter 22 | def transfer_request_id(self, value): 23 | self.__transfer_request_id = value 24 | 25 | @property 26 | def transfer_from_detail(self): 27 | return self.__transfer_from_detail 28 | 29 | @transfer_from_detail.setter 30 | def transfer_from_detail(self, value): 31 | self.__transfer_from_detail = value 32 | 33 | @property 34 | def transfer_to_detail(self): 35 | return self.__transfer_to_detail 36 | 37 | @transfer_to_detail.setter 38 | def transfer_to_detail(self, value): 39 | self.__transfer_to_detail = value 40 | 41 | def to_ams_json(self): 42 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 43 | return json_str 44 | 45 | def __to_ams_dict(self): 46 | params = dict() 47 | if hasattr(self, "transfer_request_id") and self.transfer_request_id: 48 | params['transferRequestId'] = self.transfer_request_id 49 | if hasattr(self, "transfer_from_detail") and self.transfer_from_detail: 50 | params['transferFromDetail'] = self.transfer_from_detail.to_ams_dict() 51 | if hasattr(self, "transfer_to_detail") and self.transfer_to_detail: 52 | params['transferToDetail'] = self.transfer_to_detail.to_ams_dict() 53 | return params 54 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/marketplace/alipay_inquire_balance_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayInquireBalanceRequest(AlipayRequest): 8 | def __init__(self): 9 | super(AlipayInquireBalanceRequest, self).__init__(AntomPathConstants.MARKETPLACE_INQUIREBALANCE_PATH) 10 | self.__referenceMerchantId = None 11 | 12 | @property 13 | def reference_merchant_id(self): 14 | return self.__referenceMerchantId 15 | 16 | @reference_merchant_id.setter 17 | def reference_merchant_id(self, value): 18 | self.__referenceMerchantId = value 19 | 20 | 21 | def to_ams_json(self): 22 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 23 | return json_str 24 | 25 | def __to_ams_dict(self): 26 | params = dict() 27 | if self.__referenceMerchantId is not None: 28 | params['referenceMerchantId'] = self.__referenceMerchantId 29 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/request/marketplace/alipay_settle_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.model.settlement_detail import SettlementDetail 5 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 6 | 7 | 8 | class AlipaySettleRequest(AlipayRequest): 9 | def __init__(self): 10 | super(AlipaySettleRequest, self).__init__(AntomPathConstants.MARKETPLACE_SETTLE_PATH) 11 | self.__settlement_request_id = None 12 | self.__payment_id = None 13 | self.__settlement_details = None #type: list[SettlementDetail] 14 | 15 | @property 16 | def settlement_request_id(self): 17 | return self.__settlement_request_id 18 | 19 | @settlement_request_id.setter 20 | def settlement_request_id(self, value): 21 | self.__settlement_request_id = value 22 | 23 | @property 24 | def payment_id(self): 25 | return self.__payment_id 26 | 27 | @payment_id.setter 28 | def payment_id(self, value): 29 | self.__payment_id = value 30 | 31 | @property 32 | def settlement_details(self): 33 | return self.__settlement_details 34 | 35 | @settlement_details.setter 36 | def settlement_details(self, value): 37 | self.__settlement_details = value 38 | 39 | def to_ams_json(self): 40 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 41 | return json_str 42 | 43 | def __to_ams_dict(self): 44 | params = dict() 45 | if hasattr(self, 'settlement_request_id') and self.__settlement_request_id: 46 | params['settlementRequestId'] = self.__settlement_request_id 47 | if hasattr(self, 'payment_id') and self.__payment_id: 48 | params['paymentId'] = self.__payment_id 49 | if hasattr(self, 'settlement_details') and self.__settlement_details: 50 | params['settlementDetails'] = self.__settlement_details 51 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/request/marketplace/alipay_submit_attachment_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.model.attachment_type import AttachmentType 5 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 6 | 7 | 8 | class AlipaySubmitAttachmentRequest(AlipayRequest): 9 | def __init__(self): 10 | super(AlipaySubmitAttachmentRequest, self).__init__(AntomPathConstants.MARKETPLACE_SUBMITATTACHMENT_PATH) 11 | self.__submit_attachment_request_id = None 12 | self.__attachment_type = None #type: AttachmentType 13 | self.__file_sha_256 = None 14 | 15 | @property 16 | def submit_attachment_request_id(self): 17 | return self.__submit_attachment_request_id 18 | 19 | @submit_attachment_request_id.setter 20 | def submit_attachment_request_id(self, value): 21 | self.__submit_attachment_request_id = value 22 | 23 | @property 24 | def attachment_type(self): 25 | return self.__attachment_type 26 | 27 | @attachment_type.setter 28 | def attachment_type(self, value): 29 | self.__attachment_type = value 30 | 31 | @property 32 | def file_sha_256(self): 33 | return self.__file_sha_256 34 | 35 | @file_sha_256.setter 36 | def file_sha_256(self, value): 37 | self.__file_sha_256 = value 38 | 39 | def to_ams_json(self): 40 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 41 | return json_str 42 | 43 | def __to_ams_dict(self): 44 | params = dict() 45 | if hasattr(self, 'submit_attachment_request_id') and self.submit_attachment_request_id: 46 | params['submitAttachmentRequestId'] = self.__submit_attachment_request_id 47 | if hasattr(self, 'attachment_type') and self.attachment_type: 48 | params['attachmentType'] = self.__attachment_type 49 | if hasattr(self, 'file_sha_256') and self.file_sha_256: 50 | params['fileSha256'] = self.__file_sha_256 51 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/request/merchant/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/merchant/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/merchant/alipay_merchant_registration_info_query_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayMerchantRegistrationInfoQueryRequest(AlipayRequest): 8 | 9 | def __init__(self): 10 | super(AlipayMerchantRegistrationInfoQueryRequest, self).__init__(AntomPathConstants.MERCHANTS_INQUIRY_REGISTRATION_PATH) 11 | self.__reference_merchant_id = None 12 | 13 | @property 14 | def reference_merchant_id(self): 15 | return self.__reference_merchant_id 16 | 17 | @reference_merchant_id.setter 18 | def reference_merchant_id(self, value): 19 | self.__reference_merchant_id = value 20 | 21 | def to_ams_json(self): 22 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 23 | return json_str 24 | 25 | def __to_ams_dict(self): 26 | params = dict() 27 | if hasattr(self, "reference_merchant_id") and self.reference_merchant_id: 28 | params['referenceMerchantId'] = self.reference_merchant_id 29 | 30 | return params 31 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/merchant/alipay_merchant_registration_status_query_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayMerchantRegistrationStatusQueryRequest(AlipayRequest): 8 | 9 | def __init__(self): 10 | super(AlipayMerchantRegistrationStatusQueryRequest, self).__init__(AntomPathConstants.MERCHANTS_INQUIRY_REGISTRATION_STATUS_PATH) 11 | self.__registration_request_id = None 12 | self.__reference_merchant_id = None 13 | 14 | @property 15 | def registration_request_id(self): 16 | return self.__registration_request_id 17 | 18 | @registration_request_id.setter 19 | def registration_request_id(self, value): 20 | self.__registration_request_id = value 21 | 22 | @property 23 | def reference_merchant_id(self): 24 | return self.__reference_merchant_id 25 | 26 | @reference_merchant_id.setter 27 | def reference_merchant_id(self, value): 28 | self.__reference_merchant_id = value 29 | 30 | def to_ams_json(self): 31 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 32 | return json_str 33 | 34 | def __to_ams_dict(self): 35 | params = dict() 36 | if hasattr(self, "registration_request_id") and self.registration_request_id: 37 | params['registrationRequestId'] = self.registration_request_id 38 | 39 | if hasattr(self, "reference_merchant_id") and self.reference_merchant_id: 40 | params['referenceMerchantId'] = self.reference_merchant_id 41 | 42 | return params 43 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/notify/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/notify/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/notify/alipay_notify.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.result import Result 4 | 5 | 6 | class AlipayNotify(object): 7 | 8 | def __init__(self): 9 | self.__notify_type = None 10 | self.__result = None #type: Result 11 | 12 | @property 13 | def notify_type(self): 14 | return self.__notify_type 15 | 16 | @property 17 | def result(self): 18 | return self.__result 19 | 20 | def parse_notify_body(self, notify_body): 21 | notify = json.loads(notify_body) 22 | if 'notifyType' in notify: 23 | self.__notify_type = notify['notifyType'] 24 | if 'result' in notify: 25 | result = Result() 26 | result.parse_rsp_body(notify['result']) 27 | self.__result = result 28 | return notify -------------------------------------------------------------------------------- /com/alipay/ams/api/request/notify/alipay_subscription_pay_notify.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.request.notify.alipay_notify import AlipayNotify 2 | from com.alipay.ams.api.request.notify.alipay_pay_result_notify import AlipayPayResultNotify 3 | 4 | 5 | class AlipaySubscriptionPayNotify(AlipayPayResultNotify): 6 | 7 | def __init__(self, notify_body): 8 | super(AlipaySubscriptionPayNotify, self).__init__(notify_body) 9 | self.__subscription_request_id = None 10 | self.__subscription_id = None 11 | self.__period_start_time = None 12 | self.__period_end_time = None 13 | self.__phase_no = None 14 | self.__parse_notify_body(notify_body) 15 | 16 | 17 | @property 18 | def subscription_request_id(self): 19 | return self.__subscription_request_id 20 | 21 | @property 22 | def subscription_id(self): 23 | return self.__subscription_id 24 | 25 | @property 26 | def period_start_time(self): 27 | return self.__period_start_time 28 | 29 | @property 30 | def period_end_time(self): 31 | return self.__period_end_time 32 | 33 | @property 34 | def phase_no(self): 35 | return self.__phase_no 36 | 37 | def __parse_notify_body(self, notify_body): 38 | notify = super(AlipaySubscriptionPayNotify, self).parse_notify_body(notify_body) 39 | if 'subscriptionRequestId' in notify: 40 | self.__subscription_request_id = notify['subscriptionRequestId'] 41 | if 'subscriptionId' in notify: 42 | self.__subscription_id = notify['subscriptionId'] 43 | if 'periodStartTime' in notify: 44 | self.__period_start_time = notify['periodStartTime'] 45 | if 'periodEndTime' in notify: 46 | self.__period_end_time = notify['periodEndTime'] 47 | if 'phaseNo' in notify: 48 | self.__phase_no = notify['phaseNo'] 49 | 50 | 51 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/notify/alipay_vaulting_notify.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.acquirer_info import AcquirerInfo 2 | from com.alipay.ams.api.model.payment_method_detail import PaymentMethodDetail 3 | from com.alipay.ams.api.request.notify.alipay_notify import AlipayNotify 4 | 5 | 6 | class AlipayVaultingNotify(AlipayNotify): 7 | 8 | def __init__(self, notify_body): 9 | super(AlipayVaultingNotify, self).__init__() 10 | self.__vaulting_request_id = None 11 | self.__payment_method_detail = None #type: PaymentMethodDetail 12 | self.__vaulting_create_time = None 13 | self.__acquirer_info = None # type: AcquirerInfo 14 | self.__parse_rsp_body(notify_body) 15 | 16 | 17 | @property 18 | def vaulting_request_id(self): 19 | return self.__vaulting_request_id 20 | 21 | @property 22 | def payment_method_detail(self): 23 | return self.__payment_method_detail 24 | 25 | @property 26 | def vaulting_create_time(self): 27 | return self.__vaulting_create_time 28 | 29 | @property 30 | def acquirer_info(self): 31 | return self.__acquirer_info 32 | 33 | 34 | def __parse_notify_body(self, notify_body): 35 | notify = super(AlipayVaultingNotify, self).parse_notify_body(notify_body) 36 | if 'vaultingRequestId' in notify: 37 | self.__vaulting_request_id = notify['vaultingRequestId'] 38 | if 'paymentMethodDetail' in notify: 39 | payment_method_detail = PaymentMethodDetail() 40 | payment_method_detail.parse_rsp_body(notify['paymentMethodDetail']) 41 | self.__payment_method_detail = payment_method_detail 42 | if 'vaultingCreateTime' in notify: 43 | self.__vaulting_create_time = notify['vaultingCreateTime'] 44 | if 'acquirerInfo' in notify: 45 | acquirer_info = AcquirerInfo() 46 | acquirer_info.parse_rsp_body(notify['acquirerInfo']) 47 | self.__acquirer_info = acquirer_info 48 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/pay/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/pay/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/pay/alipay_pay_cancel_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 7 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 8 | 9 | 10 | class AlipayPayCancelRequest(AlipayRequest): 11 | 12 | def __init__(self): 13 | super(AlipayPayCancelRequest, self).__init__(AntomPathConstants.CANCEL_PATH) 14 | self.__payment_id = None 15 | self.__payment_request_id = None 16 | self.__merchant_account_id = None 17 | 18 | @property 19 | def payment_id(self): 20 | return self.__payment_id 21 | 22 | @payment_id.setter 23 | def payment_id(self, value): 24 | self.__payment_id = value 25 | 26 | @property 27 | def payment_request_id(self): 28 | return self.__payment_request_id 29 | 30 | @payment_request_id.setter 31 | def payment_request_id(self, value): 32 | self.__payment_request_id = value 33 | 34 | @property 35 | def merchant_account_id(self): 36 | return self.__merchant_account_id 37 | 38 | @merchant_account_id.setter 39 | def merchant_account_id(self, value): 40 | self.__merchant_account_id = value 41 | 42 | def to_ams_json(self): 43 | json_str = json.dumps(obj=self.__to_ams_dict(), indent=3) 44 | return json_str 45 | 46 | def __to_ams_dict(self): 47 | params = dict() 48 | if hasattr(self, "payment_id") and self.payment_id: 49 | params['paymentId'] = self.payment_id 50 | 51 | if hasattr(self, "payment_request_id") and self.payment_request_id: 52 | params['paymentRequestId'] = self.payment_request_id 53 | 54 | if hasattr(self, "merchant_account_id") and self.merchant_account_id: 55 | params['merchantAccountId'] = self.merchant_account_id 56 | 57 | return params 58 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/pay/alipay_pay_query_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 7 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 8 | 9 | 10 | class AlipayPayQueryRequest(AlipayRequest): 11 | 12 | def __init__(self): 13 | super(AlipayPayQueryRequest, self).__init__(AntomPathConstants.INQUIRY_PAYMENT_PATH) 14 | self.__payment_id = None 15 | self.__payment_request_id = None 16 | self.__merchant_account_id = None 17 | 18 | 19 | @property 20 | def payment_id(self): 21 | return self.__payment_id 22 | 23 | @payment_id.setter 24 | def payment_id(self, value): 25 | self.__payment_id = value 26 | 27 | @property 28 | def payment_request_id(self): 29 | return self.__payment_request_id 30 | 31 | @payment_request_id.setter 32 | def payment_request_id(self, value): 33 | self.__payment_request_id = value 34 | 35 | @property 36 | def merchant_account_id(self): 37 | return self.__merchant_account_id 38 | 39 | @merchant_account_id.setter 40 | def merchant_account_id(self, value): 41 | self.__merchant_account_id = value 42 | 43 | 44 | # 将对象转换为json字符串 45 | def to_ams_json(self): 46 | json_str = json.dumps(obj=self.__to_ams_dict(), indent=3) 47 | return json_str 48 | 49 | def __to_ams_dict(self): 50 | params = dict() 51 | if hasattr(self, "payment_id") and self.payment_id: 52 | params['paymentId'] = self.payment_id 53 | 54 | if hasattr(self, "payment_request_id") and self.payment_request_id: 55 | params['paymentRequestId'] = self.payment_request_id 56 | 57 | if hasattr(self, "merchant_account_id") and self.merchant_account_id: 58 | params['merchantAccountId'] = self.merchant_account_id 59 | 60 | return params 61 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/pay/alipay_refund_query_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayRefundQueryRequest(AlipayRequest): 8 | 9 | def __init__(self): 10 | super(AlipayRefundQueryRequest, self).__init__(AntomPathConstants.INQUIRY_REFUND_PATH) 11 | self.__refund_request_id = None 12 | self.__refund_id = None 13 | self.__merchant_account_id = None 14 | 15 | @property 16 | def refund_request_id(self): 17 | return self.__refund_request_id 18 | 19 | @refund_request_id.setter 20 | def refund_request_id(self, value): 21 | self.__refund_request_id = value 22 | 23 | @property 24 | def refund_id(self): 25 | return self.__refund_id 26 | 27 | @refund_id.setter 28 | def refund_id(self, value): 29 | self.__refund_id = value 30 | 31 | @property 32 | def merchant_account_id(self): 33 | return self.__merchant_account_id 34 | 35 | @merchant_account_id.setter 36 | def merchant_account_id(self, value): 37 | self.__merchant_account_id = value 38 | 39 | def to_ams_json(self): 40 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 41 | return json_str 42 | 43 | def __to_ams_dict(self): 44 | params = dict() 45 | if hasattr(self, "refund_request_id") and self.refund_request_id: 46 | params['refundRequestId'] = self.refund_request_id 47 | if hasattr(self, "refund_id") and self.refund_id: 48 | params['refundId'] = self.refund_id 49 | if hasattr(self, "merchant_account_id") and self.merchant_account_id: 50 | params['merchantAccountId'] = self.merchant_account_id 51 | return params 52 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/risks/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/risks/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/risks/inquiry_risk_score_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 7 | 8 | 9 | class InquiryRiskScoreRequest(AlipayRequest): 10 | 11 | def __init__(self): 12 | super(InquiryRiskScoreRequest, self).__init__() 13 | self.__customer_belongs_to = None 14 | self.__customer_id_type = None 15 | self.__customer_id = None 16 | self.__risk_score_types = None 17 | 18 | @property 19 | def customer_belongs_to(self): 20 | return self.__customer_belongs_to 21 | 22 | @customer_belongs_to.setter 23 | def customer_belongs_to(self, value): 24 | self.__customer_belongs_to = value 25 | 26 | @property 27 | def customer_id_type(self): 28 | return self.__customer_id_type 29 | 30 | @customer_id_type.setter 31 | def customer_id_type(self, value): 32 | self.__customer_id_type = value 33 | 34 | @property 35 | def customer_id(self): 36 | return self.__customer_id 37 | 38 | @customer_id.setter 39 | def customer_id(self, value): 40 | self.__customer_id = value 41 | 42 | @property 43 | def risk_score_types(self): 44 | return self.__risk_score_types 45 | 46 | @risk_score_types.setter 47 | def risk_score_types(self, value): 48 | self.__risk_score_types = value 49 | 50 | def to_ams_json(self): 51 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 52 | return json_str 53 | 54 | def __to_ams_dict(self): 55 | params = dict() 56 | if hasattr(self, "customer_belongs_to") and self.customer_belongs_to: 57 | params['customerBelongsTo'] = self.customer_belongs_to 58 | 59 | if hasattr(self, "customer_id_type") and self.customer_id_type: 60 | params['customerIdType'] = self.customer_id_type 61 | 62 | if hasattr(self, "customer_id") and self.customer_id: 63 | params['customer_id'] = self.customer_id 64 | 65 | if hasattr(self, "risk_score_types") and self.risk_score_types: 66 | params['riskScoreTypes'] = self.risk_score_types 67 | 68 | return params 69 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/subscription/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/subscription/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/subscription/alipay_subscription_cancel_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.model.cancellation_type import CancellationType 5 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 6 | 7 | 8 | class AlipaySubscriptionCancelRequest(AlipayRequest): 9 | def __init__(self): 10 | super(AlipaySubscriptionCancelRequest, self).__init__(AntomPathConstants.SUBSCRIPTION_CANCEL_PATH) 11 | self.__subscription_id = None 12 | self.__subscription_request_id = None 13 | self.__cancellation_type = None # type:CancellationType 14 | 15 | @property 16 | def subscription_id(self): 17 | return self.__subscription_id 18 | 19 | @subscription_id.setter 20 | def subscription_id(self, value): 21 | self.__subscription_id = value 22 | 23 | @property 24 | def subscription_request_id(self): 25 | return self.__subscription_request_id 26 | 27 | @subscription_request_id.setter 28 | def subscription_request_id(self, value): 29 | self.__subscription_request_id = value 30 | 31 | @property 32 | def cancellation_type(self): 33 | return self.__cancellation_type 34 | 35 | @cancellation_type.setter 36 | def cancellation_type(self, value): 37 | self.__cancellation_type = value 38 | 39 | def to_ams_json(self): 40 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 41 | return json_str 42 | 43 | def __to_ams_dict(self): 44 | params = dict() 45 | if hasattr(self, "subscription_id") and self.subscription_id: 46 | params['subscriptionId'] = self.subscription_id 47 | if hasattr(self, "subscription_request_id") and self.subscription_request_id: 48 | params['subscriptionRequestId'] = self.subscription_request_id 49 | if hasattr(self, "cancellation_type") and self.cancellation_type: 50 | params['cancellationType'] = self.cancellation_type 51 | 52 | return params 53 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/users/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/users/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/users/alipay_user_query_info_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 7 | 8 | 9 | class AlipayUserQueryInfoRequest(AlipayRequest): 10 | 11 | def __init__(self): 12 | super(AlipayUserQueryInfoRequest, self).__init__() 13 | self.__access_token = None 14 | 15 | @property 16 | def access_token(self): 17 | return self.__access_token 18 | 19 | @access_token.setter 20 | def access_token(self, value): 21 | self.__access_token = value 22 | 23 | def to_ams_json(self): 24 | json_str = json.dumps(obj=self.__to_ams_dict(), indent=3) 25 | return json_str 26 | 27 | def __to_ams_dict(self): 28 | params = dict() 29 | if hasattr(self, "access_token") and self.access_token: 30 | params['accessToken'] = self.access_token 31 | 32 | return params 33 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/users/alipay_verify_authentication_request.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import json 5 | 6 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 7 | 8 | 9 | class AlipayVerifyAuthenticationRequest(AlipayRequest): 10 | 11 | def __init__(self): 12 | super(AlipayVerifyAuthenticationRequest, self).__init__() 13 | self.__authentication_type = None 14 | self.__authentication_request_id = None 15 | self.__authentication_value = None 16 | 17 | @property 18 | def authentication_type(self): 19 | return self.__authentication_type 20 | 21 | @authentication_type.setter 22 | def authentication_type(self, value): 23 | self.__authentication_type = value 24 | 25 | @property 26 | def authentication_request_id(self): 27 | return self.__authentication_request_id 28 | 29 | @authentication_request_id.setter 30 | def authentication_request_id(self, value): 31 | self.__authentication_request_id = value 32 | 33 | @property 34 | def authentication_value(self): 35 | return self.__authentication_value 36 | 37 | @authentication_value.setter 38 | def authentication_value(self, value): 39 | self.__authentication_value = value 40 | 41 | def to_ams_json(self): 42 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 43 | return json_str 44 | 45 | def __to_ams_dict(self): 46 | params = dict() 47 | if hasattr(self, "authentication_type") and self.authentication_type: 48 | params['authenticationType'] = self.authentication_type 49 | 50 | if hasattr(self, "authentication_request_id") and self.authentication_request_id: 51 | params['authenticationRequestId'] = self.authentication_request_id 52 | 53 | if hasattr(self, "authentication_value") and self.authentication_value: 54 | params['authenticationValue'] = self.authentication_value 55 | 56 | return params 57 | -------------------------------------------------------------------------------- /com/alipay/ams/api/request/vaulting/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/request/vaulting/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/request/vaulting/alipay_vaulting_query_request.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.antom_path_constants import AntomPathConstants 4 | from com.alipay.ams.api.request.alipay_request import AlipayRequest 5 | 6 | 7 | class AlipayVaultingQueryRequest(AlipayRequest): 8 | 9 | def __init__(self): 10 | super(AlipayVaultingQueryRequest, self).__init__(AntomPathConstants.INQUIRE_VAULTING_PATH) 11 | self.__vaulting_request_id = None 12 | 13 | 14 | @property 15 | def vaulting_request_id(self): 16 | return self.__vaulting_request_id 17 | @vaulting_request_id.setter 18 | def vaulting_request_id(self, value): 19 | self.__vaulting_request_id = value 20 | 21 | def to_ams_json(self): 22 | json_str = json.dumps(obj=self.__to_ams_dict(), default=lambda o: o.to_ams_dict(), indent=3) 23 | return json_str 24 | 25 | def __to_ams_dict(self): 26 | params = dict() 27 | if self.__vaulting_request_id is not None: 28 | params['vaultingRequestId'] = self.__vaulting_request_id 29 | return params -------------------------------------------------------------------------------- /com/alipay/ams/api/response/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/alipay_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | import json 4 | 5 | from com.alipay.ams.api.model.result import Result 6 | 7 | 8 | class AlipayResponse(object): 9 | def __init__(self): 10 | self.__result = None 11 | 12 | @property 13 | def result(self): 14 | return self.__result 15 | 16 | def parse_rsp_body(self, rsp_body): 17 | response = json.loads(rsp_body) 18 | if 'result' in response: 19 | result = Result() 20 | result.parse_rsp_body(response['result']) 21 | self.__result = result 22 | return response 23 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/auth/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/auth/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/auth/alipay_auth_apply_token_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayAuthApplyTokenResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayAuthApplyTokenResponse, self).__init__() 11 | self.__access_token = None 12 | self.__access_token_expiry_time = None 13 | self.__refresh_token = None 14 | self.__refresh_token_expiry_time = None 15 | self.__user_login_id = None 16 | self.__extend_info = None 17 | self.__parse_rsp_body(rsp_body) 18 | 19 | @property 20 | def access_token(self): 21 | return self.__access_token 22 | 23 | @property 24 | def access_token_expiry_time(self): 25 | return self.__access_token_expiry_time 26 | 27 | @property 28 | def refresh_token(self): 29 | return self.__refresh_token 30 | 31 | @property 32 | def refresh_token_expiry_time(self): 33 | return self.__refresh_token_expiry_time 34 | 35 | @property 36 | def extend_info(self): 37 | return self.__extend_info 38 | 39 | @property 40 | def user_login_id(self): 41 | return self.__user_login_id 42 | 43 | def __parse_rsp_body(self, rsp_body): 44 | response = super(AlipayAuthApplyTokenResponse, self).parse_rsp_body(rsp_body) 45 | if 'accessToken' in response: 46 | self.__access_token = response['accessToken'] 47 | if 'accessTokenExpiryTime' in response: 48 | self.__access_token_expiry_time = response['accessTokenExpiryTime'] 49 | if 'refreshToken' in response: 50 | self.__refresh_token = response['refreshToken'] 51 | if 'refreshTokenExpiryTime' in response: 52 | self.__refresh_token_expiry_time = response['refreshTokenExpiryTime'] 53 | if 'extendInfo' in response: 54 | self.__extend_info = response['extendInfo'] 55 | 56 | if 'userLoginId' in response: 57 | self.__user_login_id = response['userLoginId'] 58 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/auth/alipay_auth_consult_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | from com.alipay.ams.api.model.auth_code_form import AuthCodeForm 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayAuthConsultResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayAuthConsultResponse, self).__init__() 11 | self.__auth_url = None 12 | self.__extend_info = None 13 | self.__scheme_url = None 14 | self.__applink_url = None 15 | self.__appIdentifier = None 16 | self.__normal_url = None 17 | self.__auth_code_form = None # type: AuthCodeForm 18 | self.__parse_rsp_body(rsp_body) 19 | 20 | @property 21 | def auth_url(self): 22 | return self.__auth_url 23 | 24 | @property 25 | def extend_info(self): 26 | return self.__extend_info 27 | 28 | @property 29 | def scheme_url(self): 30 | return self.__scheme_url 31 | 32 | @property 33 | def applink_url(self): 34 | return self.__applink_url 35 | 36 | @property 37 | def appIdentifier(self): 38 | return self.__appIdentifier 39 | 40 | @property 41 | def normal_url(self): 42 | return self.__normal_url 43 | 44 | @property 45 | def auth_code_form(self): 46 | return self.__auth_code_form 47 | 48 | def __parse_rsp_body(self, rsp_body): 49 | response = super(AlipayAuthConsultResponse, self).parse_rsp_body(rsp_body) 50 | if 'authUrl' in response: 51 | self.__auth_url = response['authUrl'] 52 | if 'extendInfo' in response: 53 | self.__extend_info = response['extendInfo'] 54 | 55 | if 'schemeUrl' in response: 56 | self.__scheme_url = response['schemeUrl'] 57 | 58 | if 'applinkUrl' in response: 59 | self.__applink_url = response['applinkUrl'] 60 | 61 | if 'appIdentifier' in response: 62 | self.__appIdentifier = response['appIdentifier'] 63 | 64 | if 'normalUrl' in response: 65 | self.__normal_url = response['normalUrl'] 66 | 67 | if 'authCodeForm' in response: 68 | self.__auth_code_form = response['authCodeForm'] 69 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/auth/alipay_auth_create_session_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayAuthCreateSessionResponse(AlipayResponse): 5 | 6 | def __init__(self, rsp_body): 7 | super(AlipayAuthCreateSessionResponse, self).__init__() 8 | self.__payment_session_id = None 9 | self.__payment_session_data = None 10 | self.__payment_session_expiry_time = None 11 | self.__parse_rsp_body(rsp_body) 12 | 13 | @property 14 | def payment_session_id(self): 15 | return self.__payment_session_id 16 | 17 | @property 18 | def payment_session_data(self): 19 | return self.__payment_session_data 20 | 21 | @property 22 | def payment_session_expiry_time(self): 23 | return self.__payment_session_expiry_time 24 | 25 | def __parse_rsp_body(self, rsp_body): 26 | response = super(AlipayAuthCreateSessionResponse, self).parse_rsp_body(rsp_body) 27 | if 'paymentSessionId' in response: 28 | self.__payment_session_id = response['paymentSessionId'] 29 | 30 | if 'paymentSessionData' in response: 31 | self.__payment_session_data = response['paymentSessionData'] 32 | 33 | if 'paymentSessionExpiryTime' in response: 34 | self.__payment_session_expiry_time = response['paymentSessionExpiryTime'] -------------------------------------------------------------------------------- /com/alipay/ams/api/response/auth/alipay_auth_query_token_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayAuthQueryTokenResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayAuthQueryTokenResponse, self).__init__() 11 | self.__access_token = None 12 | self.__access_token_expiry_time = None 13 | self.__refresh_token = None 14 | self.__refresh_token_expiry_time = None 15 | self.__token_status_type = None 16 | self.__parse_rsp_body(rsp_body) 17 | 18 | @property 19 | def access_token(self): 20 | return self.__access_token 21 | 22 | @property 23 | def access_token_expiry_time(self): 24 | return self.__access_token_expiry_time 25 | 26 | @property 27 | def refresh_token(self): 28 | return self.__refresh_token 29 | 30 | @property 31 | def refresh_token_expiry_time(self): 32 | return self.__refresh_token_expiry_time 33 | 34 | @property 35 | def token_status_type(self): 36 | return self.__token_status_type 37 | 38 | def __parse_rsp_body(self, rsp_body): 39 | response = super(AlipayAuthQueryTokenResponse, self).parse_rsp_body(rsp_body) 40 | if 'accessToken' in response: 41 | self.__access_token = response['accessToken'] 42 | if 'accessTokenExpiryTime' in response: 43 | self.__access_token_expiry_time = response['accessTokenExpiryTime'] 44 | if 'refreshToken' in response: 45 | self.__refresh_token = response['refreshToken'] 46 | if 'refreshTokenExpiryTime' in response: 47 | self.__refresh_token_expiry_time = response['refreshTokenExpiryTime'] 48 | if 'tokenStatusType' in response: 49 | self.__token_status_type = response['tokenStatusType'] 50 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/auth/alipay_auth_revoke_token_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayAuthRevokeTokenResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayAuthRevokeTokenResponse, self).__init__() 11 | self.__extend_info = None 12 | self.__parse_rsp_body(rsp_body) 13 | 14 | @property 15 | def extend_info(self): 16 | return self.__extend_info 17 | 18 | def __parse_rsp_body(self, rsp_body): 19 | response = super(AlipayAuthRevokeTokenResponse, self).parse_rsp_body(rsp_body) 20 | if 'extendInfo' in response: 21 | self.__extend_info = response['extendInfo'] 22 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/declare/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/declare/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/declare/alipay_customs_query_response.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.declaration_record import DeclarationRecord 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayCustomsQueryResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayCustomsQueryResponse, self).__init__() 11 | self.__declaration_requests_not_found = None # type: list[str] 12 | self.__declaration_records = None # type: list[DeclarationRecord] 13 | self.parse_rsp_body(rsp_body) 14 | 15 | @property 16 | def declaration_requests_not_found(self): 17 | return self.__declaration_requests_not_found 18 | 19 | @property 20 | def declaration_records(self): 21 | return self.__declaration_records 22 | 23 | def parse_rsp_body(self, rsp_body): 24 | rsp_dict = super(AlipayCustomsQueryResponse, self).parse_rsp_body(rsp_body) 25 | if 'declarationRequestsNotFound' in rsp_dict: 26 | self.__declaration_requests_not_found = rsp_dict['declarationRequestsNotFound'] 27 | if 'declarationRecords' in rsp_dict: 28 | self.__declaration_records = [] 29 | for declaration_record_dict in rsp_dict['declarationRecords']: 30 | declaration_record = DeclarationRecord() 31 | declaration_record.parse_rsp_body(declaration_record_dict) 32 | self.__declaration_records.append(declaration_record) 33 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/dispute/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/dispute/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/dispute/alipay_accept_dispute_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayAcceptDisputeResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipayAcceptDisputeResponse, self).__init__() 7 | self.__dispute_id = None 8 | self.__dispute_resolution_time = None 9 | self.parse_rsp_body(rsp_body) 10 | 11 | @property 12 | def dispute_id(self): 13 | return self.__dispute_id 14 | 15 | @property 16 | def dispute_resolution_time(self): 17 | return self.__dispute_resolution_time 18 | 19 | def parse_rsp_body(self, rsp_body): 20 | rsp_dict = super(AlipayAcceptDisputeResponse, self).parse_rsp_body(rsp_body) 21 | if 'disputeId' in rsp_dict: 22 | self.__dispute_id = rsp_dict['disputeId'] 23 | if 'disputeResolutionTime' in rsp_dict: 24 | self.__dispute_resolution_time = rsp_dict['disputeResolutionTime'] 25 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/dispute/alipay_download_dispute_evidence_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.dispute_evidence_format_type import DisputeEvidenceFormatType 2 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 3 | 4 | 5 | class AlipayDownloadDisputeEvidenceResponse(AlipayResponse): 6 | 7 | def __init__(self, rsp_body): 8 | super(AlipayDownloadDisputeEvidenceResponse, self).__init__() 9 | self.__dispute_evidence = None 10 | self.__dispute_evidence_format = None # type:DisputeEvidenceFormatType 11 | self.parse_rsp_body(rsp_body) 12 | 13 | @property 14 | def dispute_evidence(self): 15 | return self.__dispute_evidence 16 | 17 | @property 18 | def dispute_evidence_format(self): 19 | return self.__dispute_evidence_format 20 | 21 | def parse_rsp_body(self, rsp_body): 22 | rsp_dict = super(AlipayDownloadDisputeEvidenceResponse, self).parse_rsp_body(rsp_body) 23 | if 'disputeEvidence' in rsp_dict: 24 | self.__dispute_evidence = rsp_dict['disputeEvidence'] 25 | if 'disputeEvidenceFormat' in rsp_dict: 26 | self.__dispute_evidence_format = rsp_dict['disputeEvidenceFormat'] 27 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/dispute/alipay_supply_defense_document_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySupplyDefenseDocumentResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipaySupplyDefenseDocumentResponse, self).__init__() 7 | self.__dispute_id = None 8 | self.__dispute_resolution_time = None 9 | self.parse_rsp_body(rsp_body) 10 | 11 | @property 12 | def dispute_id(self): 13 | return self.__dispute_id 14 | 15 | @property 16 | def dispute_resolution_time(self): 17 | return self.__dispute_resolution_time 18 | 19 | def parse_rsp_body(self, rsp_body): 20 | rsp_dict = super(AlipaySupplyDefenseDocumentResponse, self).parse_rsp_body(rsp_body) 21 | if 'disputeId' in rsp_dict: 22 | self.__dispute_id = rsp_dict['disputeId'] 23 | if 'disputeResolutionTime' in rsp_dict: 24 | self.__dispute_resolution_time = rsp_dict['disputeResolutionTime'] 25 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/marketplace/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_create_payout_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.transfer_from_detail import TransferFromDetail 2 | from com.alipay.ams.api.model.transfer_to_detail import TransferToDetail 3 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 4 | 5 | 6 | class AlipayCreatePayoutResponse(AlipayResponse): 7 | 8 | def __init__(self, rsp_body): 9 | super(AlipayCreatePayoutResponse, self).__init__() 10 | self.__transfer_id = None 11 | self.__transfer_request_id = None 12 | self.__transfer_from_detail = None #type: TransferFromDetail 13 | self.__transfer_to_detail = None #type: TransferToDetail 14 | self.__parse_rsp_body(rsp_body) 15 | 16 | @property 17 | def transfer_id(self): 18 | return self.__transfer_id 19 | 20 | @property 21 | def transfer_request_id(self): 22 | return self.__transfer_request_id 23 | 24 | @property 25 | def transfer_from_detail(self): 26 | return self.__transfer_from_detail 27 | 28 | @property 29 | def transfer_to_detail(self): 30 | return self.__transfer_to_detail 31 | 32 | def __parse_rsp_body(self, rsp_body): 33 | response = super(AlipayCreatePayoutResponse, self).parse_rsp_body(rsp_body) 34 | if "transferId" in response: 35 | self.__transfer_id = response["transferId"] 36 | if "transferRequestId" in response: 37 | self.__transfer_request_id = response["transferRequestId"] 38 | if "transferFromDetail" in response: 39 | self.__transfer_from_detail = TransferFromDetail() 40 | self.__transfer_from_detail.parse_rsp_body(response["transferFromDetail"]) 41 | if "transferToDetail" in response: 42 | self.__transfer_to_detail = TransferToDetail() 43 | self.__transfer_to_detail.parse_rsp_body(response["transferToDetail"]) -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_create_transfer_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.transfer_from_detail import TransferFromDetail 2 | from com.alipay.ams.api.model.transfer_to_detail import TransferToDetail 3 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 4 | 5 | 6 | class AlipayCreateTransferResponse(AlipayResponse): 7 | def __init__(self, rsp_body): 8 | super(AlipayCreateTransferResponse, self).__init__() 9 | self.__transfer_id = None 10 | self.__transfer_request_id = None 11 | self.__transfer_from_detail = None #type: TransferFromDetail 12 | self.__transfer_to_detail = None #type: TransferToDetail 13 | self.__parse_rsp_body(rsp_body) 14 | 15 | @property 16 | def transfer_id(self): 17 | return self.__transfer_id 18 | 19 | @property 20 | def transfer_request_id(self): 21 | return self.__transfer_request_id 22 | 23 | 24 | @property 25 | def transfer_from_detail(self): 26 | return self.__transfer_from_detail 27 | 28 | @property 29 | def transfer_to_detail(self): 30 | return self.__transfer_to_detail 31 | 32 | def __parse_rsp_body(self, rsp_body): 33 | response = super(AlipayCreateTransferResponse, self).parse_rsp_body(rsp_body) 34 | if "transferId" in response: 35 | self.__transfer_id = response["transferId"] 36 | if "transferRequestId" in response: 37 | self.__transfer_request_id = response["transferRequestId"] 38 | if "transferFromDetail" in response: 39 | self.__transfer_from_detail = TransferFromDetail() 40 | self.__transfer_from_detail.parse_rsp_body(response["transferFromDetail"]) 41 | if "transferToDetail" in response: 42 | self.__transfer_to_detail = TransferToDetail() 43 | self.__transfer_to_detail.parse_rsp_body(response["transferToDetail"]) 44 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_inquire_balance_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.account_balance import AccountBalance 2 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 3 | 4 | 5 | class AlipayInquireBalanceResponse(AlipayResponse): 6 | def __init__(self, rsp_body): 7 | super(AlipayInquireBalanceResponse, self).__init__() 8 | self.__account_balances = None #type: list[AccountBalance] 9 | self.__parse_rsp_body(rsp_body) 10 | 11 | 12 | 13 | @property 14 | def account_balances(self): 15 | return self.__account_balances 16 | 17 | 18 | def __parse_rsp_body(self, rsp_body): 19 | response = super(AlipayInquireBalanceResponse, self).parse_rsp_body(rsp_body) 20 | if 'accountBalances' in response: 21 | accountBalances = [] 22 | for accountBalance_body in response['accountBalances']: 23 | accountBalance = AccountBalance() 24 | accountBalance.parse_rsp_body(accountBalance_body) 25 | accountBalances.append(accountBalance) 26 | self.__account_balances = accountBalances -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_register_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayRegisterResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipayRegisterResponse, self).__init__() 7 | self.__registration_status = None 8 | self.__parse_rsp_body(rsp_body) 9 | 10 | @property 11 | def registration_status(self): 12 | return self.__registration_status 13 | 14 | def __parse_rsp_body(self, rsp_body): 15 | response = super(AlipayRegisterResponse, self).parse_rsp_body(rsp_body) 16 | if 'registrationStatus' in response: 17 | self.__registration_status = response['registrationStatus'] 18 | 19 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_settle_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySettleResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipaySettleResponse, self).__init__() 7 | self.__settlement_request_id = None 8 | self.__settlement_id = None 9 | self.__parse_rsp_body(rsp_body) 10 | 11 | @property 12 | def settlement_request_id(self): 13 | return self.__settlement_request_id 14 | 15 | 16 | @property 17 | def settlement_id(self): 18 | return self.__settlement_id 19 | 20 | def __parse_rsp_body(self, rsp_body): 21 | response = super(AlipaySettleResponse, self).parse_rsp_body(rsp_body) 22 | if 'settlementRequestId' in response: 23 | self.__settlement_request_id = response['settlementRequestId'] 24 | if 'settlementId' in response: 25 | self.__settlement_id = response['settlementId'] -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_settlement_info_update_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySettlementInfoUpdateResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipaySettlementInfoUpdateResponse, self).__init__() 7 | self.__update_status = None 8 | self.__parse_rsp_body(rsp_body) 9 | 10 | @property 11 | def update_status(self): 12 | return self.__update_status 13 | 14 | def __parse_rsp_body(self, rsp_body): 15 | response = super(AlipaySettlementInfoUpdateResponse, self).parse_rsp_body(rsp_body) 16 | if 'updateStatus' in response: 17 | self.__update_status = response['updateStatus'] -------------------------------------------------------------------------------- /com/alipay/ams/api/response/marketplace/alipay_submit_attachment_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.attachment_type import AttachmentType 2 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 3 | 4 | 5 | class AlipaySubmitAttachmentResponse(AlipayResponse): 6 | def __init__(self, rsp_body): 7 | super(AlipaySubmitAttachmentResponse, self).__init__() 8 | self.__submit_attachment_request_id = None 9 | self.__attachment_type = None #type: AttachmentType 10 | self.__attachment_key = None 11 | self.__parse_rsp_body(rsp_body) 12 | 13 | @property 14 | def submit_attachment_request_id(self): 15 | return self.__submit_attachment_request_id 16 | 17 | @property 18 | def attachment_type(self): 19 | return self.__attachment_type 20 | 21 | @property 22 | def attachment_key(self): 23 | return self.__attachment_key 24 | 25 | def __parse_rsp_body(self, rsp_body): 26 | response = super(AlipaySubmitAttachmentResponse, self).parse_rsp_body(rsp_body) -------------------------------------------------------------------------------- /com/alipay/ams/api/response/merchant/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/merchant/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/merchant/alipay_merchant_registration_info_query_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayMerchantRegistrationInfoQueryResponse(AlipayResponse): 5 | 6 | def __init__(self, rsp_body): 7 | super(AlipayMerchantRegistrationInfoQueryResponse, self).__init__() 8 | self.__merchant_info = None 9 | self.__product_codes = None 10 | self.__parse_rsp_body(rsp_body) 11 | 12 | @property 13 | def merchant_info(self): 14 | return self.__merchant_info 15 | 16 | @property 17 | def product_codes(self): 18 | return self.__product_codes 19 | 20 | def __parse_rsp_body(self, rsp_body): 21 | response = super(AlipayMerchantRegistrationInfoQueryResponse, self).parse_rsp_body(rsp_body) 22 | if 'merchantInfo' in response: 23 | self.__merchant_info = response['merchantInfo'] 24 | if 'productCodes' in response: 25 | self.__product_codes = response['productCodes'] 26 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/merchant/alipay_merchant_registration_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayMerchantRegistrationResponse(AlipayResponse): 5 | 6 | def __init__(self, rsp_body): 7 | super(AlipayMerchantRegistrationResponse, self).__init__() 8 | self.__pass_through_info = None 9 | self.__parse_rsp_body(rsp_body) 10 | 11 | @property 12 | def pass_through_info(self): 13 | return self.__pass_through_info 14 | 15 | def __parse_rsp_body(self, rsp_body): 16 | response = super(AlipayMerchantRegistrationResponse, self).parse_rsp_body(rsp_body) 17 | 18 | if 'passThroughInfo' in response: 19 | pass_through_info = response['passThroughInfo'] 20 | self.__pass_through_info = pass_through_info 21 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/merchant/alipay_merchant_registration_status_query_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayMerchantRegistrationStatusQueryResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipayMerchantRegistrationStatusQueryResponse, self).__init__() 7 | self.__registration_result = None 8 | self.__psp_registration_result_list = None 9 | self.__parse_rsp_body(rsp_body) 10 | 11 | @property 12 | def registration_result(self): 13 | return self.__registration_result 14 | 15 | @property 16 | def psp_registration_result_list(self): 17 | return self.__psp_registration_result_list 18 | 19 | def __parse_rsp_body(self, rsp_body): 20 | response = super(AlipayMerchantRegistrationStatusQueryResponse, self).parse_rsp_body(rsp_body) 21 | if 'registrationResult' in response: 22 | self.__registration_result = response['registrationResult'] 23 | 24 | if 'pspRegistrationResultList' in response: 25 | self.__psp_registration_result_list = response['pspRegistrationResultList'] 26 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/pay/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/alipay_capture_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.model.amount import Amount 5 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 6 | 7 | 8 | class AlipayCaptureResponse(AlipayResponse): 9 | 10 | def __init__(self, rsp_body): 11 | super(AlipayCaptureResponse, self).__init__() 12 | self.__capture_request_id = None 13 | self.__capture_id = None 14 | self.__payment_id = None 15 | self.__capture_amount = None # type: Amount 16 | self.__capture_time = None 17 | self.__acquirer_reference_no = None 18 | self.__parse_rsp_body(rsp_body) 19 | 20 | @property 21 | def capture_request_id(self): 22 | return self.__capture_request_id 23 | 24 | @property 25 | def capture_id(self): 26 | return self.__capture_id 27 | 28 | @property 29 | def payment_id(self): 30 | return self.__payment_id 31 | 32 | @property 33 | def capture_amount(self): 34 | return self.__capture_amount 35 | 36 | @property 37 | def capture_time(self): 38 | return self.__capture_time 39 | 40 | @property 41 | def acquirer__reference__no(self): 42 | return self.__acquirer_reference_no 43 | 44 | def __parse_rsp_body(self, rsp_body): 45 | response = super(AlipayCaptureResponse, self).parse_rsp_body(rsp_body) 46 | if 'captureRequestId' in response: 47 | self.__capture_request_id = response['captureRequestId'] 48 | if 'paymentId' in response: 49 | self.__payment_id = response['paymentId'] 50 | if 'captureId' in response: 51 | self.__capture_id = response['captureId'] 52 | if 'captureAmount' in response: 53 | capture_amount = Amount() 54 | capture_amount.parse_rsp_body(response['captureAmount']) 55 | self.__capture_amount = capture_amount 56 | if 'captureTime' in response: 57 | self.__capture_time = response['captureTime'] 58 | if 'acquirerReferenceNo' in response: 59 | self.__acquirer_reference_no = response['acquirerReferenceNo'] 60 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/alipay_create_order_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.model.amount import Amount 5 | from com.alipay.ams.api.model.redirect_action_form import RedirectActionForm 6 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 7 | 8 | 9 | class AlipayCreateOrderResponse(AlipayResponse): 10 | 11 | def __init__(self, rsp_body): 12 | super(AlipayCreateOrderResponse, self).__init__() 13 | self.__payment_request_id = None 14 | self.__payment_id = None 15 | self.__client_payment_token = None 16 | self.__payment_amount = None # type: Amount 17 | self.__redirect_action_form = None 18 | self.__parse_rsp_body(rsp_body) 19 | 20 | @property 21 | def payment_request_id(self): 22 | return self.__payment_request_id 23 | 24 | @property 25 | def payment_id(self): 26 | return self.__payment_id 27 | 28 | @property 29 | def client_payment_token(self): 30 | return self.__client_payment_token 31 | 32 | @property 33 | def payment_amount(self): 34 | return self.__payment_amount 35 | 36 | @property 37 | def redirect_action_form(self): 38 | return self.__redirect_action_form 39 | 40 | def __parse_rsp_body(self, rsp_body): 41 | response = super(AlipayCreateOrderResponse, self).parse_rsp_body(rsp_body) 42 | if 'paymentRequestId' in response: 43 | self.__payment_request_id = response['paymentRequestId'] 44 | if 'paymentId' in response: 45 | self.__payment_id = response['paymentId'] 46 | if 'paymentAmount' in response: 47 | payment_amount = Amount() 48 | payment_amount.parse_rsp_body(response['paymentAmount']) 49 | self.__payment_amount = payment_amount 50 | if 'clientPaymentToken' in response: 51 | self.__client_payment_token = response['clientPaymentToken'] 52 | if 'redirectActionForm' in response: 53 | redirect_action_form = RedirectActionForm() 54 | redirect_action_form.parse_rsp_body(response['redirectActionForm']) 55 | self.__redirect_action_form = redirect_action_form 56 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/alipay_create_session_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayCreateSessionResponse(AlipayResponse): 5 | 6 | def __init__(self, rsp_body): 7 | super(AlipayCreateSessionResponse, self).__init__() 8 | self.__payment_session_data = None 9 | self.__payment_session_expiry_time = None 10 | self.__payment_session_id = None 11 | self.__parse_rsp_body(rsp_body) 12 | 13 | @property 14 | def payment_session_data(self): 15 | return self.__payment_session_data 16 | 17 | @property 18 | def payment_session_expiry_time(self): 19 | return self.__payment_session_expiry_time 20 | 21 | @property 22 | def payment_session_id(self): 23 | return self.__payment_session_id 24 | 25 | def __parse_rsp_body(self, rsp_body): 26 | rsp_json = super(AlipayCreateSessionResponse, self).parse_rsp_body(rsp_body) 27 | if 'paymentSessionData' in rsp_json: 28 | self.__payment_session_data = rsp_json['paymentSessionData'] 29 | if 'paymentSessionExpiryTime' in rsp_json: 30 | self.__payment_session_expiry_time = rsp_json['paymentSessionExpiryTime'] 31 | if 'paymentSessionId' in rsp_json: 32 | self.__payment_session_id = rsp_json['paymentSessionId'] 33 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/alipay_pay_cancel_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayPayCancelResponse(AlipayResponse): 8 | def __init__(self, rsp_body): 9 | super(AlipayPayCancelResponse, self).__init__() 10 | self.__payment_id = None 11 | self.__payment_request_id = None 12 | self.__cancel_time = None 13 | self.__parse_rsp_body(rsp_body) 14 | 15 | @property 16 | def payment_request_id(self): 17 | return self.__payment_request_id 18 | 19 | @property 20 | def payment_id(self): 21 | return self.__payment_id 22 | 23 | @property 24 | def cancel_time(self): 25 | return self.__cancel_time 26 | 27 | def __parse_rsp_body(self, rsp_body): 28 | response = super(AlipayPayCancelResponse, self).parse_rsp_body(rsp_body) 29 | if 'paymentRequestId' in response: 30 | self.__payment_request_id = response['paymentRequestId'] 31 | if 'paymentId' in response: 32 | self.__payment_id = response['paymentId'] 33 | if 'cancelTime' in response: 34 | self.__cancel_time = response['cancelTime'] 35 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/alipay_pay_consult_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.model.payment_method_info import PaymentMethodInfo 5 | from com.alipay.ams.api.model.payment_option import PaymentOption 6 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 7 | 8 | 9 | class AlipayPayConsultResponse(AlipayResponse): 10 | 11 | def __init__(self, rsp_body): 12 | super(AlipayPayConsultResponse, self).__init__() 13 | self.__payment_options = None # type:PaymentOption 14 | self.__payment_method_infos = None 15 | self.__extend_info = None 16 | self.__parse_rsp_body(rsp_body) 17 | 18 | @property 19 | def payment_options(self): 20 | return self.__payment_options 21 | 22 | @property 23 | def payment_method_infos(self): 24 | return self.__payment_method_infos 25 | 26 | @property 27 | def extend_info(self): 28 | return self.__extend_info 29 | 30 | def __parse_rsp_body(self, rsp_body): 31 | response = super(AlipayPayConsultResponse, self).parse_rsp_body(rsp_body) 32 | if 'paymentOptions' in response: 33 | payment_options = PaymentOption() 34 | payment_options.parse_rsp_body(response['paymentOptions']) 35 | self.__payment_options = payment_options 36 | if 'paymentMethodInfos' in response: 37 | payment_method_infos = PaymentMethodInfo() 38 | payment_method_infos.parse_rsp_body(response['paymentMethodInfos']) 39 | self.__payment_method_infos = payment_method_infos 40 | if 'extendInfo' in response: 41 | self.__extend_info = response['extendInfo'] 42 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/pay/alipay_upload_invoice_shipping_file_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayUploadInvoiceShippingFileResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipayUploadInvoiceShippingFileResponse, self).__init__() 7 | self.__parse_rsp_body(rsp_body) 8 | 9 | def __parse_rsp_body(self, rsp_body): 10 | response = super(AlipayUploadInvoiceShippingFileResponse, self).parse_rsp_body(rsp_body) 11 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/risks/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/risks/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/risks/inquiry_risk_score_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.model.risk_score_result import RiskScoreResult 5 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 6 | 7 | 8 | class InquiryRiskScoreResponse(AlipayResponse): 9 | 10 | def __init__(self, rsp_body): 11 | super(InquiryRiskScoreResponse, self).__init__() 12 | self.__result = None 13 | self.__risk_score_results = None 14 | self.__parse_rsp_body(rsp_body) 15 | 16 | @property 17 | def result(self): 18 | return self.__result 19 | 20 | @result.setter 21 | def result(self, value): 22 | self.__result = value 23 | 24 | @property 25 | def risk_score_results(self): 26 | return self.__risk_score_results 27 | 28 | @risk_score_results.setter 29 | def risk_score_results(self, value): 30 | self.__risk_score_results = value 31 | 32 | def __parse_rsp_body(self, rsp_body): 33 | response = super(InquiryRiskScoreResponse, self).parse_rsp_body(rsp_body) 34 | if 'result' in response: 35 | self.__result = response['result'] 36 | 37 | if 'risk_score_results' in response: 38 | self.__risk_score_results = [] 39 | for entry in response['risk_score_results']: 40 | risk_score_result = RiskScoreResult() 41 | risk_score_result.parse_rsp_body(entry) 42 | self.__risk_score_results.append(risk_score_result) 43 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/risks/risk_decide_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class RiskDecideResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(RiskDecideResponse, self).__init__() 7 | self.__decision = None 8 | self.__authentication_decision = None 9 | self.__parse_rsp_body(rsp_body) 10 | 11 | @property 12 | def decision(self): 13 | return self.__decision 14 | 15 | @decision.setter 16 | def decision(self, decision): 17 | self.__decision = decision 18 | 19 | @property 20 | def authentication_decision(self): 21 | return self.__authentication_decision 22 | 23 | 24 | @authentication_decision.setter 25 | def authentication_decision(self, authentication_decision): 26 | self.__authentication_decision = authentication_decision 27 | 28 | 29 | def __parse_rsp_body(self, rsp_body): 30 | response = super(RiskDecideResponse, self).parse_rsp_body(rsp_body) 31 | if "decision" in response: 32 | self.decision = response["decision"] 33 | if "authentication_decision" in response: 34 | self.authentication_decision = response["authenticationDecision"] -------------------------------------------------------------------------------- /com/alipay/ams/api/response/risks/risk_report_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class RiskReportResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(RiskReportResponse, self).__init__() 7 | self.__parse_rsp_body(rsp_body) 8 | 9 | 10 | def __parse_rsp_body(self, rsp_body): 11 | response = super(RiskReportResponse, self).parse_rsp_body(rsp_body) 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/risks/send_payment_result_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class SendPaymentResultResponse(AlipayResponse): 5 | 6 | def __init__(self, rsp_body): 7 | super(SendPaymentResultResponse, self).__init__() 8 | self.__parse_rsp_body(rsp_body) 9 | 10 | def __parse_rsp_body(self, rsp_body): 11 | response = super(SendPaymentResultResponse, self).parse_rsp_body(rsp_body) 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/risks/send_refund_result_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class SendRefundResultResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(SendRefundResultResponse, self).__init__() 7 | self.__parse_rsp_body(rsp_body) 8 | 9 | 10 | def __parse_rsp_body(self, rsp_body): 11 | response = super(SendRefundResultResponse, self).parse_rsp_body(rsp_body) -------------------------------------------------------------------------------- /com/alipay/ams/api/response/subscription/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/subscription/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/subscription/alipay_subscription_cancel_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySubscriptionCancelResponse(AlipayResponse): 5 | 6 | def __init__(self, rsp_body): 7 | super(AlipaySubscriptionCancelResponse, self).__init__() 8 | 9 | self.__parse_rsp_body(rsp_body) 10 | 11 | def __parse_rsp_body(self, rsp_body): 12 | rsp_dict = super(AlipaySubscriptionCancelResponse, self).parse_rsp_body(rsp_body) 13 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/subscription/alipay_subscription_change_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySubscriptionChangeResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipaySubscriptionChangeResponse, self).__init__() 7 | 8 | self.__parse_rsp_body(rsp_body) 9 | 10 | def __parse_rsp_body(self, rsp_body): 11 | rsp_dict = super(AlipaySubscriptionChangeResponse, self).parse_rsp_body(rsp_body) 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/subscription/alipay_subscription_create_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySubscriptionCreateResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipaySubscriptionCreateResponse, self).__init__() 7 | self.__scheme_url = None 8 | self.__applink_url = None 9 | self.__normal_url = None 10 | self.__app_identifier = None 11 | self.__parse_rsp_body(rsp_body) 12 | 13 | @property 14 | def scheme_url(self): 15 | return self.__scheme_url 16 | 17 | @property 18 | def applink_url(self): 19 | return self.__applink_url 20 | 21 | @property 22 | def normal_url(self): 23 | return self.__normal_url 24 | 25 | @property 26 | def app_identifier(self): 27 | return self.__app_identifier 28 | 29 | def __parse_rsp_body(self, rsp_body): 30 | rsp_dict = super(AlipaySubscriptionCreateResponse, self).parse_rsp_body(rsp_body) 31 | if rsp_dict.get('schemeUrl'): 32 | self.__scheme_url = rsp_dict.get('schemeUrl') 33 | if rsp_dict.get('applinkUrl'): 34 | self.__applink_url = rsp_dict.get('applinkUrl') 35 | if rsp_dict.get('normalUrl'): 36 | self.__normal_url = rsp_dict.get('normalUrl') 37 | if rsp_dict.get('appIdentifier'): 38 | self.__app_identifier = rsp_dict.get('appIdentifier') 39 | 40 | 41 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/subscription/alipay_subscription_update_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipaySubscriptionUpdateResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipaySubscriptionUpdateResponse, self).__init__() 7 | self.__parse_rsp_body(rsp_body) 8 | 9 | 10 | def __parse_rsp_body(self, rsp_body): 11 | rsp_dict = super(AlipaySubscriptionUpdateResponse, self).parse_rsp_body(rsp_body) 12 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/users/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/users/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/users/alipay_init_authentication_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayInitAuthenticationResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayInitAuthenticationResponse, self).__init__() 11 | self.__authentication_request_id = None 12 | self.__parse_rsp_body(rsp_body) 13 | 14 | @property 15 | def authentication_request_id(self): 16 | return self.__authentication_request_id 17 | 18 | def __parse_rsp_body(self, rsp_body): 19 | response = super(AlipayInitAuthenticationResponse, self).parse_rsp_body(rsp_body) 20 | if 'authenticationRequestId' in response: 21 | self.__authentication_request_id = response['authenticationRequestId'] 22 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/users/alipay_user_query_info_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayUserQueryInfoResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayUserQueryInfoResponse, self).__init__() 11 | self.__user_id = None 12 | self.__user_login_id = None 13 | self.__hash_user_login_id = None 14 | self.__parse_rsp_body(rsp_body) 15 | 16 | @property 17 | def user_id(self): 18 | return self.__user_id 19 | 20 | @property 21 | def user_login_id(self): 22 | return self.__user_login_id 23 | 24 | @property 25 | def hash_user_login_id(self): 26 | return self.__hash_user_login_id 27 | 28 | def __parse_rsp_body(self, rsp_body): 29 | response = super(AlipayUserQueryInfoResponse, self).parse_rsp_body(rsp_body) 30 | if 'userId' in response: 31 | self.__user_id = response['userId'] 32 | 33 | if 'userLoginId' in response: 34 | self.__user_login_id = response['userLoginId'] 35 | 36 | if 'hashUserLoginId' in response: 37 | self.__hash_user_login_id = response['hashUserLoginId'] 38 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/users/alipay_verify_authentication_response.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayVerifyAuthenticationResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayVerifyAuthenticationResponse, self).__init__() 11 | self.__is_passed = None 12 | self.__parse_rsp_body(rsp_body) 13 | 14 | @property 15 | def is_passed(self): 16 | return self.__is_passed 17 | 18 | def __parse_rsp_body(self, rsp_body): 19 | response = super(AlipayVerifyAuthenticationResponse, self).parse_rsp_body(rsp_body) 20 | if 'isPassed' in response: 21 | self.__is_passed = response['isPassed'] 22 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/vaulting/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/response/vaulting/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/response/vaulting/alipay_vaulting_payment_method_response.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from com.alipay.ams.api.model.payment_method_detail import PaymentMethodDetail 4 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 5 | 6 | 7 | class AlipayVaultingPaymentMethodResponse(AlipayResponse): 8 | 9 | def __init__(self, rsp_body): 10 | super(AlipayVaultingPaymentMethodResponse, self).__init__() 11 | self.__vaulting_request_id = None 12 | self.__payment_method_detail = None #type: PaymentMethodDetail 13 | self.__normal_url = None 14 | self.__scheme_url = None 15 | self.__applink_url = None 16 | self.__parse_rsp_body(rsp_body) 17 | 18 | @property 19 | def vaulting_request_id(self): 20 | return self.__vaulting_request_id 21 | 22 | @property 23 | def payment_method_detail(self): 24 | return self.__payment_method_detail 25 | 26 | @property 27 | def normal_url(self): 28 | return self.__normal_url 29 | 30 | @property 31 | def scheme_url(self): 32 | return self.__scheme_url 33 | 34 | @property 35 | def applink_url(self): 36 | return self.__applink_url 37 | 38 | 39 | def __parse_rsp_body(self, rsp_body): 40 | rsp_dict = super(AlipayVaultingPaymentMethodResponse, self).parse_rsp_body(rsp_body) 41 | if 'vaultingRequestId' in rsp_dict: 42 | self.__vaulting_request_id = rsp_dict['vaultingRequestId'] 43 | if 'paymentMethodDetail' in rsp_dict: 44 | self.__payment_method_detail = PaymentMethodDetail.parse_rsp_body(rsp_dict['paymentMethodDetail']) 45 | if 'normalUrl' in rsp_dict: 46 | self.__normal_url = rsp_dict['normalUrl'] 47 | if 'schemeUrl' in rsp_dict: 48 | self.__scheme_url = rsp_dict['schemeUrl'] 49 | if 'applinkUrl' in rsp_dict: 50 | self.__applink_url = rsp_dict['applinkUrl'] -------------------------------------------------------------------------------- /com/alipay/ams/api/response/vaulting/alipay_vaulting_query_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.model.payment_method_detail import PaymentMethodDetail 2 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 3 | 4 | 5 | class AlipayVaultingQueryResponse(AlipayResponse): 6 | def __init__(self, rsp_body): 7 | super(AlipayVaultingQueryResponse, self).__init__() 8 | self.__vaulting_request_id = None 9 | self.__normal_url = None 10 | self.__scheme_url = None 11 | self.__applink_url = None 12 | self.__vaulting_status = None 13 | self.__payment_method_detail = None #type: PaymentMethodDetail 14 | self.__parse_rsp_body(rsp_body) 15 | 16 | @property 17 | def vaulting_request_id(self): 18 | return self.__vaulting_request_id 19 | 20 | @property 21 | def normal_url(self): 22 | return self.__normal_url 23 | 24 | @property 25 | def scheme_url(self): 26 | return self.__scheme_url 27 | 28 | @property 29 | def applink_url(self): 30 | return self.__applink_url 31 | 32 | @property 33 | def vaulting_status(self): 34 | return self.__vaulting_status 35 | 36 | @property 37 | def payment_method_detail(self): 38 | return self.__payment_method_detail 39 | 40 | def __parse_rsp_body(self, rsp_body): 41 | rsp_dict = super(AlipayVaultingQueryResponse, self).parse_rsp_body(rsp_body) 42 | if 'vaultingRequestId' in rsp_dict: 43 | self.__vaulting_request_id = rsp_dict['vaultingRequestId'] 44 | if 'normalUrl' in rsp_dict: 45 | self.__normal_url = rsp_dict['normalUrl'] 46 | if 'schemeUrl' in rsp_dict: 47 | self.__scheme_url = rsp_dict['schemeUrl'] 48 | if 'applinkUrl' in rsp_dict: 49 | self.__applink_url = rsp_dict['applinkUrl'] 50 | if 'vaultingStatus' in rsp_dict: 51 | self.__vaulting_status = rsp_dict['vaultingStatus'] 52 | if 'paymentMethodDetail' in rsp_dict: 53 | self.__payment_method_detail = PaymentMethodDetail.parse_rsp_body(rsp_dict['paymentMethodDetail']) 54 | -------------------------------------------------------------------------------- /com/alipay/ams/api/response/vaulting/alipay_vaulting_session_response.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.response.alipay_response import AlipayResponse 2 | 3 | 4 | class AlipayVaultingSessionResponse(AlipayResponse): 5 | def __init__(self, rsp_body): 6 | super(AlipayVaultingSessionResponse, self).__init__() 7 | self.__vaulting_session_data = None 8 | self.__vaulting_session_id = None 9 | self.__vaulting_session_expiry_time = None 10 | self.__parse_rsp_body(rsp_body) 11 | 12 | @property 13 | def vaulting_session_data(self): 14 | return self.__vaulting_session_data 15 | 16 | @property 17 | def vaulting_session_id(self): 18 | return self.__vaulting_session_id 19 | @property 20 | def vaulting_session_expiry_time(self): 21 | return self.__vaulting_session_expiry_time 22 | 23 | def __parse_rsp_body(self, rsp_body): 24 | rsp_dict = super(AlipayVaultingSessionResponse, self).parse_rsp_body(rsp_body) 25 | if 'vaultingSessionData' in rsp_dict: 26 | self.__vaulting_session_data = rsp_dict['vaultingSessionData'] 27 | if 'vaultingSessionId' in rsp_dict: 28 | self.__vaulting_session_id = rsp_dict['vaultingSessionId'] 29 | if 'vaultingSessionExpiryTime' in rsp_dict: 30 | self.__vaulting_session_expiry_time = rsp_dict['vaultingSessionExpiryTime'] 31 | 32 | -------------------------------------------------------------------------------- /com/alipay/ams/api/tools/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/com/alipay/ams/api/tools/__init__.py -------------------------------------------------------------------------------- /com/alipay/ams/api/tools/constants.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | import sys 4 | 5 | IS_PYTHON_VERSION_3 = True 6 | if sys.version_info < (3, 0): 7 | IS_PYTHON_VERSION_3 = False 8 | 9 | IS_PYTHON_VERSION_cryptography = True 10 | if sys.version_info < (2.7, 0): 11 | IS_PYTHON_VERSION_3 = False 12 | 13 | DEFAULT_KEY_VERSION = "1" 14 | 15 | DEFAULT_CHARSET = "UTF-8" 16 | 17 | DEFAULT_TIMEOUT = 15 18 | -------------------------------------------------------------------------------- /com/alipay/ams/api/tools/date_tools.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import time 5 | 6 | ''' 7 | python3.2前版本中需要，时区支持 8 | ''' 9 | try: 10 | import pytz 11 | except ImportError: 12 | pass 13 | 14 | from com.alipay.ams.api.tools.constants import * 15 | from datetime import datetime 16 | 17 | ''' 18 | python version > 3.2有timezone模块 19 | ''' 20 | try: 21 | from datetime import timezone 22 | except ImportError: 23 | pass 24 | 25 | 26 | def get_cur_iso8601_time(): 27 | if not IS_PYTHON_VERSION_3: 28 | return datetime.fromtimestamp(int(time.time()), tz=pytz.timezone('UTC')).isoformat() 29 | else: 30 | return datetime.fromtimestamp(int(time.time()), tz=timezone.utc).isoformat() 31 | -------------------------------------------------------------------------------- /com/alipay/ams/api/tools/webhook_tool.py: -------------------------------------------------------------------------------- 1 | from com.alipay.ams.api.exception.exception import AlipayApiException 2 | 3 | from com.alipay.ams.api.tools.signature_tool import verify 4 | 5 | 6 | def check_signature(http_method, path, client_id, req_time_str, req_body, signature, alipay_public_key): 7 | if signature and 'signature=' in signature: 8 | signature = signature.split('signature=')[1] 9 | return verify(http_method, path, client_id, req_time_str, req_body, signature, alipay_public_key) 10 | raise AlipayApiException('signature invalid:' + str(signature)) 11 | -------------------------------------------------------------------------------- /example/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alipay/global-open-sdk-python/3fb9198eb4422483c439eb5181c0e33755efbc20/example/__init__.py -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | [metadata] 2 | name = global-alipay-sdk-python 3 | version = 1.4.4 4 | 5 | [options] 6 | packages = find: 7 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | from setuptools import setup, find_packages 4 | 5 | ''' 6 | setup module for core. 7 | Created on 5/20/2020 8 | @author: songlin.xiesl、guangling.zgl 9 | ''' 10 | NAME = "global-open-sdk-python" 11 | DESCRIPTION = "The global alipay gateway SDK for Python." 12 | AUTHOR = "guodong.wzj" 13 | AUTHOR_EMAIL = "wangzunjiao.wzj@digital-engine.com" 14 | URL = "https://github.com/alipay/global-open-sdk-python" 15 | VERSION = "1.4.4" 16 | ''' 17 | only python2 need enum34、pytz 18 | ''' 19 | requires = ["enum34", "pytz", "pycryptodome", "rsa", "cryptography"] 20 | 21 | setup( 22 | name=NAME, 23 | version=VERSION, 24 | description=DESCRIPTION, 25 | author=AUTHOR, 26 | author_email=AUTHOR_EMAIL, 27 | license="MIT", 28 | url=URL, 29 | keywords=["global", "alipay", "sdk"], 30 | packages=find_packages(exclude=["example"]), 31 | include_package_data=True, 32 | platforms='any', 33 | install_requires=requires, 34 | classifiers=[ 35 | 'Intended Audience :: Developers', 36 | 'License :: OSI Approved :: MIT License', 37 | 'Programming Language :: Python', 38 | 'Programming Language :: Python :: 2.7', 39 | 'Programming Language :: Python :: 3.2', 40 | 'Programming Language :: Python :: 3.3', 41 | 'Programming Language :: Python :: 3.4', 42 | 'Programming Language :: Python :: 3.5', 43 | 'Programming Language :: Python :: 3.6', 44 | 'Programming Language :: Python :: 3.7', 45 | 'Programming Language :: Python :: 3.8', 46 | 'Programming Language :: Python :: 3.9', 47 | 'Programming Language :: Python :: 3.10', 48 | 'Programming Language :: Python :: 3.11', 49 | 'Programming Language :: Python :: 3.12', 50 | 'Topic :: Software Development', 51 | ] 52 | ) 53 | --------------------------------------------------------------------------------