X-Git-Url: http://git.inspyration.org/?a=blobdiff_plain;f=addons%2Fstock_planning%2Fstock_planning.py;h=7e9342292b9833f065ad94dd1ba1ca1512491a60;hb=4525da95257fdde0ea3d82c07fa1ae14c9750cb6;hp=0c957d8b72e4cfc4b4451d8b8e7527980364948b;hpb=bf8d2a73c06154918874220b8bfb1251dc614088;p=odoo%2Fodoo.git diff --git a/addons/stock_planning/stock_planning.py b/addons/stock_planning/stock_planning.py index 0c957d8..7e93422 100644 --- a/addons/stock_planning/stock_planning.py +++ b/addons/stock_planning/stock_planning.py @@ -1,33 +1,30 @@ -# -*- encoding: utf-8 -*- +# -*- coding: utf-8 -*- ############################################################################## # -# OpenERP, Open Source Management Solution -# Copyright (C) 2004-2008 Tiny SPRL (). All Rights Reserved -# $Id$ +# OpenERP, Open Source Management Solution +# Copyright (C) 2004-2010 Tiny SPRL (). # # This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. +# it under the terms of the GNU Affero General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. +# GNU Affero General Public License for more details. # -# You should have received a copy of the GNU General Public License +# You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . # ############################################################################## -from osv import fields,osv -import pooler -from tools import config import time +from datetime import datetime +from dateutil.relativedelta import relativedelta + +from osv import osv, fields import netsvc -import math -import mx.DateTime -from mx.DateTime import RelativeDateTime, now, DateTime, localtime from tools.translate import _ def rounding(fl, round_value): @@ -35,270 +32,105 @@ def rounding(fl, round_value): return fl return round(fl / round_value) * round_value - -# Object creating periods quickly -# changed that stop_date is created with hour 23:59:00 when it was 00:00:00 stop date was excluded from period -class stock_period_createlines(osv.osv_memory): - _name = "stock.period.createlines" - - def _get_new_period_start(self,cr,uid,context={}): - cr.execute("select max(date_stop) from stock_period") - result=cr.fetchone() - last_date = result and result[0] or False - if last_date: - period_start = mx.DateTime.strptime(last_date,"%Y-%m-%d %H:%M:%S")+ RelativeDateTime(days=1) - period_start = period_start - RelativeDateTime(hours=period_start.hour, minutes=period_start.minute, seconds=period_start.second) - else: - period_start = mx.DateTime.today() - return period_start.strftime('%Y-%m-%d') - - - _columns = { - 'name': fields.char('Period Name', size=64), - 'date_start': fields.date('Start Date', required=True), - 'date_stop': fields.date('End Date', required=True), - 'period_ids': fields.one2many('stock.period', 'planning_id', 'Periods'), - } - _defaults={ - 'date_start':_get_new_period_start, - } - - def create_period_weekly(self,cr, uid, ids, context={}): - res=self.create_period(cr, uid, ids, context, 6, 'Weekly') - return { - 'view_type': 'form', - "view_mode": 'tree', - 'res_model': 'stock.period', - 'type': 'ir.actions.act_window', - } - - def create_period_monthly(self,cr, uid, ids, context={},interval=1): - for p in self.browse(cr, uid, ids, context): - dt = p.date_start - ds = mx.DateTime.strptime(p.date_start, '%Y-%m-%d') - while ds.strftime('%Y-%m-%d') val.product_id.uom_id.category_id.id: - coef = coef / val.product_id.uos_coeff - return val.product_id.uom_id.factor / coef + coef = uom.factor + if uom.category_id.id <> product.uom_id.category_id.id: + coef = coef / product.uos_coeff + return product.uom_id.factor / coef - def _from_default_uom_factor(self, cr, uid, val, uom_id, context): + def _from_default_uom_factor(self, cr, uid, product_id, uom_id, context=None): uom_obj = self.pool.get('product.uom') + product_obj = self.pool.get('product.product') + product = product_obj.browse(cr, uid, product_id, context=context) uom = uom_obj.browse(cr, uid, uom_id, context=context) res = uom.factor - if uom.category_id.id <> val.product_id.uom_id.category_id.id: - res = res / val.product_id.uos_coeff - return res / val.product_id.uom_id.factor, uom.rounding + if uom.category_id.id <> product.uom_id.category_id.id: + res = res / product.uos_coeff + return res / product.uom_id.factor, uom.rounding def _sales_per_users(self, cr, uid, so, so_line, company, users): cr.execute("SELECT sum(sol.product_uom_qty) FROM sale_order_line AS sol LEFT JOIN sale_order AS s ON (s.id = sol.order_id) " \ "WHERE (sol.id IN %s) AND (s.state NOT IN (\'draft\',\'cancel\')) AND (s.id IN %s) AND (s.company_id=%s) " \ - "AND (s.user_id IN %s) " %(tuple(so_line), tuple(so), company, tuple(users))) + "AND (s.user_id IN %s) " ,(tuple(so_line), tuple(so), company, tuple(users))) ret = cr.fetchone()[0] or 0.0 return ret - def _sales_per_warehouse(self, cr, uid, so, so_line, company, shops): + def _sales_per_warehouse(self, cr, uid, so, so_line, company, shops): cr.execute("SELECT sum(sol.product_uom_qty) FROM sale_order_line AS sol LEFT JOIN sale_order AS s ON (s.id = sol.order_id) " \ "WHERE (sol.id IN %s) AND (s.state NOT IN (\'draft\',\'cancel\')) AND (s.id IN %s)AND (s.company_id=%s) " \ - "AND (s.shop_id IN %s)" %(tuple(so_line), tuple(so), company, tuple(shops))) + "AND (s.shop_id IN %s)" ,(tuple(so_line), tuple(so), company, tuple(shops))) ret = cr.fetchone()[0] or 0.0 return ret - def _sales_per_company(self, cr, uid, so, so_line, company, ): + def _sales_per_company(self, cr, uid, so, so_line, company): cr.execute("SELECT sum(sol.product_uom_qty) FROM sale_order_line AS sol LEFT JOIN sale_order AS s ON (s.id = sol.order_id) " \ - "WHERE (sol.id IN %s) AND (s.state NOT IN (\'draft\',\'cancel\')) AND (s.id IN %s) AND (s.company_id=%s)"%(tuple(so_line), tuple(so), company)) + "WHERE (sol.id IN %s) AND (s.state NOT IN (\'draft\',\'cancel\')) AND (s.id IN %s) AND (s.company_id=%s)", (tuple(so_line), tuple(so), company)) ret = cr.fetchone()[0] or 0.0 return ret - + def calculate_sales_history(self, cr, uid, ids, context, *args): - sales=[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],] - for obj in self.browse(cr, uid, ids): - periods =obj.analyzed_period1_id, obj.analyzed_period2_id, obj.analyzed_period3_id, obj.analyzed_period4_id, obj.analyzed_period5_id + sales = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],] + for obj in self.browse(cr, uid, ids, context=context): + periods = obj.analyzed_period1_id, obj.analyzed_period2_id, obj.analyzed_period3_id, obj.analyzed_period4_id, obj.analyzed_period5_id so_obj = self.pool.get('sale.order') - so_line_obj= self.pool.get('sale.order.line') + so_line_obj = self.pool.get('sale.order.line') so_line_product_ids = so_line_obj.search(cr, uid, [('product_id','=', obj.product_id.id)], context = context) if so_line_product_ids: so_line_product_set = ','.join(map(str,so_line_product_ids)) @@ -410,183 +247,64 @@ class stock_sale_forecast(osv.osv): dept_obj = self.pool.get('hr.department') dept_id = obj.analyzed_dept_id.id and [obj.analyzed_dept_id.id] or [] dept_ids = dept_obj.search(cr,uid,[('parent_id','child_of',dept_id)]) - dept_ids_set = ','.join(map(str,dept_ids)) - cr.execute("SELECT user_id FROM hr_department_user_rel WHERE (department_id IN %s)" %(tuple(dept_ids_set),)) + cr.execute("SELECT user_id FROM resource_resource rsc, hr_employee emp WHERE (emp.resource_id = rsc.id and emp.department_id IN %s)" ,(tuple(dept_ids),)) dept_users = [x for x, in cr.fetchall()] - dept_users_set = ','.join(map(str,dept_users)) + dept_users_set = map(str,dept_users) else: dept_users = False - factor, round_value = self._from_default_uom_factor(cr, uid, obj, obj.product_uom.id, context=context) + factor, round_value = self._from_default_uom_factor(cr, uid, obj.product_id.id, obj.product_uom.id, context=context) for i, period in enumerate(periods): if period: - so_period_ids = so_obj.search(cr, uid, [('date_order','>=',period.date_start), ('date_order','<=',period.date_stop)], context = context) + so_period_ids = so_obj.search(cr, uid, [('date_order','>=',period.date_start),('date_order','<=',period.date_stop) ], context = context) if so_period_ids: - so_period_set = ','.join(map(str,so_period_ids)) if obj.analyzed_user_id: user_set = str(obj.analyzed_user_id.id) - sales[i][0] =self._sales_per_users(cr, uid, so_period_set, so_line_product_set, obj.company_id.id, user_set) - sales[i][0] *=factor + sales[i][0] = self._sales_per_users(cr, uid, so_period_ids, so_line_product_ids, obj.company_id.id, user_set) + sales[i][0] *= factor if dept_users: - sales[i][1]= self._sales_per_users(cr, uid, so_period_set, so_line_product_set, obj.company_id.id, dept_users_set) - sales[i][1]*=factor + sales[i][1] = self._sales_per_users(cr, uid, so_period_ids, so_line_product_ids, obj.company_id.id, dept_users_set) + sales[i][1] *= factor if shops: - sales[i][2]= self._sales_per_warehouse(cr, uid, so_period_set, so_line_product_set, obj.company_id.id, shops_set) - sales[i][2]*=factor + sales[i][2] = self._sales_per_warehouse(cr, uid, so_period_ids, so_line_product_ids, obj.company_id.id, shops_set) + sales[i][2] *= factor if obj.analyze_company: - sales[i][3]= self._sales_per_company(cr, uid, so_period_set, so_line_product_set, obj.company_id.id, ) - sales[i][3]*=factor + sales[i][3] = self._sales_per_company(cr, uid, so_period_ids, so_line_product_ids, obj.company_id.id, ) + sales[i][3] *= factor self.write(cr, uid, ids, { - 'analyzed_period1_per_user':sales[0][0], - 'analyzed_period2_per_user':sales[1][0], - 'analyzed_period3_per_user':sales[2][0], - 'analyzed_period4_per_user':sales[3][0], - 'analyzed_period5_per_user':sales[4][0], - 'analyzed_period1_per_dept':sales[0][1], - 'analyzed_period2_per_dept':sales[1][1], - 'analyzed_period3_per_dept':sales[2][1], - 'analyzed_period4_per_dept':sales[3][1], - 'analyzed_period5_per_dept':sales[4][1], - 'analyzed_period1_per_warehouse':sales[0][2], - 'analyzed_period2_per_warehouse':sales[1][2], - 'analyzed_period3_per_warehouse':sales[2][2], - 'analyzed_period4_per_warehouse':sales[3][2], - 'analyzed_period5_per_warehouse':sales[4][2], - 'analyzed_period1_per_company':sales[0][3], - 'analyzed_period2_per_company':sales[1][3], - 'analyzed_period3_per_company':sales[2][3], - 'analyzed_period4_per_company':sales[3][3], - 'analyzed_period5_per_company':sales[4][3], + 'analyzed_period1_per_user': sales[0][0], + 'analyzed_period2_per_user': sales[1][0], + 'analyzed_period3_per_user': sales[2][0], + 'analyzed_period4_per_user': sales[3][0], + 'analyzed_period5_per_user': sales[4][0], + 'analyzed_period1_per_dept': sales[0][1], + 'analyzed_period2_per_dept': sales[1][1], + 'analyzed_period3_per_dept': sales[2][1], + 'analyzed_period4_per_dept': sales[3][1], + 'analyzed_period5_per_dept': sales[4][1], + 'analyzed_period1_per_warehouse': sales[0][2], + 'analyzed_period2_per_warehouse': sales[1][2], + 'analyzed_period3_per_warehouse': sales[2][2], + 'analyzed_period4_per_warehouse': sales[3][2], + 'analyzed_period5_per_warehouse': sales[4][2], + 'analyzed_period1_per_company': sales[0][3], + 'analyzed_period2_per_company': sales[1][3], + 'analyzed_period3_per_company': sales[2][3], + 'analyzed_period4_per_company': sales[3][3], + 'analyzed_period5_per_company': sales[4][3], }) return True - stock_sale_forecast() -# Creates stock planning records for products from selected Product Category for selected 'Warehouse - Period' -# Object added by contributor in ver 1.1 -class stock_planning_createlines(osv.osv_memory): - _name = "stock.planning.createlines" - - def onchange_company(self, cr, uid, ids, company_id): - result = {} - if company_id: - result['warehouse_id2'] = False - return {'value': result} - - _columns = { - 'company_id': fields.many2one('res.company', 'Company', required = True), - 'period_id2': fields.many2one('stock.period' , 'Period', required=True, help = 'Period which planning will concern.'), - 'warehouse_id2': fields.many2one('stock.warehouse' , 'Warehouse', required=True, help = 'Warehouse which planning will concern.'), - 'product_categ_id2': fields.many2one('product.category' , 'Product Category', \ - help = 'Planning will be created for products from Product Category selected by this field. '\ - 'This field is ignored when you check \"All Forecasted Product\" box.' ), - 'forecasted_products': fields.boolean('All Products with Forecast', \ - help = "Check this box to create planning for all products having any forecast for selected Warehouse and Period. "\ - "Product Category field will be ignored."), - } - - _defaults = { - 'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.planning', context=c), - } - - def create_planning(self,cr, uid, ids, context={}): - product_obj = self.pool.get('product.product') - planning_obj=self.pool.get('stock.planning') - mod_obj =self.pool.get('ir.model.data') - for f in self.browse(cr, uid, ids, context=context): - if f.forecasted_products: - cr.execute("SELECT product_id \ - FROM stock_sale_forecast \ - WHERE (period_id = %s) AND (warehouse_id = %s)", (f.period_id2.id, f.warehouse_id2.id)) - products_id1 = [x for x, in cr.fetchall()] - else: - prod_categ_obj=self.pool.get('product.category') - template_obj=self.pool.get('product.template') - categ_ids = f.product_categ_id2.id and [f.product_categ_id2.id] or [] - prod_categ_ids=prod_categ_obj.search(cr,uid,[('parent_id','child_of',categ_ids)]) - templates_ids = template_obj.search(cr,uid,[('categ_id','in',prod_categ_ids)]) - products_id1 = product_obj.search(cr,uid,[('product_tmpl_id','in',templates_ids)]) - if len(products_id1)==0: - raise osv.except_osv(_('Error !'), _('No forecasts for selected period or no products in selected category !')) - - for p in product_obj.browse(cr, uid, products_id1,context=context): - if len(planning_obj.search(cr, uid, [('product_id','=',p.id), - ('period_id','=',f.period_id2.id), - ('warehouse_id','=',f.warehouse_id2.id)]))== 0: - cr.execute("SELECT period.date_stop, planning.product_uom, planning.planned_outgoing, planning.to_procure, \ - planning.stock_only, planning.procure_to_stock, planning.confirmed_forecasts_only, \ - planning.supply_warehouse_id, planning.stock_supply_location \ - FROM stock_planning AS planning \ - LEFT JOIN stock_period AS period \ - ON planning.period_id = period.id \ - WHERE (planning.create_uid = %s OR planning.write_uid = %s) \ - AND planning.warehouse_id = %s AND planning.product_id = %s \ - AND period.date_stop < %s \ - ORDER BY period.date_stop DESC", - (uid, uid, f.warehouse_id2.id, p.id, f.period_id2.date_stop) ) - ret=cr.fetchone() -# forecast_qty = ret and ret[0] or 0.0 - if ret: -# raise osv.except_osv(_('Error !'), _('ret is %s %s %s %s %s %s')%(ret[0],ret[2],ret[3],ret[4],ret[5],ret[6],)) - prod_uom = ret[1] - planned_out = ret[2] - to_procure = ret[3] - stock_only = ret[4] - procure_to_stock = ret[5] - confirmed_forecasts_only = ret[6] - supply_warehouse_id = ret[7] - stock_supply_location = ret[8] - else: - prod_uom = p.uom_id.id - planned_out = False - to_procure = False - stock_only = False - procure_to_stock = False - confirmed_forecasts_only = False - supply_warehouse_id = False - stock_supply_location = False - prod_uos_categ = False - if p.uos_id: - prod_uos_categ = p.uos_id.category_id.id - planning_obj.create(cr, uid, { - 'company_id' : f.warehouse_id2.company_id.id, - 'period_id': f.period_id2.id, - 'warehouse_id' : f.warehouse_id2.id, - 'product_id': p.id, - 'product_uom' : prod_uom, - 'product_uom_categ' : p.uom_id.category_id.id, - 'product_uos_categ' : prod_uos_categ, - 'active_uom' : prod_uom, - 'planned_outgoing': planned_out, - 'to_procure': to_procure, - 'stock_only': stock_only, - 'procure_to_stock': procure_to_stock, - 'confirmed_forecasts_only': confirmed_forecasts_only, - 'supply_warehouse_id': supply_warehouse_id, - 'stock_supply_location': stock_supply_location, - - }) - result = mod_obj._get_id(cr, uid, 'stock_planning', 'view_stock_planning_filter') - id = mod_obj.read(cr, uid, result, ['res_id'], context=context) - return { - 'view_type': 'form', - "view_mode": 'tree', - 'res_model': 'stock.planning', - 'type': 'ir.actions.act_window', - 'search_view_id': id['res_id'], - } -stock_planning_createlines() - - # The main Stock Planning object # A lot of changes by contributor in ver 1.1 class stock_planning(osv.osv): _name = "stock.planning" - - def _get_in_out(self, cr, uid, val, date_start, date_stop, direction, done, context): -# res = {} -# if not context: -# context = {} + + def _get_in_out(self, cr, uid, val, date_start, date_stop, direction, done, context=None): + if context is None: + context = {} + product_obj = self.pool.get('product.product') mapping = {'in': { 'field': "incoming_qty", 'adapter': lambda x: x, @@ -603,22 +321,19 @@ class stock_planning(osv.osv): locations.extend([val.warehouse_id.lot_input_id.id, val.warehouse_id.lot_output_id.id]) context['location'] = locations context['compute_child'] = True - product_obj = self.pool.get('product.product') prod_id = val.product_id.id if done: - c1=context.copy() - c1.update({ 'states':('done',), 'what':(direction,) }) + context.update({ 'states':('done',), 'what':(direction,) }) prod_ids = [prod_id] - st = product_obj.get_product_available(cr,uid, prod_ids, context=c1) + st = product_obj.get_product_available(cr, uid, prod_ids, context=context) res = mapping[direction]['adapter'](st.get(prod_id,0.0)) else: - product=product_obj.read(cr, uid, prod_id,[], context) + product = product_obj.read(cr, uid, prod_id,[], context) product_qty = product[mapping[direction]['field']] res = mapping[direction]['adapter'](product_qty) -# res[val.id] = product_obj['incoming_qty'] return res - def _get_outgoing_before(self, cr, uid, val, date_start, date_stop, context): + def _get_outgoing_before(self, cr, uid, val, date_start, date_stop, context=None): cr.execute("SELECT sum(planning.planned_outgoing), planning.product_uom \ FROM stock_planning AS planning \ LEFT JOIN stock_period AS period \ @@ -631,22 +346,22 @@ class stock_planning(osv.osv): res = self._to_planning_uom(cr, uid, val, planning_qtys, context) return res - def _to_planning_uom(self, cr, uid, val, qtys, context): + def _to_planning_uom(self, cr, uid, val, qtys, context=None): res_qty = 0 if qtys: uom_obj = self.pool.get('product.uom') for qty, prod_uom in qtys: - coef = self._to_default_uom_factor(cr, uid, val, prod_uom, context=context) - res_coef, round_value = self._from_default_uom_factor(cr, uid, val, val.product_uom.id, context=context) + coef = self._to_default_uom_factor(cr, uid, val.product_id.id, prod_uom, context=context) + res_coef, round_value = self._from_default_uom_factor(cr, uid, val.product_id.id, val.product_uom.id, context=context) coef = coef * res_coef res_qty += rounding(qty * coef, round_value) return res_qty - - def _get_forecast(self, cr, uid, ids, field_names, arg, context): + + def _get_forecast(self, cr, uid, ids, field_names, arg, context=None): res = {} - for val in self.browse(cr, uid, ids): - res[val.id]={} + for val in self.browse(cr, uid, ids, context=context): + res[val.id] = {} valid_part = val.confirmed_forecasts_only and " AND state = 'validated'" or "" cr.execute('SELECT sum(product_qty), product_uom \ FROM stock_sale_forecast \ @@ -666,7 +381,9 @@ class stock_planning(osv.osv): res[val.id]['warehouse_forecast'] = rounding(res[val.id]['warehouse_forecast'], val.product_id.uom_id.rounding) return res - def _get_stock_start(self, cr, uid, val, date, context): + def _get_stock_start(self, cr, uid, val, date, context=None): + if context is None: + context = {} context['from_date'] = None context['to_date'] = date locations = [val.warehouse_id.lot_stock_id.id,] @@ -677,8 +394,8 @@ class stock_planning(osv.osv): product_obj = self.pool.get('product.product').read(cr, uid,val.product_id.id,[], context) res = product_obj['qty_available'] # value for stock_start return res - - def _get_past_future(self, cr, uid, ids, field_names, arg, context): + + def _get_past_future(self, cr, uid, ids, field_names, arg, context=None): res = {} for val in self.browse(cr, uid, ids, context=context): if val.period_id.date_stop < time.strftime('%Y-%m-%d'): @@ -687,64 +404,64 @@ class stock_planning(osv.osv): res[val.id] = 'Future' return res - def _get_op(self, cr, uid, ids, field_names, arg, context): # op = OrderPoint + def _get_op(self, cr, uid, ids, field_names, arg, context=None): # op = OrderPoint res = {} for val in self.browse(cr, uid, ids, context=context): res[val.id]={} cr.execute("SELECT product_min_qty, product_max_qty, product_uom \ FROM stock_warehouse_orderpoint \ WHERE warehouse_id = %s AND product_id = %s AND active = 'TRUE'", (val.warehouse_id.id, val.product_id.id)) - ret = cr.fetchone() or [0.0,0.0,False] + ret = cr.fetchone() or [0.0,0.0,False] coef = 1 round_value = 1 if ret[2]: - coef = self._to_default_uom_factor(cr, uid, val, ret[2], context) - res_coef, round_value = self._from_default_uom_factor(cr, uid, val, val.product_uom.id, context=context) + coef = self._to_default_uom_factor(cr, uid, val.product_id.id, ret[2], context) + res_coef, round_value = self._from_default_uom_factor(cr, uid, val.product_id.id, val.product_uom.id, context=context) coef = coef * res_coef res[val.id]['minimum_op'] = rounding(ret[0]*coef, round_value) res[val.id]['maximum_op'] = ret[1]*coef return res - - def onchange_company(self, cr, uid, ids, company_id): + + def onchange_company(self, cr, uid, ids, company_id=False): result = {} if company_id: result['warehouse_id'] = False return {'value': result} - def onchange_uom(self, cr, uid, ids, product_uom, ): + def onchange_uom(self, cr, uid, ids, product_uom=False, product_id=False, active_uom=False, + planned_outgoing=0.0, to_procure=0.0): + ret = {} if not product_uom: return {} - ret={} - val1 = self.browse(cr, uid, ids) - val = val1[0] - coeff_uom2def = self._to_default_uom_factor(cr, uid, val, val.active_uom.id, {}) - coeff_def2uom, round_value = self._from_default_uom_factor( cr, uid, val, product_uom, {}) - coeff = coeff_uom2def * coeff_def2uom - ret['planned_outgoing'] = rounding(coeff * val.planned_outgoing, round_value) - ret['to_procure'] = rounding(coeff * val.to_procure, round_value) + if active_uom: + coeff_uom2def = self._to_default_uom_factor(cr, uid, product_id, active_uom, {}) + coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, product_id, product_uom, {}) + coeff = coeff_uom2def * coeff_def2uom + ret['planned_outgoing'] = rounding(coeff * planned_outgoing, round_value) + ret['to_procure'] = rounding(coeff * to_procure, round_value) ret['active_uom'] = product_uom return {'value': ret} _columns = { 'company_id': fields.many2one('res.company', 'Company', required = True), - 'history' : fields.text('Procurement History', readonly=True, help = "History of procurement or internal supply of this planning line."), + 'history': fields.text('Procurement History', readonly=True, help = "History of procurement or internal supply of this planning line."), 'state' : fields.selection([('draft','Draft'),('done','Done')],'State',readonly=True), 'period_id': fields.many2one('stock.period' , 'Period', required=True, \ help = 'Period for this planning. Requisition will be created for beginning of the period.'), - 'warehouse_id' : fields.many2one('stock.warehouse','Warehouse', required=True), + 'warehouse_id': fields.many2one('stock.warehouse','Warehouse', required=True), 'product_id': fields.many2one('product.product' , 'Product', required=True, help = 'Product which this planning is created for.'), 'product_uom_categ' : fields.many2one('product.uom.categ', 'Product UoM Category'), # Invisible field for product_uom domain - 'product_uom' : fields.many2one('product.uom', 'UoM', required=True, help = "Unit of Measure used to show the quanities of stock calculation." \ + 'product_uom': fields.many2one('product.uom', 'UoM', required=True, help = "Unit of Measure used to show the quanities of stock calculation." \ "You can use units form default category or from second category (UoS category)."), - 'product_uos_categ' : fields.many2one('product.uom.categ', 'Product UoM Category'), # Invisible field for product_uos domain + 'product_uos_categ': fields.many2one('product.uom.categ', 'Product UoM Category'), # Invisible field for product_uos domain # Field used in onchange_uom to check what uom was before change to recalculate quantities acording to old uom (active_uom) and new uom. - 'active_uom' :fields.many2one('product.uom', string = "Active UoM"), - 'planned_outgoing' : fields.float('Planned Out', required=True, \ + 'active_uom': fields.many2one('product.uom', string = "Active UoM"), + 'planned_outgoing': fields.float('Planned Out', required=True, \ help = 'Enter planned outgoing quantity from selected Warehouse during the selected Period of selected Product. '\ 'To plan this value look at Confirmed Out or Sales Forecasts. This value should be equal or greater than Confirmed Out.'), - 'company_forecast': fields.function(_get_forecast, method=True, string ='Company Forecast', multi = 'company', \ + 'company_forecast': fields.function(_get_forecast, string ='Company Forecast', multi = 'company', \ help = 'All sales forecasts for whole company (for all Warehouses) of selected Product during selected Period.'), - 'warehouse_forecast': fields.function(_get_forecast, method=True, string ='Warehouse Forecast', multi = 'warehouse',\ + 'warehouse_forecast': fields.function(_get_forecast, string ='Warehouse Forecast', multi = 'warehouse',\ help = 'All sales forecasts for selected Warehouse of selected Product during selected Period.'), 'stock_simulation': fields.float('Stock Simulation', readonly =True, \ help = 'Stock simulation at the end of selected Period.\n For current period it is: \n' \ @@ -763,70 +480,74 @@ class stock_planning(osv.osv): 'to_procure': fields.float(string='Planned In', required=True, \ help = 'Enter quantity which (by your plan) should come in. Change this value and observe Stock simulation. ' \ 'This value should be equal or greater than Confirmed In.'), - 'line_time' : fields.function(_get_past_future, method=True,type='char', string='Past/Future'), - 'minimum_op' : fields.function(_get_op, method=True, type='float', string = 'Minimum Rule', multi= 'minimum', \ + 'line_time': fields.function(_get_past_future,type='char', string='Past/Future'), + 'minimum_op': fields.function(_get_op, type='float', string = 'Minimum Rule', multi= 'minimum', \ help = 'Minimum quantity set in Minimum Stock Rules for this Warhouse'), - 'maximum_op' : fields.function(_get_op, method=True, type='float', string = 'Maximum Rule', multi= 'maximum', \ + 'maximum_op': fields.function(_get_op, type='float', string = 'Maximum Rule', multi= 'maximum', \ help = 'Maximum quantity set in Minimum Stock Rules for this Warhouse'), - 'outgoing_before' : fields.float('Planned Out Before', readonly=True, \ + 'outgoing_before': fields.float('Planned Out Before', readonly=True, \ help= 'Planned Out in periods before calculated. '\ 'Between start date of current period and one day before start of calculated period.'), 'incoming_before': fields.float('Incoming Before', readonly = True, \ help= 'Confirmed incoming in periods before calculated (Including Already In). '\ 'Between start date of current period and one day before start of calculated period.'), - 'stock_start' : fields.float('Initial Stock', readonly=True, \ + 'stock_start': fields.float('Initial Stock', readonly=True, \ help= 'Stock quantity one day before current period.'), - 'already_out' : fields.float('Already Out', readonly=True, \ + 'already_out': fields.float('Already Out', readonly=True, \ help= 'Quantity which is already dispatched out of this warehouse in current period.'), - 'already_in' : fields.float('Already In', readonly=True, \ + 'already_in': fields.float('Already In', readonly=True, \ help= 'Quantity which is already picked up to this warehouse in current period.'), - 'stock_only' : fields.boolean("Stock Location Only", help = "Check to calculate stock location of selected warehouse only. " \ + 'stock_only': fields.boolean("Stock Location Only", help = "Check to calculate stock location of selected warehouse only. " \ "If not selected calculation is made for input, stock and output location of warehouse."), - "procure_to_stock" : fields.boolean("Procure To Stock Location", help = "Chect to make procurement to stock location of selected warehouse. " \ + "procure_to_stock": fields.boolean("Procure To Stock Location", help = "Chect to make procurement to stock location of selected warehouse. " \ "If not selected procurement will be made into input location of warehouse."), - "confirmed_forecasts_only" : fields.boolean("Validated Forecasts", help = "Check to take validated forecasts only. " \ + "confirmed_forecasts_only": fields.boolean("Validated Forecasts", help = "Check to take validated forecasts only. " \ "If not checked system takes validated and draft forecasts."), - 'supply_warehouse_id' : fields.many2one('stock.warehouse','Source Warehouse', help = "Warehouse used as source in supply pick move created by 'Supply from Another Warhouse'."), - "stock_supply_location" : fields.boolean("Stock Supply Location", help = "Check to supply from Stock location of Supply Warehouse. " \ + 'supply_warehouse_id': fields.many2one('stock.warehouse','Source Warehouse', help = "Warehouse used as source in supply pick move created by 'Supply from Another Warhouse'."), + "stock_supply_location": fields.boolean("Stock Supply Location", help = "Check to supply from Stock location of Supply Warehouse. " \ "If not checked supply will be made from Output location of Supply Warehouse. Used in 'Supply from Another Warhouse' with Supply Warehouse."), } _defaults = { 'state': lambda *args: 'draft' , - 'to_procure' : 0.0, - 'planned_outgoing' : 0.0, + 'to_procure': 0.0, + 'planned_outgoing': 0.0, 'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.planning', context=c), - } - + } + _order = 'period_id' - def _to_default_uom_factor(self, cr, uid, val, uom_id, context): + def _to_default_uom_factor(self, cr, uid, product_id, uom_id, context=None): uom_obj = self.pool.get('product.uom') + product_obj = self.pool.get('product.product') + product = product_obj.browse(cr, uid, product_id, context=context) uom = uom_obj.browse(cr, uid, uom_id, context=context) - coef = uom.factor - if uom.category_id.id != val.product_id.uom_id.category_id.id: - coef = coef / val.product_id.uos_coeff - return val.product_id.uom_id.factor / coef + coef = uom.factor + if uom.category_id.id != product.uom_id.category_id.id: + coef = coef / product.uos_coeff + return product.uom_id.factor / coef - def _from_default_uom_factor(self, cr, uid, val, uom_id, context): + def _from_default_uom_factor(self, cr, uid, product_id, uom_id, context=None): uom_obj = self.pool.get('product.uom') + product_obj = self.pool.get('product.product') + product = product_obj.browse(cr, uid, product_id, context=context) uom = uom_obj.browse(cr, uid, uom_id, context=context) res = uom.factor - if uom.category_id.id != val.product_id.uom_id.category_id.id: - res = res / val.product_id.uos_coeff - return res / val.product_id.uom_id.factor, uom.rounding + if uom.category_id.id != product.uom_id.category_id.id: + res = res / product.uos_coeff + return res / product.uom_id.factor, uom.rounding def calculate_planning(self, cr, uid, ids, context, *args): - one_minute = RelativeDateTime(minutes=1) - current_date_beginning_c = mx.DateTime.today() - current_date_end_c = current_date_beginning_c + RelativeDateTime(days=1, minutes=-1) # to get hour 23:59:00 + one_minute = relativedelta(minutes=1) + current_date_beginning_c = datetime.today() + current_date_end_c = current_date_beginning_c + relativedelta(days=1, minutes=-1) # to get hour 23:59:00 current_date_beginning = current_date_beginning_c.strftime('%Y-%m-%d %H:%M:%S') current_date_end = current_date_end_c.strftime('%Y-%m-%d %H:%M:%S') for val in self.browse(cr, uid, ids, context=context): - day = mx.DateTime.strptime(val.period_id.date_start, '%Y-%m-%d %H:%M:%S') - dbefore = mx.DateTime.DateTime(day.year, day.month, day.day) - one_minute + day = datetime.strptime(val.period_id.date_start, '%Y-%m-%d %H:%M:%S') + dbefore = datetime(day.year, day.month, day.day) - one_minute day_before_calculated_period = dbefore.strftime('%Y-%m-%d %H:%M:%S') # one day before start of calculated period cr.execute("SELECT date_start \ FROM stock_period AS period \ @@ -837,21 +558,22 @@ class stock_planning(osv.osv): date = cr.fetchone() start_date_current_period = date and date[0] or False start_date_current_period = start_date_current_period or current_date_beginning - day = mx.DateTime.strptime(start_date_current_period, '%Y-%m-%d %H:%M:%S') - dbefore = mx.DateTime.DateTime(day.year, day.month, day.day) - one_minute + + day = datetime.strptime(start_date_current_period, '%Y-%m-%d %H:%M:%S') + dbefore = datetime(day.year, day.month, day.day) - one_minute date_for_start = dbefore.strftime('%Y-%m-%d %H:%M:%S') # one day before current period - already_out = self._get_in_out(cr, uid, val, start_date_current_period, current_date_end, direction='out', done = True, context=context), - already_in = self._get_in_out(cr, uid, val, start_date_current_period, current_date_end, direction='in', done = True, context=context), - outgoing = self._get_in_out(cr, uid, val, val.period_id.date_start, val.period_id.date_stop, direction='out', done = False, context=context), - incoming = self._get_in_out(cr, uid, val, val.period_id.date_start, val.period_id.date_stop, direction='in', done = False, context=context), + already_out = self._get_in_out(cr, uid, val, start_date_current_period, current_date_end, direction='out', done=True, context=context), + already_in = self._get_in_out(cr, uid, val, start_date_current_period, current_date_end, direction='in', done=True, context=context), + outgoing = self._get_in_out(cr, uid, val, val.period_id.date_start, val.period_id.date_stop, direction='out', done=False, context=context), + incoming = self._get_in_out(cr, uid, val, val.period_id.date_start, val.period_id.date_stop, direction='in', done=False, context=context), outgoing_before = self._get_outgoing_before(cr, uid, val, start_date_current_period, day_before_calculated_period, context=context), - incoming_before = self._get_in_out(cr, uid, val, start_date_current_period, day_before_calculated_period, direction='in', done = False, context=context), + incoming_before = self._get_in_out(cr, uid, val, start_date_current_period, day_before_calculated_period, direction='in', done=False, context=context), stock_start = self._get_stock_start(cr, uid, val, date_for_start, context=context), if start_date_current_period == val.period_id.date_start: # current period is calculated - current=True + current = True else: - current=False - factor, round_value = self._from_default_uom_factor(cr, uid, val, val.product_uom.id, context=context) + current = False + factor, round_value = self._from_default_uom_factor(cr, uid, val.product_id.id, val.product_uom.id, context=context) self.write(cr, uid, ids, { 'already_out': rounding(already_out[0]*factor,round_value), 'already_in': rounding(already_in[0]*factor,round_value), @@ -861,18 +583,18 @@ class stock_planning(osv.osv): 'incoming_before': rounding((incoming_before[0]+ (not current and already_in[0]))*factor,round_value), 'outgoing_left': rounding(val.planned_outgoing - (outgoing[0] + (current and already_out[0]))*factor,round_value), 'incoming_left': rounding(val.to_procure - (incoming[0] + (current and already_in[0]))*factor,round_value), - 'stock_start' : rounding(stock_start[0]*factor,round_value), + 'stock_start': rounding(stock_start[0]*factor,round_value), 'stock_simulation': rounding(val.to_procure - val.planned_outgoing + (stock_start[0]+ incoming_before[0] - outgoing_before[0] \ + (not current and already_in[0]))*factor,round_value), }) return True # method below converts quantities and uoms to general OpenERP standard with UoM Qty, UoM, UoS Qty, UoS. -# from stock_planning standard where you have one Qty and one UoM (any from UoM or UoS category) +# from stock_planning standard where you have one Qty and one UoM (any from UoM or UoS category) # so if UoM is from UoM category it is used as UoM in standard and if product has UoS the UoS will be calcualated. -# If UoM is from UoS category it is recalculated to basic UoS from product (in planning you can use any UoS from UoS category) +# If UoM is from UoS category it is recalculated to basic UoS from product (in planning you can use any UoS from UoS category) # and basic UoM is calculated. - def _qty_to_standard(self, cr, uid, val, context): + def _qty_to_standard(self, cr, uid, val, context=None): uos = False uos_qty = 0.0 if val.product_uom.category_id.id == val.product_id.uom_id.category_id.id: @@ -880,63 +602,65 @@ class stock_planning(osv.osv): uom = val.product_uom.id if val.product_id.uos_id: uos = val.product_id.uos_id.id - coeff_uom2def = self._to_default_uom_factor(cr, uid, val, val.product_uom.id, {}) - coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, val, uos, {}) + coeff_uom2def = self._to_default_uom_factor(cr, uid, val.product_id.id, val.product_uom.id, {}) + coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, val.product_id.id, uos, {}) uos_qty = rounding(val.incoming_left * coeff_uom2def * coeff_def2uom, round_value) elif val.product_uom.category_id.id == val.product_id.uos_id.category_id.id: - coeff_uom2def = self._to_default_uom_factor(cr, uid, val, val.product_uom.id, {}) + coeff_uom2def = self._to_default_uom_factor(cr, uid, val.product_id.id, val.product_uom.id, {}) uos = val.product_id.uos_id.id - coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, val, uos, {}) + coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, val.product_id.id, uos, {}) uos_qty = rounding(val.incoming_left * coeff_uom2def * coeff_def2uom, round_value) uom = val.product_id.uom_id.id - coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, val, uom, {}) + coeff_def2uom, round_value = self._from_default_uom_factor(cr, uid, val.product_id.id, uom, {}) uom_qty = rounding(val.incoming_left * coeff_uom2def * coeff_def2uom, round_value) return uom_qty, uom, uos_qty, uos - + def procure_incomming_left(self, cr, uid, ids, context, *args): - for obj in self.browse(cr, uid, ids): + for obj in self.browse(cr, uid, ids, context=context): if obj.incoming_left <= 0: raise osv.except_osv(_('Error !'), _('Incoming Left must be greater than 0 !')) uom_qty, uom, uos_qty, uos = self._qty_to_standard(cr, uid, obj, context) - user = self.pool.get('res.users').browse(cr, uid, uid, context) + user = self.pool.get('res.users').browse(cr, uid, uid, context=context) proc_id = self.pool.get('procurement.order').create(cr, uid, { 'company_id' : obj.company_id.id, - 'name': _('Manual planning for ') + obj.period_id.name, - 'origin': _('MPS(') + str(user.login) +') '+ obj.period_id.name, + 'name': _('Manual planning for %s') %(obj.period_id.name), + 'origin': _('MPS(%s) %s') %(user.login, obj.period_id.name), 'date_planned': obj.period_id.date_start, 'product_id': obj.product_id.id, 'product_qty': uom_qty, 'product_uom': uom, 'product_uos_qty': uos_qty, 'product_uos': uos, - 'location_id': obj.procure_to_stock and obj.warehouse_id.lot_stock_id.id or obj.warehouse_id.lot_input_id.id, + 'location_id': obj.procure_to_stock and obj.warehouse_id.lot_stock_id.id or obj.warehouse_id.lot_input_id.id, 'procure_method': 'make_to_order', - 'note' : _("Procurement created in MPS by user: ") + str(user.login) + _(" Creation Date: ") + \ - time.strftime('%Y-%m-%d %H:%M:%S') + \ - _("\nFor period: ") + obj.period_id.name + _(" according to state:") + \ - _("\n Warehouse Forecast: ") + str(obj.warehouse_forecast) + \ - _("\n Initial Stock: ") + str(obj.stock_start) + \ - _("\n Planned Out: ") + str(obj.planned_outgoing) + _(" Planned In: ") + str(obj.to_procure) + \ - _("\n Already Out: ") + str(obj.already_out) + _(" Already In: ") + str(obj.already_in) + \ - _("\n Confirmed Out: ") + str(obj.outgoing) + _(" Confirmed In: ") + str(obj.incoming) + \ - _("\n Planned Out Before: ") + str(obj.outgoing_before) + _(" Confirmed In Before: ") + \ - str(obj.incoming_before) + \ - _("\n Expected Out: ") + str(obj.outgoing_left) + _(" Incoming Left: ") + str(obj.incoming_left) + \ - _("\n Stock Simulation: ") + str(obj.stock_simulation) + _(" Minimum stock: ") + str(obj.minimum_op), - + 'note' : _(' Procurement created in MPS by user: %s Creation Date: %s \ + \n For period: %s \ + \n according to state: \ + \n Warehouse Forecast: %s \ + \n Initial Stock: %s \ + \n Planned Out: %s Planned In: %s \ + \n Already Out: %s Already In: %s \ + \n Confirmed Out: %s Confirmed In: %s \ + \n Planned Out Before: %s Confirmed In Before: %s \ + \n Expected Out: %s Incoming Left: %s \ + \n Stock Simulation: %s Minimum stock: %s') %(user.login, time.strftime('%Y-%m-%d %H:%M:%S'), + obj.period_id.name, obj.warehouse_forecast, obj.planned_outgoing, obj.stock_start, obj.to_procure, + obj.already_out, obj.already_in, obj.outgoing, obj.incoming, obj.outgoing_before, obj.incoming_before, + obj.outgoing_left, obj.incoming_left, obj.stock_simulation, obj.minimum_op) }, context=context) wf_service = netsvc.LocalService("workflow") wf_service.trg_validate(uid, 'procurement.order', proc_id, 'button_confirm', cr) self.calculate_planning(cr, uid, ids, context) prev_text = obj.history or "" self.write(cr, uid, ids, { - 'history' : prev_text + _('Requisition (') + str(user.login) + ", " + time.strftime('%Y.%m.%d %H:%M) ') + str(obj.incoming_left) + \ - " " + obj.product_uom.name + "\n", + 'history': _('%s Requisition (%s, %s) %s %s \n') % (prev_text, user.login, time.strftime('%Y.%m.%d %H:%M'), + obj.incoming_left, obj.product_uom.name) }) + return True def internal_supply(self, cr, uid, ids, context, *args): - for obj in self.browse(cr, uid, ids): + for obj in self.browse(cr, uid, ids, context=context): if obj.incoming_left <= 0: raise osv.except_osv(_('Error !'), _('Incoming Left must be greater than 0 !')) if not obj.supply_warehouse_id: @@ -946,32 +670,34 @@ class stock_planning(osv.osv): uom_qty, uom, uos_qty, uos = self._qty_to_standard(cr, uid, obj, context) user = self.pool.get('res.users').browse(cr, uid, uid, context) picking_id = self.pool.get('stock.picking').create(cr, uid, { - 'origin': _('MPS(') + str(user.login) +') '+ obj.period_id.name, - 'type': 'internal', - 'state': 'auto', - 'date' : obj.period_id.date_start, - 'move_type': 'direct', - 'invoice_state': 'none', - 'company_id': obj.company_id.id, - 'note': _("Pick created from MPS by user: ") + str(user.login) + _(" Creation Date: ") + \ - time.strftime('%Y-%m-%d %H:%M:%S') + \ - _("\nFor period: ") + obj.period_id.name + _(" according to state:") + \ - _("\n Warehouse Forecast: ") + str(obj.warehouse_forecast) + \ - _("\n Initial Stock: ") + str(obj.stock_start) + \ - _("\n Planned Out: ") + str(obj.planned_outgoing) + _(" Planned In: ") + str(obj.to_procure) + \ - _("\n Already Out: ") + str(obj.already_out) + _(" Already In: ") + str(obj.already_in) + \ - _("\n Confirmed Out: ") + str(obj.outgoing) + _(" Confirmed In: ") + str(obj.incoming) + \ - _("\n Planned Out Before: ") + str(obj.outgoing_before) + _(" Confirmed In Before: ") + \ - str(obj.incoming_before) + \ - _("\n Expected Out: ") + str(obj.outgoing_left) + _(" Incoming Left: ") + str(obj.incoming_left) + \ - _("\n Stock Simulation: ") + str(obj.stock_simulation) + _(" Minimum stock: ") + str(obj.minimum_op), + 'origin': _('MPS(%s) %s') %(user.login, obj.period_id.name), + 'type': 'internal', + 'state': 'auto', + 'date': obj.period_id.date_start, + 'move_type': 'direct', + 'invoice_state': 'none', + 'company_id': obj.company_id.id, + 'note': _('Pick created from MPS by user: %s Creation Date: %s \ + \nFor period: %s according to state: \ + \n Warehouse Forecast: %s \ + \n Initial Stock: %s \ + \n Planned Out: %s Planned In: %s \ + \n Already Out: %s Already In: %s \ + \n Confirmed Out: %s Confirmed In: %s \ + \n Planned Out Before: %s Confirmed In Before: %s \ + \n Expected Out: %s Incoming Left: %s \ + \n Stock Simulation: %s Minimum stock: %s ') + % (user.login, time.strftime('%Y-%m-%d %H:%M:%S'), obj.period_id.name, obj.warehouse_forecast, + obj.stock_start, obj.planned_outgoing, obj.to_procure, obj.already_out, obj.already_in, + obj.outgoing, obj.incoming, obj.outgoing_before, obj.incoming_before, + obj.outgoing_left, obj.incoming_left, obj.stock_simulation, obj.minimum_op) }) move_id = self.pool.get('stock.move').create(cr, uid, { - 'name': _('MPS(') + str(user.login) +') '+ obj.period_id.name, + 'name': _('MPS(%s) %s') %(user.login, obj.period_id.name), 'picking_id': picking_id, 'product_id': obj.product_id.id, - 'date_planned': obj.period_id.date_start, + 'date': obj.period_id.date_start, 'product_qty': uom_qty, 'product_uom': uom, 'product_uos_qty': uos_qty, @@ -990,14 +716,14 @@ class stock_planning(osv.osv): prev_text = obj.history or "" pick_name = self.pool.get('stock.picking').browse(cr, uid, picking_id).name self.write(cr, uid, ids, { - 'history' : prev_text + _('Pick List ')+ pick_name + " (" + str(user.login) + ", " + time.strftime('%Y.%m.%d %H:%M) ') \ - + str(obj.incoming_left) +" " + obj.product_uom.name + "\n", + 'history': _('%s Pick List %s (%s, %s) %s %s \n') % (prev_text, pick_name, user.login, time.strftime('%Y.%m.%d %H:%M'), + obj.incoming_left, obj.product_uom.name) }) return True - + def product_id_change(self, cr, uid, ids, product_id): - ret={} + ret = {} if product_id: product_rec = self.pool.get('product.product').browse(cr, uid, product_id) ret['product_uom'] = product_rec.uom_id.id