dana-python 2.0.0__tar.gz → 2.1.1__tar.gz

{dana_python-2.0.0/dana_python.egg-info → dana_python-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dana-python
-Version: 2.0.0
+Version: 2.1.1
 Summary: API Client (SDK) for DANA APIs based on https://dashboard.dana.id/api-docs
 Author-email: DANA Package Manager  <package-manager@dana.id>
 Maintainer-email: DANA Package Manager  <package-manager@dana.id>
@@ -12,9 +12,9 @@ Requires-Python: >3.9.1
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: annotated-types==0.7.0
-Requires-Dist: cffi==1.17.1
+Requires-Dist: cffi==2.0.0
 Requires-Dist: cryptography<46.0.0,>=44.0.2
-Requires-Dist: pycparser==2.22
+Requires-Dist: pycparser==2.23
 Requires-Dist: pydantic<3.0.0,>=2.10.6
 Requires-Dist: pydantic-core<3.0.0,>=2.27.2
 Requires-Dist: python-dateutil==2.9.0.post0
@@ -88,7 +88,7 @@ Before using the SDK, please make sure to set the following environment variable
 | ---------------------- | ---------------------------------------------------------------------------------------       | ------------------------------------------------------------------------------- |
 | `ENV` or `DANA_ENV`    | Defines which environment the SDK will use. Possible values: `SANDBOX` or `PRODUCTION`.       | `SANDBOX`                                                                       |
 | `X_PARTNER_ID`         | Unique identifier for partner, provided by DANA, also known as `clientId`.                    | 1970010100000000000000                                                          |
-| `PRIVATE_KEY`          | Your private key string.                                                                      | `-----BEGIN PRIVATE KEY-----MIIBVgIBADANBg...LsvTqw==-----END PRIVATE KEY-----` |
+| `PRIVATE_KEY`          | Your private key string.                                                                      | |
 | `PRIVATE_KEY_PATH`     | Path to your private key file. If both are set, `PRIVATE_KEY_PATH` is used.                   | /path/to/your_private_key.pem                                                   |
 | `DANA_PUBLIC_KEY`      | DANA public key string for parsing webhook.                                                   | `-----BEGIN PUBLIC KEY-----MIIBIjANBgkq...Do/QIDAQAB-----END PUBLIC KEY-----`   |
 | `DANA_PUBLIC_KEY_PATH` | Path to DANA public key file for parsing webhook. If both set, `DANA_PUBLIC_KEY_PATH is used. | /path/to/dana_public_key.pem                                                    |

{dana_python-2.0.0 → dana_python-2.1.1}/README.md

@@ -63,7 +63,7 @@ Before using the SDK, please make sure to set the following environment variable
 | ---------------------- | ---------------------------------------------------------------------------------------       | ------------------------------------------------------------------------------- |
 | `ENV` or `DANA_ENV`    | Defines which environment the SDK will use. Possible values: `SANDBOX` or `PRODUCTION`.       | `SANDBOX`                                                                       |
 | `X_PARTNER_ID`         | Unique identifier for partner, provided by DANA, also known as `clientId`.                    | 1970010100000000000000                                                          |
-| `PRIVATE_KEY`          | Your private key string.                                                                      | `-----BEGIN PRIVATE KEY-----MIIBVgIBADANBg...LsvTqw==-----END PRIVATE KEY-----` |
+| `PRIVATE_KEY`          | Your private key string.                                                                      | |
 | `PRIVATE_KEY_PATH`     | Path to your private key file. If both are set, `PRIVATE_KEY_PATH` is used.                   | /path/to/your_private_key.pem                                                   |
 | `DANA_PUBLIC_KEY`      | DANA public key string for parsing webhook.                                                   | `-----BEGIN PUBLIC KEY-----MIIBIjANBgkq...Do/QIDAQAB-----END PUBLIC KEY-----`   |
 | `DANA_PUBLIC_KEY_PATH` | Path to DANA public key file for parsing webhook. If both set, `DANA_PUBLIC_KEY_PATH is used. | /path/to/dana_public_key.pem                                                    |

{dana_python-2.0.0 → dana_python-2.1.1}/dana/exceptions.py

@@ -22,7 +22,7 @@
     Do not edit the class manually.
 """  # noqa: E501
 
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
 from typing_extensions import Self
 
 class OpenApiException(Exception):
@@ -122,7 +122,11 @@ class ApiException(OpenApiException):
         *,
         body: Optional[str] = None,
         data: Optional[Any] = None,
+        contexts: Optional[List[Dict[str, str]]] = None,
     ) -> None:
+        self.contexts = contexts
+        if contexts is not None and reason is None:
+            reason = "; ".join(f"{c['field']}: {c['message']}" for c in contexts)
         self.status = status
         self.reason = reason
         self.body = body

dana_python-2.1.1/dana/payment_gateway/v1/custom_validation.py

@@ -0,0 +1,333 @@
+# Copyright 2026 PT Espay Debit Indonesia Koe
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+CustomValidation
+
+This module provides custom validation functions for Payment Gateway API requests.
+Validations are registered in the validation_registry and executed via custom_validation().
+"""
+
+import os
+import re
+from typing import Any, Callable, Dict, FrozenSet, List, Set
+
+from dana.utils.date_validation import validate_valid_up_to_date
+from dana.exceptions import ApiException
+
+# Money value pattern: digits (1-16) + "." + exactly 2 digits (e.g. 10000.00)
+MONEY_VALUE_PATTERN = re.compile(r'^\d{1,16}\.\d{2}$')
+
+SANDBOX_ALLOWED_PAY_METHODS: FrozenSet[str] = frozenset({
+    'BALANCE', 'CREDIT_CARD', 'DEBIT_CARD', 'VIRTUAL_ACCOUNT', 'NETWORK_PAY',
+})
+
+SANDBOX_ALLOWED_PAY_OPTIONS: FrozenSet[str] = frozenset({
+    'CARD', 'QRIS', 'BRI', 'PANIN', 'CIMB', 'MANDIRI', 'BTPN',
+})
+
+CREDIT_DEBIT_CARD_PAY_METHODS: Set[str] = {'CREDIT_CARD', 'DEBIT_CARD'}
+NETWORK_PAY_PG_CARD = 'NETWORK_PAY_PG_CARD'
+EWALLET_PAY_OPTIONS: Set[str] = {
+    'NETWORK_PAY_PG_SPAY',
+    'NETWORK_PAY_PG_OVO',
+    'NETWORK_PAY_PG_GOPAY',
+    'NETWORK_PAY_PG_LINKAJA',
+}
+
+
+def _is_sandbox() -> bool:
+    env = os.getenv('DANA_ENV', os.getenv('ENV', 'sandbox')).lower()
+    return env == 'sandbox'
+
+
+def _pay_option_allowed_in_sandbox(value: str) -> bool:
+    if not value or not str(value).strip():
+        return False
+    s = str(value).strip()
+    if s in SANDBOX_ALLOWED_PAY_OPTIONS:
+        return True
+    for opt in SANDBOX_ALLOWED_PAY_OPTIONS:
+        if s.endswith('_' + opt):
+            return True
+    return False
+
+
+def _normalize_value(value: Any) -> str:
+    if value is None:
+        return ''
+    if hasattr(value, 'value'):
+        return str(getattr(value, 'value')).strip()
+    return str(value).strip()
+
+
+def _trim_str(value: Any) -> str:
+    if value is None:
+        return ''
+    return str(value).strip()
+
+
+def _rune_len(s: str) -> int:
+    return len(list(s))
+
+
+def _ctx(field: str, message: str) -> Dict[str, str]:
+    return {'field': field, 'message': message}
+
+
+def validate_additional_info_required(request: Any) -> None:
+    if request is None:
+        return
+    if hasattr(request, 'additional_info') and request.additional_info is None:
+        raise ApiException(status=0, contexts=[_ctx('additionalInfo', 'additionalInfo is required')])
+
+
+def validate_money_value_pattern(request: Any) -> None:
+    if request is None:
+        return
+    if not hasattr(request, 'amount') or request.amount is None:
+        return
+    value = getattr(request.amount, 'value', None)
+    if value is None or value == '':
+        raise ApiException(status=0, contexts=[_ctx('amount.value', 'amount.value is required')])
+    if not MONEY_VALUE_PATTERN.match(str(value)):
+        raise ApiException(status=0, contexts=[
+            _ctx('amount.value', f'amount.value must match pattern (e.g. 10000.00): got {value!r}')
+        ])
+
+
+def validate_valid_up_to_create_order_request(request: Any) -> None:
+    if request is None:
+        return
+    if hasattr(request, 'valid_up_to') and request.valid_up_to is not None:
+        try:
+            validate_valid_up_to_date(request.valid_up_to)
+        except ValueError as e:
+            raise ApiException(status=0, contexts=[
+                _ctx('validUpTo', f'validUpTo validation failed: {str(e)}')
+            ]) from e
+
+
+def validate_external_store_id_for_qris(request: Any) -> None:
+    if request is None:
+        return
+    if not hasattr(request, 'pay_option_details') or request.pay_option_details is None:
+        return
+    has_qris = False
+    if isinstance(request.pay_option_details, list):
+        for pay_option_detail in request.pay_option_details:
+            if hasattr(pay_option_detail, 'pay_option') and pay_option_detail.pay_option == 'NETWORK_PAY_PG_QRIS':
+                has_qris = True
+                break
+    if has_qris:
+        external_store_id = None
+        if hasattr(request, 'external_store_id'):
+            external_store_id = request.external_store_id
+        if not external_store_id or (isinstance(external_store_id, str) and external_store_id.strip() == ''):
+            raise ApiException(status=0, contexts=[
+                _ctx('externalStoreId', 'externalStoreId is required when payOption is NETWORK_PAY_PG_QRIS')
+            ])
+
+
+def validate_sandbox_pay_method_and_pay_option(request: Any) -> None:
+    if request is None or not _is_sandbox():
+        return
+    pay_option_details = getattr(request, 'pay_option_details', None)
+    if not pay_option_details or not isinstance(pay_option_details, list):
+        return
+    for i, detail in enumerate(pay_option_details):
+        if not detail:
+            continue
+        if hasattr(detail, 'pay_method') and detail.pay_method is not None:
+            pm_str = _normalize_value(detail.pay_method)
+            if pm_str and pm_str not in SANDBOX_ALLOWED_PAY_METHODS:
+                raise ApiException(status=0, contexts=[
+                    _ctx(
+                        f'payOptionDetails[{i}].payMethod',
+                        (
+                            f'In sandbox, payMethod must be one of [{", ".join(sorted(SANDBOX_ALLOWED_PAY_METHODS))}]; '
+                            f'got {pm_str}'
+                        ),
+                    )
+                ])
+        if hasattr(detail, 'pay_option') and detail.pay_option is not None:
+            po_str = _normalize_value(detail.pay_option)
+            if po_str and not _pay_option_allowed_in_sandbox(po_str):
+                raise ApiException(status=0, contexts=[
+                    _ctx(
+                        f'payOptionDetails[{i}].payOption',
+                        (
+                            f'In sandbox, payOption must be one of [{", ".join(sorted(SANDBOX_ALLOWED_PAY_OPTIONS))}] '
+                            f'(or suffix like VIRTUAL_ACCOUNT_BRI); got {po_str}'
+                        ),
+                    )
+                ])
+
+
+def validate_conditional_pay_option_additional_info_create_order_request(request: Any) -> None:
+    if request is None:
+        return
+    pay_option_details = getattr(request, 'pay_option_details', None)
+    if not pay_option_details or not isinstance(pay_option_details, list):
+        return
+
+    contexts: List[Dict[str, str]] = []
+
+    for i, detail in enumerate(pay_option_details):
+        if not detail:
+            continue
+        pay_method = _trim_str(getattr(detail, 'pay_method', None))
+        pay_option = _trim_str(getattr(detail, 'pay_option', None))
+        additional_info = getattr(detail, 'additional_info', None)
+        phone_raw = None
+        if additional_info is not None:
+            phone_raw = getattr(additional_info, 'phone_number', None)
+        phone_number = _trim_str(phone_raw)
+
+        is_card = pay_method in CREDIT_DEBIT_CARD_PAY_METHODS or pay_option == NETWORK_PAY_PG_CARD
+        is_ewallet = pay_option in EWALLET_PAY_OPTIONS
+
+        if is_card or is_ewallet:
+            field = f'payOptionDetails[{i}].additionalInfo.phoneNumber'
+            if not phone_number:
+                contexts.append(
+                    _ctx(field, f'phoneNumber is required for card/e-wallet payment (payOptionDetails[{i}])')
+                )
+            else:
+                ln = _rune_len(phone_number)
+                if ln < 1 or ln > 15:
+                    contexts.append(
+                        _ctx(field, f'phoneNumber must be between 1 and 15 characters (payOptionDetails[{i}])')
+                    )
+
+    if contexts:
+        raise ApiException(status=0, contexts=contexts)
+
+
+def validate_optional_fields_with_required_nested_create_order_request(request: Any) -> None:
+    if request is None:
+        return
+    additional_info = getattr(request, 'additional_info', None)
+    if additional_info is None:
+        return
+    order = getattr(additional_info, 'order', None)
+    if not order:
+        return
+
+    contexts: List[Dict[str, str]] = []
+
+    buyer = getattr(order, 'buyer', None)
+    if buyer:
+        ext_type = _trim_str(getattr(buyer, 'external_user_type', None))
+        ext_id = _trim_str(getattr(buyer, 'external_user_id', None))
+        has_type = bool(ext_type)
+        has_id = bool(ext_id)
+        if has_id and not has_type:
+            contexts.append(
+                _ctx(
+                    'additionalInfo.order.buyer.externalUserType',
+                    'externalUserType is required when externalUserId is filled',
+                )
+            )
+        if has_type and not has_id:
+            contexts.append(
+                _ctx(
+                    'additionalInfo.order.buyer.externalUserId',
+                    'externalUserId is required when externalUserType is filled',
+                )
+            )
+
+    goods = getattr(order, 'goods', None)
+    if isinstance(goods, list) and len(goods) > 0:
+        for i, g in enumerate(goods):
+            if not g:
+                continue
+            name = _trim_str(getattr(g, 'name', None))
+            if not name:
+                contexts.append(
+                    _ctx(
+                        f'additionalInfo.order.goods[{i}].name',
+                        'name is required when goods is filled',
+                    )
+                )
+
+    shipping_info = getattr(order, 'shipping_info', None)
+    if isinstance(shipping_info, list) and len(shipping_info) > 0:
+        for i, s in enumerate(shipping_info):
+            if not s:
+                continue
+            first_name = _trim_str(getattr(s, 'first_name', None))
+            if not first_name:
+                contexts.append(
+                    _ctx(
+                        f'additionalInfo.order.shippingInfo[{i}].firstName',
+                        'firstName is required when shippingInfo is filled',
+                    )
+                )
+
+    if contexts:
+        raise ApiException(status=0, contexts=contexts)
+
+
+validation_registry: Dict[str, List[Callable[[Any], None]]] = {
+    'CreateOrderByApiRequest': [
+        validate_additional_info_required,
+        validate_money_value_pattern,
+        validate_valid_up_to_create_order_request,
+        validate_external_store_id_for_qris,
+        validate_sandbox_pay_method_and_pay_option,
+        validate_conditional_pay_option_additional_info_create_order_request,
+        validate_optional_fields_with_required_nested_create_order_request,
+    ],
+    'CreateOrderByRedirectRequest': [
+        validate_additional_info_required,
+        validate_money_value_pattern,
+        validate_valid_up_to_create_order_request,
+        validate_sandbox_pay_method_and_pay_option,
+        validate_conditional_pay_option_additional_info_create_order_request,
+        validate_optional_fields_with_required_nested_create_order_request,
+    ],
+    'CreateOrderRequest': [
+        validate_additional_info_required,
+        validate_money_value_pattern,
+        validate_valid_up_to_create_order_request,
+        validate_external_store_id_for_qris,
+        validate_sandbox_pay_method_and_pay_option,
+        validate_conditional_pay_option_additional_info_create_order_request,
+        validate_optional_fields_with_required_nested_create_order_request,
+    ],
+}
+
+
+def custom_validation(request: Any) -> None:
+    """Run all validators for the request type and aggregate client validation contexts."""
+    if request is None:
+        return
+
+    class_name = request.__class__.__name__
+    if class_name not in validation_registry:
+        return
+
+    aggregated: List[Dict[str, str]] = []
+    for validator in validation_registry[class_name]:
+        try:
+            validator(request)
+        except ApiException as e:
+            if e.contexts:
+                aggregated.extend(e.contexts)
+            else:
+                raise
+
+    if aggregated:
+        raise ApiException(status=0, contexts=aggregated)

{dana_python-2.0.0 → dana_python-2.1.1}/dana/rest.py

@@ -190,7 +190,12 @@ class RESTClientObject:
                 ):
                     request_body = None
                     if body is not None:
