def _modify_pickup(
validation_response: str, payload: PickupUpdateRequest, settings: Settings
):
errors = parse_error_response(XP.to_xml(validation_response), settings)
data = _modify_pickup_request(payload, settings) if len(errors) == 0 else None
return Job(id="modify", data=data, fallback="")
def _create_label_request(shipment_response: str) -> Job:
activity = XP.build(document, XP.to_xml(shipment_response))
fallback = shipment_response if activity is None else None
data = (create_label_request(activity, payload, settings)
if activity is None else None)
return Job(id='create', data=data, fallback=fallback)
def _validate_shipment(payload: ShipmentRequest, settings: Settings) -> Job:
return Job(
id="validate",
data=_shipment_request(payload=payload,
settings=settings,
validate=True),
)
def shipment_cancel_request(payload: ShipmentCancelRequest,
_) -> Serializable[Pipeline]:
identifier = Serializable(payload.shipment_identifier)
def _refund_if_submitted(shipment_details: str):
shipment = XP.build(ShipmentInfoType, XP.to_xml(shipment_details))
transmitted = shipment.shipment_status == 'transmitted'
data = dict(
id=payload.shipment_identifier,
payload=Serializable(
ShipmentRefundRequestType(
email=payload.options.get('email')), lambda request: XP.
export(request,
name_='shipment-refund-request',
namespacedef_=
'xmlns="http://www.canadapost.ca/ws/shipment-v8"'))
) if transmitted else None
return Job(id="refund", data=data, fallback=shipment_details)
def _cancel_other_wise(previous_job_response: str):
response: Element = XP.to_xml(previous_job_response)
refunded = (response.tag == 'shipment-refund-request-info')
data = identifier if not refunded else None
return Job(id="cancel", data=data)
request: Pipeline = Pipeline(
info=lambda *_: Job(id="info", data=identifier),
refund=_refund_if_submitted,
cancel=_cancel_other_wise)
return Serializable(request)
def _create_pickup(availability_response: str, payload: PickupRequest,
settings: Settings):
availability = XP.build(PickupAvailabilityReply,
XP.to_xml(availability_response))
data = _pickup_request(payload, settings) if availability else None
return Job(id="create_pickup", data=data, fallback="")
def _create_pickup(cancel_response: str, payload: PickupUpdateRequest,
settings: Settings) -> Job:
errors = parse_error_response(XP.to_xml(cancel_response), settings)
canceled = len(errors) == 0
data: Optional[PickupRequest] = (pickup_request(payload, settings)
if canceled else None)
fallback: Optional[str] = None if canceled else ''
return Job(id='schedule', data=data, fallback=fallback)
def _create_shipment(validate_response: str, payload: ShipmentRequest,
settings: Settings) -> Job:
errors = parse_error_response(XP.to_xml(validate_response), settings)
valid = len(errors) == 0
return Job(
id="create",
data=_shipment_request(payload, settings) if valid else None,
fallback=(validate_response if not valid else None),
)
def _cancel_pickup(payload: PickupUpdateRequest, settings: Settings) -> Job:
data = PickupCancelRequest(
confirmation_number=payload.confirmation_number,
address=payload.address,
pickup_date=payload.pickup_date,
reason='change pickup',
)
return Job(id='cancel', data=pickup_cancel_request(data, settings))
def _create_pickup(availability_response: str, payload: PickupRequest,
settings: Settings):
availability = XP.build(pickup_availability,
XP.to_xml(availability_response))
data = _create_pickup_request(
payload, settings) if availability.on_demand_tour else None
return Job(id="create_pickup",
data=data,
fallback="" if data is None else "")
def _get_shipment_label(create_response: str, payload: ShipmentRequest,
settings: Settings) -> Job:
response = XP.to_xml(create_response)
valid = len(parse_error_response(response, settings)) == 0
shipment_pin = (getattr(XP.find("ShipmentPIN", response, PIN, first=True),
'Value', None) if valid else None)
data = (get_shipping_documents_request(shipment_pin, payload, settings)
if valid else None)
return Job(id="document", data=data, fallback="")
def _create_pickup(deletion_response: str,
payload: PickupUpdateRequest) -> Job:
errors = parse_error_response(deletion_response)
create_job: Job = (_create_pickup_job(cast(PickupRequest, payload))
if not any(errors) else None)
data = (create_job.data if create_job is not None else None)
return Job(id="create_pickup",
data=data,
fallback=("{}" if data is None else None))
def _get_pickup(update_response: str, payload: PickupUpdateRequest,
settings: Settings) -> Job:
errors = parse_error_response(XP.to_xml(XP.bundle_xml([update_response])),
settings)
data = None if any(
errors
) else f"/enab/{settings.customer_number}/pickuprequest/{payload.confirmation_number}/details"
return Job(id="get_pickup",
data=Serializable(data),
fallback="" if data is None else "")
def _update_pickup(payload: PickupUpdateRequest, settings: Settings) -> Job:
data = Serializable(
dict(
confirmation_number=payload.confirmation_number,
data=_create_pickup_request(cast(PickupRequest, payload),
settings,
update=True),
), _update_request_serializer)
fallback = "" if data is None else ""
return Job(id="update_pickup", data=data, fallback=fallback)
def _get_label(shipment_response: str, settings: Settings) -> Job:
response = XP.to_xml(shipment_response)
shipment = XP.to_object(
Shipment, next(iter(response.xpath(".//*[local-name() = $name]", name="shipment")), None)
)
success = (shipment is not None and shipment.id is not None)
data = (
get_label_request(LabelRequest(shipment_id=shipment.id), settings)
if success else
None
)
return Job(id="get_label", data=data, fallback=("" if not success else None))
def _refund_if_submitted(shipment_details: str):
shipment = XP.build(ShipmentInfoType, XP.to_xml(shipment_details))
transmitted = shipment.shipment_status == 'transmitted'
data = dict(
id=payload.shipment_identifier,
payload=Serializable(
ShipmentRefundRequestType(
email=payload.options.get('email')), lambda request: XP.
export(request,
name_='shipment-refund-request',
namespacedef_=
'xmlns="http://www.canadapost.ca/ws/shipment-v8"'))
) if transmitted else None
return Job(id="refund", data=data, fallback=shipment_details)
def _cancel_pickup_request(response: str, payload: PickupUpdateRequest,
settings: Settings):
reply = next(
iter(
XP.to_xml(response).xpath(".//*[local-name() = $name]",
name="PickupCreationResponse")),
None,
)
new_pickup = XP.to_object(PickupCreationResponse, reply)
data = (pickup_cancel_request(
PickupCancelRequest(confirmation_number=payload.confirmation_number),
settings,
) if new_pickup is not None and new_pickup.PRN is not None else None)
return Job(id="cancel_pickup", data=data, fallback="")
def _cancel_pickup_request(response: str, payload: PickupUpdateRequest,
settings: Settings):
reply = next(
iter(
XP.to_xml(response).xpath(".//*[local-name() = $name]",
name="CreatePickupReply")),
None,
)
new_pickup = XP.build(CreatePickupReply, reply)
data = (pickup_cancel_request(
PickupCancelRequest(confirmation_number=payload.confirmation_number),
settings,
) if new_pickup is not None and new_pickup.HighestSeverity
== NotificationSeverityType.SUCCESS.value else None)
return Job(id="cancel_pickup", data=data, fallback="")
def _retrieve_pickup(creation_response: str, payload: PickupRequest,
settings: Settings) -> Job:
errors = parse_error_response(DP.to_dict(creation_response), settings)
data = (Serializable(
dict(
category=payload.options.get("category", "Parcel"),
pickupDate=payload.pickup_date,
streetNumber=SF.concat_str(payload.address.address_line1,
payload.address.address_line2,
join=True),
postalCode=payload.address.postal_code,
offset=10,
), urllib.parse.urlencode) if not any(errors) else None)
return Job(id="retrieve_pickup",
data=data,
fallback=('{}' if data is None else None))
def _cancel_pickup_request(
response: str, payload: PickupUpdateRequest, settings: Settings
):
new_pickup = XP.find(
"PickupCreationResponse",
XP.to_xml(response),
PickupCreationResponse,
first=True,
)
data = (
pickup_cancel_request(
PickupCancelRequest(confirmation_number=payload.confirmation_number),
settings,
)
if new_pickup is not None and new_pickup.PRN is not None
else None
)
return Job(id="cancel_pickup", data=data, fallback="")
def _get_shipment_label(create_response: str, payload: ShipmentRequest,
settings: Settings) -> Job:
errors = parse_error_response(XP.to_xml(create_response), settings)
valid = len(errors) == 0
shipment_pin = None
if valid:
node = next(
iter(
XP.to_xml(create_response).xpath(".//*[local-name() = $name]",
name="ShipmentPIN")),
None,
)
pin = PIN()
pin.build(node)
shipment_pin = pin.Value
return Job(
id="document",
data=(get_shipping_documents_request(shipment_pin, payload, settings)
if valid else None),
fallback="",
)
def _create_pickup(payload: PickupRequest) -> Job:
request = DicomPickupRequest(
date=payload.pickup_date,
ready=payload.ready_time,
category=payload.options.get("category", "Parcel"),
officeClose=payload.closing_time,
sender=Sender(city=payload.address.city,
provinceCode=payload.address.state_code,
postalCode=payload.address.postal_code,
countryCode=payload.address.country_code,
customerName=payload.address.company_name,
streetNumber=SF.concat_str(payload.address.address_line1,
payload.address.address_line2,
join=True),
contact=Contact(
fullName=payload.address.person_name,
email=payload.address.email,
telephone=payload.address.phone_number,
)),
location=payload.options.get("dicom_location", "OT"),
otherLocation=payload.package_location)
return Job(id="create_pickup", data=Serializable(request, DP.to_dict))
def _rate_pickup(payload: PickupRequest, settings: Settings):
data = pickup_rate_request(payload, settings)
return Job(id="availability", data=data)
def _delete_pickup(payload: PickupUpdateRequest, settings: Settings) -> Job:
data = pickup_cancel_request(settings=settings,
payload=cast(PickupCancelRequest, payload))
return Job(id="delete_pickup", data=data)
def _create_shipment(payload: ShipmentRequest, settings: Settings) -> Job:
return Job(
id="create",
data=_shipment_request(payload, settings),
)
def _get_pickup_availability(payload: PickupRequest):
return Job(id="availability", data=payload.address.postal_code)
def _get_pickup_availability(payload: PickupRequest):
return Job(
id="availability", data=(payload.address.postal_code or "").replace(" ", "")
)
def _get_availability(payload: PickupRequest, settings: Settings):
data = pickup_availability_request(payload, settings)
return Job(id="availability", data=data)
def _process_shipment(payload: ShipmentRequest, settings: Settings) -> Job:
packages = Packages(payload.parcels)
options = Options(payload.options, Option)
service_type = Service.map(payload.service).value_or_key
premium: Optional[bool] = next((True for option, _ in options if option in [
Option.canpar_ten_am.value,
Option.canpar_noon.value,
Option.canpar_saturday.value,
]), None)
shipping_date = DF.fdatetime(
options.shipment_date or time.strftime('%Y-%m-%d'),
current_format='%Y-%m-%d', output_format='%Y-%m-%dT%H:%M:%S'
)
request = create_envelope(
body_content=processShipment(
request=ProcessShipmentRq(
password=settings.password,
shipment=Shipment(
cod_type=options.canpar_cash_on_delivery,
delivery_address=Address(
address_line_1=payload.recipient.address_line1,
address_line_2=payload.recipient.address_line2,
address_line_3=None,
attention=payload.recipient.person_name,
city=payload.recipient.city,
country=payload.recipient.country_code,
email=payload.recipient.email,
extension=None,
name=payload.recipient.company_name,
phone=payload.recipient.phone_number,
postal_code=payload.recipient.postal_code,
province=payload.recipient.state_code,
residential=payload.recipient.residential,
),
description=None,
dg=options.canpar_dangerous_goods,
dimention_unit=DimensionUnit.IN.value,
handling=None,
handling_type=None,
instruction=None,
nsr=(options.canpar_no_signature_required or options.canpar_not_no_signature_required),
packages=[
Package(
alternative_reference=None,
cod=None,
cost_centre=None,
declared_value=None,
height=pkg.height.CM,
length=pkg.length.CM,
lg=None,
reference=None,
reported_weight=pkg.weight.LB,
store_num=None,
width=pkg.width.CM,
xc=('canpar_extra_care' in options) or None
) for pkg in packages
],
pickup_address=Address(
address_line_1=payload.shipper.address_line1,
address_line_2=payload.shipper.address_line2,
address_line_3=None,
attention=payload.shipper.person_name,
city=payload.shipper.city,
country=payload.shipper.country_code,
email=payload.shipper.email,
extension=None,
name=payload.shipper.company_name,
phone=payload.shipper.phone_number,
postal_code=payload.shipper.postal_code,
province=payload.shipper.state_code,
residential=payload.shipper.residential,
),
premium=premium,
proforma=None,
reported_weight_unit=WeightUnit.LB.value,
send_email_to_delivery=payload.recipient.email,
send_email_to_pickup=payload.shipper.email,
service_type=service_type,
shipper_num=None,
shipping_date=shipping_date,
subtotal=None,
subtotal_with_handling=None,
total=None,
total_with_handling=None,
user_id=None,
),
user_id=settings.username
)
)
)
data = Serializable(
request, partial(
settings.serialize,
extra_namespace='xmlns:xsd1="http://dto.canshipws.canpar.com/xsd"',
special_prefixes=dict(shipment_children='xsd1')
)
)
return Job(id="process", data=data)
def _cancel_other_wise(previous_job_response: str):
response: Element = XP.to_xml(previous_job_response)
refunded = (response.tag == 'shipment-refund-request-info')
data = identifier if not refunded else None
return Job(id="cancel", data=data)
def _create_pickup(rate_response: str, payload: PickupRequest, settings: Settings):
rate_result = XP.to_object(RateResultType, XP.to_xml(rate_response))
data = _create_pickup_request(payload, settings) if rate_result else None
return Job(id="create_pickup", data=data, fallback="")