~unifield-team/unifield-wm/us-826

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

#

#    OpenERP, Open Source Management Solution

#    Copyright (C) 2011 TeMPO Consulting, MSF

#

#    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 datetime import datetime

from dateutil.relativedelta import relativedelta

import time

from operator import itemgetter

from itertools import groupby

from osv import fields, osv

from tools.translate import _

import netsvc

import tools

import decimal_precision as dp

import logging

from os import path

#----------------------------------------------------------

# Procurement Order

#----------------------------------------------------------

class procurement_order(osv.osv):

    _name = 'procurement.order'

    _inherit = 'procurement.order'

    def create(self, cr, uid, vals, context=None):

        '''

        create method for filling flag from yml tests

        '''

        if context is None:

            context = {}

        if context.get('update_mode') in ['init', 'update'] and 'from_yml_test' not in vals:

            logging.getLogger('init').info('PRO: set from yml test to True')

            vals['from_yml_test'] = True

        return super(procurement_order, self).create(cr, uid, vals, context=context)

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

        """ Confirms procurement and writes exception message if any.

        @return: True

        """

        move_obj = self.pool.get('stock.move')

        for procurement in self.browse(cr, uid, ids, context=context):

            if procurement.product_qty <= 0.00:

                raise osv.except_osv(_('Data Insufficient !'),

                    _('Please check the Quantity in Procurement Order(s), it should not be less than 1!'))

            if procurement.product_id.type in ('product', 'consu'):

                if not procurement.move_id:

                    source = procurement.location_id.id

                    reason_type_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'reason_types_moves', 'reason_type_other')[1]

                    if procurement.procure_method == 'make_to_order':

                        reason_type_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'reason_types_moves', 'reason_type_external_supply')[1]

                        source = procurement.product_id.product_tmpl_id.property_stock_procurement.id

                    id = move_obj.create(cr, uid, {

                        'name': procurement.name,

                        'location_id': source,

                        'location_dest_id': procurement.location_id.id,

                        'product_id': procurement.product_id.id,

                        'product_qty': procurement.product_qty,

                        'product_uom': procurement.product_uom.id,

                        'date_expected': procurement.date_planned,

                        'state': 'draft',

                        'company_id': procurement.company_id.id,

                        'auto_validate': True,

                        'reason_type_id': reason_type_id,

                    })

                    move_obj.action_confirm(cr, uid, [id], context=context)

                    self.write(cr, uid, [procurement.id], {'move_id': id, 'close_move': 1})

        self.write(cr, uid, ids, {'state': 'confirmed', 'message': ''})

        return True

    def copy_data(self, cr, uid, id, default=None, context=None):

        '''

        reset link to purchase order from update of on order purchase order

        '''

        if not default:

            default = {}

        default.update({'so_back_update_dest_po_id_procurement_order': False,

                        'so_back_update_dest_pol_id_procurement_order': False})

        return super(procurement_order, self).copy_data(cr, uid, id, default, context=context)

    _columns = {'from_yml_test': fields.boolean('Only used to pass addons unit test', readonly=True, help='Never set this field to true !'),

                # this field is used when the po is modified during on order process, and the so must be modified accordingly

                # the resulting new purchase order line will be merged in specified po_id 

                'so_back_update_dest_po_id_procurement_order': fields.many2one('purchase.order', string='Destination of new purchase order line', readonly=True),

                'so_back_update_dest_pol_id_procurement_order': fields.many2one('purchase.order.line', string='Original purchase order line', readonly=True),

                }

    _defaults = {'from_yml_test': lambda *a: False,

                 }

procurement_order()

#----------------------------------------------------------

# Stock Picking

#----------------------------------------------------------

