global-open-sdk-python 1.4.1__py3-none-any.whl

com/alipay/ams/api/model/registration_detail.py

@@ -0,0 +1,119 @@
+from com.alipay.ams.api.model.address import Address
+from com.alipay.ams.api.model.attachment import Attachment
+from com.alipay.ams.api.model.contact_info import ContactInfo
+
+
+class RegistrationDetail(object):
+    def __init__(self):
+        self.__legal_name = None
+        self.__attachments = None  # type: list[Attachment]
+        self.__contact_info = None  # type: ContactInfo
+        self.__registration_type = None
+        self.__registration_no = None
+        self.__registration_address = None  # type: Address
+        self.__business_type = None
+        self.__registration_effective_date = None
+        self.__registration_expire_date = None
+
+    @property
+    def legal_name(self):
+        return self.__legal_name
+
+    @legal_name.setter
+    def legal_name(self, value):
+        self.__legal_name = value
+
+    @property
+    def attachments(self):
+        return self.__attachments
+
+    @attachments.setter
+    def attachments(self, value):
+        self.__attachments = value
+
+    @property
+    def contact_info(self):
+        return self.__contact_info
+
+    @contact_info.setter
+    def contact_info(self, value):
+        self.__contact_info = value
+
+    @property
+    def registration_type(self):
+        return self.__registration_type
+
+    @registration_type.setter
+    def registration_type(self, value):
+        self.__registration_type = value
+
+    @property
+    def registration_no(self):
+        return self.__registration_no
+
+    @registration_no.setter
+    def registration_no(self, value):
+        self.__registration_no = value
+
+    @property
+    def registration_address(self):
+        return self.__registration_address
+
+    @registration_address.setter
+    def registration_address(self, value):
+        self.__registration_address = value
+
+    @property
+    def business_type(self):
+        return self.__business_type
+
+    @business_type.setter
+    def business_type(self, value):
+        self.__business_type = value
+
+    @property
+    def registration_effective_date(self):
+        return self.__registration_effective_date
+
+    @registration_effective_date.setter
+    def registration_effective_date(self, value):
+        self.__registration_effective_date = value
+
+    @property
+    def registration_expire_date(self):
+        return self.__registration_expire_date
+
+    @registration_expire_date.setter
+    def registration_expire_date(self, value):
+        self.__registration_expire_date = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "legal_name") and self.legal_name:
+            params['legalName'] = self.legal_name
+
+        if hasattr(self, "attachments") and self.attachments:
+            params['attachments'] = self.attachments
+
+        if hasattr(self, "contact_info") and self.contact_info:
+            params['contactInfo'] = self.contact_info
+
+        if hasattr(self, "registration_type") and self.registration_type:
+            params['registrationType'] = self.registration_type
+
+        if hasattr(self, "registration_no") and self.registration_no:
+            params['registrationNo'] = self.registration_no
+
+        if hasattr(self, "registration_address") and self.registration_address:
+            params['registrationAddress'] = self.registration_address
+
+        if hasattr(self, "business_type") and self.business_type:
+            params['businessType'] = self.business_type
+
+        if hasattr(self, "registration_effective_date") and self.registration_effective_date:
+            params['registrationEffectiveDate'] = self.registration_effective_date
+
+        if hasattr(self, "registration_expire_date") and self.registration_expire_date:
+            params['registrationExpireDate'] = self.registration_expire_date
+
+        return params

com/alipay/ams/api/model/result.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+
+from com.alipay.ams.api.model.result_status_type import ResultStatusType
+
+
+class Result(object):
+    def __init__(self):
+        self.__result_code = None
+        self.__result_message = None
+        self.__result_status = None
+
+    @property
+    def result_code(self):
+        return self.__result_code
+
+    @property
+    def result_message(self):
+        return self.__result_message
+
+    @property
+    def result_status(self):
+        return self.__result_status
+
+    def parse_rsp_body(self, result_body):
+        if type(result_body) == str:
+            result_body = json.loads(result_body)
+
+        if 'resultCode' in result_body:
+            self.__result_code = result_body['resultCode']
+
+        if 'resultMessage' in result_body:
+            self.__result_message = result_body['resultMessage']
+
+        if 'resultStatus' in result_body:
+            result_status = ResultStatusType.value_of(result_body['resultStatus'])
+            self.__result_status = result_status

com/alipay/ams/api/model/result_status_type.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from enum import Enum, unique
+
+
+@unique
+class ResultStatusType(Enum):
+    S = "S"
+    F = "F"
+    U = "U"
+
+    def to_ams_dict(self):
+        return self.name
+
+    @staticmethod
+    def value_of(value):
+        if not value:
+            return None
+
+        if ResultStatusType.S.value == value:
+            return ResultStatusType.S
+        elif ResultStatusType.F.value == value:
+            return ResultStatusType.F
+        elif ResultStatusType.U.value == value:
+            return ResultStatusType.U
+        else:
+            return None

