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)