dana-python 2.1.8__tar.gz → 2.1.10__tar.gz

{dana_python-2.1.8/dana_python.egg-info → dana_python-2.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dana-python
-Version: 2.1.8
+Version: 2.1.10
 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>

{dana_python-2.1.8 → dana_python-2.1.10}/dana/webhook/shop_info.py

@@ -36,7 +36,7 @@ class ShopInfo(BaseModel, BaseSdkModel):
     shop_id: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="Information of shop identifier. Required if externalShopId is blank")
     external_shop_id: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="Information of external shop identifier. Required if shopId is blank")
     operator_id: Optional[Annotated[str, Field(strict=True, max_length=32)]] = Field(default=None, description="Information of operator identifier")
-    shop_address: Optional[Annotated[str, Field(strict=True, max_length=256)]] = Field(default=None, description="Information of shop address")
+    shop_address: Optional[str] = Field(default=None, description="Information of shop address")
     division_id: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="Information of division identifier")
     external_division_id: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="Information of external division identifier")
     division_type: Optional[Annotated[str, Field(strict=True, max_length=32)]] = Field(default=None, description="Information of division type")

{dana_python-2.1.8 → dana_python-2.1.10}/dana/webhook/webhook.py

@@ -141,6 +141,27 @@ class WebhookParser:
         except Exception as e:
             return "", Exception(f"MinifyJSON: failed to marshal JSON for minification: {e}")
 
+    @staticmethod
+    def _has_triple_escaped_json_string_field(json_str: str) -> bool:
+        return '":"{\\\\\\"' in json_str
+
+    @staticmethod
+    def _process_over_escaped_minified_json(json_str: str) -> str:
+        normalized = json_str.replace('\\\\"', '"')
+        return WebhookParser._process_nested_json_fields(normalized)
+
+    @staticmethod
+    def _process_nested_json_fields(json_str: str) -> str:
+        normalized_str = json_str.replace('\\\\"', '\\"')
+
+        def replace_func(match):
+            field_name = match.group(1)
+            json_value = match.group(2)
+            escaped_value = json_value.replace('"', '\\"')
+            return f'"{field_name}":"{escaped_value}"'
+
+        return re.sub(r'"(\w+)":"(\{.*?\})"', replace_func, normalized_str)
+
     @staticmethod
     def _ensure_minified_json(json_str: str) -> tuple[str, Exception]:
         """
@@ -148,27 +169,127 @@ class WebhookParser:
         Returns tuple of (minified_json, error)
         """
         try:
-            normalized_str = json_str.replace('\\"', '"')
-            
-            pattern = r'"(\w+)":"(\{.*?\})"'
-            def replace_func(match):
-                field_name = match.group(1)
-                json_value = match.group(2)
-                escaped_value = json_value.replace('"', '\\"')
-                return f'"{field_name}":"{escaped_value}"'
-            
-            processed_str = re.sub(pattern, replace_func, normalized_str)
-            
+            if WebhookParser._is_json_minified(json_str) and not WebhookParser._has_triple_escaped_json_string_field(json_str):
+                return json_str, None
+
+            if WebhookParser._is_json_minified(json_str):
+                return WebhookParser._process_over_escaped_minified_json(json_str), None
+
+            normalized_str = json_str.replace('\\\\"', '\\"')
+            processed_str = WebhookParser._process_nested_json_fields(normalized_str)
+
             if WebhookParser._is_json_minified(processed_str):
                 return processed_str, None
-            
+
             return WebhookParser._minify_json(processed_str)
-            
+
         except json.JSONDecodeError as e:
             return "", Exception(f"EnsureMinifiedJSON: failed to unmarshal JSON: {e}")
         except Exception as e:
             return "", Exception(f"EnsureMinifiedJSON: failed to marshal JSON for minification: {e}")
 