com/alipay/ams/api/model/risk_score_detail.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+
+
+class RiskScoreDetail(object):
+
+    def __init__(self):
+        self.__risk_info_code = None
+        self.__risk_info_code_result = None
+
+    @property
+    def risk_info_code(self):
+        return self.__risk_info_code
+
+    @risk_info_code.setter
+    def risk_info_code(self, value):
+        self.__risk_info_code = value
+
+    @property
+    def risk_info_code_result(self):
+        return self.__risk_info_code_result
+
+    @risk_info_code_result.setter
+    def risk_info_code_result(self, value):
+        self.__risk_info_code_result = value
+
+    def parse_rsp_body(self, risk_score_detail_body):
+        if type(risk_score_detail_body) == str:
+            risk_score_detail_body = json.loads(risk_score_detail_body)
+
+        if 'riskInfoCode' in risk_score_detail_body:
+            self.__risk_info_code = risk_score_detail_body['riskInfoCode']
+
+        if 'riskInfoCodeResult' in risk_score_detail_body:
+            self.__risk_info_code_result = risk_score_detail_body['riskInfoCodeResult']

com/alipay/ams/api/model/risk_score_result.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+
+from com.alipay.ams.api.model.risk_score_detail import RiskScoreDetail
+from com.alipay.ams.api.model.risk_score_type import RiskScoreType
+
+
+class RiskScoreResult(object):
+
+    def __init__(self):
+        self.__risk_score_type = None  # type: RiskScoreType
+        self.__risk_score = None
+        self.__risk_score_details = None  # type: list[RiskScoreDetail]
+
+    @property
+    def risk_score_type(self):
+        return self.__risk_score_type
+
+    @risk_score_type.setter
+    def risk_score_type(self, value):
+        self.__risk_score_type = value
+
+    @property
+    def risk_score(self):
+        return self.__risk_score
+
+    @risk_score.setter
+    def risk_score(self, value):
+        self.__risk_score = value
+
+    @property
+    def risk_score_details(self):
+        return self.__risk_score_details
+
+    @risk_score_details.setter
+    def risk_score_details(self, value):
+        self.__risk_score_details = value
+
+    def parse_rsp_body(self, risk_score_result_body):
+        if type(risk_score_result_body) == str:
+            risk_score_result_body = json.loads(risk_score_result_body)
+
+        if 'riskScoreType' in risk_score_result_body:
+            risk_score_type = RiskScoreType.value_of(risk_score_result_body['riskScoreType'])
+            self.__risk_score_type = risk_score_type
+
+        if 'riskScore' in risk_score_result_body:
+            self.__risk_score = risk_score_result_body['riskScore']
+
+        if 'riskScoreDetails' in risk_score_result_body:
+            self.__risk_score_details = []
+            for entry in risk_score_result_body['riskScoreDetails']:
+                risk_score_detail = RiskScoreDetail()
+                risk_score_detail.parse_rsp_body(entry)
+                self.__risk_score_details.append(risk_score_detail)

com/alipay/ams/api/model/risk_score_type.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from enum import Enum, unique
+
+
+@unique
+class RiskScoreType(Enum):
+    NSF_SCORE = "NSF_SCORE"
+    FRAUD_SCORE = "FRAUD_SCORE"
+
+    def to_ams_dict(self):
+        return self.name
+
+    @staticmethod
+    def value_of(value):
+        if not value:
+            return None
+
+        if RiskScoreType.NSF_SCORE.value == value:
+            return RiskScoreType.NSF_SCORE
+        elif RiskScoreType.FRAUD_SCORE.value == value:
+            return RiskScoreType.FRAUD_SCORE
+        else:
+            return None

com/alipay/ams/api/model/scope_type.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from enum import Enum, unique
+
+
+@unique
+class ScopeType(Enum):
+    BASE_USER_INFO = "BASE_USER_INFO"
+    AGREEMENT_PAY = "AGREEMENT_PAY"
+    USER_INFO = "USER_INFO"
+    USER_LOGIN_ID = "USER_LOGIN_ID"
+    HASH_LOGIN_ID = "HASH_LOGIN_ID"
+    SEND_OTP = "SEND_OTP"
+    TAOBAO_REBIND = "TAOBAO_REBIND"
+
+    def to_ams_dict(self):
+        return self.name

com/alipay/ams/api/model/settle_to_type.py

@@ -0,0 +1,10 @@
+from enum import Enum, unique
+
+
+@unique
+class SettleToType(Enum):
+    SELLER = "SELLER"
+    MARKETPLACE = "MARKETPLACE"
+
+    def to_ams_dict(self):
+        return self.name

