Merge pull request #79 from PurplShip/purplship-2020.9.0

[release] Purplship SDK 2020.9.0

Author: danh91

README.md

@@ -33,6 +33,16 @@
 {% endfor %}
 ''')
 
+PACKAGING_TYPES_TEMPLATE = Template('''
+{% for key, value in option_mappers.items() %}
+- <a name="options-{{ key }}"></a> {{ mappers[key]["label"] }}
+    Code | Identifier
+    --- | ---
+{% for code, name in value.items() %}    | `{{ code }}` | {{ name }}
+{% endfor %}
+{% endfor %}
+''')
+
 SHIPMENT_PRESETS_TEMPLATE = Template('''
 {% for key, value in preset_mappers.items() %}
 - <a name="presets-{{ key }}"></a> {{ mappers[key]["label"] }}
@@ -54,40 +64,49 @@ def import_pkg(pkg: str):
 
 
 PACKAGE_MAPPERS = {
+    'purplship': {
+        'label': "Multi-carrier (Purplship)",
+        'package': import_pkg('purplship.core.units'),
+        'packagingTypes': "PackagingUnit"
+    },
     'canadapost': {
         'label': "Canada Post",
         'package': import_pkg('purplship.providers.canadapost.units'),
         'services': "ServiceType",
         'options': "OptionCode",
         'packagePresets': "PackagePresets"
     },
-    'dhl': {
-        'label': "DHL",
-        'package': import_pkg('purplship.providers.dhl.units'),
+    'dhl_express': {
+        'label': "DHL Express",
+        'package': import_pkg('purplship.providers.dhl_express.units'),
         'services': "Product",
         'options': "SpecialServiceCode",
-        'packagePresets': "PackagePresets"
+        'packagePresets': "PackagePresets",
+        'packagingTypes': "DCTPackageType"
     },
     'fedex': {
         'label': "FedEx",
         'package': import_pkg('purplship.providers.fedex.units'),
         'services': "ServiceType",
         'options': "SpecialServiceType",
-        'packagePresets': "PackagePresets"
+        'packagePresets': "PackagePresets",
+        'packagingTypes': "PackagingType"
     },
     'purolator': {
         'label': "Purolator",
         'package': import_pkg('purplship.providers.purolator.units'),
         'services': "Product",
         'options': "Service",
-        'packagePresets': "PackagePresets"
+        'packagePresets': "PackagePresets",
+        'packagingTypes': "PackagingType"
     },
     'ups': {
         'label': "UPS",
         'package': import_pkg('purplship.providers.ups.units'),
         'services': "ShippingServiceCode",
         'options': "ServiceOption",
-        'packagePresets': "PackagePresets"
+        'packagePresets': "PackagePresets",
+        'packagingTypes': "RatingPackagingType"
     }
 }
 
@@ -127,6 +146,16 @@ def generate_services():
     click.echo(SERVICES_TEMPLATE.render(service_mappers=service_mappers, mappers=PACKAGE_MAPPERS))
 
 
+@cli.command()
+def generate_packaging_types():
+    service_mappers = {
+        key: {c.name: c.value for c in list(getattr(mapper['package'], mapper['packagingTypes']))}
+        for key, mapper in PACKAGE_MAPPERS.items()
+        if mapper.get('packagingTypes') is not None
+    }
+    click.echo(SERVICES_TEMPLATE.render(service_mappers=service_mappers, mappers=PACKAGE_MAPPERS))
+
+
 @cli.command()
 def generate_models():
     import purplship.core.models as m
@@ -157,4 +186,4 @@ def generate_models():
 
 
 if __name__ == '__main__':
-    cli()
+    cli()

cli.py

@@ -0,0 +1,3 @@
+from purplship.mappers.canadapost.mapper import Mapper
+from purplship.mappers.canadapost.proxy import Proxy
+from purplship.mappers.canadapost.settings import Settings

extensions/canadapost/purplship/mappers/canadapost/__init__.py

@@ -1,82 +1,88 @@
 from typing import List, Tuple
-from pydhl.dct_req_global_2_0 import DCTRequest
-from pydhl.ship_val_global_req_6_2 import ShipmentRequest as DHLShipmentRequest
-from pydhl.tracking_request_known_1_0 import KnownTrackingRequest
-from pydhl.book_pickup_global_req_3_0 import BookPURequest
-from pydhl.modify_pickup_global_req_3_0 import ModifyPURequest
-from pydhl.cancel_pickup_global_req_3_0 import CancelPURequest
-from purplship.freight.mapper import Mapper as BaseMapper
+from pycanadapost.rating import mailing_scenario
+from pycanadapost.pickuprequest import (
+    PickupRequestDetailsType,
+    PickupRequestResponseDetailsType,
+)
+from purplship.core.utils.pipeline import Pipeline
 from purplship.core.utils.serializable import Serializable, Deserializable
+from purplship.api.mapper import Mapper as BaseMapper
 from purplship.core.models import (
-    RateRequest,
-    RateDetails,
+    ShipmentRequest,
     TrackingRequest,
+    Message,
     TrackingDetails,
-    ShipmentRequest,
+    RateDetails,
+    RateRequest,
     ShipmentDetails,
     PickupRequest,
     PickupDetails,
     PickupUpdateRequest,
     PickupCancellationRequest,
-    Message,
+    ConfirmationDetails,
 )
-from purplship.providers.dhl import (
-    dct_request,
-    parse_dct_response,
-    known_tracking_request,
-    parse_known_tracking_response,
+from purplship.providers.canadapost import (
+    mailing_scenario_request,
+    parse_price_quotes,
+    tracking_pins_request,
+    parse_tracking_summary,
     shipment_request,
     parse_shipment_response,
-    book_pickup_request,
-    parse_book_pickup_response,
     cancel_pickup_request,
+    create_pickup_request,
+    update_pickup_request,
+    parse_pickup_response,
     parse_cancel_pickup_response,
-    modify_pickup_request,
-    parse_modify_pickup_response,
 )
-from purplship.freight.mappers.dhl.settings import Settings
+from purplship.mappers.canadapost.settings import Settings
 
 
 class Mapper(BaseMapper):
     settings: Settings
 
-    def create_rate_request(self, payload: RateRequest) -> Serializable[DCTRequest]:
-        return dct_request(payload, self.settings)
+    """Request Mappers"""
+
+    def create_rate_request(
+        self, payload: RateRequest
+    ) -> Serializable[mailing_scenario]:
+        return mailing_scenario_request(payload, self.settings)
 
     def create_tracking_request(
         self, payload: TrackingRequest
-    ) -> Serializable[KnownTrackingRequest]:
-        return known_tracking_request(payload, self.settings)
+    ) -> Serializable[List[str]]:
+        return tracking_pins_request(payload)
 
     def create_shipment_request(
         self, payload: ShipmentRequest
-    ) -> Serializable[DHLShipmentRequest]:
+    ) -> Serializable[Pipeline]:
         return shipment_request(payload, self.settings)
 
     def create_pickup_request(
         self, payload: PickupRequest
-    ) -> Serializable[BookPURequest]:
-        return book_pickup_request(payload, self.settings)
+    ) -> Serializable[PickupRequestDetailsType]:
+        return create_pickup_request(payload, self.settings)
 
     def create_modify_pickup_request(
         self, payload: PickupUpdateRequest
-    ) -> Serializable[ModifyPURequest]:
-        return modify_pickup_request(payload, self.settings)
+    ) -> Serializable[PickupRequestResponseDetailsType]:
+        return update_pickup_request(payload, self.settings)
 
     def create_cancel_pickup_request(
         self, payload: PickupCancellationRequest
-    ) -> Serializable[CancelPURequest]:
+    ) -> Serializable[str]:
         return cancel_pickup_request(payload, self.settings)
 
