channel-app 0.0.131__py3-none-any.whl → 0.0.135__py3-none-any.whl

channel_app/channel_app/channel/integration.py

@@ -1,84 +0,0 @@
-import requests
-
-from channel_app.channel.commands.orders.orders import GetOrders, CheckOrders, \
-    SendUpdatedOrders, GetCancelledOrders
-from channel_app.channel.commands.product_prices import (CheckPrices,
-                                                         SendInsertedPrices,
-                                                         SendUpdatedPrices)
-from channel_app.channel.commands.product_stocks import (SendUpdatedStocks,
-                                                         CheckStocks,
-                                                         SendInsertedStocks)
-from channel_app.channel.commands.products import (SendInsertedProducts,
-                                                   CheckProducts,
-                                                   CheckDeletedProducts,
-                                                   SendUpdatedProducts,
-                                                   SendDeletedProducts)
-from channel_app.channel.commands.setup import (GetCategoryTreeAndNodes,
-                                                GetCategoryAttributes,
-                                                GetChannelConfSchema)
-from channel_app.core.integration import BaseIntegration
-
-
-class ChannelIntegration(BaseIntegration):
-    """
-    Communicates with the Channel Api services through the commands defined.
-
-    If an Api Client class is developed, initialization and deletion should be handled in
-    ChannelIntegration class so that commands have easier access to the api object.
-    """
-    _sent_data = {}
-    actions = {
-        "send_inserted_products": SendInsertedProducts,
-        "send_updated_products": SendUpdatedProducts,
-        "send_deleted_products": SendDeletedProducts,
-        "check_products": CheckProducts,
-        "check_deleted_products": CheckDeletedProducts,
-        "send_updated_stocks": SendUpdatedStocks,
-        "send_inserted_stocks": SendInsertedStocks,
-        "send_updated_prices": SendUpdatedPrices,
-        "send_inserted_prices": SendInsertedPrices,
-        "check_stocks": CheckStocks,
-        "check_prices": CheckPrices,
-        "get_category_tree_and_nodes": GetCategoryTreeAndNodes,
-        "get_channel_conf_schema": GetChannelConfSchema,
-        "get_category_attributes": GetCategoryAttributes,
-        "get_orders": GetOrders,
-        "send_updated_orders": SendUpdatedOrders,
-        "check_orders": CheckOrders,
-        "get_cancelled_orders": GetCancelledOrders
-    }
-
-    def __init__(self):
-        from channel_app.core import settings
-        self.channel_id = settings.OMNITRON_CHANNEL_ID
-        self.catalog_id = settings.OMNITRON_CATALOG_ID
-
-    def create_session(self):
-        from channel_app.core import settings
-
-        session = requests.Session()
-        connections = self.channel.conf.get(
-            'connection_pool_count', settings.DEFAULT_CONNECTION_POOL_COUNT)
-        max_size = self.channel.conf.get(
-            'connection_pool_max_size', settings.DEFAULT_CONNECTION_POOL_MAX_SIZE)
-        retry = self.channel.conf.get(
-            'connection_pool_retry', settings.DEFAULT_CONNECTION_POOL_RETRY)
-
-        adapter = requests.adapters.HTTPAdapter(pool_connections=connections,
-                                                pool_maxsize=max_size,
-                                                max_retries=retry)
-        session.mount('http://', adapter)
-        session.mount('https://', adapter)
-        return session
-
-    @property
-    def _session(self):
-        __session = getattr(self, "__session", None)
-        if __session:
-            return __session
-
-        session = self.create_session()
-        setattr(self, "__session", session)
-        return session
-
-

channel_app/channel_app/core/clients.py

@@ -1,12 +0,0 @@
-from redis import Redis
-
-
-class RedisClient(Redis):
-    def __init__(self):
-        from channel_app.core import settings
-        self.broker_database_index = int(settings.CACHE_DATABASE_INDEX)
-        self.broker_port = settings.CACHE_PORT
-        self.broker_host = settings.CACHE_HOST
-        super(RedisClient, self).__init__(host=self.broker_host,
-                                          port=self.broker_port,
-                                          db=self.broker_database_index)

channel_app/channel_app/core/commands.py

