channel-app 0.0.148__tar.gz → 0.0.149__tar.gz

{channel_app-0.0.148 → channel_app-0.0.149}/.gitignore

@@ -83,4 +83,5 @@ coverage.xml
 *.py,cover
 .hypothesis/
 .pytest_cache/
-cover/
+cover/
+venv/

{channel_app-0.0.148/channel_app.egg-info → channel_app-0.0.149}/PKG-INFO

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

{channel_app-0.0.148 → channel_app-0.0.149}/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-0.0.148 → channel_app-0.0.149}/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-0.0.148 → channel_app-0.0.149}/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-0.0.148 → channel_app-0.0.149}/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-0.0.148 → channel_app-0.0.149}/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-0.0.148 → channel_app-0.0.149}/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