+    """Response Parsers"""
+
     def parse_rate_response(
         self, response: Deserializable[str]
     ) -> Tuple[List[RateDetails], List[Message]]:
-        return parse_dct_response(response.deserialize(), self.settings)
+        return parse_price_quotes(response.deserialize(), self.settings)
 
     def parse_tracking_response(
         self, response: Deserializable[str]
     ) -> Tuple[List[TrackingDetails], List[Message]]:
-        return parse_known_tracking_response(response.deserialize(), self.settings)
+        return parse_tracking_summary(response.deserialize(), self.settings)
 
     def parse_shipment_response(
         self, response: Deserializable[str]
@@ -86,14 +92,14 @@ def parse_shipment_response(
     def parse_pickup_response(
         self, response: Deserializable[str]
     ) -> Tuple[PickupDetails, List[Message]]:
-        return parse_book_pickup_response(response.deserialize(), self.settings)
+        return parse_pickup_response(response.deserialize(), self.settings)
 
     def parse_modify_pickup_response(
         self, response: Deserializable[str]
     ) -> Tuple[PickupDetails, List[Message]]:
-        return parse_modify_pickup_response(response.deserialize(), self.settings)
+        return parse_pickup_response(response.deserialize(), self.settings)
 
     def parse_cancel_pickup_response(
         self, response: Deserializable[str]
-    ) -> Tuple[dict, List[Message]]:
+    ) -> Tuple[ConfirmationDetails, List[Message]]:
         return parse_cancel_pickup_response(response.deserialize(), self.settings)

…/purplship/freight/mappers/dhl/mapper.py …t/purplship/mappers/canadapost/mapper.pyextensions/dhl/purplship/freight/mappers/dhl/mapper.py renamed to extensions/canadapost/purplship/mappers/canadapost/mapper.py extensions/dhl/purplship/freight/mappers/dhl/mapper.py renamed to extensions/canadapost/purplship/mappers/canadapost/mapper.py

@@ -9,8 +9,8 @@
     exec_parrallel,
     bundle_xml,
 )