+    @staticmethod
+    def _is_valid_json(json_str: str) -> bool:
+        try:
+            json.loads(json_str)
+            return True
+        except json.JSONDecodeError:
+            return False
+
+    @staticmethod
+    def _collapse_triple_backslash_quotes(s: str) -> str:
+        if '\\\\\\"' not in s:
+            return s
+        return s.replace('\\\\\\"', '\\"')
+
+    @staticmethod
+    def _collapse_double_backslash_quotes(s: str) -> str:
+        if '\\\\"' not in s:
+            return s
+        return s.replace('\\\\"', '"')
+
+    @staticmethod
+    def _remove_colon_space_before_quoted_value(s: str) -> str:
+        if ': \\"' not in s:
+            return s
+        return s.replace(': \\"', ':\\"')
+
+    @staticmethod
+    def _normalize_over_escaped_quotes(s: str) -> str:
+        if '\\\\"' in s:
+            return s.replace('\\\\"', '\\"')
+        return s
+
+    @staticmethod
+    def _remove_spaces_in_json_key_names(body: str) -> str:
+        return re.sub(
+            r'(\\*)"((?:\w+\s)+\w+)(\\*)"(\s*:)',
+            lambda m: m.group(1) + '"' + m.group(2).replace(' ', '') + m.group(3) + '"' + m.group(4),
+            body
+        )
+
+    @staticmethod
+    def _body_forms_for_signature(request_body: str) -> list[str]:
+        seen: set[str] = set()
+        forms: list[str] = []
+
+        def add(form: str) -> None:
+            if form and form not in seen:
+                seen.add(form)
+                forms.append(form)
+
+        collapsed = WebhookParser._collapse_triple_backslash_quotes(request_body)
+        if collapsed != request_body and WebhookParser._is_valid_json(collapsed):
+            add(collapsed)
+
+        collapsed_spaced = WebhookParser._remove_colon_space_before_quoted_value(collapsed)
+        if collapsed_spaced != request_body and WebhookParser._is_valid_json(collapsed_spaced):
+            add(collapsed_spaced)
+
+        collapsed = WebhookParser._collapse_double_backslash_quotes(request_body)
+        if collapsed != request_body and WebhookParser._is_valid_json(collapsed):
+            add(collapsed)
+
+        spaced = WebhookParser._remove_colon_space_before_quoted_value(request_body)
+        if spaced != request_body and WebhookParser._is_valid_json(spaced):
+            add(spaced)
+
+        collapsed = WebhookParser._collapse_triple_backslash_quotes(spaced)
+        if collapsed != request_body and WebhookParser._is_valid_json(collapsed):
+            add(collapsed)
+
+        if WebhookParser._is_valid_json(request_body):
+            add(request_body)
+
+        normalized = WebhookParser._normalize_over_escaped_quotes(request_body)
+        if normalized != request_body and WebhookParser._is_json_minified(normalized) and WebhookParser._is_valid_json(normalized):
+            add(normalized)
+
+        nested_processed = WebhookParser._process_nested_json_fields(request_body)
+        if nested_processed != request_body:
+            add(nested_processed)
+
+        key_despace = WebhookParser._remove_spaces_in_json_key_names(request_body)
+        if key_despace != request_body:
+            add(key_despace)
+
+        key_despace_collapsed = WebhookParser._remove_spaces_in_json_key_names(
+            WebhookParser._collapse_triple_backslash_quotes(request_body)
+        )
+        if key_despace_collapsed != request_body:
+            add(key_despace_collapsed)
+
+        minified, err = WebhookParser._ensure_minified_json(request_body)
+        if err:
+            if not forms:
+                raise ValueError("failed to prepare any signature body form") from err
+        else:
+            add(minified)
+
+        if not forms:
+            raise ValueError("failed to prepare any signature body form")
+        return forms
+
     @staticmethod
     def _sha256_lower_hex(data: str) -> str:
         return hashlib.sha256(data.encode("utf-8")).hexdigest()
@@ -179,13 +300,38 @@ class WebhookParser:
         relative_path_url: str,
         body: str,
         x_timestamp: str
