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 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 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 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 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 _request_serializer(request: FedexRateRequest) -> str:
namespacedef_ = 'xmlns:tns="http://schemas.xmlsoap.org/soap/envelope/" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:v26="http://fedex.com/ws/rate/v26"'
envelope = create_envelope(body_content=request)
envelope.Body.ns_prefix_ = envelope.ns_prefix_
apply_namespaceprefix(envelope.Body.anytypeobjs_[0], "v26")
return XP.export(envelope, namespacedef_=namespacedef_)
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 _request_serializer(request: ProcessShipmentRequest) -> str:
namespacedef_ = 'xmlns:tns="http://schemas.xmlsoap.org/soap/envelope/" xmlns:v25="http://fedex.com/ws/ship/v25"'
envelope = create_envelope(body_content=request)
envelope.Body.ns_prefix_ = envelope.ns_prefix_
apply_namespaceprefix(envelope.Body.anytypeobjs_[0], "v25")
return XP.export(envelope, namespacedef_=namespacedef_)
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 _request_serializer(request: CancelPickupRequest) -> str:
envelope: Envelope = create_envelope(body_content=request)
envelope.Body.ns_prefix_ = envelope.ns_prefix_
apply_namespaceprefix(envelope.Body.anytypeobjs_[0], "v22")
return XP.export(
envelope,
namespacedef_='xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:v22="http://fedex.com/ws/pickup/v22"',
)
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 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 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 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 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 pickup_cancel_request(payload: PickupCancelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(
header_content=settings.Security,
body_content=UPSPickupCancelRequest(Request=RequestType(),
CancelBy="02",
PRN=payload.confirmation_number),
)
return Serializable(
request,
default_request_serializer(
"v11",
'xmlns:v11="http://www.ups.com/XMLSchema/XOLTWS/Pickup/v1.1"'),
)
def tracking_request(payload: TrackingRequest,
settings: Settings) -> Serializable[List[Envelope]]:
requests = [
create_envelope(
header_content=settings.Security,
body_content=TrackRequest(
Request=RequestType(
RequestOption=[1],
TransactionReference=TransactionReferenceType(
TransactionIdentifier="TransactionIdentifier"),
),
InquiryNumber=number,
),
) for number in payload.tracking_numbers
]
return Serializable(requests, _request_serializer)
def shipment_cancel_request(payload: ShipmentCancelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(
header_content=RequestContext(
Version="2.0",
Language=settings.language,
GroupID="",
RequestReference="",
UserToken=settings.user_token,
),
body_content=VoidShipmentRequest(PIN=PIN(
Value=payload.shipment_identifier)),
)
return Serializable(request, standard_request_serializer)
def address_validation_request(payload: AddressValidationRequest,
settings: Settings) -> Serializable[Envelope]:
contact = dict(PersonName=payload.address.person_name,
CompanyName=payload.address.company_name,
PhoneNumber=payload.address.phone_number,
EMailAddress=payload.address.email)
request = create_envelope(body_content=FedexAddressValidationRequest(
WebAuthenticationDetail=settings.webAuthenticationDetail,
ClientDetail=settings.clientDetail,
TransactionDetail=TransactionDetail(
CustomerTransactionId="AddressValidationRequest_v4"),
Version=VersionId(ServiceId="aval", Major=4, Intermediate=0, Minor=0),
InEffectAsOfTimestamp=None,
AddressesToValidate=[
AddressToValidate(
ClientReferenceId=None,
Contact=Contact(ContactId=None,
PersonName=contact['person_name'],
Title=None,
CompanyName=contact['company_name'],
PhoneNumber=contact['phone_number'],
PhoneExtension=None,
TollFreePhoneNumber=None,
PagerNumber=None,
FaxNumber=None,
EMailAddress=contact['email']
) if any(contact.values()) else None,
Address=FedexAddress(
StreetLines=SF.concat_str(payload.address.address_line1,
payload.address.address_line2),
City=payload.address.city,
StateOrProvinceCode=payload.address.city,
PostalCode=payload.address.postal_code,
UrbanizationCode=None,
CountryCode=payload.address.country_code,
CountryName=None,
Residential="" if payload.address.residential else None,
),
)
],
))
return Serializable(
request,
default_request_serializer(
'v4', 'xmlns:v4="http://fedex.com/ws/addressvalidation/v4"'))
def pickup_request(payload: PickupRequest, settings: Settings) -> Serializable[Envelope]:
packages = Packages(payload.parcels)
request = create_envelope(
body_content=schedulePickupV2(
request=SchedulePickupV2Rq(
password=settings.password,
pickup=PickupV2(
collect=None,
comments=payload.instruction,
created_by=payload.address.person_name,
pickup_address=Address(
address_line_1=payload.address.address_line1,
address_line_2=payload.address.address_line2,
address_line_3=None,
attention=payload.address.person_name,
city=payload.address.city,
country=payload.address.country_code,
email=payload.address.email,
extension=None,
name=payload.address.company_name,
phone=payload.address.phone_number,
postal_code=payload.address.postal_code,
province=payload.address.state_code,
residential=payload.address.residential,
),
pickup_date=DF.fdatetime(
f"{payload.pickup_date} {payload.ready_time}", '%Y-%m-%d %H:%M', '%Y-%m-%dT%H:%M:%S'
),
pickup_location=payload.package_location,
pickup_phone=payload.address.phone_number,
shipper_num=None,
unit_of_measure=WeightUnit.LB.value,
weight=packages.weight.LB
),
user_id=settings.username
)
)
)
return Serializable(
request, partial(
settings.serialize,
extra_namespace='xmlns:xsd1="http://dto.canshipws.canpar.com/xsd"',
special_prefixes=dict(pickup_children='xsd1')
)
)
def pickup_rate_request(payload: PickupRequest,
settings: Settings) -> Serializable[Envelope]:
pickup_date = DF.date(payload.pickup_date)
same_day = pickup_date.date() == datetime.today().date()
request = create_envelope(
header_content=settings.Security,
body_content=PickupRateRequest(
Request=RequestType(),
ShipperAccount=None,
PickupAddress=PickupAddressType(
CompanyName=payload.address.company_name,
ContactName=payload.address.person_name,
AddressLine=SF.concat_str(payload.address.address_line1,
payload.address.address_line2),
Room=None,
Floor=None,
City=payload.address.city,
StateProvince=payload.address.state_code,
Urbanization=None,
PostalCode=payload.address.postal_code,
CountryCode=payload.address.country_code,
ResidentialIndicator=("Y"
if payload.address.residential else "N"),
PickupPoint=payload.package_location,
Phone=PhoneType(Number=payload.address.phone_number,
Extension=None)
if payload.address.phone_number is not None else None,
),
AlternateAddressIndicator="Y",
ServiceDateOption=("01" if same_day else "02"),
PickupDateInfo=PickupDateInfoType(
CloseTime=DF.ftime(payload.closing_time, "%H:%M", "%H%M"),
ReadyTime=DF.ftime(payload.ready_time, "%H:%M", "%H%M"),
PickupDate=pickup_date.strftime("%Y%m%d"),
),
TaxInformationIndicator=None,
UserLevelDiscountIndicator=None,
),
)
return Serializable(
request,
default_request_serializer(
"v11",
'xmlns:v11="http://www.ups.com/XMLSchema/XOLTWS/Pickup/v1.1"'),
)
def pickup_cancel_request(payload: PickupCancelRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(
header_content=RequestContext(
Version="1.2",
Language=settings.language,
GroupID="",
RequestReference="",
UserToken=settings.user_token,
),
body_content=VoidPickUpRequest(
PickUpConfirmationNumber=payload.confirmation_number),
)
return Serializable(request,
partial(standard_request_serializer, version="v1"))
def address_validation_request(payload: AddressValidationRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(body_content=searchCanadaPost(
request=SearchCanadaPostRq(
city=payload.address.city or "",
password=settings.password,
postal_code=payload.address.postal_code or "",
province=payload.address.state_code or "",
street_direction="",
street_name=SF.concat_str(payload.address.address_line1,
payload.address.address_line2,
join=True) or "",
street_num="",
street_type="",
user_id=settings.username,
validate_only=True)))
return Serializable(request, Settings.serialize)
def shipment_cancel_request(
payload: ShipmentCancelRequest, settings: Settings
) -> Serializable[Envelope]:
request = create_envelope(
header_content=settings.Security,
body_content=VoidShipmentRequest(
Request=RequestType(),
VoidShipment=VoidShipmentType(
ShipmentIdentificationNumber=payload.shipment_identifier,
TrackingNumber=None
)
),
)
return Serializable(
request,
default_request_serializer(
"void", 'xmlns:void="http://www.ups.com/XMLSchema/XOLTWS/Ship/v1.0"'
),
)
def address_validation_request(payload: AddressValidationRequest,
settings: Settings) -> Serializable[Envelope]:
request = create_envelope(
header_content=RequestContext(
Version="2.1",
Language=settings.language,
GroupID="",
RequestReference="",
UserToken=settings.user_token,
),
body_content=ValidateCityPostalCodeZipRequest(
Addresses=ArrayOfShortAddress(ShortAddress=[
ShortAddress(
City=payload.address.city,
Province=payload.address.state_code,
Country=payload.address.country_code,
PostalCode=payload.address.postal_code,
)
])))
return Serializable(request, standard_request_serializer)
def validate_pickup_request(payload: Union[PickupRequest, PickupUpdateRequest],
settings: Settings) -> Serializable[Envelope]:
"""
Create a serializable typed Envelope containing a ValidatePickUpRequest
Options:
- LoadingDockAvailable
- TrailerAccessible
:param payload: PickupRequest
:param settings: Settings
:return: Serializable[PickupRequest]
"""
packages = Packages(payload.parcels, PackagePresets, required=["weight"])
phone = Phone(payload.address.phone_number, payload.address.country_code
or 'CA')
request = create_envelope(
header_content=RequestContext(
Version="1.2",
Language=settings.language,
GroupID="",
RequestReference="",
UserToken=settings.user_token,
),
body_content=ValidatePickUpRequest(
BillingAccountNumber=settings.account_number,
PartnerID=None,
PickupInstruction=PickupInstruction(
Date=payload.pickup_date,
AnyTimeAfter="".join(payload.ready_time.split(":")),
UntilTime="".join(payload.closing_time.split(":")),
TotalWeight=Weight(Value=packages.weight.LB,
WeightUnit=WeightUnit.LB.value),
TotalPieces=len(packages) or 1,
BoxesIndicator=None,
PickUpLocation=payload.package_location,
AdditionalInstructions=payload.instruction,
SupplyRequestCodes=None,
TrailerAccessible=payload.options.get("TrailerAccessible"),
LoadingDockAvailable=payload.options.get(
"LoadingDockAvailable"),
ShipmentOnSkids=None,
NumberOfSkids=None,
),
Address=Address(
Name=payload.address.person_name or "",
Company=payload.address.company_name,
Department=None,
StreetNumber="",
StreetSuffix=None,
StreetName=SF.concat_str(payload.address.address_line1,
join=True),
StreetType=None,
StreetDirection=None,
Suite=None,
Floor=None,
StreetAddress2=SF.concat_str(payload.address.address_line2,
join=True),
StreetAddress3=None,
City=payload.address.city,
Province=payload.address.state_code,
Country=payload.address.country_code,
PostalCode=payload.address.postal_code,
PhoneNumber=PhoneNumber(
CountryCode=phone.country_code or "0",
AreaCode=phone.area_code or "0",
Phone=phone.phone or "0",
Extension=None,
),
FaxNumber=None,
),
ShipmentSummary=None,
NotificationEmails=NotificationEmails(
NotificationEmail=[payload.address.email]),
),
)
return Serializable(request,
partial(standard_request_serializer, version="v1"))
def rate_request(payload: RateRequest,
settings: Settings) -> Serializable[UPSRateRequest]:
packages = Packages(payload.parcels, PackagePresets)
is_document = all([parcel.is_document for parcel in payload.parcels])
service = Services(payload.services, ServiceCode).first
mps_packaging = PackagingType.ups_unknown.value if len(
packages) > 1 else None
request = UPSRateRequest(
Request=RequestType(
RequestOption=["Shop", "Rate"],
SubVersion=None,
TransactionReference=TransactionReferenceType(
CustomerContext=payload.reference,
TransactionIdentifier=getattr(payload, 'id', None)),
),
PickupType=None,
CustomerClassification=None,
Shipment=ShipmentType(
OriginRecordTransactionTimestamp=None,
Shipper=ShipperType(
Name=payload.shipper.company_name,
ShipperNumber=settings.account_number,
Address=ShipAddressType(
AddressLine=SF.concat_str(
payload.recipient.address_line1,
payload.recipient.address_line2,
),
City=payload.shipper.city,
StateProvinceCode=payload.shipper.state_code,
PostalCode=payload.shipper.postal_code,
CountryCode=payload.shipper.country_code,
),
),
ShipTo=ShipToType(
Name=payload.recipient.company_name,
Address=ShipToAddressType(
AddressLine=SF.concat_str(
payload.recipient.address_line1,
payload.recipient.address_line2,
),
City=payload.recipient.city,
StateProvinceCode=payload.recipient.state_code,
PostalCode=payload.recipient.postal_code,
CountryCode=payload.recipient.country_code,
ResidentialAddressIndicator=None,
),
),
ShipFrom=None,
AlternateDeliveryAddress=None,
ShipmentIndicationType=None,
PaymentDetails=None,
FRSPaymentInformation=None,
FreightShipmentInformation=None,
GoodsNotInFreeCirculationIndicator=None,
Service=(UOMCodeDescriptionType(Code=service.value,
Description=None)
if service is not None else None),
NumOfPieces=None, # Only required for Freight
ShipmentTotalWeight=
None, # Only required for "timeintransit" requests
DocumentsOnlyIndicator=("" if is_document else None),
Package=[
PackageType(
PackagingType=UOMCodeDescriptionType(
Code=(mps_packaging
or PackagingType[package.packaging_type
or "your_packaging"].value),
Description=None,
),
Dimensions=(DimensionsType(
UnitOfMeasurement=UOMCodeDescriptionType(
Code=package.dimension_unit.value,
Description=None),
Length=package.length.value,
Width=package.width.value,
Height=package.height.value,
) if any([
package.length.value,
package.height.value,
package.width.value,
]) else None),
DimWeight=None,
PackageWeight=PackageWeightType(
UnitOfMeasurement=UOMCodeDescriptionType(
Code=UPSWeightUnit[package.weight_unit.name].value,
Description=None,
),
Weight=package.weight.value,
) if package.weight.value else None,
Commodity=None,
PackageServiceOptions=None,
AdditionalHandlingIndicator=None,
) for package in packages
],
ShipmentServiceOptions=None,
ShipmentRatingOptions=ShipmentRatingOptionsType(
NegotiatedRatesIndicator=""),
InvoiceLineTotal=None,
RatingMethodRequestedIndicator=None,
TaxInformationIndicator=None,
PromotionalDiscountInformation=None,
DeliveryTimeInformation=TimeInTransitRequestType(
PackageBillType="02" if is_document else "03"),
),
)
return Serializable(
create_envelope(header_content=settings.Security,
body_content=request),
_request_serializer,
)
def shipment_request(payload: ShipmentRequest,
settings: Settings) -> Serializable[UPSShipmentRequest]:
packages = Packages(payload.parcels, PackagePresets)
is_document = all([parcel.is_document for parcel in payload.parcels])
package_description = packages[0].parcel.description if len(
packages) == 1 else None
options = Options(payload.options)
service = ShippingServiceCode[payload.service].value
if any(key in service for key in ["freight", "ground"]):
packages.validate(required=["weight"])
charges: Dict[str, Payment] = {
"01": payload.payment,
"02": payload.customs.duty if payload.customs is not None else None,
}
mps_packaging = (ShippingPackagingType.your_packaging.value
if len(packages) > 1 else None)
label_format, label_height, label_width = LabelType[payload.label_type
or 'PDF_6x4'].value
request = UPSShipmentRequest(
Request=common.RequestType(
RequestOption=["validate"],
SubVersion=None,
TransactionReference=common.TransactionReferenceType(
CustomerContext=payload.reference, TransactionIdentifier=None),
),
Shipment=ShipmentType(
Description=package_description,
DocumentsOnlyIndicator="" if is_document else None,
Shipper=ShipperType(
Name=payload.shipper.company_name,
AttentionName=payload.shipper.person_name,
CompanyDisplayableName=None,
TaxIdentificationNumber=payload.shipper.federal_tax_id,
TaxIDType=None,
Phone=(ShipPhoneType(Number=payload.shipper.phone_number,
Extension=None)
if payload.shipper.phone_number is not None else None),
ShipperNumber=settings.account_number,
FaxNumber=None,
EMailAddress=payload.shipper.email,
Address=ShipAddressType(
AddressLine=SF.concat_str(payload.shipper.address_line1,
payload.shipper.address_line2),
City=payload.shipper.city,
StateProvinceCode=payload.shipper.state_code,
PostalCode=payload.shipper.postal_code,
CountryCode=payload.shipper.country_code,
),
),
ShipTo=ShipToType(
Name=payload.recipient.company_name,
AttentionName=payload.recipient.person_name,
CompanyDisplayableName=None,
TaxIdentificationNumber=payload.recipient.federal_tax_id,
TaxIDType=None,
Phone=(ShipPhoneType(Number=payload.recipient.phone_number,
Extension=None) if
payload.recipient.phone_number is not None else None),
FaxNumber=None,
EMailAddress=payload.recipient.email,
Address=ShipAddressType(
AddressLine=SF.concat_str(
payload.recipient.address_line1,
payload.recipient.address_line2,
),
City=payload.recipient.city,
StateProvinceCode=payload.recipient.state_code,
PostalCode=payload.recipient.postal_code,
CountryCode=payload.recipient.country_code,
),
),
PaymentInformation=PaymentInfoType(
ShipmentCharge=[
ShipmentChargeType(
Type=charge_type,
BillShipper=BillShipperType(
AccountNumber=settings.account_number,
CreditCard=None,
AlternatePaymentMethod=None,
) if payment.paid_by == PaymentType.sender.name else
None,
BillReceiver=BillReceiverType(
AccountNumber=payment.account_number,
Address=BillReceiverAddressType(
PostalCode=payload.recipient.postal_code),
) if payment.paid_by == PaymentType.recipient.name else
None,
BillThirdParty=BillThirdPartyChargeType(
AccountNumber=payment.account_number, ) if payment.
paid_by == PaymentType.third_party.name else None,
ConsigneeBilledIndicator=None,
) for charge_type, payment in charges.items()
if payment is not None
],
SplitDutyVATIndicator=None,
) if any(charges.values()) else None,
Service=(ServiceType(
Code=service) if service is not None else None),
ShipmentServiceOptions=(ShipmentServiceOptionsType(
COD=(CODType(
CODFundsCode=None,
CODAmount=CurrencyMonetaryType(
CurrencyCode=options.currency or "USD",
MonetaryValue=options.cash_on_delivery,
),
) if options.cash_on_delivery else None),
Notification=([
NotificationType(
NotificationCode=event,
EMail=EmailDetailsType(EMailAddress=[
options.notification_email
or payload.recipient.email
]),
VoiceMessage=None,
TextMessage=None,
Locale=None,
) for event in [8]
] if options.notification_email is not None else None),
) if any([options.cash_on_delivery, options.notification_email])
else None),
Package=[
PackageType(
Description=package.parcel.description,
Packaging=PackagingType(
Code=mps_packaging or ShippingPackagingType[
package.packaging_type or "your_packaging"].value),
Dimensions=DimensionsType(
UnitOfMeasurement=ShipUnitOfMeasurementType(
Code=package.dimension_unit.value, ),
Length=package.length.value,
Width=package.width.value,
Height=package.height.value,
),
PackageWeight=PackageWeightType(
UnitOfMeasurement=ShipUnitOfMeasurementType(
Code=UPSWeightUnit[
package.weight_unit.name].value, ),
Weight=package.weight.value,
),
) for package in packages
],
),
LabelSpecification=LabelSpecificationType(
LabelImageFormat=LabelImageFormatType(Code=label_format,
Description=None),
HTTPUserAgent=None,
LabelStockSize=LabelStockSizeType(Height=label_height,
Width=label_width),
Instruction=None,
CharacterSet=None,
),
ReceiptSpecification=None,
)
return Serializable(
create_envelope(header_content=settings.Security,
body_content=request),
_request_serializer,
)
def rate_request(payload: RateRequest,
settings: Settings) -> Serializable[Envelope]:
packages = Packages(payload.parcels)
service_type = Services(payload.services, Service).first
options = Options(payload.options, Option)
shipment_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')
premium: Optional[bool] = next((True
for option, _ in options if option in [
Option.canpar_ten_am.name,
Option.canpar_noon.name,
Option.canpar_saturday.name,
]), None)
nsr = next(
(Option[o].value for o in
['canpar_no_signature_required', 'canpar_not_no_signature_required']
if o in options), None)
request = create_envelope(body_content=rateShipment(request=RateShipmentRq(
apply_association_discount=False,
apply_individual_discount=False,
apply_invoice_discount=False,
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=nsr,
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=options['canpar_extra_care']) 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.value,
shipper_num=None,
shipping_date=shipment_date,
subtotal=None,
subtotal_with_handling=None,
total=None,
total_with_handling=None,
user_id=None,
),
user_id=settings.username)))
return Serializable(
request,
partial(
settings.serialize,
extra_namespace='xmlns:xsd1="http://dto.canshipws.canpar.com/xsd"',
special_prefixes=dict(shipment_children='xsd1')))
def _create_pickup_request(
payload: PickupRequest, settings: Settings
) -> Serializable[Envelope]:
packages = Packages(payload.parcels, PackagePresets)
has_overweight = any(package for package in packages if package.weight.KG > 32)
request = create_envelope(
header_content=settings.Security,
body_content=PickupCreationRequest(
Request=RequestType(),
RatePickupIndicator="N",
TaxInformationIndicator=None,
UserLevelDiscountIndicator=None,
Shipper=ShipperType(
Account=AccountType(
AccountNumber=settings.account_number,
AccountCountryCode=payload.address.country_code or "",
),
ChargeCard=None,
TaxInformation=None,
),
PickupDateInfo=PickupDateInfoType(
CloseTime=DF.ftime(payload.closing_time, "%H:%M", "%H%M"),
ReadyTime=DF.ftime(payload.ready_time, "%H:%M", "%H%M"),
PickupDate=DF.date(payload.pickup_date).strftime("%Y%m%d"),
),
PickupAddress=PickupAddressType(
CompanyName=payload.address.company_name,
ContactName=payload.address.person_name,
AddressLine=SF.concat_str(
payload.address.address_line1, payload.address.address_line2
),
Room=None,
Floor=None,
City=payload.address.city,
StateProvince=payload.address.state_code,
Urbanization=None,
PostalCode=payload.address.postal_code,
CountryCode=payload.address.country_code,
ResidentialIndicator=("Y" if payload.address.residential else "N"),
PickupPoint=payload.package_location,
Phone=PhoneType(Number=payload.address.phone_number, Extension=None)
if payload.address.phone_number is not None
else None,
),
AlternateAddressIndicator="Y",
PickupPiece=None,
TotalWeight=WeightType(
Weight=packages.weight.LB, UnitOfMeasurement=WeightUnit.LB.value
),
OverweightIndicator=("Y" if has_overweight else "N"),
TrackingData=None,
TrackingDataWithReferenceNumber=None,
PaymentMethod="01",
SpecialInstruction=payload.instruction,
ReferenceNumber=None,
FreightOptions=None,
ServiceCategory=None,
CashType=None,
ShippingLabelsAvailable="Y",
),
)
return Serializable(
request,
default_request_serializer(
"v11", 'xmlns:v11="http://www.ups.com/XMLSchema/XOLTWS/Pickup/v1.1"'
),
)
