channel-app 0.0.148__py3-none-any.whl → 0.0.150__py3-none-any.whl

channel_app/app/order/service.py

@@ -1,18 +1,27 @@
 from dataclasses import asdict
 from typing import List, Generator, Union
 
+from requests import exceptions as requests_exceptions
+
 from omnisdk.omnitron.models import (Customer, Address, CargoCompany, Order,
-                                     BatchRequest)
+                                     BatchRequest, CancellationRequest)
+from omnisdk.omnitron.endpoints import ChannelIntegrationActionEndpoint
 
 from channel_app.core import settings
-from channel_app.core.data import (OmnitronCreateOrderDto, OmnitronOrderDto,
+from channel_app.core.data import (BatchRequestResponseDto, 
+                                   CancellationRequestDto, 
+                                   ChannelCancellationRequestDto, 
+                                   OmnitronCreateOrderDto, 
+                                   OmnitronOrderDto,
                                    ChannelCreateOrderDto,
                                    ErrorReportDto,
-                                   OrderBatchRequestResponseDto, CancelOrderDto,
+                                   OrderBatchRequestResponseDto, 
+                                   CancelOrderDto,
                                    ChannelUpdateOrderItemDto)
 from channel_app.core.settings import OmnitronIntegration, ChannelIntegration
 from channel_app.omnitron.batch_request import ClientBatchRequest
-from channel_app.omnitron.constants import ContentType
+from channel_app.omnitron.constants import (BatchRequestStatus, ContentType, 
+                                            FailedReasonType)
 from channel_app.omnitron.exceptions import (CityException,
                                              TownshipException,
                                              DistrictException,
@@ -35,21 +44,21 @@ class OrderService(object):
             order_batch_objects = []
             while True:
                 try:
-                    channel_create_order, report, _ = next(get_orders)
+                    channel_create_order, report_list, _ = next(get_orders)
                 except StopIteration:
                     break
 
                 # tips
                 channel_create_order: ChannelCreateOrderDto
-                report: ErrorReportDto
-
-                if report and (is_success_log or not report.is_ok):
-                    report.error_code = \
-                        f"{omnitron_integration.batch_request.local_batch_id}" \
-                        f"_GetOrders_{channel_create_order.order.number}"
-                    omnitron_integration.do_action(
-                        key='create_error_report',
-                        objects=report)
+                report_list: List[ErrorReportDto]
+                for report in report_list:
+                    if is_success_log or not report.is_ok:
+                        report.error_code = \
+                            f"{omnitron_integration.batch_request.local_batch_id}" \
+                            f"-Channel-GetOrders_{channel_create_order.order.number}"
+                        omnitron_integration.do_action(
+                            key='create_error_report',
+                            objects=report)
 
                 order = self.create_order(omnitron_integration=omnitron_integration,
                                           channel_order=channel_create_order)
@@ -57,10 +66,15 @@ class OrderService(object):
                     order_batch_objects.extend(omnitron_integration.batch_request.objects)
 
             omnitron_integration.batch_request.objects = order_batch_objects
-
-            self.batch_service(settings.OMNITRON_CHANNEL_ID).to_done(
-                batch_request=omnitron_integration.batch_request
-            )
+            try:
+                self.batch_service(settings.OMNITRON_CHANNEL_ID).to_done(
+                    batch_request=omnitron_integration.batch_request
+                )
+            except requests_exceptions.HTTPError as exc:
+                if exc.response.status_code == 406 and "batch_request_status_100_1" in exc.response.text:
+                    pass
+                else:
+                    raise exc
 
     def create_order(self, omnitron_integration: OmnitronIntegration,
                      channel_order: ChannelCreateOrderDto
@@ -144,21 +158,21 @@ class OrderService(object):
             order_batch_objects = []
             while True:
                 try:
-                    channel_update_order, report, _ = next(get_updated_orders)
+                    channel_update_order, report_list, _ = next(get_updated_orders)
                 except StopIteration:
                     break
 
                 # tips
                 channel_update_order: ChannelUpdateOrderItemDto
-                report: ErrorReportDto
-
-                if report and (is_success_log or not report.is_ok):
-                    report.error_code = \
-                        f"{omnitron_integration.batch_request.local_batch_id}" \
-                        f"_GetUpdatedOrders_{channel_update_order.remote_id}"
-                    omnitron_integration.do_action(
-                        key='create_error_report',
-                        objects=report)
+                report_list: List[ErrorReportDto]
+                for report in report_list:
+                    if report and (is_success_log or not report.is_ok):
+                        report.error_code = \
+                            f"{omnitron_integration.batch_request.local_batch_id}" \
+                            f"_GetUpdatedOrders_{channel_update_order.remote_id}"
+                        omnitron_integration.do_action(
+                            key='create_error_report',
+                            objects=report)
 
                 omnitron_integration.do_action(
                     key='update_order_items', objects=channel_update_order)
@@ -288,3 +302,166 @@ class OrderService(object):
             return success_data
         except IndexError:
             return
+
+    def fetch_and_create_cancellation_requests(self, is_success_log=True):
+        with OmnitronIntegration(
+                content_type=ContentType.cancellation_request.value) as omnitron_integration:
+            get_cancellation_requests = ChannelIntegration().do_action(
+                key='get_cancellation_requests',
+                batch_request=omnitron_integration.batch_request)
+            get_cancellation_requests: Generator
+            while True:
+                try:
+                    cancellation_request, report_list, _ = next(get_cancellation_requests)
+                except StopIteration:
+                    break
+
+                # tips
+                cancellation_request: CancellationRequestDto
+                report_list: List[ErrorReportDto]
+                for report in report_list:
+                    if report and (is_success_log or not report.is_ok):
+                        report.error_code = \
+                            f"{omnitron_integration.batch_request.local_batch_id}" \
+                            f"-Channel-GetCancellationRequests_{cancellation_request.order_item}"                        
+                        omnitron_integration.do_action(
+                            key='create_error_report',
+                            objects=report)
+                
+                # omnitron integration do action create_cancellation_request
+                cancellation_request_response = omnitron_integration.do_action(
+                    key='create_cancellation_requests',
+                    objects=cancellation_request)
+            try:
+                self.batch_service(settings.OMNITRON_CHANNEL_ID).to_done(
+                    batch_request=omnitron_integration.batch_request
+                )
+            except requests_exceptions.HTTPError as exc:
+                if exc.response.status_code == 406 and "batch_request_status_100_1" in exc.response.text:
+                    pass
+                else:
+                    raise exc                
+                
+                            
+    
+
+    def update_cancellation_requests(self, is_success_log=True):
+        with OmnitronIntegration(
+                content_type=ContentType.cancellation_request.value) as omnitron_integration:
+            cancellation_requests = omnitron_integration.do_action(
+                key='get_cancellation_requests_update', objects={})
+            cancellation_requests: List[CancellationRequest]
+
+            if not cancellation_requests:
+                omnitron_integration.batch_request.objects = None
+                self.batch_service(omnitron_integration.channel_id).to_fail(
+                    omnitron_integration.batch_request)
+                return
+            
+            batch_request_object_list = []
+            
+            for cancellation_request in cancellation_requests:
+                remote_order_item = self.get_channel_order_item(
+                    omnitron_integration, cancellation_request.order_item)
+                remote_reason = self.get_channel_reason(
+                    omnitron_integration, cancellation_request.reason)
+                remote_cancellation_request = self.get_channel_cancellation_request(
+                    omnitron_integration, cancellation_request.id)
+                
+                channel_cancellation_request = ChannelCancellationRequestDto(
+                    cancellation_type=cancellation_request.cancellation_type,
+                    status=cancellation_request.status,
+                    order_item=remote_order_item,
+                    reason=remote_reason,
+                    description=cancellation_request.description,
+                    remote_id=remote_cancellation_request,
+                )
+                response_data, reports, data = ChannelIntegration().do_action(
+                    key='update_cancellation_request',
+                    objects=channel_cancellation_request,
+                    batch_request=omnitron_integration.batch_request,
+                    is_sync=True)
+
+                # tips
+                response_data: List[BatchRequestResponseDto]
+                reports: List[ErrorReportDto]
+                data: List[ChannelCancellationRequestDto]
+
+                if reports and (is_success_log or not reports[0].is_ok):
+                    for report in reports:
+                        omnitron_integration.do_action(
+                            key='create_error_report',
+                            objects=report)
+
+                if response_data:
+                    failed_reason_type = None
+                else:
+                    failed_reason_type = FailedReasonType.remote.value
+                
+                batch_request_object_dto = dict(
+                    pk=cancellation_request.id,
+                    version_date=cancellation_request.modified_date,
+                    content_type=ContentType.cancellation_request.value,
+                    failed_reason_type=failed_reason_type,
+                    remote_id=remote_cancellation_request)
+                
+                batch_request_object_list.append(batch_request_object_dto)
+                   
+            status = BatchRequestStatus.fail.value
+            if any([br["failed_reason_type"] is None for br in batch_request_object_list]):
+                status = BatchRequestStatus.done.value
+
+            omnitron_integration.batch_request.objects = batch_request_object_list
+            service = self.batch_service(omnitron_integration.channel_id)
+            
+            if status == BatchRequestStatus.done.value:
+                service.to_done(batch_request=omnitron_integration.batch_request)
+            else:
+                service.to_fail(batch_request=omnitron_integration.batch_request)
+
+    def get_channel_order_item(self, omnitron_integration, order_item):
+        channel_id = omnitron_integration.channel_id
+        end_point = ChannelIntegrationActionEndpoint(
+            channel_id=channel_id)
+        params = {
+            "channel": channel_id,
+            "content_type_name": ContentType.order_item.value,
+            "object_id": order_item
+        }
+        integration_action = end_point.list(params=params)
+        if not integration_action:
+            return Exception("Order item remote id not found: {}".format(order_item))
+        if len(integration_action) > 1:
+            return Exception("Multiple order item remote id found: {}".format(order_item))
+        return integration_action[0].remote_id
+    
+    def get_channel_reason(self, omnitron_integration, omnitron_reason):
+        configuration = omnitron_integration.channel.conf
+        # configuration icinde yer alan reason_mapping anahtari bir json objesi,
+        # key channel_reason value omnitron_reason olan bir dict objesinden
+        # channel_reason'u döndürür
+        for channel_reason, omnitron_reason in configuration.get("reason_mapping", {}):
+            if omnitron_reason == omnitron_reason:
+                return channel_reason
+        
+        return "10"
+    
+    def get_channel_cancellation_request(self, omnitron_integration, 
+                                   omnitron_cancel_request_pk):
+        channel_id = omnitron_integration.channel_id
+        end_point = ChannelIntegrationActionEndpoint(
+            channel_id=channel_id)
+        params = {
+            "channel": channel_id,
+            "content_type_name": ContentType.cancellation_request.value,
+            "object_id": omnitron_cancel_request_pk
+        }
+        integration_action = end_point.list(params=params)
+        if not integration_action:
+            return Exception("Cancellation request remote id not found: {}".format(
+                omnitron_cancel_request_pk))
+        if len(integration_action) > 1:
+            return Exception("Multiple cancellation request remote id found: {}".format(
+                omnitron_cancel_request_pk))
+        return integration_action[0].remote_id
+

channel_app/channel/commands/orders/orders.py

@@ -5,9 +5,13 @@ from typing import Tuple, Any, List
 from omnisdk.omnitron.models import Order, BatchRequest
 
 from channel_app.core.commands import ChannelCommandInterface
-from channel_app.core.data import (ErrorReportDto, ChannelCreateOrderDto,
-                                   AddressDto, CustomerDto, ChannelOrderDto,
-                                   OrderItemDto, OrderBatchRequestResponseDto,
+from channel_app.core.data import (BatchRequestResponseDto, 
+                                   CancellationRequestDto, 
+                                   ChannelCancellationRequestDto, 
+                                   ErrorReportDto, 
+                                   ChannelCreateOrderDto, AddressDto, 
+                                   CustomerDto, ChannelOrderDto, OrderItemDto, 
+                                   OrderBatchRequestResponseDto,
                                    CancelOrderDto, ChannelUpdateOrderItemDto)
 from channel_app.omnitron.constants import ResponseStatus
 
@@ -72,17 +76,19 @@ class GetOrders(ChannelCommandInterface):
             yield channel_create_order, report, None
 
     def __mocked_request(self, data):
+        number = str(int(random() * 1000000))
         return [{
             "order": {
-                "remote_id": "123131",
-                "number": "12331",
+                "status": "400",
+                "remote_id": number,
+                "number": number,
                 "channel": "1",
                 "currency": "try",
                 "amount": "17",
                 "shipping_amount": "0.0",
                 "shipping_tax_rate": "18",
                 "extra_field": {},
-                "created_at": datetime.datetime.now(),
+                "created_at": str(datetime.datetime.now()),
                 "customer": {
                     "email": "dummy@dummy.com",
                     "phone_number": None,
@@ -110,11 +116,11 @@ class GetOrders(ChannelCommandInterface):
                     "city": "İstanbul",
                     "line": "dummy 3 dummy cd"
                 },
-                "cargo_company": "aras kargo"
+                "cargo_company": "aras"
             },
             "order_items": [
                 {
-                    "remote_id": "1234",
+                    "remote_id": "1234567816",
                     "product": "1234",
                     "price_currency": "try",
                     "price": "17.0",
@@ -351,21 +357,126 @@ class GetUpdatedOrderItems(ChannelCommandInterface):
         """
         Convert ChannelUpdateOrderItemDto to the format OmnitronIntegration
         """
-        for response_order_data in response:
-            order_items_data = response_order_data["order_items"]
-
-            report = self.create_report(response_order_data)
-            for order_item_data in order_items_data:
-                channel_update_order_item = ChannelUpdateOrderItemDto(
-                    **order_item_data)
+        for order_item_data in response:
+            report = self.create_report(order_item_data)
+            channel_update_order_item = ChannelUpdateOrderItemDto(
+                **order_item_data)
 
-                yield channel_update_order_item, report, None
+            yield channel_update_order_item, report, None
 
     def __mocked_request(self, data):
-        return {
+        return [{
             "remote_id": "XYAD123213",
+            "order_remote_id": "1234",
+            "order_number": "1234",
             "status": "550",
             "invoice_number": "1234",
             "invoice_date": None,
-            "tracking_number": "400"
+            "tracking_number": "400",
+            "extra_field": {"tracking_number": "1231"},
+        }]
+
+
+class GetCancellationRequests(ChannelCommandInterface):
+    def get_data(self):
+        data = self.objects
+        return data
+
+    def validated_data(self, data) -> object:
+        return data
+
+    def transform_data(self, data) -> object:
+        return data
+
+    def send_request(self, transformed_data) -> object:
+        response = self.__mocked_request(data=transformed_data)
+        return response
+
+    def normalize_response(
+            self, data, validated_data, transformed_data,
+            response) -> Tuple[CancellationRequestDto, ErrorReportDto, Any]:
+        report = self.create_report(response)
+        for row in response:
+            obj = CancellationRequestDto(
+                order_item=row["order_item"],
+                reason=row["reason"],
+                cancellation_type=row["cancellation_type"],
+                remote_id=row["remote_id"]
+            )
+
+            yield obj, report, data
+
+    def __mocked_request(self, data):
+        """
+        Mock a request and response for the send operation to mimic actual
+        channel data
+
+        :return:
+
+        [{
+            "order_item": "remote_item_1",
+            "reason": "remote_reason_code",
+            "cancellation_type": "remote_cancellation_type"
+         },]
+        """
+        response_data = [
+            {
+                'order_item': "1234567816",
+                'reason': "iptal",
+                'cancellation_type': "refund",
+                'remote_id': "1234567816_1"
+            }
+        ]
+        return response_data
+
+
+class UpdateCancellationRequest(ChannelCommandInterface):
+    def get_data(self) -> ChannelCancellationRequestDto:
+        isinstance(self.objects, ChannelCancellationRequestDto)
+        data = self.objects
+        return data
+
+    def validated_data(self, data) -> object:
+        return data
+
+    def transform_data(self, data) -> object:
+        return data
+
+    def send_request(self, transformed_data) -> object:
+        response = self.__mocked_request(data=transformed_data)
+        return response
+
+    def normalize_response(
+            self, data, validated_data, transformed_data,
+            response) -> Tuple[BatchRequestResponseDto, ErrorReportDto, Any]:
+
+        obj = BatchRequestResponseDto(
+            status=response["status"],
+            remote_id=response["remote_id"],
+            sku=response["sku"],
+            message=response["message"])
+        
+        report = self.create_report(response)
+        return obj, report, data
+
+    def __mocked_request(self, data):
+        """
+        Mock a request and response for the send operation to mimic actual
+        channel data
+
+        :return:
+            
+            {
+                "status": "SUCCESS",
+                "remote_id": "123a1",
+                "sku": "1234567",
+                "message": ""
+            }
+        """
+        return {
+            "status": ResponseStatus.success,
+            "remote_id": data.remote_id,
+            "sku": data.remote_id,
+            "message": data.status
         }
+        

channel_app/channel/commands/setup.py

@@ -1006,6 +1006,11 @@ class GetChannelConfSchema(ChannelCommandInterface):
                 data_type=ChannelConfSchemaDataTypes.text,
                 key="setting_name_2",
                 label="setting_name_2"),
+            "reason_mapping": ChannelConfSchemaField(
+                required=True,
+                data_type=ChannelConfSchemaDataTypes.json,
+                key="reason_mapping",
+                label="reason_mapping"),
         }
 
         return schema, None, None

channel_app/channel/integration.py

@@ -1,8 +1,8 @@
 import requests
 
 from channel_app.channel.commands.orders.orders import (
-    GetOrders, CheckOrders, SendUpdatedOrders, GetCancelledOrders,
-    GetUpdatedOrderItems)
+    GetCancellationRequests, GetOrders, CheckOrders, SendUpdatedOrders, 
+    GetCancelledOrders, GetUpdatedOrderItems, UpdateCancellationRequest)
 from channel_app.channel.commands.product_images import (
     SendUpdatedImages, SendInsertedImages, CheckImages)
 from channel_app.channel.commands.product_prices import (
@@ -49,7 +49,9 @@ class ChannelIntegration(BaseIntegration):
         "get_updated_order_items": GetUpdatedOrderItems,
         "send_updated_orders": SendUpdatedOrders,
         "check_orders": CheckOrders,
-        "get_cancelled_orders": GetCancelledOrders
+        "get_cancelled_orders": GetCancelledOrders,
+        "get_cancellation_requests": GetCancellationRequests,
+        "update_cancellation_request": UpdateCancellationRequest,
     }
 
     def __init__(self):

channel_app/core/commands.py

@@ -11,7 +11,7 @@ from channel_app.core.data import ErrorReportDto
 from channel_app.core.integration import BaseIntegration
 from channel_app.omnitron.batch_request import ClientBatchRequest
 from channel_app.omnitron.constants import BatchRequestStatus, ContentType
-from channel_app.omnitron.exceptions import (CountryException, CityException,
+from channel_app.omnitron.exceptions import (AppException, CityException,
                                              TownshipException,
                                              DistrictException)
 
@@ -106,17 +106,24 @@ class ChannelCommandInterface(CommandInterface):
         if not self.is_batch_request:
             return
         name = self.__class__.__name__
+        if isinstance(response, Response):
+            raw_request = f"{response.request.method}-"
+            f"{response.request.url}-"
+            f"{response.request.body}"
+            raw_response = response.text
+        else:
+            raw_request = str("")
+            raw_response = str(response)
+        
         report_list = []
         report = ErrorReportDto(
             action_content_type=ContentType.batch_request.value,
             action_object_id=self.batch_request.pk,
             modified_date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            error_code=f"{self.batch_request.local_batch_id}-{name}-{datetime.now().timestamp()}",
-            error_description=f"{self.batch_request.local_batch_id}-{name}",
-            raw_request=f"{response.request.method}-"
-                        f"{response.request.url}-"
-                        f"{response.request.body}",
-            raw_response=f"{response.text}"
+            error_code=f"{self.batch_request.local_batch_id}-Channel-{name}-{datetime.now().timestamp()}",
+            error_description=f"{name}",
+            raw_request=raw_request,
+            raw_response=raw_response
         )
         is_ok = self.check_response_is_ok(response=response)
         if is_ok:
@@ -130,7 +137,7 @@ class ChannelCommandInterface(CommandInterface):
                 action_object_id=failed_obj[0].pk,
                 modified_date=failed_obj[0].modified_date,
                 error_code=f"{self.batch_request.local_batch_id}-{name}-{datetime.now().timestamp()}",
-                error_description=f"{self.batch_request.local_batch_id}-{name}",
+                error_description=f"{name}",
                 raw_request="",
                 raw_response=f"{failed_obj[0].failed_reason_type}-{failed_obj[2]}",
                 is_ok=False
@@ -139,7 +146,10 @@ class ChannelCommandInterface(CommandInterface):
         return report_list
 
     def check_response_is_ok(self, response):
-        if str(response.status_code).startswith("2"):
+        is_response_obj = isinstance(response, Response)
+        if is_response_obj and str(response.status_code).startswith("2"):
+            return True
+        elif not is_response_obj and response:
             return True
         return False
 
@@ -209,15 +219,15 @@ class OmnitronCommandInterface(CommandInterface):
             raw_response = e.response.text
             is_ok = False
             logger.error(f"{raw_request}-/-{raw_response}")
-        except CountryException as e:
-            is_ok = False
-            raw_response = str(e.params)
         except (CityException, TownshipException, DistrictException) as e:
             is_ok = False
             self.integration.do_action(
                 key='create_address_error_report',
                 objects=e.params)
             raw_response = str(e.params)
+        except AppException as e:
+            is_ok = False
+            raw_response = str(e.params)
         except Exception as e:
             is_ok = False
             raw_response = f"{str(e)} - {traceback.format_exc()}"
@@ -225,7 +235,6 @@ class OmnitronCommandInterface(CommandInterface):
             if request:
                 raw_request = f"{request.method} - {request.url} - {request.body}"
             logger.error(f"{raw_request}-/-{raw_response}")
-
         finally:
             if not is_ok:
                 self.send_error_report(raw_request, raw_response)
@@ -258,8 +267,8 @@ class OmnitronCommandInterface(CommandInterface):
                 action_content_type=failed_obj[1],
                 action_object_id=failed_obj[0].pk,
                 modified_date=failed_obj[0].modified_date,
-                error_code=f"{self.integration.batch_request.local_batch_id}-{name}",
-                error_description=f"{self.integration.batch_request.local_batch_id}-{name}",
+                error_code=f"{self.integration.batch_request.local_batch_id}-Omnitron-{name}",
+                error_description=f"Omnitron-{name}",
                 raw_request="",
                 raw_response=f"{failed_obj[0].failed_reason_type}-{failed_obj[2]}",
                 is_ok=False
@@ -278,7 +287,7 @@ class OmnitronCommandInterface(CommandInterface):
             action_object_id=self.integration.batch_request.pk,
             modified_date=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             error_code=f"{self.integration.batch_request.local_batch_id}-{name}-{datetime.now().microsecond}",
-            error_description=f"{self.integration.batch_request.local_batch_id}-{name}",
+            error_description=f"Omnitron-{name}",
             raw_request=raw_request,
             raw_response=raw_response
         )

channel_app/core/data.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from decimal import Decimal
 from typing import List, Optional
 
-from channel_app.omnitron.constants import ResponseStatus, \
+from channel_app.omnitron.constants import CancellationType, ResponseStatus, \
     ChannelConfSchemaDataTypes
 
 
@@ -194,6 +194,14 @@ class CancelOrderDto:
     refund_invoice_number: Optional[str] = None
 
 
+@dataclass
+class CancellationRequestDto:
+    order_item: str  # remote item number
+    reason: str      # reason code
+    remote_id: str
+    cancellation_type: Optional[str] = "cancel"
+
+
 @dataclass
 class CustomerDto:
     email: str  # "john.doe@akinon.com"
@@ -254,3 +262,13 @@ class ChannelUpdateOrderItemDto:
     invoice_date: Optional[str] = None
     tracking_number: Optional[str] = None
     extra_field: Optional[dict] = None
+
+
+@dataclass
+class ChannelCancellationRequestDto:
+    cancellation_type: CancellationType  # cancel, refund
+    status: str  # confirmed, waiting_approval, approved, rejected, completed
+    order_item: str  # omnitron order item remote id
+    reason: str  # omnitron reason code
+    description: Optional[str]  # description for refund
+    remote_id: Optional[str]  # remote id for cancellation request

channel_app/core/settings.py

@@ -1,5 +1,7 @@
 import importlib
 import os
+from dotenv import load_dotenv
+load_dotenv()
 
 env_variables = os.environ
 
@@ -21,8 +23,8 @@ DEFAULT_CONNECTION_POOL_MAX_SIZE = os.getenv("DEFAULT_CONNECTION_POOL_COUNT") or
 DEFAULT_CONNECTION_POOL_RETRY = os.getenv("DEFAULT_CONNECTION_POOL_RETRY") or 0
 REQUEST_LOG = os.getenv("REQUEST_LOG") or False
 
-omnitron_module = importlib.import_module(os.environ.get("OMNITRON_MODULE"))
+omnitron_module = importlib.import_module(os.getenv("OMNITRON_MODULE"))
 OmnitronIntegration = omnitron_module.OmnitronIntegration
 
-channel_module = importlib.import_module(os.environ.get("CHANNEL_MODULE"))
+channel_module = importlib.import_module(os.getenv("CHANNEL_MODULE"))
 ChannelIntegration = channel_module.ChannelIntegration

channel_app/omnitron/commands/orders/addresses.py

@@ -69,7 +69,7 @@ class GetOrCreateAddress(OmnitronCommandInterface):
             "district": district_pk,
             "title": address.title and address.title[:128],
             "line": address.line[:255],
-            "postcode": address.postcode[:64],
+            "postcode": address.postcode and address.postcode[:64],
             "notes": address.notes and address.notes[:512],
             "company_name": address.company_name and address.company_name[:255],
             "tax_office": address.tax_office and address.tax_office[:64],
@@ -187,6 +187,10 @@ class GetOrCreateAddress(OmnitronCommandInterface):
         countries = endpoint.list(params=params)
         if len(countries) == 1:
             return countries[0]
+        params = {"name__exact": country_code, "is_active": True}
+        countries = endpoint.list(params=params)
+        if len(countries) == 1:
+            return countries[0]        
         try:
             countries = self.get_mapping_object(country_code, endpoint)
         except IntegrationMappingException as exc:

channel_app/omnitron/commands/orders/cargo_companies.py

@@ -4,6 +4,7 @@ from omnisdk.omnitron.endpoints import ChannelCargoEndpoint
 from omnisdk.omnitron.models import CargoCompany
 
 from channel_app.core.commands import OmnitronCommandInterface
+from channel_app.omnitron.exceptions import CargoCompanyException
 
 
 class GetCargoCompany(OmnitronCommandInterface):
@@ -14,7 +15,7 @@ class GetCargoCompany(OmnitronCommandInterface):
         for cargo_company in data:
             if cargo_company.erp_code == cargo_company_code:
                 return cargo_company
-        raise Exception("CargoCompany does not exists: {}".format(
+        raise CargoCompanyException("CargoCompany does not exists: {}".format(
             cargo_company_code))
 
     def get_data(self) -> List[CargoCompany]:

channel_app/omnitron/commands/orders/customers.py

@@ -56,7 +56,7 @@ class GetOrCreateCustomer(OmnitronCommandInterface):
                 new_customer.last_name = data.last_name
             if must_update:
                 customer = self.endpoint(channel_id=self.integration.channel_id).update(
-                    id=customer.pk, item=customer)
+                    id=customer.pk, item=new_customer)
         else:
             new_customer = Customer()
             new_customer.channel = self.integration.channel_id

channel_app/omnitron/commands/orders/orders.py

@@ -1,5 +1,7 @@
 from dataclasses import asdict
-from typing import List
+from typing import Any, List
+
+from requests import exceptions as requests_exceptions
 
 from omnisdk.omnitron.endpoints import (ChannelCreateOrderEndpoint,
                                         ChannelIntegrationActionEndpoint,
@@ -15,12 +17,13 @@ from omnisdk.omnitron.models import Order, OrderShippingInfo, \
 from channel_app.core.commands import OmnitronCommandInterface
 from channel_app.core.data import (OrderBatchRequestResponseDto,
                                    OmnitronCreateOrderDto, OmnitronOrderDto,
-                                   OrderItemDto, CancelOrderDto, ErrorReportDto)
+                                   OrderItemDto, CancelOrderDto, 
+                                   CancellationRequestDto)
 from channel_app.core.utilities import split_list
 from channel_app.omnitron.batch_request import ClientBatchRequest
 from channel_app.omnitron.commands.batch_requests import ProcessBatchRequests
 from channel_app.omnitron.constants import (ContentType, BatchRequestStatus)
-from channel_app.omnitron.exceptions import OrderException
+from channel_app.omnitron.exceptions import AppException, OrderException
 
 
 class GetOrders(OmnitronCommandInterface):
@@ -227,10 +230,12 @@ class CreateOrders(OmnitronCommandInterface):
 
         except OrderException:
             return is_order_exists
-
-        order = self.endpoint(
-            channel_id=self.integration.channel_id
-        ).create(item=order_obj)
+        try:
+            order = self.endpoint(
+                channel_id=self.integration.channel_id
+            ).create(item=order_obj)
+        except requests_exceptions.HTTPError as exc:
+            raise OrderException(params=exc.response.text)
 
         self._update_batch_request(order)
         return order
@@ -274,6 +279,9 @@ class CreateOrders(OmnitronCommandInterface):
         for item in order_items:
             price_list = self.integration.catalog.price_list
             stock_list = self.integration.catalog.stock_list
+            if item.product not in product_dict:
+                raise AppException(
+                    "Product not found: remote_id={}".format(item.product))
             order_item_data = {
                 "product": product_dict[item.product],
                 "status": item.status or "400",
@@ -488,7 +496,7 @@ class GetCancellationRequest(OmnitronCommandInterface):
 
     def get_data(self):
         """
-        {"status": "approved", "cancellation_type": "refund or cancel", "order_item": 3212}
+        {"status": "approved", "cancellation_type": "refund or cancel"}
         """
         assert isinstance(self.objects, dict)
         query_params = self.objects
@@ -504,8 +512,125 @@ class GetCancellationRequest(OmnitronCommandInterface):
             if not batch:
                 break
             cancellation_requests.extend(batch)
+        
+        objects_data = self.create_batch_objects(
+            data=cancellation_requests, content_type=self.content_type)
+        self.update_batch_request(objects_data=objects_data)
+                
         return cancellation_requests
+    
+    def check_run(self, is_ok, formatted_data):
+        if not is_ok:
+            return False
+        return True
+
+
+class GetCancellationRequestUpdates(GetCancellationRequest):
+    endpoint = ChannelCancellationRequestEndpoint
+    path = "updates"
+
+    def get_cancellation_requests(self, query_params={}) -> List[CancellationRequest]:
+        endpoint = self.endpoint(channel_id=self.integration.channel_id,
+                                 path=self.path)
+        cancellation_requests = endpoint.list(params=query_params)
+        for batch in endpoint.iterator:
+            if not batch:
+                break
+            cancellation_requests.extend(batch)
+        
+        for cr in cancellation_requests:
+            cr.pk = cr.id
+            
+        objects_data = self.create_batch_objects(
+            data=cancellation_requests, content_type=self.content_type)
+        self.update_batch_request(objects_data=objects_data)
+        return cancellation_requests
+
+    def check_run(self, is_ok, formatted_data):
+        if not is_ok:
+            return False
+        return True
+
 
+class CreateCancellationRequest(OmnitronCommandInterface):
+    endpoint = ChannelCancellationRequestEndpoint
+
+    def get_data(self):
+        assert isinstance(self.objects, CancellationRequestDto)
+        cancellation_request = self.objects
+        # omnitron donusumleri yapilir.
+        omnitron_reason = self.get_omnitron_reason(cancellation_request.reason)
+        # omnitron reason
+        cancellation_request.reason = omnitron_reason
+        # remote_id
+        cancellation_request.remote_id = cancellation_request.remote_id
+        # omnitron order_item
+        omnitron_order_item = self.get_omnitron_order_item(cancellation_request.order_item)
+        cancellation_request.order_item = omnitron_order_item
+        
+        data = asdict(cancellation_request)
+        return CancellationRequest(**data)
+    
+    def send(self, validated_data) -> CancellationRequest:
+        """
+        :param validated_data: data for order
+        :return: cancellationrequest objects
+        """
+        endpoint = self.endpoint(channel_id=self.integration.channel_id)
+
+        response_cancellation_request = endpoint.create(item=validated_data)
+        response_cancellation_request.remote_id = validated_data.remote_id
+        response_cancellation_request.pk = response_cancellation_request.id
+        objects_data = self.create_batch_objects(
+            data=[response_cancellation_request], 
+            content_type=ContentType.cancellation_request.value)
+        
+        self.update_batch_request(objects_data=objects_data)
+        return response_cancellation_request
+    
+    def normalize_response(self, data, response) -> List[object]:
+        return [response]
+    
+    def check_run(self, is_ok, formatted_data):
+        if not is_ok:
+            return False
+        return True
+
+    def get_omnitron_order_item(self, channel_order_item):
+        """
+        order_item_remote_id -> omnitron orderitem remote_id str
+        :return: int
+        """
+        end_point = ChannelIntegrationActionEndpoint(
+            channel_id=self.integration.channel_id)
+        
+        params = {"channel": self.integration.channel_id,
+                  "content_type_name": ContentType.order_item.value,
+                  "remote_id__exact": channel_order_item,
+                  "sort": "id"}
+        integration_actions = end_point.list(params=params)
+        for item in end_point.iterator:
+            if not item:
+                break
+            integration_actions.extend(item)
+
+        if not integration_actions:
+            raise AppException(
+                "OrderItem not found, number={}".format(
+                    channel_order_item))
+        if len(integration_actions) != 1:
+            raise AppException("Multiple records returned from Omnitron "
+                               "for a single order item: remote_id: {}".format(
+                                   channel_order_item))
+        return integration_actions[0].object_id
+            
+    def get_omnitron_reason(self, channel_reason):
+        configuration = self.integration.channel.conf
+        omnitron_reason = configuration.get("reason_mapping", {}).get(channel_reason)
+        if omnitron_reason:
+            return omnitron_reason
+        return 10
+    
 
 class UpdateOrderItems(OmnitronCommandInterface):
     endpoint = ChannelOrderItemEndpoint

channel_app/omnitron/commands/tests/test_orders.py

@@ -6,13 +6,25 @@ from omnisdk.omnitron.endpoints import (
     ChannelCustomerEndpoint,
     ChannelOrderEndpoint,
     ChannelOrderItemEndpoint,
-)
-from channel_app.core.data import CustomerDto, OrderBatchRequestResponseDto
+    ChannelCancellationRequestEndpoint,
+    ChannelBatchRequestEndpoint)
+from omnisdk.omnitron.models import CancellationRequest
+
+from channel_app.core.data import CancellationRequestDto, CustomerDto, OrderBatchRequestResponseDto
 from channel_app.core.tests import BaseTestCaseMixin
 from channel_app.omnitron.commands.orders.cargo_companies import GetCargoCompany
 from channel_app.omnitron.commands.orders.customers import GetOrCreateCustomer
-from channel_app.omnitron.commands.orders.orders import GetOrderItems, GetOrderItemsWithOrder, ProcessOrderBatchRequests
-from channel_app.omnitron.constants import BatchRequestStatus, CustomerIdentifierField
+from channel_app.omnitron.commands.orders.orders import (
+    CreateCancellationRequest,
+    GetCancellationRequestUpdates, 
+    GetOrderItems, 
+    GetOrderItemsWithOrder, 
+    ProcessOrderBatchRequests,
+    ChannelIntegrationActionEndpoint)
+from channel_app.omnitron.constants import (
+    BatchRequestStatus,
+    CancellationType, 
+    CustomerIdentifierField)
 
 
 class TestProcessOrderBatchRequests(BaseTestCaseMixin):
@@ -482,3 +494,99 @@ class TestGetOrderItemsWithOrder(BaseTestCaseMixin):
 
         self.assertEqual(len(orders), 1)
         self.assertEqual(len(orders[0].orderitem_set), 2)
+
+class TestGetCancellationRequestUpdates(BaseTestCaseMixin):
+    """
+    Test case for GetCancellationRequestUpdates
+    run: python -m unittest channel_app.omnitron.commands.tests.test_orders.GetCancellationRequestUpdates
+    """
+
+    def setUp(self) -> None:
+        self.instance = GetCancellationRequestUpdates(
+            integration=self.mock_integration,
+        )
+       
+        self.instance.objects = {
+            'status': 'completed',
+            'cancellation_type': 'refund'
+        }
+        self.endpoint = ChannelCancellationRequestEndpoint
+        self.cancellation_request = MagicMock(
+                pk=1,
+                status='completed',
+                cancellation_type='refund',
+                easy_return=None,
+                order_item=1,
+            )
+        return super().setUp()
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(ChannelCancellationRequestEndpoint, '_list')
+    @patch.object(ChannelBatchRequestEndpoint, 'update')    
+    def test_get_data(self, mock_endpoint, mock_get_instance, mock_batch_request):
+        response_data = [
+                MagicMock(
+                pk=1,
+                status='completed',
+                cancellation_type=CancellationType.refund.value,
+                easy_return=None,
+                order_item=1,
+            ),
+                MagicMock(
+                pk=2,
+                status='completed',
+                cancellation_type=CancellationType.refund.value,
+                easy_return=None,
+                order_item=2,
+            )
+        ]
+        response = MagicMock()
+        response.list.return_value = response_data
+        with patch.object(self.endpoint, '__new__', return_value=response):
+            data = self.instance.get_data()
+            self.assertEqual(len(data), 2)
+            self.assertEqual(data[0].status, self.instance.objects['status'])
+
+    @patch.object(GetCancellationRequestUpdates, 'get_cancellation_requests')
+    def test_update_cancellation_request(self, mock_get_cancellation_requests):
+        mock_get_cancellation_requests.return_value = self.cancellation_request
+        self.instance.get_cancellation_requests(self.cancellation_request)
+        self.assertEqual(self.cancellation_request.status, self.instance.objects['status'])
+        self.assertEqual(self.cancellation_request.cancellation_type, self.instance.objects['cancellation_type'])
+
+
+class TestCreateCancellationRequest(BaseTestCaseMixin):
+    """
+    Test case for CreateCancellationRequest
+    run: python -m unittest channel_app.omnitron.commands.tests.test_orders.TestCreateCancellationRequest
+    """
+
+    def setUp(self) -> None:
+        self.instance = CreateCancellationRequest(
+            integration=self.mock_integration)
+
+        self.endpoint = ChannelCancellationRequestEndpoint
+        self.instance.objects = CancellationRequestDto(
+            order_item='1',
+            reason='reason_code',
+            remote_id='2',
+            cancellation_type=CancellationType.refund.value)
+        return super().setUp()
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(CreateCancellationRequest, 'get_omnitron_order_item')
+    def test_get_data(self, mock_get_instance, mock_get_omnitron_order_item):
+        mock_get_omnitron_order_item.return_value = 1
+        response_data = CancellationRequest(
+                pk=1,
+                status='waiting',
+                cancellation_type='refund',
+                easy_return=None,
+                order_item=1,
+            )
+        response = MagicMock()
+        response.create.return_value = response_data
+
+        with patch.object(self.endpoint, '__new__', return_value=response):
+            data = self.instance.get_data()
+            self.assertIsInstance(data, CancellationRequest)

channel_app/omnitron/constants.py

@@ -96,3 +96,8 @@ class ChannelConfSchemaDataTypes:
     json = 'json'
     list = 'list'
     integer = 'integer'
+
+
+class CancellationType(Enum):
+    cancel = "cancel"
+    refund = "refund"

channel_app/omnitron/exceptions.py

@@ -1,8 +1,11 @@
-class IntegrationMappingException(Exception):
+class AppException(Exception):
     def __init__(self, params=None):
-        super(IntegrationMappingException, self).__init__()
+        super(BaseException, self).__init__()
         self.params = params
 
+class IntegrationMappingException(AppException):
+    pass
+
 
 class CountryException(IntegrationMappingException):
     pass
@@ -24,19 +27,13 @@ class AddressException(IntegrationMappingException):
     pass
 
 
-class OrderException(Exception):
-    def __init__(self, params=None):
-        super(OrderException, self).__init__()
-        self.params = params
+class OrderException(AppException):
+    pass
 
 
-class CargoCompanyException(Exception):
-    def __init__(self, params=None):
-        super().__init__()
-        self.params = params
+class CargoCompanyException(AppException):
+    pass
 
 
-class CustomerException(Exception):
-    def __init__(self, params=None):
-        super(CustomerException, self).__init__()
-        self.params = params
+class CustomerException(AppException):
+    pass

channel_app/omnitron/integration.py

@@ -18,6 +18,8 @@ from channel_app.omnitron.commands.orders.customers import GetOrCreateCustomer
 from channel_app.omnitron.commands.orders.orders import (
     CreateOrders,
     CreateOrderShippingInfo,
+    GetCancellationRequestUpdates,
+    CreateCancellationRequest,
     GetOrders,
     ProcessOrderBatchRequests,
     CreateOrderCancel,
@@ -135,6 +137,8 @@ class OmnitronIntegration(BaseIntegration):
         "get_product_objects": GetProductObjects,
         "get_product_from_batch_request": GetProductsFromBatchrequest,
         "get_cancellation_requests": GetCancellationRequest,
+        "get_cancellation_requests_update": GetCancellationRequestUpdates,
+        "create_cancellation_requests": CreateCancellationRequest,
         "update_order_items": UpdateOrderItems
         # "fetch_cancellation_plan": FetchCancellationPlan
     }

{channel_app-0.0.148.dist-info → channel_app-0.0.150.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: channel_app
-Version: 0.0.148
+Version: 0.0.150
 Summary: Channel app for Sales Channels
 Home-page: https://github.com/akinon/channel_app
 Author: akinonteam

{channel_app-0.0.148.dist-info → channel_app-0.0.150.dist-info}/RECORD

@@ -1,7 +1,7 @@
 channel_app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channel_app/app/order/service.py,sha256=YFP4QAWx0aaWhrG5lgnpyDIJXtJYLAnyDDW1a8w2DOs,11585
+channel_app/app/order/service.py,sha256=ZYQ7TRyVRk3VyNPfXyhdfVpLljtpHP8Gdijiq_47Wtk,20462
 channel_app/app/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/product/service.py,sha256=7DZF-Vtoaf5eKT1m_ccEOAqUxWSO7Csop4HEtJmcrvw,10646
 channel_app/app/product_image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -13,30 +13,30 @@ channel_app/app/product_stock/service.py,sha256=6oS4tkWkkVAwEMFWqn0uc0zZgByoxP69
 channel_app/app/setup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/app/setup/service.py,sha256=d53IKrQjahNZvxCaZAmXo2VUKBMM6-wm-P9I9tBTYOY,4553
 channel_app/channel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channel_app/channel/integration.py,sha256=q7wwPvYukEEoLCMZZ6d4GDiRHV8u_dPHT3cGU6DUuik,3587
+channel_app/channel/integration.py,sha256=fDx5nxa6w-4gMucU7xo_OTOkqPHdBUHeDtuzeaDJlXE,3769
 channel_app/channel/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/channel/commands/product_categories.py,sha256=ktN8NnWNcHcVREVOU-SSZbH5ZEwihAUOgHsZm1KcEpY,52
 channel_app/channel/commands/product_images.py,sha256=8lCSt-_YkD1IytAXOtAJAwWd9d53QZPKir-iopK1fC0,4855
 channel_app/channel/commands/product_prices.py,sha256=pOY_1qb_0soGyK1wkTy2epL4xUeFflFfWLGCKoVRiCo,4855
 channel_app/channel/commands/product_stocks.py,sha256=3mUz9K1zA3ljvtcOBgD5uQsMHBmzTxrSfj5vHXBV5qs,8157
 channel_app/channel/commands/products.py,sha256=ZzmJbcOJISOcsZ9F3FL012rqU-eNhwW_LGYYlb2WmzA,5257
-channel_app/channel/commands/setup.py,sha256=NNUq7jzBHXt61Jhm9XExm2kXp6u7YEjO45fjpIRiNKk,36040
+channel_app/channel/commands/setup.py,sha256=GX2yp0yGsoKDjl_w3ooY_ftaVZ6-hk_F9B55KqBr3ho,36263
 channel_app/channel/commands/orders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channel_app/channel/commands/orders/orders.py,sha256=PcoDuJDR-1RuZBPqKgkPXJWkbr7OwQasyqzKrXigmFg,12487
+channel_app/channel/commands/orders/orders.py,sha256=edBCmp0BBg5qNhduWnB7p2yAf0pVFEZ5uef2EvVDUl0,15837
 channel_app/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/core/clients.py,sha256=o8OBkXwof8BobEyiiHPwmGsUcOlPb60u3oUeAUxo_hc,1591
-channel_app/core/commands.py,sha256=dQ-aJxZkc0j25hmp1Ui_s1ykY5LQ5_wxZCo6OrcxmnI,14120
-channel_app/core/data.py,sha256=-9jDxdYZrvUhusbOfvtAfHwlweky_p-XD2zzOW5liLA,6302
+channel_app/core/commands.py,sha256=gGSsjHJmMTkj6OuzhUsbVMQCGGiumwnSzM1T9mqHiss,14316
+channel_app/core/data.py,sha256=xiNQh_r_F3RXSO6jncHNEVLPO9sDVm_3A-MMOwdh6n8,6910
 channel_app/core/integration.py,sha256=OqpN8B3KBLsjjrbZXZaNVF6NtObejh7P_7kGFj1xU3o,2817
 channel_app/core/products.py,sha256=uInjFw-vze1XP8vWEeq4VWDZVQQIiatoe1YsQ6n_H5E,2092
-channel_app/core/settings.py,sha256=66y5YJksINO0WQ6UwXeYQXiCVfjrve0r4QgRENQaGyQ,1212
+channel_app/core/settings.py,sha256=1KF8PhbjEqyZOWese9EFA_DnaSA1eVcscfShVIroTRo,1247
 channel_app/core/tests.py,sha256=ucgnLyb3D8H2JvjjH6icdRZzZQoMFbnlnFLylhoJ0Js,434
 channel_app/core/utilities.py,sha256=3iSU4RHFSsdTWBfUYBK23CRGtAIC-nYIBIJLm0Dlx3o,4168
 channel_app/omnitron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/omnitron/batch_request.py,sha256=S8IHtbI1RtVLbnOwtfXSmkrREGp8wUYW2E-eu5omwyY,3550
-channel_app/omnitron/constants.py,sha256=2kvdez5VJPzhNcMyV0VaG_6JTYkUVYwuOifnMIwGOg8,2718
-channel_app/omnitron/exceptions.py,sha256=_NjIx5LKPbKiP5jrJJGIfKGsRbGK6Thas3j5MGlq8Js,928
-channel_app/omnitron/integration.py,sha256=Jw9SZeDMLKRxzrZB02FTVhwDbercawfCi_GwYSPqFdc,9253
+channel_app/omnitron/constants.py,sha256=WZR6k_k2zZfN7lfi1ZLv1PphsHIq_LiZgw6Nd6LduvE,2793
+channel_app/omnitron/exceptions.py,sha256=iVChxLBl6JJy42lgfnmZIA3Sa8ykL1_P0jErpRmOovY,672
+channel_app/omnitron/integration.py,sha256=A3hIM2jVYR-CRzVIztq2iHQrlasmgCeY_9OZhUiAO6Y,9461
 channel_app/omnitron/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 channel_app/omnitron/commands/batch_requests.py,sha256=WXd1iCJKC-nCcMHZ2XDP9UVcC2Xq3MFd1uCqz8h5_pU,11638
 channel_app/omnitron/commands/error_reports.py,sha256=PFeWryOjAyN6huKn5W8gq-ii0aa2yTGPfBoWieNL5RQ,2942
@@ -48,17 +48,17 @@ channel_app/omnitron/commands/product_stocks.py,sha256=va2LbTtFMLe99kJr5aFceYLi2
 channel_app/omnitron/commands/products.py,sha256=As8Hnw3h6dOfPdxPBPUs-Hdip_9IaQXQyLAMsAylMTs,32098
 channel_app/omnitron/commands/setup.py,sha256=dcbvvIFDKKeDVziwR2qWJhVd92IlVLEoYIbMrxKjWDE,35220
 channel_app/omnitron/commands/orders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channel_app/omnitron/commands/orders/addresses.py,sha256=FS63zncxP1hHjObq0Yjr9mq1voixzL52YdKt17Q0uV0,12358
-channel_app/omnitron/commands/orders/cargo_companies.py,sha256=pTyOgsoIBLHUIj7F2eB_y3NXS8p8Qi0rsqjIZ7AZiWs,1308
-channel_app/omnitron/commands/orders/customers.py,sha256=bBE5o3KFyReaMQm4dTrcZm7u0FEq3u-_YpVt5ru3_B8,3446
-channel_app/omnitron/commands/orders/orders.py,sha256=MJP3nAhBqOYfe028tjn7TOzxrjojcFNAIUScTxm2zXw,22755
+channel_app/omnitron/commands/orders/addresses.py,sha256=2wjYOyAv5TSZ6c7TUl2SWSFCYg5Vmihimj1Iz4Ybm_U,12566
+channel_app/omnitron/commands/orders/cargo_companies.py,sha256=Q5RKIbP8cNLRa82GA7TyjrKZ2gIDWXscMTQTSJOvwGE,1386
+channel_app/omnitron/commands/orders/customers.py,sha256=1IbzZsQSIcroJagsinKy__q3vEU8kZj3LxNhxb-mWQ0,3450
+channel_app/omnitron/commands/orders/orders.py,sha256=U_DwYsPzWo_MfFc1QUZhcLfKhg_bjoSGzpYutOFKFhs,27697
 channel_app/omnitron/commands/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channel_app/omnitron/commands/tests/test_orders.py,sha256=mG2o4hftXFoYvTfWmgP9QrGtgMUPudoFRYKRZLku0l0,16345
+channel_app/omnitron/commands/tests/test_orders.py,sha256=acndyE5vpWUYdIaAsa2TlJxxmtUNRKE0IDP7DJRMgTo,20451
 channel_app/omnitron/commands/tests/test_product_images.py,sha256=y6tmiJ00kd2GTqSv4MOCjUnXFFSAKhhAwsqQ0l0ccNk,3492
 channel_app/omnitron/commands/tests/test_product_prices.py,sha256=5HPX9PmjGw6gk3oNrwtWLqdrOkfeNx1mYP-pYwOesZU,3496
 channel_app/omnitron/commands/tests/test_product_stocks.py,sha256=q4RGlrCNUUJyN5CBL1fzrvdd4Q3xt816mbMRQT0XEd0,3496
 channel_app/omnitron/commands/tests/test_products.py,sha256=DUUdB7pKe-wj8H1N-otKhR-97z37Q3Mh0QgROlnrKTQ,102028
-channel_app-0.0.148.dist-info/METADATA,sha256=4z7ZPV0_H7HL_j3rZjKgc6ROo4azRlDW26c_m339WWw,309
-channel_app-0.0.148.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-channel_app-0.0.148.dist-info/top_level.txt,sha256=JT-gM6L5Cwxr1xEoN7NHrREDs-d6iGFGfRnK-NrJ3tU,12
-channel_app-0.0.148.dist-info/RECORD,,
+channel_app-0.0.150.dist-info/METADATA,sha256=hBDfLNla_Z7s_B6rgAPeAFHb6V3kN0lM1TkvzleiOz0,309
+channel_app-0.0.150.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+channel_app-0.0.150.dist-info/top_level.txt,sha256=JT-gM6L5Cwxr1xEoN7NHrREDs-d6iGFGfRnK-NrJ3tU,12
+channel_app-0.0.150.dist-info/RECORD,,

{channel_app-0.0.148.dist-info → channel_app-0.0.150.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any