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

channel_app/channel_app/omnitron/commands/error_reports.py

@@ -1,86 +0,0 @@
-from omnisdk.omnitron.endpoints import ChannelErrorReportEndpoint, \
-    ContentTypeEndpoint
-from omnisdk.omnitron.models import ErrorReport
-
-from channel_app.core.commands import OmnitronCommandInterface
-from channel_app.core.data import ErrorReportDto
-from channel_app.omnitron.constants import CONTENT_TYPE_IDS
-
-
-class CreateAddressErrorReports(OmnitronCommandInterface):
-    endpoint = ChannelErrorReportEndpoint
-
-    def get_data(self) -> list:
-        data = self.objects
-        return data
-
-    def send(self, validated_data) -> object:
-        endpoint = self.endpoint(
-            channel_id=self.integration.channel_id,
-            raw=True,
-            path=validated_data["type"])
-        obj = endpoint.create(item=validated_data)
-        return obj
-
-    def row_send_error_report(self):
-        pass
-
-    def send_error_report(self, raw_request, raw_response):
-        pass
-
-    def check_run(self, is_ok, formatted_data):
-        return False
-
-class CreateErrorReports(OmnitronCommandInterface):
-    endpoint = ChannelErrorReportEndpoint
-
-    def get_data(self) -> object:
-        return self.objects
-
-    def validated_data(self, data):
-        assert isinstance(data, ErrorReportDto)
-        return data
-
-    def send(self, validated_data: ErrorReportDto) -> object:
-        error_report = ErrorReport(
-            action_content_type=self.get_content_type(
-                validated_data.action_content_type),
-            action_object_id=validated_data.action_object_id,
-            target_content_type=self.get_content_type(
-                validated_data.target_content_type or "channel"),
-            target_object_id=validated_data.target_object_id or self.integration.channel_id,
-            obj_modified_date=validated_data.modified_date,
-            error_code=validated_data.error_code or "custom",
-            error_desc=validated_data.error_description or "custom",
-            raw_request=validated_data.raw_request,
-            raw_response=validated_data.raw_response,
-            is_ok=validated_data.is_ok
-        )
-        report = self.endpoint(
-            channel_id=self.integration.channel_id).create(item=error_report)
-        return [report]
-
-    def get_content_type(self, content_type: str):
-        try:
-            return CONTENT_TYPE_IDS[content_type]
-        except KeyError:
-            pass
-        content_type = ContentTypeEndpoint().list(
-            params={"model": content_type})
-        if not content_type:
-            raise Exception("Invalid Content Type")
-        if len(content_type) > 1:
-            raise Exception("Invalid Content Type")
-
-        content_type_id = content_type[0].id
-        CONTENT_TYPE_IDS[content_type[0].model] = content_type_id
-        return content_type_id
-
-    def row_send_error_report(self):
-        pass
-
-    def send_error_report(self, raw_request, raw_response):
-        pass
-
-    def check_run(self, is_ok, formatted_data):
-        return False

channel_app/channel_app/omnitron/commands/integration_actions.py