-from purplship.package.mappers.canadapost.settings import Settings
-from purplship.package.proxy import Proxy as BaseProxy
+from purplship.mappers.canadapost.settings import Settings
+from purplship.api.proxy import Proxy as BaseProxy
 from pycanadapost.rating import mailing_scenario
 
 
@@ -88,16 +88,16 @@ def _get_label(job: Job):
                 },
                 method="GET",
             )
-            return f'<label>{label_string}</label>'
+            return f"<label>{label_string}</label>"
 
         def process(job: Job):
             if job.data is None:
                 return job.fallback
 
             subprocess = {
-                'contract_shipment': _contract_shipment,
-                'non_contract_shipment': _non_contract_shipment,
-                'shipment_label': _get_label
+                "contract_shipment": _contract_shipment,
+                "non_contract_shipment": _non_contract_shipment,
+                "shipment_label": _get_label,
             }
             if job.id not in subprocess:
                 raise PurplShipError(f"Unknown shipment request job id: {job.id}")
@@ -108,3 +108,73 @@ def process(job: Job):
         response = pipeline.apply(process)
 
         return Deserializable(bundle_xml(response), to_xml)
+
+    def request_pickup(self, request: Serializable[Pipeline]) -> Deserializable[str]:
+        def _availability(job: Job) -> str:
+            return http(
+                url=f"{self.settings.server_url}/ad/pickup/pickupavailability/{job.data}",
+                headers={
+                    "Accept": "application/vnd.cpc.pickup+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": "en-CA",
+                },
+                method="GET",
+            )
+
+        def _create_pickup(job: Job) -> str:
+            return http(
+                url=f"{self.settings.server_url}/enab/{self.settings.customer_number}/pickuprequest",
+                data=bytearray(job.data.serialize(), "utf-8"),
+                headers={
+                    "Accept": "application/vnd.cpc.pickuprequest+xml",
+                    "Content-Type": "application/vnd.cpc.pickuprequest+xml",
+                    "Authorization": f"Basic {self.settings.authorization}",
+                    "Accept-language": "en-CA",
+                },
+                method="POST",
+            )
+
+        def process(job: Job):
+            if job.data is None:
+                return job.fallback
+
+            subprocess = {
+                "create_pickup": _create_pickup,
+                "availability": _availability,
+            }
+            if job.id not in subprocess:
+                raise PurplShipError(f"Unknown pickup request job id: {job.id}")
+
+            return subprocess[job.id](job)
+
+        pipeline: Pipeline = request.serialize()
+        response = pipeline.apply(process)
+
+        return Deserializable(bundle_xml(response), to_xml)
+
+    def modify_pickup(self, request: Serializable[dict]) -> Deserializable[str]:
+        payload = request.serialize()
+        response = http(
+            url=f"{self.settings.server_url}/enab/{self.settings.customer_number}/pickuprequest/{payload['pickuprequest']}",
+            data=bytearray(payload["data"], "utf-8"),
+            headers={
+                "Accept": "application/vnd.cpc.pickuprequest+xml",
+                "Authorization": f"Basic {self.settings.authorization}",
+                "Accept-language": "en-CA",
+            },
+            method="PUT",
+        )
+        return Deserializable(response, to_xml)
+
+    def cancel_pickup(self, request: Serializable[str]) -> Deserializable[str]:
+        pickuprequest = request.serialize()
+        response = http(
+            url=f"{self.settings.server_url}/enab/{self.settings.customer_number}/pickuprequest/{pickuprequest}",
+            headers={
+                "Accept": "application/vnd.cpc.pickuprequest+xml",
+                "Authorization": f"Basic {self.settings.authorization}",
+                "Accept-language": "en-CA",
+            },
+            method="DELETE",
+        )
+        return Deserializable(response or "<wrapper></wrapper>", to_xml)