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

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

@@ -0,0 +1,229 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from com.alipay.ams.api.model.browser_info import BrowserInfo
+from com.alipay.ams.api.model.os_type import OsType
+from com.alipay.ams.api.model.terminal_type import TerminalType
+
+
+class Env(object):
+    def __init__(self):
+        self.__terminal_type = None  # type: TerminalType
+        self.__os_type = None  # type: OsType
+        self.__user_agent = None
+        self.__device_token_id = None
+        self.__client_ip = None
+        self.__cookie_id = None
+        self.__store_terminal_id = None
+        self.__store_terminal_request_time = None
+        self.__extend_info = None
+        self.__browser_info = None  # type: BrowserInfo
+        self.__color_depth = None
+        self.__screen_height = None
+        self.__screen_width = None
+        self.__time_zone_offset = None
+        self.__device_brand = None
+        self.__device_model = None
+        self.__device_language = None
+        self.__device_id = None
+
+    @property
+    def terminal_type(self):
+        return self.__terminal_type
+
+    @terminal_type.setter
+    def terminal_type(self, value):
+        self.__terminal_type = value
+
+    @property
+    def os_type(self):
+        return self.__os_type
+
+    @os_type.setter
+    def os_type(self, value):
+        self.__os_type = value
+
+    @property
+    def user_agent(self):
+        return self.__user_agent
+
+    @user_agent.setter
+    def user_agent(self, value):
+        self.__user_agent = value
+
+    @property
+    def device_token_id(self):
+        return self.__device_token_id
+
+    @device_token_id.setter
+    def device_token_id(self, value):
+        self.__device_token_id = value
+
+    @property
+    def client_ip(self):
+        return self.__client_ip
+
+    @client_ip.setter
+    def client_ip(self, value):
+        self.__client_ip = value
+
+    @property
+    def cookie_id(self):
+        return self.__cookie_id
+
+    @cookie_id.setter
+    def cookie_id(self, value):
+        self.__cookie_id = value
+
+    @property
+    def store_terminal_id(self):
+        return self.__store_terminal_id
+
+    @store_terminal_id.setter
+    def store_terminal_id(self, value):
+        self.__store_terminal_id = value
+
+    @property
+    def store_terminal_request_time(self):
+        return self.__store_terminal_request_time
+
+    @store_terminal_request_time.setter
+    def store_terminal_request_time(self, value):
+        self.__store_terminal_request_time = value
+
+    @property
+    def extend_info(self):
+        return self.__extend_info
+
+    @extend_info.setter
+    def extend_info(self, value):
+        self.__extend_info = value
+
+    @property
+    def browser_info(self):
+        return self.__browser_info
+
+    @browser_info.setter
+    def browser_info(self, value):
+        self.__browser_info = value
+
+    @property
+    def color_depth(self):
+        return self.__color_depth
+
+    @color_depth.setter
+    def color_depth(self, value):
+        self.__color_depth = value
+
+    @property
+    def screen_height(self):
+        return self.__screen_height
+
+    @screen_height.setter
+    def screen_height(self, value):
+        self.__screen_height = value
+
+    @property
+    def screen_width(self):
+        return self.__screen_width
+
+    @screen_width.setter
+    def screen_width(self, value):
+        self.__screen_width = value
+
+    @property
+    def time_zone_offset(self):
+        return self.__time_zone_offset
+
+    @time_zone_offset.setter
+    def time_zone_offset(self, value):
+        self.__time_zone_offset = value
+
+    @property
+    def device_brand(self):
+        return self.__device_brand
+
+    @device_brand.setter
+    def device_brand(self, value):
+        self.__device_brand = value
+
+    @property
+    def device_model(self):
+        return self.__device_model
+
+    @device_model.setter
+    def device_model(self, value):
+        self.__device_model = value
+
+    @property
+    def device_language(self):
+        return self.__device_language
+
+    @device_language.setter
+    def device_language(self, value):
+        self.__device_language = value
+
+    @property
+    def device_id(self):
+        return self.__device_id
+
+    @device_id.setter
+    def device_id(self, value):
+        self.__device_id = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "terminal_type") and self.terminal_type:
+            params['terminalType'] = self.terminal_type
+
+        if hasattr(self, "os_type") and self.os_type:
+            params['osType'] = self.os_type
+
+        if hasattr(self, "user_agent") and self.user_agent:
+            params['userAgent'] = self.user_agent
+
+        if hasattr(self, "device_token_id ") and self.device_token_id:
+            params['deviceTokenId'] = self.device_token_id
+
+        if hasattr(self, "client_ip") and self.client_ip:
+            params['clientIp'] = self.client_ip
+
+        if hasattr(self, "cookie_id") and self.cookie_id:
+            params['cookieId'] = self.cookie_id
+
+        if hasattr(self, "store_terminal_id") and self.store_terminal_id:
+            params['storeTerminalId'] = self.store_terminal_id
+
+        if hasattr(self, "store_terminal_request_time") and self.store_terminal_request_time:
+            params['storeTerminalRequestTime'] = self.store_terminal_request_time
+
+        if hasattr(self, "extend_info") and self.extend_info:
+            params['extendInfo'] = self.extend_info
+
+        if hasattr(self, "browser_info") and self.browser_info:
+            params['browserInfo'] = self.browser_info
+
+        if hasattr(self, "color_depth") and self.color_depth:
+            params['colorDepth'] = self.color_depth
+
+        if hasattr(self, "screen_height") and self.screen_height:
+            params['screenHeight'] = self.screen_height
+
+        if hasattr(self, "screen_width") and self.screen_width:
+            params['screenWidth'] = self.screen_width
+
+        if hasattr(self, "time_zone_offset") and self.time_zone_offset:
+            params['timeZoneOffset'] = self.time_zone_offset
+
+        if hasattr(self, "device_brand") and self.device_brand:
+            params['deviceBrand'] = self.device_brand
+
+        if hasattr(self, "device_model") and self.device_model:
+            params['deviceModel'] = self.device_model
+
+        if hasattr(self, "device_language") and self.device_language:
+            params['deviceLanguage'] = self.device_language
+
+        if hasattr(self, "device_id") and self.device_id:
+            params['deviceId'] = self.device_id
+
+        return params

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

