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 cancel_shipment(self, request: Serializable) -> Deserializable:
tag = request.value.__class__.__name__.replace("Request", "")
api = f"{tag}Certify" if self.settings.test else tag
serialized_request = request.serialize().replace(tag, api)
query = urllib.parse.urlencode({"API": api, "XML": serialized_request})
response = http(url=f"{self.settings.server_url}?{query}",
method="GET")
return Deserializable(response, XP.to_xml)
def get_rates(self, request: Serializable) -> Deserializable:
query = urllib.parse.urlencode({
"API": "RateV4",
"XML": request.serialize()
})
response = http(url=f"{self.settings.server_url}?{query}",
method="GET")
return Deserializable(response, XP.to_xml)
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 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, default_request_serializer)
def shipment_request(payload: ShipmentRequest,
settings: Settings) -> Serializable[Pipeline]:
requests: Pipeline = Pipeline(
create=lambda *_: partial(
_create_shipment, payload=payload, settings=settings)(),
document=partial(_get_shipment_label,
payload=payload,
settings=settings),
)
return Serializable(requests)
def _send_request(self, request: Serializable, path: str) -> str:
return http(
url=f"{self.settings.server_url}{path}",
data=bytearray(request.serialize(), "utf-8"),
headers={
"Content-Type": "application/xml",
"Authorization": f"Basic {self.settings.authorization}"
},
method="POST",
)
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)
def book_pickup_request(
payload: PickupRequest, settings: Settings
) -> Serializable[BookPURequest]:
weight_unit = DHLWeightUnit.LB
weight = sum(
[
Weight(parcel.weight, WeightUnit[weight_unit.name]).LB
for parcel in payload.parcels
]
)
request = BookPURequest(
Request=settings.Request(
MetaData=MetaData(SoftwareName="XMLPI", SoftwareVersion=3.0)
),
schemaVersion=3.0,
RegionCode=CountryRegion[payload.address.country_code].value
if payload.address.country_code
else "AM",
Requestor=Requestor(
AccountNumber=settings.account_number,
AccountType="D",
RequestorContact=RequestorContact(
PersonName=payload.address.person_name,
Phone=payload.address.phone_number,
PhoneExtension=None,
),
CompanyName=payload.address.company_name,
),
Place=Place(
City=payload.address.city,
StateCode=payload.address.state_code,
PostalCode=payload.address.postal_code,
CompanyName=payload.address.company_name,
CountryCode=payload.address.country_code,
PackageLocation=payload.package_location,
LocationType="R" if payload.address.residential else "B",
Address1=payload.address.address_line1,
Address2=payload.address.address_line2,
),
PickupContact=RequestorContact(
PersonName=payload.address.person_name, Phone=payload.address.phone_number
),
Pickup=Pickup(
Pieces=len(payload.parcels),
PickupDate=payload.date,
ReadyByTime=f'{payload.ready_time}:00',
CloseTime=f'{payload.closing_time}:00',
SpecialInstructions=[payload.instruction],
RemotePickupFlag="Y",
weight=WeightSeg(Weight=weight, WeightUnit=weight_unit.value),
),
ShipmentDetails=None,
ConsigneeDetails=None,
)
return Serializable(request, _request_serializer)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(body_content=VoidPackages(
AuthenicateAccount=Authenticate(
AccountID=settings.account_id,
Password=settings.password,
),
Packages=ArrayOfString(string=[payload.shipment_identifier]),
))
return Serializable(request, Settings.serialize)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable:
if 'international' in payload.service:
request = eVSICancelRequest(USERID=settings.username,
BarcodeNumber=payload.shipment_identifier)
else:
request = eVSCancelRequest(USERID=settings.username,
BarcodeNumber=payload.shipment_identifier)
return Serializable(request)
def get_label_request(payload: LabelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(body_content=getLabelsAdvanced(
request=GetLabelsAdvancedRq(horizontal=False,
id=payload.shipment_id,
password=settings.password,
thermal=payload.thermal,
user_id=settings.username)))
return Serializable(request, default_request_serializer)
def tracking_request(payload: TrackingRequest,
_) -> Serializable[List[Envelope]]:
request = [
create_envelope(body_content=trackByBarcodeV2(
request=TrackByBarcodeV2Rq(
barcode=barcode, filter=None, track_shipment=True)))
for barcode in payload.tracking_numbers
]
return Serializable(request, _request_serializer)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable[str]:
request = Freightcom(
username=settings.username,
password=settings.password,
version="3.1.0",
ShipmentCancelRequest=ShipmentCancelRequestType(Order=OrderType(
orderId=payload.shipment_identifier)))
return Serializable(request, standard_request_serializer)
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_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 _send_request(self, request: Serializable, path: str) -> str:
return http(
url=f"{self.settings.server_url}{path}",
data=bytearray(
urllib.parse.urlencode(dict(xml_in=request.serialize())),
"utf-8"),
headers={
"Content-Type": "application/x-www-form-urlencoded",
"Authorization": f"Basic {self.settings.authorization}"
},
method="POST",
)
def get_rates(self,
request: Serializable[Envelope]) -> Deserializable[str]:
product, data = request.serialize()
responses = [
f'<product>{product}</product>',
self._send_request(
soapaction="http://www.icscourier.ca/GetEstimatedCharges",
request=Serializable(data),
)
]
return Deserializable(XP.bundle_xml(responses), XP.to_xml)
def pickup_update_request(payload: PickupUpdateRequest,
settings: Settings) -> Serializable[Pipeline]:
request: Pipeline = Pipeline(
delete_pickup=lambda *_: _delete_pickup(payload, settings),
create_pickup=partial(_create_pickup,
payload=payload,
settings=settings),
retrieve_pickup=partial(_retrieve_pickup,
payload=payload,
settings=settings))
return Serializable(request)
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, default_request_serializer)
def pickup_request(payload: PickupRequest,
settings: Settings) -> Serializable[Envelope]:
packages = Packages(payload.parcels, PackagePresets)
request = create_envelope(header_content=settings.Security,
body_content=FreightPickupRequest())
return Serializable(
request,
default_request_serializer(
"v11",
'xmlns:v11="http://www.ups.com/XMLSchema/XOLTWS/Pickup/v1.1"'),
)
def get_tracking(self, request: Serializable) -> Deserializable[str]:
query = urllib.parse.urlencode(request.serialize())
response = http(
url=f"http://trackapi.yanwentech.com/api/tracking?{query}",
headers={
"Content-Type": "application/json",
"Accept": "application/json",
"Authorization": self.settings.customer_number
},
method="GET",
)
return Deserializable(response, DP.to_dict)
def rate_request(payload: RateRequest,
settings: Settings) -> Serializable[priceRequest]:
options = Options(payload.options, ShipmentOption)
package = Packages(payload.parcels).single
service = Services(payload.services, ShipmentService).first
option_codes = [code for label, code in options if 'division' not in label]
request = priceRequest(
appId=settings.username,
appVersion="3.0",
priceCheck=priceCheck(
rateId=None,
sender=address(country=payload.shipper.country_code,
town=payload.shipper.city,
postcode=payload.shipper.postal_code),
delivery=address(country=payload.recipient.country_code,
town=payload.recipient.city,
postcode=payload.recipient.postal_code),
collectionDateTime=DF.fdatetime(options.shipment_date,
output_format='%Y-%m-%dT%H:%M:%S'),
product=product(
id=getattr(service, 'value', None),
division=next(
(code for label, code in options if 'division' in label),
None),
productDesc=None,
type_=('D' if package.parcel.is_document else 'N'),
options=(optionsType(
option=[option(optionCode=code) for code in option_codes])
if any(option_codes) else None)),
account=(account(
accountNumber=settings.account_number,
accountCountry=settings.account_country_code,
) if any([settings.account_number, settings.account_country_code])
else None),
insurance=(insurance(insuranceValue=options.insurance,
goodsValue=options.insurance)
if options.insurance is not None else None),
termsOfPayment=PaymentType.sender.value,
currency=options.currency,
priceBreakDown=True,
consignmentDetails=consignmentDetails(
totalWeight=package.weight.KG,
totalVolume=package.volume.value,
totalNumberOfPieces=1,
),
pieceLine=None),
)
return Serializable(request, XP.to_xml)
def rate_request(payload: RateRequest,
settings: Settings) -> Serializable[DicomRateRequest]:
packages = Packages(payload.parcels)
service = (Services(payload.services, Service).first
or Service.dicom_ground_delivery).value
options = Options(payload.options, Option)
request = DicomRateRequest(
category="Parcel",
paymentType=PaymentType.prepaid.value,
deliveryType=service,
unitOfMeasurement=UnitOfMeasurement.KC.value,
sender=Address(postalCode=payload.shipper.postal_code,
provinceCode=payload.shipper.state_code,
countryCode=payload.shipper.country_code,
name=(payload.shipper.company_name
or payload.shipper.person_name)),
consignee=Address(postalCode=payload.recipient.postal_code,
provinceCode=payload.recipient.state_code,
countryCode=payload.recipient.country_code,
name=(payload.recipient.company_name
or payload.recipient.person_name)),
parcels=[
Parcel(
quantity=1,
parcelType=ParcelType[package.packaging_type
or "dicom_box"].value,
id=None,
weight=package.weight.KG,
length=package.height.CM,
depth=package.length.CM,
width=package.width.CM,
note=None,
status=None,
FCA_Class=None,
hazmat=None,
requestReturnLabel=None,
returnWaybill=None,
) for package in packages
],
billing=settings.billing_account,
promoCodes=None,
surcharges=[
Surcharge(type=getattr(option, 'key', option),
value=getattr(option, 'value', None))
for _, option in options
],
appointment=None,
)
return Serializable(request, DP.to_dict)
def get_tracking(self, request: Serializable) -> Deserializable:
def _get_tracking(tracking_number: str):
return http(
url=f"{self.settings.server_url}/v1/tracking/{tracking_number}",
headers={
"Accept": "application/json",
"Authorization": f"Basic {self.settings.authorization}"
},
method="GET",
)
responses: List[dict] = exec_async(_get_tracking, request.serialize())
return Deserializable(responses, lambda res: [DP.to_dict(r) for r in res if any(r.strip())])
def get_tracking(self, request: Serializable) -> Deserializable[str]:
query = urllib.parse.urlencode(request.serialize())
response = http(
url=f"{self.settings.server_url}/shipping/v1/track?{query}",
headers={
"Content-Type": "application/json",
"Accept": "application/json",
"Account-Number": self.settings.account_number,
"Authorization": f"Basic {self.settings.authorization}"
},
method="GET",
)
return Deserializable(response, DP.to_dict)
def tracking_request(payload: TrackingRequest, _) -> Serializable[TrackRequest]:
request = TrackRequest(
locale="en_US",
version="3.1",
SearchCriteria=SearchCriteriaType(ConsignmentNumber=payload.tracking_numbers),
LevelOfDetail=LevelOfDetailType(
Complete=CompleteType(
originAddress=True,
destinationAddress=True,
)
)
)
return Serializable(request, XP.export)
def get_tracking(self, request: Serializable) -> Deserializable[str]:
def _get_tracking(tracking_request: dict):
query = urllib.parse.urlencode(tracking_request)
return http(
url=f"{self.settings.server_url}/track/shipments?{query}",
headers={
"Accept": "application/json",
"DHL-API-Key": self.settings.consumer_key
},
method="GET",
)
responses: List[dict] = exec_async(_get_tracking, request.serialize())
return Deserializable(responses,
lambda res: [DP.to_dict(r) for r in res])
def tracking_request(payload: TrackingRequest,
settings: Settings) -> Serializable[TrackRequest]:
request = TrackRequest(
locale="en_US",
version="3.1",
SearchCriteria=SearchCriteriaType(
marketType="INTERNATIONAL",
originCountry=(settings.account_country_code or "US"),
ConsignmentNumber=payload.tracking_numbers),
LevelOfDetail=LevelOfDetailType(Complete=CompleteType(
originAddress=True,
destinationAddress=True,
)))
return Serializable(request, XP.export)
def address_validation_request(payload: AddressValidationRequest,
_) -> Serializable[UPSAddressValidationRequest]:
request = UPSAddressValidationRequest(
Request=RequestType(
TransactionReference=None,
RequestAction="AV",
),
Address=AddressType(City=payload.address.city,
StateProvinceCode=payload.address.state_code,
CountryCode=payload.address.country_code,
PostalCode=payload.address.postal_code),
)
return Serializable(request, _request_serializer)
