~matjaz-6/openerpsl/openerpsl_01_25

# -*- coding: utf-8 -*-

##############################################################################

#

#    OpenERP, Open Source Management Solution

#    Copyright (C) 2013 Mentis d.o.o. (<http://www.mentis.si/openerp>)

#

#    This program is free software: you can redistribute it and/or modify

#    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 Affero General Public License for more details.

#

#    You should have received a copy of the GNU Affero General Public License

#    along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

##############################################################################

 

from osv import fields, osv

from tools.translate import _

from datetime import datetime

import time

import openerp.addons.decimal_precision as dp

 

class account_product_cost_recalculation(osv.osv_memory):

    _name="account.product.cost.recalculation"

    _description="Recalculate Product Costs"

    

    _columns={

        'calculation_type': fields.selection([('average','Average Price'),('weighted','Weighted Average Price')], 'Calculation Type', required=True,

            help="Average price: The cost is recomputed accoring to each incoming shipment. \nWeighted Average Price: The cost price is recalculated for whole period."),

        'period_id': fields.many2one('account.period', "Period", required=False, 

            help="Period for which recalculation will be done. If not set recalculation will be done for whole fiscal year."),

        'product_id': fields.many2one('product.product', "Product", domain=[('cost_method','=','average')], required=False,

            help="Product for which recalculation will be done. If not set recalculation will be done for all products with cost method set 'Average Price'"),

        'method': fields.selection([('cr','SQL statements'),('orm','ORM methods')], 'Calculation Method', required=True)

    }

    _defaults={

        'calculation_type': 'weighted',

        'period_id': False,

        'product_id': False,

        'method': 'cr'

    }

    

    def _do_recalculation(self, cr, uid, ids, context=None):

        print datetime.now()

        

        _recalc_id = self.browse(cr, uid, ids[0], context)

        _period_id = False

        _dates = {}

 

        # najdem ustrezna obdobja

        if _recalc_id.period_id:

            _period_id = _recalc_id.period_id

        else:

            _period_obj = self.pool.get('account.period').find(cr, uid)

            if _period_obj:

                _period_id = self.pool.get('account.period').browse(cr, uid, _period_obj[0])

 

        if not _period_id:

            raise osv.except_osv(_('Error!'), _('Cannot find suitable dates for recalculation.'))

        

        _year_start = _period_id.fiscalyear_id.date_start

        _date_from = _period_id.date_start

        _date_to = _period_id.date_stop

            

        # najdem ustrezne izdelke

        _product_ids = []

        

        if _recalc_id.product_id:

            _product_ids.append(_recalc_id.product_id.id)

        else:

            cr.execute("""SELECT sm.product_id AS id

                            FROM stock_move AS sm

                                 INNER JOIN product_template AS pt ON pt.id = sm.product_id

                                                                      AND pt.cost_method = 'average'

                                 INNER JOIN stock_location AS sl_src ON sl_src.id = sm.location_id

                                                                        AND sl_src.usage = 'internal'

                                 INNER JOIN stock_location AS sl_dest ON sl_dest.id = sm.location_dest_id

                                                                         AND sl_dest.usage <> 'internal'

                           WHERE sm.date >= %s 

                                 AND sm.date <= %s

                        GROUP BY sm.product_id

                        ORDER BY sm.product_id""", (_date_from, _date_to))

            _products_tup = cr.fetchall()

            for _tup in _products_tup:

                _product_ids.append(_tup[0])

 

        # preračunam posamezen izdelek

        _products = self.pool.get('product.product').browse(cr, uid, _product_ids, context)

        for _product in _products:

            

            # izračunam začetno zalogo in ceno

            _dates['date_from'] = _year_start

            _dates['date_to'] = _date_from

            _start_stock, _start_cost = _product._get_stock_and_cost(_dates)

            if _start_stock == 0.0:

                _start_cost = 0.0

 

            # izračunam povprečno ceno za obdobje

            _dates['date_from'] = _date_from

            _dates['date_to'] = _date_to

            _period_stock, _period_cost = _product._get_purchase_amount_and_cost(_dates)

 

            # izračunam skupno vrednost zaloge konec obdobja

            _end_period_stock = _start_stock + _period_stock

            _end_period_cost = (_start_stock * _start_cost) + _period_cost

 

            # izračunam povprečno ceno za obdobje

            _period_average = False

            if _end_period_stock and _end_period_stock <> 0:

                _period_average = _end_period_cost / _end_period_stock

 

            # posodobim vrednosti prodaje na povprečno ceno za obdobje

            if _period_average and _period_average <> 0:

                if _recalc_id.method == 'orm':

                    _product._set_period_cost_orm(_dates, _period_average)

                else:

                    _product._set_period_cost_cr(_dates, _period_average)

 

        print datetime.now()

 

        return True

    

    def execute(self, cr, uid, ids, context=None):

        if context is None:

            context = {}

        if self._do_recalculation(cr, uid, ids, context):

            return {'type': 'ir.actions.act_window_close'}

        else:

            return False

 

 

account_product_cost_recalculation()