def parse_address_validation_response(
response: Element,
settings: Settings) -> Tuple[AddressValidationDetails, List[Message]]:
errors = parse_error_response(response, settings)
address_node = next(
iter(response.xpath(".//*[local-name() = $name]", name="address")),
None)
address = XP.to_object(CanparAddress, address_node)
success = len(errors) == 0
validation_details = AddressValidationDetails(
carrier_id=settings.carrier_id,
carrier_name=settings.carrier_name,
success=success,
complete_address=Address(postal_code=address.postal_code,
city=address.city,
company_name=address.name,
country_code=address.country,
email=address.email,
state_code=address.province,
residential=address.residential,
address_line1=address.address_line_1,
address_line2=SF.concat_str(
address.address_line_2,
address.address_line_3,
join=True))) if success else None
return validation_details, errors
def parse_address_validation_response(
response: Element,
settings: Settings) -> Tuple[AddressValidationDetails, List[Message]]:
errors = parse_error_response(response, settings)
reply = XP.to_object(
ValidateCityPostalCodeZipResponse,
next(
iter(
response.xpath(".//*[local-name() = $name]",
name="ValidateCityPostalCodeZipResponse")),
None))
address: ShortAddress = next(
(result.Address
for result in reply.SuggestedAddresses.SuggestedAddress), None)
success = len(errors) == 0
validation_details = AddressValidationDetails(
carrier_id=settings.carrier_id,
carrier_name=settings.carrier_name,
success=success,
complete_address=Address(city=address.City,
state_code=address.Province,
country_code=address.Country,
postal_code=address.PostalCode)
if address is not None else None) if success else None
return validation_details, errors
def parse_address_validation_response(
response: Element,
settings: Settings) -> Tuple[AddressValidationDetails, List[Message]]:
reply = XP.build(
AddressValidationReply,
next(
iter(
response.xpath(".//*[local-name() = $name]",
name="AddressValidationReply")), None))
address: FedexAddress = next(
(result.EffectiveAddress for result in reply.AddressResults), None)
success = reply.HighestSeverity == NotificationSeverityType.SUCCESS.value
_, lines = (address.StreetLines if address is not None
and len(address.StreetLines) > 1 else ["", ""])
validation_details = AddressValidationDetails(
carrier_id=settings.carrier_id,
carrier_name=settings.carrier_name,
success=success,
complete_address=Address(city=address.City,
state_code=address.StateOrProvinceCode,
country_code=address.CountryCode,
residential=address.Residential,
address_line1=next(iter(address.StreetLines),
None),
address_line2=SF.concat_str(lines, join=True))
if address is not None else None) if success else None
return validation_details, parse_error_response(response, settings)
def shipment_request(payload: ShipmentRequest,
settings: Settings) -> Serializable[DicomShipmentRequest]:
packages = Packages(payload.parcels)
is_international = payload.shipper.country_code != payload.recipient.country_code
broker_info = payload.options.get('dicom_broker_info', {})
importer_info = (Address(**payload.options.get('importer_info'))
if 'importer_info' in payload.options else None)
delivery_type = Service[payload.service].value
options = {
key: (value if Option[key].value in ['DCV', 'COD'] else None)
for key, value in payload.options if key in Option.__members__
}
request = DicomShipmentRequest(
paymentType=PaymentType[payload.payment.paid_by or "prepaid"].value,
billingAccount=settings.billing_account,
sender=DicomAddress(city=payload.shipper.city,
provinceCode=payload.shipper.state_code,
postalCode=payload.shipper.postal_code,
countryCode=payload.shipper.country_code,
customerName=payload.shipper.company_name,
addressLine1=payload.shipper.address_line1,
addressLine2=payload.shipper.address_line2,
contact=Contact(
fullName=payload.shipper.person_name,
email=payload.shipper.email,
telephone=payload.shipper.phone_number)),
consignee=DicomAddress(city=payload.recipient.city,
provinceCode=payload.recipient.state_code,
postalCode=payload.recipient.postal_code,
countryCode=payload.recipient.country_code,
customerName=payload.recipient.company_name,
addressLine1=payload.recipient.address_line1,
addressLine2=payload.recipient.address_line2,
contact=Contact(
fullName=payload.recipient.person_name,
email=payload.recipient.email,
telephone=payload.recipient.phone_number)),
parcels=[
Parcel(
quantity=1,
parcelType=ParcelType[package.packaging_type
or "dicom_box"].value,
weight=package.weight.KG,
length=package.height.CM,
depth=package.length.CM,
width=package.width.CM,
note=None,
status=None,
FCAClass=None,
hazmat=None,
requestReturnLabel=None,
returnWaybill=None,
) for package in packages
],
note=None,
category="Parcel",
pickupDate=None,
deliveryType=delivery_type,
trackingNumber=None,
unitOfMeasurement=UnitOfMeasurement.KC.value,
surcharges=[
Surcharge(type=key, value=value) for key, value in options.items()
],
promoCodes=None,
references=None,
returnAddress=None,
appointment=None,
internationalDetails=(InternationalDetails(
isDicomBroker=(broker_info is not None),
descriptionOfGoods=payload.customs.content_description,
dutyBilling=payload.customs.duty.paid_by,
importerOfRecord=(DicomAddress(
city=importer_info.city,
provinceCode=importer_info.state_code,
postalCode=importer_info.postal_code,
countryCode=importer_info.country_code,
customerName=importer_info.company_name,
addressLine1=importer_info.address_line1,
addressLine2=importer_info.address_line2,
contact=Contact(fullName=importer_info.person_name,
email=importer_info.email,
telephone=importer_info.phone_number))
if importer_info is not None else None),
broker=(Broker(
id=broker_info.get("id"),
CSA_BusinessNumber=broker_info.get("CSA_BusinessNumber"),
otherBroker=broker_info.get("otherBroker"))
if broker_info is not None else None),
purpose=(Purpose[payload.customs.content_type].value
if payload.customs.content_type is not None else None),
products=[
Product(id=index, Quantity=product.quantity)
for index, product in enumerate(payload.customs.commodities, 1)
]) if is_international and payload.customs is not None else None),
)
return Serializable(request)
def shipment_request(
payload: ShipmentRequest,
settings: Settings) -> Serializable[eVSPriorityMailIntlRequest]:
package = Packages(payload.parcels,
max_weight=Weight(70, WeightUnit.LB)).single
options = Options(payload.options, ShipmentOption)
label_format = LabelFormat[payload.label_type or 'usps_6_x_4_label'].value
extra_services = [
getattr(option, 'value', option) for key, option in options
if 'usps_option' not in key
]
customs = payload.customs or Customs(commodities=[])
insurance = getattr(
(options['usps_insurance_priority_mail_international']), 'value',
options.insurance)
# Gets the first provided non delivery option or default to "RETURN"
non_delivery = next(
(option.value for name, option in options if 'non_delivery' in name),
"RETURN")
redirect_address = Address(
**(options['usps_option_redirect_non_delivery'] or {}))
request = eVSPriorityMailIntlRequest(
USERID=settings.username,
Option=None,
Revision=2,
ImageParameters=ImageParametersType(ImageParameter=label_format),
FromFirstName=customs.signer or payload.shipper.person_name or "N/A",
FromMiddleInitial=None,
FromLastName=payload.shipper.person_name,
FromFirm=payload.shipper.company_name or "N/A",
FromAddress1=payload.shipper.address_line1,
FromAddress2=payload.shipper.address_line2,
FromUrbanization=None,
FromCity=payload.shipper.city,
FromState=Location(payload.shipper.state_code,
country='US').as_state_name,
FromZip5=Location(payload.shipper.postal_code).as_zip5,
FromZip4=Location(payload.shipper.postal_code).as_zip4,
FromPhone=payload.shipper.phone_number,
FromCustomsReference=None,
ToName=None,
ToFirstName=payload.recipient.person_name,
ToLastName=None,
ToFirm=payload.recipient.company_name or "N/A",
ToAddress1=payload.recipient.address_line1,
ToAddress2=payload.recipient.address_line2,
ToAddress3=None,
ToCity=payload.recipient.city,
ToProvince=payload.recipient.state_code,
ToCountry=Location(payload.recipient.country_code).as_country_name,
ToPostalCode=payload.recipient.postal_code,
ToPOBoxFlag=None,
ToPhone=payload.recipient.phone_number,
ToFax=None,
ToEmail=payload.recipient.email,
ImportersReferenceNumber=None,
NonDeliveryOption=non_delivery,
RedirectName=redirect_address.person_name,
RedirectEmail=redirect_address.email,
RedirectSMS=redirect_address.phone_number,
RedirectAddress=SF.concat_str(redirect_address.address_line1,
redirect_address.address_line2,
join=True),
RedirectCity=redirect_address.city,
RedirectState=redirect_address.state_code,
RedirectZipCode=redirect_address.postal_code,
RedirectZip4=Location(redirect_address.postal_code).as_zip4,
Container=None,
ShippingContents=ShippingContentsType(ItemDetail=[
ItemDetailType(
Description=item.description,
Quantity=item.quantity,
Value=item.value_amount,
NetPounds=Weight(item.weight, WeightUnit[item.weight_unit
or 'LB']).LB,
NetOunces=Weight(item.weight, WeightUnit[item.weight_unit
or 'LB']).OZ,
HSTariffNumber=item.sku,
CountryOfOrigin=Location(item.origin_country).as_country_name)
for item in payload.customs.commodities
]),
Insured=('N' if insurance is None else 'Y'),
InsuredAmount=insurance,
GrossPounds=package.weight.LB,
GrossOunces=package.weight.OZ,
ContentType=ContentType[customs.content_type or "other"].value,
ContentTypeOther=customs.content_description or "N/A",
Agreement=('N' if customs.certify else 'Y'),
Comments=customs.content_description,
LicenseNumber=customs.license_number,
CertificateNumber=customs.certificate_number,
InvoiceNumber=customs.invoice,
ImageType="PDF",
ImageLayout="ALLINONEFILE",
CustomerRefNo=None,
CustomerRefNo2=None,
POZipCode=None,
LabelDate=DF.fdatetime(options.shipment_date,
output_format="%m/%d/%Y"),
EMCAAccount=None,
HoldForManifest=None,
EELPFC=customs.eel_pfc,
PriceOptions=None,
Length=package.length.IN,
Width=package.weight.IN,
Height=package.height.IN,
Girth=(package.girth.value
if package.packaging_type == "tube" else None),
ExtraServices=(ExtraServicesType(ExtraService=[
getattr(option, 'value', option) for option in extra_services
]) if any(extra_services) else None),
ActionCode=None,
OptOutOfSPE=None,
PermitNumber=None,
AccountZipCode=None,
ImportersReferenceType=None,
ImportersTelephoneNumber=None,
ImportersFaxNumber=None,
ImportersEmail=None,
Machinable=options["usps_option_machinable_item"],
DestinationRateIndicator="I",
MID=None,
LogisticsManagerMID=None,
CRID=None,
VendorCode=None,
VendorProductVersionNumber=None,
ChargebackCode=None,
)
return Serializable(request, XP.export)
def shipment_request(payload: ShipmentRequest,
settings: Settings) -> Serializable[eVSRequest]:
if payload.shipper.country_code is not None and payload.shipper.country_code != Country.US.name:
raise OriginNotServicedError(payload.shipper.country_code)
if payload.recipient.country_code is not None and payload.recipient.country_code != Country.US.name:
raise DestinationNotServicedError(payload.recipient.country_code)
service = ServiceType[payload.service].value
package = Packages(payload.parcels).single
options = Options(payload.options, ShipmentOption)
customs = payload.customs or Customs(commodities=[])
extra_services = [
getattr(option, 'value', option) for key, option in options
if 'usps_option' not in key
]
label_format = LabelFormat[payload.label_type or 'usps_6_x_4_label'].value
insurance = next(
(option.value for key, option in options if 'usps_insurance' in key),
options.insurance)
# Gets the first provided non delivery option or default to "RETURN"
non_delivery = next(
(option.value for name, option in options if 'non_delivery' in name),
"RETURN")
redirect_address = Address(
**(options['usps_option_redirect_non_delivery'] or {}))
request = eVSRequest(
USERID=settings.username,
Option=None,
Revision="1",
ImageParameters=ImageParametersType(ImageParameter=label_format,
LabelSequence=LabelSequenceType(
PackageNumber=1,
TotalPackages=1)),
FromName=payload.shipper.person_name,
FromFirm=payload.shipper.company_name or "N/A",
FromAddress1=payload.shipper.address_line1,
FromAddress2=payload.shipper.address_line2,
FromCity=payload.shipper.city,
FromState=payload.shipper.state_code,
FromZip5=Location(payload.shipper.postal_code).as_zip5,
FromZip4=Location(payload.shipper.postal_code).as_zip4,
FromPhone=payload.shipper.phone_number,
POZipCode=None,
AllowNonCleansedOriginAddr=False,
ToName=payload.recipient.person_name,
ToFirm=payload.recipient.company_name or "N/A",
ToAddress1=payload.recipient.address_line1,
ToAddress2=payload.recipient.address_line2,
ToCity=payload.recipient.city,
ToState=payload.recipient.state_code,
ToZip5=Location(payload.recipient.postal_code).as_zip5,
ToZip4=Location(payload.recipient.postal_code).as_zip4,
ToPhone=payload.recipient.phone_number,
POBox=None,
ToContactPreference=None,
ToContactMessaging=payload.recipient.email,
ToContactEmail=payload.recipient.email,
AllowNonCleansedDestAddr=False,
WeightInOunces=package.weight.OZ,
ServiceType=service,
Container=PackagingType[package.packaging_type or 'variable'].value,
Width=package.width.IN,
Length=package.length.IN,
Height=package.height.IN,
Girth=(package.girth.value
if package.packaging_type == "tube" else None),
Machinable=options["usps_option_machinable_item"],
ProcessingCategory=None,
PriceOptions=None,
InsuredAmount=insurance,
AddressServiceRequested=None,
ExpressMailOptions=None,
ShipDate=options.shipment_date,
CustomerRefNo=None,
ExtraServices=(ExtraServicesType(ExtraService=[
getattr(option, 'value', option) for option in extra_services
]) if any(extra_services) else None),
CRID=None,
MID=None,
LogisticsManagerMID=None,
VendorCode=None,
VendorProductVersionNumber=None,
SenderName=(payload.shipper.person_name
or payload.shipper.company_name),
SenderEMail=payload.shipper.email,
RecipientName=(payload.recipient.person_name
or payload.recipient.company_name),
RecipientEMail=payload.recipient.email,
ReceiptOption="SEPARATE PAGE",
ImageType="PDF",
HoldForManifest=None,
NineDigitRoutingZip=None,
ShipInfo=options["usps_option_ship_info"],
CarrierRelease=None,
DropOffTime=None,
ReturnCommitments=None,
PrintCustomerRefNo=None,
Content=None,
ShippingContents=(ShippingContentsType(ItemDetail=[
ItemDetailType(
Description=item.description,
Quantity=item.quantity,
Value=item.value_amount,
NetPounds=Weight(item.weight, WeightUnit[item.weight_unit
or 'LB']).LB,
NetOunces=Weight(item.weight, WeightUnit[item.weight_unit
or 'LB']).OZ,
HSTariffNumber=item.sku,
CountryOfOrigin=Location(item.origin_country).as_country_name)
for item in customs.commodities
]) if payload.customs is not None else None),
CustomsContentType=ContentType[customs.content_type or "other"].value,
ContentComments=None,
RestrictionType=None,
RestrictionComments=None,
AESITN=customs.aes,
ImportersReference=None,
ImportersContact=None,
ExportersReference=None,
ExportersContact=None,
InvoiceNumber=customs.invoice,
LicenseNumber=customs.license_number,
CertificateNumber=customs.certificate_number,
NonDeliveryOption=non_delivery,
AltReturnAddress1=redirect_address.address_line1,
AltReturnAddress2=redirect_address.address_line2,
AltReturnAddress3=None,
AltReturnAddress4=None,
AltReturnAddress5=None,
AltReturnAddress6=None,
AltReturnCountry=None,
LabelImportType=None,
ChargebackCode=None,
TrackingRetentionPeriod=None,
)
return Serializable(request)