@@ -1,364 +0,0 @@
-import logging
-import traceback
-from datetime import datetime
-from io import StringIO
-from typing import List, Any
-
-from omnisdk.omnitron.models import BatchRequest
-from requests import HTTPError, Request, Response
-
-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,
-                                             TownshipException,
-                                             DistrictException)
-
-logger = logging.getLogger(__name__)
-
-
-class LogService(object):
-    pass
-
-
-class CommandInterface(object):
-    def get_data(self) -> object:
-        """
-        This method fetches the input data for the command.
-        """
-        raise NotImplementedError()
-
-    def transform_data(self, data) -> object:
-        """
-        This method can be used to format the input data before it is executed on the run method.
-        """
-        raise NotImplementedError()
-
-    def validated_data(self, data) -> dict:
-        """
-        If the input data needs to satisfy some conditions or contain required a parameter, the
-        validation is done here.
-        """
-        return data
-
-    def send(self, validated_data) -> object:
-        """
-        If the command sends a request using input data to achieve the main object of the
-        command, it is recommended to place those operations in this method.
-
-        :param validated_data:
-        """
-        raise NotImplementedError()
-
-
-class ChannelCommandInterface(CommandInterface):
-    def __init__(self, integration, objects=None, batch_request=None, **kwargs):
-        self.objects = objects
-        self.integration = integration
-        self.batch_request = batch_request
-        self.failed_object_list = []
-        self.session = integration._session
-        self.CHUNK_SIZE = 50
-        self.BATCH_SIZE = 100
-
-        for key, value in kwargs.items():
-            setattr(self, "param_{}".format(key), value)
-
-    def get_data(self) -> object:
-        raise NotImplementedError
-
-    def validated_data(self, data) -> object:
-        raise NotImplementedError
-
-    def transform_data(self, data) -> object:
-        raise NotImplementedError
-
-    def send_request(self, transformed_data) -> object:
-        """
-        If the command sends a request using input data to achieve the main object of the
-        command, it is recommended to place those operations in this method.
-        """
-        raise NotImplementedError()
-
-    def normalize_response(self, data, validated_data, transformed_data,
-                           response):
-        raise NotImplementedError
-
-    def run(self):
-        """
-        Main flow of the command. `do_action` method of the integration class executes this method.
-        This method must also call necessary command interface methods.
-        :return: returns to response of the command if it has one.
-        """
-        data = self.get_data()
-        validated_data = self.validated_data(data)
-        transformed_data = self.transform_data(validated_data)
-        response = self.send_request(transformed_data=transformed_data)
-        normalize_data = self.normalize_response(
-            data=data,
-            validated_data=validated_data,
-            transformed_data=transformed_data,
-            response=response)
-        return normalize_data
-
-    def create_report(self, response):
-        if not self.is_batch_request:
-            return
-        name = self.__class__.__name__
-        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}",
-            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}"
-        )
-        is_ok = self.check_response_is_ok(response=response)
-        if is_ok:
-            report.is_ok = True
-        else:
-            report.is_ok = False
-        report_list.append(report)
-        for failed_obj in self.failed_object_list:
-            raw_report = ErrorReportDto(
-                action_content_type=failed_obj[1],
-                action_object_id=failed_obj[0].pk,
-                modified_date=failed_obj[0].modified_date,
-                error_code=f"{self.batch_request.local_batch_id}-{name}",
-                error_description=f"{self.batch_request.local_batch_id}-{name}",
-                raw_request="",
-                raw_response=f"{failed_obj[0].failed_reason_type}-{failed_obj[2]}",
-                is_ok=False
-            )
-            report_list.append(raw_report)
-        return report_list
-
-    def check_response_is_ok(self, response):
-        if str(response.status_code).startswith("2"):
-            return True
-        return False
-
-    @property
-    def is_batch_request(self) -> bool:
-        is_object = getattr(
-            self, 'batch_request', None)
-        return bool(is_object)
-
-
-class OmnitronCommandInterface(CommandInterface):
-    """
-    Commands implement list of steps to achieve a task. A command can contain a simple get request
-    or a complicated business logic with lots of validation.
-
-    """
-    batch_service = ClientBatchRequest
-    content_type = None
-
-    def __init__(self, integration: BaseIntegration, objects: Any = None,
-                 batch_request: BatchRequest = None, **kwargs):
-        """
-        :param integration: Integration object
-        :param objects: Input to the command
-        :param batch_request: Related batch request to keep track of the whole task
-
-        """
-        self.objects = objects
-        self.batch_request = batch_request
-        self.integration = integration
-        self.failed_object_list = []
-        for key, value in kwargs.items():
-            setattr(self, "param_{}".format(key), value)
-
-    def get_data(self) -> object:
-        return self.objects
-
-    def send(self, validated_data) -> object:
-        return validated_data
-
-    def normalize_response(self, data, response) -> List[object]:
-        return response
-
-    def run(self) -> Any:
-        """
-        Main flow of the command. `do_action` method of the integration class executes this method.
-        This method must also call necessary command interface methods.
-        :return: Response of the command or None
-        """
-        is_ok = True
-        formatted_data = None
-        raw_request, raw_response = None, None
-        try:
-            model_items = self.validated_data(self.get_data())
-            response = self.send(validated_data=model_items)
-            normalize_data = self.normalize_response(data=model_items,
-                                                     response=response)
-            if isinstance(normalize_data, list):
-                formatted_data = [model_obj for model_obj in normalize_data
-                                  if
-                                  not getattr(model_obj, "failed_reason_type",
-                                              None)]
-            self.row_send_error_report()
-        except HTTPError as e:
-            request = e.request
-            raw_request = f"{request.method} - {request.url} - {request.body}"
-            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 Exception as e:
-            is_ok = False
-            raw_response = f"{str(e)} - {traceback.format_exc()}"
-            request = getattr(e, "request", "")
-            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)
-
-        is_check_and_update_batch_service = self.check_run(
-            is_ok=is_ok, formatted_data=formatted_data)
-        if not is_check_and_update_batch_service:
-            return []
-
-        return formatted_data
-
-    def check_run(self, is_ok, formatted_data):
-        if is_ok and not formatted_data and self.is_batch_request:
-            self.batch_service(self.integration.channel_id).to_done(
-                self.integration.batch_request)
-            return False
-        elif not is_ok and self.is_batch_request:
-            self.integration.batch_request.objects = None
-            self.batch_service(self.integration.channel_id).to_fail(
-                self.integration.batch_request)
-            return False
-        return True
-
-    def row_send_error_report(self):
-        name = self.__class__.__name__
-        for failed_obj in self.failed_object_list:
-            report = ErrorReportDto(
-                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}",
-                raw_request="",
-                raw_response=f"{failed_obj[0].failed_reason_type}-{failed_obj[2]}",
-                is_ok=False
-            )
-            self.integration.do_action(key='create_error_report',
-                                       objects=report)
-
-    def send_error_report(self, raw_request, raw_response):
-        if not self.is_batch_request:
-            return
-
-        name = self.__class__.__name__
-
-        report = ErrorReportDto(
-            action_content_type=ContentType.batch_request.value,
-            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}",
-            error_description=f"{self.integration.batch_request.local_batch_id}-{name}",
-            raw_request=raw_request,
-            raw_response=raw_response
-        )
-        self.integration.do_action(
-            key='create_error_report',
-            objects=report)
-
-    @property
-    def is_batch_request(self) -> bool:
-        is_object = getattr(
-            self.integration, 'batch_request', None)
-        return bool(is_object)
-
-    def create_log_file(self, message: str = None, raw_request: Request = None,
-                        raw_response: Response = None, **kwargs):
-        """
-        Log files are attached to batch requests. If you need to attach logs
-        to a problematic command or want to see detailed logs for standard a
-        command, you can use this method. However, if you do not use a batch request
-        for a command and still want to see the logs, You will need to manage the command
-        with a batch request.
-
-        :param message: Reason of the exception/entry logged
-        :param raw_request:
-        :param raw_response:
-        """
-        bytes_io = StringIO()
-        if raw_request and raw_response:
-            context = f"""
-            "message": {message},
-            "url": {raw_request.url},
-            "request_body": {raw_request.body},
-            "response_text": {raw_response.text},
-            "response_reason": {raw_response.reason},
-            "response_status_code": {raw_response.status_code}
-            """
-        else:
-            context = f"""
-                        "message": {message}
-                        """
-        bytes_io.write(context)
-        bytes_io.seek(0)
-        return bytes_io
-
-    @property
-    def update_state(self, *args, **kwargs) -> BatchRequestStatus:
-        return BatchRequestStatus.commit
-
-    def update_batch_request(self, objects_data: list):
-        """
-        Batch requests are used to track state of long-running processes across multiple
-        systems. State of those requests can be managed through this method.
-
-        :param content_type: String values of the ContentType enum model
-        :param remote_batch_id: Batch request id of the
-        :param objects_data:
-
-        """
-        self.integration.batch_request.objects = objects_data
-        service = self.batch_service(self.integration.channel_id)
-        state = getattr(service, f'to_{self.update_state.value}')(
-            self.integration.batch_request)
-        return state
-
-    def create_batch_objects(self, data: list, content_type: str) -> List[dict]:
-        """
-        In batch requests, you can attach Omnitron objects that are being processed in that batch
-        so that they are excluded from further calls until that batch is finalized with done or
-        fail statuses.
-
-        :param data: List of objects which are being processed for this batch request
-        :param content_type: String values of the ContentType enum model
-
-        """
-        objects = []
-        for item in data:
-            object = {
-                "pk": item.pk,
-                "failed_reason_type": getattr(item, "failed_reason_type", None),
-                "remote_id": getattr(item, "remote_id", None),
-                "version_date": item.modified_date,
-                "content_type": content_type
-            }
-            objects.append(object)
-        return objects

