def colissimo_send_shipping(self, pickings):
_logger.debug("colissimo_send_shipping: begin")
res = []
coli = ColissimoRequest(self.prod_environment, self.log_xml)
for picking in pickings:
package_count = len(picking.package_ids) or 1
_logger.debug("colissimo_send_shipping: Pack. count: %s" %
package_count)
shipping = coli.shipping_request(picking, self)
carrier_tracking_ref = shipping['tracking_number']
currency = (picking.sale_id.currency_id
or picking.company_id.currency_id)
if currency.name == shipping['currency']:
carrier_price = float(shipping['price'])
else:
quote_currency = self.env['res.currency'].search([
('name', '=', shipping['currency']),
],
limit=1)
carrier_price = quote_currency._convert(
float(shipping['price']), currency, picking.company_id,
picking.sale_id.date_order or fields.Date.today())
package_labels = coli.get_response()
log_message = (_("Shipment created into Colissimo<br/> "
"<b>Tracking Numbers:</b> %s<br/>"
"<b>Packages:</b> %s") %
(carrier_tracking_ref, ', '.join(
[pl[0] for pl in package_labels])))
if self.coli_label_format.startswith('PDF_'):
attachments = [(_('Label_Colissimo.pdf'),
pdf.merge_pdf([pl[1]
for pl in package_labels]))]
else:
attachments = [(_('Label_Colissimo-%s.%s') %
(pl[0], self.coli_label_format), pl[1])
for pl in package_labels]
picking.message_post(body=log_message, attachments=attachments)
try:
cn23 = [(('cn23.pdf'),
pdf.merge_pdf([pl[2] for pl in package_labels]))]
if cn23:
log_message = (_("Shipment CN23 declaration<br/>"))
picking.message_post(body=log_message, attachments=cn23)
except Exception:
pass
shipping_data = {
'exact_price': carrier_price,
'tracking_number': carrier_tracking_ref,
}
res += [shipping_data]
return res
def test_merge_pdf(self):
self.assertEqual(self.minimal_pdf_reader.getNumPages(), 1)
page = self.minimal_pdf_reader.getPage(0)
merged_pdf = pdf.merge_pdf([self.file, self.file])
merged_reader_buffer = io.BytesIO(merged_pdf)
merged_pdf_reader = pdf.OdooPdfFileReader(merged_reader_buffer)
self.assertEqual(merged_pdf_reader.getNumPages(), 2)
merged_reader_buffer.close()
def create_paynet_message(self):
"""Generate the paynet message for an invoice."""
self.ensure_one()
contract = self.partner_id.get_active_contract(self.transmit_method_id)
if not contract:
return
# Generate PDf to be send
pdf_data = []
report_names = ["account.report_invoice"]
if contract.payment_type == "qr":
report_names.append("l10n_ch.qr_report_main")
elif contract.payment_type == "isr":
report_names.append("l10n_ch.isr_report_main")
for report_name in report_names:
r = self.env["ir.actions.report"]._get_report_from_name(
report_name)
pdf_content, _ = r._render([self.id])
pdf_data.append(pdf_content)
if not odoo.tools.config["test_enable"]:
pdf = merge_pdf(pdf_data)
else:
# When test are run, pdf are not generated, so use an empty pdf
pdf = b""
message = self.env["paynet.invoice.message"].create({
"service_id":
contract.paynet_service_id.id,
"invoice_id":
self.id,
"ebill_account_number":
contract.paynet_account_number,
"payment_type":
contract.payment_type,
})
attachment = self.env["ir.attachment"].create({
"name":
"paynet ebill",
"type":
"binary",
"datas":
base64.b64encode(pdf).decode("ascii"),
"res_model":
"paynet.invoice.message",
"res_id":
message.id,
"mimetype":
"application/x-pdf",
})
message.attachment_id = attachment.id
return message
def print_inventory_commands(self):
if not request.env.user.has_group('stock.group_stock_user'):
return request.not_found()
barcode_pdfs = []
# get fixed command barcodes
file_path = get_resource_path('stock_barcode', 'static/img',
'barcodes_actions.pdf')
commands_file = open(file_path, 'rb')
barcode_pdfs.append(commands_file.read())
commands_file.close()
# make sure we use the selected company if possible
allowed_company_ids = self._get_allowed_company_ids()
# same domain conditions for picking types and locations
domain = [('active', '=', 'True'), ('barcode', '!=', ''),
('company_id', 'in', allowed_company_ids)]
# get picking types barcodes
picking_type_ids = request.env['stock.picking.type'].search(domain)
picking_report = request.env.ref(
'stock.action_report_picking_type_label', raise_if_not_found=True)
picking_types_pdf, _ = picking_report._render_qweb_pdf(
picking_type_ids.ids)
if picking_types_pdf:
barcode_pdfs.append(picking_types_pdf)
# get locations barcodes
if request.env.user.has_group('stock.group_stock_multi_locations'):
locations_ids = request.env['stock.location'].search(domain)
locations_report = request.env.ref(
'stock.action_report_location_barcode',
raise_if_not_found=True)
locations_pdf, _ = locations_report._render_qweb_pdf(
locations_ids.ids)
if locations_pdf:
barcode_pdfs.append(locations_pdf)
merged_pdf = pdf.merge_pdf(barcode_pdfs)
pdfhttpheaders = [('Content-Type', 'application/pdf'),
('Content-Length', len(merged_pdf))]
return request.make_response(merged_pdf, headers=pdfhttpheaders)
def generate_multi_report(self):
self.ensure_one()
if not self.print_report and self.account_move_ids:
for account_move in self.account_move_ids:
account_move.print_report_binary()
# merger = PdfFileMerger(strict=False)
reports = []
for account_move in self.account_move_ids:
if account_move.print_report:
#raise ValidationError(type(account_move.print_report))
#if account_move.print_report.startswith(b'%PDF-'):
# raise ValidationError('estamos mal pero vgamos bien')
#f = io.BytesIO(account_move.print_report)
#f = io.BytesIO(base64.b64decode(account_move.print_report))
f = base64.b64decode(account_move.print_report)
reports.append(f)
# merger.append(f,import_bookmarks=False)
#merger.append(base64.encodestring(account_move.print_report),import_bookmarks=False)
#output = open('/tmp/salida_facturas.pdf','w+')
#merger.write(output)
#output.close()
merged_pdf = merge_pdf(reports)
self.print_report = base64.b64encode(merged_pdf)
def ups_send_shipping(self, pickings):
res = []
superself = self.sudo()
ResCurrency = self.env['res.currency']
for picking in pickings:
srm = UPSRequest(
self.log_xml, superself.ups_username, superself.ups_passwd,
superself._get_main_ups_account_number(picking=picking),
superself.ups_access_number, self.prod_environment)
# Hibou Delivery
shipper_company = superself.get_shipper_company(picking=picking)
shipper_warehouse = superself.get_shipper_warehouse(
picking=picking)
recipient = superself.get_recipient(picking=picking)
currency = picking.sale_id.currency_id if picking.sale_id else picking.company_id.currency_id
insurance_currency_code = currency.name
picking_packages = picking.package_ids
package_carriers = picking_packages.mapped('carrier_id')
if package_carriers:
# only ship ours
picking_packages = picking_packages.filtered(
lambda p: p.carrier_id == self and not p.
carrier_tracking_ref)
if not picking_packages:
continue
packages = []
package_names = []
if picking_packages:
# Create all packages
for package in picking_packages:
packages.append(
Package(
self,
package.shipping_weight,
quant_pack=package.packaging_id,
name=package.name,
insurance_value=superself.get_insurance_value(
picking=picking, package=package),
insurance_currency_code=insurance_currency_code,
signature_required=superself.
_get_ups_signature_required(picking=picking,
package=package)))
package_names.append(package.name)
# what is the point of weight_bulk?
# Create one package with the rest (the content that is not in a package)
# if picking.weight_bulk:
# packages.append(Package(self, picking.weight_bulk))
invoice_line_total = 0
for move in picking.move_lines:
invoice_line_total += picking.company_id.currency_id.round(
move.product_id.lst_price * move.product_qty)
shipment_info = {
'description': superself.get_order_name(picking=picking),
'total_qty':
sum(sml.qty_done for sml in picking.move_line_ids),
'ilt_monetary_value': '%d' % invoice_line_total,
'itl_currency_code': self.env.user.company_id.currency_id.name,
'phone': recipient.mobile or recipient.phone,
}
if picking.sale_id and picking.sale_id.carrier_id != picking.carrier_id:
ups_service_type = picking.carrier_id.ups_default_service_type or picking.ups_service_type or superself.ups_default_service_type
else:
ups_service_type = picking.ups_service_type or superself.ups_default_service_type
# Hibou Delivery
ups_carrier_account = superself._get_ups_carrier_account(picking)
if picking.carrier_id.ups_cod:
cod_info = {
'currency': picking.partner_id.country_id.currency_id.name,
'monetary_value': picking.sale_id.amount_total,
'funds_code': superself.ups_cod_funds_code,
}
else:
cod_info = None
check_value = srm.check_required_value(shipper_company,
shipper_warehouse,
recipient,
picking=picking)
if check_value:
raise UserError(check_value)
package_type = picking_packages and picking_packages[
0].packaging_id.shipper_package_code or self.ups_default_packaging_id.shipper_package_code
srm.send_shipping(
shipment_info=shipment_info,
packages=packages,
shipper=shipper_company,
ship_from=shipper_warehouse,
ship_to=recipient,
packaging_type=package_type,
service_type=ups_service_type,
duty_payment=picking.carrier_id.ups_duty_payment,
label_file_type=self.ups_label_file_type,
ups_carrier_account=ups_carrier_account,
saturday_delivery=picking.carrier_id.ups_saturday_delivery,
cod_info=cod_info)
result = srm.process_shipment()
if result.get('error_message'):
raise UserError(result['error_message'].__str__())
order = picking.sale_id
company = order.company_id or picking.company_id or self.env.company
currency_order = picking.sale_id.currency_id
if not currency_order:
currency_order = picking.company_id.currency_id
if currency_order.name == result['currency_code']:
price = float(result['price'])
else:
quote_currency = ResCurrency.search(
[('name', '=', result['currency_code'])], limit=1)
price = quote_currency._convert(
float(result['price']), currency_order, company,
order.date_order or fields.Date.today())
package_labels = []
for track_number, label_binary_data in result.get(
'label_binary_data').items():
package_labels = package_labels + [
(track_number, label_binary_data)
]
carrier_tracking_ref = "+".join([pl[0] for pl in package_labels])
logmessage = _("Shipment created into UPS<br/>"
"<b>Tracking Numbers:</b> %s<br/>"
"<b>Packages:</b> %s") % (carrier_tracking_ref,
','.join(package_names))
if superself.ups_label_file_type != 'GIF':
attachments = [
('LabelUPS-%s.%s' % (pl[0], superself.ups_label_file_type),
pl[1]) for pl in package_labels
]
if superself.ups_label_file_type == 'GIF':
attachments = [('LabelUPS.pdf',
pdf.merge_pdf([pl[1]
for pl in package_labels]))]
picking.message_post(body=logmessage, attachments=attachments)
shipping_data = {
'exact_price': price,
'tracking_number': carrier_tracking_ref
}
res = res + [shipping_data]
if self.return_label_on_delivery:
self.ups_get_return_label(picking)
return res
def generate_label_from_shipstation(self):
_logger.info(">>>>>>>>>>>>>>>>>> Generate Lebel")
shipment_cost = 0.0
self.ensure_one()
if not self.carrier_id:
raise ValidationError("Please set proper delivery method")
final_tracking_number = []
input_path = []
label_datas = []
file_name = self.name
pdf_merger = PdfFileMerger()
file_name = file_name.replace('/', '_')
file_path = "/tmp/waves/"
directory = os.path.dirname(file_path)
try:
os.stat(directory)
except:
os.system("mkdir %s" % (file_path))
error_detail = ""
if any(move.product_id.weight <= 0.0 for move in self.move_lines):
raise ValidationError("Need to set Product Weight.")
for package_id in self.package_ids:
_logger.info("Inside Package : %s" % (package_id))
try:
if not package_id.is_generate_label_in_shipstation:
continue
weight = package_id.shipping_weight
carrier_id = package_id.carrier_id if package_id.carrier_id else self.carrier_id
body = carrier_id.generate_label_from_shipstation(
self, package_id, weight)
_logger.info("Label Body >>>>>>>>>>> : %s" % (body))
#response_data = carrier_id.api_calling_function("/shipments/createlabel", body, self.sale_id.shipstation_warehouse_address_id)
response_data = carrier_id.api_calling_function(
"/orders/createlabelfororder", body)
_logger.info("Label Response Data: %s" % (response_data))
if response_data.status_code == 200:
responses = response_data.json()
_logger.info("Label Responsese >>>> After 200 : %s" %
(responses))
shipment_id = responses.get('shipmentId')
if shipment_id:
self.shipstation_shipment_id = shipment_id
label_data = responses.get('labelData')
tracking_number = responses.get('trackingNumber')
shipment_cost += responses.get('shipmentCost')
final_tracking_number.append(tracking_number)
base_data = binascii.a2b_base64(str(label_data))
label_datas.append(base_data)
tracking_message = (
_("Shipstation Tracking Number: </b>%s") %
(tracking_number))
message_id = self.message_post(
body=tracking_message
) #attachments=[('%s_Shipstation_Tracking_%s.pdf' % (self.name ,tracking_number), base_data)]
package_id.response_message = "Sucessfully Label Generated"
package_id.custom_tracking_number = tracking_number
package_id.shipstation_shipment_id = shipment_id
input_path.append("%s_%s.pdf" %
(file_path, tracking_number))
# with open("%s_%s.pdf" % (file_path, tracking_number), "ab") as f:
# f.write(base64.b64decode(message_id and message_id.attachment_ids[0] and message_id.attachment_ids[0].datas))
logmessage = _("<b>Tracking Numbers:</b> %s") % (
tracking_number)
label_data_pdf = binascii.a2b_base64(str(label_data))
self.message_post(body=logmessage,
attachments=[("%s.pdf" % (self.id),
label_data_pdf)])
else:
error_code = "%s" % (response_data.status_code)
_logger.info("ERROR CODE: %s" % (error_code))
error_message = response_data.reason
_logger.info("Package : ERROR Response: %s" %
(response_data))
error_detail = {
'error': error_code + " - " + error_message + " - "
}
if response_data.json():
error_detail = {
'error':
error_code + " - " + error_message + " - %s" %
(response_data.json())
}
package_id.response_message = error_detail
except Exception as e:
package_id.response_message = e
_logger.info("Exception >>>>> Inside Package: %s" % (e))
if self.weight_bulk:
try:
weight = self.weight_bulk
body = self.carrier_id and self.carrier_id.generate_label_from_shipstation(
self, False, weight)
#warehouse_location_id = self.sale_id and self.sale_id.shipstation_warehouse_address_id
#response_data=self.carrier_id and self.carrier_id.api_calling_function("/shipments/createlabel", body, warehouse_location_id)
response_data = self.carrier_id.api_calling_function(
"/orders/createlabelfororder", body)
if response_data.status_code == 200:
responses = response_data.json()
shipment_id = responses.get('shipmentId')
if shipment_id:
self.shipstation_shipment_id = shipment_id
label_data = responses.get('labelData')
tracking_number = responses.get('trackingNumber')
shipment_cost += responses.get('shipmentCost')
final_tracking_number.append(tracking_number)
base_data = binascii.a2b_base64(str(label_data))
label_datas.append(base_data)
tracking_mesage = (
_("Shipstation Tracking Number: </b>%s") %
(tracking_number))
message_id = self.message_post(
body=tracking_mesage
) #attachments=[('%s_Shipstation_Tracking_%s.pdf' % (self.name ,tracking_number), base_data)]
input_path.append("%s_%s.pdf" %
(file_path, tracking_number))
#with open("%s_%s.pdf" % (file_path, tracking_number), "ab") as f:f.write(base64.b64decode(message_id and message_id.attachment_ids[0] and message_id.attachment_ids[0].datas))
logmessage = _("<b>Tracking Numbers:</b> %s") % (
tracking_number)
label_data_pdf = binascii.a2b_base64(str(label_data))
self.message_post(body=logmessage,
attachments=[("%s.pdf" % (self.id),
label_data_pdf)])
else:
error_code = "%s" % (response_data.status_code)
_logger.info("Inside Bulk Weight ERROR CODE: %s" %
(error_code))
error_message = response_data.reason
_logger.info("ERROR Reponse Data: %s" % (response_data))
error_detail = {
'error': error_code + " - " + error_message + " - "
}
if response_data.json():
error_detail = {
'error':
error_code + " - " + error_message + " - %s" %
(response_data.json())
}
self.message_post(body=error_detail)
except Exception as e:
self.message_post(body=e)
_logger.info("Exception >>> Inside Bulk Weight: %s" % (e))
if not final_tracking_number:
#_logger.info("Not Final Tracking Number: %s" % (response_data))
raise ValidationError("{}".format(error_detail))
self.carrier_tracking_ref = ','.join(final_tracking_number)
self.shipment_cost = shipment_cost
# for path in input_path:
# pdf_merger.append(path)
file_data_temp = pdf.merge_pdf(label_datas)
file_data_temp = base64.b64encode(file_data_temp)
# with open("%s_%s.pdf" % (file_path, file_name), 'wb') as fileobj:
# pdf_merger.write(fileobj)
#
# with open("%s_%s.pdf" % (file_path, file_name), "rb") as f1:
# f1.seek(0)
# buffer = data = f1.read()
# f1.close()
# file_data_temp = base64.b64encode(buffer)
att_id = self.env['ir.attachment'].create({
'name':
"Wave -%s.pdf" % (file_name or ""),
'type':
'binary',
'datas':
file_data_temp or "",
'mimetype':
'application/pdf',
'res_model':
'stock.picking',
'res_id':
self.id,
'res_name':
self.name
})
# if os.stat(directory):
# os.system("%s" % (file_path))
# os.system("rm -R %s" % (directory))
return {
'type':
'ir.actions.act_url',
'url':
'/web/binary/download_document?model=ir.attachment&field=datas&id=%s&filename=%s.pdf'
% (att_id.id, self.name.replace('/', '_')),
'target':
'self'
}
def ups_get_return_label(self, picking, tracking_number=None, origin_date=None):
res = []
superself = self.sudo()
srm = UPSRequest(self.log_xml, superself.ups_username, superself.ups_passwd, superself.ups_shipper_number, superself.ups_access_number, self.prod_environment)
ResCurrency = self.env['res.currency']
packages = []
package_names = []
if picking.is_return_picking:
weight = sum([m.product_id.weight * m.product_qty for m in picking.move_lines])
packages.append(Package(self, weight))
else:
if picking.package_ids:
# Create all packages
for package in picking.package_ids:
packages.append(Package(self, package.shipping_weight, quant_pack=package.packaging_id, name=package.name))
package_names.append(package.name)
# Create one package with the rest (the content that is not in a package)
if picking.weight_bulk:
packages.append(Package(self, picking.weight_bulk))
invoice_line_total = 0
for move in picking.move_lines:
invoice_line_total += picking.company_id.currency_id.round(move.product_id.lst_price * move.product_qty)
shipment_info = {
'description': picking.origin,
'total_qty': sum(sml.qty_done for sml in picking.move_line_ids),
'ilt_monetary_value': '%d' % invoice_line_total,
'itl_currency_code': self.env.company.currency_id.name,
'phone': picking.partner_id.mobile or picking.partner_id.phone or picking.sale_id.partner_id.mobile or picking.sale_id.partner_id.phone,
}
if picking.sale_id and picking.sale_id.carrier_id != picking.carrier_id:
ups_service_type = picking.carrier_id.ups_default_service_type or picking.ups_service_type or self.ups_default_service_type
else:
ups_service_type = picking.ups_service_type or self.ups_default_service_type
ups_carrier_account = picking.ups_carrier_account
if picking.carrier_id.ups_cod:
cod_info = {
'currency': picking.partner_id.country_id.currency_id.name,
'monetary_value': picking.sale_id.amount_total,
'funds_code': self.ups_cod_funds_code,
}
else:
cod_info = None
check_value = srm.check_required_value(picking.partner_id, picking.partner_id, picking.picking_type_id.warehouse_id.partner_id)
if check_value:
raise UserError(check_value)
package_type = picking.package_ids and picking.package_ids[0].packaging_id.shipper_package_code or self.ups_default_packaging_id.shipper_package_code
srm.send_shipping(
shipment_info=shipment_info, packages=packages, shipper=picking.partner_id, ship_from=picking.partner_id,
ship_to=picking.picking_type_id.warehouse_id.partner_id, packaging_type=package_type, service_type=ups_service_type, duty_payment='RECIPIENT', label_file_type=self.ups_label_file_type, ups_carrier_account=ups_carrier_account,
saturday_delivery=picking.carrier_id.ups_saturday_delivery, cod_info=cod_info)
srm.return_label()
result = srm.process_shipment()
if result.get('error_message'):
raise UserError(result['error_message'])
order = picking.sale_id
company = order.company_id or picking.company_id or self.env.company
currency_order = picking.sale_id.currency_id
if not currency_order:
currency_order = picking.company_id.currency_id
if currency_order.name == result['currency_code']:
price = float(result['price'])
else:
quote_currency = ResCurrency.search([('name', '=', result['currency_code'])], limit=1)
price = quote_currency._convert(
float(result['price']), currency_order, company, order.date_order or fields.Date.today())
package_labels = []
for track_number, label_binary_data in result.get('label_binary_data').items():
package_labels = package_labels + [(track_number, label_binary_data)]
carrier_tracking_ref = "+".join([pl[0] for pl in package_labels])
logmessage = _("Return label generated<br/>"
"<b>Tracking Numbers:</b> %s<br/>"
"<b>Packages:</b> %s") % (carrier_tracking_ref, ','.join(package_names))
if self.ups_label_file_type != 'GIF':
attachments = [('%s-%s-%s.%s' % (self.get_return_label_prefix(), pl[0], index, self.ups_label_file_type), pl[1]) for index, pl in enumerate(package_labels)]
if self.ups_label_file_type == 'GIF':
attachments = [('%s-%s-%s.%s' % (self.get_return_label_prefix(), package_labels[0][0], 1, 'pdf'), pdf.merge_pdf([pl[1] for pl in package_labels]))]
picking.message_post(body=logmessage, attachments=attachments)
shipping_data = {
'exact_price': price,
'tracking_number': carrier_tracking_ref}
res = res + [shipping_data]
return res
def fedex_send_shipping(self, pickings):
res = []
for picking in pickings:
srm = FedexRequest(self.log_xml,
request_type="shipping",
prod_environment=self.prod_environment)
superself = self.sudo()
srm.web_authentication_detail(superself.fedex_developer_key,
superself.fedex_developer_password)
srm.client_detail(superself.fedex_account_number,
superself.fedex_meter_number)
srm.transaction_detail(picking.id)
package_type = picking.package_ids and picking.package_ids[
0].packaging_id.shipper_package_code or self.fedex_default_packaging_id.shipper_package_code
srm.shipment_request(self.fedex_droppoff_type,
self.fedex_service_type, package_type,
self.fedex_weight_unit,
self.fedex_saturday_delivery)
srm.set_currency(
_convert_curr_iso_fdx(picking.company_id.currency_id.name))
srm.set_shipper(picking.company_id.partner_id,
picking.picking_type_id.warehouse_id.partner_id)
srm.set_recipient(picking.partner_id)
srm.shipping_charges_payment(superself.fedex_account_number)
srm.shipment_label('COMMON2D', self.fedex_label_file_type,
self.fedex_label_stock_type,
'TOP_EDGE_OF_TEXT_FIRST',
'SHIPPING_LABEL_FIRST')
order = picking.sale_id
company = order.company_id or picking.company_id or self.env.company
order_currency = picking.sale_id.currency_id or picking.company_id.currency_id
net_weight = self._fedex_convert_weight(picking.shipping_weight,
self.fedex_weight_unit)
# Commodities for customs declaration (international shipping)
if self.fedex_service_type in [
'INTERNATIONAL_ECONOMY', 'INTERNATIONAL_PRIORITY'
] or (picking.partner_id.country_id.code == 'IN'
and picking.picking_type_id.warehouse_id.partner_id.
country_id.code == 'IN'):
commodity_currency = order_currency
total_commodities_amount = 0.0
commodity_country_of_manufacture = picking.picking_type_id.warehouse_id.partner_id.country_id.code
for operation in picking.move_line_ids:
commodity_amount = operation.move_id.sale_line_id.price_reduce_taxinc or operation.product_id.list_price
total_commodities_amount += (commodity_amount *
operation.qty_done)
commodity_description = operation.product_id.name
commodity_number_of_piece = '1'
commodity_weight_units = self.fedex_weight_unit
commodity_weight_value = self._fedex_convert_weight(
operation.product_id.weight * operation.qty_done,
self.fedex_weight_unit)
commodity_quantity = operation.qty_done
commodity_quantity_units = 'EA'
commodity_harmonized_code = operation.product_id.hs_code or ''
srm.commodities(
_convert_curr_iso_fdx(commodity_currency.name),
commodity_amount, commodity_number_of_piece,
commodity_weight_units, commodity_weight_value,
commodity_description,
commodity_country_of_manufacture, commodity_quantity,
commodity_quantity_units, commodity_harmonized_code)
srm.customs_value(
_convert_curr_iso_fdx(commodity_currency.name),
total_commodities_amount, "NON_DOCUMENTS")
srm.duties_payment(
picking.picking_type_id.warehouse_id.partner_id,
superself.fedex_account_number,
superself.fedex_duty_payment)
send_etd = superself.env['ir.config_parameter'].get_param(
"delivery_fedex.send_etd")
srm.commercial_invoice(self.fedex_document_stock_type,
send_etd)
package_count = len(picking.package_ids) or 1
# For india picking courier is not accepted without this details in label.
po_number = order.display_name or False
dept_number = False
if picking.partner_id.country_id.code == 'IN' and picking.picking_type_id.warehouse_id.partner_id.country_id.code == 'IN':
po_number = 'B2B' if picking.partner_id.commercial_partner_id.is_company else 'B2C'
dept_number = 'BILL D/T: SENDER'
# TODO RIM master: factorize the following crap
################
# Multipackage #
################
if package_count > 1:
# Note: Fedex has a complex multi-piece shipping interface
# - Each package has to be sent in a separate request
# - First package is called "master" package and holds shipping-
# related information, including addresses, customs...
# - Last package responses contains shipping price and code
# - If a problem happens with a package, every previous package
# of the shipping has to be cancelled separately
# (Why doing it in a simple way when the complex way exists??)
master_tracking_id = False
package_labels = []
carrier_tracking_ref = ""
for sequence, package in enumerate(picking.package_ids,
start=1):
package_weight = self._fedex_convert_weight(
package.shipping_weight, self.fedex_weight_unit)
packaging = package.packaging_id
srm._add_package(
package_weight,
package_code=packaging.shipper_package_code,
package_height=packaging.height,
package_width=packaging.width,
package_length=packaging.packaging_length,
sequence_number=sequence,
po_number=po_number,
dept_number=dept_number,
reference=picking.display_name,
)
srm.set_master_package(
net_weight,
package_count,
master_tracking_id=master_tracking_id)
request = srm.process_shipment()
package_name = package.name or sequence
warnings = request.get('warnings_message')
if warnings:
_logger.info(warnings)
# First package
if sequence == 1:
if not request.get('errors_message'):
master_tracking_id = request['master_tracking_id']
package_labels.append(
(package_name, srm.get_label()))
carrier_tracking_ref = request['tracking_number']
else:
raise UserError(request['errors_message'])
# Intermediary packages
elif sequence > 1 and sequence < package_count:
if not request.get('errors_message'):
package_labels.append(
(package_name, srm.get_label()))
carrier_tracking_ref = carrier_tracking_ref + "," + request[
'tracking_number']
else:
raise UserError(request['errors_message'])
# Last package
elif sequence == package_count:
# recuperer le label pdf
if not request.get('errors_message'):
package_labels.append(
(package_name, srm.get_label()))
carrier_price = self._get_request_price(
request['price'], order, order_currency)
carrier_tracking_ref = carrier_tracking_ref + "," + request[
'tracking_number']
logmessage = _(
"Shipment created into Fedex<br/>"
"<b>Tracking Numbers:</b> %s<br/>"
"<b>Packages:</b> %s") % (
carrier_tracking_ref, ','.join(
[pl[0] for pl in package_labels]))
if self.fedex_label_file_type != 'PDF':
attachments = [
('LabelFedex-%s.%s' %
(pl[0], self.fedex_label_file_type),
pl[1]) for pl in package_labels
]
if self.fedex_label_file_type == 'PDF':
attachments = [
('LabelFedex.pdf',
pdf.merge_pdf(
[pl[1] for pl in package_labels]))
]
picking.message_post(body=logmessage,
attachments=attachments)
shipping_data = {
'exact_price': carrier_price,
'tracking_number': carrier_tracking_ref
}
res = res + [shipping_data]
else:
raise UserError(request['errors_message'])
# TODO RIM handle if a package is not accepted (others should be deleted)
###############
# One package #
###############
elif package_count == 1:
packaging = picking.package_ids[:
1].packaging_id or picking.carrier_id.fedex_default_packaging_id
srm._add_package(
net_weight,
package_code=packaging.shipper_package_code,
package_height=packaging.height,
package_width=packaging.width,
package_length=packaging.packaging_length,
po_number=po_number,
dept_number=dept_number,
reference=picking.display_name,
)
srm.set_master_package(net_weight, 1)
# Ask the shipping to fedex
request = srm.process_shipment()
warnings = request.get('warnings_message')
if warnings:
_logger.info(warnings)
if not request.get('errors_message'):
if _convert_curr_iso_fdx(
order_currency.name) in request['price']:
carrier_price = request['price'][_convert_curr_iso_fdx(
order_currency.name)]
else:
_logger.info(
"Preferred currency has not been found in FedEx response"
)
company_currency = picking.company_id.currency_id
if _convert_curr_iso_fdx(
company_currency.name) in request['price']:
amount = request['price'][_convert_curr_iso_fdx(
company_currency.name)]
carrier_price = company_currency._convert(
amount, order_currency, company,
order.date_order or fields.Date.today())
else:
amount = request['price']['USD']
carrier_price = company_currency._convert(
amount, order_currency, company,
order.date_order or fields.Date.today())
carrier_tracking_ref = request['tracking_number']
logmessage = (_(
"Shipment created into Fedex <br/> <b>Tracking Number : </b>%s"
) % (carrier_tracking_ref))
fedex_labels = [
('LabelFedex-%s-%s.%s' % (carrier_tracking_ref, index,
self.fedex_label_file_type),
label) for index, label in enumerate(
srm._get_labels(self.fedex_label_file_type))
]
picking.message_post(body=logmessage,
attachments=fedex_labels)
shipping_data = {
'exact_price': carrier_price,
'tracking_number': carrier_tracking_ref
}
res = res + [shipping_data]
else:
raise UserError(request['errors_message'])
##############
# No package #
##############
else:
raise UserError(_('No packages for this picking'))
if self.return_label_on_delivery:
self.get_return_label(
picking,
tracking_number=request['tracking_number'],
origin_date=request['date'])
commercial_invoice = srm.get_document()
if commercial_invoice:
fedex_documents = [('DocumentFedex.pdf', commercial_invoice)]
picking.message_post(body='Fedex Documents',
attachments=fedex_documents)
return res
def ups_send_shipping(self, pickings):
res = []
superself = self.sudo()
ResCurrency = self.env['res.currency']
for picking in pickings:
if picking.is_ship_collect:
srm = UPSRequestRef(self.log_xml, superself.ups_username,
superself.ups_passwd,
picking.shipper_number,
superself.ups_access_number,
self.prod_environment)
else:
srm = UPSRequestRef(self.log_xml, superself.ups_username,
superself.ups_passwd,
superself.ups_shipper_number,
superself.ups_access_number,
self.prod_environment)
packages = []
package_names = []
if picking.package_ids:
# Create all packages
for package in picking.package_ids:
packages.append(
Package(self,
package.shipping_weight,
quant_pack=package.packaging_id,
name=package.name))
package_names.append(package.name)
# Create one package with the rest (the content that is not in a package)
if picking.weight_bulk:
packages.append(Package(self, picking.weight_bulk))
invoice_line_total = 0
for move in picking.move_lines:
invoice_line_total += picking.company_id.currency_id.round(
move.product_id.lst_price * move.product_qty)
shipment_info = {
'description':
picking.origin,
'total_qty':
sum(sml.qty_done for sml in picking.move_line_ids),
'ilt_monetary_value':
'%d' % invoice_line_total,
'itl_currency_code':
self.env.company.currency_id.name,
'phone':
picking.partner_id.mobile or picking.partner_id.phone
or picking.sale_id.partner_id.mobile
or picking.sale_id.partner_id.phone,
}
if picking.sale_id and picking.sale_id.carrier_id != picking.carrier_id:
ups_service_type = picking.carrier_id.ups_default_service_type or picking.ups_service_type or self.ups_default_service_type
else:
ups_service_type = picking.ups_service_type or self.ups_default_service_type
ups_carrier_account = picking.ups_carrier_account
if picking.carrier_id.ups_cod:
cod_info = {
'currency': picking.partner_id.country_id.currency_id.name,
'monetary_value': picking.sale_id.amount_total,
'funds_code': self.ups_cod_funds_code,
}
else:
cod_info = None
check_value = srm.check_required_value(
picking.company_id.partner_id,
picking.picking_type_id.warehouse_id.partner_id,
picking.partner_id,
picking=picking)
if check_value:
raise UserError(check_value)
package_type = picking.package_ids and picking.package_ids[
0].packaging_id.shipper_package_code or self.ups_default_packaging_id.shipper_package_code
# using customer's shipper number for UPS integration'
# if picking.is_ship_collect and not picking.sale_id.edi_order:
# srm.send_shipping(
# shipment_info=shipment_info, packages=packages, shipper=picking.company_id.partner_id, ship_from=picking.picking_type_id.warehouse_id.partner_id,
# ship_to=picking.partner_id, packaging_type=package_type, service_type=ups_service_type, duty_payment='RECIPIENT',
# label_file_type=self.ups_label_file_type, ups_carrier_account=picking.shipper_number, saturday_delivery=picking.carrier_id.ups_saturday_delivery,
# cod_info=cod_info, order=picking.sale_id)
if picking.is_ship_collect:
srm.send_shipping(
shipment_info=shipment_info,
packages=packages,
shipper=picking.company_id.partner_id,
ship_from=picking.picking_type_id.warehouse_id.partner_id,
ship_to=picking.partner_id,
packaging_type=package_type,
service_type=ups_service_type,
duty_payment='RECIPIENT',
label_file_type=self.ups_label_file_type,
ups_carrier_account=superself.ups_shipper_number,
saturday_delivery=picking.carrier_id.ups_saturday_delivery,
cod_info=cod_info,
order=picking.sale_id)
else:
srm.send_shipping(
shipment_info=shipment_info,
packages=packages,
shipper=picking.company_id.partner_id,
ship_from=picking.picking_type_id.warehouse_id.partner_id,
ship_to=picking.partner_id,
packaging_type=package_type,
service_type=ups_service_type,
duty_payment=picking.carrier_id.ups_duty_payment,
label_file_type=self.ups_label_file_type,
ups_carrier_account=ups_carrier_account,
saturday_delivery=picking.carrier_id.ups_saturday_delivery,
cod_info=cod_info,
order=picking.sale_id)
result = srm.process_shipment()
if result.get('error_message'):
raise UserError(result['error_message'].__str__())
order = picking.sale_id
company = order.company_id or picking.company_id or self.env.company
currency_order = picking.sale_id.currency_id
if not currency_order:
currency_order = picking.company_id.currency_id
if currency_order.name == result['currency_code']:
price = float(result['price'])
else:
quote_currency = ResCurrency.search(
[('name', '=', result['currency_code'])], limit=1)
price = quote_currency._convert(
float(result['price']), currency_order, company,
order.date_order or fields.Date.today())
package_labels = []
for track_number, label_binary_data in result.get(
'label_binary_data').items():
package_labels = package_labels + [
(track_number, label_binary_data)
]
carrier_tracking_ref = "+".join([pl[0] for pl in package_labels])
label_data = [pl[1] for pl in package_labels]
#writing tracking reference to respective packages
for index, package in enumerate(picking.package_ids):
package.carrier_tracking_ref = carrier_tracking_ref.split(
'+')[index]
# package.label_data = label_data[index]
attachments = [
('LabelUPS-%s.%s' % (package.carrier_tracking_ref, 'PNG'),
label_data[index])
]
package.message_post(body="label created",
attachments=attachments)
return_label_ids = self.env['ir.attachment'].search(
[('res_model', '=', 'stock.quant.package'),
('res_id', '=', package.id), '|',
('name', 'like', '%s%%' % 'LabelFedex'),
('name', 'like', '%s%%' % 'LabelUPS')],
limit=1)
package.label_data = return_label_ids.datas
package.label_id = return_label_ids.id
# print(c)
logmessage = _("Shipment created into UPS<br/>"
"<b>Tracking Numbers:</b> %s<br/>"
"<b>Packages:</b> %s") % (carrier_tracking_ref,
','.join(package_names))
if self.ups_label_file_type == 'GIF':
attachments = [('LabelUPS-%s.%s' % (pl[0], 'PNG'), pl[1])
for pl in package_labels]
if self.ups_label_file_type != 'GIF':
attachments = [('LabelUPS.pdf',
pdf.merge_pdf([pl[1]
for pl in package_labels]))]
picking.message_post(body=logmessage, attachments=attachments)
shipping_data = {
'exact_price':
price,
'tracking_number':
carrier_tracking_ref and carrier_tracking_ref.split('+')[0]
or carrier_tracking_ref
}
res = res + [shipping_data]
# if self.return_label_on_delivery:
# self.ups_get_return_label(picking)
return res