@@ -1,200 +0,0 @@
-from collections import defaultdict
-from typing import List
-
-from omnisdk.omnitron.endpoints import ChannelIntegrationActionEndpoint, \
-    ChannelProductEndpoint, ChannelProductPriceEndpoint, \
-    ChannelProductStockEndpoint
-from omnisdk.omnitron.models import IntegrationAction
-
-from channel_app.core.commands import OmnitronCommandInterface
-from channel_app.core.utilities import split_list
-
-
-class CreateIntegrationActions(OmnitronCommandInterface):
-    endpoint = ChannelIntegrationActionEndpoint
-
-    def get_data(self) -> list:
-        obj_list = self.objects
-        items = []
-        for obj in obj_list:
-            data = {
-                "content_type": obj.content_type,
-                "channel_id": self.integration.channel_id,
-                "object_id": obj.pk,
-                "remote_id": obj.remote_id,
-                "version_date": obj.modified_date,
-                "state": {}
-            }
-            items.append(data)
-        return items
-
-    def send(self, validated_data) -> object:
-        integration_actions = []
-        for item in validated_data:
-            integration_action = self.endpoint(
-                channel_id=self.integration.channel_id).create(item=item)
-
-            integration_actions.append(integration_action)
-        return integration_actions
-
-
-class UpdateIntegrationActions(CreateIntegrationActions):
-    endpoint = ChannelIntegrationActionEndpoint
-
-    def get_data(self) -> list:
-        return self.objects
-
-    def send(self, validated_data) -> object:
-        integration_actions = []
-        for item in validated_data:
-            item.content_type_id = item.content_type['id']
-            delattr(item, "content_type")
-
-            integration_action = self.endpoint(
-                channel_id=self.integration.channel_id
-            ).update(id=item.pk, item=item)
-
-            integration_actions.append(integration_action)
-        return integration_actions
-
-
-class GetIntegrationActionsWithObjectId(OmnitronCommandInterface):
-    endpoint = ChannelIntegrationActionEndpoint
-    id_type = "object_id__in"
-    CHUNK_SIZE = 50
-
-    def get_ia_dict(self, integration_action):
-        return {i.object_id: i for i in integration_action}
-
-    def get_data(self) -> List:
-        integration_action_list = []
-        group_by_content_type = self.get_grup_by_content_type_pk_list()
-
-        for ct, pk_list in group_by_content_type.items():
-            for chunk_pk_list in split_list(pk_list, self.CHUNK_SIZE):
-                chunk_ia = self.endpoint(
-                    channel_id=self.integration.channel_id
-                ).list(params={
-                    "channel_id": self.integration.channel_id,
-                    "content_type_name": ct,
-                    self.id_type: ",".join([str(pk) for pk in chunk_pk_list])
-                })
-                integration_action_list.extend(chunk_ia)
-
-        ia_dict = self.get_ia_dict(integration_action_list)
-        self.update_objects(ia_dict)
-        return self.objects
-
-    def update_objects(self, ia_dict):
-        for obj in self.objects:
-            obj.integration_action = ia_dict[obj.pk]
-
-    def get_grup_by_content_type_pk_list(self):
-        group_by_content_type = defaultdict(list)
-        for obj in self.objects:
-            group_by_content_type[obj.content_type].append(obj.pk)
-        return group_by_content_type
-
-
-class GetIntegrationActionsWithRemoteId(GetIntegrationActionsWithObjectId):
-    endpoint = ChannelIntegrationActionEndpoint
-    id_type = "remote_id__in"
-
-    def get_grup_by_content_type_pk_list(self):
-        group_by_content_type = defaultdict(list)
-        for obj in self.objects:
-            group_by_content_type[obj.content_type].append(obj.remote_id)
-        return group_by_content_type
-
-    def get_ia_dict(self, ia):
-        return {i.remote_id: i for i in ia}
-
-    def update_objects(self, ia_dict):
-        for obj in self.objects:
-            obj.integration_action = ia_dict[obj.remote_id]
-
-
-class GetIntegrationActions(OmnitronCommandInterface):
-    endpoint = ChannelIntegrationActionEndpoint
-    CHUNK_SIZE = 10
-
-    def get_data(self) -> dict:
-        if "limit" not in self.objects:
-            self.objects.update({"limit": self.CHUNK_SIZE})
-        return self.objects
-
-    def run(self) -> List[IntegrationAction]:
-        integration_action_endpoint = ChannelIntegrationActionEndpoint(
-            channel_id=self.integration.channel_id)
-        self.objects.update({
-            "channel_id": self.integration.channel_id,
-        })
-        integration_action_list = integration_action_endpoint.list(
-            params=self.objects)
-        for batch in integration_action_endpoint.iterator:
-            if not batch:
-                break
-            integration_action_list.extend(batch)
-        return integration_action_list
-
-
-class GetObjectsFromIntegrationAction(OmnitronCommandInterface):
-    endpoint = {
-        "product": ChannelProductEndpoint,
-        "productprice": ChannelProductPriceEndpoint,
-        "productstock": ChannelProductStockEndpoint
-    }
-    CHUNK_SIZE = 100
-
-    def get_data(self) -> List[IntegrationAction]:
-        """
-
-        :return: Added content type object in integration action objects
-            Example: if content type product, -> integration_action.product
-                     if content type productprice, -> integration_action.productprice
-        """
-        integration_actions = self.objects
-        group = self.group_by_content_type(integration_actions)
-        grouped_integration_actions = self.get_content_objects(group)
-        return self.extract_group(grouped_integration_actions)
-
-    def group_by_content_type(self, integration_actions):
-        """
-
-        :param integration_actions:
-        :return:
-        {
-        "product":[integration1,integration2,...],
-        "productprice":[integration3,integration4,...]
-        }
-        """
-        group = defaultdict(list)
-        for integration_action in integration_actions:
-            model = integration_action.content_type.get("model")
-            group[model].append(integration_action)
-        return group
-
-    def get_content_objects(self, grouped_integration_actions: dict):
-        for content_type, integration_actions in grouped_integration_actions.items():
-            endpoint = self.endpoint.get(content_type)
-            if endpoint:
-                id_list = [str(ia.object_id) for ia in integration_actions]
-                end_point = endpoint(channel_id=self.integration.channel_id)
-                objects_list = []
-                for chunk_id_list in split_list(id_list, self.CHUNK_SIZE):
-                    objects = end_point.list(
-                        params={"pk__in": ",".join(chunk_id_list),
-                                "limit": len(chunk_id_list)})
-                    objects_list.extend(objects)
-                objects_dict = {s.pk: s for s in objects_list}
-                for integration_action in integration_actions:
-                    setattr(integration_action, content_type,
-                            objects_dict.get(integration_action.object_id))
-
-        return grouped_integration_actions
-
-    def extract_group(self, group: dict):
-        object_list = []
-        for key, value_list in group.items():
-            object_list.extend(value_list)
-        return object_list

