size
int64 0
304k
| ext
stringclasses 1
value | lang
stringclasses 1
value | branch
stringclasses 1
value | content
stringlengths 0
304k
| avg_line_length
float64 0
238
| max_line_length
int64 0
304k
|
|---|---|---|---|---|---|---|
290 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class AccountBankStatementLine(models.Model):
_inherit = "account.bank.statement.line"
date_due = fields.Date(string="Due date")
| 28.8 | 288 |
577 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Auto-refresh delivery",
"summary": "Auto-refresh delivery price in sales orders",
"version": "15.0.1.0.1",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["delivery"],
"data": ["views/sale_order_views.xml", "views/res_config_settings_views.xml"],
}
| 36.0625 | 577 |
591 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Tecnativa - Pilar Vargas
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
"""Remove system parameter records of 'delivery_auto_refresh' with value 0 or False,
to avoid their activation during migration due to their presence in the database."""
openupgrade.logged_query(
env.cr,
"""
DELETE FROM ir_config_parameter
WHERE key LIKE '%delivery_auto_refresh%'
AND (value = '0' OR value = 'False')
""",
)
| 34.764706 | 591 |
13,333 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2023 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests import Form, common, tagged
def _execute_onchanges(records, field_name):
"""Helper methods that executes all onchanges associated to a field."""
for onchange in records._onchange_methods.get(field_name, []):
for record in records:
onchange(record)
@tagged("post_install", "-at_install")
class TestDeliveryAutoRefresh(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
service = cls.env["product.product"].create(
{"name": "Service Test", "type": "service"}
)
pricelist = cls.env["product.pricelist"].create(
{"name": "Test pricelist", "currency_id": cls.env.company.currency_id.id}
)
carrier_form = Form(cls.env["delivery.carrier"])
carrier_form.name = "Test carrier 1"
carrier_form.delivery_type = "base_on_rule"
carrier_form.product_id = service
with carrier_form.price_rule_ids.new() as price_rule_form:
price_rule_form.variable = "weight"
price_rule_form.operator = "<="
price_rule_form.max_value = 20
price_rule_form.list_base_price = 50
with carrier_form.price_rule_ids.new() as price_rule_form:
price_rule_form.variable = "weight"
price_rule_form.operator = "<="
price_rule_form.max_value = 40
price_rule_form.list_base_price = 30
price_rule_form.list_price = 1
price_rule_form.variable_factor = "weight"
with carrier_form.price_rule_ids.new() as price_rule_form:
price_rule_form.variable = "weight"
price_rule_form.operator = ">"
price_rule_form.max_value = 40
price_rule_form.list_base_price = 20
price_rule_form.list_price = 1.5
price_rule_form.variable_factor = "weight"
cls.carrier_1 = carrier_form.save()
carrier_form = Form(cls.env["delivery.carrier"])
carrier_form.name = "Test carrier 2"
carrier_form.delivery_type = "base_on_rule"
carrier_form.product_id = service
with carrier_form.price_rule_ids.new() as price_rule_form:
price_rule_form.variable = "weight"
price_rule_form.operator = "<="
price_rule_form.max_value = 20
price_rule_form.list_base_price = 50
cls.carrier_2 = carrier_form.save()
cls.product = cls.env["product.product"].create(
{"name": "Test product", "weight": 10, "list_price": 20}
)
cls.partner = cls.env["res.partner"].create(
{
"name": "Test partner",
"property_delivery_carrier_id": cls.carrier_1.id,
"property_product_pricelist": pricelist.id,
}
)
cls.auto_add_delivery_line = "delivery_auto_refresh.auto_add_delivery_line"
cls.refresh_after_picking = "delivery_auto_refresh.refresh_after_picking"
cls.auto_void_delivery_line = "delivery_auto_refresh.auto_void_delivery_line"
cls.settings = cls.env["res.config.settings"].create({})
cls.settings.set_default_carrier = True
cls.settings.execute()
order_form = Form(cls.env["sale.order"])
order_form.partner_id = cls.partner
order_form.partner_invoice_id = cls.partner
order_form.partner_shipping_id = cls.partner
with order_form.order_line.new() as ol_form:
ol_form.product_id = cls.product
ol_form.product_uom_qty = 2
cls.order = order_form.save()
def test_auto_refresh_so(self):
self.assertFalse(self.order.order_line.filtered("is_delivery"))
self.settings.auto_add_delivery_line = True
self.settings.execute()
self.order.write(
{"order_line": [(1, self.order.order_line.id, {"product_uom_qty": 3})]}
)
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.price_unit, 60)
line2 = self.order.order_line.new(
{
"order_id": self.order.id,
"product_id": self.product.id,
"product_uom_qty": 2,
}
)
_execute_onchanges(line2, "product_id")
vals = line2._convert_to_write(line2._cache)
del vals["order_id"]
self.order.write({"order_line": [(0, 0, vals)]})
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.price_unit, 95)
# Test saving the discount
line_delivery.discount = 10
self.order.carrier_id = self.carrier_2
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.discount, 10)
# Test change the carrier_id using the wizard
wiz = Form(
self.env["choose.delivery.carrier"].with_context(
default_order_id=self.order.id,
default_carrier_id=self.carrier_1.id,
)
).save()
wiz.button_confirm()
self.assertEqual(self.order.carrier_id, self.carrier_1)
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.name, "Test carrier 1")
def test_auto_refresh_picking(self):
self.settings.refresh_after_picking = True
self.settings.execute()
self.order.order_line.product_uom_qty = 3
wiz = Form(
self.env["choose.delivery.carrier"].with_context(
default_order_id=self.order.id,
default_carrier_id=self.carrier_1.id,
)
).save()
wiz.button_confirm()
self.order.action_confirm()
picking = self.order.picking_ids
picking.action_assign()
picking.move_line_ids[0].qty_done = 2
picking._action_done()
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.price_unit, 50)
def test_auto_refresh_picking_fixed_price(self):
self.settings.refresh_after_picking = True
self.settings.execute()
product_fixed_price = self.env["product.product"].create(
{
"name": "Test carrier fixed price auto refresh",
"type": "service",
}
)
carrier_form = Form(self.env["delivery.carrier"])
carrier_form.name = product_fixed_price.name
carrier_form.product_id = product_fixed_price
carrier_form.delivery_type = "fixed"
carrier_form.fixed_price = 2
carrier_fixed_price = carrier_form.save()
wiz = Form(
self.env["choose.delivery.carrier"].with_context(
default_order_id=self.order.id,
default_carrier_id=carrier_fixed_price.id,
)
).save()
wiz.button_confirm()
self.order.action_confirm()
self.order.action_done() # Lock order to check writing protection disabling
picking = self.order.picking_ids
picking.action_assign()
picking.move_line_ids[0].qty_done = 2
picking._action_done()
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.price_unit, 2)
def test_no_auto_refresh_picking(self):
self.settings.refresh_after_picking = False
self.settings.execute()
self.order.order_line.product_uom_qty = 3
wiz = Form(
self.env["choose.delivery.carrier"].with_context(
default_order_id=self.order.id,
default_carrier_id=self.carrier_1.id,
)
).save()
wiz.button_confirm()
self.order.action_confirm()
picking = self.order.picking_ids
picking.action_assign()
picking.move_line_ids[0].qty_done = 2
picking._action_done()
line_delivery = self.order.order_line.filtered("is_delivery")
self.assertEqual(line_delivery.price_unit, 60)
def test_compute_carrier_id(self):
order_form_1 = Form(self.env["sale.order"])
order_form_1.partner_id = self.partner
self.assertEqual(order_form_1.carrier_id, self.carrier_1)
partner_without_carrier = self.env["res.partner"].create(
{
"name": "Test partner without carrier",
"property_delivery_carrier_id": False,
}
)
no_carrier = self.env["delivery.carrier"]
order_form_2 = Form(self.env["sale.order"])
order_form_2.partner_id = partner_without_carrier
self.assertEqual(order_form_2.carrier_id, no_carrier)
def _confirm_sale_order(self, order):
sale_form = Form(order)
# Force the delivery line creation
with sale_form.order_line.edit(0) as line_form:
line_form.product_uom_qty = 2
sale_form.save()
line_delivery = order.order_line.filtered("is_delivery")
order.action_confirm()
return line_delivery
def _validate_picking(self, picking):
"""Helper method to confirm the pickings"""
for line in picking.move_lines:
line.quantity_done = line.product_uom_qty
picking._action_done()
def _return_whole_picking(self, picking, to_refund=True):
"""Helper method to create a return of the original picking. It could
be refundable or not"""
return_wiz_form = Form(
self.env["stock.return.picking"].with_context(
active_ids=picking.ids,
active_id=picking[:1].id,
active_model="stock.picking",
)
)
return_wiz = return_wiz_form.save()
return_wiz.product_return_moves.quantity = picking.move_lines.quantity_done
return_wiz.product_return_moves.to_refund = to_refund
res = return_wiz.create_returns()
return_picking = self.env["stock.picking"].browse(res["res_id"])
self._validate_picking(return_picking)
def _test_autorefresh_void_line(self, lock=False, to_refund=True, invoice=False):
"""Helper method to test the possible cases for voiding the line"""
self.assertFalse(self.order.order_line.filtered("is_delivery"))
self.settings.auto_add_delivery_line = True
self.settings.auto_void_delivery_line = True
self.settings.execute()
line_delivery = self._confirm_sale_order(self.order)
self._validate_picking(self.order.picking_ids)
if invoice:
self.order._create_invoices()
if lock:
self.order.action_done()
self._return_whole_picking(self.order.picking_ids, to_refund)
return line_delivery
def test_auto_refresh_so_and_return_no_invoiced(self):
"""The delivery line is voided as all conditions apply when the return
is made"""
line_delivery = self._test_autorefresh_void_line()
self.assertEqual(line_delivery.price_unit, 0)
self.assertEqual(line_delivery.product_uom_qty, 0)
def test_auto_refresh_so_and_return_no_invoiced_locked(self):
"""The delivery line is voided as all conditions apply when the return
is made. We overrided the locked state in this case"""
line_delivery = self._test_autorefresh_void_line(lock=True)
self.assertEqual(line_delivery.price_unit, 0)
self.assertEqual(line_delivery.product_uom_qty, 0)
def test_auto_refresh_so_and_return_invoiced(self):
"""There's already an invoice, so the delivery line can't be voided"""
line_delivery = self._test_autorefresh_void_line(invoice=True)
self.assertEqual(line_delivery.price_unit, 50)
self.assertEqual(line_delivery.product_uom_qty, 1)
def test_auto_refresh_so_and_return_no_refund(self):
"""The return wasn't flagged to refund, so the delivered qty won't
change, thus the delivery line shouldn't be either"""
line_delivery = self._test_autorefresh_void_line(to_refund=False)
self.assertEqual(line_delivery.price_unit, 50)
self.assertEqual(line_delivery.product_uom_qty, 1)
def _test_autorefresh_unlink_line(self):
"""Helper method to test the possible cases for voiding the line"""
self.assertFalse(self.order.order_line.filtered("is_delivery"))
self.settings.auto_add_delivery_line = True
self.settings.execute()
sale_form = Form(self.order)
# Force the delivery line creation
with sale_form.order_line.edit(0) as line_form:
line_form.product_uom_qty = 2
sale_form.save()
return self.order.order_line.filtered("is_delivery")
def test_auto_refresh_so_and_unlink_line(self):
"""The return wasn't flagged to refund, so the delivered qty won't
change, thus the delivery line shouldn't be either"""
self._test_autorefresh_unlink_line()
delivery_line = self.order.order_line.filtered("is_delivery")
sale_form = Form(self.order)
sale_form.order_line.remove(0)
sale_form.save()
self.assertFalse(delivery_line.exists())
| 44.0033 | 13,333 |
6,253 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Pedro M. Baeza
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class SaleOrder(models.Model):
_inherit = "sale.order"
available_carrier_ids = fields.Many2many(
comodel_name="delivery.carrier",
compute="_compute_available_carrier_ids",
)
@api.onchange("partner_id", "partner_shipping_id")
def _onchange_partner_id(self):
res = None
if hasattr(super(), "_onchange_partner_id"):
res = super()._onchange_partner_id()
set_default_carrier = (
self.env["ir.config_parameter"]
.sudo()
.get_param("delivery_auto_refresh.set_default_carrier")
)
if set_default_carrier:
for order in self:
action = order.action_open_delivery_wizard()
carrier_id = self.env["delivery.carrier"].browse(
action["context"]["default_carrier_id"]
)
# If the carrier isn't allowed for the current shipping address, we wont
# default to it. In that case we'd try to fallback to the former carrier.
order.carrier_id = fields.first(
(carrier_id | order.carrier_id).filtered(
lambda x: x in order.available_carrier_ids._origin
)
)
return res
@api.depends("partner_shipping_id")
def _compute_available_carrier_ids(self):
"""We want to apply the same carriers filter in the header as in the wizard"""
for sale in self:
wizard = self.env["choose.delivery.carrier"].new({"order_id": sale.id})
sale.available_carrier_ids = wizard.available_carrier_ids._origin
def _get_param_auto_add_delivery_line(self):
# When we have the context 'website_id' it means that we are doing the order from
# e-commerce. So we don't want to add the delivery line automatically.
if self.env.context.get("website_id"):
return False
return (
self.env["ir.config_parameter"]
.sudo()
.get_param("delivery_auto_refresh.auto_add_delivery_line")
)
def _auto_refresh_delivery(self):
self.ensure_one()
# Make sure that if you have removed the carrier, the line is gone
if self.state in {"draft", "sent"}:
# Context added to avoid the recursive calls and save the new
# value of carrier_id
self.with_context(auto_refresh_delivery=True)._remove_delivery_line()
if self._get_param_auto_add_delivery_line() and self.carrier_id:
if self.state in {"draft", "sent"}:
price_unit = self.carrier_id.rate_shipment(self)["price"]
self._create_delivery_line(self.carrier_id, price_unit)
self.with_context(auto_refresh_delivery=True).write(
{"recompute_delivery_price": False}
)
@api.model
def create(self, vals):
"""Create or refresh delivery line on create."""
order = super().create(vals)
order._auto_refresh_delivery()
return order
def write(self, vals):
"""Create or refresh delivery line after saving."""
res = super().write(vals)
if self._get_param_auto_add_delivery_line() and not self.env.context.get(
"auto_refresh_delivery"
):
for order in self:
delivery_line = order.order_line.filtered("is_delivery")
order.with_context(
delivery_discount=delivery_line[-1:].discount,
)._auto_refresh_delivery()
return res
def _create_delivery_line(self, carrier, price_unit):
"""Allow users to keep discounts to delivery lines. Unit price will
be recomputed anyway"""
sol = super()._create_delivery_line(carrier, price_unit)
discount = self.env.context.get("delivery_discount")
if discount and sol:
sol.discount = discount
return sol
def set_delivery_line(self, carrier, amount):
if self._get_param_auto_add_delivery_line() and self.state in {"draft", "sent"}:
self.carrier_id = carrier.id
else:
return super().set_delivery_line(carrier, amount)
def _remove_delivery_line(self):
current_carrier = self.carrier_id
res = super()._remove_delivery_line()
self.carrier_id = current_carrier
return res
def _is_delivery_line_voidable(self):
"""If the picking is returned before being invoiced, like when the picking
is delivered but immediately return because the customer refused the order,
so no delivery charges should be applied."""
# There are invoiceable lines so there's no full return or the lines
# were not set to refund.
qty_delivered = sum(
self.order_line.filtered(
lambda x: not x.is_delivery and x.product_id.type != "service"
).mapped("qty_delivered")
)
# There must be validated pickings
pickings = self.picking_ids.filtered(lambda x: x.state == "done")
# If there aren't delivery lines or the order is a quotation there's
# nothing to be done either. If there are more than one delivery lines
# we won't be doing anything as well.
if (
self.state not in {"done", "sale"}
or self.invoice_ids
or not self.order_line.filtered("is_delivery")
or len(self.order_line.filtered("is_delivery")) > 1
or qty_delivered
or not pickings
):
return False
return True
class SaleOrderLine(models.Model):
_inherit = "sale.order.line"
def _get_protected_fields(self):
"""Avoid locked orders validation error when voiding the
delivery line"""
fields = super()._get_protected_fields()
if self.env.context.get("delivery_auto_refresh_override_locked"):
return [x for x in fields if x not in ["product_uom_qty", "price_unit"]]
return fields
| 41.138158 | 6,253 |
3,527 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2023 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import models
class StockPicking(models.Model):
_inherit = "stock.picking"
def _add_delivery_cost_to_so(self):
"""Update delivery price in SO (no matter the type of carrier invoicing policy)
and in picking from picking data if indicated so. Carriers based on rules
doesn't refresh with real picking data, only with SO ones.
"""
res = super()._add_delivery_cost_to_so()
refresh_after_picking = (
self.env["ir.config_parameter"]
.sudo()
.get_param("delivery_auto_refresh.refresh_after_picking")
)
if not refresh_after_picking:
return res
self.ensure_one()
sale_order = self.sale_id
if not sale_order or not self.carrier_id: # pragma: no cover
return res
so_line = sale_order.order_line.filtered(lambda x: x.is_delivery)[:1]
if not so_line: # pragma: no cover
return res
so_line = so_line.with_context(delivery_auto_refresh_override_locked=True)
if self.carrier_id.delivery_type == "base_on_rule":
total = weight = volume = quantity = 0
for move_line in self.move_line_ids.filtered("qty_done"):
if not move_line.product_id:
continue
move = move_line.move_id
qty = move.product_uom._compute_quantity(
move_line.qty_done,
move_line.product_id.uom_id,
)
weight += (move_line.product_id.weight or 0.0) * qty
volume += (move_line.product_id.volume or 0.0) * qty
quantity += qty
total += move.sale_line_id.price_unit * qty
total = sale_order.currency_id._convert(
total,
sale_order.company_id.currency_id,
sale_order.company_id,
sale_order.date_order,
)
self.carrier_price = self.carrier_id._get_price_from_picking(
total,
weight,
volume,
quantity,
)
if self.carrier_price and so_line.price_unit != self.carrier_price:
so_line.with_context(
delivery_auto_refresh_override_locked=True
).price_unit = self.carrier_price
return res
def _action_done(self):
res = super()._action_done()
# If configured, we want to set to 0 automatically the delivery line
# when we have a returned picking that isn't invoiced so we don't have
# it as invoiceable line. Otherwise, the salesman has to do it by hand.
auto_void_delivery_line = (
self.env["ir.config_parameter"]
.sudo()
.get_param("delivery_auto_refresh.auto_void_delivery_line")
)
if not auto_void_delivery_line:
return res
sales_to_void_delivery = self.filtered(
lambda x: x.sale_id
and x.picking_type_code == "incoming"
and x.sale_id._is_delivery_line_voidable()
).mapped("sale_id")
sales_to_void_delivery.mapped("order_line").filtered(
lambda x: x.is_delivery
).with_context(delivery_auto_refresh_override_locked=True).write(
{"qty_delivered": 0, "product_uom_qty": 0, "price_unit": 0}
)
return res
| 41.494118 | 3,527 |
905 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Tecnativa - Pilar Vargas Moreno
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
set_default_carrier = fields.Boolean(
"Set Default Carrier Automatically",
config_parameter="delivery_auto_refresh.set_default_carrier",
)
auto_add_delivery_line = fields.Boolean(
"Add Delivery Line Automatically",
config_parameter="delivery_auto_refresh.auto_add_delivery_line",
)
refresh_after_picking = fields.Boolean(
"Refresh After Picking Automatically",
config_parameter="delivery_auto_refresh.refresh_after_picking",
)
auto_void_delivery_line = fields.Boolean(
"Void delivery lines automatically",
config_parameter="delivery_auto_refresh.auto_void_delivery_line",
)
| 36.2 | 905 |
542 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Stock Picking Delivery Link",
"summary": "Adds link to the delivery on all intermediate operations.",
"version": "15.0.1.0.1",
"author": "Camptocamp, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/delivery-carrier",
"category": "Warehouse Management",
"depends": ["stock", "delivery"],
"data": ["views/stock_picking.xml"],
"installable": True,
"license": "AGPL-3",
}
| 36.133333 | 542 |
2,739 |
py
|
PYTHON
|
15.0
|
# Copyright 2021-2021 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from .common import StockPickingDeliveryLinkCommonCase
class TestStockPickingDeliveryLink(StockPickingDeliveryLinkCommonCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.product = cls.env["product.product"].create(
{"name": "Test Product", "type": "product"}
)
def test_ship_data_from_pick(self):
move1 = self._create_move(
self.product,
self.stock_loc,
self.shelf1_loc,
picking_type_id=self.wh.pick_type_id.id,
)
move2 = self._create_move(
self.product,
self.stock_loc,
self.shelf1_loc,
picking_type_id=self.wh.pack_type_id.id,
)
move3 = self._create_move(
self.product,
self.shelf1_loc,
self.shelf2_loc,
picking_type_id=self.wh.out_type_id.id,
)
(move1 | move2 | move3)._assign_picking()
carrier = self.env.ref("delivery.free_delivery_carrier")
move3.picking_id.carrier_id = carrier
move1.move_dest_ids = move2
move2.move_dest_ids = move3
ship = move1.picking_id.ship_picking_id
self.assertEqual(ship, move3.picking_id)
self.assertEqual(ship.carrier_id, carrier)
def test_ship_data_from_pack(self):
move1 = self._create_move(
self.product,
self.stock_loc,
self.shelf1_loc,
picking_type_id=self.wh.pack_type_id.id,
)
move2 = self._create_move(
self.product,
self.shelf1_loc,
self.shelf2_loc,
picking_type_id=self.wh.out_type_id.id,
)
(move1 | move2)._assign_picking()
carrier = self.env.ref("delivery.free_delivery_carrier")
move2.picking_id.carrier_id = carrier
move1.move_dest_ids = move2
ship = move1.picking_id.ship_picking_id
self.assertEqual(ship, move2.picking_id)
self.assertEqual(ship.carrier_id, carrier)
def test_ship_data_no_ship_found(self):
move1 = self._create_move(
self.product,
self.stock_loc,
self.shelf1_loc,
picking_type_id=self.wh.pick_type_id.id,
)
move2 = self._create_move(
self.product,
self.shelf1_loc,
self.shelf2_loc,
picking_type_id=self.wh.pack_type_id.id,
)
(move1 | move2)._assign_picking()
move1.move_dest_ids = move2
self.assertFalse(move1.picking_id.ship_picking_id)
self.assertFalse(move1.picking_id.ship_carrier_id)
| 33.814815 | 2,739 |
1,116 |
py
|
PYTHON
|
15.0
|
# Copyright 2020-2021 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests import TransactionCase
class StockPickingDeliveryLinkCommonCase(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
cls.wh = cls.env.ref("stock.warehouse0")
cls.stock_loc = cls.wh.lot_stock_id
cls.shelf1_loc = cls.env.ref("stock.stock_location_components")
cls.shelf2_loc = cls.env.ref("stock.stock_location_14")
def _create_move(self, product, src_location, dst_location, **values):
Move = self.env["stock.move"]
# simulate create + onchange
move = Move.new(
{
"product_id": product.id,
"location_id": src_location.id,
"location_dest_id": dst_location.id,
}
)
move._onchange_product_id()
move_values = move._convert_to_write(move._cache)
move_values.update(**values)
return Move.create(move_values)
| 34.875 | 1,116 |
1,549 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptocamp SA (http://www.camptocamp.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
def get_first_move_dest(moves, done=False):
move_states = ("cancel", "done")
for move in moves.move_dest_ids:
if done and move.state in move_states:
return move
if not done and move.state not in move_states:
return move
class StockPicking(models.Model):
_inherit = "stock.picking"
ship_picking_id = fields.Many2one(
comodel_name="stock.picking",
compute="_compute_ship_picking_data",
string="Related delivery",
)
ship_carrier_id = fields.Many2one(
comodel_name="delivery.carrier",
compute="_compute_ship_picking_data",
string="Related carrier",
)
def _compute_ship_picking_data(self):
for picking in self:
ship = picking._get_ship_from_chain()
picking.ship_picking_id = ship
picking.ship_carrier_id = ship.carrier_id
def _get_ship_from_chain(self, done=False):
"""Returns the shipment related to the current operation."""
move_dest = get_first_move_dest(self.move_lines, done=done)
while move_dest:
picking = move_dest.picking_id
if picking.picking_type_id.code == "outgoing":
return picking
move_dest = get_first_move_dest(move_dest, done=done)
# Should return an empty record if we reach this line
return self.browse()
| 34.422222 | 1,549 |
832 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Delivery CTT Express",
"summary": "Delivery Carrier implementation for CTT Express API",
"version": "15.0.1.1.0",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": ["delivery_package_number", "delivery_state", "delivery_price_method"],
"external_dependencies": {"python": ["zeep"]},
"data": [
"security/ir.model.access.csv",
"wizards/cttexpress_manifest_wizard_views.xml",
"wizards/cttexpress_pickup_wizard.xml",
"views/delivery_cttexpress_view.xml",
"views/stock_picking_views.xml",
],
}
| 39.619048 | 832 |
4,239 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
# Copyright 2022 Tecnativa - David Vidal
from odoo.exceptions import UserError
from odoo.tests import Form, common
class TestDeliveryCTTExpress(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.shipping_product = cls.env["product.product"].create(
{"type": "service", "name": "Test Shipping costs", "list_price": 10.0}
)
cls.carrier_cttexpress = cls.env["delivery.carrier"].create(
{
"name": "CTT Express",
"delivery_type": "cttexpress",
"product_id": cls.shipping_product.id,
"debug_logging": True,
"prod_environment": False,
# CTT will maintain these credentials in order to allow OCA testing
"cttexpress_user": "000002ODOO1",
"cttexpress_password": "CAL%224271",
"cttexpress_agency": "000002",
"cttexpress_contract": "1",
"cttexpress_customer": "ODOO1",
"cttexpress_shipping_type": "19H",
}
)
cls.product = cls.env["product.product"].create(
{"type": "consu", "name": "Test product"}
)
cls.wh_partner = cls.env["res.partner"].create(
{
"name": "My Spanish WH",
"city": "Zaragoza",
"zip": "50001",
"street": "C/ Mayor, 1",
"country_id": cls.env.ref("base.es").id,
}
)
cls.partner = cls.env["res.partner"].create(
{
"name": "Mr. Odoo & Co.",
"city": "Madrid",
"zip": "28001",
"email": "[email protected]",
"street": "Calle de La Rua, 3",
"country_id": cls.env.ref("base.es").id,
}
)
order_form = Form(cls.env["sale.order"].with_context(tracking_disable=True))
order_form.partner_id = cls.partner
with order_form.order_line.new() as line:
line.product_id = cls.product
line.product_uom_qty = 20.0
cls.sale_order = order_form.save()
cls.sale_order.carrier_id = cls.carrier_cttexpress
cls.sale_order.action_confirm()
# Ensure shipper address
cls.sale_order.warehouse_id.partner_id = cls.wh_partner
cls.picking = cls.sale_order.picking_ids
cls.picking.move_lines.quantity_done = 20
def test_00_cttexpress_test_connection(self):
"""Test credentials validation"""
self.carrier_cttexpress.action_ctt_validate_user()
self.carrier_cttexpress.cttexpress_password = "Bad password"
with self.assertRaises(UserError):
self.carrier_cttexpress.action_ctt_validate_user()
def test_01_cttexpress_picking_confirm_simple(self):
"""The picking is confirm and the shipping is recorded to CTT Express"""
self.picking.button_validate()
self.assertTrue(self.picking.carrier_tracking_ref)
self.picking.tracking_state_update()
self.assertTrue(self.picking.tracking_state)
self.picking.cancel_shipment()
self.assertFalse(self.picking.carrier_tracking_ref)
def test_02_cttexpress_picking_confirm_simple_pt(self):
"""We can deliver from Portugal as well"""
self.wh_partner.country_id = self.env.ref("base.pt")
self.picking.button_validate()
self.assertTrue(self.picking.carrier_tracking_ref)
def test_03_cttexpress_manifest(self):
"""API work although without data"""
wizard = self.env["cttexpress.manifest.wizard"].create({})
wizard.carrier_ids = self.carrier_cttexpress
wizard.get_manifest()
# There we have our manifest
self.assertTrue(wizard.attachment_ids)
def test_04_cttexpress_pickup(self):
"""API work although without data"""
wizard = self.env["cttexpress.pickup.wizard"].create(
{"carrier_id": self.carrier_cttexpress.id, "min_hour": 0.0}
)
wizard.create_pickup_request()
# There we have our manifest
self.assertTrue(wizard.code)
| 41.558824 | 4,239 |
2,144 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
# Master Data provided by CTT Express
CTTEXPRESS_SERVICES = [
("01V", "VALIJA UNITOQUE DIARIA"),
("02V", "VALIJA BITOQUE DIARIA"),
("03V", "VALIJA UNITOQUE 3 DIAS"),
("04V", "VALIJA BITOQUE 3 DÍAS"),
("10H", "10 HORAS"),
("13A", "13 HORAS ISLAS"),
("13H", "13 HORAS"),
("13M", "FRANCIA 13M"),
("13O", "OPTICA"),
("18M", "FRANCIA 18M"),
("19A", "CANARIAS E-COMMERCE"),
("19E", "19 E-COMMERCE"),
("19H", "19 HORAS"),
("48E", "48 E-COMMERCE"),
("48H", "48 HORAS"),
("48M", "48 CANARIAS MARITIMO"),
("48N", "48H NUEVOS CLIENTES"),
("48P", "48 E-COMMERCE NUEVOS CLIENTES"),
("63E", "RECOGERAN E-COMMERCE CANARIAS"),
("63P", "PUNTOS CERCANÍA"),
("63R", "RECOGERAN EN AGENCIA"),
("80I", "GLOBAL EXPRESS"),
("80R", "GLOBAL RECOGIDA INTERNACIONAL"),
("80T", "GLOBAL EXPRESS"),
("81I", "TERRESTRE ECONOMY"),
("81R", "RECOGIDA TERRESTRE ECONOMY"),
("81T", "TERRESTRE ECONOMY"),
("830", "8.30 HORAS"),
("93T", "TERRESTE E-COMMERCE"),
]
CTTEXPRESS_DELIVERY_STATES_STATIC = {
"0": "shipping_recorded_in_carrier", # PENDIENTE DE ENTRADA EN RED
"1": "in_transit", # EN TRANSITO
"2": "in_transit", # EN REPARTO
"3": "customer_delivered", # ENTREGADO
"4": "incidence", # INCIDENCIA
"5": "incidence", # DEVOLUCION
"6": "in_transit", # RECOGERAN EN AGENCIA
"7": "incidence", # RECANALIZADO
"8": "incidence", # NO REALIZADO
"9": "incidence", # RETORNADO
"10": "in_transit", # EN ADUANA
"11": "in_transit", # EN AGENCIA
"12": "customer_delivered", # ENTREGA PARCIAL
"13": "incidence", # POSICIONADO EN PER
"50": "incidence", # DEVOLUCION DESDE PLATAFORMA
"51": "incidence", # DEVOLUCION SINIESTROS MERCANCIA YA EVALUADA
"70": "incidence", # RECANALIZADO A SINIESTROS POR PLATAFORMA
"71": "incidence", # REENCAMINADO
"90": "canceled_shipment", # ANULADO
"91": "in_transit", # REACTIVACION ENVIO (TOL)
"99": "in_transit", # COMPUESTO
}
| 35.7 | 2,142 |
9,799 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from lxml import etree
from zeep import Client
from zeep.helpers import serialize_object
from zeep.plugins import HistoryPlugin
_logger = logging.getLogger(__name__)
CTTEXPRESS_API_URL = {
"test": "http://iberws.tourlineexpress.com:8686/ClientsAPI.svc?singleWsdl",
"prod": "http://iberws.tourlineexpress.com:8700/ClientsAPI.svc?singleWsdl",
}
def log_request(method):
"""Decorator to write raw request/response in the CTT request object"""
def wrapper(*args, **kwargs):
res = method(*args, **kwargs)
try:
args[0].ctt_last_request = etree.tostring(
args[0].history.last_sent["envelope"],
encoding="UTF-8",
pretty_print=True,
)
args[0].ctt_last_response = etree.tostring(
args[0].history.last_received["envelope"],
encoding="UTF-8",
pretty_print=True,
)
# Don't fail hard on this. Sometimes zeep can't keep history
except Exception:
return res
return res
return wrapper
class CTTExpressRequest:
"""Interface between CTT Express SOAP API and Odoo recordset.
Abstract CTT Express API Operations to connect them with Odoo
"""
def __init__(self, user, password, agency, customer, contract, prod=False):
self.user = user
self.password = password
self.agency = agency
self.customer = customer
self.contract = contract
self.history = HistoryPlugin(maxlen=10)
# We'll store raw xml request/responses in this properties
self.ctt_last_request = False
self.ctt_last_response = False
self.client = Client(
wsdl=CTTEXPRESS_API_URL["prod" if prod else "test"],
plugins=[self.history],
)
@staticmethod
def _format_error(error):
"""Common method to format error outputs
:param zeep.objects.ArrayOfErrorResult error: Error response or None
:return list: List of tuples with errors (code, description)
"""
if not error:
return []
return [(x.ErrorCode, x.ErrorMessage) for x in error.ErrorResult]
@staticmethod
def _format_document(documents):
"""Common method to format document outputs
:param list document: List of documents
"""
if not documents:
return []
return [(x.FileName, x.FileContent) for x in documents.Document]
def _credentials(self):
"""Get the credentials in the API expected format.
:return dict: Credentials keys and values
"""
return {
"Id": self.user,
"Password": self.password,
"ContractCode": self.contract,
"ClientCode": self.customer,
"AgencyCode": self.agency,
}
# API Methods
@log_request
def manifest_shipping(self, shipping_values):
"""Create shipping with the proper picking values
:param dict shipping_values: Shippng values prepared from Odoo
:return tuple: tuple containing:
list: Error Codes
list: Document binaries
str: Shipping code
"""
values = dict(self._credentials(), **shipping_values)
response = self.client.service.ManifestShipping(**values)
return (
self._format_error(response.ErrorCodes),
self._format_document(response.Documents),
response.ShippingCode,
)
@log_request
def get_tracking(self, shipping_code):
"""Gather tracking status of shipping code. Maps to API's GetTracking.
:param str shipping_code: Shipping code
:return tuple: contents of tuple:
list: error codes in the form of tuples (code, descriptions)
list: of OrderedDict with statuses
"""
values = dict(self._credentials(), ShippingCode=shipping_code)
response = self.client.service.GetTracking(**values)
return (
self._format_error(response.ErrorCodes),
(response.Tracking and serialize_object(response.Tracking.Tracking) or []),
)
@log_request
def get_documents(self, shipping_code):
"""Get shipping documents (label)
:param str shipping_code: Shipping code
:return tuple: tuple containing:
list: error codes in the form of tuples (code, descriptions)
list: documents in the form of tuples (file_content, file_name)
"""
values = dict(self._credentials(), ShippingCode=shipping_code)
response = self.client.service.GetDocuments(**values)
return (
self._format_error(response.ErrorCodes),
self._format_document(response.Documents),
)
@log_request
def get_documents_multi(
self,
shipping_codes,
document_code="LASER_MAIN_ES",
model_code="SINGLE",
kind_code="PDF",
offset=0,
):
"""Get shipping codes documents
:param str shipping_codes: shipping codes separated by ;
:param str document_code: Document code, defaults to LASER_MAIN_ES
:param str model_code: (SINGLE|MULTI1|MULTI3|MULTI4), defaults to SINGLE
- SINGLE: Thermical single label printer
- MULTI1: Sheet format 1 label per sheet
- MULTI3: Portrait 3 labels per sheet
- MULTI4: Landscape 4 labels per sheet
:param str kind_code: (PDF|PNG|BMP), defaults to PDF
:param int offset: Document offset, defaults to 0
:return tuple: tuple containing:
list: error codes in the form of tuples (code, descriptions)
list: documents in the form of tuples (file_content, file_name)
"""
values = dict(
self._credentials(),
**{
"ShippingCodes": shipping_codes,
"DocumentCode": document_code,
"ModelCode": model_code,
"KindCode": kind_code,
"Offset": offset,
}
)
response = self.client.service.GetDocumentsV2(**values)
return (
self._format_error(response.ErrorCodes),
self._format_document(response.Documents),
)
@log_request
def get_service_types(self):
"""Gets the hired service types. Maps to API's GetServiceTypes.
:return tuple: contents of tuple:
list: error codes in the form of tuples (code, descriptions)
list: list of tuples (service_code, service_description):
"""
response = self.client.service.GetServiceTypes(**self._credentials())
return (
self._format_error(response.ErrorCodes),
[
(x.ShippingTypeCode, x.ShippingTypeDescription)
for x in response.Services.ClientShippingType
],
)
@log_request
def cancel_shipping(self, shipping_code):
"""Cancel a shipping by code
:param str shipping_code: Shipping code
:return str: Error codes
"""
values = dict(self._credentials(), ShippingCode=shipping_code)
response = self.client.service.CancelShipping(**values)
return [(x.ErrorCode, x.ErrorMessage) for x in response]
@log_request
def report_shipping(
self, process_code="ODOO", document_type="XLSX", from_date=None, to_date=None
):
"""Get the shippings manifest. Mapped to API's ReportShipping
:param str process_code: (ODOO|MAGENTO|PRESTASHOP), defaults to "ODOO"
:param str document_type: Report type, defaults to "XLSX" (PDF|XLSX)
:param str from_date: Date from "yyyy-mm-dd", defaults to None.
:param str to_date: Date to "yyyy-mm-dd", defaults to None.
:return tuple: tuple containing:
list: error codes in the form of tuples (code, descriptions)
list: documents in the form of tuples (file_content, file_name)
"""
values = dict(
self._credentials(),
ProcessCode=process_code,
DocumentKindCode=document_type,
FromDate=from_date,
ToDate=to_date,
)
response = self.client.service.ReportShipping(**values)
return (
self._format_error(response.ErrorCodes),
self._format_document(response.Documents),
)
@log_request
def validate_user(self):
"""Validate credentials against the API.
:return tuple: tuple containing:
int: Error code (0 for success)
str: Validation result message
"""
response = self.client.service.ValidateUser(**self._credentials())[0]
return [(response.ErrorCode, response.ErrorMessage)]
@log_request
def create_request(self, delivery_date, min_hour, max_hour):
"""Create a shipping pickup request. CreateRequest API's mapping.
:param datetime.date delivery_date: Delivery date
:param str min_hour: Minimum pickup hour in format "HH:MM"
:param str max_hour: Maximum pickup hour in format "HH:MM"
:return tuple: tuple containing:
list: Error codes
str: Request shipping code
"""
values = dict(
self._credentials(),
**{
"DeliveryDate": delivery_date,
"HourMinuteMin1": min_hour,
"HourMinuteMax1": max_hour,
}
)
response = self.client.service.CreateRequest(**values)
return (self._format_error(response.ErrorCodes), response.RequestShippingCode)
| 35.762774 | 9,799 |
720 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, models
class StockPicking(models.Model):
_inherit = "stock.picking"
def cttexpress_get_label(self):
"""Get label for current picking
:return tuple: (filename, filecontent)
"""
self.ensure_one()
tracking_ref = self.carrier_tracking_ref
if self.delivery_type != "cttexpress" or not tracking_ref:
return
label = self.carrier_id.cttexpress_get_label(tracking_ref)
self.message_post(
body=(_("CTT Express label for %s") % tracking_ref),
attachments=label,
)
return label
| 30 | 720 |
12,268 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import UserError
from .cttexpress_master_data import (
CTTEXPRESS_DELIVERY_STATES_STATIC,
CTTEXPRESS_SERVICES,
)
from .cttexpress_request import CTTExpressRequest
class DeliveryCarrier(models.Model):
_inherit = "delivery.carrier"
delivery_type = fields.Selection(
selection_add=[("cttexpress", "CTT Express")],
ondelete={"cttexpress": "set default"},
)
cttexpress_user = fields.Char(string="User")
cttexpress_password = fields.Char(string="Password")
cttexpress_customer = fields.Char(string="Customer code")
cttexpress_agency = fields.Char(string="Agency code")
cttexpress_contract = fields.Char(string="Contract code")
cttexpress_shipping_type = fields.Selection(
selection=CTTEXPRESS_SERVICES,
string="Shipping type",
)
cttexpress_document_model_code = fields.Selection(
selection=[
("SINGLE", "Single"),
("MULTI1", "Multi 1"),
("MULTI3", "Multi 3"),
("MULTI4", "Multi 4"),
],
default="SINGLE",
string="Document model",
)
cttexpress_document_format = fields.Selection(
selection=[("PDF", "PDF"), ("PNG", "PNG"), ("BMP", "BMP")],
default="PDF",
string="Document format",
)
cttexpress_document_offset = fields.Integer(string="Document Offset")
@api.onchange("delivery_type")
def _onchange_delivery_type_ctt(self):
"""Default price method for CTT as the API can't gather prices."""
if self.delivery_type == "cttexpress":
self.price_method = "base_on_rule"
def _ctt_request(self):
"""Get CTT Request object
:return CTTExpressRequest: CTT Express Request object
"""
return CTTExpressRequest(
user=self.cttexpress_user,
password=self.cttexpress_password,
agency=self.cttexpress_agency,
customer=self.cttexpress_customer,
contract=self.cttexpress_contract,
prod=self.prod_environment,
)
@api.model
def _ctt_log_request(self, ctt_request):
"""When debug is active requests/responses will be logged in ir.logging
:param ctt_request ctt_request: CTT Express request object
"""
self.log_xml(ctt_request.ctt_last_request, "ctt_request")
self.log_xml(ctt_request.ctt_last_response, "ctt_response")
def _ctt_check_error(self, error):
"""Common error checking. We stop the program when an error is returned.
:param list error: List of tuples in the form of (code, description)
:raises UserError: Prompt the error to the user
"""
if not error:
return
error_msg = ""
for code, msg in error:
if not code:
continue
error_msg += "{} - {}\n".format(code, msg)
if not error_msg:
return
raise UserError(_("CTT Express Error:\n\n%s") % error_msg)
@api.model
def _cttexpress_format_tracking(self, tracking):
"""Helper to forma tracking history strings
:param OrderedDict tracking: CTT tracking values
:return str: Tracking line
"""
status = "{} - [{}] {}".format(
fields.Datetime.to_string(tracking["StatusDateTime"]),
tracking["StatusCode"],
tracking["StatusDescription"],
)
if tracking["IncidentCode"]:
status += " ({}) - {}".format(
tracking["IncidentCode"], tracking["IncidentDescription"]
)
return status
@api.onchange("cttexpress_shipping_type")
def _onchange_cttexpress_shipping_type(self):
"""Control service validity according to credentials
:raises UserError: We list the available services for given credentials
"""
if not self.cttexpress_shipping_type:
return
# Avoid checking if credentianls aren't setup or are invalid
try:
self.action_ctt_validate_user()
except UserError:
return
ctt_request = self._ctt_request()
error, service_types = ctt_request.get_service_types()
self._ctt_log_request(ctt_request)
self._ctt_check_error(error)
type_codes, type_descriptions = zip(*service_types)
if self.cttexpress_shipping_type not in type_codes:
service_name = dict(
self._fields["cttexpress_shipping_type"]._description_selection(
self.env
)
)[self.cttexpress_shipping_type]
raise UserError(
_(
"This CTT Express service (%(service_name)s) isn't allowed for "
"this account configuration. Please choose one of the followings\n"
"%(type_descriptions)s",
service_name=service_name,
type_descriptions=type_descriptions,
)
)
def action_ctt_validate_user(self):
"""Maps to API's ValidateUser method
:raises UserError: If the user credentials aren't valid
"""
self.ensure_one()
ctt_request = self._ctt_request()
error = ctt_request.validate_user()
self._ctt_log_request(ctt_request)
# For user validation success there's an error return as well.
# We better ignore it.
if error[0]:
self._ctt_check_error(error)
def _prepare_cttexpress_shipping(self, picking):
"""Convert picking values for CTT Express API
:param record picking: `stock.picking` record
:return dict: Values prepared for the CTT connector
"""
self.ensure_one()
# A picking can be delivered from any warehouse
sender_partner = (
picking.picking_type_id.warehouse_id.partner_id
or picking.company_id.partner_id
)
recipient = picking.partner_id
recipient_entity = picking.partner_id.commercial_partner_id
weight = picking.shipping_weight
reference = picking.name
if picking.sale_id:
reference = "{}-{}".format(picking.sale_id.name, reference)
return {
"ClientReference": reference, # Optional
"ClientDepartmentCode": None, # Optional (no core field matches)
"ItemsCount": picking.number_of_packages,
"IsClientPodScanRequired": None, # Optional
"RecipientAddress": recipient.street,
"RecipientCountry": recipient.country_id.code,
"RecipientEmail": recipient.email or recipient_entity.email, # Optional
"RecipientSMS": None, # Optional
"RecipientMobile": recipient.mobile or recipient_entity.mobile, # Optional
"RecipientName": recipient.name or recipient_entity.name,
"RecipientPhone": recipient.phone or recipient_entity.phone,
"RecipientPostalCode": recipient.zip,
"RecipientTown": recipient.city,
"RefundValue": None, # Optional
"HasReturn": None, # Optional
"IsSaturdayDelivery": None, # Optional
"SenderAddress": sender_partner.street,
"SenderName": sender_partner.name,
"SenderPhone": sender_partner.phone or "",
"SenderPostalCode": sender_partner.zip,
"SenderTown": sender_partner.city,
"ShippingComments": None, # Optional
"ShippingTypeCode": self.cttexpress_shipping_type,
"Weight": int(weight * 1000) or 1, # Weight in grams
"PodScanInstructions": None, # Optional
"IsFragile": None, # Optional
"RefundTypeCode": None, # Optional
"CreatedProcessCode": "ODOO", # Optional
"HasControl": None, # Optional
"HasFinalManagement": None, # Optional
}
def cttexpress_send_shipping(self, pickings):
"""CTT Express wildcard method called when a picking is confirmed
:param record pickings: `stock.picking` recordset
:raises UserError: On any API error
:return dict: With tracking number and delivery price (always 0)
"""
ctt_request = self._ctt_request()
result = []
for picking in pickings:
vals = self._prepare_cttexpress_shipping(picking)
try:
error, documents, tracking = ctt_request.manifest_shipping(vals)
self._ctt_check_error(error)
except Exception as e:
raise (e)
finally:
self._ctt_log_request(ctt_request)
vals.update({"tracking_number": tracking, "exact_price": 0})
# The default shipping method doesn't allow to configure the label
# format, so once we get the tracking, we ask for it again.
documents = self.cttexpress_get_label(tracking)
# We post an extra message in the chatter with the barcode and the
# label because there's clean way to override the one sent by core.
body = _("CTT Shipping Documents")
picking.message_post(body=body, attachments=documents)
result.append(vals)
return result
def cttexpress_cancel_shipment(self, pickings):
"""Cancel the expedition
:param recordset: pickings `stock.picking` recordset
:returns boolean: True if success
"""
ctt_request = self._ctt_request()
for picking in pickings.filtered("carrier_tracking_ref"):
try:
error = ctt_request.cancel_shipping(picking.carrier_tracking_ref)
self._ctt_check_error(error)
except Exception as e:
raise (e)
finally:
self._ctt_log_request(ctt_request)
return True
def cttexpress_get_label(self, reference):
"""Generate label for picking
:param str reference: shipping reference
:returns tuple: (file_content, file_name)
"""
self.ensure_one()
if not reference:
return False
ctt_request = self._ctt_request()
try:
error, label = ctt_request.get_documents_multi(
reference,
model_code=self.cttexpress_document_model_code,
kind_code=self.cttexpress_document_format,
offset=self.cttexpress_document_offset,
)
self._ctt_check_error(error)
except Exception as e:
raise (e)
finally:
self._ctt_log_request(ctt_request)
if not label:
return False
return label
def cttexpress_tracking_state_update(self, picking):
"""Wildcard method for CTT Express tracking followup
:param recod picking: `stock.picking` record
"""
self.ensure_one()
if not picking.carrier_tracking_ref:
return
ctt_request = self._ctt_request()
try:
error, trackings = ctt_request.get_tracking(picking.carrier_tracking_ref)
self._ctt_check_error(error)
except Exception as e:
raise (e)
finally:
self._ctt_log_request(ctt_request)
picking.tracking_state_history = "\n".join(
[self._cttexpress_format_tracking(tracking) for tracking in trackings]
)
current_tracking = trackings.pop()
picking.tracking_state = self._cttexpress_format_tracking(current_tracking)
picking.delivery_state = CTTEXPRESS_DELIVERY_STATES_STATIC.get(
current_tracking["StatusCode"], "incidence"
)
def cttexpress_get_tracking_link(self, picking):
"""Wildcard method for CTT Express tracking link.
:param record picking: `stock.picking` record
:return str: tracking url
"""
tracking_url = (
"https://app.cttexpress.com/AreaClientes/Views/" "Destinatarios.aspx?s={}"
)
return tracking_url.format(picking.carrier_tracking_ref)
| 38.946032 | 12,268 |
2,168 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class CTTExpressPickupWizard(models.TransientModel):
_name = "cttexpress.pickup.wizard"
_description = "Generate shipping pickups"
carrier_id = fields.Many2one(
comodel_name="delivery.carrier",
domain=[("delivery_type", "=", "cttexpress")],
)
delivery_date = fields.Date(required=True, default=fields.Date.context_today)
min_hour = fields.Float(required=True)
max_hour = fields.Float(required=True, default=23.99)
code = fields.Char(readonly=True)
state = fields.Selection(
selection=[("new", "new"), ("done", "done")],
default="new",
readonly=True,
)
@api.onchange("min_hour", "max_hour")
def _onchange_hours(self):
"""Min and max hours UX"""
# Avoid negative or after midnight
self.min_hour = min(self.min_hour, 23.99)
self.min_hour = max(self.min_hour, 0.0)
self.max_hour = min(self.max_hour, 23.99)
self.max_hour = max(self.max_hour, 0.0)
# Avoid wrong order
self.max_hour = max(self.max_hour, self.min_hour)
def create_pickup_request(self):
"""Get the pickup code"""
def convert_float_time_to_str(float_time):
"""Helper to pass the times in the expexted format 'HH:MM'"""
return "{:02.0f}:{:02.0f}".format(*divmod(float_time * 60, 60))
ctt_request = self.carrier_id._ctt_request()
delivery_date = fields.Date.to_string(self.delivery_date)
error, code = ctt_request.create_request(
delivery_date,
convert_float_time_to_str(self.min_hour),
convert_float_time_to_str(self.max_hour),
)
self.carrier_id._ctt_check_error(error)
self.carrier_id._ctt_log_request(ctt_request)
self.code = code
self.state = "done"
return dict(
self.env["ir.actions.act_window"]._for_xml_id(
"delivery_cttexpress.action_delivery_cttexpress_pickup_wizard"
),
res_id=self.id,
)
| 37.37931 | 2,168 |
3,525 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import base64
from odoo import fields, models
class CTTExpressManifestWizard(models.TransientModel):
_name = "cttexpress.manifest.wizard"
_description = "Get the CTT Express Manifest for the given date range"
document_type = fields.Selection(
selection=[("XLSX", "Excel"), ("PDF", "PDF")],
string="Format",
default="XLSX",
required=True,
)
from_date = fields.Date(required=True, default=fields.Date.context_today)
to_date = fields.Date(required=True, default=fields.Date.context_today)
carrier_ids = fields.Many2many(
string="Filter accounts",
comodel_name="delivery.carrier",
domain=[("delivery_type", "=", "cttexpress")],
help="Leave empty to gather all the CTT account manifests",
)
state = fields.Selection(
selection=[("new", "new"), ("done", "done")],
default="new",
readonly=True,
)
attachment_ids = fields.Many2many(
comodel_name="ir.attachment", readonly=True, string="Manifests"
)
def get_manifest(self):
"""List of shippings for the given dates as CTT provides them"""
carriers = self.carrier_ids or self.env["delivery.carrier"].search(
[("delivery_type", "=", "cttexpress")]
)
# Avoid getting repeated manifests. Carriers with different service
# configuration would produce the same manifest.
unique_accounts = {
(c.cttexpress_customer, c.cttexpress_contract, c.cttexpress_agency)
for c in carriers
}
filtered_carriers = self.env["delivery.carrier"]
for customer, contract, agency in unique_accounts:
filtered_carriers += fields.first(
carriers.filtered(
lambda x: x.cttexpress_customer == customer
and x.cttexpress_contract == contract
and x.cttexpress_agency == agency
)
)
for carrier in filtered_carriers:
ctt_request = carrier._ctt_request()
from_date = fields.Date.to_string(self.from_date)
to_date = fields.Date.to_string(self.to_date)
error, manifest = ctt_request.report_shipping(
"ODOO", self.document_type, from_date, to_date
)
carrier._ctt_check_error(error)
carrier._ctt_log_request(ctt_request)
for _filename, file in manifest:
filename = "{}{}{}-{}-{}.{}".format(
carrier.cttexpress_customer,
carrier.cttexpress_contract,
carrier.cttexpress_agency,
from_date.replace("-", ""),
to_date.replace("-", ""),
self.document_type.lower(),
)
self.attachment_ids += self.env["ir.attachment"].create(
{
"datas": base64.b64encode(file),
"name": filename,
"res_model": self._name,
"res_id": self.id,
"type": "binary",
}
)
self.state = "done"
return dict(
self.env["ir.actions.act_window"]._for_xml_id(
"delivery_cttexpress.action_delivery_cttexpress_manifest_wizard"
),
res_id=self.id,
)
| 40.056818 | 3,525 |
879 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Partner Delivery Zone",
"summary": "This module allows to create partner delivery zones for physical products",
"version": "15.0.1.1.0",
"development_status": "Beta",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Pesol, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["sale_stock", "contacts"],
"data": [
"security/ir.model.access.csv",
"views/partner_delivery_zone_view.xml",
"views/res_partner_view.xml",
"views/sale_order_view.xml",
"views/stock_picking_view.xml",
"views/report_deliveryslip.xml",
"views/report_shipping.xml",
],
}
| 36.625 | 879 |
6,875 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from lxml import etree
from odoo.tests import TransactionCase
class TestPartnerDeliveryZone(TransactionCase):
at_install = False
post_install = True
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.warehouse = cls.env.ref("stock.warehouse0")
cls.delivery_zone_a = cls.env["partner.delivery.zone"].create(
{"name": "Delivery Zone A", "code": "10"}
)
cls.delivery_zone_b = cls.env["partner.delivery.zone"].create(
{"name": "Delivery Zone A", "code": "10"}
)
cls.partner = cls.env["res.partner"].create(
{"name": "test", "delivery_zone_id": cls.delivery_zone_a.id}
)
cls.product = cls.env["product.product"].create({"name": "test"})
so = cls.env["sale.order"].new(
{
"partner_id": cls.partner.id,
"order_line": [
(
0,
0,
{
"name": cls.product.name,
"product_id": cls.product.id,
"product_uom_qty": 10.0,
"product_uom": cls.product.uom_id.id,
"price_unit": 1000.00,
},
)
],
}
)
so.onchange_partner_id()
cls.order = cls.env["sale.order"].create(so._convert_to_write(so._cache))
cls.View = cls.env["ir.ui.view"]
def test_partner_child_propagate(self):
other_partner = self.env["res.partner"].create(
{"name": "other partner", "delivery_zone_id": self.delivery_zone_b.id}
)
self.order.partner_shipping_id = other_partner
self.assertEqual(self.order.delivery_zone_id, other_partner.delivery_zone_id)
def test_sale_order_confirm(self):
self.order.action_confirm()
self.assertEqual(
self.order.picking_ids.delivery_zone_id, self.partner.delivery_zone_id
)
def test_stock_picking(self):
partner2 = self.env["res.partner"].create(
{"name": "partner 2", "delivery_zone_id": self.delivery_zone_b.id}
)
self.order.action_confirm()
self.order.picking_ids.partner_id = partner2
self.assertEqual(self.order.picking_ids.delivery_zone_id, self.delivery_zone_b)
def _get_ctx_from_view(self, res):
partner_xml = etree.XML(res["arch"])
partner_path = "//field[@name='child_ids']"
partner_field = partner_xml.xpath(partner_path)[0]
return partner_field.attrib.get("context", "{}")
def test_default_line_discount_value(self):
res = self.partner.fields_view_get(
view_id=self.env.ref("partner_delivery_zone.view_partner_form").id,
view_type="form",
)
ctx = self._get_ctx_from_view(res)
self.assertTrue("default_delivery_zone_id" in ctx)
view = self.View.create(
{
"name": "test",
"type": "form",
"model": "res.partner",
"arch": """
<data>
<field name='child_ids'
context="{'default_name': 'test'}">
</field>
</data>
""",
}
)
res = self.partner.fields_view_get(view_id=view.id, view_type="form")
ctx = self._get_ctx_from_view(res)
self.assertTrue("default_delivery_zone_id" in ctx)
def test_order_assign_commercial_partner_delivery_zone(self):
# For contact type partners the delivery zone get from commercial
# partner
self.child_partner_contact = self.env["res.partner"].create(
{"name": "Partner contact", "type": "contact", "parent_id": self.partner.id}
)
self.child_partner_delivery = self.env["res.partner"].create(
{
"name": "Partner delivery",
"type": "delivery",
"parent_id": self.partner.id,
}
)
self.order.partner_shipping_id = self.child_partner_contact
self.assertEqual(self.order.delivery_zone_id, self.partner.delivery_zone_id)
self.order.partner_shipping_id = self.child_partner_delivery
self.assertFalse(self.order.delivery_zone_id)
def test_picking_assign_commercial_partner_contact_zone(self):
# For contact type partners the delivery zone get from commercial
# partner
self.child_partner_contact = self.env["res.partner"].create(
{"name": "Partner contact", "type": "contact", "parent_id": self.partner.id}
)
self.order.action_confirm()
picking = self.order.picking_ids[0]
picking.partner_id = self.child_partner_contact
self.assertEqual(picking.delivery_zone_id, self.partner.delivery_zone_id)
def test_picking_assign_commercial_partner_delivery_zone(self):
# For contact type partners the delivery zone get from commercial
# partner
self.child_partner_delivery = self.env["res.partner"].create(
{
"name": "Partner delivery",
"type": "delivery",
"parent_id": self.partner.id,
}
)
self.order.action_confirm()
picking = self.order.picking_ids[0]
picking.partner_id = self.child_partner_delivery
self.assertFalse(picking.delivery_zone_id)
def test_change_delivery_zone(self):
self.order.action_confirm()
self.assertEqual(self.order.picking_ids.delivery_zone_id, self.delivery_zone_a)
self.order.picking_ids.delivery_zone_id = self.delivery_zone_b
self.assertEqual(self.order.delivery_zone_id, self.delivery_zone_b)
self.order.delivery_zone_id = self.delivery_zone_a
self.assertEqual(self.order.picking_ids.delivery_zone_id, self.delivery_zone_a)
def test_wharehouse_three_steps(self):
self.warehouse.delivery_steps = "pick_pack_ship"
self.order.action_confirm()
for picking in self.order.picking_ids:
self.assertEqual(picking.delivery_zone_id, self.order.delivery_zone_id)
def test_wharehouse_three_steps_so_wo_delivery_zone(self):
# If SO has not delivery zone, all pickings obtains the delivery zone
# from shipping partner
self.warehouse.delivery_steps = "pick_pack_ship"
self.order.delivery_zone_id = False
self.order.action_confirm()
for picking in self.order.picking_ids:
self.assertEqual(
picking.delivery_zone_id,
self.order.partner_shipping_id.delivery_zone_id,
)
| 40.441176 | 6,875 |
1,318 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class SaleOrder(models.Model):
_inherit = "sale.order"
delivery_zone_id = fields.Many2one(
comodel_name="partner.delivery.zone",
string="Delivery Zone",
ondelete="restrict",
compute="_compute_delivery_zone_id",
store=True,
readonly=False,
index=True,
)
@api.depends("partner_shipping_id")
def _compute_delivery_zone_id(self):
for so in self:
partner = (
so.partner_shipping_id
if so.partner_shipping_id.type == "delivery"
else so.partner_shipping_id.commercial_partner_id
)
so.delivery_zone_id = partner.delivery_zone_id
def write(self, vals):
# Update picking delivery zone if user update it in sale order that
# creates a picking,
res = super().write(vals)
if "delivery_zone_id" in vals and not self.env.context.get(
"skip_delivery_zone_update", False
):
self.mapped("picking_ids").with_context(
skip_delivery_zone_update=True
).write({"delivery_zone_id": vals["delivery_zone_id"]})
return res
| 33.794872 | 1,318 |
383 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class PartnerDeliveryZone(models.Model):
_name = "partner.delivery.zone"
_description = "Partner delivery zone"
code = fields.Char()
name = fields.Char(string="Zone", required=True)
active = fields.Boolean(default=True)
| 31.916667 | 383 |
805 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import models
class StockMove(models.Model):
_inherit = "stock.move"
def get_original_move(self):
if self.move_dest_ids:
return self.move_dest_ids.get_original_move()
return self
def _get_new_picking_values(self):
vals = super()._get_new_picking_values()
original_move = self.get_original_move()
zone_id = original_move.sale_line_id.order_id.delivery_zone_id.id
if not zone_id:
zone_id = (
self.env["res.partner"]
.browse(vals.get("partner_id", False))
.delivery_zone_id.id
)
vals["delivery_zone_id"] = zone_id
return vals
| 32.2 | 805 |
1,279 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class StockPicking(models.Model):
_inherit = "stock.picking"
delivery_zone_id = fields.Many2one(
comodel_name="partner.delivery.zone",
string="Delivery Zone",
index=True,
store=True,
readonly=False,
compute="_compute_delivery_zone_id",
)
@api.depends("partner_id")
def _compute_delivery_zone_id(self):
for picking in self:
partner = (
picking.partner_id
if picking.partner_id.type == "delivery"
else picking.partner_id.commercial_partner_id
)
picking.delivery_zone_id = partner.delivery_zone_id
def write(self, vals):
# Update sale order delivery zone if user update it a picking linked
# to a sale order,
res = super().write(vals)
if "delivery_zone_id" in vals and not self.env.context.get(
"skip_delivery_zone_update", False
):
self.mapped("sale_id").with_context(skip_delivery_zone_update=True).write(
{"delivery_zone_id": vals["delivery_zone_id"]}
)
return res
| 33.657895 | 1,279 |
1,516 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from lxml import etree
from odoo import api, fields, models
class ResPartner(models.Model):
_inherit = "res.partner"
delivery_zone_id = fields.Many2one(
comodel_name="partner.delivery.zone",
string="Delivery Zone",
ondelete="restrict",
index=True,
)
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
"""The purpose of this is to write a context on "child_ids" field
respecting other contexts on this field.
There is a PR (https://github.com/odoo/odoo/pull/26607) to odoo for
avoiding this. If merged, remove this method and add the attribute
in the field.
"""
res = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "form":
partner_xml = etree.XML(res["arch"])
partner_fields = partner_xml.xpath("//field[@name='child_ids']")
if partner_fields:
partner_field = partner_fields[0]
context = partner_field.attrib.get("context", "{}").replace(
"{", "{'default_delivery_zone_id': delivery_zone_id, ", 1
)
partner_field.attrib["context"] = context
res["arch"] = etree.tostring(partner_xml)
return res
| 36.97561 | 1,516 |
1,093 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
{
"name": "Routific Connector",
"summary": "Connector for Routific Platform",
"version": "15.0.1.0.0",
"development_status": "Production/Stable",
"category": "Inventory",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"maintainers": ["CarlosRoca13"],
"depends": ["stock", "phone_validation"],
"external_dependencies": {"python": ["lxml", "email_validator"]},
"data": [
"data/sequence.xml",
"security/ir.model.access.csv",
"views/product_attribute_views.xml",
"views/routific_config_views.xml",
"views/routific_driver_views.xml",
"views/routific_project_views.xml",
"views/res_partner_view.xml",
"wizards/routific_project_creator_view.xml",
"views/routific_project_driver_view.xml",
"views/stock_picking_views.xml",
],
}
| 37.689655 | 1,093 |
13,020 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import datetime
import json
from functools import partial
from unittest.mock import patch
import requests
import odoo
from odoo.exceptions import UserError
from odoo.tests.common import Form, TransactionCase
PATH = "odoo.addons.connector_routific.models.routific_config.requests"
patch_post = partial(patch, PATH + ".post")
patch_get = partial(patch, PATH + ".get")
@odoo.tests.tagged("post_install", "-at_install")
class TestConnectorRoutific(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# Operation types
operation_form = Form(cls.env["stock.picking.type"])
operation_form.name = "Test delivery type"
operation_form.sequence_code = "TDT"
operation_form.code = "outgoing"
cls.operation_type = operation_form.save()
# Config creation
config_form = Form(cls.env["routific.config"])
config_form.name = "Test config"
config_form.token = "API_TOKEN"
config_form.picking_type_id = cls.operation_type
cls.config = config_form.save()
cls.config.sequence = -1
# Country Creation
country = cls.env.ref("base.us")
# State Creation
state = cls.env["res.country.state"].create(
{"name": "Some state", "code": "02", "country_id": country.id}
)
# Clients Creation
cls.client_1 = cls.env["res.partner"].create(
{
"name": "Test client 1",
"street": "Some street 1",
"city": "Some city",
"state_id": state.id,
"zip": "12345",
"country_id": country.id,
}
)
cls.client_2 = cls.env["res.partner"].create(
{
"name": "Test client 2",
"street": "Some street 2",
"city": "Some city",
"state_id": state.id,
"zip": "12345",
"country_id": country.id,
}
)
# Driver Creation
cls.env.company.partner_id.street = "Some street origin"
cls.env.company.partner_id.city = "Some city"
cls.env.company.partner_id.state_id = state
cls.env.company.partner_id.zip = "12345"
cls.env.company.partner_id.country_id = country
cls.driver_1 = cls.env["res.partner"].create(
{
"name": "Test Driver 1",
"company_type": "person",
"is_routific_driver": True,
"routific_driver_active": True,
"routific_start": 9.0,
"routific_end": 12.0,
"partner_start_id": cls.env.company.partner_id.id,
}
)
# Product Creation
cls.product = cls.env["product.product"].create(
{"name": "Storable product", "type": "product"}
)
cls.wh1 = cls.env["stock.warehouse"].create(
{"name": "TEST WH1", "code": "TST1"}
)
cls.env["stock.quant"].create(
{
"product_id": cls.product.id,
"location_id": cls.wh1.lot_stock_id.id,
"quantity": 100.0,
}
)
# Pickings Creation
cls.picking_1 = cls.env["stock.picking"].create(
{
"location_id": cls.wh1.lot_stock_id.id,
"location_dest_id": cls.wh1.wh_output_stock_loc_id.id,
"picking_type_id": cls.operation_type.id,
"partner_id": cls.client_1.id,
"move_lines": [
(
0,
0,
{
"name": cls.product.name,
"location_id": cls.wh1.lot_stock_id.id,
"location_dest_id": cls.wh1.wh_output_stock_loc_id.id,
"product_id": cls.product.id,
"product_uom": cls.product.uom_id.id,
"product_uom_qty": 10,
},
)
],
}
)
cls.picking_1.state = "assigned"
cls.picking_2 = cls.env["stock.picking"].create(
{
"location_id": cls.wh1.lot_stock_id.id,
"location_dest_id": cls.wh1.wh_output_stock_loc_id.id,
"picking_type_id": cls.operation_type.id,
"partner_id": cls.client_2.id,
"move_lines": [
(
0,
0,
{
"name": cls.product.name,
"location_id": cls.wh1.lot_stock_id.id,
"location_dest_id": cls.wh1.wh_output_stock_loc_id.id,
"product_id": cls.product.id,
"product_uom": cls.product.uom_id.id,
"product_uom_qty": 10,
},
)
],
}
)
cls.picking_2.state = "assigned"
def _get_header(self):
return {
"Content-Type": "application/json",
"Authorization": "Bearer API_TOKEN",
}
def _get_post_creation_data(self, project):
return {
"name": project.name,
"date": project.date.strftime("%Y-%m-%d"),
"drivers": [
{
"name": "Test Driver 1 [%s]" % (self.driver_1.id),
"start_location": {
"address": (
"Some street origin, Some city, Some state, 12345, "
"United States"
)
},
"end_location": {
"address": (
"Some street origin, Some city, Some state, 12345, "
"United States"
)
},
"shift_start": "09:00",
"shift_end": "12:00",
"speed": 1.0,
"types": [],
},
],
"stops": [
{
"name": "Test client 1",
"location": {
"address": (
"Some street 1, Some city, Some state, 12345, United States"
)
},
"types": [],
"custom_notes": {"picking_id": str(self.picking_1.id)},
},
],
"settings": {
"max_stop_lateness": 0,
"max_driver_overtime": 0,
"shortest_distance": False,
"traffic": 1.0,
"strict_start": False,
"auto_balance": False,
"default_load": 1,
"default_duration": 10,
},
}
def _get_post_new_data(self, project):
return [
{
"name": "Test client 2",
"location": {
"address": (
"Some street 2, Some city, Some state, 12345, United States"
)
},
"types": [],
"custom_notes": {"picking_id": str(self.picking_2.id)},
}
]
def _get_data_for_get(self, project_id):
return {
"solution": {
"routes": [
{
"_id": project_id.project_driver_ids[0].routific_driver_id,
"visits": [
{"id": self.picking_1.routific_stop_id},
{"id": self.picking_2.routific_stop_id},
],
}
]
}
}
def _create_project_wiz(self):
wizard_form = Form(
self.env["routific.project.creator"].with_context(
active_ids=self.picking_1.ids
)
)
wizard = wizard_form.save()
data = wizard.create_project()
return self.env["routific.project"].browse(data["res_id"])
def test_wizard_fill_info(self):
wizard_form = Form(self.env["routific.project.creator"])
self.assertTrue(self.driver_1 in wizard_form.driver_ids)
self.assertEqual(wizard_form.config_id, self.config)
self.assertEqual(
wizard_form.date,
datetime.date.today() + datetime.timedelta(days=1),
)
def test_project_creation_from_wizard(self):
project_id = self._create_project_wiz()
self.assertTrue(
self.driver_1 in project_id.project_driver_ids.mapped("driver_id")
)
self.assertTrue(self.picking_1 == project_id.picking_ids)
self.assertEqual(project_id.routific_config_id, self.config)
self.assertEqual(
project_id.date, datetime.date.today() + datetime.timedelta(days=1)
)
def test_bad_connection(self):
def bad_response():
response = requests.Response()
response.status_code = 404
return response
project_id = self._create_project_wiz()
with patch_post(return_value=bad_response()) as post_mock:
# If the API server returns 404 error, it explodes in user's face
with self.assertRaises(UserError):
project_id.send_project()
# Assert module did the correct API call
post_mock.assert_called_once_with(
"https://product-api.routific.com/v1.0/project",
headers=self._get_header(),
json=self._get_post_creation_data(project_id),
)
def test_full_operation(self):
project_id = self._create_project_wiz()
def creation_response():
response = requests.Response()
response.status_code = 200
response.encoding = "utf-8"
data = self._get_post_creation_data(project_id)
data["id"] = "project_id"
data["stops"][0]["id"] = "stop_id_1"
data["drivers"][0]["id"] = "driver_id_1"
response._content = json.dumps(data).encode(encoding=response.encoding)
return response
def addition_response():
response = requests.Response()
response.status_code = 200
response.encoding = "utf-8"
data = self._get_post_new_data(project_id)
data[0]["id"] = "stop_id_2"
response._content = json.dumps(data).encode(encoding=response.encoding)
return response
def get_response():
response = requests.Response()
response.status_code = 200
response.encoding = "utf-8"
data = self._get_data_for_get(project_id)
response._content = json.dumps(data).encode(encoding=response.encoding)
return response
with patch_post(return_value=creation_response()) as post_mock:
project_id.send_project()
# Assert module did the correct API call
post_mock.assert_called_once_with(
"https://product-api.routific.com/v1.0/project",
headers=self._get_header(),
json=self._get_post_creation_data(project_id),
)
# Assert that project, stops and drivers have his ids from Routific
self.assertEqual(project_id.routific_project_id, "project_id")
self.assertEqual(self.picking_1.routific_stop_id, "stop_id_1")
self.assertEqual(
project_id.project_driver_ids[0].routific_driver_id, "driver_id_1"
)
project_id.picking_ids += self.picking_2
with patch_post(return_value=addition_response()) as post_mock:
project_id.button_send_new_stops()
# Assert module did the correct API call
post_mock.assert_called_once_with(
"https://product-api.routific.com/v0.1/project/%s/stops/"
% (project_id.routific_project_id),
headers=self._get_header(),
json=self._get_post_new_data(project_id),
)
self.assertEqual(self.picking_2.routific_stop_id, "stop_id_2")
with patch_get(return_value=get_response()) as get_mock:
project_id.get_solution()
# Assert module did the correct API call
get_mock.assert_called_once_with(
"https://api.routific.com/product/projects/%s"
% (project_id.routific_project_id),
headers=self._get_header(),
)
self.assertEqual(self.picking_1.driver_id, self.driver_1)
self.assertEqual(self.picking_2.driver_id, self.driver_1)
| 38.294118 | 13,020 |
9,689 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import json
from datetime import date, timedelta
from odoo import _, api, fields, models
from odoo.exceptions import UserError
class RoutificProject(models.Model):
_name = "routific.project"
_inherit = ["mail.thread", "mail.activity.mixin"]
_description = "Project for Routific"
def _default_routific_config_id(self):
config_ids = self.env["routific.config"].search([])
if config_ids:
return min(config_ids, key=lambda rc: rc.sequence)
def _default_project_driver_ids(self):
active_drivers = self.env["res.partner"].search(
[("is_routific_driver", "=", True), ("routific_driver_active", "=", True)]
)
project_drivers = self.env["routific.project.driver"]
for driver in active_drivers:
project_drivers = project_drivers + project_drivers.create(
{"driver_id": driver.id}
)
return project_drivers
name = fields.Char(readonly=True, default="New", copy=False, required=True)
company_id = fields.Many2one(
comodel_name="res.company",
default=lambda self: self.env.company.id,
string="Company",
required=True,
)
routific_project_id = fields.Char(string="Routific project id")
date = fields.Date(default=date.today() + timedelta(days=1), required=True)
project_driver_ids = fields.One2many(
comodel_name="routific.project.driver",
inverse_name="project_id",
string="Drivers",
required=True,
default=_default_project_driver_ids,
)
picking_ids = fields.Many2many(
comodel_name="stock.picking",
string="Stops",
required=True,
domain="[('id', '=', allowed_picking_ids)]",
)
allowed_picking_ids = fields.Many2many(
comodel_name="stock.picking", compute="_compute_allowed_picking_ids"
)
has_new_picking = fields.Boolean(compute="_compute_has_new_picking")
state = fields.Selection(
selection=[("draft", "Draft"), ("send", "Sent")],
string="Status",
readonly=True,
default="draft",
help="""
* The 'Draft' is used when a user create a new project\n
* The 'Sent' is used when the project is sended to Routific
""",
)
routific_config_id = fields.Many2one(
comodel_name="routific.config",
string="Settings",
required=True,
default=_default_routific_config_id,
)
json_send = fields.Text()
json_retrieve = fields.Text()
json_solution = fields.Text()
@api.model
def create(self, vals):
vals["name"] = self.env["ir.sequence"].next_by_code("routific.project")
res = super().create(vals)
# Fill the "picking_ids.routific_project_id" with the ID of the created project.
for picking in res.picking_ids:
picking.routific_project_id = res.id
picking.routific_stop_id = False
return res
def write(self, vals):
res = super().write(vals)
# Fill the "picking_ids.routific_project_id" with the ID of the created project.
if vals.get("picking_ids"):
for picking in self.picking_ids:
if picking.routific_project_id.id != self.id:
picking.routific_stop_id = False
picking.routific_project_id = self.id
return res
def _get_drivers(self):
"""With this method we get the info of all drivers selected."""
drivers = []
for driver in self.project_driver_ids.mapped("driver_id"):
vals = driver.get_routific_data(self.routific_config_id)
drivers.append(vals)
return drivers
def _get_stops(self, picking_ids):
"""With this method we get the info of all stops selected."""
stops = []
for stop in picking_ids:
if stop.picking_type_id == self.routific_config_id.picking_type_id:
value = stop.get_routific_data(self.routific_config_id)
stops.append(value)
return stops
def _get_all_stops(self):
return self._get_stops(self.picking_ids)
def send_project(self):
"""With this method we make the dictionary that has to be posted and we process
the response.
"""
data = {
"name": self.name,
"date": self.date.strftime("%Y-%m-%d"),
"drivers": self._get_drivers(),
"stops": self._get_all_stops(),
"settings": self.routific_config_id.get_settings(),
}
json_str = json.dumps(data) + "\n"
self.json_send = self.json_send + json_str if self.json_send else json_str
res = self.routific_config_id.send_project(data)
json_str = res + "\n"
self.json_retrieve = (
self.json_retrieve + json_str if self.json_retrieve else json_str
)
res = json.loads(res)
self.routific_project_id = res.get("id")
self._set_routific_stop_id(res.get("stops", []))
self._set_routific_driver_id(res.get("drivers", []))
self.state = "send"
def _set_routific_driver_id(self, drivers):
"""Set the id of Routific to each routific.project.driver"""
for driver in drivers:
id_start = driver["name"].index("[") + 1
id_end = driver["name"].index("]")
partner_id = int(driver["name"][id_start:id_end])
project_driver = self.project_driver_ids.filtered(
lambda d: d.driver_id.id == partner_id
)
project_driver.routific_driver_id = driver["id"]
def _set_routific_stop_id(self, stops):
"""Set the id of Routific to each stock.picking"""
for stop in stops:
picking = self.picking_ids.search(
[("id", "=", int(stop.get("custom_notes", {}).get("picking_id")))]
)
picking.routific_stop_id = stop.get("id")
def get_solution(self):
"""Method that process the solution"""
res = self.routific_config_id.get_solution(self.routific_project_id)
json_str = res + "\n"
self.json_solution = (
self.json_solution + json_str if self.json_solution else json_str
)
res = json.loads(res)
solution = res.get("solution")
if solution:
routes = solution.get("routes", [])
for route in routes:
project_driver_id = self.project_driver_ids.filtered(
lambda pd: pd.routific_driver_id == route["_id"]
)
stop_sequence = 0
for visit in route["visits"]:
picking = self.picking_ids.search(
[("routific_stop_id", "=", visit["id"])]
)
if picking:
stop_sequence += 1
picking.routific_stop_sequence = stop_sequence
picking.driver_id = project_driver_id.driver_id
else:
raise UserError(
_(
"You have not optimice the route on Routific Platform for get "
"the solution."
)
)
def button_send_new_stops(self):
data = self._get_stops(
self.picking_ids.filtered(lambda p: not p.routific_stop_id)
)
json_str = json.dumps(data) + "\n"
self.json_send = self.json_send + json_str if self.json_send else json_str
res = self.routific_config_id.send_new_stops(self.routific_project_id, data)
json_str = res + "\n"
self.json_retrieve = (
self.json_retrieve + json_str if self.json_retrieve else json_str
)
res = json.loads(res)
self._set_routific_stop_id(res)
@api.depends("routific_config_id")
def _compute_allowed_picking_ids(self):
for record in self:
record.allowed_picking_ids = self.env["stock.picking"].search(
[
(
"picking_type_id",
"=",
record.routific_config_id.picking_type_id.id,
),
("state", "=", "assigned"),
("driver_id", "=", False),
]
)
@api.depends("picking_ids")
def _compute_has_new_picking(self):
for record in self:
new_pickings = record.picking_ids.filtered(lambda p: not p.routific_stop_id)
if new_pickings and record.state == "send":
self.has_new_picking = True
else:
self.has_new_picking = False
@api.onchange("picking_ids")
def _onchange_picking_ids(self):
actual_pickings = self.env["stock.picking"]
for picking in self.picking_ids:
actual_pickings += picking._origin
deleted_pickings = self._origin.picking_ids - actual_pickings
for picking in deleted_pickings:
if picking.routific_stop_id:
raise UserError(_("You can't delete a stop sent to routific"))
def action_affected_picking_tree_view(self):
return {
"name": _("Pickings"),
"view_mode": "tree",
"res_model": "stock.picking",
"view_id": False,
"views": [(self.env.ref("connector_routific.vpicktree").id, "tree")],
"type": "ir.actions.act_window",
"domain": [("id", "in", self.picking_ids.ids)],
"context": {"create": False},
}
| 38.756 | 9,689 |
718 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class RoutificProjectDriver(models.Model):
"""Routifc creates new drivers for every project created."""
_name = "routific.project.driver"
_description = "Routific drivers for every project"
driver_id = fields.Many2one(
comodel_name="res.partner",
string="Driver",
required=True,
domain=[
("is_routific_driver", "=", True),
("routific_driver_active", "=", True),
],
)
project_id = fields.Many2one(comodel_name="routific.project", string="Project")
routific_driver_id = fields.Char()
| 32.636364 | 718 |
2,746 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from email_validator import validate_email
from odoo import fields, models
from odoo.addons.resource.models.resource import float_to_time
class StockPicking(models.Model):
_inherit = "stock.picking"
driver_id = fields.Many2one(comodel_name="res.partner", string="Driver")
routific_stop_id = fields.Char(string="Routific stop id")
routific_project_id = fields.Many2one(
comodel_name="routific.project", string="Routific project id"
)
routific_stop_sequence = fields.Integer(string="Sequence stop")
def get_routific_data(self, config_id):
"""With this method we build the diccionary of one stop that has to be sent
to Routific.
"""
vals = {
"name": self.partner_id.name,
"location": {
"address": self.partner_id.get_address(
address_format=config_id.address_format, partner_id=self.partner_id
)
},
"types": self._get_product_types().mapped("name"),
"custom_notes": {"picking_id": "%s" % self.id},
}
if self.partner_id.routific_start != 0.0:
vals["start"] = float_to_time(self.partner_id.routific_start).strftime(
"%H:%M"
)
if self.partner_id.routific_end != 24.0:
vals["end"] = float_to_time(self.partner_id.routific_end).strftime("%H:%M")
# Compute mobile/phone for avoid send unformatted values
phone = self.partner_id.get_formatted_mobile_or_phone()
if phone:
vals["phone_number"] = phone
# Validate email for avoid send incorrect values
try:
email = validate_email(
self.partner_id.email, check_deliverability=False
).email
except Exception:
email = False
if email:
vals["email"] = email
if self.partner_id.delivery_duration:
vals["duration"] = self.partner_id.delivery_duration
if self.note:
vals["notes"] = self.note
return vals
def _get_product_types(self):
"""Method to get the afected types of products on a picking."""
attribute_value_ids = self.env["product.attribute.value"]
for product in self.move_lines.mapped("product_id"):
for tmpl_attribute_value in product.product_template_attribute_value_ids:
if tmpl_attribute_value.attribute_id.is_routific_type:
attribute_value_ids += (
tmpl_attribute_value.product_attribute_value_id
)
return attribute_value_ids
| 40.382353 | 2,746 |
279 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ProductAttribute(models.Model):
_inherit = "product.attribute"
is_routific_type = fields.Boolean(string="Is routific type")
| 31 | 279 |
4,868 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import requests
from odoo import _, api, fields, models
from odoo.exceptions import UserError
class RoutificConfig(models.Model):
_name = "routific.config"
_inherit = ["mail.thread", "mail.activity.mixin"]
_description = "Settings for Routific connexion."
_order = "sequence,id"
name = fields.Char(required=True)
sequence = fields.Integer()
company_id = fields.Many2one(
comodel_name="res.company",
default=lambda self: self.env.company.id,
string="Company",
)
post_endpoint = fields.Char(
"Post URL", default="https://product-api.routific.com", required=True
)
get_endpoint = fields.Char(
"Get URL", default="https://api.routific.com", required=True
)
token = fields.Text(required=True)
max_stop_lateness = fields.Integer(string="Maximum stop lateness")
max_driver_overtime = fields.Integer(string="Maximum driver overtime")
shortest_distance = fields.Boolean(string="Optimize by shortest distance")
traffic = fields.Float(
string="Traffic estimation", help="Faster = 1.0 - Slower = 2.0", default=1
)
strict_start = fields.Boolean(
string="Strict start",
help="""It forces the departure time of a driver to be at shift_start.
The default is false
""",
)
auto_balance = fields.Boolean(string="Stops distributed across all drivers")
default_load = fields.Integer(string="Default load of stops", default=1)
default_duration = fields.Integer(string="Default duration of stops", default=10)
picking_type_id = fields.Many2one(
comodel_name="stock.picking.type",
string="Allowed operation type",
required=True,
)
address_format = fields.Text(
string="Address format",
default="%(street)s, %(city)s, %(state)s, %(zip)s, %(country)s",
required=True,
)
def get_settings(self):
"""With this method we build the settings dictionary that has to be sent
to Routific.
"""
return {
"max_stop_lateness": self.max_stop_lateness,
"max_driver_overtime": self.max_driver_overtime,
"shortest_distance": self.shortest_distance,
"traffic": self.traffic,
"strict_start": self.strict_start,
"auto_balance": self.auto_balance,
"default_load": self.default_load,
"default_duration": self.default_duration,
}
def _routific_header(self):
"""This method does the construction of headers for the requests to the API."""
self.ensure_one()
if self.token:
return {
"Content-Type": "application/json",
"Authorization": "Bearer %s" % self.token,
}
else:
raise UserError(_("Token needed to make the comunication with Routific."))
def send_project(self, json_object):
"""This method is for post the project to Routific."""
url = self.post_endpoint + "/v1.0/project"
response = requests.post(url, headers=self._routific_header(), json=json_object)
if response.status_code != 200:
raise UserError(
_("Error on project posting %(code)s \n\n %(response)s")
% {"code": response.status_code, "response": response.text}
)
return response.text
def send_new_stops(self, routific_project_id, json_object):
"""This method is for post the new stops to a Routific project."""
url = self.post_endpoint + "/v0.1/project/%s/stops/" % routific_project_id
response = requests.post(url, headers=self._routific_header(), json=json_object)
if response.status_code != 200:
raise UserError(
_("Error at new stop posting %(code)s \n\n %(response)s")
% {"code": response.status_code, "response": response.text}
)
return response.text
def get_solution(self, project_id):
"""This method is for get the solution from Routific."""
url = self.get_endpoint + "/product/projects/%s" % (project_id)
response = requests.get(url, headers=self._routific_header())
if response.status_code != 200:
raise UserError(
_("Error at new stop posting %(code)s \n\n %(response)s")
% {"code": response.status_code, "response": response.text}
)
return response.text
@api.constrains("traffic")
def _check_range_traffic_value(self):
for rec in self:
if rec.traffic < 1.0 or rec.traffic > 2.0:
raise UserError(
_("The traffic estimation value must be between 1.0 and 2.0")
)
| 40.533333 | 4,864 |
6,051 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import UserError
from odoo.addons.phone_validation.tools.phone_validation import phone_format
from odoo.addons.resource.models.resource import float_to_time
class ResPartner(models.Model):
_inherit = "res.partner"
is_routific_driver = fields.Boolean(string="Is driver", company_dependent=True)
routific_driver_active = fields.Boolean(
string="Driver active",
company_dependent=True,
compute="_compute_routific_active",
readonly=False,
store=True,
)
partner_start_id = fields.Many2one(
comodel_name="res.partner", string="Start location"
)
partner_end_id = fields.Many2one(comodel_name="res.partner", string="End location")
finish_at_start = fields.Boolean(
string="Finish route where start", default=True, company_dependent=True
)
routific_start = fields.Float(
string="Start",
company_dependent=True,
help="""
If the partner is a driver, this value shows the start work schedule.
If it isn't it will show the start of the time that can receive a shipping.
""",
)
routific_end = fields.Float(
string="End",
default=24.0,
company_dependent=True,
help="""
If the partner is a driver, this value shows the end work schedule.
If it isn't it will show the end of the time that can receive a shipping.
""",
)
delivery_duration = fields.Integer(string="Delivery duration (MIN)")
speed = fields.Float(
default=1.0,
help="""Set the average speed of the driver
being 0.1 the smallest and 2.0 the biggest""",
)
capacity = fields.Integer(
company_dependent=True,
help="Keep as 0 for no control of capacity",
)
routific_type_ids = fields.Many2many(
comodel_name="product.attribute.value",
string="Types allowed",
domain="[('id', '=', allowed_routific_type_ids)]",
)
allowed_routific_type_ids = fields.Many2many(
comodel_name="product.attribute.value",
compute="_compute_allowed_routific_type_ids",
)
def _compute_routific_active(self):
"""Method to be extended in possible extra modules"""
def get_address(self, address_format="", partner_id=False):
"""With this method we achieve to calculate the address that has to be sent to
Routific API.
"""
args = {
"street": partner_id.street or "",
"city": partner_id.city or "",
"state": partner_id.state_id.name or "",
"zip": partner_id.zip or "",
"country": partner_id.country_id.name or "",
}
return address_format % args
def get_routific_data(self, config_id):
"""With this method we build the diccionary of one driver that has to be sent
to Routific.
"""
vals = {
"name": "{} [{}]".format(self.name, self.id),
"start_location": {
"address": self.get_address(
address_format=config_id.address_format,
partner_id=self.partner_start_id,
)
},
"speed": self.speed,
"types": self.routific_type_ids.mapped("name"),
}
if self.routific_start != 0.0:
vals["shift_start"] = float_to_time(self.routific_start).strftime("%H:%M")
if self.routific_end != 24.0:
vals["shift_end"] = float_to_time(self.routific_end).strftime("%H:%M")
phone = self.get_formatted_mobile_or_phone()
if phone:
vals["phone_number"] = phone
if self.finish_at_start:
vals["end_location"] = vals["start_location"]
elif self.partner_end_id:
vals["end_location"] = {
"address": self.get_address(
address_format=config_id.address_format,
partner_id=self.partner_end_id,
)
}
if self.capacity:
vals["capacity"] = self.capacity
return vals
@api.depends("company_id")
def _compute_allowed_routific_type_ids(self):
"""This method give us the allowed product.attribute.values that can be
selected on routific_type_ids field.
"""
for record in self:
attributes = self.env["product.attribute"].search(
[("is_routific_type", "=", True)]
)
record.allowed_routific_type_ids = attributes.mapped(
"attribute_line_ids.value_ids"
)
@api.constrains("speed")
def _check_range_speed_value(self):
for ref in self:
if ref.speed < 0.1 or ref.speed > 2.0:
raise UserError(
_("The speed of the driver must be a value between 0.1 and 2.0")
)
@api.constrains("routific_start", "routific_end")
def _check_time_values(self):
for ref in self:
if ref.routific_start >= ref.routific_end:
raise UserError(_("The start of the schedule must be before the end"))
if ref.routific_start < 0.0:
raise UserError(_("The day starts at 00:00"))
if ref.routific_end > 24.0:
raise UserError(_("The day ends at 24:00"))
def get_formatted_mobile_or_phone(self):
phone = self.mobile or self.phone
country = self.country_id or self.env.company.country_id
if phone:
try:
phone = phone_format(
phone,
country.code if country else None,
country.phone_code if country else None,
force_format="INTERNATIONAL",
raise_exception=True,
)
except Exception:
phone = False
return phone
| 37.583851 | 6,051 |
2,970 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from datetime import date, timedelta
from odoo import _, fields, models
from odoo.exceptions import UserError
class RoutificProjectCreator(models.TransientModel):
"""Wizard launched from stock.pickings that allow us to create routific.project
by selecting all the pickings that have to be delivered.
"""
_name = "routific.project.creator"
_description = "Wizard for Routific project creation"
def _default_driver_ids(self):
# By default we get all drivers.
return self.env["res.partner"].search(
[("is_routific_driver", "=", True), ("routific_driver_active", "=", True)]
)
def _default_config_id(self):
return min(self.env["routific.config"].search([]), key=lambda rc: rc.sequence)
driver_ids = fields.Many2many(
comodel_name="res.partner",
string="Drivers",
domain=[
("is_routific_driver", "=", True),
("routific_driver_active", "=", True),
],
default=_default_driver_ids,
required=True,
)
config_id = fields.Many2one(
comodel_name="routific.config",
string="Settings",
required=True,
default=_default_config_id,
)
date = fields.Date(
string="Delivery date", default=date.today() + timedelta(days=1), required=True
)
def create_project(self):
picking_ids = self.env["stock.picking"].browse(self.env.context["active_ids"])
for picking in picking_ids:
if picking.picking_type_id != self.config_id.picking_type_id:
raise UserError(
_(
"The operation type %(picking_name)s is not allowed on "
"%(config_name)s configuration"
)
% {
"picking_name": picking.picking_type_id.name,
"config_name": self.config_id.name,
}
)
if picking.driver_id:
raise UserError(
_("The picking %s has a driver assigned yet") % (picking.name)
)
if picking.state != "assigned":
raise UserError(_("The picking %s is not Ready") % (picking.name))
project = self.env["routific.project"].create(
{
"routific_config_id": self.config_id.id,
"picking_ids": self.env.context["active_ids"],
"project_driver_ids": [
(0, 0, {"driver_id": driver.id}) for driver in self.driver_ids
],
}
)
return {
"view_type": "form",
"view_mode": "form",
"res_model": "routific.project",
"res_id": project.id,
"type": "ir.actions.act_window",
"context": {},
}
| 36.219512 | 2,970 |
646 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Serv. Tecnol. Avanzados - Pedro M. Baeza
# Copyright 2016-2017 Pedro M. Baeza <[email protected]>
# Copyright 2017 Vicent Cubells <[email protected]>
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
{
"name": "Delivery costs in purchases",
"version": "15.0.1.0.0",
"development_status": "Production/Stable",
"category": "Operations/Purchase",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["purchase", "delivery"],
"data": ["views/purchase_order_view.xml"],
}
| 40.375 | 646 |
4,090 |
py
|
PYTHON
|
15.0
|
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from odoo.tests import Form, common
class TestDeliveryPurchase(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.delivery_product = cls.env["product.product"].create(
{"name": "Delivery test product"}
)
cls.carrier_fixed = cls.env["delivery.carrier"].create(
{
"product_id": cls.delivery_product.id,
"delivery_type": "fixed",
"fixed_price": 20,
"name": "Carrier Test",
}
)
cls.carrier_rules = cls.env["delivery.carrier"].create(
{
"name": "Carrier Rule",
"product_id": cls.delivery_product.id,
"delivery_type": "base_on_rule",
"price_rule_ids": [
(
0,
0,
{
"variable": "weight",
"operator": ">",
"max_value": 5,
"list_base_price": "30",
},
),
(
0,
0,
{
"variable": "weight",
"operator": "<=",
"max_value": 5,
"list_base_price": "10",
},
),
],
}
)
cls.partner = cls.env["res.partner"].create(
{
"name": "Test partner",
"property_delivery_carrier_id": cls.carrier_fixed.id,
}
)
cls.product = cls.env["product.product"].create({"name": "Test product"})
purchase_form = Form(cls.env["purchase.order"])
purchase_form.partner_id = cls.partner
with purchase_form.order_line.new() as purchase_line_form:
purchase_line_form.product_id = cls.product
purchase_line_form.price_unit = 1
cls.purchase = purchase_form.save()
cls.purchase_line = cls.purchase.order_line
def test_onchange_partner_id(self):
self.assertEqual(self.purchase.carrier_id, self.carrier_fixed)
def test_delivery_purchase(self):
self.purchase.get_delivery_cost()
self.assertEqual(self.purchase.delivery_price, 20)
self.purchase.carrier_id = self.carrier_rules.id
self.purchase.get_delivery_cost()
self.assertEqual(self.purchase.delivery_price, 10)
self.purchase_line.product_id.weight = 8
self.purchase.get_delivery_cost()
self.assertEqual(self.purchase.delivery_price, 30)
def test_picking_carrier(self):
self.purchase.button_confirm()
self.assertEqual(
self.purchase.picking_ids[0].carrier_id,
self.carrier_fixed,
)
def test_onchange_picking_carrier(self):
self.purchase.button_confirm()
picking = self.purchase.picking_ids
picking.carrier_id = self.carrier_rules.id
res = picking.button_validate()
model = self.env[res["res_model"]].with_context(**res["context"])
model.create({}).process()
self.assertEqual(picking.carrier_price, 10)
def test_onchange_picking_carrier_invoice_policy_real(self):
self.carrier_rules.invoice_policy = "real"
self.purchase.carrier_id = False
self.purchase.button_confirm()
picking = self.purchase.picking_ids
picking.carrier_id = self.carrier_rules.id
res = picking.button_validate()
model = self.env[res["res_model"]].with_context(**res["context"])
model.create({}).process()
self.assertEqual(picking.carrier_id, self.carrier_rules)
self.assertEqual(picking.carrier_price, 10)
self.assertEqual(self.purchase.carrier_id, self.carrier_rules)
self.assertEqual(self.purchase.delivery_price, 10)
| 38.584906 | 4,090 |
1,046 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Serv. Tecnol. Avanzados - Pedro M. Baeza
# Copyright 2016 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class PurchaseOrder(models.Model):
_inherit = "purchase.order"
carrier_id = fields.Many2one(
comodel_name="delivery.carrier",
string="Delivery Method",
)
delivery_price = fields.Float()
@api.onchange("partner_id")
def onchange_partner_id_delivery_purchase(self):
if self.partner_id.property_delivery_carrier_id:
self.carrier_id = self.partner_id.property_delivery_carrier_id.id
@api.onchange("order_line", "amount_total", "carrier_id")
def get_delivery_cost(self):
if self.carrier_id:
self.delivery_price = self.carrier_id.purchase_rate_shipment(self)["price"]
@api.model
def _prepare_picking(self):
res = super()._prepare_picking()
if self.carrier_id:
res["carrier_id"] = self.carrier_id.id
return res
| 32.6875 | 1,046 |
2,147 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, models
class StockPicking(models.Model):
_inherit = "stock.picking"
def _send_confirmation_email(self):
for pick in self.filtered(
lambda r: r.carrier_id.integration_level == "rate_and_ship"
and r.picking_type_code == "incoming"
):
pick.purchase_send_to_shipper()
return super()._send_confirmation_email()
def purchase_send_to_shipper(self):
self.ensure_one()
res = self.carrier_id.purchase_send_shipping(self)[0]
if (
self.carrier_id.free_over
and self.purchase_id
and self.purchase_id.amount_total >= self.carrier_id.amount
):
res["exact_price"] = 0.0
self.carrier_price = res["exact_price"] * (
1.0 + (self.carrier_id.margin / 100.0)
)
if res["tracking_number"]:
self.carrier_tracking_ref = res["tracking_number"]
order_currency = self.purchase_id.currency_id or self.company_id.currency_id
msg = _(
"Shipment sent to carrier %(carrier_name)s for shipping with tracking "
"number %(tracking_ref)s<br/>Cost: %(carrier_price)s %(currency_name)s"
) % (
{
"carrier_name": self.carrier_id.name,
"tracking_ref": self.carrier_tracking_ref,
"carrier_price": "%.2f" % self.carrier_price,
"currency_name": order_currency.name,
}
)
self.message_post(body=msg)
self._add_delivery_cost_to_po()
def _add_delivery_cost_to_po(self):
self.ensure_one()
if (
self.purchase_id
and self.carrier_id.invoice_policy == "real"
and self.carrier_price
):
carrier_price = self.carrier_price * (
1.0 + (float(self.carrier_id.margin) / 100.0)
)
self.purchase_id.write(
{"carrier_id": self.carrier_id, "delivery_price": carrier_price}
)
| 37.017241 | 2,147 |
6,007 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Serv. Tecnol. Avanzados - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
class DeliveryCarrier(models.Model):
_inherit = "delivery.carrier"
@api.model
def _get_delivery_partner_from_purchase(self, purchase):
return purchase.dest_address_id or purchase.partner_id
def purchase_rate_shipment(self, order):
"""Compute the price of the order shipment
:param order: record of purchase.order
:return dict: {'success': boolean,
'price': a float,
'error_message': a string containing an error message,
'warning_message': a string containing a warning message}
"""
self.ensure_one()
if hasattr(self, "purchase_%s_rate_shipment" % self.delivery_type):
res = getattr(self, "purchase_%s_rate_shipment" % self.delivery_type)(order)
# apply margin on computed price
res["price"] = float(res["price"]) * (1.0 + (self.margin / 100.0))
# save the real price in case a free_over rule overide it to 0
res["carrier_price"] = res["price"]
# free when order is large enough
if (
res["success"]
and self.free_over
and (order.amount_total + order.delivery_price) >= self.amount
):
res["warning_message"] = _(
"The shipping is free since the order amount exceeds %.2f."
) % (self.amount)
res["price"] = 0.0
return res
def purchase_send_shipping(self, pickings):
"""Send the package to the service provider
:param pickings: A recordset of pickings
:return list: A list of dictionaries (one per picking) containing of the form::
{ 'exact_price': price,
'tracking_number': number }
"""
self.ensure_one()
if hasattr(self, "purchase_%s_send_shipping" % self.delivery_type):
return getattr(self, "purchase_%s_send_shipping" % self.delivery_type)(
pickings
)
def purchase_fixed_rate_shipment(self, order):
carrier = self._match_address(order.partner_id)
if not carrier:
return {
"success": False,
"price": 0.0,
"error_message": _(
"Error: this delivery method is not available for this address."
),
"warning_message": False,
}
price = self.fixed_price
company = self.company_id or order.company_id or self.env.company
if company.currency_id != order.currency_id:
price = company.currency_id._convert(
price, order.currency_id, company, fields.Date.today()
)
return {
"success": True,
"price": price,
"error_message": False,
"warning_message": False,
}
def purchase_base_on_rule_rate_shipment(self, order):
carrier = self._match_address(order.partner_id)
if not carrier:
return {
"success": False,
"price": 0.0,
"error_message": _("Error: no matching grid."),
"warning_message": False,
}
try:
price_unit = self._purchase_get_price_available(order)
except UserError as e:
return {
"success": False,
"price": 0.0,
"error_message": e.name,
"warning_message": False,
}
if order.company_id.currency_id.id != order.currency_id.id:
price_unit = order.company_id.currency_id._convert(
price_unit,
order.currency_id,
order.company_id,
order.date_order or fields.Date.today(),
)
return {
"success": True,
"price": price_unit,
"error_message": False,
"warning_message": False,
}
def purchase_fixed_send_shipping(self, pickings):
res = []
for p in pickings:
res = res + [
{"exact_price": p.carrier_id.fixed_price, "tracking_number": False}
]
return res
def purchase_base_on_rule_send_shipping(self, pickings):
res = []
for p in pickings:
carrier = self._match_address(p.partner_id)
if not carrier:
raise ValidationError(_("There is no matching delivery rule."))
res = res + [
{
"exact_price": p.carrier_id._purchase_get_price_available(
p.purchase_id
)
if p.purchase_id
else 0.0,
"tracking_number": False,
}
]
return res
def _purchase_get_price_available(self, order):
self.ensure_one()
self = self.sudo()
order = order.sudo()
weight = volume = quantity = 0
for line in order.order_line.filtered(
lambda l: l.state != "cancel" and bool(l.product_id)
):
qty = line.product_uom._compute_quantity(
line.product_uom_qty, line.product_id.uom_id
)
weight += (line.product_id.weight or 0.0) * qty
volume += (line.product_id.volume or 0.0) * qty
quantity += qty
total = order.amount_total or 0.0
total = order.currency_id._convert(
total,
order.company_id.currency_id,
order.company_id,
order.date_order or fields.Date.today(),
)
return self._get_price_from_picking(total, weight, volume, quantity)
| 37.080247 | 6,007 |
616 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Stock Picking Package Number",
"summary": "Set or compute number of packages for a picking",
"version": "15.0.1.1.0",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"depends": ["delivery"],
"data": [
"views/stock_picking_views.xml",
"wizard/stock_immediate_transfer_views.xml",
],
}
| 34.222222 | 616 |
2,173 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests import Form
from odoo.tests.common import TransactionCase
class TestDeliveryPackageNumber(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.product = cls.env["product.product"].create(
{"name": "Test product", "type": "product"}
)
cls.wh1 = cls.env["stock.warehouse"].create(
{"name": "TEST WH1", "code": "TST1"}
)
cls.picking = cls.env["stock.picking"].create(
{
"location_id": cls.wh1.lot_stock_id.id,
"location_dest_id": cls.wh1.wh_output_stock_loc_id.id,
"picking_type_id": cls.wh1.int_type_id.id,
}
)
cls.move_line_obj = cls.env["stock.move.line"]
cls.ml1 = cls.move_line_obj.create(
{
"product_id": cls.product.id,
"product_uom_id": cls.product.uom_id.id,
"qty_done": 5,
"location_id": cls.wh1.lot_stock_id.id,
"location_dest_id": cls.wh1.wh_output_stock_loc_id.id,
"picking_id": cls.picking.id,
}
)
cls.ml2 = cls.ml1.copy({"qty_done": 0})
def test_number_of_packages(self):
# By default it's computed to 1
self.assertEqual(self.picking.number_of_packages, 1)
# We can edit the number of packages as there aren't delivery packages
picking_form = Form(self.picking)
picking_form.number_of_packages = 3
picking_form.save()
self.assertEqual(self.picking.number_of_packages, 3)
# We add a package and it recalculates
self.picking.action_put_in_pack()
self.assertEqual(self.picking.number_of_packages, 1)
self.ml2.qty_done = 5
self.picking.action_put_in_pack()
self.assertEqual(self.picking.number_of_packages, 2)
# We can later set it manually if we want to
picking_form.number_of_packages = 3
picking_form.save()
self.assertEqual(self.picking.number_of_packages, 3)
| 40.240741 | 2,173 |
788 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class StockImmediateTransfer(models.TransientModel):
_inherit = "stock.immediate.transfer"
number_of_packages = fields.Integer(
help="Set the number of packages for this picking(s)",
)
ask_number_of_packages = fields.Boolean(compute="_compute_ask_number_of_packages")
@api.depends("pick_ids")
def _compute_ask_number_of_packages(self):
for item in self:
item.ask_number_of_packages = bool(item.pick_ids.carrier_id)
def process(self):
if self.number_of_packages:
self.pick_ids.write({"number_of_packages": self.number_of_packages})
return super().process()
| 35.818182 | 788 |
562 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class StockPicking(models.Model):
_inherit = "stock.picking"
number_of_packages = fields.Integer(
string="Number of Packages",
compute="_compute_number_of_packages",
readonly=False,
store=True,
)
@api.depends("package_ids")
def _compute_number_of_packages(self):
for picking in self:
picking.number_of_packages = len(picking.package_ids) or 1
| 29.578947 | 562 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
1,487 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-delivery-carrier",
description="Meta package for oca-delivery-carrier Odoo addons",
version=version,
install_requires=[
'odoo-addon-base_delivery_carrier_label>=15.0dev,<15.1dev',
'odoo-addon-connector_routific>=15.0dev,<15.1dev',
'odoo-addon-delivery_auto_refresh>=15.0dev,<15.1dev',
'odoo-addon-delivery_carrier_info>=15.0dev,<15.1dev',
'odoo-addon-delivery_carrier_multi_zip>=15.0dev,<15.1dev',
'odoo-addon-delivery_cttexpress>=15.0dev,<15.1dev',
'odoo-addon-delivery_free_fee_removal>=15.0dev,<15.1dev',
'odoo-addon-delivery_multi_destination>=15.0dev,<15.1dev',
'odoo-addon-delivery_package_number>=15.0dev,<15.1dev',
'odoo-addon-delivery_price_method>=15.0dev,<15.1dev',
'odoo-addon-delivery_purchase>=15.0dev,<15.1dev',
'odoo-addon-delivery_state>=15.0dev,<15.1dev',
'odoo-addon-delivery_translatable>=15.0dev,<15.1dev',
'odoo-addon-partner_delivery_schedule>=15.0dev,<15.1dev',
'odoo-addon-partner_delivery_zone>=15.0dev,<15.1dev',
'odoo-addon-stock_picking_delivery_link>=15.0dev,<15.1dev',
'odoo-addon-stock_picking_report_delivery_cost>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 43.735294 | 1,487 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
581 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Delivery cost in Picking Reports",
"summary": "Show delivery cost in delivery slip and picking operations " " reports",
"version": "15.0.1.0.0",
"category": "Stock",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": ["delivery"],
"data": ["report/report_shipping.xml", "report/report_deliveryslip.xml"],
}
| 38.733333 | 581 |
2,676 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests import Form, common
class TestStockPickingReportDeliveryCost(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.partner = cls.env["res.partner"].create({"name": "Test contact"})
cls.product = cls.env["product.product"].create(
{"name": "Test product", "type": "consu"}
)
cls.carrier_product = cls.env["product.product"].create(
{
"name": "Test product",
"type": "service",
"list_price": 5,
"taxes_id": False,
}
)
cls.carrier = cls.env["delivery.carrier"].create(
{
"name": "Test carrier",
"delivery_type": "fixed",
"product_id": cls.carrier_product.id,
}
)
cls.pricelist = cls.env["product.pricelist"].create({"name": "Test pricelist"})
cls.order = cls.env["sale.order"].create(
{
"partner_id": cls.partner.id,
"carrier_id": cls.carrier.id,
"pricelist_id": cls.pricelist.id,
"order_line": [
(
0,
0,
{
"name": cls.product.name,
"product_id": cls.product.id,
"product_uom_qty": 2,
"product_uom": cls.product.uom_id.id,
"price_unit": 300.00,
},
),
],
}
)
def test_carrier_price_for_report_before(self):
delivery_wizard = Form(
self.env["choose.delivery.carrier"].with_context(
default_order_id=self.order.id,
default_carrier_id=self.carrier.id,
)
)
choose_delivery_carrier = delivery_wizard.save()
choose_delivery_carrier.button_confirm()
self.order.action_confirm()
picking = self.order.picking_ids
self.assertAlmostEqual(picking.carrier_price_for_report, 5)
def test_carrier_price_for_report_after(self):
self.order.action_confirm()
picking = self.order.picking_ids
self.assertAlmostEqual(picking.carrier_price_for_report, 0)
move = picking.move_ids_without_package
move.quantity_done = move.product_qty
picking.button_validate()
self.assertAlmostEqual(picking.carrier_price_for_report, 5)
| 37.166667 | 2,676 |
943 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class StockPicking(models.Model):
_inherit = "stock.picking"
# Needed for fields.Monetary
currency_id = fields.Many2one(
related="sale_id.currency_id",
readonly=True,
string="Currency",
related_sudo=True, # for avoiding access problems
)
carrier_price_for_report = fields.Monetary(
compute="_compute_carrier_price_for_report",
)
@api.depends("sale_id", "carrier_price")
def _compute_carrier_price_for_report(self):
for picking in self:
so_lines = picking.sale_id.order_line.filtered("is_delivery")
if so_lines:
picking.carrier_price_for_report = sum(so_lines.mapped("price_unit"))
else:
picking.carrier_price_for_report = picking.carrier_price
| 34.925926 | 943 |
652 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Delivery Price Method",
"summary": "Provides fields to be able to contemplate the tracking states"
"and also adds a global fields",
"author": "Trey (www.trey.es), " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/delivery-carrier",
"license": "AGPL-3",
"development_status": "Production/Stable",
"category": "Delivery",
"version": "15.0.1.0.0",
"depends": ["delivery"],
"data": ["views/delivery_carrier_views.xml"],
}
| 40.75 | 652 |
4,509 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests import Form
from odoo.tests.common import TransactionCase
from odoo.tools import float_compare
class TestDeliveryPriceMethod(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
self = cls
product_shipping_cost = self.env["product.product"].create(
{
"type": "service",
"name": "Shipping costs",
"standard_price": 10,
"list_price": 100,
}
)
self.carrier = self.env["delivery.carrier"].create(
{
"name": "Test carrier",
"delivery_type": "fixed",
"product_id": product_shipping_cost.id,
"fixed_price": 99.99,
}
)
self.pricelist = self.env["product.pricelist"].create(
{
"name": "Test pricelist",
"item_ids": [
(
0,
0,
{
"applied_on": "3_global",
"compute_price": "formula",
"base": "list_price",
},
)
],
}
)
self.product = self.env.ref("product.product_delivery_01")
self.partner = self.env.ref("base.res_partner_12")
self.sale = self.env["sale.order"].create(
{
"partner_id": self.partner.id,
"pricelist_id": self.pricelist.id,
"carrier_id": self.carrier.id,
"order_line": [
(0, 0, {"product_id": self.product.id, "product_uom_qty": 1})
],
}
)
def _add_delivery(self):
sale = self.sale
delivery_wizard = Form(
self.env["choose.delivery.carrier"].with_context(
default_order_id=sale.id, default_carrier_id=self.carrier
)
)
choose_delivery_carrier = delivery_wizard.save()
choose_delivery_carrier.button_confirm()
def test_delivery_price_fixed(self):
sale = self.sale
self._add_delivery()
delivery_lines = sale.order_line.filtered(lambda r: r.is_delivery)
delivery_price = sum(delivery_lines.mapped("price_unit"))
self.assertEqual(float_compare(delivery_price, 99.99, precision_digits=2), 0)
self.assertEqual(len(delivery_lines), 1)
sale.action_confirm()
picking = sale.picking_ids[0]
self.assertEqual(len(picking.move_lines), 1)
self.assertEqual(picking.carrier_id, self.carrier)
picking.action_confirm()
picking.action_assign()
self.assertFalse(picking.carrier_price)
picking.send_to_shipper()
self.assertEqual(picking.carrier_price, 99.99)
def test_delivery_price_method(self):
self.carrier.write({"price_method": "fixed", "fixed_price": 99.99})
sale = self.sale
self._add_delivery()
delivery_lines = sale.order_line.filtered(lambda r: r.is_delivery)
delivery_price = sum(delivery_lines.mapped("price_unit"))
self.assertEqual(float_compare(delivery_price, 99.99, precision_digits=2), 0)
self.assertEqual(len(delivery_lines), 1)
self.carrier.write({"price_method": "fixed", "fixed_price": 5})
self._add_delivery()
delivery_lines = sale.order_line.filtered(lambda r: r.is_delivery)
delivery_price = sum(delivery_lines.mapped("price_unit"))
self.assertEqual(delivery_price, 5)
self.carrier.write(
{
"price_method": "base_on_rule",
"price_rule_ids": [
(
0,
0,
{
"variable": "quantity",
"operator": "==",
"max_value": 1,
"list_base_price": 11.11,
},
)
],
}
)
self._add_delivery()
delivery_lines = sale.order_line.filtered(lambda r: r.is_delivery)
delivery_price = sum(delivery_lines.mapped("price_unit"))
self.assertEqual(delivery_price, 11.11)
| 37.890756 | 4,509 |
1,491 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class DeliveryCarrier(models.Model):
_inherit = "delivery.carrier"
# pylint: disable=W8113
price_method = fields.Selection(
selection=[
("carrier", "Carrier obtained price"),
("fixed", "Fixed price"),
("base_on_rule", "Based on Rules"),
],
default="carrier",
string="Price method",
)
def rate_shipment(self, order):
"""Trick the method for using all the upstream code for the
price computation in case of using fixed or base_on_rule.
"""
previous_method = False
if self.price_method in ("fixed", "base_on_rule"):
previous_method = self.delivery_type
self.sudo().delivery_type = self.price_method
res = super().rate_shipment(order)
if previous_method:
self.sudo().delivery_type = previous_method
return res
def send_shipping(self, pickings):
res = super().send_shipping(pickings)
if self.price_method in ("fixed", "base_on_rule"):
rates = getattr(self, "%s_send_shipping" % self.price_method)(pickings)
for index, rate in enumerate(rates):
del rate["tracking_number"] # remove offending key
res[index].update(rate)
return res
| 36.365854 | 1,491 |
791 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 FactorLibre
# Copyright 2020 Tecnativa - David Vidal
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Delivery State",
"summary": "Provides fields to be able to contemplate the tracking states"
"and also adds a global fields",
"author": "Trey (www.trey.es), "
"FactorLibre, "
"Tecnativa, "
"Odoo Community Association (OCA)",
"website": "https://github.com/OCA/delivery-carrier",
"license": "AGPL-3",
"category": "Delivery",
"version": "15.0.1.1.2",
"depends": ["delivery"],
"data": [
"data/ir_cron_data.xml",
"data/mail_template.xml",
"views/res_config_settings_view.xml",
"views/stock_picking_views.xml",
],
}
| 32.958333 | 791 |
543 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
old_template = env.ref("delivery_state.delivery_notification")
new_template = env.ref("stock.mail_template_data_delivery_confirmation")
items = env["res.company"].search(
[("stock_mail_confirmation_template_id", "=", old_template.id)]
)
items.write({"stock_mail_confirmation_template_id": new_template.id})
| 38.642857 | 541 |
446 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
"""Delete noupdate record because the xml_id is deprecated in favor of
stock.mail_template_data_delivery_confirmation.
"""
openupgrade.delete_records_safely_by_xml_id(
env, ["delivery_state.delivery_notification"]
)
| 31.857143 | 446 |
4,594 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 FactorLibre
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields
from odoo.tests import Form
from odoo.tests.common import TransactionCase
from odoo.tools import float_compare
class TestDeliveryState(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
product_shipping_cost = cls.env["product.product"].create(
{
"type": "service",
"name": "Shipping costs",
"standard_price": 10,
"list_price": 100,
}
)
cls.carrier = cls.env["delivery.carrier"].create(
{
"name": "Test carrier",
"delivery_type": "fixed",
"product_id": product_shipping_cost.id,
"fixed_price": 99.99,
}
)
cls.product = cls.env["product.product"].create(
{"name": "Test product", "type": "product"}
)
cls.partner = cls.env["res.partner"].create({"name": "Mr. Odoo"})
cls.partner_shipping = cls.env["res.partner"].create(
{"name": "Mr. Odoo (shipping)", "email": "[email protected]"}
)
cls.pricelist = cls.env["product.pricelist"].create(
{
"name": "Test pricelist",
"item_ids": [
(
0,
0,
{
"applied_on": "3_global",
"compute_price": "formula",
"base": "list_price",
},
)
],
}
)
cls.sale = cls.env["sale.order"].create(
{
"partner_id": cls.partner.id,
"partner_shipping_id": cls.partner_shipping.id,
"pricelist_id": cls.pricelist.id,
"order_line": [
(0, 0, {"product_id": cls.product.id, "product_uom_qty": 1})
],
}
)
def test_delivery_state(self):
delivery_wizard = Form(
self.env["choose.delivery.carrier"].with_context(
**{"default_order_id": self.sale.id, "default_carrier_id": self.carrier}
)
)
choose_delivery_carrier = delivery_wizard.save()
choose_delivery_carrier.button_confirm()
delivery_lines = self.sale.order_line.filtered(lambda r: r.is_delivery)
delivery_price = sum(delivery_lines.mapped("price_unit"))
self.assertEqual(float_compare(delivery_price, 99.99, precision_digits=2), 0)
self.assertEqual(len(delivery_lines), 1)
self.sale.action_confirm()
picking = self.sale.picking_ids[0]
self.assertEqual(len(picking.move_lines), 1)
self.assertEqual(picking.carrier_id, self.carrier)
picking.action_confirm()
picking.action_assign()
picking.send_to_shipper()
self.assertEqual(picking.delivery_state, "shipping_recorded_in_carrier")
self.assertTrue(picking.date_shipped)
self.assertFalse(picking.tracking_state_history)
picking.tracking_state_update()
picking.date_delivered = fields.Datetime.now()
with self.assertRaises(NotImplementedError):
picking.cancel_shipment()
self.env["delivery.carrier"]._patch_method(
"fixed_cancel_shipment", lambda *args: True
)
picking.cancel_shipment()
self.assertEqual(picking.delivery_state, "canceled_shipment")
self.assertFalse(picking.date_shipped)
self.assertFalse(picking.date_delivered)
def test_delivery_confirmation_send(self):
template = self.env.ref("delivery_state.delivery_state_delivered_notification")
template.auto_delete = False
self.sale.action_confirm()
picking = self.sale.picking_ids
picking.company_id.delivery_state_delivered_email_validation = True
picking.company_id.delivery_state_delivered_mail_template_id = template
picking.carrier_tracking_ref = "XX-0000"
picking.move_lines.quantity_done = 1
picking._action_done()
picking.write({"delivery_state": "customer_delivered"})
mails = picking.message_ids.filtered(
lambda x: self.partner_shipping in x.partner_ids
)
last_mail = fields.first(mails)
self.assertTrue("XX-0000" in last_mail.body)
| 40.280702 | 4,592 |
560 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResCompany(models.Model):
_inherit = "res.company"
delivery_state_delivered_email_validation = fields.Boolean(
string="Email Confirmation delivered picking", default=False
)
delivery_state_delivered_mail_template_id = fields.Many2one(
comodel_name="mail.template",
string="Email Template delivered picking",
domain="[('model', '=', 'stock.picking')]",
)
| 32.823529 | 558 |
3,247 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 FactorLibre
# Copyright 2020 Tecnativa - David Vidal
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class StockPicking(models.Model):
_inherit = "stock.picking"
date_shipped = fields.Date(
string="Shipment Date",
readonly=True,
)
date_delivered = fields.Datetime(
string="Delivery Date",
readonly=True,
)
tracking_state = fields.Char(
readonly=True,
index=True,
tracking=True,
)
tracking_state_history = fields.Text(
readonly=True,
)
delivery_state = fields.Selection(
selection=[
("shipping_recorded_in_carrier", "Shipping recorded in carrier"),
("in_transit", "In transit"),
("canceled_shipment", "Canceled shipment"),
("incidence", "Incidence"),
("customer_delivered", "Customer delivered"),
("warehouse_delivered", "Warehouse delivered"),
("no_update", "No more updates from carrier"),
],
string="Carrier State",
tracking=True,
readonly=True,
)
def tracking_state_update(self):
"""Call to the service provider API which should have the method
defined in the model as:
<my_provider>_tracking_state_update
It can be triggered manually or by the cron."""
for picking in self.filtered("carrier_id"):
method = "%s_tracking_state_update" % picking.delivery_type
if hasattr(picking.carrier_id, method):
getattr(picking.carrier_id, method)(picking)
@api.model
def _update_delivery_state(self):
"""Automated action to query the delivery states to the carriers API.
every carrier should implement it 's own method. We split them by
delivery type so only those carries with the method update"""
pickings = self.search(
[
("state", "=", "done"),
(
"delivery_state",
"not in",
["customer_delivered", "canceled_shipment", "no_update"],
),
# These won't ever autoupdate, so we don't want to evaluate them
("delivery_type", "not in", [False, "fixed", "base_one_rule"]),
]
)
pickings.tracking_state_update()
def _send_delivery_state_delivered_email(self):
for item in self.filtered(
lambda p: p.company_id.delivery_state_delivered_email_validation
and p.picking_type_id.code == "outgoing"
and p.delivery_state == "customer_delivered"
):
template_id = item.company_id.delivery_state_delivered_mail_template_id.id
item.with_context(force_send=True).message_post_with_template(
template_id, email_layout_xmlid="mail.mail_notification_light"
)
def write(self, vals):
res = super().write(vals)
if vals.get("delivery_state") == "customer_delivered":
self._send_delivery_state_delivered_email()
return res
| 37.298851 | 3,245 |
548 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
delivery_state_delivered_email_validation = fields.Boolean(
related="company_id.delivery_state_delivered_email_validation", readonly=False
)
delivery_state_delivered_mail_template_id = fields.Many2one(
related="company_id.delivery_state_delivered_mail_template_id", readonly=False
)
| 36.4 | 546 |
838 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Trey, Kilobytes de Soluciones
# Copyright 2020 FactorLibre
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class DeliveryCarrier(models.Model):
_inherit = "delivery.carrier"
def send_shipping(self, pickings):
res = super().send_shipping(pickings)
pickings.write(
{
"delivery_state": "shipping_recorded_in_carrier",
"date_shipped": fields.Date.today(),
}
)
return res
def cancel_shipment(self, pickings):
res = super().cancel_shipment(pickings)
pickings.write(
{
"delivery_state": "canceled_shipment",
"date_delivered": False,
"date_shipped": False,
}
)
return res
| 28.896552 | 838 |
728 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import SUPERUSER_ID, api
def post_init_hook(cr, registry):
"""Convert current ZIP field values to ZIP entries"""
env = api.Environment(cr, SUPERUSER_ID, dict())
carriers = (
env["delivery.carrier"]
.with_context(
show_children_carriers=True # compatibility with delivery_multi_destination
)
.search(["|", ("zip_from", "!=", False), ("zip_to", "!=", False)])
)
for carrier in carriers:
carrier.write({"zip_from": carrier.zip_from, "zip_to": carrier.zip_to})
env.cr.execute("UPDATE delivery_carrier SET zip_from=NULL, zip_to=NULL")
| 40.444444 | 728 |
556 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Multiple ZIP intervals for the same delivery method",
"version": "15.0.1.0.0",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": ["delivery"],
"data": ["security/ir.model.access.csv", "views/delivery_carrier_view.xml"],
"post_init_hook": "post_init_hook",
}
| 39.714286 | 556 |
2,335 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests import common
from odoo.addons.delivery_carrier_multi_zip.hooks import post_init_hook
class TestDeliveryCarrierMultiZip(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.partner_1 = cls.env["res.partner"].create(
{"name": "Test partner 1", "zip": "0001"}
)
cls.partner_2 = cls.env["res.partner"].create(
{"name": "Test partner 2", "zip": "0002"}
)
cls.product = cls.env["product.product"].create(
{"name": "Test carrier", "type": "service"}
)
cls.carrier = cls.env["delivery.carrier"].create(
{
"name": "Test carrier multi ZIP",
"product_id": cls.product.id,
"zip_from": "0001",
"zip_to": "0001",
}
)
def test_delivery_multi_zip_write_create(self):
self.assertEqual(len(self.carrier.zip_range_ids), 1)
self.assertEqual(self.carrier.zip_range_ids.zip_from, "0001")
self.assertEqual(self.carrier.zip_range_ids.zip_to, "0001")
self.carrier.write({"zip_to": "0002"})
self.assertEqual(len(self.carrier.zip_range_ids), 2)
self.assertEqual(self.carrier.zip_range_ids[1].zip_from, "0")
self.assertEqual(self.carrier.zip_range_ids[1].zip_to, "0002")
def test_post_init_hook(self):
self.carrier.zip_range_ids.unlink()
self.carrier.with_context(bypass_multi_zip=True).write({"zip_from": "0002"})
post_init_hook(self.env.cr, None)
self.assertEqual(len(self.carrier.zip_range_ids), 1)
self.assertEqual(self.carrier.zip_range_ids.zip_from, "0002")
self.assertEqual(self.carrier.zip_range_ids.zip_to, "z")
self.carrier.refresh()
self.assertFalse(self.carrier.zip_from)
def test_available_carriers(self):
self.assertIn(self.carrier, self.carrier.available_carriers(self.partner_1))
self.assertNotIn(self.carrier, self.carrier.available_carriers(self.partner_2))
self.carrier.zip_range_ids = [(0, 0, {"zip_from": "0002", "zip_to": "0020"})]
self.assertIn(self.carrier, self.carrier.available_carriers(self.partner_2))
| 43.240741 | 2,335 |
2,472 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class DeliveryCarrier(models.Model):
_inherit = "delivery.carrier"
zip_range_ids = fields.One2many(
comodel_name="delivery.carrier.zip",
inverse_name="carrier_id",
string="ZIP codes",
)
@api.model
def _convert_zip_to_intervals(self, vals):
if self.env.context.get("bypass_multi_zip"):
return
if vals.get("zip_from") or vals.get("zip_to"):
vals.setdefault("zip_range_ids", [])
vals["zip_range_ids"].append(
(
0,
0,
{
"zip_from": vals.get("zip_from", "0") or "0",
"zip_to": vals.get("zip_to", "z") or "z",
},
)
)
vals.pop("zip_from", False)
vals.pop("zip_to", False)
@api.model_create_multi
def create(self, vals_list):
"""Intercept creation for changing ZIP values to ZIP interval."""
for vals in vals_list:
self._convert_zip_to_intervals(vals)
return super().create(vals_list)
def write(self, vals):
"""Intercept write for changing ZIP values to ZIP interval."""
self._convert_zip_to_intervals(vals)
return super().write(vals)
def _match_address(self, partner):
"""Match as well by zip intervals if they are present."""
res = super()._match_address(partner) # it has self.ensure_one()
if res and self.zip_range_ids:
partner_zip = partner.zip or ""
res = bool(
self.zip_range_ids.filtered(
lambda r: r.zip_from <= partner_zip and r.zip_to >= partner_zip
)
)
return res
class DeliveryCarrierZip(models.Model):
_name = "delivery.carrier.zip"
_description = "Delivery destination availability ZIP interval line"
carrier_id = fields.Many2one(
comodel_name="delivery.carrier", ondelete="cascade", index=True
)
zip_from = fields.Char(required=True)
zip_to = fields.Char(required=True)
name = fields.Char(compute="_compute_name")
@api.depends("zip_from", "zip_to")
def _compute_name(self):
for record in self:
record.name = "%s - %s" % (record.zip_from, record.zip_to)
| 33.405405 | 2,472 |
733 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Partner Delivery Schedule",
"summary": "Set on partners a schedule for delivery goods",
"version": "15.0.1.0.1",
"development_status": "Production/Stable",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["delivery"],
"data": [
"security/ir.model.access.csv",
"views/partner_delivery_schedule_view.xml",
"views/res_partner_view.xml",
"views/report_shipping.xml",
],
}
| 34.904762 | 733 |
3,793 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.exceptions import ValidationError
from odoo.tests import Form, TransactionCase
class TestStockPikingReturnRefundOption(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.schedule = cls.env["delivery.schedule"].create(
{
"name": "test",
"hour_from": 8,
"hour_to": 10,
"monday": True,
"tuesday": True,
"wednesday": False,
"thursday": False,
"friday": False,
}
)
cls.schedule2 = cls.env["delivery.schedule"].create(
{
"name": "test2",
"hour_from": 10,
"hour_to": 12,
"monday": True,
"tuesday": True,
"wednesday": False,
"thursday": False,
"friday": False,
}
)
cls.partner = cls.env["res.partner"].create(
{
"name": "test",
"delivery_schedule_ids": [(6, 0, cls.schedule.ids + cls.schedule2.ids)],
}
)
cls.report_model = cls.env["ir.actions.report"]
cls.product = cls.env["product.product"].create(
{"name": "Test product", "type": "product"}
)
cls.order = cls._create_sale_order(cls)
cls.order.action_confirm()
cls.picking = cls.order.picking_ids[0]
def _create_sale_order(self):
order_form = Form(self.env["sale.order"])
order_form.partner_id = self.partner
with order_form.order_line.new() as line_form:
line_form.product_id = self.product
line_form.product_uom_qty = 1.0
return order_form.save()
def test_partner_schedule_name(self):
self.assertEqual(self.schedule.name_get()[0][1], "08:00-10:00 (Mo, Tu)")
day_update = {}
for day in self.schedule._days_of_week():
day_update[day[0]] = True
self.schedule.update(day_update)
self.assertEqual(self.schedule.name_get()[0][1], "08:00-10:00 (All days)")
with self.assertRaises(ValidationError):
self.schedule.update({"hour_from": 0, "hour_to": 25})
day_update = {}
for day in self.schedule._days_of_week():
day_update[day[0]] = False
with self.assertRaises(ValidationError):
self.schedule.update(day_update)
def test_partner_allow_delivery(self):
self.assertTrue(self.partner.allow_delivery_date("2018-09-03 09:00:00"))
self.assertTrue(self.partner.allow_delivery_date("2018-09-04 09:00:00"))
self.assertFalse(self.partner.allow_delivery_date("2018-09-04 12:01:00"))
self.assertFalse(self.partner.allow_delivery_date("2018-09-05 10:01:00"))
# Allow delivery in all days
day_update = {}
for day in self.schedule._days_of_week():
day_update[day[0]] = True
self.schedule.update(day_update)
self.assertTrue(self.partner.allow_delivery_date("2018-09-09 09:00:00"))
def test_report_picking(self):
res = self.report_model._get_report_from_name(
"stock.report_picking"
)._render_qweb_text(self.picking.ids, False)
self.assertRegex(str(res[0]), "08:00-10:00")
self.assertRegex(str(res[0]), "10:00-12:00")
def test_report_deliveryslip(self):
res = self.report_model._get_report_from_name(
"stock.report_deliveryslip"
)._render_qweb_text(self.picking.ids, False)
self.assertRegex(str(res[0]), "08:00-10:00")
self.assertRegex(str(res[0]), "10:00-12:00")
| 37.93 | 3,793 |
2,788 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class DeliverySchedule(models.Model):
_name = "delivery.schedule"
_description = "Delivery Schedule"
name = fields.Char(required=True)
color = fields.Integer(string="Color Index")
hour_from = fields.Float(string="From")
hour_to = fields.Float(string="To", default=24.00, required=True)
monday = fields.Boolean(default=True)
tuesday = fields.Boolean(default=True)
wednesday = fields.Boolean(default=True)
thursday = fields.Boolean(default=True)
friday = fields.Boolean(default=True)
saturday = fields.Boolean()
sunday = fields.Boolean()
@api.constrains("hour_from", "hour_to")
def _check_hour_interval(self):
if (
self.hour_from < 0.0
or self.hour_to > 24.0
or self.hour_from >= self.hour_to
):
raise ValidationError(
_(
"Error ! You can not set hour_from greater or equal "
"than hour_to ."
)
)
return True
@api.constrains(
"monday",
"tuesday",
"wednesday",
"wednesday",
"thursday",
"friday",
"saturday",
"sunday",
)
def _check_day_selected(self):
if not any([self[x[0]] for x in self._days_of_week()]):
raise ValidationError(_("Error ! You must set one day to delivery."))
return True
def _days_of_week(self):
return [
("monday", _("Monday")),
("tuesday", _("Tuesday")),
("wednesday", _("Wednesday")),
("thursday", _("Thursday")),
("friday", _("Friday")),
("saturday", _("Saturday")),
("sunday", _("Sunday")),
]
def name_get(self):
result = []
for schedule in self:
hour_from = "{:02.0f}:{:02.0f}".format(*divmod(schedule.hour_from * 60, 60))
hour_to = "{:02.0f}:{:02.0f}".format(*divmod(schedule.hour_to * 60, 60))
days_accepted = [d[1][:2] for d in self._days_of_week() if schedule[d[0]]]
days = (
days_accepted
and len(days_accepted) > 0
and len(days_accepted) < 7
and ", ".join(days_accepted)
or _("All days")
)
result.append(
(
schedule.id,
"{hour_from}-{hour_to} ({days})".format(
hour_from=hour_from, hour_to=hour_to, days=days
),
)
)
return result
| 32.8 | 2,788 |
1,106 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Sergio Teruel
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResPartner(models.Model):
_inherit = "res.partner"
delivery_schedule_ids = fields.Many2many(
comodel_name="delivery.schedule",
column1="partner_id",
column2="delivery_schedule_id",
string="Delivery Schedule",
)
def allow_delivery_date(self, date_str):
"""
Help method that returns if a partner allow delivery goods in
requested date (with time)
"""
day_list = self.env["delivery.schedule"]._days_of_week()
date = fields.Datetime.from_string(date_str)
week_day = day_list[date.weekday()][0]
request_delivery_hour = int(date.hour) + float(date.minute / 60)
delivery_records = self.delivery_schedule_ids.filtered(
lambda x: (
x[week_day]
and request_delivery_hour >= x.hour_from
and request_delivery_hour < x.hour_to
)
)
return bool(delivery_records)
| 34.5625 | 1,106 |
781 |
py
|
PYTHON
|
15.0
|
# Copyright 2013-2015 Yannick Vaucher (Camptocamp SA)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Base module for carrier labels",
"version": "15.0.1.0.1",
"author": "Camptocamp,Akretion,Odoo Community Association (OCA)",
"maintainer": "Camptocamp",
"category": "Delivery",
"depends": ["delivery_carrier_info"],
"website": "https://github.com/OCA/delivery-carrier",
"data": [
"views/delivery.xml",
"views/stock.xml",
"views/res_config.xml",
"views/carrier_account.xml",
"security/ir.model.access.csv",
"security/carrier_security.xml",
"wizard/manifest_wizard_view.xml",
],
"installable": True,
"auto_install": False,
"license": "AGPL-3",
}
| 33.956522 | 781 |
667 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Angel Moya (PESOL)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields
from odoo.tests.common import TransactionCase
class ManifestWizardCase(TransactionCase):
def setUp(self):
super(ManifestWizardCase, self).setUp()
self.free_delivery = self.env.ref("delivery.free_delivery_carrier")
def test_wizard(self):
"""Create manifest wizard."""
wizard = self.env["manifest.wizard"].create(
{"carrier_id": self.free_delivery.id, "from_date": fields.Date.today()}
)
with self.assertRaises(NotImplementedError):
wizard.get_manifest_file()
| 35.105263 | 667 |
7,961 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests.common import TransactionCase
class TestGetWeight(TransactionCase):
"""Test get_weight functions."""
# some helpers
def _create_order(self, customer):
return self.env["sale.order"].create({"partner_id": customer.id})
def _create_order_line(self, order, products):
for product in products:
self.env["sale.order.line"].create(
{"product_id": product.id, "order_id": order.id}
)
def _create_ul(self):
vals = [
{"name": "Cardboard box", "type": "box", "weight": 0.200},
{"name": "Wood box", "type": "box", "weight": 1.30},
]
return [self.env["product.ul"].create(val) for val in vals]
def _create_operation(self, picking, values):
vals = {
"picking_id": picking.id,
"location_id": picking.location_id.id,
"location_dest_id": picking.location_dest_id.id,
}
vals.update(values)
return self.env["stock.move.line"].create(vals)
def _create_product(self, vals):
return self.env["product.product"].create(vals)
def _get_products(self, weights):
"""A recordset of products without any specific uom.
It means : no uom or kg or unit
Params:
weights: recordset will be size of weights and each
product will get a size according of weights[i]
"""
kg_id = self.env.ref("uom.product_uom_kgm").id
unit_id = self.env.ref("uom.product_uom_unit").id
products = self.env["product.product"].search(
[["uom_id", "in", (False, kg_id, unit_id)]], limit=len(weights)
)
for idx, product in enumerate(products):
# by default there is no weight on products
product.weight = weights[idx]
return products
def _generate_picking(self, products):
"""Create a picking from products."""
customer = self.env["res.partner"].search([], limit=1)
order = self._create_order(customer)
self._create_order_line(order, products)
order.action_confirm()
picking = order.picking_ids
picking.button_validate()
return picking
def test_get_weight(self):
"""Test quant.package.weight computed field and
pack.operation.get_weight."""
# prepare some data
weights = [2, 30, 1, 24, 39]
products = self._get_products(weights)
picking = self._generate_picking(products)
package = self.env["stock.quant.package"].create({})
operations = self.env["stock.move.line"]
for product in products:
operations |= self._create_operation(
picking,
{
"product_uom_qty": 1,
"product_id": product.id,
"product_uom_id": product.uom_id.id,
"result_package_id": package.id,
},
)
# end of prepare data
# test operation.get_weight()
for operation in operations:
self.assertEqual(
operation.get_weight(),
operation.product_id.weight * operation.product_uom_qty,
)
# test package.weight
self.assertEqual(package.weight, sum(product.weight for product in products))
def test_total_weight(self):
"""Test quant.package.weight computed field when a total
weight is defined"""
# prepare some data
weights = [2, 30, 1, 24, 39]
products = self._get_products(weights)
picking = self._generate_picking(products)
package = self.env["stock.quant.package"].create({})
operations = self.env["stock.move.line"]
for product in products:
operations |= self._create_operation(
picking,
{
"product_uom_qty": 1,
"product_id": product.id,
"product_uom_id": product.uom_id.id,
"result_package_id": package.id,
},
)
package.shipping_weight = 1542.0
# end of prepare data
# test operation.get_weight()
for operation in operations:
self.assertEqual(
operation.get_weight(),
operation.product_id.weight * operation.product_uom_qty,
)
# test package.weight
self.assertEqual(package.weight, package.shipping_weight)
def test_get_weight_with_qty(self):
"""Ensure qty are taken in account."""
# prepare some data
weights = [2, 30, 1, 24, 39]
products = self._get_products(weights)
picking = self._generate_picking(products)
package = self.env["stock.quant.package"].create({})
operations = self.env["stock.move.line"]
for idx, product in enumerate(products):
operations |= self._create_operation(
picking,
{
"product_uom_qty": idx, # nice one
"product_id": product.id,
"product_uom_id": product.uom_id.id,
"result_package_id": package.id,
},
)
# end of prepare data
# test operation.get_weight()
for operation in operations:
self.assertEqual(
operation.get_weight(),
operation.product_id.weight * operation.product_uom_qty,
)
# test package._weight
self.assertEqual(
package.weight, sum(operation.get_weight() for operation in operations)
)
def test_get_weight_with_uom(self):
"""Check with differents uom."""
# prepare some data
weights = [0.3, 14.01, 0.59]
package = self.env["stock.quant.package"].create({})
tonne_id = self.env.ref("uom.product_uom_ton")
kg_id = self.env.ref("uom.product_uom_kgm")
gr_id = self.env.ref("uom.product_uom_gram")
products = []
products.append(
self._create_product(
{
"name": "Expected Odoo dev documentation",
"uom_id": tonne_id.id,
"uom_po_id": tonne_id.id,
"weight": weights[0],
}
)
)
products.append(
self._create_product(
{
"name": "OCA documentation",
"uom_id": kg_id.id,
"uom_po_id": kg_id.id,
"weight": weights[1],
}
)
)
products.append(
self._create_product(
{
"name": "Actual Odoo dev documentation",
"uom_id": gr_id.id,
"uom_po_id": gr_id.id,
"weight": weights[2],
}
)
)
products_weight = (
weights[0] * 1000 + weights[1] * 1 + weights[2] * 0.01 # tonne # kg # g
)
picking = self._generate_picking(products)
operations = self.env["stock.move.line"]
for product in products:
operations |= self._create_operation(
picking,
{
"product_uom_qty": 1,
"product_id": product.id,
"product_uom_id": product.uom_id.id,
"result_package_id": package.id,
},
)
# end of prepare data
# because uom conversion is not implemented
self.assertEqual(package.weight, False)
# if one day, uom conversion is implemented:
# self.assertEqual(package.get_weight(), products_weight)
self.assertEqual(products_weight, products_weight) # flak8 warning
| 35.540179 | 7,961 |
1,527 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Hunki Enterprises BV
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import base64
from unittest import mock
from odoo.tests.common import Form, TransactionCase
class TestSend(TransactionCase):
"""Test sending a picking"""
def test_send(self):
"""Test if the module picks up labels returned from delivery.carrier#send"""
carrier = self.env.ref("delivery.normal_delivery_carrier")
picking_form = Form(
self.env["stock.picking"].with_context(
default_picking_type_id=self.env.ref("stock.picking_type_out").id,
)
)
picking_form.carrier_id = carrier
picking = picking_form.save()
with mock.patch.object(type(carrier), "fixed_send_shipping") as mocked:
mocked.return_value = [
dict(
labels=[
dict(
name="hello_world.pdf",
file=base64.b64encode(bytes("hello world", "utf8")),
file_type="pdf",
),
]
)
]
labels_before = self.env["shipping.label"].search([])
carrier.send_shipping(picking)
label = self.env["shipping.label"].search([]) - labels_before
self.assertTrue(label, "No label created")
self.assertEqual(
label.mimetype, "application/pdf", "Wrong attachment created"
)
| 37.243902 | 1,527 |
3,241 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Hunki Enterprises BV
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.exceptions import UserError
from odoo.tests.common import TransactionCase
class CarrierLabelCase(TransactionCase):
"""Base class for carrier label tests. Inherit and override _get_carrier
to return the carrier you want to test"""
def setUp(self, *args, **kwargs):
super().setUp(*args, **kwargs)
self._create_order_picking()
@property
def transfer_in_setup(self):
return True
def _create_order_picking(self):
"""Create a sale order and deliver the picking"""
self.order = self.env["sale.order"].create(self._sale_order_data())
for product in self.order.mapped("order_line.product_id"):
self.env["stock.quant"].with_context(inventory_mode=True).create(
{
"product_id": product.id,
"location_id": self.order.warehouse_id.lot_stock_id.id,
"inventory_quantity": sum(
self.order.mapped("order_line.product_uom_qty")
),
}
)
self.order.action_confirm()
self.picking = self.order.picking_ids
self.picking.write(self._picking_data())
if self.transfer_in_setup:
self._transfer_order_picking()
def _transfer_order_picking(self):
self.env["stock.immediate.transfer"].create(
{"pick_ids": [(6, 0, self.picking.ids)]}
).process()
def _get_carrier(self):
"""Return the carrier to test"""
raise NotImplementedError()
def _sale_order_data(self):
"""Return a values dict to create a sale order"""
return {
"partner_id": self.env["res.partner"].create(self._partner_data()).id,
"order_line": [(0, 0, data) for data in self._order_line_data()],
"carrier_id": self._get_carrier().id,
}
def _partner_data(self):
"""Return a values dict to create a partner"""
return {
"name": "Carrier label test customer",
}
def _order_line_data(self):
"""Return a list of value dicts to create order lines"""
return [
{
"product_id": self.env["product.product"]
.create(self._product_data())
.id,
"product_uom_qty": 1,
}
]
def _product_data(self):
"""Return a values dict to create a product"""
return {
"name": "Carrier test product",
"type": "product",
}
def _picking_data(self):
"""Return a values dict to be written to the picking in order to set
carrier options"""
return {}
def _assert_labels(self):
"""Fail if there are no labels for the current picking"""
try:
self.picking._check_existing_shipping_label()
except UserError:
return
self.fail("No labels found")
class TestCarrierLabel(CarrierLabelCase):
def test_labels(self):
"""Test if labels are created by the button"""
self.picking.send_to_shipper()
self._assert_labels()
| 33.071429 | 3,241 |
3,119 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Hunki Enterprises BV
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import base64
from odoo.tests.common import TransactionCase
class TestHelperFunctions(TransactionCase):
"""Test convenience functions on stock.picking"""
def test_get_carrier_account(self):
"""Test finding the correct account for a picking"""
account_without_company = self.env["carrier.account"].create(
{
"name": "Account without company",
"account": "account",
"password": "password",
"delivery_type": "fixed",
"sequence": 1,
}
)
account_with_company = account_without_company.copy(
default=dict(
name="Account with company",
company_id=self.env.user.company_id.id,
sequence=2,
),
)
second_account_with_company = account_with_company.copy(
default=dict(name="2. Account with company", sequence=-1),
)
carrier_id = self.env.ref("delivery.normal_delivery_carrier").id
pick = self.env["stock.picking"].new(
dict(
carrier_id=carrier_id,
company_id=self.env.user.company_id.id,
)
)
account = pick._get_carrier_account()
self.assertEqual(account, second_account_with_company)
# restrict second_account_with_company to another delivery method
free_method = self.env.ref("delivery.free_delivery_carrier")
second_account_with_company.write({"carrier_ids": [(6, 0, [free_method.id])]})
account = pick._get_carrier_account()
self.assertEqual(account, account_with_company)
second_account_with_company.write({"carrier_ids": [(4, carrier_id, 0)]})
account = pick._get_carrier_account()
self.assertEqual(account, second_account_with_company)
def test_attach_shipping_label(self):
"""Test if attaching labels works correctly"""
picking = self.env["stock.picking"].new(
dict(
carrier_id=self.env.ref("delivery.normal_delivery_carrier").id,
company_id=self.env.user.company_id.id,
)
)
label = picking.attach_shipping_label(
dict(
name="hello_world.pdf",
file=base64.b64encode(bytes("hello world", "utf8")),
file_type="pdf",
package_id=self.env["stock.quant.package"]
.create(dict(name="package"))
.id,
tracking_number="hello",
)
)
self.assertEqual(label.name, "hello_world.pdf")
def test_delivery_carrier_option(self):
"""Mandatory option on delivery options sets color"""
option = self.env["delivery.carrier.option"].create(
{
"name": __name__,
"code": __name__,
}
)
self.assertFalse(option.color)
option.mandatory = True
self.assertEqual(option.color, 2)
| 37.130952 | 3,119 |
1,093 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 FactorLibre (http://www.factorlibre.com)
# Ismael Calvo <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import _, fields, models
class ManifestWizard(models.TransientModel):
_name = "manifest.wizard"
_description = "Delivery carrier manifest wizard"
carrier_id = fields.Many2one(
comodel_name="delivery.carrier",
string="Carrier",
states={"done": [("readonly", True)]},
required=True,
)
from_date = fields.Datetime(required=True)
to_date = fields.Datetime()
file_out = fields.Binary("Manifest", readonly=True)
filename = fields.Char("File Name", readonly=True)
notes = fields.Text("Result", readonly=True)
state = fields.Selection(
[("init", "Init"), ("file", "File"), ("end", "END")],
readonly=True,
default="init",
)
def get_manifest_file(self):
raise NotImplementedError(
_("Manifest not implemented for '%s' carrier.")
% self.carrier_id.delivery_type
)
| 33.121212 | 1,093 |
1,598 |
py
|
PYTHON
|
15.0
|
# Copyright 2014-TODAY Florian da Costa Akretion <http://www.akretion.com>.
# Copyright 2014 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
class CarrierAccount(models.Model):
_name = "carrier.account"
_description = "Base account datas"
_order = "sequence"
@api.model
def _selection_file_format(self):
"""To inherit to add label file types"""
return [("PDF", "PDF"), ("ZPL", "ZPL"), ("XML", "XML")]
name = fields.Char(required=True)
sequence = fields.Integer()
delivery_type = fields.Selection(
selection=lambda self: self.env["delivery.carrier"]
._fields["delivery_type"]
.selection,
help="This field may be used to link an account to a carrier",
)
carrier_ids = fields.Many2many(
"delivery.carrier",
"delivery_carrier_account_rel",
"account_id",
"carrier_id",
string="Carriers",
help=(
"This field may be used to link an account to specific delivery methods"
" It may be usefull to find an account with more precision than with "
"only the delivery type"
),
)
account = fields.Char(string="Account Number", required=True)
password = fields.Char(string="Account Password", required=True)
company_id = fields.Many2one(comodel_name="res.company", string="Company")
file_format = fields.Selection(
selection="_selection_file_format",
help="Default format of the carrier's label you want to print",
)
| 36.318182 | 1,598 |
1,551 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Hpar
# Copyright 2016 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from odoo import fields, models
_logger = logging.getLogger(__name__)
class StockMoveLine(models.Model):
_inherit = "stock.move.line"
weight = fields.Float(digits="Stock Weight", help="Weight of the pack_operation")
def get_weight(self):
"""Calc and save weight of pack.operations.
Warning: Type conversion not implemented
it will return False if at least one uom or uos not in kg
return:
the sum of the weight of [self]
"""
total_weight = 0
kg = self.env.ref("uom.product_uom_kgm").id
units = self.env.ref("uom.product_uom_unit").id
allowed = (False, kg, units)
cant_calc_total = False
for operation in self:
product = operation.product_id
# if not defined we assume it's in kg
if product.uom_id.id not in allowed:
_logger.warning(
"Type conversion not implemented for product %s" % product.id
)
cant_calc_total = True
# product_qty may be 0 if you don't set move line
# individually but directly validate the picking
qty = operation.qty_done or operation.product_qty
operation.weight = product.weight * qty
total_weight += operation.weight
if cant_calc_total:
return False
return total_weight
| 32.3125 | 1,551 |
698 |
py
|
PYTHON
|
15.0
|
# Copyright 2013-2016 Camptocamp SA
# Copyright 2014 Akretion <http://www.akretion.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ShippingLabel(models.Model):
"""Child class of ir attachment to identify which are labels"""
_name = "shipping.label"
_inherits = {"ir.attachment": "attachment_id"}
_description = "Shipping Label"
file_type = fields.Char(default="pdf")
package_id = fields.Many2one(comodel_name="stock.quant.package", string="Pack")
attachment_id = fields.Many2one(
comodel_name="ir.attachment",
string="Attachement",
required=True,
ondelete="cascade",
)
| 31.727273 | 698 |
1,828 |
py
|
PYTHON
|
15.0
|
# Copyright 2012 Akretion <http://www.akretion.com>.
# Copyright 2013-2016 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class DeliveryCarrierOption(models.Model):
"""Option selected for a carrier method
Those options define the list of available pre-added and available
to be added on delivery orders
"""
_name = "delivery.carrier.option"
_description = "Delivery carrier option"
_inherits = {"delivery.carrier.template.option": "tmpl_option_id"}
active = fields.Boolean(default=True)
mandatory = fields.Boolean(
help=(
"If checked, this option is necessarily applied "
"to the delivery order. Mandatory options show up in orange "
"in the option widget on the picking."
),
)
by_default = fields.Boolean(
string="Applied by Default",
help="By check, user can choose to apply this option "
"to each Delivery Order\n using this delivery method",
)
tmpl_option_id = fields.Many2one(
comodel_name="delivery.carrier.template.option",
string="Option",
required=True,
ondelete="cascade",
)
carrier_id = fields.Many2one(comodel_name="delivery.carrier", string="Carrier")
readonly_flag = fields.Boolean(
help="When True, help to prevent the user to modify some fields "
"option (if attribute is defined in the view)",
)
color = fields.Integer(
compute="_compute_color",
help="Orange if the option is mandatory, otherwise no color",
)
@api.depends("mandatory")
def _compute_color(self):
"""Show that a tag is mandatory using the color attribute"""
for tag in self:
tag.color = 2 if tag.mandatory else False
| 34.490566 | 1,828 |
7,916 |
py
|
PYTHON
|
15.0
|
# Copyright 2012-2015 Akretion <http://www.akretion.com>.
# Copyright 2013-2016 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from odoo import _, api, fields, models
from odoo.exceptions import UserError
_logger = logging.getLogger(__name__)
class StockPicking(models.Model):
_inherit = "stock.picking"
carrier_id = fields.Many2one(
comodel_name="delivery.carrier",
string="Carrier",
states={"done": [("readonly", True)]},
)
carrier_code = fields.Char(related="carrier_id.code", readonly=True)
option_ids = fields.Many2many(
comodel_name="delivery.carrier.option", string="Options"
)
def get_shipping_label_values(self, label):
self.ensure_one()
return {
"name": label["name"],
"res_id": self.id,
"res_model": "stock.picking",
"datas": label["file"],
"file_type": label["file_type"],
}
def attach_shipping_label(self, label):
"""Attach a label returned by generate_shipping_labels to a picking"""
self.ensure_one()
data = self.get_shipping_label_values(label)
if label.get("package_id"):
data["package_id"] = label["package_id"]
if label.get("tracking_number"):
self.env["stock.quant.package"].browse(label["package_id"]).write(
{"parcel_tracking": label.get("tracking_number")}
)
context_attachment = self.env.context.copy()
return (
self.env["shipping.label"]
.with_context(context_attachment=context_attachment)
.create(data)
)
def _set_a_default_package(self):
"""Pickings using this module must have a package
If not this method put it one silently
"""
for picking in self:
move_lines = picking.move_line_ids.filtered(
lambda s: not s.result_package_id
)
if move_lines:
picking._put_in_pack(move_lines)
def send_to_shipper(self):
self.ensure_one()
if self.env.context.get("set_default_package", True):
self._set_a_default_package()
# We consider that label has already been generated in case we have a
# carrier tracking ref, this way we may print the labels before shipping
# and not generated in second time during shipment
if self.carrier_tracking_ref:
return
else:
return super().send_to_shipper()
@api.onchange("carrier_id")
def onchange_carrier_id(self):
"""Inherit this method in your module"""
if not self.carrier_id:
return
# This can look useless as the field carrier_code and
# carrier_type are related field. But it's needed to fill
# this field for using this fields in the view. Indeed the
# module that depend of delivery base can hide some field
# depending of the type or the code
carrier = self.carrier_id
self.update(
{"delivery_type": carrier.delivery_type, "carrier_code": carrier.code}
)
default_options = carrier.default_options()
self.option_ids = [(6, 0, default_options.ids)]
result = {
"domain": {"option_ids": [("id", "in", carrier.available_option_ids.ids)]}
}
return result
@api.onchange("option_ids")
def onchange_option_ids(self):
if not self.carrier_id:
return
carrier = self.carrier_id
for available_option in carrier.available_option_ids:
if available_option.mandatory and available_option not in self.option_ids:
# XXX the client does not allow to modify the field that
# triggered the onchange:
# https://github.com/odoo/odoo/issues/2693#issuecomment-56825399
# Ideally we should add the missing option
raise UserError(
_(
"You should not remove a mandatory option."
"Please cancel the edit or "
"add back the option: %s."
)
% available_option.name
)
@api.model
def _values_with_carrier_options(self, values):
values = values.copy()
carrier_id = values.get("carrier_id")
option_ids = values.get("option_ids")
if carrier_id and not option_ids:
carrier_obj = self.env["delivery.carrier"]
carrier = carrier_obj.browse(carrier_id)
default_options = carrier.default_options()
if default_options:
values.update(option_ids=[(6, 0, default_options.ids)])
return values
def write(self, vals):
"""Set the default options when the delivery method is changed.
So we are sure that the options are always in line with the
current delivery method.
"""
vals = self._values_with_carrier_options(vals)
return super().write(vals)
@api.model
def create(self, vals):
"""Trigger onchange_carrier_id on create
To ensure options are setted on the basis of carrier_id copied from
Sale order or defined by default.
"""
vals = self._values_with_carrier_options(vals)
return super().create(vals)
def _get_carrier_account_domain(self):
return [
("delivery_type", "in", self.mapped("delivery_type")),
"|",
("company_id", "=", False),
("company_id", "in", self.mapped("company_id.id")),
"|",
("carrier_ids", "=", False),
("carrier_ids", "in", self.mapped("carrier_id").ids),
]
def _get_carrier_account(self):
"""Return a carrier suitable for the current picking"""
domain = self._get_carrier_account_domain()
return self.env["carrier.account"].search(
domain,
limit=1,
order="company_id asc, sequence asc",
)
def _get_label_sender_address(self):
"""On each carrier label module you need to define
which is the sender of the parcel.
The most common case is 'picking.company_id.partner_id'
and then choose the contact which has the type 'delivery'
which is suitable for each delivery carrier label module.
But your client might want to customize sender address
if he has several brands and/or shops in his company.
In this case he doesn't want his customer to see
the address of his company in his transport label
but instead, the address of the partner linked to his shop/brand
To reach this modularity, call this method to get sender address
in your delivery_carrier_label_yourcarrier module, then every
developer can manage specific needs by inherit this method in
module like :
delivery_carrier_label_yourcarrier_yourproject.
"""
self.ensure_one()
partner = self.company_id.partner_id
address_id = partner.address_get(adr_pref=["delivery"])["delivery"]
return self.env["res.partner"].browse(address_id)
def _check_existing_shipping_label(self):
"""Check that labels don't already exist for this picking"""
self.ensure_one()
labels = self.env["shipping.label"].search(
[("res_id", "=", self.id), ("res_model", "=", "stock.picking")]
)
if labels:
raise UserError(
_(
"Some labels already exist for the picking %s.\n"
"Please delete the existing labels in the "
"attachments of this picking and try again"
)
% self.name
)
| 38.057692 | 7,916 |
2,031 |
py
|
PYTHON
|
15.0
|
# Copyright 2012 Akretion <http://www.akretion.com>.
# Copyright 2013-2016 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class DeliveryCarrier(models.Model):
_inherit = "delivery.carrier"
available_option_ids = fields.One2many(
comodel_name="delivery.carrier.option",
inverse_name="carrier_id",
string="Option",
context={"active_test": False},
)
def alternative_send_shipping(self, pickings):
return [{"exact_price": False, "tracking_number": False}]
def default_options(self):
"""Returns default and available options for a carrier"""
options = self.env["delivery.carrier.option"].browse()
for available_option in self.available_option_ids:
if available_option.mandatory or available_option.by_default:
options |= available_option
return options
def send_shipping(self, pickings):
"""Handle labels and if we have them. Expected format is {'labels': [{}, ...]}
The dicts are input for stock.picking#attach_label"""
result = None
# We could want to generate labels calling a method that does not depend
# on one specific delivery_type.
# For instance, if we want to generate a default label in case there are not
# carrier
# we may want to call another method not based on any delivery_type.
# or at the contrary, we could call a common method for multiple delivery_type
# for instance, in delivery_roulier, the same method is always called for any
# carrier implemented in roulier lib.
if pickings.carrier_id:
result = super().send_shipping(pickings)
if not result:
result = self.alternative_send_shipping(pickings)
for result_dict, picking in zip(result, pickings):
for label in result_dict.get("labels", []):
picking.attach_shipping_label(label)
return result
| 42.3125 | 2,031 |
1,790 |
py
|
PYTHON
|
15.0
|
# Copyright 2014-2015 Akretion <http://www.akretion.com>
# Copyright 2014-2016 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class StockQuantPackage(models.Model):
_inherit = "stock.quant.package"
parcel_tracking = fields.Char()
parcel_tracking_uri = fields.Char(
help="Link to the carrier's tracking page for this package."
)
@api.depends("shipping_weight")
def _compute_weight(self):
"""Use shipping_weight if defined
otherwise fallback on the computed weight
"""
to_do = self.browse()
for pack in self:
if pack.shipping_weight:
pack.weight = pack.shipping_weight
elif not pack.quant_ids and not self.env.context.get("picking_id"):
# package.pack_operations would be too easy
operations = self.env["stock.move.line"].search(
[
("result_package_id", "=", pack.id),
("package_id", "=", False),
("product_id", "!=", False),
]
)
pack.weight = operations.get_weight()
else:
to_do |= pack
if to_do:
return super(StockQuantPackage, to_do)._compute_weight()
def _complete_name(self, name, args):
res = super()._complete_name(name, args)
for pack in self:
if pack.parcel_tracking:
res[pack.id] += " [%s]" % pack.parcel_tracking
if pack.weight:
res[pack.id] += " %s kg" % pack.weight
return res
def open_website_url(self):
"""Implement you own action in your module"""
return None
| 35.098039 | 1,790 |
705 |
py
|
PYTHON
|
15.0
|
# Copyright 2012 Akretion <http://www.akretion.com>.
# Copyright 2013-2016 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class DeliveryCarrierTemplateOption(models.Model):
"""Available options for a carrier (partner)"""
_name = "delivery.carrier.template.option"
_description = "Delivery carrier template option"
partner_id = fields.Many2one(comodel_name="res.partner", string="Partner Carrier")
name = fields.Char(readonly=True)
code = fields.Char(readonly=True)
description = fields.Char(
readonly=True,
help="Allow to define a more complete description " "than in the name field.",
)
| 35.25 | 705 |
600 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Delivery Free Fee Removal",
"summary": "Hide free fee lines on sales orders",
"version": "15.0.1.0.0",
"category": "Delivery",
"website": "https://github.com/OCA/delivery-carrier",
"author": "Tecnativa, Camptocamp, Odoo Community Association (OCA)",
"installable": True,
"license": "AGPL-3",
"depends": ["delivery"],
"data": ["views/sale_order_views.xml", "reports/sale_report_templates.xml"],
}
| 40 | 600 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.