OCA / OCB / 155

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

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

#

#    OpenERP, Open Source Management Solution

#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).

#

#    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/>.

#

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

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

# Incoterms

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

        'name': fields.char('Name', size=64, required=True, help="Incoterms are series of sales terms.They are used to divide transaction costs and responsibilities between buyer and seller and reflect state-of-the-art transportation practices."),

        'code': fields.char('Code', size=3, required=True, help="Code for Incoterms"),

        'active': fields.boolean('Active', help="By unchecking the active field, you may hide an INCOTERM without deleting it."),

    }

        'active': True,

    }

        'name': fields.char('Stock Journal', size=32, required=True),

        'user_id': fields.many2one('res.users', 'Responsible'),

    }

        'user_id': lambda s, c, u, ctx: u

    }

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

# Stock Location

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

    # TODO: implement name_search() in a way that matches the results of name_get!

        # always return the full hierarchical name

        """ Forms complete name of location from parent location to child location.

        @return: Dictionary of values

        """

        """ return all sublocations of the given stock locations (included) """

        """Computes stock value (real and virtual) for a product, as well as stock qty (real and virtual).

        @param field_names: Name of field

        @return: Dictionary of values

        """

        'name': fields.char('Location Name', size=64, required=True, translate=True),

        'active': fields.boolean('Active', help="By unchecking the active field, you may hide a location without deleting it."),

        'usage': fields.selection([('supplier', 'Supplier Location'), ('view', 'View'), ('internal', 'Internal Location'), ('customer', 'Customer Location'), ('inventory', 'Inventory'), ('procurement', 'Procurement'), ('production', 'Production'), ('transit', 'Transit Location for Inter-Companies Transfers')], 'Location Type', required=True,

                 help="""* Supplier Location: Virtual location representing the source location for products coming from your suppliers

                       \n* View: Virtual location used to create a hierarchical structures for your warehouse, aggregating its child locations ; can't directly contain products

                       \n* Internal Location: Physical locations inside your own warehouses,

                       \n* Customer Location: Virtual location representing the destination location for products sent to your customers

                       \n* Inventory: Virtual location serving as counterpart for inventory operations used to correct stock levels (Physical inventories)

                       \n* Procurement: Virtual location serving as temporary counterpart for procurement operations when the source (supplier or production) is not known yet. This location should be empty when the procurement scheduler has finished running.

                       \n* Production: Virtual counterpart location for production operations: this location consumes the raw material and produces finished products

                      """, select = True),

         # temporarily removed, as it's unused: 'allocation_method': fields.selection([('fifo', 'FIFO'), ('lifo', 'LIFO'), ('nearest', 'Nearest')], 'Allocation Method', required=True),

        'complete_name': fields.function(_complete_name, type='char', size=256, string="Location Name",

                            store={'stock.location': (_get_sublocations, ['name', 'location_id'], 10)}),

        'stock_real': fields.function(_product_value, type='float', string='Real Stock', multi="stock"),

        'stock_virtual': fields.function(_product_value, type='float', string='Virtual Stock', multi="stock"),

        'location_id': fields.many2one('stock.location', 'Parent Location', select=True, ondelete='cascade'),

        'child_ids': fields.one2many('stock.location', 'location_id', 'Contains'),

        'chained_journal_id': fields.many2one('stock.journal', 'Chaining Journal',help="Inventory Journal in which the chained move will be written, if the Chaining Type is not Transparent (no journal is used if left empty)"),

        'chained_location_id': fields.many2one('stock.location', 'Chained Location If Fixed'),

        'chained_location_type': fields.selection([('none', 'None'), ('customer', 'Customer'), ('fixed', 'Fixed Location')],

            'Chained Location Type', required=True,

            help="Determines whether this location is chained to another location, i.e. any incoming product in this location \n" \

                "should next go to the chained location. The chained location is determined according to the type :"\

                "\n* None: No chaining at all"\

                "\n* Customer: The chained location will be taken from the Customer Location field on the Partner form of the Partner that is specified in the Picking list of the incoming products." \

                "\n* Fixed Location: The chained location is taken from the next field: Chained Location if Fixed." \

                ),

        'chained_auto_packing': fields.selection(

            [('auto', 'Automatic Move'), ('manual', 'Manual Operation'), ('transparent', 'Automatic No Step Added')],

            'Chaining Type',

            required=True,

            help="This is used only if you select a chained location type.\n" \

                "The 'Automatic Move' value will create a stock move after the current one that will be "\

                "validated automatically. With 'Manual Operation', the stock move has to be validated "\

                "by a worker. With 'Automatic No Step Added', the location is replaced in the original move."

            ),

        'chained_picking_type': fields.selection([('out', 'Sending Goods'), ('in', 'Getting Goods'), ('internal', 'Internal')], 'Shipping Type', help="Shipping Type of the Picking List that will contain the chained move (leave empty to automatically detect the type based on the source and destination locations)."),

        'chained_company_id': fields.many2one('res.company', 'Chained Company', help='The company the Picking List containing the chained move will belong to (leave empty to use the default company determination rules'),

        'chained_delay': fields.integer('Chaining Lead Time',help="Delay between original move and chained move in days"),

        'partner_id': fields.many2one('res.partner', 'Location Address',help="Address of  customer or supplier."),

        'icon': fields.selection(tools.icons, 'Icon', size=64,help="Icon show in  hierarchical tree view"),

        'comment': fields.text('Additional Information'),

        'posx': fields.integer('Corridor (X)',help="Optional localization details, for information purpose only"),

        'posy': fields.integer('Shelves (Y)', help="Optional localization details, for information purpose only"),

        'posz': fields.integer('Height (Z)', help="Optional localization details, for information purpose only"),

        'parent_left': fields.integer('Left Parent', select=1),

        'parent_right': fields.integer('Right Parent', select=1),

        'stock_real_value': fields.function(_product_value, type='float', string='Real Stock Value', multi="stock", digits_compute=dp.get_precision('Account')),

        'stock_virtual_value': fields.function(_product_value, type='float', string='Virtual Stock Value', multi="stock", digits_compute=dp.get_precision('Account')),

        'company_id': fields.many2one('res.company', 'Company', select=1, help='Let this field empty if this location is shared between all companies'),

        'scrap_location': fields.boolean('Scrap Location', help='Check this box to allow using this location to put scrapped/damaged goods.'),

        'valuation_in_account_id': fields.many2one('account.account', 'Stock Valuation Account (Incoming)', domain = [('type','=','other')],

                                                   help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "

                                                        "this account will be used to hold the value of products being moved from an internal location "

                                                        "into this location, instead of the generic Stock Output Account set on the product. "

                                                        "This has no effect for internal locations."),

        'valuation_out_account_id': fields.many2one('account.account', 'Stock Valuation Account (Outgoing)', domain = [('type','=','other')],

                                                   help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "

                                                        "this account will be used to hold the value of products being moved out of this location "

                                                        "and into an internal location, instead of the generic Stock Output Account set on the product. "

                                                        "This has no effect for internal locations."),

    }

        'active': True,

        'usage': 'internal',

        'chained_location_type': 'none',

        'chained_auto_packing': 'manual',

        'company_id': lambda self, cr, uid, c: self.pool.get('res.company')._company_default_get(cr, uid, 'stock.location', context=c),

        'posx': 0,

        'posy': 0,

        'posz': 0,

        'icon': False,

        'scrap_location': False,

    }

        """ Finds chained location

        @param location: Location id

        @param partner: Partner id

        @param product: Product id

        @return: List of values

        """

            else:

        """ Gets type of picking.

        @param from_location: Source location

        @param to_location: Destination location

        @return: Location type

        """

            context=None, recursive=False):

        """ Finds the product quantity and price for particular location.

        @param product_ids: Ids of product

        @param recursive: True or False

        @return: Dictionary of values

        """

        if context is None:

            context = {}

        # Take the user company and pricetype

        # To be able to offer recursive or non-recursive reports we need to prevent recursive quantities by default

                        context=ctx)

                    # Compute based on pricetype

                    # Choose the right filed standard_price to read

                        'price': amount_unit,

                        'prod_name': product.name,

                        'code': product.default_code, # used by lot_overview_all report!

                        'variants': product.variants or '',

                        'uom': product.uom_id.name,

                        'prod_qty': qty[product_id],

                        'price_value': price,

                    })

                                    states=['done'], what=('in', 'out')):

        """

        @param product_ids: Ids of product

        @param states: List of states

        @param what: Tuple of

        @return:

        """

        if context is None:

            context = {}

            'states': states,

            'what': what,

            'location': ids

        })

        """

        @param product_ids:

        @param states:

        @return:

        """

        # build the list of ids of children of the location given by id

        """

        Attempt to find a quantity ``product_qty`` (in the product's default uom or the uom passed in ``context``) of product ``product_id``

        in locations with id ``ids`` and their child locations. If ``lock`` is True, the stock.move lines

        of product with id ``product_id`` in the searched location will be write-locked using Postgres's

        "FOR UPDATE NOWAIT" option until the transaction is committed or rolled back, to prevent reservin

        twice the same products.

        If ``lock`` is True and the lock cannot be obtained (because another transaction has locked some of

        the same stock.move lines), a log line will be output and False will be returned, as if there was

        not enough stock.

        :param product_id: Id of product to reserve

        :param product_qty: Quantity of product to reserve (in the product's default uom or the uom passed in ``context``)

        :param lock: if True, the stock.move lines of product with id ``product_id`` in all locations (and children locations) with ``ids`` will

                     be write-locked using postgres's "FOR UPDATE NOWAIT" option until the transaction is committed or rolled back. This is

                     to prevent reserving twice the same products.

        :param context: optional context dictionary: if a 'uom' key is present it will be used instead of the default product uom to

                        compute the ``product_qty`` and in the return value.

        :return: List of tuples in the form (qty, location_id) with the (partial) quantities that can be taken in each location to

                 reach the requested product_qty (``qty`` is expressed in the default uom of the product), of False if enough

                 products could not be found, or the lock could not be obtained (and ``lock`` was True).

        """

        if context is None:

            context = {}

            # Fetch only the locations in which this product has ever been processed (in or out)

                        EXISTS (SELECT 1 FROM stock_move m WHERE m.product_id = %s

                                AND ((state = 'done' AND m.location_dest_id = l.id)

                                    OR (state in ('done','assigned') AND m.location_id = l.id)))

                       """, (tuple(locations_ids), product_id,))

                    # Must lock with a separate select query because FOR UPDATE can't be used with

                    # aggregation/group by's (when individual rows aren't identifiable).

                    # We use a SAVEPOINT to be able to rollback this part of the transaction without

                    # failing the whole transaction in case the LOCK cannot be acquired.

                                  WHERE product_id=%s AND

                                          (

                                            (location_dest_id=%s AND

                                             location_id<>%s AND

                                             state='done')

                                            OR

                                            (location_id=%s AND

                                             location_dest_id<>%s AND

                                             state in ('done', 'assigned'))

                                          )

                                  FOR UPDATE of stock_move NOWAIT""", (product_id, id, id, id, id), log_exceptions=False)

                    # Here it's likely that the FOR UPDATE NOWAIT failed to get the LOCK,

                    # so we ROLLBACK to the SAVEPOINT to restore the transaction to its earlier

                    # state, we return False as if the products were not available, and log it:

            # XXX TODO: rewrite this with one single query, possibly even the quantity conversion

                          FROM stock_move

                          WHERE location_dest_id=%s AND

                                location_id<>%s AND

                                product_id=%s AND

                                state='done'

                          GROUP BY product_uom

                       """,

                       (id, id, product_id))

                          FROM stock_move

                          WHERE location_id=%s AND

                                location_dest_id<>%s AND

                                product_id=%s AND

                                state in ('done', 'assigned')

                          GROUP BY product_uom

                       """,

                       (id, id, product_id))

        'name': fields.char('Pack Reference', size=64, required=True, select=True, help="By default, the pack reference is generated following the sscc standard. (Serial number + 1 check digit)"),

        'active': fields.boolean('Active', help="By unchecking the active field, you may hide a pack without deleting it."),

        'serial': fields.char('Additional Reference', size=64, select=True, help="Other reference or serial number"),

        'move_ids': fields.one2many('stock.move', 'tracking_id', 'Moves for this pack', readonly=True),

        'date': fields.datetime('Creation Date', required=True),

    }

        'active': 1,

        'name': make_sscc,

        'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),

    }

        """Append the serial to the name"""

                                      or r['name'] )

                for r in self.read(cr, uid, ids, ['name', 'serial'],

                                   context=context) ]

        """ It traces the information of a product

        @param self: The object pointer.

        @param cr: A database cursor

        @param uid: ID of the user currently logged in

        @param ids: List of IDs selected

        @param context: A standard dictionary

        @return: A dictionary of values

        """

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

