1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
|
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from collections import defaultdict
from odoo import _, Command, fields, models
from odoo.osv import expression
from odoo.tools.float_utils import float_is_zero
from odoo.tools.misc import OrderedSet
class StockMoveLine(models.Model):
_inherit = "stock.move.line"
batch_id = fields.Many2one(related='picking_id.batch_id', store=True)
def action_open_add_to_wave(self):
# This action can be called from the move line list view or from the 'Add to wave' wizard
if 'active_wave_id' in self.env.context:
wave = self.env['stock.picking.batch'].browse(self.env.context.get('active_wave_id'))
return self._add_to_wave(wave)
view = self.env.ref('stock_picking_batch.stock_add_to_wave_form')
return {
'name': _('Add to Wave'),
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_model': 'stock.add.to.wave',
'views': [(view.id, 'form')],
'view_id': view.id,
'target': 'new',
}
def _add_to_wave(self, wave=False, description=False):
""" Detach lines (and corresponding stock move from a picking to another). If wave is
passed, attach new picking into it. If not attach line to their original picking.
:param int wave: id of the wave picking on which to put the move lines. """
if not wave:
wave = self.env['stock.picking.batch'].create({
'is_wave': True,
'picking_type_id': self.picking_type_id and self.picking_type_id[0].id,
'user_id': self.env.context.get('active_owner_id'),
'description': description,
})
line_by_picking = defaultdict(lambda: self.env['stock.move.line'])
for line in self:
line_by_picking[line.picking_id] |= line
picking_to_wave_vals_list = []
for picking, lines in line_by_picking.items():
# Move the entire picking if all the line are taken
line_by_move = defaultdict(lambda: self.env['stock.move.line'])
qty_by_move = defaultdict(float)
for line in lines:
move = line.move_id
line_by_move[move] |= line
qty = line.product_uom_id._compute_quantity(line.quantity, line.product_id.uom_id, rounding_method='HALF-UP')
qty_by_move[line.move_id] += qty
# If all moves are to be transferred to the wave, link the picking to the wave
if lines == picking.move_line_ids and lines.move_id == picking.move_ids:
add_all_moves = True
for move, qty in qty_by_move.items():
if float_is_zero(qty, precision_rounding=move.product_uom.rounding):
add_all_moves = False
break
if add_all_moves:
wave.picking_ids = [Command.link(picking.id)]
continue
# Split the picking in two part to extract only line that are taken on the wave
picking_to_wave_vals = picking.copy_data({
'move_ids': [],
'move_line_ids': [],
'batch_id': wave.id,
})[0]
for move, move_lines in line_by_move.items():
picking_to_wave_vals['move_line_ids'] += [Command.link(line.id) for line in lines]
# if all the line of a stock move are taken we change the picking on the stock move
if move_lines == move.move_line_ids:
picking_to_wave_vals['move_ids'] += [Command.link(move.id)]
continue
# Split the move
qty = qty_by_move[move]
new_move = move._split(qty)
new_move[0]['move_line_ids'] = [Command.set(move_lines.ids)]
picking_to_wave_vals['move_ids'] += [Command.create(new_move[0])]
picking_to_wave_vals_list.append(picking_to_wave_vals)
if picking_to_wave_vals_list:
self.env['stock.picking'].create(picking_to_wave_vals_list)
if wave.picking_type_id.batch_auto_confirm:
wave.action_confirm()
def _is_auto_waveable(self):
self.ensure_one()
if not self.picking_id \
or self.picking_id.state != 'assigned' \
or float_is_zero(self.quantity, precision_rounding=self.product_uom_id.rounding) \
or self.batch_id.is_wave \
or not self.picking_type_id._is_auto_wave_grouped() \
or (self.picking_type_id.wave_group_by_category and self.product_id.categ_id not in self.picking_type_id.wave_category_ids): # noqa: SIM103
return False
return True
def _auto_wave(self):
""" Try to find compatible waves to attach the move lines to, otherwise create new waves when possible/appropriate. """
wave_locs_by_picking_type = {}
for picking_type in self.picking_type_id:
if not picking_type.wave_group_by_location:
continue
if picking_type in wave_locs_by_picking_type:
continue
wave_locs_by_picking_type[picking_type] = set(picking_type.wave_location_ids.ids)
lines_nearest_parent_locations = defaultdict(lambda: self.env['stock.location'])
batchable_line_ids = OrderedSet()
for line in self:
if not line._is_auto_waveable():
continue
if not line.picking_type_id.wave_group_by_location:
batchable_line_ids.add(line.id)
continue
# We want to find the most descendant location in the wave locations list that is a parent of the line location.
# Since the wave locations are ordered by complete_name (from the most descendant to the most ancestor), we can iterate in reverse order.
wave_locs_set = wave_locs_by_picking_type[line.picking_type_id]
loc = line.location_id
while (loc):
if loc.id in wave_locs_set:
lines_nearest_parent_locations[line] = loc
batchable_line_ids.add(line.id)
break
loc = loc.location_id
batchable_lines = self.env['stock.move.line'].browse(batchable_line_ids)
remaining_line_ids = batchable_lines._auto_wave_lines_into_existing_waves(nearest_parent_locations=lines_nearest_parent_locations)
remaining_lines = self.env['stock.move.line'].browse(remaining_line_ids)
if remaining_lines:
remaining_lines._auto_wave_lines_into_new_waves(nearest_parent_locations=lines_nearest_parent_locations)
def _auto_wave_lines_into_existing_waves(self, nearest_parent_locations=False):
""" Try to add move lines to existing waves if possible, return move lines of which no appropriate waves were found to link to
:param nearest_parent_locations (defaultdict): the key is the move line and the value is the nearest parent location in the wave locations list"""
remaining_lines = OrderedSet()
for (picking_type, lines) in self.grouped(lambda l: l.picking_type_id).items():
if lines:
domain = [
('picking_type_id', '=', picking_type.id),
('company_id', 'in', lines.mapped('company_id').ids),
('is_wave', '=', True)
]
if picking_type.batch_auto_confirm:
domain = expression.AND([domain, [('state', 'not in', ['done', 'cancel'])]])
else:
domain = expression.AND([domain, [('state', '=', 'draft')]])
if picking_type.batch_group_by_partner:
domain = expression.AND([domain, [('picking_ids.partner_id', 'in', lines.move_id.partner_id.ids)]])
if picking_type.batch_group_by_destination:
domain = expression.AND([domain, [('picking_ids.partner_id.country_id', 'in', lines.move_id.partner_id.country_id.ids)]])
if picking_type.batch_group_by_src_loc:
domain = expression.AND([domain, [('picking_ids.location_id', 'in', lines.location_id.ids)]])
if picking_type.batch_group_by_dest_loc:
domain = expression.AND([domain, [('picking_ids.location_dest_id', 'in', lines.location_dest_id.ids)]])
potential_waves = self.env['stock.picking.batch'].search(domain)
wave_to_new_lines = defaultdict(set)
# These dictionaries are used to enforce batch max lines/transfers/weight limits
# Each time a line is matched to a wave, we update the corresponding values
wave_to_new_moves = defaultdict(set)
waves_to_new_pickings = defaultdict(set)
waves_new_extra_weight = defaultdict(float)
waves_nearest_parent_locations = defaultdict(int)
if picking_type.wave_group_by_location:
valid_wave_ids = set()
# We want to find the most descendant location in the wave locations list that is a parent of all the lines in each wave.
# We also want to exclude waves that have lines that are not in these locations.
for wave in potential_waves:
for wave_location in reversed(picking_type.wave_location_ids):
if all(loc._child_of(wave_location) for loc in wave.move_line_ids.location_id):
waves_nearest_parent_locations[wave] = wave_location.id
valid_wave_ids.add(wave.id)
break
potential_waves = self.env['stock.picking.batch'].browse(valid_wave_ids)
for line in lines:
wave_found = False
for wave in potential_waves:
if line.company_id != wave.company_id \
or (picking_type.batch_group_by_partner and line.move_id.partner_id != wave.picking_ids.partner_id) \
or (picking_type.batch_group_by_destination and line.move_id.partner_id.country_id != wave.picking_ids.partner_id.country_id) \
or (picking_type.batch_group_by_src_loc and line.location_id != wave.picking_ids.location_id) \
or (picking_type.batch_group_by_dest_loc and line.location_dest_id != wave.picking_ids.location_dest_id) \
or (picking_type.wave_group_by_product and line.product_id != wave.move_line_ids.product_id) \
or (picking_type.wave_group_by_category and line.product_id.categ_id != wave.move_line_ids.product_id.categ_id) \
or (picking_type.wave_group_by_location and waves_nearest_parent_locations[wave] != nearest_parent_locations[line].id):
continue
wave_new_move_ids = wave_to_new_moves[wave]
wave_new_picking_ids = waves_to_new_pickings[wave]
wave_move_ids = set(wave.move_line_ids.mapped('move_id.id'))
wave_picking_ids = set(wave.move_line_ids.mapped('picking_id.id'))
# `is_line_auto_mergeable` is a method that checks if the line can be added to the wave without exceeding the limits
# It takes as arguments the number of new moves that will be added to the wave, the number of new pickings that will be added to the wave
# and the extra weight that will be added to the wave. So we need to check that the move/picking of the line is not already in the wave
# so that we don't count them as new moves/pickings.
if not wave._is_line_auto_mergeable(
line.move_id.id not in wave_move_ids and line.move_id.id not in wave_new_move_ids and len(wave_new_move_ids) + 1,
line.picking_id.id not in wave_picking_ids and line.picking_id.id not in wave_new_picking_ids and len(wave_new_picking_ids) + 1,
waves_new_extra_weight[wave] + line.product_id.weight * line.quantity_product_uom
):
continue
if line.move_id.id not in wave_move_ids:
wave_to_new_moves[wave].add(line.move_id.id)
if line.picking_id.id not in wave_picking_ids:
waves_to_new_pickings[wave].add(line.picking_id.id)
waves_new_extra_weight[wave] += line.product_id.weight * line.quantity_product_uom
wave_to_new_lines[wave].add(line.id)
wave_found = True
break
if not wave_found:
remaining_lines.add(line.id)
for wave, line_ids in wave_to_new_lines.items():
lines = self.env['stock.move.line'].browse(line_ids)
lines._add_to_wave(wave)
return list(remaining_lines)
def _auto_wave_lines_into_new_waves(self, nearest_parent_locations=False):
""" Create new waves for the move lines that could not be added to existing waves. """
picking_types = self.picking_type_id
for picking_type in picking_types:
lines = self.filtered(lambda l: l.picking_type_id == picking_type)
domain = [
('id', 'in', lines.ids),
('company_id', 'in', self.company_id.ids),
('picking_id.state', '=', 'assigned'),
('picking_type_id', '=', picking_type.id),
'|',
('batch_id', '=', False),
('batch_id.is_wave', '=', False)
]
if picking_type.batch_group_by_partner:
domain = expression.AND([domain, [('move_id.partner_id', 'in', lines.move_id.partner_id.ids)]])
if picking_type.batch_group_by_destination:
domain = expression.AND([domain, [('move_id.partner_id.country_id', 'in', lines.move_id.partner_id.country_id.ids)]])
if picking_type.batch_group_by_src_loc:
domain = expression.AND([domain, [('location_id', 'in', lines.location_id.ids)]])
if picking_type.batch_group_by_dest_loc:
domain = expression.AND([domain, [('location_dest_id', 'in', lines.location_dest_id.ids)]])
if picking_type.wave_group_by_product:
domain = expression.AND([domain, [('product_id', 'in', lines.product_id.ids)]])
if picking_type.wave_group_by_category:
domain = expression.AND([domain, [('product_id.categ_id', 'in', lines.product_id.categ_id.ids)]])
if picking_type.wave_group_by_location:
domain = expression.AND([domain, [('location_id', 'child_of', picking_type.wave_location_ids.ids)]])
potential_lines = self.env['stock.move.line'].search(domain)
lines_nearest_parent_locations = defaultdict(int)
if picking_type.wave_group_by_location:
for line in potential_lines:
for location in reversed(picking_type.wave_location_ids):
if line.location_id._child_of(location):
lines_nearest_parent_locations[line] = location.id
break
line_to_lines = defaultdict(set)
matched_lines = set()
remaining_line_ids = OrderedSet()
for line in lines:
lines_found = False
if line.id in matched_lines:
continue
for potential_line in potential_lines:
if line.id == potential_line.id \
or line.company_id != potential_line.company_id \
or (picking_type.batch_group_by_partner and line.move_id.partner_id != potential_line.move_id.partner_id) \
or (picking_type.batch_group_by_destination and line.move_id.partner_id.country_id != potential_line.move_id.partner_id.country_id) \
or (picking_type.batch_group_by_src_loc and line.location_id != potential_line.location_id) \
or (picking_type.batch_group_by_dest_loc and line.location_dest_id != potential_line.location_dest_id) \
or (picking_type.wave_group_by_product and line.product_id != potential_line.product_id) \
or (picking_type.wave_group_by_category and line.product_id.categ_id != potential_line.product_id.categ_id) \
or (picking_type.wave_group_by_location and lines_nearest_parent_locations[potential_line] != nearest_parent_locations[line].id):
continue
line_to_lines[line].add(potential_line.id)
matched_lines.add(potential_line.id)
lines_found = True
if not lines_found:
remaining_line_ids.add(line.id)
for line, potential_line_ids in line_to_lines.items():
if line.batch_id.is_wave:
continue
potential_lines = self.env['stock.move.line'].browse(potential_line_ids | {line.id})
# We want to make sure that batch/wave limits specified in the picking type are respected.
# We want also to reduce picking splits as much as possible. So we try to group as much as possible by sorting the lines by picking and move.
potential_lines = potential_lines.sorted(key=lambda l: (l.picking_id.id, l.move_id.id))
while potential_lines:
new_wave = self.env['stock.picking.batch'].create({
'is_wave': True,
'picking_type_id': picking_type.id,
'description': line._get_auto_wave_description(nearest_parent_locations[line]),
})
wave_move_ids = set()
wave_picking_ids = set()
wave_weight = 0
wave_line_ids = set()
for potential_line in potential_lines:
if potential_line.batch_id.is_wave:
continue
wave_move_ids.add(potential_line.move_id.id)
wave_picking_ids.add(potential_line.picking_id.id)
wave_weight += potential_line.product_id.weight * potential_line.quantity_product_uom
if new_wave._is_line_auto_mergeable(
len(wave_move_ids),
len(wave_picking_ids),
wave_weight
):
wave_line_ids.add(potential_line.id)
else:
break
wave_lines = self.env['stock.move.line'].browse(wave_line_ids)
wave_lines._add_to_wave(new_wave)
potential_lines -= wave_lines
remaining_lines = self.env['stock.move.line'].browse(remaining_line_ids)
remaining_waves = self.env['stock.picking.batch'].create([{
'is_wave': True,
'picking_type_id': picking_type.id,
'description': remaining_line._get_auto_wave_description(nearest_parent_locations[remaining_line]),
} for remaining_line in remaining_lines])
for (line, wave) in zip(remaining_lines, remaining_waves):
line._add_to_wave(wave)
def _get_auto_wave_description(self, nearest_parent_location=False):
self.ensure_one()
description = self.picking_id._get_auto_batch_description()
description_items = []
if description:
description_items.append(description)
if self.picking_type_id.wave_group_by_product:
description_items.append(self.product_id.display_name)
if self.picking_type_id.wave_group_by_category:
description_items.append(self.product_id.categ_id.complete_name)
if self.picking_type_id.wave_group_by_location:
description_items.append(nearest_parent_location.complete_name)
description = ', '.join(description_items)
return description
|