@@ -0,0 +1,21 @@
+from com.alipay.ams.api.model.china_extra_trans_info import ChinaExtraTransInfo
+
+
+class ExtendInfo(object):
+    def __init__(self):
+        self.__china_extra_trans_info = None  # type:ChinaExtraTransInfo
+
+    @property
+    def china_extra_trans_info(self):
+        return self.__china_extra_trans_info
+
+    @china_extra_trans_info.setter
+    def china_extra_trans_info(self, value):
+        self.__china_extra_trans_info = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "china_extra_trans_info") and self.china_extra_trans_info:
+            params['chinaExtraTransInfo'] = self.china_extra_trans_info
+
+        return params

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

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+
+
+class ExternalPaymentMethodDetail(object):
+
+    def __init__(self):
+        self.__asset_token = None
+        self.__account_display_name = None
+        self.__disable_reason = None
+        self.__payment_method_detail_metadata = None
+
+    @property
+    def asset_token(self):
+        return self.__asset_token
+
+    @asset_token.setter
+    def asset_token(self, value):
+        self.__asset_token = value
+
+    @property
+    def account_display_name(self):
+        return self.__account_display_name
+
+
+    @account_display_name.setter
+    def account_display_name(self, value):
+        self.__account_display_name = value
+
+    @property
+    def disable_reason(self):
+        return self.__disable_reason
+
+
+    @disable_reason.setter
+    def disable_reason(self, value):
+        self.__disable_reason = value
+
+    @property
+    def payment_method_detail_metadata(self):
+        return self.__payment_method_detail_metadata
+
+    @payment_method_detail_metadata.setter
+    def payment_method_detail_metadata(self, value):
+        self.__payment_method_detail_metadata = value
+
+    def parse_rsp_body(self, external_payment_method_detail_body):
+        if type(external_payment_method_detail_body) == str:
+            external_payment_method_detail_body = json.loads(external_payment_method_detail_body)
+
+        if 'assetToken' in external_payment_method_detail_body:
+            self.__asset_token = external_payment_method_detail_body['assetToken']
+
+        if 'accountDisplayName' in external_payment_method_detail_body:
+            self.__account_display_name = external_payment_method_detail_body['accountDisplayName']
+
+        if 'disableReason' in external_payment_method_detail_body:
+            self.__disable_reason = external_payment_method_detail_body['disableReason']
+
+        if 'paymentMethodDetailMetadata' in external_payment_method_detail_body:
+            self.__payment_method_detail_metadata = external_payment_method_detail_body['paymentMethodDetailMetadata']
+
+    def to_ams_dict(self):
+        params = dict()
+        if self.asset_token:
+            params['assetToken'] = self.asset_token
+        if self.account_display_name:
+            params['accountDisplayName'] = self.account_display_name
+        if self.disable_reason:
+            params['disableReason'] = self.disable_reason
+        if self.payment_method_detail_metadata:
+            params['paymentMethodDetailMetadata'] = self.payment_method_detail_metadata
+
+        return params

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