# Stock Picking

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

        """ Calculates planned date if it is greater than 'value'.

        @param name: Name of field

        @param value: Value of field

        @param arg: User defined argument

        @return: True or False

        """

                    date_expected='%s'

                where

                    picking_id=%d """ % (value, pick.id)

        """ Calculates planned date if it is less than 'value'.

        @param name: Name of field

        @param value: Value of field

        @param arg: User defined argument

        @return: True or False

        """

                    date_expected='%s'

                where

                    picking_id=%s """ % (value, pick.id)

        """ Finds minimum and maximum dates for picking.

        @return: Dictionary of values

        """

                picking_id,

                min(date_expected),

                max(date_expected)

            from

                stock_move

            where

                picking_id IN %s

            group by

                picking_id""",(tuple(ids),))

        '''Return the ids of pickings that should change, due to changes

        in stock moves.'''

        'name': fields.char('Reference', size=64, select=True, states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}),

        'origin': fields.char('Source Document', size=64, states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}, help="Reference of the document", select=True),

        'backorder_id': fields.many2one('stock.picking', 'Back Order of', states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}, help="If this shipment was split, then this field links to the shipment which contains the already processed part.", select=True),

        'type': fields.selection([('out', 'Sending Goods'), ('in', 'Getting Goods'), ('internal', 'Internal')], 'Shipping Type', required=True, select=True, help="Shipping type specify, goods coming in or going out."),

        'note': fields.text('Notes', states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}),

        'stock_journal_id': fields.many2one('stock.journal','Stock Journal', select=True, states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}),

        'location_id': fields.many2one('stock.location', 'Location', states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}, help="Keep empty if you produce at the location where the finished products are needed." \

                "Set a location if you produce at a fixed location. This can be a partner location " \

                "if you subcontract the manufacturing operations.", select=True),

        'location_dest_id': fields.many2one('stock.location', 'Dest. Location', states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}, help="Location where the system will stock the finished products.", select=True),

        'move_type': fields.selection([('direct', 'Partial'), ('one', 'All at once')], 'Delivery Method', required=True, states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}, help="It specifies goods to be deliver partially or all at once"),

        'state': fields.selection([

            ('draft', 'Draft'),

            ('cancel', 'Cancelled'),

            ('auto', 'Waiting Another Operation'),

            ('confirmed', 'Waiting Availability'),

            ('assigned', 'Ready to Transfer'),

            ('done', 'Transferred'),

            ], 'Status', readonly=True, select=True, track_visibility='onchange', help="""

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

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

            * Waiting Availability: still waiting for the availability of products\n

            * Ready to Transfer: products reserved, simply waiting for confirmation.\n

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

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

        ),

        'min_date': fields.function(

            get_min_max_date,

            fnct_inv=_set_minimum_date, multi='min_max_date',

            store={

                'stock.move': (

                    _get_stock_move_changes,

                    ['date_expected'], 10,

                )

            },

            type='datetime', string='Scheduled Time', select=True,

            help="Scheduled time for the shipment to be processed"

        ),

        'date': fields.datetime('Creation Date', help="Creation date, usually the time of the order.", select=True, states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}),

        'date_done': fields.datetime('Date of Transfer', help="Date of Completion", states={'done':[('readonly', True)], 'cancel':[('readonly',True)]}),

        'max_date': fields.function(

            get_min_max_date,

            fnct_inv=_set_maximum_date, multi='min_max_date',

            store={

                'stock.move': (

                    _get_stock_move_changes,

                    ['date_expected'], 10,

                )

            },

            type='datetime', string='Max. Expected Date', select=True