com/alipay/ams/api/model/settlement_bank_account.py

@@ -0,0 +1,143 @@
+from com.alipay.ams.api.model.account_holder_type import AccountHolderType
+from com.alipay.ams.api.model.account_type import AccountType
+from com.alipay.ams.api.model.address import Address
+
+
+class SettlementBankAccount:
+    def __init__(self):
+        self.__bank_account_no = None
+        self.__account_holder_name = None
+        self.__swift_code = None
+        self.__bank_region = None
+        self.__account_holder_type = None  # type: AccountHolderType
+        self.__routing_number = None
+        self.__branch_code = None
+        self.__account_holder_tIN = None
+        self.__account_type = None  # type: AccountType
+        self.__bank_name = None
+        self.__account_holder_address = None  # type: Address
+        self.__iban = None
+
+    @property
+    def bank_account_no(self):
+        return self.__bank_account_no
+
+    @bank_account_no.setter
+    def bank_account_no(self, value):
+        self.__bank_account_no = value
+
+    @property
+    def account_holder_name(self):
+        return self.__account_holder_name
+
+    @account_holder_name.setter
+    def account_holder_name(self, value):
+        self.__account_holder_name = value
+
+    @property
+    def swift_code(self):
+        return self.__swift_code
+
+    @swift_code.setter
+    def swift_code(self, value):
+        self.__swift_code = value
+
+    @property
+    def bank_region(self):
+        return self.__bank_region
+
+    @bank_region.setter
+    def bank_region(self, value):
+        self.__bank_region = value
+
+    @property
+    def account_holder_type(self):
+        return self.__account_holder_type
+
+    @account_holder_type.setter
+    def account_holder_type(self, value):
+        self.__account_holder_type = value
+
+    @property
+    def routing_number(self):
+        return self.__routing_number
+
+    @routing_number.setter
+    def routing_number(self, value):
+        self.__routing_number = value
+
+    @property
+    def branch_code(self):
+        return self.__branch_code
+
+    @branch_code.setter
+    def branch_code(self, value):
+        self.__branch_code = value
+
+    @property
+    def account_holder_tIN(self):
+        return self.__account_holder_tIN
+
+    @account_holder_tIN.setter
+    def account_holder_tIN(self, value):
+        self.__account_holder_tIN = value
+
+    @property
+    def account_type(self):
+        return self.__account_type
+
+    @account_type.setter
+    def account_type(self, value):
+        self.__account_type = value
+
+    @property
+    def bank_name(self):
+        return self.__bank_name
+
+    @bank_name.setter
+    def bank_name(self, value):
+        self.__bank_name = value
+
+    @property
+    def account_holder_address(self):
+        return self.__account_holder_address
+
+    @account_holder_address.setter
+    def account_holder_address(self, value):
+        self.__account_holder_address = value
+
+    @property
+    def iban(self):
+        return self.__iban
+
+    @iban.setter
+    def iban(self, value):
+        self.__iban = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "bank_account_no") and self.bank_account_no:
+            params['bankAccountNo'] = self.bank_account_no
+        if hasattr(self, "account_holder_name") and self.account_holder_name:
+            params['accountHolderName'] = self.account_holder_name
+        if hasattr(self, "swift_code") and self.swift_code:
+            params['swiftCode'] = self.swift_code
+        if hasattr(self, "bank_region") and self.bank_region:
+            params['bankRegion'] = self.bank_region
+        if hasattr(self, "account_holder_type") and self.account_holder_type:
+            params['accountHolderType'] = self.account_holder_type.value
+        if hasattr(self, "routing_number") and self.routing_number:
+            params['routingNumber'] = self.routing_number
+        if hasattr(self, "branch_code") and self.branch_code:
+            params['branchCode'] = self.branch_code
+        if hasattr(self, "account_holder_tIN") and self.account_holder_tIN:
+            params['accountHolderTIN'] = self.account_holder_tIN
+        if hasattr(self, "account_type") and self.account_type:
+            params['accountType'] = self.account_type.value
+        if hasattr(self, "bank_name") and self.bank_name:
+            params['bankName'] = self.bank_name
+        if hasattr(self, "account_holder_address") and self.account_holder_address:
+            params['accountHolderAddress'] = self.account_holder_address.to_ams_dict()
+        if hasattr(self, "iban") and self.iban:
+            params['iban'] = self.iban
+        return params

com/alipay/ams/api/model/settlement_detail.py

