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 rate_request(payload: RateRequest,
settings: Settings) -> Serializable[Envelope]:
packages = Packages(payload.parcels)
product = Services(payload.services, Service).first
request = create_envelope(body_content=GetEstimatedCharges(
AuthenicateAccount=Authenticate(
AccountID=settings.account_id,
Password=settings.password,
),
PkgInfo=PackgeInfoToGetCharges(
Product=(product or Service.ics_courier_ground.value),
Pieces=ArrayOfPieceInfo(PieceInfo=[
PieceInfo(
Weight=piece.weight.value,
WeightUnit=piece.weight.unit,
Length=piece.length.value,
Width=piece.width.value,
Height=piece.height.value,
DeclaredValue=None,
) for piece in packages
]),
FromPost=payload.shipper.postal_code,
ToPost=payload.recipient.postal_code,
)))
return Serializable(request, lambda _: (product, Settings.serialize(_)))
def shipment_cancel_request(payload: ShipmentCancelRequest, settings: Settings) -> Serializable:
request = dict(
packageID=payload.shipment_identifier,
accountNumber=settings.account_number,
)
return Serializable(request)
def tracking_request(payload: TrackingRequest, settings: Settings) -> Serializable[Envelope]:
request = create_envelope(
body_content=ShipmentTrackingRequest(
ClientInfo=ClientInfo(
UserName=settings.username,
Password=settings.password,
Version='1.0',
AccountNumber=settings.account_number,
AccountPin=settings.account_pin,
AccountEntity=settings.account_entity,
AccountCountryCode=settings.account_country_code,
),
Transaction=None,
Shipments=ArrayOfstring(
string=payload.tracking_numbers
),
GetLastTrackingUpdateOnly=False,
)
)
return Serializable(
request, partial(
settings.standard_request_serializer,
extra_namespace='xmlns:arr="http://schemas.microsoft.com/2003/10/Serialization/Arrays',
special_prefixes=dict(string='arr')
)
)
def create_shipment_request(payload: ShipmentRequest, settings: Settings) -> Serializable[Pipeline]:
requests: Pipeline = Pipeline(
validate=lambda *_: partial(_validate_shipment, payload=payload, settings=settings)(),
create=partial(_create_shipment, payload=payload, settings=settings),
document=partial(_get_shipment_label, payload=payload, settings=settings),
)
return Serializable(requests)
def track_request(payload: TrackingRequest,
settings: Settings) -> Serializable[TrackRequest]:
request = TrackRequest(
WebAuthenticationDetail=settings.webAuthenticationDetail,
ClientDetail=settings.clientDetail,
TransactionDetail=TransactionDetail(
CustomerTransactionId="Track By Number_v14",
Localization=Localization(
LanguageCode=payload.language_code or "en"),
),
Version=VersionId(ServiceId="trck", Major=14, Intermediate=0, Minor=0),
SelectionDetails=[
TrackSelectionDetail(
CarrierCode="FDXE", # Read doc for carrier code customization
OperatingCompany=None,
PackageIdentifier=TrackPackageIdentifier(
Type="TRACKING_NUMBER_OR_DOORTAG", Value=tracking_number),
TrackingNumberUniqueIdentifier=None,
ShipDateRangeBegin=None,
ShipDateRangeEnd=None,
ShipmentAccountNumber=None,
SecureSpodAccount=None,
Destination=None,
PagingDetail=None,
CustomerSpecifiedTimeOutValueInMilliseconds=None,
) for tracking_number in payload.tracking_numbers
],
TransactionTimeOutValueInMilliseconds=None,
ProcessingOptions=None,
)
return Serializable(request, _request_serializer)
def pickup_update_request(payload: PickupUpdateRequest, _) -> Serializable:
shipments: List[ShipmentDetails] = payload.options.get('shipments', [])
request = BoxKnightPickupUpdateRequest(
orderIds=[shipment.shipment_identifier for shipment in shipments])
return Serializable(request)
def shipment_request(payload: ShipmentRequest, _) -> Serializable:
request = OrderRequest(
packageCount=len(payload.parcels),
signatureRequired=payload.options.get('signature_required', False),
recipient=Recipient(name=payload.recipient.person_name,
phone=payload.recipient.phone_number,
notes=None,
email=payload.recipient.email),
recipientAddress=Address(street=SF.concat_str(
payload.recipient.address_line1,
payload.recipient.address_line2,
join=True),
city=payload.recipient.city,
province=payload.recipient.state_code,
country=payload.recipient.country_code,
postalCode=payload.recipient.postal_code,
unit=None),
originAddress=Address(street=SF.concat_str(
payload.shipper.address_line1,
payload.shipper.address_line2,
join=True),
city=payload.shipper.city,
province=payload.shipper.state_code,
country=payload.shipper.country_code,
postalCode=payload.shipper.postal_code,
unit=None),
service=Service[payload.service].value,
notes=None,
refNumber=payload.reference,
completeAfter=None,
completeBefore=None,
merchantDisplayName=payload.shipper.company_name)
return Serializable(request)
def pickup_request(payload: PickupRequest, _) -> Serializable:
shipments: List[ShipmentDetails] = payload.options.get('shipments', [])
after = DF.date(f"{payload.pickup_date} {payload.ready_time}", current_format="%Y-%m-%d %H:%M")
before = DF.date(f"{payload.pickup_date} {payload.ready_time}", current_format="%Y-%m-%d %H:%M")
request = BoxKnightPickupRequest(
packageCount=len(payload.parcels),
recipient=Recipient(
name=payload.address.person_name,
phone=payload.address.phone_number,
notes=None,
email=payload.address.email,
),
recipientAddress=PickupRequestRecipientAddress(
street=SF.concat_str(payload.address.address_line1, payload.address.address_line2, join=True),
city=payload.address.city,
province=payload.address.state_code,
country=payload.address.country_code,
postalCode=payload.address.postal_code,
unit=None
),
notes=payload.instruction,
completeAfter=int(after.timestamp() * 1000.0),
completeBefore=int(before.timestamp() * 1000.0),
orderIds=[shipment.shipment_identifier for shipment in shipments],
)
return Serializable(request)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable[Envelope]:
tracking_type = next(
(t for t in list(TrackingIdType) if t.name.lower() in payload.service),
TrackingIdType.EXPRESS).value
deletion_type = DeletionControlType[payload.options.get(
'deletion_type', 'DELETE_ALL_PACKAGES')].value
request = create_envelope(body_content=DeleteShipmentRequest(
WebAuthenticationDetail=settings.webAuthenticationDetail,
ClientDetail=settings.clientDetail,
TransactionDetail=TransactionDetail(
CustomerTransactionId="Delete Shipment"),
Version=VersionId(ServiceId="ship", Major=23, Intermediate=0, Minor=0),
ShipTimestamp=None,
TrackingId=TrackingId(TrackingIdType=tracking_type,
FormId=None,
UspsApplicationId=None,
TrackingNumber=payload.shipment_identifier),
DeletionControl=deletion_type))
return Serializable(
request,
default_request_serializer('v23',
'xmlns:v23="http://fedex.com/ws/ship/v23"'))
def pickup_update_request(payload: PickupUpdateRequest,
settings: Settings) -> Serializable[Pipeline]:
request: Pipeline = Pipeline(
update_pickup=lambda *_: _update_pickup(payload, settings),
get_pickup=partial(_get_pickup, payload=payload, settings=settings),
)
return Serializable(request)
def pickup_request(payload: PickupRequest, settings: Settings) -> Serializable:
shipments: List[ShipmentRequest] = payload.options.get('shipments', [])
packages = Packages(payload.parcels)
request = CarrierPickupScheduleRequest(
USERID=settings.username,
FirstName=payload.address.person_name,
LastName=None,
FirmName=payload.address.company_name,
SuiteOrApt=payload.address.address_line1,
Address2=SF.concat_str(payload.address.address_line1,
payload.address.address_line2,
join=True),
Urbanization=None,
City=payload.address.city,
State=payload.address.state_code,
ZIP5=payload.address.postal_code,
ZIP4=None,
Phone=payload.address.phone_number,
Extension=None,
Package=[
PackageType(ServiceType=shipment.service,
Count=len(shipment.parcels)) for shipment in shipments
],
EstimatedWeight=packages.weight.LB,
PackageLocation=payload.package_location,
SpecialInstructions=payload.instruction,
EmailAddress=payload.address.email)
return Serializable(request)
def get_shipping_documents_request(
pin: str, payload: ShipmentRequest,
settings: Settings) -> Serializable[Envelope]:
is_international = payload.shipper.country_code != payload.recipient.country_code
label_type = PrintType.map(payload.label_type or 'PDF').name
document_type = SF.concat_str(
("International" if is_international else "Domestic"),
"BillOfLading", ("Thermal" if label_type == "ZPL" else ""),
separator="",
join=True)
request = create_envelope(
header_content=RequestContext(
Version="1.3",
Language=settings.language,
GroupID="",
RequestReference=(getattr(payload, 'id', None) or ""),
UserToken=settings.user_token,
),
body_content=GetDocumentsRequest(
OutputType=label_type,
Synchronous=True,
DocumentCriterium=ArrayOfDocumentCriteria(DocumentCriteria=[
DocumentCriteria(PIN=PIN(Value=pin),
DocumentTypes=DocumentTypes(
DocumentType=[document_type]))
]),
),
)
return Serializable(request, _request_serializer)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable:
request = eVSICancelRequest(USERID=settings.username,
BarcodeNumber=payload.shipment_identifier)
return Serializable(request, XP.export)
def shipment_request(payload: ShipmentRequest,
settings: Settings) -> Serializable[Pipeline]:
requests: Pipeline = Pipeline(
create_shipment=lambda *_: _create_shipment(payload, settings),
retrieve_label=partial(_get_shipment_label),
)
return Serializable(requests)
def _modify_pickup_request(
payload: PickupUpdateRequest, settings: Settings
) -> Serializable[Envelope]:
request = create_envelope(
header_content=RequestContext(
Version="1.2",
Language=settings.language,
GroupID="",
RequestReference="",
UserToken=settings.user_token,
),
body_content=ModifyPickUpRequest(
BillingAccountNumber=settings.account_number,
ConfirmationNumber=payload.confirmation_number,
ModifyPickupInstruction=ModifyPickupInstruction(
UntilTime="".join(payload.closing_time.split(":")),
PickUpLocation=payload.package_location,
SupplyRequestCodes=None,
TrailerAccessible=payload.options.get("TrailerAccessible"),
LoadingDockAvailable=payload.options.get("LoadingDockAvailable"),
ShipmentOnSkids=None,
NumberOfSkids=None,
),
ShipmentSummary=None,
),
)
return Serializable(request, partial(standard_request_serializer, version="v1"))
def pickup_cancel_request(
payload: PickupCancelRequest,
settings: Settings) -> Serializable[CancelPickupRequest]:
request = CancelPickupRequest(
WebAuthenticationDetail=settings.webAuthenticationDetail,
ClientDetail=settings.clientDetail,
TransactionDetail=TransactionDetail(CustomerTransactionId="FTC"),
Version=VersionId(ServiceId="disp", Major=17, Intermediate=0, Minor=0),
CarrierCode=CarrierCodeType.FDXE.value,
PickupConfirmationNumber=payload.confirmation_number,
ScheduledDate=payload.pickup_date,
EndDate=None,
Location=None,
Remarks=None,
ShippingChargesPayment=None,
Reason=payload.reason,
ContactName=(payload.address.person_name
if payload.address is not None else None),
PhoneNumber=(payload.address.phone_number
if payload.address is not None else None),
PhoneExtension=None,
)
return Serializable(request, _request_serializer)
def address_validation_request(
payload: AddressValidationRequest,
settings: Settings) -> Serializable[RouteRequest]:
country = (Country[payload.address.country_code]
if payload.address.country_code is not None else None)
division = (
CountryState[country.name].value[payload.address.state_code].value if
(country.name in CountryState.__members__
and payload.address.state_code
in CountryState[country.name].value.__members__) else None)
request = RouteRequest(
schemaVersion="2.0",
Request=settings.Request(
MetaData=MetaData(SoftwareName="3PV", SoftwareVersion=1.0)),
RegionCode=CountryRegion[payload.address.country_code].value,
RequestType=RequestType.D.value,
Address1=SF.concat_str(payload.address.address_line1, join=True),
Address2=SF.concat_str(payload.address.address_line2, join=True),
Address3=None,
PostalCode=payload.address.postal_code,
City=payload.address.city,
Division=division,
CountryCode=country.name,
CountryName=country.value,
OriginCountryCode=payload.address.country_code,
)
return Serializable(request, _request_serializer)
def shipment_request(payload: ShipmentRequest, settings: Settings) -> Serializable[Envelope]:
packages = Packages(payload.parcels)
options = Options(payload.options, Option)
product = Service.map(payload.service).value_or_key
request = create_envelope(
body_content=CreateShipment(
AuthenicateAccount=Authenticate(
AccountID=settings.account_id,
Password=settings.password,
),
ConsigneeInfo=AddressInfo(
ID=payload.recipient.id,
Name=payload.recipient.company_name,
Address1=payload.recipient.address_line1,
Address2=payload.recipient.address_line2,
City=payload.recipient.city,
Province=payload.recipient.state_code,
Postcode=payload.recipient.postal_code,
Contact=payload.recipient.person_name,
Phone=payload.recipient.phone_number,
),
PackageInfo=PackageInfo(
Product=product,
Pieces=ArrayOfPieceInfo(
PieceInfo=[
PieceInfo(
Weight=piece.weight.value,
WeightUnit=piece.weight.unit,
Length=piece.length.value,
Width=piece.width.value,
Height=piece.height.value,
DeclaredValue=None,
)
for piece in packages
]
),
Contact=payload.shipper.person_name,
Phone=payload.shipper.phone_number,
CostCenter=options.ics_courier_cost_center,
Refereces=(
ArrayOfString(string=[payload.reference])
if payload.reference is not None
else payload.reference
),
NotificationEmail=(
options.email_notification_to or payload.recipient.email_address
if options.email_notification and any(
[options.email_notification_to or payload.recipient.email_address]
) else None
),
SpecialInstruction=options.ics_courier_special_instruction,
NoSignatureRequired=options.ics_courier_no_signature_required,
ShipDate=options.ship_date,
)
),
)
return Serializable(request)
def rate_request(payload: RateRequest,
settings: Settings) -> Serializable[mailing_scenario]:
"""Create the appropriate Canada Post rate request depending on the destination
:param settings: Purplship carrier connection settings
:param payload: Purplship unified API rate request data
:return: a domestic or international Canada post compatible request
:raises: an OriginNotServicedError when origin country is not serviced by the carrier
"""
if payload.shipper.country_code and payload.shipper.country_code != Country.CA.name:
raise OriginNotServicedError(payload.shipper.country_code)
package = Packages(payload.parcels, PackagePresets,
required=["weight"]).single
services = Services(payload.services, ServiceType)
options = Options(payload.options, OptionCode)
request = mailing_scenario(
customer_number=settings.customer_number,
contract_id=None,
promo_code=None,
quote_type=None,
expected_mailing_date=options.shipment_date,
options=(optionsType(option=[
optionType(option_code=getattr(option, 'key', option),
option_amount=getattr(option, 'value', None))
for code, option in options if code in OptionCode
]) if any([c in OptionCode for c, _ in options]) else None),
parcel_characteristics=parcel_characteristicsType(
weight=package.weight.map(MeasurementOptions).KG,
dimensions=dimensionsType(
length=package.length.map(MeasurementOptions).CM,
width=package.width.map(MeasurementOptions).CM,
height=package.height.map(MeasurementOptions).CM,
),
unpackaged=None,
mailing_tube=None,
oversized=None,
),
services=(servicesType(
service_code=[svc.value
for svc in services]) if any(services) else None),
origin_postal_code=payload.shipper.postal_code,
destination=destinationType(
domestic=(
domesticType(postal_code=payload.recipient.postal_code) if
(payload.recipient.country_code == Country.CA.name) else None),
united_states=(
united_statesType(zip_code=payload.recipient.postal_code) if
(payload.recipient.country_code == Country.US.name) else None),
international=(internationalType(
country_code=payload.recipient.postal_code) if
(payload.recipient.country_code not in [
Country.US.name, Country.CA.name
]) else None),
),
)
return Serializable(request, _request_serializer)
def rate_request(payload: RateRequest, _) -> Serializable:
request = BoxKnightRateRequest(
postalCode=payload.recipient.postal_code,
originPostalCode=payload.shipper.postal_code
)
return Serializable(request)
def tracking_request(payload: TrackingRequest,
_) -> Serializable[List[Envelope]]:
request = create_envelope(body_content=TracePackge(
TrackNums=ArrayOfString(string=payload.tracking_numbers),
DetailInfo=True,
))
return Serializable(request, Settings.serialize)
def pickup_request(
payload: PickupRequest, settings: Settings
) -> Serializable[Pipeline]:
request: Pipeline = Pipeline(
get_availability=lambda *_: _get_pickup_availability(payload),
create_pickup=partial(_create_pickup, payload=payload, settings=settings),
)
return Serializable(request)
def shipment_request(payload: ShipmentRequest, settings: Settings) -> Serializable[Pipeline]:
request: Pipeline = Pipeline(
process=lambda *_: _process_shipment(payload, settings),
get_label=partial(_get_label, settings=settings)
)
return Serializable(request)
def tracking_request(payload: TrackingRequest, _) -> Serializable[Request]:
request = Request(requestID="EXP_RECE_SEARCH_ROUTES",
msgData=SFTrackingRequest(
language="1",
trackingType="1",
methodType="1",
trackingNumber=payload.tracking_numbers))
return Serializable(request, DP.jsonify)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(body_content=voidShipment(
request=VoidShipmentRq(id=int(payload.shipment_identifier),
password=settings.password,
user_id=settings.username)))
return Serializable(request, Settings.serialize)
def tracking_request(payload: TrackingRequest,
settings: Settings) -> Serializable[KnownTrackingRequest]:
request = KnownTrackingRequest(
Request=settings.Request(),
LanguageCode=payload.language_code or "en",
LevelOfDetails=payload.level_of_details or "ALL_CHECK_POINTS",
AWBNumber=payload.tracking_numbers,
)
return Serializable(request, _request_serializer)
def pickup_cancel_request(payload: PickupCancelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(body_content=cancelPickup(
request=CancelPickupRq(id=int(payload.confirmation_number),
password=settings.password,
user_id=settings.username)))
return Serializable(request, Settings.serialize)
def pickup_request(payload: PickupRequest, settings: Settings) -> Serializable:
request: Pipeline = Pipeline(
create_pickup=lambda *_: _create_pickup(payload),
retrieve_pickup=partial(_retrieve_pickup,
payload=payload,
settings=settings))
return Serializable(request)
def tracking_request(payload: TrackingRequest,
_) -> Serializable[DHLTrackingRequest]:
request = [
DHLTrackingRequest(
trackingNumber=number,
language="en",
) for number in payload.tracking_numbers
]
return Serializable(request, DP.to_dict)