class stock_picking(osv.osv):

    _inherit = "stock.picking"

    _description = "Picking List"

    def _hook_state_list(self, cr, uid, *args, **kwargs):

        '''

        Change terms into states list

        '''

        state_list = kwargs['state_list']

        state_list['done'] = _('is closed.')

        return state_list

    _columns = {

        'state': fields.selection([

            ('draft', 'Draft'),

            ('auto', 'Waiting'),

            ('confirmed', 'Confirmed'),

            ('assigned', 'Available'),

            ('done', 'Closed'),

            ('cancel', 'Cancelled'),

            ], 'State', readonly=True, select=True,

            help="* Draft: not confirmed yet and will not be scheduled until confirmed\n"\

                 "* Confirmed: still waiting for the availability of products\n"\

                 "* Available: products reserved, simply waiting for confirmation.\n"\

                 "* Waiting: waiting for another move to proceed before it becomes automatically available (e.g. in Make-To-Order flows)\n"\

                 "* Closed: has been processed, can't be modified or cancelled anymore\n"\

                 "* Cancelled: has been cancelled, can't be confirmed anymore"),

        'from_yml_test': fields.boolean('Only used to pass addons unit test', readonly=True, help='Never set this field to true !'),

        'address_id': fields.many2one('res.partner.address', 'Delivery address', help="Address of partner", readonly=False, states={'done': [('readonly', True)], 'cancel': [('readonly', True)]}, domain="[('partner_id', '=', partner_id)]"),

        'partner_id2': fields.many2one('res.partner', 'Partner', required=False),

        'from_wkf': fields.boolean('From wkf'),

    }

    _defaults = {'from_yml_test': lambda *a: False,

                'from_wkf': lambda *a: False,

                 }

    def create(self, cr, uid, vals, context=None):

        '''

        create method for filling flag from yml tests

        '''

        if context is None:

            context = {}

        if not context.get('active_id',False):

            vals['from_wkf'] = True

        # in case me make a copy of a stock.picking coming from a workflow

        if context.get('not_workflow', False):

            vals['from_wkf'] = False

        if context.get('update_mode') in ['init', 'update'] and 'from_yml_test' not in vals:

            logging.getLogger('init').info('PICKING: set from yml test to True')

            vals['from_yml_test'] = True

        if not vals.get('partner_id2') and vals.get('address_id'):

            addr = self.pool.get('res.partner.address').browse(cr, uid, vals.get('address_id'), context=context)

            vals['partner_id2'] = addr.partner_id and addr.partner_id.id or False

        if not vals.get('address_id') and vals.get('partner_id2'):

            addr = self.pool.get('res.partner').address_get(cr, uid, vals.get('partner_id2'), ['delivery', 'default'])

            if not addr.get('delivery'):

                vals['address_id'] = addr.get('default')

            else:

                vals['address_id'] = addr.get('delivery')

        return super(stock_picking, self).create(cr, uid, vals, context=context)

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

        '''

        Update the partner or the address according to the other

        '''

        if not vals.get('address_id') and vals.get('partner_id2'):

            for pick in self.browse(cr, uid, ids, context=context):

                if pick.partner_id.id != vals.get('partner_id2'):

                    addr = self.pool.get('res.partner').address_get(cr, uid, vals.get('partner_id2'), ['delivery', 'default'])

                    if not addr.get('delivery'):

                        vals['address_id'] = addr.get('default')

                    else:

                        vals['address_id'] = addr.get('delivery')

        if not vals.get('partner_id2') and vals.get('address_id'):

            for pick in self.browse(cr, uid, ids, context=context):

                if pick.address_id.id != vals.get('address_id'):

                    addr = self.pool.get('res.partner.address').browse(cr, uid, vals.get('address_id'), context=context)

                    vals['partner_id2'] = addr.partner_id and addr.partner_id.id or False

        return super(stock_picking, self).write(cr, uid, ids, vals, context=context)

    def on_change_partner(self, cr, uid, ids, partner_id, address_id, context=None):

        '''

        Change the delivery address when the partner change.

        '''

        v = {}

        d = {}

        if not partner_id:

            v.update({'address_id': False})

        else:

            d.update({'address_id': [('partner_id', '=', partner_id)]})

        if address_id:

            addr = self.pool.get('res.partner.address').browse(cr, uid, address_id, context=context)

        if not address_id or addr.partner_id.id != partner_id:

            addr = self.pool.get('res.partner').address_get(cr, uid, partner_id, ['delivery', 'default'])

            if not addr.get('delivery'):

                addr = addr.get('default')

            else:

                addr = addr.get('delivery')

            v.update({'address_id': addr})

        return {'value': v,

                'domain': d}

    def set_manually_done(self, cr, uid, ids, all_doc=True, context=None):

        '''

        Set the picking to done

        '''

        move_ids = []

        if isinstance(ids, (int, long)):

            ids = [ids]

        for pick in self.browse(cr, uid, ids, context=context):

            for move in pick.move_lines:

                if move.state not in ('cancel', 'done'):

                    move_ids.append(move.id)

        #Set all stock moves to done

        self.pool.get('stock.move').set_manually_done(cr, uid, move_ids, all_doc=all_doc, context=context)

        return True

    def _do_partial_hook(self, cr, uid, ids, context=None, *args, **kwargs):

        '''

        Please copy this to your module's method also.

        This hook belongs to the do_partial method from stock_override>stock.py>stock_picking

        - allow to modify the defaults data for move creation and copy

        '''

        defaults = kwargs.get('defaults')

        assert defaults is not None, 'missing defaults'

        return defaults

    def _picking_done_cond(self, cr, uid, ids, context=None, *args, **kwargs):

        '''

        Please copy this to your module's method also.

        This hook belongs to the do_partial method from stock_override>stock.py>stock_picking

        - allow to conditionally execute the picking processing to done

        '''

        return True

    def _custom_code(self, cr, uid, ids, context=None, *args, **kwargs):

        '''

        Please copy this to your module's method also.

        This hook belongs to the do_partial method from stock_override>stock.py>stock_picking

        - allow to execute specific custom code before processing picking to done

        - no supposed to modify partial_datas

        '''

        return True

    # @@@override stock>stock.py>stock_picking>do_partial

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

        """ Makes partial picking and moves done.

        @param partial_datas : Dictionary containing details of partial picking

                          like partner_id, address_id, delivery_date,

                          delivery moves with product_id, product_qty, uom

        @return: Dictionary of values

        """

        if context is None:

            context = {}

        else:

            context = dict(context)

        res = {}

        move_obj = self.pool.get('stock.move')

        product_obj = self.pool.get('product.product')

        currency_obj = self.pool.get('res.currency')

        uom_obj = self.pool.get('product.uom')

        sequence_obj = self.pool.get('ir.sequence')

        wf_service = netsvc.LocalService("workflow")

        internal_loc_ids = self.pool.get('stock.location').search(cr, uid, [('usage','=','internal'), ('cross_docking_location_ok', '=', False)])

        ctx_avg = context.copy()

        ctx_avg['location'] = internal_loc_ids

        for pick in self.browse(cr, uid, ids, context=context):

            new_picking = None

            complete, too_many, too_few , not_aval = [], [], [], []

            move_product_qty = {}

            prodlot_ids = {}

            product_avail = {}

            for move in pick.move_lines:

                if move.state in ('done', 'cancel'):

                    continue

                elif move.state in ('confirmed'):

                    not_aval.append(move)

                    continue

                partial_data = partial_datas.get('move%s'%(move.id), {})

                #Commented in order to process the less number of stock moves from partial picking wizard

                #assert partial_data, _('Missing partial picking data for move #%s') % (move.id)

                product_qty = partial_data.get('product_qty') or 0.0

                move_product_qty[move.id] = product_qty

                product_uom = partial_data.get('product_uom') or False

                product_price = partial_data.get('product_price') or 0.0

                product_currency = partial_data.get('product_currency') or False

                prodlot_id = partial_data.get('prodlot_id') or False

                prodlot_ids[move.id] = prodlot_id

                if move.product_qty == product_qty:

                    complete.append(move)

                elif move.product_qty > product_qty:

                    too_few.append(move)

                else:

                    too_many.append(move)

                # Average price computation

                if (pick.type == 'in') and (move.product_id.cost_method == 'average') and not move.location_dest_id.cross_docking_location_ok:

                    product = product_obj.browse(cr, uid, move.product_id.id, context=ctx_avg)

                    move_currency_id = move.company_id.currency_id.id

                    context['currency_id'] = move_currency_id

                    qty = uom_obj._compute_qty(cr, uid, product_uom, product_qty, product.uom_id.id)

                    if product.id in product_avail:

                        product_avail[product.id] += qty

                    else:

                        product_avail[product.id] = product.qty_available

                    if qty > 0:

                        new_price = currency_obj.compute(cr, uid, product_currency,

                                move_currency_id, product_price)

                        new_price = uom_obj._compute_price(cr, uid, product_uom, new_price,

                                product.uom_id.id)

                        if product.qty_available <= 0:

                            new_std_price = new_price

                        else:

                            # Get the standard price

                            amount_unit = product.price_get('standard_price', context)[product.id]

                            new_std_price = ((amount_unit * product_avail[product.id])\

                                + (new_price * qty))/(product_avail[product.id] + qty)

                        # Write the field according to price type field

                        product_obj.write(cr, uid, [product.id], {'standard_price': new_std_price})

                        # Record the values that were chosen in the wizard, so they can be

                        # used for inventory valuation if real-time valuation is enabled.

                        move_obj.write(cr, uid, [move.id],

                                {'price_unit': product_price,

                                 'price_currency_id': product_currency})

            for move in not_aval:

                if not new_picking:

                    new_picking = self.copy(cr, uid, pick.id,

                            {

                                'name': sequence_obj.get(cr, uid, 'stock.picking.%s'%(pick.type)),

                                'move_lines' : [],

                                'state':'draft',

                            })

            for move in too_few:

                product_qty = move_product_qty[move.id]

                if not new_picking:

                    new_picking = self.copy(cr, uid, pick.id,

                            {

                                'name': sequence_obj.get(cr, uid, 'stock.picking.%s'%(pick.type)),

                                'move_lines' : [],

                                'state':'draft',

                            })

                if product_qty != 0:

                    defaults = {

                            'product_qty' : product_qty,

                            'product_uos_qty': product_qty, #TODO: put correct uos_qty

                            'picking_id' : new_picking,

                            'state': 'assigned',

                            'move_dest_id': False,

                            'price_unit': move.price_unit,

                    }

                    prodlot_id = prodlot_ids[move.id]

                    if prodlot_id:

                        defaults.update(prodlot_id=prodlot_id)

                    # override : call to hook added

                    defaults = self._do_partial_hook(cr, uid, ids, context, move=move, partial_datas=partial_datas, defaults=defaults)

                    move_obj.copy(cr, uid, move.id, defaults)

                move_obj.write(cr, uid, [move.id],

                        {

                            'product_qty' : move.product_qty - product_qty,

                            'product_uos_qty':move.product_qty - product_qty, #TODO: put correct uos_qty

                        })

            if new_picking:

                move_obj.write(cr, uid, [c.id for c in complete], {'picking_id': new_picking})

            for move in complete:

                # override : refactoring

                defaults = {}

                prodlot_id = prodlot_ids.get(move.id)

                if prodlot_id:

                    defaults.update(prodlot_id=prodlot_id)

                defaults = self._do_partial_hook(cr, uid, ids, context, move=move, partial_datas=partial_datas, defaults=defaults)

                move_obj.write(cr, uid, [move.id], defaults)

                # override : end

            for move in too_many:

                product_qty = move_product_qty[move.id]

                defaults = {

                    'product_qty' : product_qty,

                    'product_uos_qty': product_qty, #TODO: put correct uos_qty

                }

                prodlot_id = prodlot_ids.get(move.id)

                if prodlot_ids.get(move.id):

                    defaults.update(prodlot_id=prodlot_id)

                if new_picking:

                    defaults.update(picking_id=new_picking)

                # override : call to hook added

                defaults = self._do_partial_hook(cr, uid, ids, context, move=move, partial_datas=partial_datas, defaults=defaults)

                move_obj.write(cr, uid, [move.id], defaults)

            # At first we confirm the new picking (if necessary)

            if new_picking:

                self.write(cr, uid, [pick.id], {'backorder_id': new_picking})

                # custom code execution

                self._custom_code(cr, uid, ids, context=context, partial_datas=partial_datas, concerned_picking=self.browse(cr, uid, new_picking, context=context))

                # we confirm the new picking after its name was possibly modified by custom code - so the link message (top message) is correct

                wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_confirm', cr)

                # Then we finish the good picking

                if self._picking_done_cond(cr, uid, ids, context=context, partial_datas=partial_datas):

                    self.action_move(cr, uid, [new_picking])

                    wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_done', cr)

                wf_service.trg_write(uid, 'stock.picking', pick.id, cr)

                delivered_pack_id = new_picking

            else:

                # custom code execution

                self._custom_code(cr, uid, ids, context=context, partial_datas=partial_datas, concerned_picking=pick)

                if self._picking_done_cond(cr, uid, ids, context=context, partial_datas=partial_datas):

                    self.action_move(cr, uid, [pick.id])

                    wf_service.trg_validate(uid, 'stock.picking', pick.id, 'button_done', cr)

                delivered_pack_id = pick.id

            delivered_pack = self.browse(cr, uid, delivered_pack_id, context=context)

            res[pick.id] = {'delivered_picking': delivered_pack.id or False}

        return res

    # @@@override end

    # @@@override stock>stock.py>stock_picking>_get_invoice_type

    def _get_invoice_type(self, pick):

        src_usage = dest_usage = None

        inv_type = None

        if pick.invoice_state == '2binvoiced':

            if pick.move_lines:

                src_usage = pick.move_lines[0].location_id.usage

                dest_usage = pick.move_lines[0].location_dest_id.usage

            if pick.type == 'out' and dest_usage == 'supplier':

                inv_type = 'in_refund'

            elif pick.type == 'out' and dest_usage == 'customer':

                inv_type = 'out_invoice'

            elif (pick.type == 'in' and src_usage == 'supplier') or (pick.type == 'internal'):

                inv_type = 'in_invoice'

            elif pick.type == 'in' and src_usage == 'customer':

                inv_type = 'out_refund'

            else:

                inv_type = 'out_invoice'

        return inv_type

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

        """

        Create automatically invoice

        """

        res = super(stock_picking, self).action_done(cr, uid, ids, context=context)

        if res:

            if isinstance(ids, (int, long)):

                ids = [ids]

            for sp in self.browse(cr, uid, ids):

                # we do not create invoice for procurement_request (Internal Request)

                if not sp.sale_id.procurement_request and sp.subtype == 'standard':

                    sp_type = False

                    inv_type = self._get_invoice_type(sp)

                    if sp.type == 'in' or sp.type == 'internal':

                        if inv_type == 'out_refund':

                            sp_type = 'sale_refund'

                        else:

                            sp_type = 'purchase'

                    elif sp.type == 'out':

                        if inv_type == 'in_refund':

                            sp_type = 'purchase_refund'

                        else:

                            sp_type = 'sale'

                    # Journal type

                    journal_type = sp_type

                    # Disturb journal for invoice only on intermission partner type

                    if sp.partner_id.partner_type == 'intermission':

                        journal_type = 'intermission'

                    journal_ids = self.pool.get('account.journal').search(cr, uid, [('type', '=', journal_type),

                                                                                    ('is_current_instance', '=', True)])

                    if not journal_ids:

                        raise osv.except_osv(_('Warning'), _('No %s journal found!') % (journal_type,))

                    # Create invoice

                    self.action_invoice_create(cr, uid, [sp.id], journal_ids[0], False, inv_type, {})

        return res

    def action_invoice_create(self, cr, uid, ids, journal_id=False, group=False, type='out_invoice', context=None):

        """

        Attach an intermission journal to the Intermission Voucher IN/OUT if partner type is intermission from the picking.

        Prepare intermission voucher IN/OUT

        Change invoice purchase_list field to TRUE if this picking come from a PO which is 'purchase_list'

        """

        res = super(stock_picking, self).action_invoice_create(cr, uid, ids, journal_id, group, type, context)

        intermission_journal_ids = self.pool.get('account.journal').search(cr, uid, [('type', '=', 'intermission'),

                                                                                     ('is_current_instance', '=', True)])

        company = self.pool.get('res.users').browse(cr, uid, uid, context).company_id

        intermission_default_account = company.intermission_default_counterpart

        for pick in self.browse(cr, uid, [x for x in res]):

            # Check if PO and PO is purchase_list

            if pick.purchase_id and pick.purchase_id.order_type and pick.purchase_id.order_type == 'purchase_list':

                inv_id = res[pick.id]

                self.pool.get('account.invoice').write(cr, uid, [inv_id], {'purchase_list': True})

            # Check intermission

            if pick.partner_id.partner_type == 'intermission':

                inv_id = res[pick.id]

                if not intermission_journal_ids:

                    raise osv.except_osv(_('Error'), _('No Intermission journal found!'))

                if not intermission_default_account or not intermission_default_account.id:

                    raise osv.except_osv(_('Error'), _('Please configure a default intermission account in Company configuration.'))

                self.pool.get('account.invoice').write(cr, uid, [inv_id], {'journal_id': intermission_journal_ids[0], 

                    'is_intermission': True, 'account_id': intermission_default_account.id,})

                # Change currency for this invoice

                company_currency = company.currency_id and company.currency_id.id or False

                if not company_currency:

                    raise osv.except_osv(_('Warning'), _('No company currency found!'))

                wiz_account_change = self.pool.get('account.change.currency').create(cr, uid, {'currency_id': company_currency})

                self.pool.get('account.change.currency').change_currency(cr, uid, [wiz_account_change], context={'active_id': inv_id})

        return res

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

        """

            stock.picking: action confirm

            if INCOMING picking: confirm and check availability

        """

        super(stock_picking, self).action_confirm(cr, uid, ids, context=context)

        move_obj = self.pool.get('stock.move')

        if isinstance(ids, (int, long)):

            ids = [ids]

        for pick in self.browse(cr, uid, ids):

            if pick.move_lines and pick.type == 'in':

                not_assigned_move = [x.id for x in pick.move_lines if x.state == 'confirmed']

                if not_assigned_move:

                    move_obj.action_assign(cr, uid, not_assigned_move)

        return True

stock_picking()

# ----------------------------------------------------

# Move

# ----------------------------------------------------

#

# Fields:

#   location_dest_id is only used for predicting futur stocks

#

class stock_move(osv.osv):

    _inherit = "stock.move"

    _description = "Stock Move with hook"

    def set_manually_done(self, cr, uid, ids, all_doc=True, context=None):

        '''

        Set the stock move to manually done

        '''

        return self.write(cr, uid, ids, {'state': 'cancel'}, context=context)