channel_app/channel_app/omnitron/commands/orders/addresses.py

@@ -1,242 +0,0 @@
-from omnisdk.omnitron.endpoints import (ChannelAddressEndpoint,
-                                        ChannelCountryEndpoint,
-                                        ChannelCityEndpoint,
-                                        ChannelTownshipEndpoint,
-                                        ChannelDistrictEndpoint)
-from omnisdk.omnitron.models import (City, Country, Township, District, Address,
-                                     Customer)
-from requests import HTTPError
-
-from channel_app.core.commands import OmnitronCommandInterface
-from channel_app.core.data import AddressDto
-from channel_app.omnitron.constants import INTEGRATION_TYPE, ErrorType
-from channel_app.omnitron.exceptions import (CountryException,
-                                             IntegrationMappingException,
-                                             CityException, TownshipException,
-                                             DistrictException)
-
-
-class GetOrCreateAddress(OmnitronCommandInterface):
-    endpoint = ChannelAddressEndpoint
-
-    def get_data(self) -> dict:
-        """
-        :return:
-        {
-            "email": "john.doe@akinon.com",
-            "phone_number": "05556667788",
-            "first_name": "John",
-            "last_name": "Doe",
-            "country": 1,
-            "city": 80,
-            "line": "Hemen sahil kenarı",
-            "title": "COMM-876",
-            "township": 933,
-            "district": 71387,
-            "postcode": "",
-            "notes": null,
-            "company_name": "",
-            "tax_office": "",
-            "tax_no": "",
-            "e_bill_taxpayer": false,
-            "hash_data": "b5e07b50cb033f5e4c86de7f1093bb37",
-            "address_type": "customer",
-            "retail_store": null,
-            "remote_id": null,
-            "identity_number": null,
-            "extra_field": {},
-            "customer": 36406,
-            "is_active": true
-        },
-        """
-        address: AddressDto = self.objects["address"]
-        customer: Customer = self.objects["customer"]
-        country_pk, city_pk, township_pk, district_pk = \
-            self.get_location_objects(address.country,
-                                      address.city,
-                                      address.township,
-                                      address.district)
-        data = {
-            "email": address.email[:254],
-            "phone_number": address.phone_number[:128],
-            "first_name": customer.first_name[:255],
-            "last_name": customer.last_name[:255],
-            "customer": customer.pk,
-            "country": country_pk,
-            "city": city_pk,
-            "township": township_pk,
-            "district": district_pk,
-            "title": address.title and address.title[:128],
-            "line": address.line[:255],
-            "postcode": 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],
-            "tax_no": address.tax_no and address.tax_no[:20],
-            "e_bill_taxpayer": address.e_bill_taxpayer or False,
-            "remote_id": address.remote_id,
-            "identity_number": address.identity_number and address.identity_number[:64],
-            "extra_field": address.extra_field or {}
-        }
-        return data
-
-    def send(self, validated_data) -> object:
-        """
-
-        :param validated_data: data for address
-        :return: address objects
-        """
-        try:
-            address_obj = Address(**validated_data)
-            address = self.endpoint(
-                channel_id=self.integration.channel_id).create(
-                item=address_obj)
-        except HTTPError as e:
-            addresses = []
-            if ("hash_data" in e.response.text and
-                    "non_field_errors" in e.response.text):
-                try:
-                    error_data = e.response.json()['non_field_errors'].split()[0].split(':')
-                    if error_data[0] == "hash_data":
-                        hash_data = error_data[1]
-                        addresses = self.endpoint(
-                            channel_id=self.integration.channel_id).list(
-                            params={"hash_data": hash_data})
-                except Exception:
-                    pass
-            if len(addresses) != 1:
-                raise
-            address = addresses[0]
-        return [address]
-
-    def get_location_objects(self, country_code, city_name, township_name=None,
-                             district_name=None):
-        """
-        :param country_code: country code ("Tr")
-        :param city_name: city name ("Istanbul")
-        :param township_name: town ship ("Kadikoy")
-        :param district_name: district name ("Moda")
-        :return: country_pk, city_pk, township_pk, district_pk
-        """
-        country = self.get_country(country_code=country_code)
-        country_pk = country.pk
-
-        city = self.get_city(country=country, city_name=city_name)
-        city_pk = city.pk
-        township = None
-        township_pk = None
-        if township_name:
-            township = self.get_township(country=country, city=city,
-                                         township_name=township_name)
-            township_pk = township.pk
-        district_pk = None
-        if district_name and township:
-            district = self.get_district(country=country, city=city,
-                                         township=township,
-                                         district_name=district_name)
-            district_pk = district.pk
-        return country_pk, city_pk, township_pk, district_pk
-
-    def get_mapping_object(self, code, endpoint):
-        """
-        :param code: Identifier code for the City and Country on the Sales Channel. This is
-            prefix with channel_id as integration_code
-        :param endpoint: omnitron sdk endpoint
-        :return: mapped objects E.g (City, Country)
-        """
-        integration_code = f"{self.integration.channel_id}_{code}"
-        params = {"mapping__code__exact": integration_code,
-                  "mapping__integration_type": INTEGRATION_TYPE}
-        objects = endpoint.list(params=params)
-        if len(objects) != 1:
-            raise IntegrationMappingException(params={"code": integration_code})
-        return objects
-
-    def get_country(self, country_code: str) -> Country:
-        endpoint = ChannelCountryEndpoint(channel_id=self.integration.channel_id)
-
-        params = {"code__exact": country_code}
-        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:
-            raise CountryException(params={
-                "type": ErrorType.country.value,
-                "remote_code": exc.params['code'],
-                "country_code": country_code,
-                "name": country_code,
-                "integration_type": INTEGRATION_TYPE,
-                "err_code": "Country was not found",
-                "err_desc": f"Country code {country_code} was not found in Omnitron"})
-        return countries[0]
-
-    def get_city(self, country: Country, city_name: str) -> City:
-        endpoint = ChannelCityEndpoint(channel_id=self.integration.channel_id)
-
-        params = {"name__exact": city_name, "country": country.pk}
-        cities = endpoint.list(params=params)
-        if len(cities) == 1:
-            return cities[0]
-        try:
-            cities = self.get_mapping_object(code=city_name, endpoint=endpoint)
-        except IntegrationMappingException as exc:
-            raise CityException(
-                params={"type": ErrorType.city.value,
-                        "remote_code": exc.params['code'],
-                        "country_id": country.pk,
-                        "integration_type": INTEGRATION_TYPE,
-                        "err_code": "integrations_200_10_2",
-                        "err_desc": f"Address is not valid. channel: {self.integration.channel_id} "
-                                    f"code:{exc.params['code']} "
-                                    f"model: City country id: {country.pk}"})
-        return cities[0]
-
-    def get_township(self, country: Country, city: City, township_name: str) -> Township:
-        endpoint = ChannelTownshipEndpoint(channel_id=self.integration.channel_id)
-
-        params = {"name__exact": township_name, "country": country.pk, "city": city.pk}
-        townships = endpoint.list(params=params)
-        if len(townships) == 1:
-            return townships[0]
-        try:
-            townships = self.get_mapping_object(township_name, endpoint)
-        except IntegrationMappingException as exc:
-            raise TownshipException(
-                params={"type": ErrorType.township.value,
-                        "remote_code": exc.params['code'],
-                        "city_id": city.pk,
-                        "name": township_name,
-                        "integration_type": INTEGRATION_TYPE,
-                        "err_code": "integrations_200_10_1",
-                        "err_desc": f"Address is not valid. channel: {self.integration.channel_id}"
-                                    f"code: {exc.params['code']} "
-                                    f"model: Township city id: {city.pk}"})
-        return townships[0]
-
-    def get_district(self, country: Country, city: City, township: Township,
-                     district_name: str) -> District:
-        endpoint = ChannelDistrictEndpoint(channel_id=self.integration.channel_id)
-
-        params = {"name__exact": district_name, "country": country.pk, "city": city.pk,
-                  "township": township.pk}
-        districts = endpoint.list(params=params)
-        if len(districts) == 1:
-            return districts[0]
-        try:
-            districts = self.get_mapping_object(district_name, endpoint)
-        except IntegrationMappingException as exc:
-            raise DistrictException(
-                params={"type": ErrorType.district.value,
-                        "remote_code": exc.params['code'],
-                        "city_id": city.pk,
-                        "township_id": township.pk,
-                        "name": district_name,
-                        "integration_type": INTEGRATION_TYPE,
-                        "err_code": "integrations_200_10_3",
-                        "err_desc": f"Address is not valid. channel: {self.integration.channel_id}"
-                                    f"code: {exc.params['code']} "
-                                    f"model: District township id: {township.pk}"}
-            )
-        return districts[0]