-                        request_body = json.dumps(body)
+                        # If body is already a string or bytes (e.g. pre-serialized JSON from OpenAPI widget),
+                        # send as-is to avoid double JSON encoding. Otherwise serialize.
+                        if isinstance(body, (str, bytes)):
+                            request_body = body
+                        else:
+                            request_body = json.dumps(body)
                     r = self.pool_manager.request(
                         method,
                         url,

{dana_python-2.0.0 → dana_python-2.1.1}/dana/utils/open_api_header.py

@@ -90,12 +90,37 @@ class OpenApiHeader:
             elif private_key:
                 # Handle escaped newlines
                 private_key = private_key.replace("\\n", "\n")
-                private_key_obj = serialization.load_pem_private_key(
-                    private_key.encode(),
-                    password=None,
-                    backend=default_backend()
-                )
-                return private_key_obj
+                
+                # Check if private key already has PEM headers/footers
+                if not private_key.strip().startswith('-----BEGIN'):
+                    # Raw base64 key content - add PEM headers and footers
+                    private_key = f"-----BEGIN PRIVATE KEY-----\n{private_key}\n-----END PRIVATE KEY-----"
+                
+                try:
+                    private_key_obj = serialization.load_pem_private_key(
+                        private_key.encode(),
+                        password=None,
+                        backend=default_backend()
+                    )
+                    return private_key_obj
+                except ValueError as e:
+                    # If loading fails, try alternative PEM formats
+                    if "BEGIN PRIVATE KEY" in private_key:
+                        # Already in PKCS#8 format, try RSA format
+                        rsa_key = private_key.replace("-----BEGIN PRIVATE KEY-----", "-----BEGIN RSA PRIVATE KEY-----")
+                        rsa_key = rsa_key.replace("-----END PRIVATE KEY-----", "-----END RSA PRIVATE KEY-----")
+                        try:
+                            from cryptography.hazmat.primitives.serialization import load_pem_private_key
+                            private_key_obj = load_pem_private_key(
+                                rsa_key.encode(),
+                                password=None,
+                                backend=default_backend()
+                            )
+                            return private_key_obj
+                        except:
+                            pass
+                    
+                    raise ValueError(f"Unable to load private key: {str(e)}. Please ensure the private key is in proper PEM format.")
             else:
                 raise ValueError("Provide one of private_key or private_key_path")
 
@@ -155,14 +180,14 @@ class OpenApiHeader:
         # Generate unique request message ID
         req_msg_id = "sdk" + str(uuid.uuid4())[3:]
         
-        # Return auth settings following snap_header pattern
+        # Return auth settings following correct field order: version, function, clientId, clientSecret, reqTime, reqMsgId, reserve
         return {
             VERSION: generateOpenApiSetting(key=VERSION, value=version),
             FUNCTION: generateOpenApiSetting(key=FUNCTION, value=function_name),
             CLIENT_ID: generateOpenApiSetting(key=CLIENT_ID, value=client_id),
+            CLIENT_SECRET: generateOpenApiSetting(key=CLIENT_SECRET, value=client_secret),
             REQ_TIME: generateOpenApiSetting(key=REQ_TIME, value=timestamp),
             REQ_MSG_ID: generateOpenApiSetting(key=REQ_MSG_ID, value=req_msg_id),
-            CLIENT_SECRET: generateOpenApiSetting(key=CLIENT_SECRET, value=client_secret),
             RESERVE: generateOpenApiSetting(key=RESERVE, value="{}")
         }
 

{dana_python-2.0.0 → dana_python-2.1.1}/dana/utils/script.py

@@ -15,10 +15,23 @@
 import importlib
 import pkgutil
 import os
+import re
 from typing import List
 
 PACKAGE_NAME = 'dana'
 
+# Only single path segments that are valid Python identifiers (no traversal / injection).
+_SAFE_PKG_SEGMENT = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _assert_safe_import_segment(name: str, label: str) -> None:
+    if not name or not _SAFE_PKG_SEGMENT.fullmatch(name):
+        raise ValueError(
+            f"Refusing dynamic import: disallowed {label} {name!r} "
+            "(expected a single identifier-like package segment)"
+        )
+
+
 def import_all_models(base_path: str) -> None:
     """
     Imports all model modules from subdirectories of the specified base path.
@@ -48,6 +61,8 @@ def import_all_models(base_path: str) -> None:
         path_to_domain: List[str] = getattr(subdomain.module_finder, 'path', '')
         domain = os.path.basename(path_to_domain)
 
-        # Construct the full module path and import
+        # Construct the full module path and import (whitelist segments — no dynamic/untrusted strings)
+        _assert_safe_import_segment(domain, "domain")
+        _assert_safe_import_segment(subdomain.name, "subdomain")
         module_name = f"{PACKAGE_NAME}.{domain}.{subdomain.name}.models"
         importlib.import_module(module_name)

{dana_python-2.0.0 → dana_python-2.1.1}/dana/widget/v1/api/widget_api.py

@@ -21,6 +21,7 @@
     Generated by OpenAPI Generator (https://openapi-generator.tech)
     Do not edit the class manually.
 """  # noqa: E501
+import json
 import warnings
 from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union, Type
@@ -1901,6 +1902,70 @@ class WidgetApi:
         # authentication setting
         _auth_settings: List[str] = [
         ]
+        # For OPEN_API type, we use CLIENT_SECRET authentication with signature
+        # merge list of auth settings with Open API runtime headers
+        from dana.utils.open_api_header import OpenApiHeader
+        _auth_settings = OpenApiHeader.merge_with_open_api_runtime_headers(_auth_settings)
+        # Create the full request structure for OPEN_API
+        # Wrap the simplified body parameters in the proper DANA request format
+        # Extract accessToken from request body if available (widget-specific)
+        request_body_dict = query_user_profile_request.to_dict()
+        access_token = request_body_dict.get('accessToken', '')
+        # Create body without accessToken (for queryUserProfile)
+        body_without_access_token = {k: v for k, v in request_body_dict.items() if k != 'accessToken'}
+        # Generate head parameters
+        _generated_auth = OpenApiHeader.get_open_api_generated_headers(
+            method='POST',
+            resource_path='/dana/member/query/queryUserProfile.htm',
+            body='{}',  # Empty body for head generation
+            function_name="dana.member.query.queryUserProfile",
+            client_id=self.api_client.configuration.get_api_key_with_prefix('X_PARTNER_ID'),
+            client_secret=self.api_client.configuration.get_api_key_with_prefix('CLIENT_SECRET')
+        )
+        # Extract values from auth settings for JSON body, ensuring correct field order
+        head_params = {}
+        # Add fields in the correct order: version, function, clientId, clientSecret, reqTime, reqMsgId
+        for key in ['version', 'function', 'clientId', 'clientSecret', 'reqTime', 'reqMsgId']:
+            if key in _generated_auth:
+                head_params[key] = _generated_auth[key]['value']
+        # Add accessToken before reserve if found in request body (widget-specific)
+        if access_token:
+            head_params['accessToken'] = access_token
+        # Add reserve at the end
+        if 'reserve' in _generated_auth:
+            head_params['reserve'] = _generated_auth['reserve']['value']
+        # Create the full request structure (use body without accessToken)
+        request_body = {
+            "request": {
+                "head": head_params,
+                "body": body_without_access_token
+            }
+        }
+        # Generate signature (pass full structure, function will extract request part)
+        _signature = OpenApiHeader.generate_open_api_signature(
+                body=json.dumps(request_body),
+                private_key=self.api_client.configuration.get_api_key_with_prefix('PRIVATE_KEY')
+            )
+        # Add signature to the request
+        if _signature:
+            request_body['signature'] = _signature
+        # Convert final request to JSON string
+        _body_params = json.dumps(request_body)
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/dana/member/query/queryUserProfile.htm',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth,
+            _generated_auth=_generated_auth,
+        )
     @validate_call
     def refund_order(
         self,