-
Notifications
You must be signed in to change notification settings - Fork 54
/
stock_batch_picking.py
172 lines (155 loc) · 7.19 KB
/
stock_batch_picking.py
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
##############################################################################
# For copyright and license notices, see __manifest__.py file in module root
# directory
##############################################################################
from odoo import models, fields, api, _
from odoo.exceptions import UserError
class StockPickingBatch(models.Model):
_inherit = 'stock.picking.batch'
picking_type_code = fields.Selection(store=True)
partner_id = fields.Many2one(
'res.partner',
# por ahora lo hacemos requerido porque si no tenemos que hacer algun
# maneje en la vista para que si esta seteado pase dominio
# y si no esta seteado no
# required=True,
help='If you choose a partner then only pickings of this partner will'
'be sellectable',
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]}
)
voucher_number = fields.Char(
states={'done': [('readonly', True)], 'cancel': [('readonly', True)]},
)
voucher_required = fields.Boolean(
# related='picking_type_id.voucher_required',
compute='_compute_picking_type_data',
)
restrict_number_package = fields.Boolean(
compute='_compute_picking_type_data',
)
number_of_packages = fields.Integer(
copy=False,
)
picking_type_ids = fields.Many2many(
'stock.picking.type',
# related='picking_type_id.voucher_required',
compute='_compute_picking_type_data',
)
vouchers = fields.Char(
related='picking_ids.vouchers',
)
picking_count = fields.Integer(
string="# Transferencias", compute="_compute_picking_count",
)
def _compute_picking_count(self):
"""Calculate number of pickings."""
groups = self.env["stock.picking"].read_group(
domain=[("batch_id", "in", self.ids)],
fields=["batch_id"],
groupby=["batch_id"],
)
counts = {g["batch_id"][0]: g["batch_id_count"] for g in groups}
for batch in self:
batch.picking_count = counts.get(batch.id, 0)
@api.depends('picking_ids')
def _compute_picking_type_data(self):
for rec in self:
types = rec.picking_ids.mapped('picking_type_id')
rec.picking_type_ids = types
rec.voucher_required = any(x.voucher_required for x in types)
rec.restrict_number_package = False
# este viene exigido desde la cia pero seguramente lo movamos a
# exigir desde picking type
# solo es requerido para outgoings
if rec.picking_type_code == 'outgoing':
rec.restrict_number_package = any(
x.picking_type_id.restrict_number_package
for x in rec.picking_ids)
@api.onchange('picking_type_code', 'partner_id')
def changes_set_pickings(self):
# if we change type or partner reset pickings
self.picking_ids = False
@api.onchange('voucher_number', 'picking_ids')
def format_voucher_number(self):
for rec in self:
if not rec.voucher_number:
continue
voucher_number = self.env['stock.picking.voucher']._format_document_number(rec.voucher_number)
if voucher_number and voucher_number != rec.voucher_number:
rec.voucher_number = voucher_number
def write(self, vals):
if 'voucher_number' in vals and vals.get('voucher_number'):
voucher_number = self.env['stock.picking.voucher']._format_document_number(vals.get('voucher_number'))
if voucher_number and voucher_number != vals.get('voucher_number'):
vals['voucher_number'] = voucher_number
return super().write(vals)
def add_picking_operation(self):
self.ensure_one()
view_id = self.env.ref('stock_ux.view_move_line_tree').id
search_view_id = self.env.ref(
'stock_ux.stock_move_line_view_search').id
return {
"type": "ir.actions.act_window",
"res_model": "stock.move.line",
"search_view_id": search_view_id,
"views": [[view_id, "tree"], [False, "form"]],
"domain": [["id", "in", self.move_line_ids.ids]],
"context": {"create": False, "from_batch": True},
}
def action_transfer(self):
# agregamos los numeros de remito
for rec in self:
# al agregar la restriccion de que al menos una tenga que tener
# cantidad entonces nunca se manda el force_qty al picking
if all(operation.qty_done == 0
for operation in rec.move_line_ids):
raise UserError(_(
'Debe definir Cantidad Realizada en al menos una '
'operación.'))
if rec.restrict_number_package and not rec.number_of_packages > 0:
raise UserError(_('The number of packages can not be 0'))
if rec.number_of_packages:
rec.picking_ids.write({
'number_of_packages': rec.number_of_packages})
if rec.picking_type_code == 'incoming' and rec.voucher_number:
for picking in rec.active_picking_ids:
# agregamos esto para que no se asigne a los pickings
# que no se van a recibir ya que todavia no se limpiaron
# y ademas, por lo de arriba, no se fuerza la cantidad
# si son todos cero, se terminan sacando
if all(operation.qty_done == 0
for operation in picking.move_line_ids):
continue
rec.env['stock.picking.voucher'].create({
'picking_id': picking.id,
'name': rec.voucher_number,
})
elif rec.picking_type_code != 'incoming':
# llamamos al chequeo de stock voucher ya que este metodo
# termina usando do_transfer pero el chequeo se llama solo
# con do_new_transfer
rec.active_picking_ids.do_stock_voucher_transfer_check()
res = super(StockPickingBatch, self.with_context(
do_not_assign_numbers=True)).action_transfer()
# nosotros preferimos que no se haga en muchos pasos y una vez
# confirmado se borre lo no hecho y se marque como realizado
# lo hago para distinto de incomring porque venia andando bien para
# Incoming, pero no debería hacer falta este chequeo
# self.remove_undone_pickings()
return res
def do_unreserve_picking(self):
batches = self.get_not_empties()
if not batches.verify_state("in_progress"):
self._check_company()
pickings_todo = self.mapped('picking_ids')
self.write({'state': 'draft'})
pickings_todo.do_unreserve()
def action_view_stock_picking(self):
"""This function returns an action that display existing pickings of
given batch picking.
"""
self.ensure_one()
pickings = self.mapped("picking_ids")
action = self.env.ref("stock.action_picking_tree_all").read([])[0]
action["domain"] = [("id", "in", pickings.ids)]
return action