channel_app/channel_app/omnitron/commands/orders/cargo_companies.py

@@ -1,40 +0,0 @@
-from typing import List
-
-from omnisdk.omnitron.endpoints import ChannelCargoEndpoint
-from omnisdk.omnitron.models import CargoCompany
-
-from channel_app.core.commands import OmnitronCommandInterface
-
-
-class GetCargoCompany(OmnitronCommandInterface):
-    endpoint = ChannelCargoEndpoint
-
-    def get_cargo_company(self, data):
-        cargo_company_code = self.objects
-        for cargo_company in data:
-            if cargo_company.erp_code == cargo_company_code:
-                return cargo_company
-        raise Exception("CargoCompany does not exists: {}".format(
-            cargo_company_code))
-
-    def get_data(self) -> List[CargoCompany]:
-        """
-        :return: [
-            {
-                "pk": 1,
-                "name": "Yurtici Kargo",
-                "erp_code": "yurtici-kargo",
-                "shipping_company": "yurtici"
-            },
-        ]
-        """
-        params = getattr(self, "param_{}".format("params"), {})
-
-        end_point = self.endpoint(channel_id=self.integration.channel_id)
-        cargo_companies = end_point.list(
-            params=params)
-        for next_cargo_companies in end_point.iterator:
-            cargo_companies.extend(next_cargo_companies)
-
-        cargo_company = self.get_cargo_company(data=cargo_companies)
-        return [cargo_company]

channel_app/channel_app/omnitron/commands/orders/customers.py

@@ -1,72 +0,0 @@
-from dataclasses import asdict
-from omnisdk.omnitron.endpoints import ChannelCustomerEndpoint
-from omnisdk.omnitron.models import Customer
-
-from channel_app.core.commands import OmnitronCommandInterface
-from channel_app.core.data import CustomerDto
-from channel_app.omnitron.constants import CustomerIdentifierField
-
-
-class GetOrCreateCustomer(OmnitronCommandInterface):
-    endpoint = ChannelCustomerEndpoint
-
-    def get_data(self) -> Customer:
-        data = self.objects
-        data: CustomerDto
-        return self.get_customer(data)
-
-    def get_customer(self, data: CustomerDto) -> Customer:
-        customer_identifier_field = self.integration.channel.conf.get(
-            "CUSTOMER_IDENTIFIER_FIELD", CustomerIdentifierField.email)
-        customers = None
-        if customer_identifier_field == CustomerIdentifierField.email:
-            customers = self.endpoint(channel_id=self.integration.channel_id).list(params={
-                "email": data.email,
-            })
-            for c in customers:
-                if c.email != data.email:
-                    raise Exception("Customer email filter incorrect")
-        elif customer_identifier_field == CustomerIdentifierField.phone_number:
-            # TODO phone_number filter does not exist on customerfilter
-            customers = self.endpoint(channel_id=self.integration.channel_id).list(params={
-                "phone_number": data.phone_number,
-            })
-            for c in customers:
-                if c.phone_number != data.phone_number:
-                    raise Exception("Customer phone_number filter incorrect")
-
-        if customers:
-            customer = customers[0]
-            must_update = False
-            new_customer = Customer()
-            new_customer.channel = customer.channel
-            new_customer.channel_code = customer.channel_code
-            if "email" in asdict(data) and data.email != customer.email:
-                must_update = True
-                new_customer.email = data.email
-            if "phone_number" in asdict(data) and data.phone_number != customer.phone_number:
-                must_update = True
-                new_customer.phone_number = data.phone_number
-            if "first_name" in asdict(data) and data.first_name != customer.first_name:
-                must_update = True
-                new_customer.first_name = data.first_name
-            if "last_name" in asdict(data) and data.last_name != customer.last_name:
-                must_update = True
-                new_customer.first_name = data.last_name
-            if must_update:
-                customer = self.endpoint(channel_id=self.integration.channel_id).update(
-                    id=customer.pk, item=customer)
-        else:
-            new_customer = Customer()
-            new_customer.channel = self.integration.channel_id
-            new_customer.email = data.email
-            new_customer.phone_number = data.phone_number
-            new_customer.first_name = data.first_name
-            new_customer.last_name = data.last_name
-            new_customer.extra_field = data.extra_field or {}
-            new_customer.channel_code = data.channel_code
-            new_customer.is_active = data.is_active or True
-            new_customer = self.endpoint(channel_id=self.integration.channel_id).create(
-                item=new_customer)
-            customer = new_customer
-        return [customer]