@@ -0,0 +1,32 @@
+from com.alipay.ams.api.model.amount import Amount
+from com.alipay.ams.api.model.settle_to_type import SettleToType
+
+
+class SettlementDetail:
+    def __init__(self):
+        self.__settle_to = None #type: SettleToType
+        self.__settlement_amount = None #type: Amount
+
+    @property
+    def settle_to(self):
+        return self.__settle_to
+
+    @settle_to.setter
+    def settle_to(self, value):
+        self.__settle_to = value
+
+    @property
+    def settlement_amount(self):
+        return self.__settlement_amount
+
+    @settlement_amount.setter
+    def settlement_amount(self, value):
+        self.__settlement_amount = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, 'settle_to') and self.settle_to:
+            params['settleTo'] = self.settle_to.value
+        if hasattr(self, 'settlement_amount') and self.settlement_amount:
+            params['settlementAmount'] = self.settlement_amount.to_ams_dict()
+        return params

com/alipay/ams/api/model/settlement_info.py

@@ -0,0 +1,31 @@
+from com.alipay.ams.api.model.settlement_bank_account import SettlementBankAccount
+
+
+class SettlementInfo:
+    def __init__(self):
+        self.__settlement_currency = None
+        self.__settlement_bank_account = None #type: SettlementBankAccount
+
+    @property
+    def settlement_currency(self):
+        return self.__settlement_currency
+
+    @settlement_currency.setter
+    def settlement_currency(self, value):
+        self.__settlement_currency = value
+
+    @property
+    def settlement_bank_account(self):
+        return self.__settlement_bank_account
+
+    @settlement_bank_account.setter
+    def settlement_bank_account(self, value):
+        self.__settlement_bank_account = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, 'settlement_currency') and self.settlement_currency:
+            params['settlementCurrency'] = self.settlement_currency
+        if hasattr(self, 'settlement_bank_account') and self.settlement_bank_account:
+            params['settlementBankAccount'] = self.settlement_bank_account.to_ams_dict()
+        return params

com/alipay/ams/api/model/settlement_strategy.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class SettlementStrategy(object):
+    def __init__(self):
+        self.__settlement_currency = None
+
+    @property
+    def settlement_currency(self):
+        return self.__settlement_currency
+
+    @settlement_currency.setter
+    def settlement_currency(self, value):
+        self.__settlement_currency = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "settlement_currency") and self.settlement_currency:
+            params['settlementCurrency'] = self.settlement_currency
+
+        return params

com/alipay/ams/api/model/shipping.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from com.alipay.ams.api.model.address import Address
+from com.alipay.ams.api.model.user_name import UserName
+
+
+class Shipping(object):
+
+    def __init__(self):
+        self.__shipping_name = None  # type:UserName
+        self.__shipping_address = None  # type:Address
+        self.__shipping_carrier = None
+        self.__shipping_phone_no = None
+
+    @property
+    def shipping_name(self):
+        return self.__shipping_name
+
+    @shipping_name.setter
+    def shipping_name(self, value):
+        self.__shipping_name = value
+
+    @property
+    def shipping_address(self):
+        return self.__shipping_address
+
+    @shipping_address.setter
+    def shipping_address(self, value):
+        self.__shipping_address = value
+
+    @property
+    def shipping_carrier(self):
+        return self.__shipping_carrier
+
+    @shipping_carrier.setter
+    def shipping_carrier(self, value):
+        self.__shipping_carrier = value
+
+    @property
+    def shipping_phone_no(self):
+        return self.__shipping_phone_no
+
+    @shipping_phone_no.setter
+    def shipping_phone_no(self, value):
+        self.__shipping_phone_no = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "shipping_name") and self.shipping_name:
+            params['shippingName'] = self.shipping_name
+
+        if hasattr(self, "shipping_address") and self.shipping_address:
+            params['shippingAddress'] = self.shipping_address
+
+        if hasattr(self, "shipping_carrier") and self.shipping_carrier:
+            params['shippingCarrier'] = self.shipping_carrier
+
+        if hasattr(self, "shipping_phone_no") and self.shipping_phone_no:
+            params['shippingPhoneNo'] = self.shipping_phone_no
+
+        return params

com/alipay/ams/api/model/stock_info.py

@@ -0,0 +1,26 @@
+
+class StockInfo:
+    def __init__(self):
+        self.__listed_region = None
+        self.__ticker_symbol = None
+
+    def get_listed_region(self):
+        return self.__listed_region
+
+    def set_listed_region(self, listed_region):
+        self.__listed_region = listed_region
+
+    def get_ticker_symbol(self):
+        return self.__ticker_symbol
+
+    def set_ticker_symbol(self, ticker_symbol):
+        self.__ticker_symbol = ticker_symbol
+
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, 'listed_region') and self.listed_region:
+            params['listedRegion'] = self.listed_region
+        if hasattr(self, 'ticker_symbol') and self.ticker_symbol:
+            params['tickerSymbol'] = self.ticker_symbol
+        return params