def shipment_request(payload: ShipmentRequest,
settings: Settings) -> Serializable[DHLShipmentRequest]:
if any(settings.account_country_code or "") and (
payload.shipper.country_code != settings.account_country_code):
raise OriginNotServicedError(payload.shipper.country_code)
packages = Packages.map(payload.parcels,
PackagePresets,
required=["weight"])
options = Options(payload.options, SpecialServiceCode)
product = ProductCode.map(payload.service).value_or_key
shipper = CompleteAddress.map(payload.shipper)
recipient = CompleteAddress.map(payload.recipient)
weight_unit, dim_unit = (COUNTRY_PREFERED_UNITS.get(
payload.shipper.country_code) or packages.compatible_units)
is_document = all(p.parcel.is_document for p in packages)
package_type = PackageType[packages.package_type].value
label_format, label_template = LabelType[payload.label_type
or 'PDF_6x4'].value
payment = (payload.payment
or Payment(paid_by="sender",
account_number=settings.account_number))
customs = (payload.customs or Customs(commodities=[]))
is_dutiable = (is_document is False and customs.duty is not None)
paperless_supported = (is_dutiable and payload.shipper.country_code
not in UNSUPPORTED_PAPERLESS_COUNTRIES)
duty = (customs.duty or Duty(paid_by="sender"))
bill_to = CompleteAddress.map(duty.bill_to)
content = (packages[0].parcel.content or customs.content_description
or "N/A")
reference = (payload.reference or getattr(payload, 'id', None))
request = DHLShipmentRequest(
schemaVersion='10.0',
Request=settings.Request(
MetaData=MetaData(SoftwareName="3PV", SoftwareVersion='10.0')),
RegionCode=CountryRegion[shipper.country_code].value,
LanguageCode="en",
LatinResponseInd=None,
Billing=Billing(
ShipperAccountNumber=settings.account_number,
ShippingPaymentType=PaymentType[payment.paid_by].value,
BillingAccountNumber=payment.account_number,
DutyAccountNumber=duty.account_number,
),
Consignee=Consignee(
CompanyName=recipient.company_name or "N/A",
SuiteDepartmentName=recipient.suite,
AddressLine1=recipient.address_line1 or recipient.address_line,
AddressLine2=SF.concat_str(recipient.address_line2, join=True),
AddressLine3=None,
City=recipient.city,
Division=None,
DivisionCode=recipient.state_code,
PostalCode=recipient.postal_code,
CountryCode=recipient.country_code,
CountryName=recipient.country_name,
Contact=Contact(
PersonName=recipient.person_name,
PhoneNumber=recipient.phone_number or "0000",
Email=recipient.email,
),
Suburb=recipient.suburb,
StreetName=recipient.street_name,
BuildingName=None,
StreetNumber=recipient.street_number,
RegistrationNumbers=None,
BusinessPartyTypeCode=None,
),
Commodity=([
Commodity(CommodityCode=c.sku, CommodityName=c.description)
for c in payload.customs.commodities
] if any(customs.commodities) else None),
Dutiable=(Dutiable(
DeclaredValue=duty.declared_value or options.declared_value or 1.0,
DeclaredCurrency=duty.currency or options.currency or "USD",
ScheduleB=None,
ExportLicense=customs.license_number,
ShipperEIN=None,
ShipperIDType=None,
TermsOfTrade=customs.incoterm,
CommerceLicensed=None,
Filing=None) if is_dutiable else None),
UseDHLInvoice=("Y" if is_dutiable else None),
DHLInvoiceLanguageCode=("en" if is_dutiable else None),
DHLInvoiceType=(("CMI" if customs.commercial_invoice else "PFI")
if is_dutiable else None),
ExportDeclaration=(ExportDeclaration(
InterConsignee=None,
IsPartiesRelation=None,
ECCN=None,
SignatureName=customs.signer,
SignatureTitle=None,
ExportReason=customs.content_type,
ExportReasonCode=ExportReasonCode[customs.content_type
or 'other'].value,
SedNumber=None,
SedNumberType=None,
MxStateCode=None,
InvoiceNumber=(customs.invoice or "N/A"),
InvoiceDate=(customs.invoice_date or time.strftime("%Y-%m-%d")),
BillToCompanyName=bill_to.company_name,
BillToContactName=bill_to.person_name,
BillToAddressLine=bill_to.address_line,
BillToCity=bill_to.city,
BillToPostcode=bill_to.postal_code,
BillToSuburb=bill_to.extra,
BillToCountryName=bill_to.country_name,
BillToPhoneNumber=bill_to.phone_number,
BillToPhoneNumberExtn=None,
BillToFaxNumber=None,
BillToFederalTaxID=bill_to.federal_tax_id,
Remarks=customs.content_description,
DestinationPort=None,
TermsOfPayment=None,
PayerGSTVAT=bill_to.state_tax_id,
SignatureImage=None,
ReceiverReference=None,
ExporterId=None,
ExporterCode=None,
ExportLineItem=[
ExportLineItem(
LineNumber=index,
Quantity=item.quantity,
QuantityUnit='PCS',
Description=item.description or 'N/A',
Value=((item.quantity or 1) * (item.value_amount or 0.0)),
IsDomestic=None,
CommodityCode=item.sku,
ScheduleB=None,
ECCN=None,
Weight=WeightType(
Weight=Weight(item.weight,
WeightUnit[item.weight_unit
or 'KG'])[weight_unit.name],
WeightUnit=DHLWeightUnit[weight_unit.name].value),
GrossWeight=WeightType(
Weight=Weight(item.weight,
WeightUnit[item.weight_unit
or 'KG'])[weight_unit.name],
WeightUnit=DHLWeightUnit[weight_unit.name].value),
License=None,
LicenseSymbol=None,
ManufactureCountryCode=item.origin_country,
ManufactureCountryName=Location(
item.origin_country).as_country_name,
ImportTaxManagedOutsideDhlExpress=None,
AdditionalInformation=None,
ImportCommodityCode=None,
ItemReferences=None,
CustomsPaperworks=None,
) for (index, item) in enumerate(customs.commodities, start=1)
],
ShipmentDocument=None,
InvoiceInstructions=None,
CustomerDataTextEntries=None,
PlaceOfIncoterm="N/A",
ShipmentPurpose=(
"COMMERCIAL" if customs.commercial_invoice else "PERSONAL"),
DocumentFunction=None,
CustomsDocuments=None,
InvoiceTotalNetWeight=None,
InvoiceTotalGrossWeight=None,
InvoiceReferences=None,
) if is_dutiable else None),
Reference=([Reference(
ReferenceID=reference)] if any([reference]) else None),
ShipmentDetails=DHLShipmentDetails(
Pieces=Pieces(Piece=[
Piece(
PieceID=index,
PackageType=(package_type
or PackageType[package.packaging_type
or "your_packaging"].value),
Depth=package.length.map(MeasurementOptions)[
dim_unit.name],
Width=package.width.map(MeasurementOptions)[dim_unit.name],
Height=package.height.map(MeasurementOptions)[
dim_unit.name],
Weight=package.weight[weight_unit.name],
PieceContents=(
package.parcel.content or package.parcel.description),
PieceReference=([Reference(
ReferenceID=package.parcel.id)] if package.parcel.
id is not None else None),
AdditionalInformation=(AdditionalInformation(
CustomerDescription=package.parcel.description
) if package.parcel.description is not None else None))
for (index, package) in enumerate(packages, start=1)
]),
WeightUnit=DHLWeightUnit[weight_unit.name].value,
GlobalProductCode=product,
LocalProductCode=product,
Date=(options.shipment_date or time.strftime("%Y-%m-%d")),
Contents=content,
DimensionUnit=DimensionUnit[dim_unit.name].value,
PackageType=package_type,
IsDutiable=("Y" if is_dutiable else "N"),
CurrencyCode=options.currency or "USD",
CustData=getattr(payload, 'id', None),
ShipmentCharges=(options.cash_on_delivery
if options.cash_on_delivery else None),
ParentShipmentIdentificationNumber=None,
ParentShipmentGlobalProductCode=None,
ParentShipmentPackagesCount=None,
),
Shipper=Shipper(
ShipperID=settings.account_number or "N/A",
CompanyName=shipper.company_name or "N/A",
SuiteDepartmentName=shipper.suite,
RegisteredAccount=settings.account_number,
AddressLine1=shipper.address_line1 or shipper.address_line,
AddressLine2=SF.concat_str(shipper.address_line2, join=True),
AddressLine3=None,
City=shipper.city,
Division=None,
DivisionCode=shipper.state_code,
PostalCode=shipper.postal_code,
OriginServiceAreaCode=None,
OriginFacilityCode=None,
CountryCode=shipper.country_code,
CountryName=shipper.country_name,
Contact=Contact(
PersonName=shipper.person_name,
PhoneNumber=shipper.phone_number or "0000",
Email=shipper.email,
),
Suburb=shipper.suburb,
StreetName=shipper.street_name,
BuildingName=None,
StreetNumber=shipper.street_number,
RegistrationNumbers=None,
BusinessPartyTypeCode=None,
),
SpecialService=([
SpecialService(
SpecialServiceType=SpecialServiceCode[key].value.key,
ChargeValue=getattr(svc, 'value', None),
CurrencyCode=(options.currency or "USD" if hasattr(
svc, 'value') else None))
for key, svc in options if key in SpecialServiceCode
] + ( # Add paperless trade if dutiable
[SpecialService(SpecialServiceType="WY")] if paperless_supported
and 'dhl_paperless_trade' not in options else [])),
Notification=(Notification(
EmailAddress=options.email_notification_to or recipient.email)
if options.email_notification
and any([options.email_notification_to, recipient.email])
else None),
Place=None,
EProcShip=None,
Airwaybill=None,
DocImages=None,
LabelImageFormat=label_format,
RequestArchiveDoc=None,
NumberOfArchiveDoc=None,
RequestQRCode='N',
RequestTransportLabel=None,
Label=Label(LabelTemplate=label_template),
ODDLinkReq=None,
DGs=None,
GetPriceEstimate='Y',
SinglePieceImage='N',
ShipmentIdentificationNumber=None,
UseOwnShipmentIdentificationNumber='N',
Importer=None,
)
return Serializable(request, _request_serializer)
def shipment_request(
payload: ShipmentRequest,
settings: Settings) -> Serializable[eVSGXGGetLabelRequest]:
package = Packages(payload.parcels,
max_weight=Weight(70, WeightUnit.LB)).single
options = Options(payload.options, ShipmentOption)
customs = payload.customs or Customs(commodities=[])
incoterm = Incoterm[customs.incoterm or 'OTHER'].value
insurance = getattr((options['usps_insurance_global_express_guaranteed']),
'value', options.insurance)
request = eVSGXGGetLabelRequest(
USERID=settings.username,
PASSWORD=settings.password,
Option=None,
Revision=2,
ImageParameters=None,
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,
ShipFromZIP=None,
ToFirstName=None,
ToLastName=payload.recipient.person_name,
ToFirm=payload.recipient.company_name or "N/A",
ToAddress1=payload.recipient.address_line1,
ToAddress2=payload.recipient.address_line2,
ToAddress3=None,
ToPostalCode=payload.recipient.postal_code,
ToPhone=payload.recipient.phone_number,
RecipientEMail=payload.recipient.email,
ToDPID="000", # supposedly required test and find a solution
ToProvince=payload.recipient.state_code,
ToTaxID=(payload.recipient.federal_tax_id
or payload.recipient.state_tax_id),
Container=PackagingType[package.packaging_type or 'package'].value,
ContentType=('DOCUMENTS' if package.parcel.is_document else 'NON-DOC'),
ShippingContents=ShippingContentsType(ItemDetail=[
ItemDetailType(
Description=item.description,
Commodity=item.description or "N/A",
Quantity=item.quantity,
UnitValue=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,
UnitOfMeasure=None,
HSTariffNumber=item.sku,
CountryofManufacture=Location(
item.origin_country).as_country_name)
for item in payload.customs.commodities
]),
PurposeOfShipment=ContentType[customs.content_type or 'other'],
PartiesToTransaction=None,
Agreement=('N' if customs.certify else 'Y'),
Postage=None,
InsuredValue=insurance,
GrossPounds=package.weight.LB,
GrossOunces=package.weight.OZ,
Length=package.length.IN,
Width=package.weight.IN,
Height=package.height.IN,
Girth=(package.girth.value
if package.packaging_type == "tube" else None),
Shape=None,
CIRequired=customs.commercial_invoice,
InvoiceDate=None,
InvoiceNumber=customs.invoice,
CustomerOrderNumber=None,
CustOrderNumber=None,
TermsDelivery=incoterm,
TermsDeliveryOther=((customs.incoterm or incoterm)
if incoterm == 'OTHER' else None),
PackingCost=None,
CountryUltDest=Location(
payload.recipient.country_code).as_country_name,
CIAgreement=customs.commercial_invoice,
ImageType="PDF",
ImageLayout=None,
CustomerRefNo=None,
CustomerRefNo2=None,
ShipDate=DF.fdatetime((options.shipment_date or datetime.now()),
output_format="%m/%d/%Y"),
HoldForManifest=None,
PriceOptions=None,
CommercialShipment=customs.commercial_invoice,
BuyerRecipient=(
customs.commercial_invoice
or None), # Consider recipient as buyer for commercial shipment
TermsPayment=("Net 50" if customs.commercial_invoice else None),
ActionCode=None,
OptOutOfSPE=None,
PermitNumber=None,
AccountZipCode=None,
Machinable=options['usps_option_machinable_item'],
DestinationRateIndicator="I",
MID=None,
LogisticsManagerMID=None,
CRID=None,
VendorCode=None,
VendorProductVersionNumber=None,
OverrideMID=None,
ChargebackCode=None,
)
return Serializable(request, XP.export)
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[ShippingRequest]:
package = Packages(payload.parcels).single
options = Options(payload.options, Option)
product_code = Service.map(payload.service).value_or_key
unique_id = getattr(payload, 'id', uuid4().hex)
customs = payload.customs or Customs(commodities=[])
request = ShippingRequest(
accountNumber=settings.account_number,
subAccountNumber=options.asendia_sub_account_number,
processingLocation=ProcessingLocation.map(
options.asendia_processing_location or "SFO").name,
includeRate=True,
labelType=LabelType.map(payload.label_type or "PDF").name_or_key,
orderNumber=unique_id,
dispatchNumber=unique_id,
packageID=unique_id,
recipientTaxID=payload.recipient.state_tax_id,
returnFirstName=payload.shipper.person_name,
returnLastName=payload.shipper.person_name,
returnCompanyName=payload.shipper.company_name,
returnAddressLine1=payload.shipper.address_line1,
returnAddressLine2=payload.shipper.address_line2,
returnAddressLine3=None,
returnProvince=payload.shipper.state_code,
returnPostalCode=payload.shipper.postal_code,
returnCountryCode=payload.shipper.country_code,
returnPhone=payload.shipper.phone_number,
returnEmail=payload.shipper.email,
recipientFirstName=payload.recipient.person_name,
recipientLastName=payload.recipient.person_name,
recipientBusinessName=payload.recipient.company_name,
recipientAddressLine1=payload.recipient.address_line1,
recipientAddressLine2=payload.recipient.address_line2,
recipientAddressLine3=None,
recipientCity=payload.recipient.city,
recipientProvince=payload.recipient.state_code,
recipientPostalCode=payload.recipient.postal_code,
recipientPhone=payload.recipient.phone_number,
recipientEmail=payload.recipient.email,
totalPackageWeight=package.weight.value,
weightUnit=package.weight_unit.value.lower(),
dimLength=package.length.value,
dimWidth=package.width.value,
dimHeight=package.height.value,
dimUnit=package.dimension_unit.value,
totalPackageValue=options.declared_value,
currencyType=options.currency,
productCode=product_code,
customerReferenceNumber1=payload.reference,
customerReferenceNumber2=None,
customerReferenceNumber3=None,
contentType=("D" if package.parcel.is_document else "M"),
packageContentDescription=package.parcel.description,
vatNumber=None,
sellerName=payload.shipper.person_name,
sellerAddressLine1=payload.shipper.address_line1,
sellerAddressLine2=payload.shipper.address_line2,
sellerAddressLine3=None,
sellerProvince=payload.shipper.state_code,
sellerPostalCode=payload.shipper.postal_code,
sellerPhone=payload.shipper.phone_number,
sellerEmail=payload.shipper.email,
items=[
Item(sku=item.sku,
itemDescription=item.description,
unitPrice=item.value_amount,
quantity=item.quantity,
unitWeight=Weight(item.weight, package.weight_unit).value,
countryOfOrigin=item.origin_country,
htsNumber=None) for item in customs.commodities
])
return Serializable(request)
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)
def shipment_request(
payload: ShipmentRequest, settings: Settings
) -> Serializable[DHLShipmentRequest]:
packages = Packages(payload.parcels, PackagePresets, required=["weight"])
options = Options(payload.options, SpecialServiceCode)
product = next(
(p.value for p in ProductCode if payload.service == p.name),
payload.service
)
insurance = options['dhl_shipment_insurance'].value if 'dhl_shipment_insurance' in options else None
package_type = (
PackageType[packages[0].packaging_type or "your_packaging"].value
if len(packages) == 1 else None
)
delivery_type = next(
(d for d in DeliveryType if d.name in payload.options.keys()), None
)
label_format, label_template = LabelType[payload.label_type or 'PDF_6x4'].value
payment = (payload.payment or Payment(paid_by="sender", account_number=settings.account_number))
customs = (payload.customs or Customs())
content = (packages[0].parcel.content or "N/A")
request = DHLShipmentRequest(
schemaVersion=6.2,
Request=settings.Request(
MetaData=MetaData(SoftwareName="3PV", SoftwareVersion=6.2)
),
RegionCode=CountryRegion[payload.shipper.country_code].value,
RequestedPickupTime="Y",
LanguageCode="en",
PiecesEnabled="Y",
LatinResponseInd=None,
Billing=Billing(
ShipperAccountNumber=settings.account_number,
BillingAccountNumber=payment.account_number,
ShippingPaymentType=PaymentType[payment.paid_by].value,
DutyAccountNumber=(customs.duty.account_number if customs.duty is not None else None),
DutyPaymentType=(PaymentType[customs.duty.paid_by].value if customs.duty is not None else None),
),
Consignee=Consignee(
CompanyName=payload.recipient.company_name or "N/A",
SuiteDepartmentName=None,
AddressLine=SF.concat_str(
payload.recipient.address_line1, payload.recipient.address_line2
),
City=payload.recipient.city,
Division=None,
DivisionCode=payload.recipient.state_code,
PostalCode=payload.recipient.postal_code,
CountryCode=payload.recipient.country_code,
CountryName=Country[payload.recipient.country_code].value,
FederalTaxId=payload.shipper.federal_tax_id,
StateTaxId=payload.shipper.state_tax_id,
Contact=(
Contact(
PersonName=payload.recipient.person_name,
PhoneNumber=payload.recipient.phone_number or "0000",
Email=payload.recipient.email,
)
),
Suburb=None,
),
Commodity=(
[
Commodity(CommodityCode=c.sku, CommodityName=c.description)
for c in payload.customs.commodities
]
if any(customs.commodities) else None
),
NewShipper=None,
Shipper=Shipper(
ShipperID=settings.account_number or "N/A",
RegisteredAccount=settings.account_number,
AddressLine=SF.concat_str(
payload.shipper.address_line1, payload.shipper.address_line2
),
CompanyName=payload.shipper.company_name or "N/A",
PostalCode=payload.shipper.postal_code,
CountryCode=payload.shipper.country_code,
City=payload.shipper.city,
CountryName=Country[payload.shipper.country_code].value,
Division=None,
DivisionCode=payload.shipper.state_code,
Contact=(
Contact(
PersonName=payload.shipper.person_name,
PhoneNumber=payload.shipper.phone_number or "0000",
Email=payload.shipper.email,
)
),
),
ShipmentDetails=DHLShipmentDetails(
NumberOfPieces=len(packages),
Pieces=Pieces(
Piece=[
Piece(
PieceID=package.parcel.id,
PackageType=(
package_type
or PackageType[
package.packaging_type or "your_packaging"
].value
),
Depth=package.length.IN,
Width=package.width.IN,
Height=package.height.IN,
Weight=package.weight.LB,
DimWeight=None,
PieceContents=(
package.parcel.content or package.parcel.description
),
)
for package in packages
]
),
Weight=packages.weight.LB,
CurrencyCode=options.currency or "USD",
WeightUnit=WeightUnit.L.value,
DimensionUnit=DimensionUnit.I.value,
Date=(options.shipment_date or time.strftime("%Y-%m-%d")),
PackageType=package_type,
IsDutiable=("Y" if payload.customs is not None else "N"),
InsuredAmount=insurance,
ShipmentCharges=(options.cash_on_delivery if options.cash_on_delivery else None),
DoorTo=delivery_type,
GlobalProductCode=product,
LocalProductCode=product,
Contents=content,
),
EProcShip=None,
Dutiable=(
Dutiable(
DeclaredCurrency=customs.duty.currency or "USD",
DeclaredValue=insurance or 1.0,
TermsOfTrade=customs.incoterm,
)
if customs.duty is not None else None
),
ExportDeclaration=None,
Reference=[Reference(ReferenceID=payload.reference)],
SpecialService=[
SpecialService(SpecialServiceType=SpecialServiceCode[key].value.key)
for key, svc in options if key in SpecialServiceCode
],
Notification=(
Notification(
EmailAddress=options.notification_email or payload.recipient.email
)
if options.notification_email is None else None
),
DocImages=None,
RequestArchiveDoc=None,
NumberOfArchiveDoc=None,
LabelImageFormat=label_format,
Label=Label(LabelTemplate=label_template),
ODDLinkReq=None,
DGs=None,
)
return Serializable(request, _request_serializer)
def shipment_request(payload: ShipmentRequest, settings: Settings) -> Serializable[eVSFirstClassMailIntlRequest]:
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 key in ShipmentOption and 'usps_option' not in key
]
customs = payload.customs or Customs(commodities=[])
request = eVSFirstClassMailIntlRequest(
USERID=settings.username,
Option=None,
Revision=2,
ImageParameters=ImageParametersType(ImageParameter=label_format),
FromFirstName=customs.signer or payload.shipper.person_name,
FromLastName=payload.shipper.person_name,
FromFirm=payload.shipper.company_name or "N/A",
FromAddress1=payload.shipper.address_line2,
FromAddress2=payload.shipper.address_line1,
FromUrbanization=None,
FromCity=payload.shipper.city,
FromZip5=Location(payload.shipper.postal_code).as_zip5,
FromZip4=Location(payload.shipper.postal_code).as_zip4 or "",
FromPhone=payload.shipper.phone_number,
ToName=None,
ToFirstName=payload.recipient.person_name,
ToLastName=payload.recipient.person_name,
ToFirm=payload.recipient.company_name or "N/A",
ToAddress1=payload.recipient.address_line2,
ToAddress2=payload.recipient.address_line1,
ToAddress3=None,
ToCity=payload.recipient.city,
ToProvince=Location(payload.recipient.state_code, country=payload.recipient.country_code).as_state_name,
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,
FirstClassMailType=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
]
),
Postage=None,
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 or time.strftime('%Y-%m-%d')),
current_format="%Y-%m-%d",
output_format="%m/%d/%Y"
),
HoldForManifest=None,
EELPFC=customs.eel_pfc,
Container=None,
Length=package.length.IN,
Width=package.width.IN,
Height=package.height.IN,
Girth=(package.girth.value if package.packaging_type == "tube" else None),
ExtraServices=(
ExtraServicesType(ExtraService=[s for s in extra_services])
if any(extra_services) else None
),
PriceOptions=None,
ActionCode=None,
OptOutOfSPE=None,
PermitNumber=None,
AccountZipCode=None,
Machinable=(options.usps_option_machinable_item or False),
DestinationRateIndicator="I",
MID=settings.mailer_id,
LogisticsManagerMID=settings.logistics_manager_mailer_id,
CRID=settings.customer_registration_id,
VendorCode=None,
VendorProductVersionNumber=None,
RemainingBarcodes=None,
ChargebackCode=None,
)
return Serializable(request, XP.export)