Yannick Tivisse
473c74f636
Purpose
=======
The method _name_search and _search add support to search as another user.
All the overrides of name_search and search redefine the behavior of the search.
This bring inconsistencies as the result of a call to _name_search and name_search
could differ on certain modules, which is not acceptable.
Specification
=============
Example:
~~~~~~~~
If the name_search method is overridden to search also on the driver name,
then calling name_search with a label 'JF' will return all the cars with a name containing
'JF' or all the cars with a driver name containing 'JF'. Let's say that we have a ir.rule
preventing a user to read the cars of another company. Then the call to name search only returns
the cars satisfying the previous condition AND belonging to his company.
Now, we want to overpass this constraint. We call _name_search with the attribute name_get_uid=1.
Then the call to _name_search returns all the cars from all the companies with a name like 'JF',
but nothing is done about the driver_name.
Example of wrong search redefinition on a model
-----------------------------------------------
@api.model
def name_search(self, name, args=None, operator='ilike', limit=100):
domain = args or []
domain = expression.AND([domain, [('name', 'ilike', name)]])
partners = self.env['res.partner'].search([('name', operator, name)])
if partners and name:
domain = expression.OR([domain, ['|', ('driver_id', 'in', partners.ids), ('driver_id', '=', False)]])
rec = self.search(domain, limit=limit)
return rec.name_get()
Example of correct search redefinition on a model
-------------------------------------------------
@api.model
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
domain = args or []
domain = expression.AND([domain, [('name', operator, name)]])
partner_ids = self.env['res.partner']._search([('name', operator, name)], access_rights_uid=name_get_uid)
if partner_ids:
domain = expression.OR([domain, ['|', ('driver_id', 'in', partner_ids), ('driver_id', '=', False)]])
rec = self._search(domain, limit=limit, access_rights_uid=name_get_uid)
return self.browse(rec).name_get()
The same logic should be applied on the overrides of the search method.
249 lines
15 KiB
Python
249 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from datetime import datetime
|
|
from dateutil import relativedelta
|
|
from odoo.exceptions import UserError
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT
|
|
|
|
|
|
class Location(models.Model):
|
|
_name = "stock.location"
|
|
_description = "Inventory Locations"
|
|
_parent_name = "location_id"
|
|
_parent_store = True
|
|
_order = 'complete_name'
|
|
_rec_name = 'complete_name'
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
res = super(Location, self).default_get(fields)
|
|
if 'barcode' in fields and 'barcode' not in res and res.get('complete_name'):
|
|
res['barcode'] = res['complete_name']
|
|
return res
|
|
|
|
name = fields.Char('Location Name', required=True, translate=True)
|
|
complete_name = fields.Char("Full Location Name", compute='_compute_complete_name', store=True)
|
|
active = fields.Boolean('Active', default=True, help="By unchecking the active field, you may hide a location without deleting it.")
|
|
usage = fields.Selection([
|
|
('supplier', 'Vendor Location'),
|
|
('view', 'View'),
|
|
('internal', 'Internal Location'),
|
|
('customer', 'Customer Location'),
|
|
('inventory', 'Inventory Loss'),
|
|
('procurement', 'Procurement'),
|
|
('production', 'Production'),
|
|
('transit', 'Transit Location')], string='Location Type',
|
|
default='internal', index=True, required=True,
|
|
help="* Vendor Location: Virtual location representing the source location for products coming from your vendors"
|
|
"\n* View: Virtual location used to create a hierarchical structures for your warehouse, aggregating its child locations ; can't directly contain products"
|
|
"\n* Internal Location: Physical locations inside your own warehouses,"
|
|
"\n* Customer Location: Virtual location representing the destination location for products sent to your customers"
|
|
"\n* Inventory Loss: Virtual location serving as counterpart for inventory operations used to correct stock levels (Physical inventories)"
|
|
"\n* Procurement: Virtual location serving as temporary counterpart for procurement operations when the source (vendor or production) is not known yet. This location should be empty when the procurement scheduler has finished running."
|
|
"\n* Production: Virtual counterpart location for production operations: this location consumes the raw material and produces finished products"
|
|
"\n* Transit Location: Counterpart location that should be used in inter-company or inter-warehouses operations")
|
|
location_id = fields.Many2one(
|
|
'stock.location', 'Parent Location', index=True, ondelete='cascade',
|
|
help="The parent location that includes this location. Example : The 'Dispatch Zone' is the 'Gate 1' parent location.")
|
|
child_ids = fields.One2many('stock.location', 'location_id', 'Contains')
|
|
partner_id = fields.Many2one('res.partner', 'Owner', help="Owner of the location if not internal")
|
|
comment = fields.Text('Additional Information')
|
|
posx = fields.Integer('Corridor (X)', default=0, help="Optional localization details, for information purpose only")
|
|
posy = fields.Integer('Shelves (Y)', default=0, help="Optional localization details, for information purpose only")
|
|
posz = fields.Integer('Height (Z)', default=0, help="Optional localization details, for information purpose only")
|
|
parent_path = fields.Char(index=True)
|
|
company_id = fields.Many2one(
|
|
'res.company', 'Company',
|
|
default=lambda self: self.env['res.company']._company_default_get('stock.location'), index=True,
|
|
help='Let this field empty if this location is shared between companies')
|
|
scrap_location = fields.Boolean('Is a Scrap Location?', default=False, help='Check this box to allow using this location to put scrapped/damaged goods.')
|
|
return_location = fields.Boolean('Is a Return Location?', help='Check this box to allow using this location as a return location.')
|
|
removal_strategy_id = fields.Many2one('product.removal', 'Removal Strategy', help="Defines the default method used for suggesting the exact location (shelf) where to take the products from, which lot etc. for this location. This method can be enforced at the product category level, and a fallback is made on the parent locations if none is set here.")
|
|
putaway_strategy_id = fields.Many2one('product.putaway', 'Put Away Strategy', help="Allows to suggest the exact location (shelf) where to store the product.")
|
|
barcode = fields.Char('Barcode', copy=False, oldname='loc_barcode')
|
|
quant_ids = fields.One2many('stock.quant', 'location_id')
|
|
|
|
_sql_constraints = [('barcode_company_uniq', 'unique (barcode,company_id)', 'The barcode for a location must be unique per company !')]
|
|
|
|
@api.one
|
|
@api.depends('name', 'location_id.complete_name')
|
|
def _compute_complete_name(self):
|
|
""" Forms complete name of location from parent location to child location. """
|
|
if self.location_id.complete_name:
|
|
self.complete_name = '%s/%s' % (self.location_id.complete_name, self.name)
|
|
else:
|
|
self.complete_name = self.name
|
|
|
|
def write(self, values):
|
|
if 'usage' in values and values['usage'] == 'view':
|
|
if self.mapped('quant_ids'):
|
|
raise UserError(_("This location's usage cannot be changed to view as it contains products."))
|
|
return super(Location, self).write(values)
|
|
|
|
def name_get(self):
|
|
ret_list = []
|
|
for location in self:
|
|
orig_location = location
|
|
name = location.name
|
|
while location.location_id and location.usage != 'view':
|
|
location = location.location_id
|
|
if not name:
|
|
raise UserError(_('You have to set a name for this location.'))
|
|
name = location.name + "/" + name
|
|
ret_list.append((orig_location.id, name))
|
|
return ret_list
|
|
|
|
@api.model
|
|
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
|
|
""" search full name and barcode """
|
|
if args is None:
|
|
args = []
|
|
location_ids = self._search(['|', ('barcode', operator, name), ('complete_name', operator, name)] + args, limit=limit, access_rights_uid=name_get_uid)
|
|
return self.browse(location_ids).name_get()
|
|
|
|
def get_putaway_strategy(self, product):
|
|
''' Returns the location where the product has to be put, if any compliant putaway strategy is found. Otherwise returns None.'''
|
|
current_location = self
|
|
putaway_location = self.env['stock.location']
|
|
while current_location and not putaway_location:
|
|
if current_location.putaway_strategy_id:
|
|
putaway_location = current_location.putaway_strategy_id.putaway_apply(product)
|
|
current_location = current_location.location_id
|
|
return putaway_location
|
|
|
|
@api.returns('stock.warehouse', lambda value: value.id)
|
|
def get_warehouse(self):
|
|
""" Returns warehouse id of warehouse that contains location """
|
|
domain = [('view_location_id', 'parent_of', self.ids)]
|
|
return self.env['stock.warehouse'].search(domain, limit=1)
|
|
|
|
def should_bypass_reservation(self):
|
|
self.ensure_one()
|
|
return self.usage in ('supplier', 'customer', 'inventory', 'production') or self.scrap_location
|
|
|
|
|
|
class Route(models.Model):
|
|
_name = 'stock.location.route'
|
|
_description = "Inventory Routes"
|
|
_order = 'sequence'
|
|
|
|
name = fields.Char('Route Name', required=True, translate=True)
|
|
active = fields.Boolean('Active', default=True, help="If the active field is set to False, it will allow you to hide the route without removing it.")
|
|
sequence = fields.Integer('Sequence', default=0)
|
|
pull_ids = fields.One2many('procurement.rule', 'route_id', 'Procurement Rules', copy=True,
|
|
help="The demand represented by a procurement from e.g. a sale order, a reordering rule, another move, needs to be solved by applying a procurement rule. Depending on the action on the procurement rule,"\
|
|
"this triggers a purchase order, manufacturing order or another move. This way we create chains in the reverse order from the endpoint with the original demand to the starting point. "\
|
|
"That way, it is always known where we need to go and that is why they are preferred over push rules.")
|
|
push_ids = fields.One2many('stock.location.path', 'route_id', 'Push Rules', copy=True,
|
|
help="When a move is foreseen to a location, the push rule will automatically create a move to a next location after. This is mainly only needed when creating manual operations e.g. 2/3 step manual purchase order or 2/3 step finished product manual manufacturing order. In other cases, it is important to use pull rules where you know where you are going based on a demand.")
|
|
product_selectable = fields.Boolean('Applicable on Product', default=True, help="When checked, the route will be selectable in the Inventory tab of the Product form. It will take priority over the Warehouse route. ")
|
|
product_categ_selectable = fields.Boolean('Applicable on Product Category', help="When checked, the route will be selectable on the Product Category. It will take priority over the Warehouse route. ")
|
|
warehouse_selectable = fields.Boolean('Applicable on Warehouse', help="When a warehouse is selected for this route, this route should be seen as the default route when products pass through this warehouse. This behaviour can be overridden by the routes on the Product/Product Categories or by the Preferred Routes on the Procurement")
|
|
supplied_wh_id = fields.Many2one('stock.warehouse', 'Supplied Warehouse')
|
|
supplier_wh_id = fields.Many2one('stock.warehouse', 'Supplying Warehouse')
|
|
company_id = fields.Many2one(
|
|
'res.company', 'Company',
|
|
default=lambda self: self.env['res.company']._company_default_get('stock.location.route'), index=True,
|
|
help='Leave this field empty if this route is shared between all companies')
|
|
product_ids = fields.Many2many('product.template', 'stock_route_product', 'route_id', 'product_id', 'Products')
|
|
categ_ids = fields.Many2many('product.category', 'stock_location_route_categ', 'route_id', 'categ_id', 'Product Categories')
|
|
warehouse_ids = fields.Many2many('stock.warehouse', 'stock_route_warehouse', 'route_id', 'warehouse_id', 'Warehouses')
|
|
|
|
def write(self, values):
|
|
'''when a route is deactivated, deactivate also its pull and push rules'''
|
|
res = super(Route, self).write(values)
|
|
if 'active' in values:
|
|
self.mapped('push_ids').filtered(lambda path: path.active != values['active']).write({'active': values['active']})
|
|
self.mapped('pull_ids').filtered(lambda rule: rule.active != values['active']).write({'active': values['active']})
|
|
return res
|
|
|
|
def view_product_ids(self):
|
|
return {
|
|
'name': _('Products'),
|
|
'view_type': 'form',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'product.template',
|
|
'type': 'ir.actions.act_window',
|
|
'domain': [('route_ids', 'in', self.ids)],
|
|
}
|
|
|
|
def view_categ_ids(self):
|
|
return {
|
|
'name': _('Product Categories'),
|
|
'view_type': 'form',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'product.category',
|
|
'type': 'ir.actions.act_window',
|
|
'domain': [('route_ids', 'in', self.ids)],
|
|
}
|
|
|
|
|
|
class PushedFlow(models.Model):
|
|
_name = "stock.location.path"
|
|
_description = "Pushed Flow"
|
|
_order = "sequence, name"
|
|
|
|
name = fields.Char('Operation Name', required=True)
|
|
company_id = fields.Many2one(
|
|
'res.company', 'Company',
|
|
default=lambda self: self.env['res.company']._company_default_get('stock.location.path'), index=True)
|
|
route_id = fields.Many2one('stock.location.route', 'Route', required=True, ondelete='cascade')
|
|
location_from_id = fields.Many2one(
|
|
'stock.location', 'Source Location', index=True, ondelete='cascade', required=True,
|
|
help="This rule can be applied when a move is confirmed that has this location as destination location")
|
|
location_dest_id = fields.Many2one(
|
|
'stock.location', 'Destination Location', index=True, ondelete='cascade', required=True,
|
|
help="The new location where the goods need to go")
|
|
delay = fields.Integer('Delay (days)', default=0, help="Number of days needed to transfer the goods")
|
|
picking_type_id = fields.Many2one(
|
|
'stock.picking.type', 'Operation Type', required=True,
|
|
help="This is the operation type that will be put on the stock moves")
|
|
auto = fields.Selection([
|
|
('manual', 'Manual Operation'),
|
|
('transparent', 'Automatic No Step Added')], string='Automatic Move',
|
|
default='manual', index=True, required=True,
|
|
help="The 'Manual Operation' value will create a stock move after the current one. "
|
|
"With 'Automatic No Step Added', the location is replaced in the original move.")
|
|
propagate = fields.Boolean('Propagate cancel and split', default=True, help='If checked, when the previous move is cancelled or split, the move generated by this move will too')
|
|
active = fields.Boolean('Active', default=True)
|
|
warehouse_id = fields.Many2one('stock.warehouse', 'Warehouse')
|
|
route_sequence = fields.Integer('Route Sequence', related='route_id.sequence', store=True)
|
|
sequence = fields.Integer('Sequence')
|
|
|
|
def _apply(self, move):
|
|
new_date = (datetime.strptime(move.date_expected, DEFAULT_SERVER_DATETIME_FORMAT) + relativedelta.relativedelta(days=self.delay)).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
|
|
if self.auto == 'transparent':
|
|
move.write({
|
|
'date': new_date,
|
|
'date_expected': new_date,
|
|
'location_dest_id': self.location_dest_id.id})
|
|
# avoid looping if a push rule is not well configured; otherwise call again push_apply to see if a next step is defined
|
|
if self.location_dest_id != move.location_dest_id:
|
|
# TDE FIXME: should probably be done in the move model IMO
|
|
move._push_apply()
|
|
else:
|
|
new_move_vals = self._prepare_move_copy_values(move, new_date)
|
|
new_move = move.copy(new_move_vals)
|
|
move.write({'move_dest_ids': [(4, new_move.id)]})
|
|
new_move._action_confirm()
|
|
|
|
def _prepare_move_copy_values(self, move_to_copy, new_date):
|
|
new_move_vals = {
|
|
'origin': move_to_copy.origin or move_to_copy.picking_id.name or "/",
|
|
'location_id': move_to_copy.location_dest_id.id,
|
|
'location_dest_id': self.location_dest_id.id,
|
|
'date': new_date,
|
|
'date_expected': new_date,
|
|
'company_id': self.company_id.id,
|
|
'picking_id': False,
|
|
'picking_type_id': self.picking_type_id.id,
|
|
'propagate': self.propagate,
|
|
'push_rule_id': self.id,
|
|
'warehouse_id': self.warehouse_id.id,
|
|
}
|
|
|
|
return new_move_vals
|