addons/mrp_byproduct/mrp_byproduct.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 from openerp.osv import fields
  23 from openerp.osv import osv
  24 import openerp.addons.decimal_precision as dp
  25 from openerp.tools.translate import _
  26
  27 class mrp_subproduct(osv.osv):
  28     _name = 'mrp.subproduct'
  29     _description = 'Byproduct'
  30     _columns={
  31         'product_id': fields.many2one('product.product', 'Product', required=True),
  32         'product_qty': fields.float('Product Qty', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
  33         'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True),
  34         'subproduct_type': fields.selection([('fixed','Fixed'),('variable','Variable')], 'Quantity Type', required=True, help="Define how the quantity of byproducts will be set on the production orders using this BoM.\
  35   'Fixed' depicts a situation where the quantity of created byproduct is always equal to the quantity set on the BoM, regardless of how many are created in the production order.\
  36   By opposition, 'Variable' means that the quantity will be computed as\
  37     '(quantity of byproduct set on the BoM / quantity of manufactured product set on the BoM * quantity of manufactured product in the production order.)'"),
  38         'bom_id': fields.many2one('mrp.bom', 'BoM'),
  39     }
  40     _defaults={
  41         'subproduct_type': 'variable',
  42         'product_qty': lambda *a: 1.0,
  43     }
  44
  45     def onchange_product_id(self, cr, uid, ids, product_id, context=None):
  46         """ Changes UoM if product_id changes.
  47         @param product_id: Changed product_id
  48         @return: Dictionary of changed values
  49         """
  50         if product_id:
  51             prod = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
  52             v = {'product_uom': prod.uom_id.id}
  53             return {'value': v}
  54         return {}
  55
  56     def onchange_uom(self, cr, uid, ids, product_id, product_uom, context=None):
  57         res = {'value':{}}
  58         if not product_uom or not product_id:
  59             return res
  60         product = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
  61         uom = self.pool.get('product.uom').browse(cr, uid, product_uom, context=context)
  62         if uom.category_id.id != product.uom_id.category_id.id:
  63             res['warning'] = {'title': _('Warning'), 'message': _('The Product Unit of Measure you chose has a different category than in the product form.')}
  64             res['value'].update({'product_uom': product.uom_id.id})
  65         return res
  66
  67 mrp_subproduct()
  68
  69 class mrp_bom(osv.osv):
  70     _name = 'mrp.bom'
  71     _description = 'Bill of Material'
  72     _inherit='mrp.bom'
  73
  74     _columns={
  75         'sub_products':fields.one2many('mrp.subproduct', 'bom_id', 'Byproducts'),
  76     }
  77
  78 mrp_bom()
  79
  80 class mrp_production(osv.osv):
  81     _description = 'Production'
  82     _inherit= 'mrp.production'
  83
  84
  85     def action_confirm(self, cr, uid, ids):
  86         """ Confirms production order and calculates quantity based on subproduct_type.
  87         @return: Newly generated picking Id.
  88         """
  89         picking_id = super(mrp_production,self).action_confirm(cr, uid, ids)
  90         product_uom_obj = self.pool.get('product.uom')
  91         for production in self.browse(cr, uid, ids):
  92             source = production.product_id.property_stock_production.id
  93             if not production.bom_id:
  94                 continue
  95             for sub_product in production.bom_id.sub_products:
  96                 product_uom_factor = product_uom_obj._compute_qty(cr, uid, production.product_uom.id, production.product_qty, production.bom_id.product_uom.id)
  97                 qty1 = sub_product.product_qty
  98                 qty2 = production.product_uos and production.product_uos_qty or False
  99                 product_uos_factor = 0.0
 100                 if qty2 and production.bom_id.product_uos.id:
 101                     product_uos_factor = product_uom_obj._compute_qty(cr, uid, production.product_uos.id, production.product_uos_qty, production.bom_id.product_uos.id)
 102                 if sub_product.subproduct_type == 'variable':
 103                     if production.product_qty:
 104                         qty1 *= product_uom_factor / (production.bom_id.product_qty or 1.0)
 105                     if production.product_uos_qty:
 106                         qty2 *= product_uos_factor / (production.bom_id.product_uos_qty or 1.0)
 107                 data = {
 108                     'name': 'PROD:'+production.name,
 109                     'date': production.date_planned,
 110                     'product_id': sub_product.product_id.id,
 111                     'product_qty': qty1,
 112                     'product_uom': sub_product.product_uom.id,
 113                     'product_uos_qty': qty2,
 114                     'product_uos': production.product_uos and production.product_uos.id or False,
 115                     'location_id': source,
 116                     'location_dest_id': production.location_dest_id.id,
 117                     'move_dest_id': production.move_prod_id.id,
 118                     'state': 'waiting',
 119                     'production_id': production.id
 120                 }
 121                 self.pool.get('stock.move').create(cr, uid, data)
 122         return picking_id
 123
 124     def _get_subproduct_factor(self, cr, uid, production_id, move_id=None, context=None):
 125         """Compute the factor to compute the qty of procucts to produce for the given production_id. By default,
 126             it's always equal to the quantity encoded in the production order or the production wizard, but with
 127             the module mrp_byproduct installed it can differ for byproducts having type 'variable'.
 128         :param production_id: ID of the mrp.order
 129         :param move_id: ID of the stock move that needs to be produced. Identify the product to produce.
 130         :return: The factor to apply to the quantity that we should produce for the given production order and stock move.
 131         """
 132         sub_obj = self.pool.get('mrp.subproduct')
 133         move_obj = self.pool.get('stock.move')
 134         production_obj = self.pool.get('mrp.production')
 135         production_browse = production_obj.browse(cr, uid, production_id, context=context)
 136         move_browse = move_obj.browse(cr, uid, move_id, context=context)
 137         subproduct_factor = 1
 138         sub_id = sub_obj.search(cr, uid,[('product_id', '=', move_browse.product_id.id),('bom_id', '=', production_browse.bom_id.id), ('subproduct_type', '=', 'variable')], context=context)
 139         if sub_id:
 140             subproduct_record = sub_obj.browse(cr ,uid, sub_id[0], context=context)
 141             if subproduct_record.bom_id.product_qty:
 142                 subproduct_factor = subproduct_record.product_qty / subproduct_record.bom_id.product_qty
 143                 return subproduct_factor
 144         return super(mrp_production, self)._get_subproduct_factor(cr, uid, production_id, move_id, context=context)
 145
 146 mrp_production()
 147
 148 class change_production_qty(osv.osv_memory):
 149     _inherit = 'change.production.qty'
 150
 151     def _update_product_to_produce(self, cr, uid, prod, qty, context=None):
 152         bom_obj = self.pool.get('mrp.bom')
 153         move_lines_obj = self.pool.get('stock.move')
 154         prod_obj = self.pool.get('mrp.production')
 155         for m in prod.move_created_ids:
 156             if m.product_id.id == prod.product_id.id:
 157                 move_lines_obj.write(cr, uid, [m.id], {'product_qty': qty})
 158             else:
 159                 for sub_product_line in prod.bom_id.sub_products:
 160                     if sub_product_line.product_id.id == m.product_id.id:
 161                         factor = prod_obj._get_subproduct_factor(cr, uid, prod.id, m.id, context=context)
 162                         subproduct_qty = sub_product_line.subproduct_type == 'variable' and qty * factor or sub_product_line.product_qty
 163                         move_lines_obj.write(cr, uid, [m.id], {'product_qty': subproduct_qty})
 164
 165 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: