Anand Kansagra
e488f208d2
And use CamelCase in label Closes odoo/odoo#29010 Closes odoo/odoo#29092 Signed-off-by: Martin Trigaux (mat) <mat@odoo.com>
1111 lines
57 KiB
Python
1111 lines
57 KiB
Python
# -*- coding: utf-8 -*-
|
||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
|
||
from collections import namedtuple
|
||
import time
|
||
from datetime import date
|
||
|
||
from itertools import groupby
|
||
from odoo import api, fields, models, SUPERUSER_ID, _
|
||
from odoo.osv import expression
|
||
from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT
|
||
from odoo.tools.float_utils import float_compare, float_is_zero, float_round
|
||
from odoo.exceptions import UserError
|
||
from odoo.addons.stock.models.stock_move import PROCUREMENT_PRIORITIES
|
||
from operator import itemgetter
|
||
|
||
|
||
class PickingType(models.Model):
|
||
_name = "stock.picking.type"
|
||
_description = "Picking Type"
|
||
_order = 'sequence, id'
|
||
|
||
def _default_show_operations(self):
|
||
return self.user_has_groups('stock.group_production_lot,'
|
||
'stock.group_stock_multi_locations,'
|
||
'stock.group_tracking_lot')
|
||
|
||
name = fields.Char('Operation Type', required=True, translate=True)
|
||
color = fields.Integer('Color')
|
||
sequence = fields.Integer('Sequence', help="Used to order the 'All Operations' kanban view")
|
||
sequence_id = fields.Many2one('ir.sequence', 'Reference Sequence', required=True)
|
||
default_location_src_id = fields.Many2one(
|
||
'stock.location', 'Default Source Location',
|
||
help="This is the default source location when you create a picking manually with this operation type. It is possible however to change it or that the routes put another location. If it is empty, it will check for the supplier location on the partner. ")
|
||
default_location_dest_id = fields.Many2one(
|
||
'stock.location', 'Default Destination Location',
|
||
help="This is the default destination location when you create a picking manually with this operation type. It is possible however to change it or that the routes put another location. If it is empty, it will check for the customer location on the partner. ")
|
||
code = fields.Selection([('incoming', 'Vendors'), ('outgoing', 'Customers'), ('internal', 'Internal')], 'Type of Operation', required=True)
|
||
return_picking_type_id = fields.Many2one('stock.picking.type', 'Operation Type for Returns')
|
||
show_entire_packs = fields.Boolean('Move Entire Packages', help="If ticked, you will be able to select entire packages to move")
|
||
warehouse_id = fields.Many2one(
|
||
'stock.warehouse', 'Warehouse', ondelete='cascade',
|
||
default=lambda self: self.env['stock.warehouse'].search([('company_id', '=', self.env.company.id)], limit=1))
|
||
active = fields.Boolean('Active', default=True)
|
||
use_create_lots = fields.Boolean(
|
||
'Create New Lots/Serial Numbers', default=True,
|
||
help="If this is checked only, it will suppose you want to create new Lots/Serial Numbers, so you can provide them in a text field. ")
|
||
use_existing_lots = fields.Boolean(
|
||
'Use Existing Lots/Serial Numbers', default=True,
|
||
help="If this is checked, you will be able to choose the Lots/Serial Numbers. You can also decide to not put lots in this operation type. This means it will create stock with no lot or not put a restriction on the lot taken. ")
|
||
show_operations = fields.Boolean(
|
||
'Show Detailed Operations', default=_default_show_operations,
|
||
help="If this checkbox is ticked, the pickings lines will represent detailed stock operations. If not, the picking lines will represent an aggregate of detailed stock operations.")
|
||
|
||
# Statistics for the kanban view
|
||
count_picking_draft = fields.Integer(compute='_compute_picking_count')
|
||
count_picking_ready = fields.Integer(compute='_compute_picking_count')
|
||
count_picking = fields.Integer(compute='_compute_picking_count')
|
||
count_picking_waiting = fields.Integer(compute='_compute_picking_count')
|
||
count_picking_late = fields.Integer(compute='_compute_picking_count')
|
||
count_picking_backorders = fields.Integer(compute='_compute_picking_count')
|
||
rate_picking_late = fields.Integer(compute='_compute_picking_count')
|
||
rate_picking_backorders = fields.Integer(compute='_compute_picking_count')
|
||
barcode = fields.Char('Barcode', copy=False)
|
||
company_id = fields.Many2one('res.company', 'Company', related='warehouse_id.company_id', store=True)
|
||
|
||
def _compute_picking_count(self):
|
||
# TDE TODO count picking can be done using previous two
|
||
domains = {
|
||
'count_picking_draft': [('state', '=', 'draft')],
|
||
'count_picking_waiting': [('state', 'in', ('confirmed', 'waiting'))],
|
||
'count_picking_ready': [('state', '=', 'assigned')],
|
||
'count_picking': [('state', 'in', ('assigned', 'waiting', 'confirmed'))],
|
||
'count_picking_late': [('scheduled_date', '<', time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)), ('state', 'in', ('assigned', 'waiting', 'confirmed'))],
|
||
'count_picking_backorders': [('backorder_id', '!=', False), ('state', 'in', ('confirmed', 'assigned', 'waiting'))],
|
||
}
|
||
for field in domains:
|
||
data = self.env['stock.picking'].read_group(domains[field] +
|
||
[('state', 'not in', ('done', 'cancel')), ('picking_type_id', 'in', self.ids)],
|
||
['picking_type_id'], ['picking_type_id'])
|
||
count = {
|
||
x['picking_type_id'][0]: x['picking_type_id_count']
|
||
for x in data if x['picking_type_id']
|
||
}
|
||
for record in self:
|
||
record[field] = count.get(record.id, 0)
|
||
for record in self:
|
||
record.rate_picking_late = record.count_picking and record.count_picking_late * 100 / record.count_picking or 0
|
||
record.rate_picking_backorders = record.count_picking and record.count_picking_backorders * 100 / record.count_picking or 0
|
||
|
||
def name_get(self):
|
||
""" Display 'Warehouse_name: PickingType_name' """
|
||
res = []
|
||
for picking_type in self:
|
||
if picking_type.warehouse_id:
|
||
name = picking_type.warehouse_id.name + ': ' + picking_type.name
|
||
else:
|
||
name = picking_type.name
|
||
res.append((picking_type.id, name))
|
||
return res
|
||
|
||
@api.model
|
||
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
|
||
args = args or []
|
||
domain = []
|
||
if name:
|
||
domain = ['|', ('name', operator, name), ('warehouse_id.name', operator, name)]
|
||
picking_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid)
|
||
return self.browse(picking_ids).name_get()
|
||
|
||
@api.onchange('code')
|
||
def onchange_picking_code(self):
|
||
if self.code == 'incoming':
|
||
self.default_location_src_id = self.env.ref('stock.stock_location_suppliers').id
|
||
self.default_location_dest_id = self.env.ref('stock.stock_location_stock').id
|
||
elif self.code == 'outgoing':
|
||
self.default_location_src_id = self.env.ref('stock.stock_location_stock').id
|
||
self.default_location_dest_id = self.env.ref('stock.stock_location_customers').id
|
||
self.show_operations = self.code != 'incoming' and self.user_has_groups(
|
||
'stock.group_production_lot,'
|
||
'stock.group_stock_multi_locations,'
|
||
'stock.group_tracking_lot'
|
||
)
|
||
|
||
def _get_action(self, action_xmlid):
|
||
# TDE TODO check to have one view + custo in methods
|
||
action = self.env.ref(action_xmlid).read()[0]
|
||
if self:
|
||
action['display_name'] = self.display_name
|
||
return action
|
||
|
||
def get_action_picking_tree_late(self):
|
||
return self._get_action('stock.action_picking_tree_late')
|
||
|
||
def get_action_picking_tree_backorder(self):
|
||
return self._get_action('stock.action_picking_tree_backorder')
|
||
|
||
def get_action_picking_tree_waiting(self):
|
||
return self._get_action('stock.action_picking_tree_waiting')
|
||
|
||
def get_action_picking_tree_ready(self):
|
||
return self._get_action('stock.action_picking_tree_ready')
|
||
|
||
def get_stock_picking_action_picking_type(self):
|
||
return self._get_action('stock.stock_picking_action_picking_type')
|
||
|
||
|
||
class Picking(models.Model):
|
||
_name = "stock.picking"
|
||
_inherit = ['mail.thread', 'mail.activity.mixin']
|
||
_description = "Transfer"
|
||
_order = "priority desc, date asc, id desc"
|
||
|
||
name = fields.Char(
|
||
'Reference', default='/',
|
||
copy=False, index=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]})
|
||
origin = fields.Char(
|
||
'Source Document', index=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
|
||
help="Reference of the document")
|
||
note = fields.Text('Notes')
|
||
|
||
backorder_id = fields.Many2one(
|
||
'stock.picking', 'Back Order of',
|
||
copy=False, index=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
|
||
help="If this shipment was split, then this field links to the shipment which contains the already processed part.")
|
||
|
||
backorder_ids = fields.One2many('stock.picking', 'backorder_id', 'Back Orders')
|
||
|
||
move_type = fields.Selection([
|
||
('direct', 'As soon as possible'), ('one', 'When all products are ready')], 'Shipping Policy',
|
||
default='direct', required=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
|
||
help="It specifies goods to be deliver partially or all at once")
|
||
|
||
state = fields.Selection([
|
||
('draft', 'Draft'),
|
||
('waiting', 'Waiting Another Operation'),
|
||
('confirmed', 'Waiting'),
|
||
('assigned', 'Ready'),
|
||
('done', 'Done'),
|
||
('cancel', 'Cancelled'),
|
||
], string='Status', compute='_compute_state',
|
||
copy=False, index=True, readonly=True, store=True, tracking=True,
|
||
help=" * Draft: The transfer is not confirmed yet. Reservation doesn't apply.\n"
|
||
" * Waiting another operation: This transfer is waiting for another operation before being ready.\n"
|
||
" * Waiting: The transfer is waiting for the availability of some products.\n(a) The shipping policy is \"As soon as possible\": no product could be reserved.\n(b) The shipping policy is \"When all products are ready\": not all the products could be reserved.\n"
|
||
" * Ready: The transfer is ready to be processed.\n(a) The shipping policy is \"As soon as possible\": at least one product has been reserved.\n(b) The shipping policy is \"When all products are ready\": all product have been reserved.\n"
|
||
" * Done: The transfer has been processed.\n"
|
||
" * Cancelled: The transfer has been cancelled.")
|
||
|
||
group_id = fields.Many2one(
|
||
'procurement.group', 'Procurement Group',
|
||
readonly=True, related='move_lines.group_id', store=True)
|
||
|
||
priority = fields.Selection(
|
||
PROCUREMENT_PRIORITIES, string='Priority',
|
||
compute='_compute_priority', inverse='_set_priority', store=True,
|
||
# default='1', required=True, # TDE: required, depending on moves ? strange
|
||
index=True, tracking=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
|
||
help="Products will be reserved first for the transfers with the highest priorities.")
|
||
scheduled_date = fields.Datetime(
|
||
'Scheduled Date', compute='_compute_scheduled_date', inverse='_set_scheduled_date', store=True,
|
||
index=True, tracking=True,
|
||
help="Scheduled time for the first part of the shipment to be processed. Setting manually a value here would set it as expected date for all the stock moves.")
|
||
date = fields.Datetime(
|
||
'Creation Date',
|
||
default=fields.Datetime.now, index=True, tracking=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
|
||
help="Creation Date, usually the time of the order")
|
||
date_done = fields.Datetime('Date of Transfer', copy=False, readonly=True, help="Date at which the transfer has been processed or cancelled.")
|
||
|
||
location_id = fields.Many2one(
|
||
'stock.location', "Source Location",
|
||
default=lambda self: self.env['stock.picking.type'].browse(self._context.get('default_picking_type_id')).default_location_src_id,
|
||
readonly=True, required=True,
|
||
states={'draft': [('readonly', False)]})
|
||
location_dest_id = fields.Many2one(
|
||
'stock.location', "Destination Location",
|
||
default=lambda self: self.env['stock.picking.type'].browse(self._context.get('default_picking_type_id')).default_location_dest_id,
|
||
readonly=True, required=True,
|
||
states={'draft': [('readonly', False)]})
|
||
move_lines = fields.One2many('stock.move', 'picking_id', string="Stock Moves", copy=True)
|
||
move_ids_without_package = fields.One2many('stock.move', 'picking_id', string="Stock moves not in package", compute='_compute_move_without_package', inverse='_set_move_without_package')
|
||
has_scrap_move = fields.Boolean(
|
||
'Has Scrap Moves', compute='_has_scrap_move')
|
||
picking_type_id = fields.Many2one(
|
||
'stock.picking.type', 'Operation Type',
|
||
required=True,
|
||
readonly=True,
|
||
states={'draft': [('readonly', False)]})
|
||
picking_type_code = fields.Selection([
|
||
('incoming', 'Vendors'),
|
||
('outgoing', 'Customers'),
|
||
('internal', 'Internal')], related='picking_type_id.code',
|
||
readonly=True)
|
||
picking_type_entire_packs = fields.Boolean(related='picking_type_id.show_entire_packs',
|
||
readonly=True)
|
||
|
||
partner_id = fields.Many2one(
|
||
'res.partner', 'Contact',
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]})
|
||
company_id = fields.Many2one(
|
||
'res.company', 'Company',
|
||
default=lambda self: self.env.company,
|
||
index=True, required=True,
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]})
|
||
user_id = fields.Many2one(
|
||
'res.users', 'Responsible', tracking=True,
|
||
domain=lambda self: [('groups_id', 'in', self.env.ref('stock.group_stock_user').id)],
|
||
default=lambda self: self.env.user)
|
||
|
||
move_line_ids = fields.One2many('stock.move.line', 'picking_id', 'Operations')
|
||
move_line_ids_without_package = fields.One2many('stock.move.line', 'picking_id', 'Operations without package', domain=['|',('package_level_id', '=', False), ('picking_type_entire_packs', '=', False)])
|
||
|
||
move_line_exist = fields.Boolean(
|
||
'Has Pack Operations', compute='_compute_move_line_exist',
|
||
help='Check the existence of pack operation on the picking')
|
||
|
||
has_packages = fields.Boolean(
|
||
'Has Packages', compute='_compute_has_packages',
|
||
help='Check the existence of destination packages on move lines')
|
||
|
||
show_check_availability = fields.Boolean(
|
||
compute='_compute_show_check_availability',
|
||
help='Technical field used to compute whether the check availability button should be shown.')
|
||
show_mark_as_todo = fields.Boolean(
|
||
compute='_compute_show_mark_as_todo',
|
||
help='Technical field used to compute whether the mark as todo button should be shown.')
|
||
show_validate = fields.Boolean(
|
||
compute='_compute_show_validate',
|
||
help='Technical field used to compute whether the validate should be shown.')
|
||
use_create_lots = fields.Boolean(related='picking_type_id.use_create_lots')
|
||
|
||
owner_id = fields.Many2one(
|
||
'res.partner', 'Owner',
|
||
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
|
||
help="Default Owner")
|
||
printed = fields.Boolean('Printed')
|
||
is_locked = fields.Boolean(default=True, help='When the picking is not done this allows changing the '
|
||
'initial demand. When the picking is done this allows '
|
||
'changing the done quantities.')
|
||
# Used to search on pickings
|
||
product_id = fields.Many2one('product.product', 'Product', related='move_lines.product_id', readonly=False)
|
||
show_operations = fields.Boolean(compute='_compute_show_operations')
|
||
show_lots_text = fields.Boolean(compute='_compute_show_lots_text')
|
||
has_tracking = fields.Boolean(compute='_compute_has_tracking')
|
||
immediate_transfer = fields.Boolean(default=False)
|
||
package_level_ids = fields.One2many('stock.package_level', 'picking_id')
|
||
package_level_ids_details = fields.One2many('stock.package_level', 'picking_id')
|
||
|
||
_sql_constraints = [
|
||
('name_uniq', 'unique(name, company_id)', 'Reference must be unique per company!'),
|
||
]
|
||
|
||
def _compute_has_tracking(self):
|
||
for picking in self:
|
||
picking.has_tracking = any(m.has_tracking != 'none' for m in picking.move_lines)
|
||
|
||
@api.depends('picking_type_id.show_operations')
|
||
def _compute_show_operations(self):
|
||
for picking in self:
|
||
if self.env.context.get('force_detailed_view'):
|
||
picking.show_operations = True
|
||
continue
|
||
if picking.picking_type_id.show_operations:
|
||
if (picking.state == 'draft' and picking.immediate_transfer) or picking.state != 'draft':
|
||
picking.show_operations = True
|
||
else:
|
||
picking.show_operations = False
|
||
else:
|
||
picking.show_operations = False
|
||
|
||
@api.depends('move_line_ids', 'picking_type_id.use_create_lots', 'picking_type_id.use_existing_lots', 'state')
|
||
def _compute_show_lots_text(self):
|
||
group_production_lot_enabled = self.user_has_groups('stock.group_production_lot')
|
||
for picking in self:
|
||
if not picking.move_line_ids:
|
||
picking.show_lots_text = False
|
||
elif group_production_lot_enabled and picking.picking_type_id.use_create_lots \
|
||
and not picking.picking_type_id.use_existing_lots and picking.state != 'done':
|
||
picking.show_lots_text = True
|
||
else:
|
||
picking.show_lots_text = False
|
||
|
||
@api.depends('move_type', 'move_lines.state', 'move_lines.picking_id')
|
||
def _compute_state(self):
|
||
''' State of a picking depends on the state of its related stock.move
|
||
- Draft: only used for "planned pickings"
|
||
- Waiting: if the picking is not ready to be sent so if
|
||
- (a) no quantity could be reserved at all or if
|
||
- (b) some quantities could be reserved and the shipping policy is "deliver all at once"
|
||
- Waiting another move: if the picking is waiting for another move
|
||
- Ready: if the picking is ready to be sent so if:
|
||
- (a) all quantities are reserved or if
|
||
- (b) some quantities could be reserved and the shipping policy is "as soon as possible"
|
||
- Done: if the picking is done.
|
||
- Cancelled: if the picking is cancelled
|
||
'''
|
||
for picking in self:
|
||
if not picking.move_lines:
|
||
picking.state = 'draft'
|
||
elif any(move.state == 'draft' for move in picking.move_lines): # TDE FIXME: should be all ?
|
||
picking.state = 'draft'
|
||
elif all(move.state == 'cancel' for move in picking.move_lines):
|
||
picking.state = 'cancel'
|
||
elif all(move.state in ['cancel', 'done'] for move in picking.move_lines):
|
||
picking.state = 'done'
|
||
else:
|
||
relevant_move_state = picking.move_lines._get_relevant_state_among_moves()
|
||
if relevant_move_state == 'partially_available':
|
||
picking.state = 'assigned'
|
||
else:
|
||
picking.state = relevant_move_state
|
||
|
||
@api.depends('move_lines.priority')
|
||
def _compute_priority(self):
|
||
for picking in self:
|
||
if picking.mapped('move_lines'):
|
||
priorities = [priority for priority in picking.mapped('move_lines.priority') if priority] or ['1']
|
||
picking.priority = max(priorities)
|
||
else:
|
||
picking.priority = '1'
|
||
|
||
def _set_priority(self):
|
||
for picking in self:
|
||
picking.move_lines.write({'priority': picking.priority})
|
||
|
||
@api.depends('move_lines.date_expected')
|
||
def _compute_scheduled_date(self):
|
||
for picking in self:
|
||
if picking.move_type == 'direct':
|
||
picking.scheduled_date = min(picking.move_lines.mapped('date_expected') or [fields.Datetime.now()])
|
||
else:
|
||
picking.scheduled_date = max(picking.move_lines.mapped('date_expected') or [fields.Datetime.now()])
|
||
|
||
def _set_scheduled_date(self):
|
||
for picking in self:
|
||
picking.move_lines.write({'date_expected': picking.scheduled_date})
|
||
|
||
def _has_scrap_move(self):
|
||
for picking in self:
|
||
# TDE FIXME: better implementation
|
||
picking.has_scrap_move = bool(self.env['stock.move'].search_count([('picking_id', '=', picking.id), ('scrapped', '=', True)]))
|
||
|
||
def _compute_move_line_exist(self):
|
||
for picking in self:
|
||
picking.move_line_exist = bool(picking.move_line_ids)
|
||
|
||
def _compute_has_packages(self):
|
||
for picking in self:
|
||
picking.has_packages = picking.move_line_ids.filtered(lambda ml: ml.result_package_id)
|
||
|
||
def _compute_show_check_availability(self):
|
||
""" According to `picking.show_check_availability`, the "check availability" button will be
|
||
displayed in the form view of a picking.
|
||
"""
|
||
for picking in self:
|
||
if picking.immediate_transfer or not picking.is_locked or picking.state not in ('confirmed', 'waiting', 'assigned'):
|
||
picking.show_check_availability = False
|
||
continue
|
||
picking.show_check_availability = any(
|
||
move.state in ('waiting', 'confirmed', 'partially_available') and
|
||
float_compare(move.product_uom_qty, 0, precision_rounding=move.product_uom.rounding)
|
||
for move in picking.move_lines
|
||
)
|
||
|
||
@api.depends('state', 'move_lines')
|
||
def _compute_show_mark_as_todo(self):
|
||
for picking in self:
|
||
if not picking.move_lines and not picking.package_level_ids:
|
||
picking.show_mark_as_todo = False
|
||
elif not picking.immediate_transfer and picking.state == 'draft':
|
||
picking.show_mark_as_todo = True
|
||
elif picking.state != 'draft' or not picking.id:
|
||
picking.show_mark_as_todo = False
|
||
else:
|
||
picking.show_mark_as_todo = True
|
||
|
||
@api.depends('state', 'is_locked')
|
||
def _compute_show_validate(self):
|
||
for picking in self:
|
||
if not (picking.immediate_transfer) and picking.state == 'draft':
|
||
picking.show_validate = False
|
||
elif picking.state not in ('draft', 'waiting', 'confirmed', 'assigned') or not picking.is_locked:
|
||
picking.show_validate = False
|
||
else:
|
||
picking.show_validate = True
|
||
|
||
@api.onchange('picking_type_id', 'partner_id')
|
||
def onchange_picking_type(self):
|
||
if self.picking_type_id:
|
||
if self.picking_type_id.default_location_src_id:
|
||
location_id = self.picking_type_id.default_location_src_id.id
|
||
elif self.partner_id:
|
||
location_id = self.partner_id.property_stock_supplier.id
|
||
else:
|
||
customerloc, location_id = self.env['stock.warehouse']._get_partner_locations()
|
||
|
||
if self.picking_type_id.default_location_dest_id:
|
||
location_dest_id = self.picking_type_id.default_location_dest_id.id
|
||
elif self.partner_id:
|
||
location_dest_id = self.partner_id.property_stock_customer.id
|
||
else:
|
||
location_dest_id, supplierloc = self.env['stock.warehouse']._get_partner_locations()
|
||
|
||
if self.state == 'draft':
|
||
self.location_id = location_id
|
||
self.location_dest_id = location_dest_id
|
||
# TDE CLEANME move into onchange_partner_id
|
||
if self.partner_id and self.partner_id.picking_warn:
|
||
if self.partner_id.picking_warn == 'no-message' and self.partner_id.parent_id:
|
||
partner = self.partner_id.parent_id
|
||
elif self.partner_id.picking_warn not in ('no-message', 'block') and self.partner_id.parent_id.picking_warn == 'block':
|
||
partner = self.partner_id.parent_id
|
||
else:
|
||
partner = self.partner_id
|
||
if partner.picking_warn != 'no-message':
|
||
if partner.picking_warn == 'block':
|
||
self.partner_id = False
|
||
return {'warning': {
|
||
'title': ("Warning for %s") % partner.name,
|
||
'message': partner.picking_warn_msg
|
||
}}
|
||
|
||
@api.model
|
||
def create(self, vals):
|
||
# TDE FIXME: clean that brol
|
||
defaults = self.default_get(['name', 'picking_type_id'])
|
||
if vals.get('name', '/') == '/' and defaults.get('name', '/') == '/' and vals.get('picking_type_id', defaults.get('picking_type_id')):
|
||
vals['name'] = self.env['stock.picking.type'].browse(vals.get('picking_type_id', defaults.get('picking_type_id'))).sequence_id.next_by_id()
|
||
|
||
# TDE FIXME: what ?
|
||
# As the on_change in one2many list is WIP, we will overwrite the locations on the stock moves here
|
||
# As it is a create the format will be a list of (0, 0, dict)
|
||
moves = vals.get('move_lines') or vals.get('move_ids_without_package')
|
||
if moves and vals.get('location_id') and vals.get('location_dest_id'):
|
||
for move in moves:
|
||
if len(move) == 3 and move[0] == 0:
|
||
move[2]['location_id'] = vals['location_id']
|
||
move[2]['location_dest_id'] = vals['location_dest_id']
|
||
res = super(Picking, self).create(vals)
|
||
res._autoconfirm_picking()
|
||
return res
|
||
|
||
def write(self, vals):
|
||
res = super(Picking, self).write(vals)
|
||
# Change locations of moves if those of the picking change
|
||
after_vals = {}
|
||
if vals.get('location_id'):
|
||
after_vals['location_id'] = vals['location_id']
|
||
if vals.get('location_dest_id'):
|
||
after_vals['location_dest_id'] = vals['location_dest_id']
|
||
if after_vals:
|
||
self.mapped('move_lines').filtered(lambda move: not move.scrapped).write(after_vals)
|
||
if vals.get('move_lines'):
|
||
# Do not run autoconfirm if any of the moves has an initial demand. If an initial demand
|
||
# is present in any of the moves, it means the picking was created through the "planned
|
||
# transfer" mechanism.
|
||
pickings_to_not_autoconfirm = self.env['stock.picking']
|
||
for picking in self:
|
||
if picking.state != 'draft':
|
||
continue
|
||
for move in picking.move_lines:
|
||
if not float_is_zero(move.product_uom_qty, precision_rounding=move.product_uom.rounding):
|
||
pickings_to_not_autoconfirm |= picking
|
||
break
|
||
(self - pickings_to_not_autoconfirm)._autoconfirm_picking()
|
||
return res
|
||
|
||
def unlink(self):
|
||
self.mapped('move_lines')._action_cancel()
|
||
self.mapped('move_lines').unlink() # Checks if moves are not done
|
||
return super(Picking, self).unlink()
|
||
|
||
# Actions
|
||
# ----------------------------------------
|
||
|
||
def action_assign_owner(self):
|
||
for picking in self:
|
||
picking.move_line_ids.write({'owner_id': picking.owner_id.id})
|
||
|
||
def action_assign_partner(self):
|
||
for picking in self:
|
||
picking.move_lines.write({'partner_id': picking.partner_id.id})
|
||
|
||
def do_print_picking(self):
|
||
self.write({'printed': True})
|
||
return self.env.ref('stock.action_report_picking').report_action(self)
|
||
|
||
def action_confirm(self):
|
||
self.mapped('package_level_ids').filtered(lambda pl: pl.state == 'draft' and not pl.move_ids)._generate_moves()
|
||
# call `_action_confirm` on every draft move
|
||
self.mapped('move_lines')\
|
||
.filtered(lambda move: move.state == 'draft')\
|
||
._action_confirm()
|
||
# call `_action_assign` on every confirmed move which location_id bypasses the reservation
|
||
self.filtered(lambda picking: picking.location_id.usage in ('supplier', 'inventory', 'production') and picking.state == 'confirmed')\
|
||
.mapped('move_lines')._action_assign()
|
||
return True
|
||
|
||
def action_assign(self):
|
||
""" Check availability of picking moves.
|
||
This has the effect of changing the state and reserve quants on available moves, and may
|
||
also impact the state of the picking as it is computed based on move's states.
|
||
@return: True
|
||
"""
|
||
self.filtered(lambda picking: picking.state == 'draft').action_confirm()
|
||
moves = self.mapped('move_lines').filtered(lambda move: move.state not in ('draft', 'cancel', 'done'))
|
||
if not moves:
|
||
raise UserError(_('Nothing to check the availability for.'))
|
||
# If a package level is done when confirmed its location can be different than where it will be reserved.
|
||
# So we remove the move lines created when confirmed to set quantity done to the new reserved ones.
|
||
package_level_done = self.mapped('package_level_ids').filtered(lambda pl: pl.is_done and pl.state == 'confirmed')
|
||
package_level_done.write({'is_done': False})
|
||
moves._action_assign()
|
||
package_level_done.write({'is_done': True})
|
||
return True
|
||
|
||
def action_cancel(self):
|
||
self.mapped('move_lines')._action_cancel()
|
||
self.write({'is_locked': True})
|
||
return True
|
||
|
||
def action_done(self):
|
||
"""Changes picking state to done by processing the Stock Moves of the Picking
|
||
|
||
Normally that happens when the button "Done" is pressed on a Picking view.
|
||
@return: True
|
||
"""
|
||
# TDE FIXME: remove decorator when migration the remaining
|
||
todo_moves = self.mapped('move_lines').filtered(lambda self: self.state in ['draft', 'waiting', 'partially_available', 'assigned', 'confirmed'])
|
||
# Check if there are ops not linked to moves yet
|
||
for pick in self:
|
||
# # Explode manually added packages
|
||
# for ops in pick.move_line_ids.filtered(lambda x: not x.move_id and not x.product_id):
|
||
# for quant in ops.package_id.quant_ids: #Or use get_content for multiple levels
|
||
# self.move_line_ids.create({'product_id': quant.product_id.id,
|
||
# 'package_id': quant.package_id.id,
|
||
# 'result_package_id': ops.result_package_id,
|
||
# 'lot_id': quant.lot_id.id,
|
||
# 'owner_id': quant.owner_id.id,
|
||
# 'product_uom_id': quant.product_id.uom_id.id,
|
||
# 'product_qty': quant.qty,
|
||
# 'qty_done': quant.qty,
|
||
# 'location_id': quant.location_id.id, # Could be ops too
|
||
# 'location_dest_id': ops.location_dest_id.id,
|
||
# 'picking_id': pick.id
|
||
# }) # Might change first element
|
||
# # Link existing moves or add moves when no one is related
|
||
for ops in pick.move_line_ids.filtered(lambda x: not x.move_id):
|
||
# Search move with this product
|
||
moves = pick.move_lines.filtered(lambda x: x.product_id == ops.product_id)
|
||
moves = sorted(moves, key=lambda m: m.quantity_done < m.product_qty, reverse=True)
|
||
if moves:
|
||
ops.move_id = moves[0].id
|
||
else:
|
||
new_move = self.env['stock.move'].create({
|
||
'name': _('New Move:') + ops.product_id.display_name,
|
||
'product_id': ops.product_id.id,
|
||
'product_uom_qty': ops.qty_done,
|
||
'product_uom': ops.product_uom_id.id,
|
||
'description_picking': ops.description_picking,
|
||
'location_id': pick.location_id.id,
|
||
'location_dest_id': pick.location_dest_id.id,
|
||
'picking_id': pick.id,
|
||
'picking_type_id': pick.picking_type_id.id,
|
||
})
|
||
ops.move_id = new_move.id
|
||
new_move._action_confirm()
|
||
todo_moves |= new_move
|
||
#'qty_done': ops.qty_done})
|
||
todo_moves._action_done(cancel_backorder=self.env.context.get('cancel_backorder'))
|
||
self.write({'date_done': fields.Datetime.now()})
|
||
return True
|
||
|
||
@api.depends('state', 'move_lines', 'move_lines.state', 'move_lines.package_level_id', 'move_lines.move_line_ids.package_level_id')
|
||
def _compute_move_without_package(self):
|
||
for picking in self:
|
||
move_ids_without_package = self.env['stock.move']
|
||
if picking.picking_type_entire_packs == False:
|
||
move_ids_without_package = picking.move_lines
|
||
else:
|
||
for move in picking.move_lines:
|
||
if not move.package_level_id:
|
||
if move.state in ('assigned', 'done'):
|
||
if any(not ml.package_level_id for ml in move.move_line_ids):
|
||
move_ids_without_package |= move
|
||
else:
|
||
move_ids_without_package |= move
|
||
picking.move_ids_without_package = move_ids_without_package.filtered(lambda move: not move.scrap_ids)
|
||
|
||
def _set_move_without_package(self):
|
||
self.move_lines |= self.move_ids_without_package
|
||
|
||
def _check_move_lines_map_quant_package(self, package):
|
||
""" This method checks that all product of the package (quant) are well present in the move_line_ids of the picking. """
|
||
all_in = True
|
||
pack_move_lines = self.move_line_ids.filtered(lambda ml: ml.package_id == package)
|
||
keys = ['product_id', 'lot_id']
|
||
precision_digits = self.env['decimal.precision'].precision_get('Product Unit of Measure')
|
||
|
||
grouped_quants = {}
|
||
for k, g in groupby(sorted(package.quant_ids, key=itemgetter(*keys)), key=itemgetter(*keys)):
|
||
grouped_quants[k] = sum(self.env['stock.quant'].concat(*list(g)).mapped('quantity'))
|
||
|
||
grouped_ops = {}
|
||
for k, g in groupby(sorted(pack_move_lines, key=itemgetter(*keys)), key=itemgetter(*keys)):
|
||
grouped_ops[k] = sum(self.env['stock.move.line'].concat(*list(g)).mapped('product_qty'))
|
||
if any(not float_is_zero(grouped_quants.get(key, 0) - grouped_ops.get(key, 0), precision_digits=precision_digits) for key in grouped_quants) \
|
||
or any(not float_is_zero(grouped_ops.get(key, 0) - grouped_quants.get(key, 0), precision_digits=precision_digits) for key in grouped_ops):
|
||
all_in = False
|
||
return all_in
|
||
|
||
def _check_entire_pack(self):
|
||
""" This function check if entire packs are moved in the picking"""
|
||
for picking in self:
|
||
origin_packages = picking.move_line_ids.mapped("package_id")
|
||
for pack in origin_packages:
|
||
if picking._check_move_lines_map_quant_package(pack):
|
||
package_level_ids = picking.package_level_ids.filtered(lambda pl: pl.package_id == pack)
|
||
move_lines_to_pack = picking.move_line_ids.filtered(lambda ml: ml.package_id == pack)
|
||
if not package_level_ids:
|
||
self.env['stock.package_level'].create({
|
||
'picking_id': picking.id,
|
||
'package_id': pack.id,
|
||
'location_id': pack.location_id.id,
|
||
'location_dest_id': picking.move_line_ids.filtered(lambda ml: ml.package_id == pack).mapped('location_dest_id')[:1].id,
|
||
'move_line_ids': [(6, 0, move_lines_to_pack.ids)]
|
||
})
|
||
move_lines_to_pack.write({
|
||
'result_package_id': pack.id,
|
||
})
|
||
else:
|
||
move_lines_in_package_level = move_lines_to_pack.filtered(lambda ml: ml.move_id.package_level_id)
|
||
move_lines_without_package_level = move_lines_to_pack - move_lines_in_package_level
|
||
for ml in move_lines_in_package_level:
|
||
ml.write({
|
||
'result_package_id': pack.id,
|
||
'package_level_id': ml.move_id.package_level_id.id,
|
||
})
|
||
move_lines_without_package_level.write({
|
||
'result_package_id': pack.id,
|
||
'package_level_id': package_level_ids[0].id,
|
||
})
|
||
|
||
def do_unreserve(self):
|
||
for picking in self:
|
||
picking.move_lines._do_unreserve()
|
||
picking.package_level_ids.filtered(lambda p: not p.move_ids).unlink()
|
||
|
||
def button_validate(self):
|
||
self.ensure_one()
|
||
if not self.move_lines and not self.move_line_ids:
|
||
raise UserError(_('Please add some items to move.'))
|
||
|
||
# If no lots when needed, raise error
|
||
picking_type = self.picking_type_id
|
||
precision_digits = self.env['decimal.precision'].precision_get('Product Unit of Measure')
|
||
no_quantities_done = all(float_is_zero(move_line.qty_done, precision_digits=precision_digits) for move_line in self.move_line_ids.filtered(lambda m: m.state not in ('done', 'cancel')))
|
||
no_reserved_quantities = all(float_is_zero(move_line.product_qty, precision_rounding=move_line.product_uom_id.rounding) for move_line in self.move_line_ids)
|
||
if no_reserved_quantities and no_quantities_done:
|
||
raise UserError(_('You cannot validate a transfer if no quantites are reserved nor done. To force the transfer, switch in edit more and encode the done quantities.'))
|
||
|
||
if picking_type.use_create_lots or picking_type.use_existing_lots:
|
||
lines_to_check = self.move_line_ids
|
||
if not no_quantities_done:
|
||
lines_to_check = lines_to_check.filtered(
|
||
lambda line: float_compare(line.qty_done, 0,
|
||
precision_rounding=line.product_uom_id.rounding)
|
||
)
|
||
|
||
for line in lines_to_check:
|
||
product = line.product_id
|
||
if product and product.tracking != 'none':
|
||
if not line.lot_name and not line.lot_id:
|
||
raise UserError(_('You need to supply a Lot/Serial number for product %s.') % product.display_name)
|
||
|
||
if no_quantities_done:
|
||
view = self.env.ref('stock.view_immediate_transfer')
|
||
wiz = self.env['stock.immediate.transfer'].create({'pick_ids': [(4, self.id)]})
|
||
return {
|
||
'name': _('Immediate Transfer?'),
|
||
'type': 'ir.actions.act_window',
|
||
'view_mode': 'form',
|
||
'res_model': 'stock.immediate.transfer',
|
||
'views': [(view.id, 'form')],
|
||
'view_id': view.id,
|
||
'target': 'new',
|
||
'res_id': wiz.id,
|
||
'context': self.env.context,
|
||
}
|
||
|
||
if self._get_overprocessed_stock_moves() and not self._context.get('skip_overprocessed_check'):
|
||
view = self.env.ref('stock.view_overprocessed_transfer')
|
||
wiz = self.env['stock.overprocessed.transfer'].create({'picking_id': self.id})
|
||
return {
|
||
'type': 'ir.actions.act_window',
|
||
'view_mode': 'form',
|
||
'res_model': 'stock.overprocessed.transfer',
|
||
'views': [(view.id, 'form')],
|
||
'view_id': view.id,
|
||
'target': 'new',
|
||
'res_id': wiz.id,
|
||
'context': self.env.context,
|
||
}
|
||
|
||
# Check backorder should check for other barcodes
|
||
if self._check_backorder():
|
||
return self.action_generate_backorder_wizard()
|
||
self.action_done()
|
||
return
|
||
|
||
def action_generate_backorder_wizard(self):
|
||
view = self.env.ref('stock.view_backorder_confirmation')
|
||
wiz = self.env['stock.backorder.confirmation'].create({'pick_ids': [(4, p.id) for p in self]})
|
||
return {
|
||
'name': _('Create Backorder?'),
|
||
'type': 'ir.actions.act_window',
|
||
'view_mode': 'form',
|
||
'res_model': 'stock.backorder.confirmation',
|
||
'views': [(view.id, 'form')],
|
||
'view_id': view.id,
|
||
'target': 'new',
|
||
'res_id': wiz.id,
|
||
'context': self.env.context,
|
||
}
|
||
|
||
def action_toggle_is_locked(self):
|
||
self.ensure_one()
|
||
self.is_locked = not self.is_locked
|
||
return True
|
||
|
||
def _check_backorder(self):
|
||
""" This method will loop over all the move lines of self and
|
||
check if creating a backorder is necessary. This method is
|
||
called during button_validate if the user has already processed
|
||
some quantities and in the immediate transfer wizard that is
|
||
displayed if the user has not processed any quantities.
|
||
|
||
:return: True if a backorder is necessary else False
|
||
"""
|
||
quantity_todo = {}
|
||
quantity_done = {}
|
||
for move in self.mapped('move_lines'):
|
||
quantity_todo.setdefault(move.product_id.id, 0)
|
||
quantity_done.setdefault(move.product_id.id, 0)
|
||
quantity_todo[move.product_id.id] += move.product_uom_qty
|
||
quantity_done[move.product_id.id] += move.quantity_done
|
||
for ops in self.mapped('move_line_ids').filtered(lambda x: x.package_id and not x.product_id and not x.move_id):
|
||
for quant in ops.package_id.quant_ids:
|
||
quantity_done.setdefault(quant.product_id.id, 0)
|
||
quantity_done[quant.product_id.id] += quant.qty
|
||
for pack in self.mapped('move_line_ids').filtered(lambda x: x.product_id and not x.move_id):
|
||
quantity_done.setdefault(pack.product_id.id, 0)
|
||
quantity_done[pack.product_id.id] += pack.product_uom_id._compute_quantity(pack.qty_done, pack.product_id.uom_id)
|
||
return any(quantity_done[x] < quantity_todo.get(x, 0) for x in quantity_done)
|
||
|
||
def _autoconfirm_picking(self):
|
||
for picking in self.filtered(lambda picking: picking.immediate_transfer and picking.state not in ('done', 'cancel') and (picking.move_lines or picking.package_level_ids)):
|
||
picking.action_confirm()
|
||
|
||
def _get_overprocessed_stock_moves(self):
|
||
self.ensure_one()
|
||
return self.move_lines.filtered(
|
||
lambda move: move.product_uom_qty != 0 and float_compare(move.quantity_done, move.product_uom_qty,
|
||
precision_rounding=move.product_uom.rounding) == 1
|
||
)
|
||
|
||
def _create_backorder(self):
|
||
|
||
""" This method is called when the user chose to create a backorder. It will create a new
|
||
picking, the backorder, and move the stock.moves that are not `done` or `cancel` into it.
|
||
"""
|
||
backorders = self.env['stock.picking']
|
||
for picking in self:
|
||
moves_to_backorder = picking.move_lines.filtered(lambda x: x.state not in ('done', 'cancel'))
|
||
if moves_to_backorder:
|
||
backorder_picking = picking.copy({
|
||
'name': '/',
|
||
'move_lines': [],
|
||
'move_line_ids': [],
|
||
'backorder_id': picking.id
|
||
})
|
||
picking.message_post(
|
||
body=_('The backorder <a href=# data-oe-model=stock.picking data-oe-id=%d>%s</a> has been created.') % (
|
||
backorder_picking.id, backorder_picking.name))
|
||
moves_to_backorder.write({'picking_id': backorder_picking.id})
|
||
moves_to_backorder.mapped('package_level_id').write({'picking_id':backorder_picking.id})
|
||
moves_to_backorder.mapped('move_line_ids').write({'picking_id': backorder_picking.id})
|
||
backorder_picking.action_assign()
|
||
backorders |= backorder_picking
|
||
return backorders
|
||
|
||
def _log_activity_get_documents(self, orig_obj_changes, stream_field, stream, sorted_method=False, groupby_method=False):
|
||
""" Generic method to log activity. To use with
|
||
_log_activity method. It either log on uppermost
|
||
ongoing documents or following documents. This method
|
||
find all the documents and responsible for which a note
|
||
has to be log. It also generate a rendering_context in
|
||
order to render a specific note by documents containing
|
||
only the information relative to the document it. For example
|
||
we don't want to notify a picking on move that it doesn't
|
||
contain.
|
||
|
||
:param orig_obj_changes dict: contain a record as key and the
|
||
change on this record as value.
|
||
eg: {'move_id': (new product_uom_qty, old product_uom_qty)}
|
||
:param stream_field string: It has to be a field of the
|
||
records that are register in the key of 'orig_obj_changes'
|
||
eg: 'move_dest_ids' if we use move as record (previous example)
|
||
- 'UP' if we want to log on the upper most ongoing
|
||
documents.
|
||
- 'DOWN' if we want to log on following documents.
|
||
:param sorted_method method, groupby_method: Only need when
|
||
stream is 'DOWN', it should sort/group by tuple(object on
|
||
which the activity is log, the responsible for this object)
|
||
"""
|
||
move_to_orig_object_rel = {co: ooc for ooc in orig_obj_changes.keys() for co in ooc[stream_field]}
|
||
origin_objects = self.env[list(orig_obj_changes.keys())[0]._name].concat(*list(orig_obj_changes.keys()))
|
||
# The purpose here is to group each destination object by
|
||
# (document to log, responsible) no matter the stream direction.
|
||
# example:
|
||
# {'(delivery_picking_1, admin)': stock.move(1, 2)
|
||
# '(delivery_picking_2, admin)': stock.move(3)}
|
||
visited_documents = {}
|
||
if stream == 'DOWN':
|
||
if sorted_method and groupby_method:
|
||
grouped_moves = groupby(sorted(origin_objects.mapped(stream_field), key=sorted_method), key=groupby_method)
|
||
else:
|
||
raise UserError(_('You have to define a groupby and sorted method and pass them as arguments.'))
|
||
elif stream == 'UP':
|
||
# When using upstream document it is required to define
|
||
# _get_upstream_documents_and_responsibles on
|
||
# destination objects in order to ascend documents.
|
||
grouped_moves = {}
|
||
for visited_move in origin_objects.mapped(stream_field):
|
||
for document, responsible, visited in visited_move._get_upstream_documents_and_responsibles(self.env[visited_move._name]):
|
||
if grouped_moves.get((document, responsible)):
|
||
grouped_moves[(document, responsible)] |= visited_move
|
||
visited_documents[(document, responsible)] |= visited
|
||
else:
|
||
grouped_moves[(document, responsible)] = visited_move
|
||
visited_documents[(document, responsible)] = visited
|
||
grouped_moves = grouped_moves.items()
|
||
else:
|
||
raise UserError(_('Unknown stream.'))
|
||
|
||
documents = {}
|
||
for (parent, responsible), moves in grouped_moves:
|
||
if not parent:
|
||
continue
|
||
moves = list(moves)
|
||
moves = self.env[moves[0]._name].concat(*moves)
|
||
# Get the note
|
||
rendering_context = {move: (orig_object, orig_obj_changes[orig_object]) for move in moves for orig_object in move_to_orig_object_rel[move]}
|
||
if visited_documents:
|
||
documents[(parent, responsible)] = rendering_context, visited_documents.values()
|
||
else:
|
||
documents[(parent, responsible)] = rendering_context
|
||
return documents
|
||
|
||
def _log_activity(self, render_method, documents):
|
||
""" Log a note for each documents, responsible pair in
|
||
documents passed as argument. The render_method is then
|
||
call in order to use a template and render it with a
|
||
rendering_context.
|
||
|
||
:param documents dict: A tuple (document, responsible) as key.
|
||
An activity will be log by key. A rendering_context as value.
|
||
If used with _log_activity_get_documents. In 'DOWN' stream
|
||
cases the rendering_context will be a dict with format:
|
||
{'stream_object': ('orig_object', new_qty, old_qty)}
|
||
'UP' stream will add all the documents browsed in order to
|
||
get the final/upstream document present in the key.
|
||
:param render_method method: a static function that will generate
|
||
the html note to log on the activity. The render_method should
|
||
use the args:
|
||
- rendering_context dict: value of the documents argument
|
||
the render_method should return a string with an html format
|
||
:param stream string:
|
||
"""
|
||
for (parent, responsible), rendering_context in documents.items():
|
||
note = render_method(rendering_context)
|
||
parent.activity_schedule(
|
||
'mail.mail_activity_data_warning',
|
||
date.today(),
|
||
note=note,
|
||
user_id=responsible.id or SUPERUSER_ID
|
||
)
|
||
|
||
def _log_less_quantities_than_expected(self, moves):
|
||
""" Log an activity on picking that follow moves. The note
|
||
contains the moves changes and all the impacted picking.
|
||
|
||
:param dict moves: a dict with a move as key and tuple with
|
||
new and old quantity as value. eg: {move_1 : (4, 5)}
|
||
"""
|
||
def _keys_in_sorted(move):
|
||
""" sort by picking and the responsible for the product the
|
||
move.
|
||
"""
|
||
return (move.picking_id.id, move.product_id.responsible_id.id)
|
||
|
||
def _keys_in_groupby(move):
|
||
""" group by picking and the responsible for the product the
|
||
move.
|
||
"""
|
||
return (move.picking_id, move.product_id.responsible_id)
|
||
|
||
def _render_note_exception_quantity(rendering_context):
|
||
""" :param rendering_context:
|
||
{'move_dest': (move_orig, (new_qty, old_qty))}
|
||
"""
|
||
origin_moves = self.env['stock.move'].browse([move.id for move_orig in rendering_context.values() for move in move_orig[0]])
|
||
origin_picking = origin_moves.mapped('picking_id')
|
||
move_dest_ids = self.env['stock.move'].concat(*rendering_context.keys())
|
||
impacted_pickings = origin_picking._get_impacted_pickings(move_dest_ids) - move_dest_ids.mapped('picking_id')
|
||
values = {
|
||
'origin_picking': origin_picking,
|
||
'moves_information': rendering_context.values(),
|
||
'impacted_pickings': impacted_pickings,
|
||
}
|
||
return self.env.ref('stock.exception_on_picking').render(values=values)
|
||
|
||
documents = self._log_activity_get_documents(moves, 'move_dest_ids', 'DOWN', _keys_in_sorted, _keys_in_groupby)
|
||
documents = self._less_quantities_than_expected_add_documents(moves, documents)
|
||
self._log_activity(_render_note_exception_quantity, documents)
|
||
|
||
def _less_quantities_than_expected_add_documents(self, moves, documents):
|
||
return documents
|
||
|
||
def _get_impacted_pickings(self, moves):
|
||
""" This function is used in _log_less_quantities_than_expected
|
||
the purpose is to notify a user with all the pickings that are
|
||
impacted by an action on a chained move.
|
||
param: 'moves' contain moves that belong to a common picking.
|
||
return: all the pickings that contain a destination moves
|
||
(direct and indirect) from the moves given as arguments.
|
||
"""
|
||
|
||
def _explore(impacted_pickings, explored_moves, moves_to_explore):
|
||
for move in moves_to_explore:
|
||
if move not in explored_moves:
|
||
impacted_pickings |= move.picking_id
|
||
explored_moves |= move
|
||
moves_to_explore |= move.move_dest_ids
|
||
moves_to_explore = moves_to_explore - explored_moves
|
||
if moves_to_explore:
|
||
return _explore(impacted_pickings, explored_moves, moves_to_explore)
|
||
else:
|
||
return impacted_pickings
|
||
|
||
return _explore(self.env['stock.picking'], self.env['stock.move'], moves)
|
||
|
||
def _pre_put_in_pack_hook(self, move_line_ids):
|
||
return self._check_destinations(move_line_ids)
|
||
|
||
def _check_destinations(self, move_line_ids):
|
||
if len(move_line_ids.mapped('location_dest_id')) > 1:
|
||
view_id = self.env.ref('stock.stock_package_destination_form_view').id
|
||
wiz = self.env['stock.package.destination'].create({
|
||
'picking_id': self.id,
|
||
'location_dest_id': move_line_ids[0].location_dest_id.id,
|
||
})
|
||
return {
|
||
'name': _('Choose destination location'),
|
||
'view_mode': 'form',
|
||
'res_model': 'stock.package.destination',
|
||
'view_id': view_id,
|
||
'views': [(view_id, 'form')],
|
||
'type': 'ir.actions.act_window',
|
||
'res_id': wiz.id,
|
||
'target': 'new'
|
||
}
|
||
else:
|
||
return {}
|
||
|
||
def _put_in_pack(self, move_line_ids):
|
||
package = False
|
||
for pick in self:
|
||
move_lines_to_pack = self.env['stock.move.line']
|
||
package = self.env['stock.quant.package'].create({})
|
||
for ml in move_line_ids:
|
||
if float_compare(ml.qty_done, ml.product_uom_qty,
|
||
precision_rounding=ml.product_uom_id.rounding) >= 0:
|
||
move_lines_to_pack |= ml
|
||
else:
|
||
quantity_left_todo = float_round(
|
||
ml.product_uom_qty - ml.qty_done,
|
||
precision_rounding=ml.product_uom_id.rounding,
|
||
rounding_method='UP')
|
||
done_to_keep = ml.qty_done
|
||
new_move_line = ml.copy(
|
||
default={'product_uom_qty': 0, 'qty_done': ml.qty_done})
|
||
ml.write({'product_uom_qty': quantity_left_todo, 'qty_done': 0.0})
|
||
new_move_line.write({'product_uom_qty': done_to_keep})
|
||
move_lines_to_pack |= new_move_line
|
||
package_level = self.env['stock.package_level'].create({
|
||
'package_id': package.id,
|
||
'picking_id': pick.id,
|
||
'location_id': False,
|
||
'location_dest_id': move_line_ids.mapped('location_dest_id').id,
|
||
'move_line_ids': [(6, 0, move_lines_to_pack.ids)]
|
||
})
|
||
move_lines_to_pack.write({
|
||
'result_package_id': package.id,
|
||
})
|
||
return package
|
||
|
||
def put_in_pack(self):
|
||
self.ensure_one()
|
||
if self.state not in ('done', 'cancel'):
|
||
move_line_ids = self.move_line_ids.filtered(lambda ml:
|
||
float_compare(ml.qty_done, 0.0, precision_rounding=ml.product_uom_id.rounding) > 0
|
||
and not ml.result_package_id
|
||
)
|
||
if move_line_ids:
|
||
res = self._pre_put_in_pack_hook(move_line_ids)
|
||
if not res:
|
||
res = self._put_in_pack(move_line_ids)
|
||
return res
|
||
else:
|
||
raise UserError(_('You must first set the quantity you will put in the pack.'))
|
||
|
||
def button_scrap(self):
|
||
self.ensure_one()
|
||
view = self.env.ref('stock.stock_scrap_form_view2')
|
||
products = self.env['product.product']
|
||
for move in self.move_lines:
|
||
if move.state not in ('draft', 'cancel') and move.product_id.type in ('product', 'consu'):
|
||
products |= move.product_id
|
||
return {
|
||
'name': _('Scrap'),
|
||
'view_mode': 'form',
|
||
'res_model': 'stock.scrap',
|
||
'view_id': view.id,
|
||
'views': [(view.id, 'form')],
|
||
'type': 'ir.actions.act_window',
|
||
'context': {'default_picking_id': self.id, 'product_ids': products.ids, 'default_company_id': self.company_id.id},
|
||
'target': 'new',
|
||
}
|
||
|
||
def action_see_move_scrap(self):
|
||
self.ensure_one()
|
||
action = self.env.ref('stock.action_stock_scrap').read()[0]
|
||
scraps = self.env['stock.scrap'].search([('picking_id', '=', self.id)])
|
||
action['domain'] = [('id', 'in', scraps.ids)]
|
||
action['context'] = dict(self._context, create=False)
|
||
return action
|
||
|
||
def action_see_packages(self):
|
||
self.ensure_one()
|
||
action = self.env.ref('stock.action_package_view').read()[0]
|
||
packages = self.move_line_ids.mapped('result_package_id')
|
||
action['domain'] = [('id', 'in', packages.ids)]
|
||
action['context'] = {'picking_id': self.id}
|
||
return action
|
||
|
||
def action_picking_move_tree(self):
|
||
action = self.env.ref('stock.stock_move_action').read()[0]
|
||
action['views'] = [
|
||
(self.env.ref('stock.view_picking_move_tree').id, 'tree'),
|
||
]
|
||
action['context'] = self.env.context
|
||
action['domain'] = [('picking_id', 'in', self.ids)]
|
||
return action
|