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

                    if not move.prodlot_id and move.product_qty:

                    if not move.prodlot_id and move.product_qty:

                

        # quantities are set to False

        result.setdefault('value', {}).update({'product_qty': 0.00,

                                               'product_uos_qty': 0.00,

                                               })

    

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

        """ Checks if production lot is assigned to stock move or not.

        @return: True or False

        """

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

            if not move.prodlot_id and move.product_qty and \

               (move.state == 'done' and \

               ( \

                   (move.product_id.track_production and move.location_id.usage == 'production') or \

                   (move.product_id.track_production and move.location_dest_id.usage == 'production') or \

                   (move.product_id.track_incoming and move.location_id.usage == 'supplier') or \

                   (move.product_id.track_outgoing and move.location_dest_id.usage == 'customer') \

               )):

                return False

        return True

                     (_check_tracking,

                      'You must assign a production lot for this product',

                      ['prodlot_id']),

 

    def _stock_search_virtual(self, cr, uid, obj, name, args, context=None):

        """ Searches Ids of products

        @return: Ids of locations

        """

        if context is None:

            context = {}

        # when the location_id = False results now in showing stock for all internal locations

        # *previously*, was showing the location of no location (= 0.0 for all prodlot)

        if 'location_id' not in context or not context['location_id']:

            locations = self.pool.get('stock.location').search(cr, uid, [('usage', '=', 'internal')], context=context)

        else:

            locations = context['location_id'] and [context['location_id']] or []

        

        ids = [('id', 'in', [])]

        if locations:

            cr.execute('''select

                    prodlot_id,

                    sum(qty)

                from

                    stock_report_prodlots_virtual

                where

                    location_id IN %s group by prodlot_id

                having  sum(qty) '''+ str(args[0][1]) + str(args[0][2]),(tuple(locations),))

            res = cr.fetchall()

            ids = [('id', 'in', map(lambda x: x[0], res))]

        return ids

    def _stock_search(self, cr, uid, obj, name, args, context=None):

        '''

        call super method, as fields.function does not work with inheritance

        '''

        return super(stock_production_lot, self)._stock_search(cr, uid, obj, name, args, context=context)

 

    def _get_stock_virtual(self, cr, uid, ids, field_name, arg, context=None):

        # when the location_id = False results now in showing stock for all internal locations

        # *previously*, was showing the location of no location (= 0.0 for all prodlot)

        if 'location_id' not in context or not context['location_id']:

            locations = self.pool.get('stock.location').search(cr, uid, [('usage', '=', 'internal')], context=context)

        else:

            locations = context['location_id'] and [context['location_id']] or []

 

 

        res = {}.fromkeys(ids, 0.0)

        if locations:

            cr.execute('''select

                    prodlot_id,

                    sum(qty)

                from

                    stock_report_prodlots_virtual

                where

                    location_id IN %s and prodlot_id IN %s group by prodlot_id''',(tuple(locations),tuple(ids),))

            res.update(dict(cr.fetchall()))

 

        return res

    

    def _get_stock(self, cr, uid, ids, field_name, arg, context=None):

        '''

        call super method, as fields.function does not work with inheritance

        '''

        return super(stock_production_lot, self)._get_stock(cr, uid, ids, field_name, arg, context=context)

                'stock_virtual': fields.function(_get_stock_virtual, method=True, type="float", string="Available Stock", select=True,

                                                 help="Current available quantity of products with this Production Lot Number in company warehouses",

                                                 digits_compute=dp.get_precision('Product UoM'), readonly=True,

                                                 fnct_search=_stock_search_virtual,),

                'stock_available': fields.function(_get_stock, fnct_search=_stock_search, method=True, type="float", string="Real Stock", select=True,

                                                   help="Current real quantity of products with this Production Lot Number in company warehouses",

                                                   digits_compute=dp.get_precision('Product UoM')),

class stock_location(osv.osv):

    '''

    override stock location to add:

    - stock_real

    - stock_virtual

    '''

    _inherit = 'stock.location'

    

    def replace_field_key(self, fieldsDic, search, replace):

        '''

        will replace 'stock_real' by 'stock_real_specific'

        and 'stock_virtual' by 'stock_virtual_specific'

        

        and return a new dictionary

        '''

        return dict((replace if key == search else key, (self.replace_field_key(value, search, replace) if isinstance(value, dict) else value)) for key, value in fieldsDic.items())

    

    def _product_value_specific_rules(self, cr, uid, ids, field_names, arg, context=None):

        '''

        add two fields for custom stock computation, if no product selected, both stock are set to 0.0

        '''

        if context is None:

            context = {}

        # initialize data

        result = {}

        for id in ids:

            result[id] = {}

            for f in field_names:

                result[id].update({f: False,})

        # if product is set to False, it does not make sense to return a stock value, return False for each location

        if 'product_id' in context and not context['product_id']:

            return result

        

        result = super(stock_location, self)._product_value(cr, uid, ids, ['stock_real', 'stock_virtual'], arg, context=context)

        # replace stock real

        result = self.replace_field_key(result, 'stock_real', 'stock_real_specific')

        # replace stock virtual

        result = self.replace_field_key(result, 'stock_virtual', 'stock_virtual_specific')

        return result

    

    def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):

        """

        display the modified stock values (stock_real_specific, stock_virtual_specific) if needed

        """

        if context is None:

            context = {}

        # warehouse wizards or inventory screen

        if view_type == 'tree' and context.get('specific_rules_tree_view', False):

            view = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'specific_rules', 'view_location_tree2')

            if view:

                view_id = view[1]

        result = super(osv.osv, self).fields_view_get(cr, uid, view_id, view_type, context=context, toolbar=toolbar, submenu=submenu)

        return result

    

    _columns = {'stock_real_specific': fields.function(_product_value_specific_rules, method=True, type='float', string='Real Stock', multi="get_vals_specific_rules"),

                'stock_virtual_specific': fields.function(_product_value_specific_rules, method=True, type='float', string='Virtual Stock', multi="get_vals_specific_rules"),

                }

    