@@ -0,0 +1,16 @@
+from enum import Enum, unique
+
+
+@unique
+class FundingType(Enum):
+    CREDIT = "CREDIT"
+    DEBIT = "DEBIT"
+
+
+PREPAID = "PREPAID"
+CHARGE = "CHARGE"
+DEFERRED_DEBIT = "DEFERRED_DEBIT"
+
+
+def to_ams_dict(self):
+    return self.name

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

@@ -0,0 +1,55 @@
+class Gaming(object):
+
+    def __init__(self):
+        self.__game_name = None
+        self.__topped_up_user = None
+        self.__topped_up_email = None
+        self.__topped_up_phone_no = None
+
+    @property
+    def game_name(self):
+        return self.__game_name
+
+    @game_name.setter
+    def game_name(self, value):
+        self.__game_name = value
+
+    @property
+    def topped_up_user(self):
+        return self.__topped_up_user
+
+    @topped_up_user.setter
+    def topped_up_user(self, value):
+        self.__topped_up_user = value
+
+    @property
+    def topped_up_email(self):
+        return self.__topped_up_email
+
+    @topped_up_email.setter
+    def topped_up_email(self, value):
+        self.__topped_up_email = value
+
+    @property
+    def topped_up_phone_no(self):
+        return self.__topped_up_phone_no
+
+    @topped_up_phone_no.setter
+    def topped_up_phone_no(self, value):
+        self.__topped_up_phone_no = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "game_name") and self.game_name:
+            params['gameName'] = self.game_name
+
+        if hasattr(self, "topped_up_user") and self.topped_up_user:
+            params['toppedUpUser'] = self.topped_up_user.to_ams_dict()
+
+        if hasattr(self, "topped_up_email") and self.topped_up_email:
+            params['toppedUpEmail'] = self.topped_up_email
+
+        if hasattr(self, "topped_up_phone_no") and self.topped_up_phone_no:
+            params['toppedUpPhoneNo'] = self.topped_up_phone_no
+
+        return params

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

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from com.alipay.ams.api.model.amount import Amount
+from com.alipay.ams.api.model.delivery_method_type import DeliveryMethodType
+
+
+class Goods(object):
+    def __init__(self):
+        self.__reference_goods_id = None
+        self.__goods_name = None
+        self.__goods_category = None
+        self.__goods_brand = None
+        self.__goods_unit_amount = None  # type:Amount
+        self.__goods_quantity = None
+        self.__goods_sku_name = None
+        self.__delivery_method_type = None  # type:DeliveryMethodType
+
+    @property
+    def reference_goods_id(self):
+        return self.__reference_goods_id
+
+    @reference_goods_id.setter
+    def reference_goods_id(self, value):
+        self.__reference_goods_id = value
+
+    @property
+    def goods_name(self):
+        return self.__goods_name
+
+    @goods_name.setter
+    def goods_name(self, value):
+        self.__goods_name = value
+
+    @property
+    def goods_category(self):
+        return self.__goods_category
+
+    @goods_category.setter
+    def goods_category(self, value):
+        self.__goods_category = value
+
+    @property
+    def goods_brand(self):
+        return self.__goods_brand
+
+    @goods_brand.setter
+    def goods_brand(self, value):
+        self.__goods_brand = value
+
+    @property
+    def goods_unit_amount(self):
+        return self.__goods_unit_amount
+
+    @goods_unit_amount.setter
+    def goods_unit_amount(self, value):
+        self.__goods_unit_amount = value
+
+    @property
+    def goods_quantity(self):
+        return self.__goods_quantity
+
+    @goods_quantity.setter
+    def goods_quantity(self, value):
+        self.__goods_quantity = value
+
+    @property
+    def goods_sku_name(self):
+        return self.__goods_sku_name
+
+    @goods_sku_name.setter
+    def goods_sku_name(self, value):
+        self.__goods_sku_name = value
+
+    @property
+    def delivery_method_type(self):
+        return self.__delivery_method_type
+
+    @delivery_method_type.setter
+    def delivery_method_type(self, value):
+        self.__delivery_method_type = value
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, "reference_goods_id") and self.reference_goods_id:
+            params['referenceGoodsId'] = self.reference_goods_id
+
+        if hasattr(self, "goods_name") and self.goods_name:
+            params['goodsName'] = self.goods_name
+
+        if hasattr(self, "goods_category") and self.goods_category:
+            params['goodsCategory'] = self.goods_category
+
+        if hasattr(self, "goods_brand") and self.goods_brand:
+            params['goodsBrand'] = self.goods_brand
+
+        if hasattr(self, "goods_unit_amount") and self.goods_unit_amount:
+            params['goodsUnitAmount'] = self.goods_unit_amount
+
+        if hasattr(self, "goods_quantity") and self.goods_quantity:
+            params['goodsQuantity'] = self.goods_quantity
+
+        if hasattr(self, "goods_sku_name") and self.goods_sku_name:
+            params['goodsSkuName'] = self.goods_sku_name
+
+        if hasattr(self, "delivery_method_type") and self.delivery_method_type:
+            params['deliveryMethodType'] = self.delivery_method_type
+
+        return params

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from enum import Enum, unique
+
+
+@unique
+class GrantType(Enum):
+    AUTHORIZATION_CODE = "AUTHORIZATION_CODE"
+    REFRESH_TOKEN = "REFRESH_TOKEN"
+
+    def to_ams_dict(self):
+        return self.name

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from enum import Enum, unique
+
+
+@unique
+class HttpMethod(Enum):
+    POST = "POST"
+    GET = "GET"

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

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class IdentityCheckResult(Enum):
+    CHECK_PASSED = "CHECK_PASSED"
+    CHECK_NOT_PASSED = "CHECK_NOT_PASSED"
+
+    def to_ams_dict(self):
+        return self.name

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

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from enum import Enum, unique
+
+
+@unique
+class InStorePaymentScenario(Enum):
+    PaymentCode = "PaymentCode"
+    OrderCode = "OrderCode"
+    EntryCode = "EntryCode"
+
+    def to_ams_dict(self):
+        return self.name

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