channel_app/channel_app/core/data.py

@@ -1,227 +0,0 @@
-import datetime
-from dataclasses import dataclass
-from decimal import Decimal
-from typing import List, Optional
-
-from channel_app.omnitron.constants import ResponseStatus, \
-    ChannelConfSchemaDataTypes
-
-
-@dataclass
-class CategoryNodeDto:
-    name: str
-    children: List['CategoryNodeDto']
-    remote_id: Optional[str] = ''
-    parent: Optional['CategoryNodeDto'] = None
-
-
-@dataclass
-class CategoryTreeDto:
-    root: CategoryNodeDto
-
-
-@dataclass
-class CategoryAttributeValueDto:
-    remote_id: str
-    name: str
-
-
-@dataclass
-class CategoryAttributeDto:
-    remote_id: str
-    name: str
-    required: bool
-    variant: bool
-    allow_custom_value: bool
-    values: List[CategoryAttributeValueDto]
-
-
-@dataclass
-class CategoryDto:
-    remote_id: str
-    name: str
-    attributes: List[CategoryAttributeDto]
-
-
-@dataclass
-class ChannelConfSchemaField:
-    required: bool
-    data_type: ChannelConfSchemaDataTypes
-    key: str
-    label: str
-    schema: Optional[dict] = None
-
-
-@dataclass
-class ErrorReportDto:
-    action_content_type: str
-    action_object_id: int
-    modified_date: str
-    raw_request: str = ""
-    raw_response: str = ""
-    error_code: str = "custom"
-    error_description: str = "custom"
-    is_ok: bool = False
-    target_content_type: Optional[str] = ''
-    target_object_id: Optional[str] = ''
-
-
-@dataclass
-class BatchRequestObjectsDto:
-    pk: int
-    version_date: str
-    content_type: str
-    failed_reason_type: Optional[str] = ''
-    remote_id: Optional[int] = 0
-
-
-class BatchRequestDto:
-    channel: int
-    local_batch_id: str
-    content_type: str
-    pk: Optional[int] = 0
-    remote_batch_id: Optional[str] = ''
-    status: Optional[str] = ''
-    objects: Optional[List[BatchRequestObjectsDto]] = []
-
-
-@dataclass
-class ProductBatchRequestResponseDto:
-    status: ResponseStatus
-    sku: str
-    remote_id: Optional[str] = ''
-    message: Optional[str] = ''
-
-
-@dataclass
-class BatchRequestResponseDto:
-    status: ResponseStatus
-    remote_id: Optional[str] = ''
-    sku: Optional[str] = ''
-    message: Optional[str] = ''
-
-
-@dataclass
-class OrderBatchRequestResponseDto:
-    status: ResponseStatus
-    remote_id: str
-    number: str
-    message: Optional[str] = ''
-
-
-@dataclass
-class OmnitronOrderDto:
-    remote_id: str
-    number: str
-    channel: int
-    customer: int
-    shipping_address: int
-    billing_address: int
-    currency: str
-    amount: Decimal
-    shipping_amount: Decimal
-    shipping_tax_rate: Decimal
-    extra_field: dict
-    cargo_company: int
-    created_at: datetime.datetime
-    delivery_type: Optional[str] = ""
-    discount_amount: Optional[Decimal] = "0.0"
-    net_shipping_amount: Optional[Decimal] = "0.0"
-    tracking_number: Optional[str] = None
-    carrier_shipping_code: Optional[str] = ""
-    remote_addr: Optional[str] = None
-    has_gift_box: Optional[bool] = False
-    gift_box_note: Optional[str] = ""
-    client_type: Optional[str] = ""
-    language_code: Optional[str] = ""
-    notes: Optional[str] = ""
-    delivery_range: Optional[str] = ""
-    shipping_option_slug: Optional[str] = ""
-    status: Optional[str] = ""
-
-
-@dataclass
-class OrderItemDto:
-    remote_id: str
-    product: str
-    price_currency: str
-    price: Decimal
-    tax_rate: Decimal
-    extra_field: dict
-    status: Optional[str] = None
-    price_list: Optional[int] = None
-    stock_list: Optional[int] = None
-    tracking_number: Optional[str] = None
-    carrier_shipping_code: Optional[str] = ""
-    discount_amount: Optional[Decimal] = 0.0
-    retail_price: Optional[Decimal] = 0.0
-    attributes: Optional[dict] = None
-    attributes_kwargs: Optional[dict] = None
-    parent: Optional[str] = None
-    delivered_date: Optional[str] = None
-    estimated_delivery_date: Optional[str] = None
-
-
-# dataclass used for omnitron.commands.orders.orders.CreateOrders
-@dataclass
-class OmnitronCreateOrderDto:
-    order: OmnitronOrderDto
-    order_item: List[OrderItemDto]
-
-
-@dataclass
-class CancelOrderDto:
-    order: str  # remote order number
-    cancel_items: List[str]  # order_item_remote_id list
-    reasons: dict  # order_item_remote_id : reason code
-    is_cargo_refund: Optional[bool] = False  # default False
-    refund_invoice_number: Optional[str] = None
-
-
-@dataclass
-class CustomerDto:
-    email: str  # "john.doe@akinon.com"
-    first_name: str  # "John"
-    last_name: str  # "Doe"
-    channel_code: str  # will be unique
-    extra_field: Optional[dict] = None
-    phone_number: Optional[str] = None  # "05556667788"
-    is_active: Optional[bool] = True
-
-
-@dataclass
-class AddressDto:
-    email: str  # "john.doe@akinon.com"
-    phone_number: str  # "05556667788"
-    first_name: str  # "John"
-    last_name: str  # "Doe"
-    country: str  # 1
-    city: str  # 80
-    line: str  # "Hemen sahil kenarı"
-    title: Optional[str] = None  # "COMM-876"
-    township: Optional[str] = None  # 933
-    district: Optional[str] = None  # 71387
-    postcode: Optional[str] = None  # ""
-    notes: Optional[str] = None  # null
-    company_name: Optional[str] = None  # ""
-    tax_office: Optional[str] = None  # ""
-    tax_no: Optional[str] = None  # ""
-    e_bill_taxpayer: Optional[bool] = False
-    remote_id: Optional[str] = None  # null
-    identity_number: Optional[str] = None  # null
-    extra_field: Optional[dict] = None  # {}
-    is_active: Optional[bool] = True  # true
-
-
-@dataclass
-class ChannelOrderDto(OmnitronOrderDto):
-    customer = CustomerDto
-    shipping_address = AddressDto
-    billing_address = AddressDto
-    cargo_company = str
-
-
-@dataclass
-class ChannelCreateOrderDto:
-    order: ChannelOrderDto
-    order_item: List[OrderItemDto]