stock_location()

 

 

    def common_on_change(self, cr, uid, ids, location_id, product, prod_lot_id, uom=False, to_date=False, result=None):

        '''

        commmon qty computation

        '''

        if result is None:

            result = {}

        if not product:

            return result

        product_obj = self.pool.get('product.product').browse(cr, uid, product)

        uom = uom or product_obj.uom_id.id

        stock_context = {'uom': uom, 'to_date': to_date,

                         'prodlot_id':prod_lot_id,}

        if location_id:

            # if a location is specified, we do not list the children locations, otherwise yes

            stock_context.update({'compute_child': False,})

        amount = self.pool.get('stock.location')._product_get(cr, uid, location_id, [product], stock_context)[product]

        result.setdefault('value', {}).update({'product_qty': amount, 'product_uom': uom})

        return result

    

    def change_lot(self, cr, uid, ids, location_id, product, prod_lot_id, uom=False, to_date=False,):

        # reset expiry date or fill it

            result['value'].update(expiry_date=prodlot_obj.browse(cr, uid, prod_lot_id).life_date)

        # compute qty

        result = self.common_on_change(cr, uid, ids, location_id, product, prod_lot_id, uom, to_date, result=result)

        return result

    

    def on_change_location_id(self, cr, uid, ids, location_id, product, prod_lot_id, uom=False, to_date=False,):

        """ Changes UoM and name if product_id changes.

        @param location_id: Location id

        @param product: Changed product_id

        @param uom: UoM product

        @return:  Dictionary of changed values

        """

        result = {}

        if not product:

            # do nothing

            result.setdefault('value', {}).update({'product_qty': 0.0,})

            return result

        # compute qty

        result = self.common_on_change(cr, uid, ids, location_id, product, prod_lot_id, uom, to_date, result=result)

        return result

    

    def on_change_product_id_specific_rules(self, cr, uid, ids, location_id, product, prod_lot_id, uom=False, to_date=False,):

        '''

        the product changes, set the hidden flag if necessary

        '''

        result = super(stock_inventory_line, self).on_change_product_id(cr, uid, ids, location_id, product, uom, to_date)

        # product changes, prodlot is always cleared

        result.setdefault('value', {})['prod_lot_id'] = False

        result.setdefault('value', {})['expiry_date'] = False

        # reset the hidden flags

        result.setdefault('value', {})['hidden_batch_management_mandatory'] = False

        result.setdefault('value', {})['hidden_perishable_mandatory'] = False

        if product:

            product_obj = self.pool.get('product.product').browse(cr, uid, product)

            if product_obj.batch_management:

                result.setdefault('value', {})['hidden_batch_management_mandatory'] = True

            elif product_obj.perishable:

                result.setdefault('value', {})['hidden_perishable_mandatory'] = True

            # if not product, result is 0.0 by super

            # compute qty

            result = self.common_on_change(cr, uid, ids, location_id, product, prod_lot_id, uom, to_date, result=result)

        return result

    

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

        '''

        complete info normally generated by javascript on_change function

        '''

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

        if vals.get('product_id', False):

            # complete hidden flags - needed if not created from GUI

            product = prod_obj.browse(cr, uid, vals.get('product_id'), context=context)

            if product.batch_management:

                vals.update(hidden_batch_management_mandatory=True)

            elif product.perishable:

                vals.update(hidden_perishable_mandatory=True)

            else:

                vals.update(hidden_batch_management_mandatory=False,

                            hidden_perishable_mandatory=False,

                            )

        # complete expiry date from production lot - needed if not created from GUI

        prodlot_obj = self.pool.get('stock.production.lot')

        if vals.get('prod_lot_id', False):

            vals.update(expiry_date=prodlot_obj.browse(cr, uid, vals.get('prod_lot_id'), context=context).life_date)

        # call super

        result = super(stock_inventory_line, self).create(cr, uid, vals, context=context)

        return result

    

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

        '''

        complete info normally generated by javascript on_change function

        '''

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

        if vals.get('product_id', False):

            # complete hidden flags - needed if not created from GUI

            product = prod_obj.browse(cr, uid, vals.get('product_id'), context=context)

            if product.batch_management:

                vals.update(hidden_batch_management_mandatory=True)

            elif product.perishable:

                vals.update(hidden_perishable_mandatory=True)

            else:

                vals.update(hidden_batch_management_mandatory=False,

                            hidden_perishable_mandatory=False,

                            )

        # complete expiry date from production lot - needed if not created from GUI

        prodlot_obj = self.pool.get('stock.production.lot')

        if vals.get('prod_lot_id', False):

            vals.update(expiry_date=prodlot_obj.browse(cr, uid, vals.get('prod_lot_id'), context=context).life_date)

        # call super

        result = super(stock_inventory_line, self).write(cr, uid, ids, vals, context=context)