@@ -0,0 +1,97 @@
+from com.alipay.ams.api.model.address import Address
+from com.alipay.ams.api.model.certificate import Certificate
+from com.alipay.ams.api.model.contact import Contact
+from com.alipay.ams.api.model.user_name import UserName
+
+
+class Individual:
+
+    def __init__(self):
+        self.__name = None #type: UserName
+        self.__english_name = None #type: UserName
+        self.__date_of_birth = None
+        self.__place_of_birth = None #type: Address
+        self.__certificates = None #type: list[Certificate]
+        self.__nationality = None
+        self.__contacts = None #type: list[Contact]
+
+    @property
+    def name(self):
+        return self.__name
+
+    @name.setter
+    def name(self, value):
+        self.__name = value
+
+    @property
+    def english_name(self):
+        return self.__english_name
+
+    @english_name.setter
+    def english_name(self, value):
+        self.__english_name = value
+
+    @property
+    def date_of_birth(self):
+        return self.__date_of_birth
+
+    @date_of_birth.setter
+    def date_of_birth(self, value):
+        self.__date_of_birth = value
+
+    @property
+    def place_of_birth(self):
+        return self.__place_of_birth
+
+    @place_of_birth.setter
+    def place_of_birth(self, value):
+        self.__place_of_birth = value
+
+    @property
+    def certificates(self):
+        return self.__certificates
+
+    @certificates.setter
+    def certificates(self, value):
+        self.__certificates = value
+
+    @property
+    def nationality(self):
+        return self.__nationality
+
+    @nationality.setter
+    def nationality(self, value):
+        self.__nationality = value
+
+    @property
+    def contacts(self):
+        return self.__contacts
+
+    @contacts.setter
+    def contacts(self, value):
+        self.__contacts = value
+
+
+    def to_ams_dict(self):
+        params = dict()
+        if hasattr(self, 'name') and self.name:
+            params['name'] = self.name.to_ams_dict()
+        if hasattr(self, 'english_name') and self.english_name:
+            params['englishName'] = self.english_name.to_ams_dict()
+        if hasattr(self, 'date_of_birth') and self.date_of_birth:
+            params['dateOfBirth'] = self.date_of_birth
+        if hasattr(self, 'place_of_birth') and self.place_of_birth:
+            params['placeOfBirth'] = self.place_of_birth.to_ams_dict()
+        if hasattr(self, 'certificates') and self.certificates:
+            certificates_list = list()
+            for d in self.certificates:
+                certificates_list.append(d.to_ams_dict())
+            params['certificates'] = certificates_list
+        if hasattr(self, 'nationality') and self.nationality:
+            params['nationality'] = self.nationality
+        if hasattr(self, 'contacts') and self.contacts:
+            contacts_list = list()
+            for d in self.contacts:
+                contacts_list.append(d.to_ams_dict())
+                params['contacts'] = contacts_list
+        return params

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