-    ) -> tuple[str, Exception]:
-        processed_body, err = self._ensure_minified_json(body)
-        if err:
-            return "", Exception(f"_construct_string_to_verify: failed to ensure JSON is minified: {err}")
-        
-        body_hash = self._sha256_lower_hex(processed_body)
-        return f"{http_method}:{relative_path_url}:{body_hash}:{x_timestamp}", None
+    ) -> str:
+        path = relative_path_url if relative_path_url.startswith("/") else f"/{relative_path_url}"
+        body_hash = self._sha256_lower_hex(body)
+        return f"{http_method.upper()}:{path}:{body_hash}:{x_timestamp}"
+
+    def _verify_signature(
+        self,
+        http_method: str,
+        relative_path_url: str,
+        body: str,
+        x_timestamp: str,
+        x_signature: str,
+    ) -> None:
+        body_forms = self._body_forms_for_signature(body)
+        signature_bytes = base64.b64decode(x_signature)
+
+        for body_form in body_forms:
+            string_to_verify = self._construct_string_to_verify(
+                http_method, relative_path_url, body_form, x_timestamp
+            )
+            try:
+                self.public_key.verify(
+                    signature_bytes,
+                    string_to_verify.encode("utf-8"),
+                    padding.PKCS1v15(),
+                    hashes.SHA256(),
+                )
+                return
+            except InvalidSignature:
+                continue
+
+        raise ValueError("Signature verification failed.")
 
     def parse_webhook(
         self,
@@ -200,33 +346,33 @@ class WebhookParser:
         if not x_signature or not x_timestamp:
             raise ValueError("Missing X-SIGNATURE or X-TIMESTAMP header.")
 
-        string_to_verify, err = self._construct_string_to_verify(
-            http_method=http_method,
-            relative_path_url=relative_path_url,
-            body=body,
-            x_timestamp=x_timestamp
-        )
-        if err:
-            raise ValueError(str(err))
-        signature_bytes = base64.b64decode(x_signature)
-        try:
-            self.public_key.verify(
-                signature_bytes,
-                string_to_verify.encode('utf-8'),
-                padding.PKCS1v15(),
-                hashes.SHA256()
-            )
-        except InvalidSignature:
-            raise ValueError("Signature verification failed.")
+        self._verify_signature(http_method, relative_path_url, body, x_timestamp, x_signature)
+
+        # Try multiple body transformations for parsing in order of likelihood:
+        # 1. Collapsed triple-backslash form (handles over-escaped \\\" → \")
+        # 2. Process nested JSON fields (handles bare-quote inner JSON like "field":"{...}")
+        # 3. ensureMinifiedJson fallback for pretty-printed bodies
+        payload_dict = None
+        for candidate in [
+            self._collapse_triple_backslash_quotes(body),
+            self._process_nested_json_fields(body),
+        ]:
+            try:
+                payload_dict = json.loads(candidate)
+                break
+            except json.JSONDecodeError:
+                continue
+
+        if payload_dict is None:
+            processed_body, err = self._ensure_minified_json(body)
+            if err:
+                raise ValueError(f"Failed to process JSON body: {err}")
+            try:
+                payload_dict = json.loads(processed_body)
+            except json.JSONDecodeError:
+                raise ValueError("Invalid JSON in request body.")
 
-        processed_body, err = self._ensure_minified_json(body)
-        if err:
-            raise ValueError(f"Failed to process JSON body: {err}")
-            
         try:
-            payload_dict = json.loads(processed_body)
             return FinishNotifyRequest.from_dict(payload_dict)
-        except json.JSONDecodeError:
-            raise ValueError("Invalid JSON in request body.")
         except Exception as e:
             raise ValueError(f"Failed to parse body into FinishNotifyRequest: {e}")

{dana_python-2.1.8 → dana_python-2.1.10/dana_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dana-python
-Version: 2.1.8
+Version: 2.1.10
 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>

{dana_python-2.1.8 → dana_python-2.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dana-python"
-version = "2.1.8"
+version = "2.1.10"
 readme = "README.md"
 description = "API Client (SDK) for DANA APIs based on https://dashboard.dana.id/api-docs"
 license = "Apache-2.0"

{dana_python-2.1.8 → dana_python-2.1.10}/tests/test_merchant_management_api.py

@@ -39,7 +39,8 @@ class TestMerchantManagementApi:
     """Test class for Merchant Management API endpoints"""
     def test_create_shop_and_query_shop_success(self, api_instance_merchant_management: MerchantManagementApi, create_shop_request: CreateShopRequest, query_shop_request: QueryShopRequest):
         """Should successfully create a shop and return success response"""
-        
+        pytest.skip("Temporarily skipped")
+
         # Act
         api_response = api_instance_merchant_management.create_shop(create_shop_request)
         
@@ -87,6 +88,26 @@ class TestMerchantManagementApi:
             assert hasattr(query_shop_response.response.body, 'shop_resource_info')
             assert query_shop_response.response.body.shop_resource_info is not None
 
+    def test_query_shop_success(self, api_instance_merchant_management: MerchantManagementApi, query_shop_request: QueryShopRequest):
+        """Should successfully query a shop using a static shop ID"""
+        query_shop_request.shop_id = "216660000003429526679"
+
+        query_shop_response = api_instance_merchant_management.query_shop(query_shop_request)
+        print(f"Raw query shop response: {query_shop_response}")
+
+        assert query_shop_response is not None
+        assert hasattr(query_shop_response, 'response')
+        assert hasattr(query_shop_response.response, 'body')
+        assert hasattr(query_shop_response.response.body, 'result_info')
+
+        query_result_info = query_shop_response.response.body.result_info
+        assert query_result_info.result_status is not None
+        assert query_result_info.result_code is not None
+
+        if query_result_info.result_code == "SUCCESS":
+            assert hasattr(query_shop_response.response.body, 'shop_resource_info')
+            assert query_shop_response.response.body.shop_resource_info is not None
+
     def test_query_merchant_resource_success(self, api_instance_merchant_management: MerchantManagementApi, query_merchant_resource_request: QueryMerchantResourceRequest):
         """Should successfully query merchant resource and return balance information"""