@@ -0,0 +1,41 @@
+import json
+
+from com.alipay.ams.api.model.plan import Plan
+from com.alipay.ams.api.model.support_card_brand import SupportCardBrand
+
+
+class Installment(object):
+    def __init__(self):
+        self.__support_card_brands = None  # type: list[SupportCardBrand]
+        self.__plans = None  # type: list[Plan]
+
+    @property
+    def support_card_brands(self):
+        return self.__support_card_brands
+
+    @support_card_brands.setter
+    def support_card_brands(self, value):
+        self.__support_card_brands = value
+
+    @property
+    def plans(self):
+        return self.__plans
+
+    @plans.setter
+    def plans(self, value):
+        self.__plans = value
+
+    def parse_rsp_body(self, installment_body):
+        if type(installment_body) == str:
+            installment_body = json.loads(installment_body)
+        if 'supportCardBrand' in installment_body:
+            self.support_card_brands = installment_body.get('supportCardBrand')
+            for support_card_brand in self.support_card_brands:
+                support_card_brand.parse_rsp_body(support_card_brand)
+                self.support_card_brands = support_card_brand
+
+        if 'plans' in installment_body:
+            self.plans = installment_body.get('plans')
+            for plan in self.plans:
+                plan.parse_rsp_body(plan)
+                self.plans = plan