class hr_contract_be(osv.osv):
_inherit = 'hr.contract'
_columns = {
'travel_reimbursement_amount': fields.float('Reimbursement of travel expenses', digits_compute=dp.get_precision('Payroll')),
'car_company_amount': fields.float('Company car employer', digits_compute=dp.get_precision('Payroll')),
'car_employee_deduction': fields.float('Company Car Deduction for Worker', digits_compute=dp.get_precision('Payroll')),
'misc_onss_deduction': fields.float('Miscellaneous exempt ONSS ', digits_compute=dp.get_precision('Payroll')),
'meal_voucher_amount': fields.float('Check Value Meal ', digits_compute=dp.get_precision('Payroll')),
'meal_voucher_employee_deduction': fields.float('Check Value Meal - by worker ', digits_compute=dp.get_precision('Payroll')),
'insurance_employee_deduction': fields.float('Insurance Group - by worker ', digits_compute=dp.get_precision('Payroll')),
'misc_advantage_amount': fields.float('Benefits of various nature ', digits_compute=dp.get_precision('Payroll')),
'additional_net_amount': fields.float('Net supplements', digits_compute=dp.get_precision('Payroll')),
'retained_net_amount': fields.float('Net retained ', digits_compute=dp.get_precision('Payroll')),
}
class pay_sale_order(orm.TransientModel):
_name = 'pay.sale.order'
_description = 'Wizard to generate a payment from the sale order'
_columns = {
'journal_id': fields.many2one('account.journal', 'Journal'),
'amount': fields.float('Amount',
digits_compute=dp.get_precision('Sale Price')),
'date': fields.datetime('Payment Date'),
'description': fields.char('Description', size=64),
}
def _get_journal_id(self, cr, uid, context=None):
if context is None:
context = {}
if context.get('active_id'):
sale_obj = self.pool.get('sale.order')
order = sale_obj.browse(cr, uid, context['active_id'],
context=context)
if order.payment_method_id:
return order.payment_method_id.journal_id.id
return False
def _get_amount(self, cr, uid, context=None):
if context is None:
context = {}
if context.get('active_id'):
sale_obj = self.pool.get('sale.order')
order = sale_obj.browse(cr, uid, context['active_id'],
context=context)
return order.residual
return False
_defaults = {
'journal_id': _get_journal_id,
'amount': _get_amount,
'date': fields.datetime.now,
}
def pay_sale_order(self, cr, uid, ids, context=None):
""" Pay the sale order """
wizard = self.browse(cr, uid, ids[0], context=context)
sale_obj = self.pool.get('sale.order')
sale_obj.add_payment(cr, uid,
context['active_id'],
wizard.journal_id.id,
wizard.amount,
wizard.date,
description=wizard.description,
context=context)
return {'type': 'ir.actions.act_window_close'}
def pay_sale_order_and_confirm(self, cr, uid, ids, context=None):
""" Pay the sale order """
self.pay_sale_order(cr, uid, ids, context=context)
sale_obj = self.pool.get('sale.order')
return sale_obj.action_button_confirm(cr, uid,
[context['active_id']],
context=context)
class stock_move_consume(osv.osv_memory):
_name = "stock.move.consume"
_description = "Consume Products"
_columns = {
'product_id': fields.many2one('product.product', 'Product', required=True, select=True),
'product_qty': fields.float('Quantity', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True),
'location_id': fields.many2one('stock.location', 'Location', required=True),
'restrict_lot_id': fields.many2one('stock.production.lot', 'Lot'),
}
#TOFIX: product_uom should not have different category of default UOM of product. Qty should be convert into UOM of original move line before going in consume and scrap
def default_get(self, cr, uid, fields, context=None):
if context is None:
context = {}
res = super(stock_move_consume, self).default_get(cr, uid, fields, context=context)
move = self.pool.get('stock.move').browse(cr, uid, context['active_id'], context=context)
if 'product_id' in fields:
res.update({'product_id': move.product_id.id})
if 'product_uom' in fields:
res.update({'product_uom': move.product_uom.id})
if 'product_qty' in fields:
res.update({'product_qty': move.product_uom_qty})
if 'location_id' in fields:
res.update({'location_id': move.location_id.id})
return res
def do_move_consume(self, cr, uid, ids, context=None):
if context is None:
context = {}
move_obj = self.pool.get('stock.move')
uom_obj = self.pool.get('product.uom')
production_obj = self.pool.get('mrp.production')
move_ids = context['active_ids']
move = move_obj.browse(cr, uid, move_ids[0], context=context)
production_id = move.raw_material_production_id.id
production = production_obj.browse(cr, uid, production_id, context=context)
precision = self.pool['decimal.precision'].precision_get(cr, uid, 'Product Unit of Measure')
for data in self.browse(cr, uid, ids, context=context):
qty = uom_obj._compute_qty(cr, uid, data['product_uom'].id, data.product_qty, data.product_id.uom_id.id)
remaining_qty = move.product_qty - qty
#check for product quantity is less than previously planned
if float_compare(remaining_qty, 0, precision_digits=precision) >= 0:
move_obj.action_consume(cr, uid, move_ids, qty, data.location_id.id, restrict_lot_id=data.restrict_lot_id.id, context=context)
else:
consumed_qty = min(move.product_qty, qty)
new_moves = move_obj.action_consume(cr, uid, move_ids, consumed_qty, data.location_id.id, restrict_lot_id=data.restrict_lot_id.id, context=context)
#consumed more in wizard than previously planned
extra_more_qty = qty - consumed_qty
#create new line for a remaining qty of the product
extra_move_id = production_obj._make_consume_line_from_data(cr, uid, production, data.product_id, data.product_id.uom_id.id, extra_more_qty, context=context)
move_obj.write(cr, uid, [extra_move_id], {'restrict_lot_id': data.restrict_lot_id.id}, context=context)
move_obj.action_done(cr, uid, [extra_move_id], context=context)
return {'type': 'ir.actions.act_window_close'}
class ProductTemplate(models.Model):
_inherit = "product.template"
uos_id = fields.Many2one(
'product.uom',
'Unit of Sale',
help='Specify a unit of measure here if invoicing is made in another'
' unit of measure than inventory. Keep empty to use the default unit of measure.'
)
uos_coeff = fields.Float(
'Unit of Measure -> UOS Coeff',
digits=dp.get_precision('Product Unit of Measure'),
help='Coefficient to convert default Unit of Measure to Unit of Sale'
' uos = uom * coeff')
class stock_landed_cost_lines(osv.osv):
_name = 'stock.landed.cost.lines'
_description = 'Stock Landed Cost Lines'
def onchange_product_id(self,
cr,
uid,
ids,
product_id=False,
context=None):
result = {}
if not product_id:
return {'value': {'quantity': 0.0, 'price_unit': 0.0}}
product = self.pool.get('product.product').browse(cr,
uid,
product_id,
context=context)
result['name'] = product.name
result['split_method'] = product.split_method
result['price_unit'] = product.standard_price
result[
'account_id'] = product.property_account_expense_id and product.property_account_expense_id.id or product.categ_id.property_account_expense_categ_id.id
return {'value': result}
_columns = {
'name':
fields.char('Description'),
'cost_id':
fields.many2one('stock.landed.cost',
'Landed Cost',
required=True,
ondelete='cascade'),
'product_id':
fields.many2one('product.product', 'Product', required=True),
'price_unit':
fields.float('Cost',
required=True,
digits_compute=dp.get_precision('Product Price')),
'split_method':
fields.selection(product.SPLIT_METHOD,
string='Split Method',
required=True),
'account_id':
fields.many2one('account.account',
'Account',
domain=[('internal_type', '!=', 'view'),
('internal_type', '!=', 'closed'),
('deprecated', '=', False)]),
}
class mrp_product_produce_line(osv.osv_memory):
_name = "mrp.product.produce.line"
_description = "Product Produce Consume lines"
_columns = {
'product_id':
fields.many2one('product.product', string='Product'),
'product_qty':
fields.float(
'Quantity (in default UoM)',
digits_compute=dp.get_precision('Product Unit of Measure')),
'lot_id':
fields.many2one('stock.production.lot', string='Lot'),
'produce_id':
fields.many2one('mrp.product.produce', string="Produce"),
}
class stock_return_picking_line(osv.osv_memory):
_name = "stock.return.picking.line"
_rec_name = 'product_id'
_columns = {
'product_id':
fields.many2one('product.product', string="Product", required=True),
'quantity':
fields.float(
"Quantity",
digits_compute=dp.get_precision('Product Unit of Measure'),
required=True),
'wizard_id':
fields.many2one('stock.return.picking', string="Wizard"),
'move_id':
fields.many2one('stock.move', "Move"),
}
class bid_line_qty(osv.osv_memory):
_name = "bid.line.qty"
_description = "Change Bid line quantity"
_columns = {
'qty':
fields.float(
'Quantity',
digits_compute=dp.get_precision('Product Unit of Measure'),
required=True),
}
def change_qty(self, cr, uid, ids, context=None):
active_ids = context and context.get('active_ids', [])
data = self.browse(cr, uid, ids, context=context)[0]
self.pool.get('purchase.order.line').write(
cr, uid, active_ids, {'quantity_tendered': data.qty})
return {'type': 'ir.actions.act_window_close'}
class mrp_subproduct(osv.osv):
_name = 'mrp.subproduct'
_description = 'Byproduct'
_columns={
'product_id': fields.many2one('product.product', 'Product', required=True),
'product_qty': fields.float('Product Qty', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True),
'subproduct_type': fields.selection([('fixed','Fixed'),('variable','Variable')], 'Quantity Type', required=True, help="Define how the quantity of byproducts will be set on the production orders using this BoM.\
'Fixed' depicts a situation where the quantity of created byproduct is always equal to the quantity set on the BoM, regardless of how many are created in the production order.\
By opposition, 'Variable' means that the quantity will be computed as\
'(quantity of byproduct set on the BoM / quantity of manufactured product set on the BoM * quantity of manufactured product in the production order.)'"),
'bom_id': fields.many2one('mrp.bom', 'BoM', ondelete='cascade'),
}
_defaults={
'subproduct_type': 'variable',
'product_qty': lambda *a: 1.0,
}
def onchange_product_id(self, cr, uid, ids, product_id, context=None):
""" Changes UoM if product_id changes.
@param product_id: Changed product_id
@return: Dictionary of changed values
"""
if product_id:
prod = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
v = {'product_uom': prod.uom_id.id}
return {'value': v}
return {}
def onchange_uom(self, cr, uid, ids, product_id, product_uom, context=None):
res = {'value':{}}
if not product_uom or not product_id:
return res
product = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
uom = self.pool.get('product.uom').browse(cr, uid, product_uom, context=context)
if uom.category_id.id != product.uom_id.category_id.id:
res['warning'] = {'title': _('Warning'), 'message': _('The Product Unit of Measure you chose has a different category than in the product form.')}
res['value'].update({'product_uom': product.uom_id.id})
return res
class mrp_repair_fee(osv.osv, ProductChangeMixin):
_name = 'mrp.repair.fee'
_description = 'Repair Fees Line'
def _amount_line(self, cr, uid, ids, field_name, arg, context=None):
""" Calculates amount.
@param field_name: Name of field.
@param arg: Argument
@return: Dictionary of values.
"""
res = {}
tax_obj = self.pool.get('account.tax')
cur_obj = self.pool.get('res.currency')
for line in self.browse(cr, uid, ids, context=context):
if line.to_invoice:
cur = line.repair_id.pricelist_id.currency_id
taxes = tax_obj.compute_all(cr, uid, line.tax_id, line.price_unit, cur.id, line.product_uom_qty, line.product_id.id, line.repair_id.partner_id.id)
res[line.id] = taxes['total_included']
else:
res[line.id] = 0
return res
_columns = {
'repair_id': fields.many2one('mrp.repair', 'Repair Order Reference', required=True, ondelete='cascade', select=True),
'name': fields.char('Description', select=True, required=True),
'product_id': fields.many2one('product.product', 'Product'),
'product_uom_qty': fields.float('Quantity', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
'price_unit': fields.float('Unit Price', required=True),
'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True),
'price_subtotal': fields.function(_amount_line, string='Subtotal', digits=0),
'tax_id': fields.many2many('account.tax', 'repair_fee_line_tax', 'repair_fee_line_id', 'tax_id', 'Taxes'),
'invoice_line_id': fields.many2one('account.invoice.line', 'Invoice Line', readonly=True, copy=False),
'to_invoice': fields.boolean('To Invoice'),
'invoiced': fields.boolean('Invoiced', readonly=True, copy=False),
}
_defaults = {
'to_invoice': lambda *a: True,
}
class SaleOrderLine(models.Model):
_inherit = 'sale.order.line'
@api.one
def _set_uos(self):
if self.product_id.uos_coeff:
self.product_uom_qty = self.product_uos_qty / self.product_id.uos_coeff
self.product_uom = self.product_id.uom_id
@api.one
def _compute_uos(self):
self.product_uos_qty = self.product_uom_qty * self.product_id.uos_coeff
product_uos_qty = fields.Float(
string='Quantity',
digits=dp.get_precision('Product Unit of Measure'),
compute='_compute_uos',
inverse='_set_uos',
readonly=False)
product_uos = fields.Many2one('product.uom',
string='Unit of Measure',
required=True,
related='product_id.uos_id',
readonly=True)
class stock_move_scrap(osv.osv_memory):
_name = "stock.move.scrap"
_description = "Scrap Products"
_columns = {
'product_id':
fields.many2one('product.product',
'Product',
required=True,
select=True),
'product_qty':
fields.float(
'Quantity',
digits_compute=dp.get_precision('Product Unit of Measure'),
required=True),
'product_uom':
fields.many2one('product.uom',
'Product Unit of Measure',
required=True),
'location_id':
fields.many2one('stock.location', 'Location', required=True),
'restrict_lot_id':
fields.many2one('stock.production.lot', 'Lot'),
}
_defaults = {'location_id': lambda *x: False}
def default_get(self, cr, uid, fields, context=None):
""" Get default values
@param self: The object pointer.
@param cr: A database cursor
@param uid: ID of the user currently logged in
@param fields: List of fields for default value
@param context: A standard dictionary
@return: default values of fields
"""
if context is None:
context = {}
res = super(stock_move_scrap, self).default_get(cr,
uid,
fields,
context=context)
move = self.pool.get('stock.move').browse(cr,
uid,
context['active_id'],
context=context)
location_obj = self.pool.get('stock.location')
scrap_location_id = location_obj.search(
cr, uid, [('scrap_location', '=', True)])
if 'product_id' in fields:
res.update({'product_id': move.product_id.id})
if 'product_uom' in fields:
res.update({'product_uom': move.product_uom.id})
if 'location_id' in fields:
if scrap_location_id:
res.update({'location_id': scrap_location_id[0]})
else:
res.update({'location_id': False})
return res
def move_scrap(self, cr, uid, ids, context=None):
""" To move scrapped products
@param self: The object pointer.
@param cr: A database cursor
@param uid: ID of the user currently logged in
@param ids: the ID or list of IDs if we want more than one
@param context: A standard dictionary
@return:
"""
if context is None:
context = {}
move_obj = self.pool.get('stock.move')
move_ids = context['active_ids']
for data in self.browse(cr, uid, ids):
move_obj.action_scrap(cr,
uid,
move_ids,
data.product_qty,
data.location_id.id,
restrict_lot_id=data.restrict_lot_id.id,
context=context)
if context.get('active_id'):
move = self.pool.get('stock.move').browse(cr,
uid,
context['active_id'],
context=context)
if move.picking_id:
return {
'view_type': 'form',
'view_mode': 'form',
'res_model': 'stock.picking',
'type': 'ir.actions.act_window',
'res_id': move.picking_id.id,
'context': context
}
return {'type': 'ir.actions.act_window_close'}
class change_production_qty(osv.osv_memory):
_name = 'change.production.qty'
_description = 'Change Quantity of Products'
_columns = {
'product_qty': fields.float('Product Qty', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
}
def default_get(self, cr, uid, fields, context=None):
""" To get default values for the object.
@param self: The object pointer.
@param cr: A database cursor
@param uid: ID of the user currently logged in
@param fields: List of fields for which we want default values
@param context: A standard dictionary
@return: A dictionary which of fields with values.
"""
if context is None:
context = {}
res = super(change_production_qty, self).default_get(cr, uid, fields, context=context)
prod_obj = self.pool.get('mrp.production')
prod = prod_obj.browse(cr, uid, context.get('active_id'), context=context)
if 'product_qty' in fields:
res.update({'product_qty': prod.product_qty})
return res
def _update_product_to_produce(self, cr, uid, prod, qty, context=None):
move_lines_obj = self.pool.get('stock.move')
for m in prod.move_created_ids:
move_lines_obj.write(cr, uid, [m.id], {'product_uom_qty': qty})
def change_prod_qty(self, cr, uid, ids, context=None):
"""
Changes the Quantity of 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:
"""
record_id = context and context.get('active_id',False)
assert record_id, _('Active Id not found')
prod_obj = self.pool.get('mrp.production')
bom_obj = self.pool.get('mrp.bom')
move_obj = self.pool.get('stock.move')
for wiz_qty in self.browse(cr, uid, ids, context=context):
prod = prod_obj.browse(cr, uid, record_id, context=context)
prod_obj.write(cr, uid, [prod.id], {'product_qty': wiz_qty.product_qty})
prod_obj.action_compute(cr, uid, [prod.id])
for move in prod.move_lines:
bom_point = prod.bom_id
bom_id = prod.bom_id.id
if not bom_point:
bom_id = bom_obj._bom_find(cr, uid, product_id=prod.product_id.id, context=context)
if not bom_id:
raise UserError(_("Cannot find bill of material for this product."))
prod_obj.write(cr, uid, [prod.id], {'bom_id': bom_id})
bom_point = bom_obj.browse(cr, uid, [bom_id])[0]
if not bom_id:
raise UserError(_("Cannot find bill of material for this product."))
factor = prod.product_qty * prod.product_uom.factor / bom_point.product_uom.factor
product_details, workcenter_details = \
bom_obj._bom_explode(cr, uid, bom_point, prod.product_id, factor / bom_point.product_qty, [], context=context)
for r in product_details:
if r['product_id'] == move.product_id.id:
move_obj.write(cr, uid, [move.id], {'product_uom_qty': r['product_qty']})
if prod.move_prod_id:
move_obj.write(cr, uid, [prod.move_prod_id.id], {'product_uom_qty' : wiz_qty.product_qty})
self._update_product_to_produce(cr, uid, prod, wiz_qty.product_qty, context=context)
return {}
class mrp_workorder(osv.osv):
_name = "mrp.workorder"
_description = "Work Order Report"
_auto = False
_columns = {
'nbr':
fields.integer(
'# of Lines',
readonly=True), # TDE FIXME master: rename into nbr_lines
'date':
fields.date('Date', readonly=True),
'product_id':
fields.many2one('product.product', 'Product', readonly=True),
'product_tmpl_id':
fields.many2one('product.template', 'Product Template', readonly=True),
'category_id':
fields.many2one('product.category', 'Product Category', readonly=True),
'product_qty':
fields.float(
'Product Qty',
digits_compute=dp.get_precision('Product Unit of Measure'),
readonly=True),
'state':
fields.selection([('draft', 'Draft'), ('startworking', 'In Progress'),
('pause', 'Pause'), ('cancel', 'Cancelled'),
('done', 'Finished')],
'Status',
readonly=True),
'total_hours':
fields.float('Total Hours', readonly=True),
'total_cycles':
fields.float('Total Cycles', readonly=True),
'delay':
fields.float('Delay', readonly=True),
'production_id':
fields.many2one('mrp.production', 'Production', readonly=True),
'workcenter_id':
fields.many2one('mrp.workcenter', 'Work Center', readonly=True),
'user_id':
fields.many2one('res.users', 'Responsible'),
'routing_id':
fields.many2one('mrp.routing', string='Routing', readonly=True),
'bom_id':
fields.many2one('mrp.bom', 'Bill of Material', readonly=True),
}
def init(self, cr):
tools.drop_view_if_exists(cr, 'mrp_workorder')
cr.execute("""
create or replace view mrp_workorder as (
select
date(wl.date_planned) as date,
min(wl.id) as id,
mp.product_id as product_id,
p.product_tmpl_id,
t.categ_id as category_id,
sum(wl.hour) as total_hours,
avg(wl.delay) as delay,
(w.costs_hour*sum(wl.hour)) as total_cost,
wl.production_id as production_id,
wl.workcenter_id as workcenter_id,
sum(wl.cycle) as total_cycles,
count(*) as nbr,
sum(mp.product_qty) as product_qty,
wl.state as state,
mp.user_id,
mp.routing_id,
mp.bom_id
from mrp_production_workcenter_line wl
left join mrp_workcenter w on (w.id = wl.workcenter_id)
left join mrp_production mp on (mp.id = wl.production_id)
left join product_product p on (mp.product_id=p.id)
left join product_template t on (p.product_tmpl_id=t.id)
group by
w.costs_hour, mp.product_id, mp.name, mp.user_id, mp.routing_id, mp.bom_id, wl.state, wl.date_planned, wl.production_id, wl.workcenter_id, p.product_tmpl_id, t.categ_id
)""")
class sale_quote_line(osv.osv):
_name = "sale.quote.line"
_description = "Quotation Template Lines"
_columns = {
'sequence':
fields.integer(
'Sequence',
help=
"Gives the sequence order when displaying a list of sale quote lines."
),
'quote_id':
fields.many2one('sale.quote.template',
'Quotation Template Reference',
required=True,
ondelete='cascade',
select=True),
'name':
fields.text('Description', required=True, translate=True),
'product_id':
fields.many2one('product.product',
'Product',
domain=[('sale_ok', '=', True)],
required=True),
'website_description':
fields.related('product_id',
'product_tmpl_id',
'quote_description',
string='Line Description',
type='html',
translate=True),
'price_unit':
fields.float('Unit Price',
required=True,
digits_compute=dp.get_precision('Product Price')),
'discount':
fields.float('Discount (%)',
digits_compute=dp.get_precision('Discount')),
'product_uom_qty':
fields.float('Quantity',
required=True,
digits_compute=dp.get_precision('Product UoS')),
'product_uom_id':
fields.many2one('product.uom', 'Unit of Measure ', required=True),
}
_order = 'sequence, id'
_defaults = {
'product_uom_qty': 1,
'discount': 0.0,
'sequence': 10,
}
def on_change_product_id(self,
cr,
uid,
ids,
product,
uom_id=None,
context=None):
vals, domain = {}, []
product_obj = self.pool.get('product.product').browse(cr,
uid,
product,
context=context)
name = product_obj.name
if product_obj.description_sale:
name += '\n' + product_obj.description_sale
vals.update({
'price_unit':
product_obj.lst_price,
'product_uom_id':
product_obj.uom_id.id,
'website_description':
product_obj and
(product_obj.quote_description or product_obj.website_description)
or '',
'name':
name,
'product_uom_id':
uom_id or product_obj.uom_id.id,
})
uom_obj = self.pool.get('product.uom')
if vals['product_uom_id'] != product_obj.uom_id.id:
selected_uom = uom_obj.browse(cr,
uid,
vals['product_uom_id'],
context=context)
new_price = uom_obj._compute_price(cr, uid, product_obj.uom_id.id,
vals['price_unit'],
vals['product_uom_id'])
vals['price_unit'] = new_price
if not uom_id:
domain = {
'product_uom_id':
[('category_id', '=', product_obj.uom_id.category_id.id)]
}
return {'value': vals, 'domain': domain}
def product_uom_change(self, cr, uid, ids, product, uom_id, context=None):
context = context or {}
if not uom_id:
return {'value': {'price_unit': 0.0, 'uom_id': False}}
return self.on_change_product_id(cr,
uid,
ids,
product,
uom_id=uom_id,
context=context)
def _inject_quote_description(self, cr, uid, values, context=None):
values = dict(values or {})
if not values.get('website_description') and values.get('product_id'):
product = self.pool['product.product'].browse(cr,
uid,
values['product_id'],
context=context)
values[
'website_description'] = product.quote_description or product.website_description or ''
return values
def create(self, cr, uid, values, context=None):
values = self._inject_quote_description(cr, uid, values, context)
ret = super(sale_quote_line, self).create(cr,
uid,
values,
context=context)
# hack because create don t make the job for a related field
if values.get('website_description'):
self.write(cr,
uid,
ret,
{'website_description': values['website_description']},
context=context)
return ret
def write(self, cr, uid, ids, values, context=None):
values = self._inject_quote_description(cr, uid, values, context)
return super(sale_quote_line, self).write(cr,
uid,
ids,
values,
context=context)
class hr_expense_expense(osv.osv):
def _amount(self, cr, uid, ids, field_name, arg, context=None):
res = {}
for expense in self.browse(cr, uid, ids, context=context):
total = 0.0
for line in expense.line_ids:
total += line.unit_amount * line.unit_quantity
res[expense.id] = total
return res
def _get_expense_from_line(self, cr, uid, ids, context=None):
return [
line.expense_id.id for line in self.pool.get(
'hr.expense8.line').browse(cr, uid, ids, context=context)
]
def _get_currency(self, cr, uid, context=None):
user = self.pool.get('res.users').browse(cr,
uid, [uid],
context=context)[0]
return user.company_id.currency_id.id
_name = "hr.expense8.expense"
_inherit = ['mail.thread']
_description = "Expense"
_order = "id desc"
_track = {
'state': {
'hr_expense.mt_expense_approved':
lambda self, cr, uid, obj, ctx=None: obj.state == 'accepted',
'hr_expense.mt_expense_refused':
lambda self, cr, uid, obj, ctx=None: obj.state == 'cancelled',
'hr_expense.mt_expense_confirmed':
lambda self, cr, uid, obj, ctx=None: obj.state == 'confirm',
},
}
_columns = {
'name':
fields.char('Description',
required=True,
readonly=True,
states={
'draft': [('readonly', False)],
'confirm': [('readonly', False)]
}),
'id':
fields.integer('Sheet ID', readonly=True),
'date':
fields.date('Date',
select=True,
readonly=True,
states={
'draft': [('readonly', False)],
'confirm': [('readonly', False)]
}),
'journal_id':
fields.many2one('account.journal',
'Force Journal',
help="The journal used when the expense is done."),
'employee_id':
fields.many2one('hr.employee',
"Employee",
required=True,
readonly=True,
states={
'draft': [('readonly', False)],
'confirm': [('readonly', False)]
}),
'user_id':
fields.many2one('res.users', 'User', required=True),
'date_confirm':
fields.date(
'Confirmation Date',
select=True,
copy=False,
help=
"Date of the confirmation of the sheet expense. It's filled when the button Confirm is pressed."
),
'date_valid':
fields.date(
'Validation Date',
select=True,
copy=False,
help=
"Date of the acceptation of the sheet expense. It's filled when the button Accept is pressed."
),
'user_valid':
fields.many2one('res.users',
'Validation By',
readonly=True,
copy=False,
states={
'draft': [('readonly', False)],
'confirm': [('readonly', False)]
}),
'account_move_id':
fields.many2one('account.move', 'Ledger Posting', copy=False),
'line_ids':
fields.one2many('hr.expense8.line',
'expense_id',
'Expense Lines',
copy=True,
readonly=True,
states={'draft': [('readonly', False)]}),
'note':
fields.text('Note'),
'amount':
fields.function(_amount,
string='Total Amount',
digits_compute=dp.get_precision('Account'),
store={
'hr.expense8.line':
(_get_expense_from_line,
['unit_amount', 'unit_quantity'], 10)
}),
'currency_id':
fields.many2one('res.currency',
'Currency',
required=True,
readonly=True,
states={
'draft': [('readonly', False)],
'confirm': [('readonly', False)]
}),
'department_id':
fields.many2one('hr.department',
'Department',
readonly=True,
states={
'draft': [('readonly', False)],
'confirm': [('readonly', False)]
}),
'company_id':
fields.many2one('res.company', 'Company', required=True),
'state':
fields.selection(
[
('draft', 'New'),
('cancelled', 'Refused'),
('confirm', 'Waiting Approval'),
('accepted', 'Approved'),
('done', 'Waiting Payment'),
('paid', 'Paid'),
],
'Status',
readonly=True,
track_visibility='onchange',
copy=False,
help=
'When the expense request is created the status is \'Draft\'.\n It is confirmed by the user and request is sent to admin, the status is \'Waiting Confirmation\'.\
\nIf the admin accepts it, the status is \'Accepted\'.\n If the accounting entries are made for the expense request, the status is \'Waiting Payment\'.'
),
}
_defaults = {
'company_id':
lambda s, cr, uid, c: s.pool.get('res.company')._company_default_get(
cr, uid, 'hr.employee', context=c),
'date':
fields.date.context_today,
'state':
'draft',
'employee_id':
_employee_get,
'user_id':
lambda cr, uid, id, c={}: id,
'currency_id':
_get_currency,
}
def unlink(self, cr, uid, ids, context=None):
for rec in self.browse(cr, uid, ids, context=context):
if rec.state != 'draft':
raise osv.except_osv(_('Warning!'),
_('You can only delete draft expenses!'))
return super(hr_expense_expense, self).unlink(cr, uid, ids, context)
def onchange_currency_id(self,
cr,
uid,
ids,
currency_id=False,
company_id=False,
context=None):
res = {'value': {'journal_id': False}}
journal_ids = self.pool.get('account.journal').search(
cr,
uid, [('type', '=', 'purchase'), ('company_id', '=', company_id)],
context=context)
if journal_ids:
res['value']['journal_id'] = journal_ids[0]
return res
def onchange_employee_id(self, cr, uid, ids, employee_id, context=None):
emp_obj = self.pool.get('hr.employee')
department_id = False
company_id = False
if employee_id:
employee = emp_obj.browse(cr, uid, employee_id, context=context)
department_id = employee.department_id.id
company_id = employee.company_id.id
return {
'value': {
'department_id': department_id,
'company_id': company_id
}
}
def expense_confirm(self, cr, uid, ids, context=None):
for expense in self.browse(cr, uid, ids):
if expense.employee_id and expense.employee_id.parent_id.user_id:
self.message_subscribe_users(
cr,
uid, [expense.id],
user_ids=[expense.employee_id.parent_id.user_id.id])
return self.write(cr,
uid,
ids, {
'state': 'confirm',
'date_confirm': time.strftime('%Y-%m-%d')
},
context=context)
def expense_accept(self, cr, uid, ids, context=None):
return self.write(cr,
uid,
ids, {
'state': 'accepted',
'date_valid': time.strftime('%Y-%m-%d'),
'user_valid': uid
},
context=context)
def expense_canceled(self, cr, uid, ids, context=None):
return self.write(cr,
uid,
ids, {'state': 'cancelled'},
context=context)
def account_move_get(self, cr, uid, expense_id, context=None):
'''
This method prepare the creation of the account move related to the given expense.
:param expense_id: Id of expense for which we are creating account_move.
:return: mapping between fieldname and value of account move to create
:rtype: dict
'''
journal_obj = self.pool.get('account.journal')
expense = self.browse(cr, uid, expense_id, context=context)
company_id = expense.company_id.id
date = expense.date_confirm
ref = expense.name
journal_id = False
if expense.journal_id:
journal_id = expense.journal_id.id
else:
journal_id = journal_obj.search(cr, uid,
[('type', '=', 'purchase'),
('company_id', '=', company_id)])
if not journal_id:
raise osv.except_osv(
_('Error!'),
_("No expense journal found. Please make sure you have a journal with type 'purchase' configured."
))
journal_id = journal_id[0]
return self.pool.get('account.move').account_move_prepare(
cr,
uid,
journal_id,
date=date,
ref=ref,
company_id=company_id,
context=context)
def line_get_convert(self, cr, uid, x, part, date, context=None):
partner_id = self.pool.get('res.partner')._find_accounting_partner(
part).id
return {
'date_maturity':
x.get('date_maturity', False),
'partner_id':
partner_id,
'name':
x['name'][:64],
'date':
date,
'debit':
x['price'] > 0 and x['price'],
'credit':
x['price'] < 0 and -x['price'],
'account_id':
x['account_id'],
'analytic_lines':
x.get('analytic_lines', False),
'amount_currency':
x['price'] > 0 and abs(x.get('amount_currency', False))
or -abs(x.get('amount_currency', False)),
'currency_id':
x.get('currency_id', False),
'tax_code_id':
x.get('tax_code_id', False),
'tax_amount':
x.get('tax_amount', False),
'ref':
x.get('ref', False),
'quantity':
x.get('quantity', 1.00),
'product_id':
x.get('product_id', False),
'product_uom_id':
x.get('uos_id', False),
'analytic_account_id':
x.get('account_analytic_id', False),
}
def compute_expense_totals(self,
cr,
uid,
exp,
company_currency,
ref,
account_move_lines,
context=None):
'''
internal method used for computation of total amount of an expense in the company currency and
in the expense currency, given the account_move_lines that will be created. It also do some small
transformations at these account_move_lines (for multi-currency purposes)
:param account_move_lines: list of dict
:rtype: tuple of 3 elements (a, b ,c)
a: total in company currency
b: total in hr.expense currency
c: account_move_lines potentially modified
'''
cur_obj = self.pool.get('res.currency')
context = dict(context or {},
date=exp.date_confirm or time.strftime('%Y-%m-%d'))
total = 0.0
total_currency = 0.0
for i in account_move_lines:
if exp.currency_id.id != company_currency:
i['currency_id'] = exp.currency_id.id
i['amount_currency'] = i['price']
i['price'] = cur_obj.compute(cr,
uid,
exp.currency_id.id,
company_currency,
i['price'],
context=context)
else:
i['amount_currency'] = False
i['currency_id'] = False
total -= i['price']
total_currency -= i['amount_currency'] or i['price']
return total, total_currency, account_move_lines
def action_move_create(self, cr, uid, ids, context=None):
'''
main function that is called when trying to create the accounting entries related to an expense
'''
move_obj = self.pool.get('account.move')
for exp in self.browse(cr, uid, ids, context=context):
if not exp.employee_id.address_home_id:
raise osv.except_osv(
_('Error!'), _('The employee must have a home address.'))
#zhangzs
# if not exp.employee_id.address_home_id.property_account_payable.id:
# raise osv.except_osv(_('Error!'), _('The employee must have a payable account set on his home address.'))
company_currency = exp.company_id.currency_id.id
diff_currency_p = exp.currency_id.id <> company_currency
#create the move that will contain the accounting entries
move_id = move_obj.create(cr,
uid,
self.account_move_get(cr,
uid,
exp.id,
context=context),
context=context)
#one account.move.line per expense line (+taxes..)
eml = self.move_line_get(cr, uid, exp.id, context=context)
#create one more move line, a counterline for the total on payable account
total, total_currency, eml = self.compute_expense_totals(
cr, uid, exp, company_currency, exp.name, eml, context=context)
acc = exp.employee_id.address_home_id.property_account_payable.id
eml.append({
'type':
'dest',
'name':
'/',
'price':
total,
'account_id':
acc,
'date_maturity':
exp.date_confirm,
'amount_currency':
diff_currency_p and total_currency or False,
'currency_id':
diff_currency_p and exp.currency_id.id or False,
'ref':
exp.name
})
#convert eml into an osv-valid format
lines = map(
lambda x:
(0, 0,
self.line_get_convert(cr,
uid,
x,
exp.employee_id.address_home_id,
exp.date_confirm,
context=context)), eml)
journal_id = move_obj.browse(cr, uid, move_id, context).journal_id
# post the journal entry if 'Skip 'Draft' State for Manual Entries' is checked
if journal_id.entry_posted:
move_obj.button_validate(cr, uid, [move_id], context)
move_obj.write(cr,
uid, [move_id], {'line_id': lines},
context=context)
self.write(cr,
uid,
ids, {
'account_move_id': move_id,
'state': 'done'
},
context=context)
return True
def move_line_get(self, cr, uid, expense_id, context=None):
res = []
tax_obj = self.pool.get('account.tax')
cur_obj = self.pool.get('res.currency')
if context is None:
context = {}
exp = self.browse(cr, uid, expense_id, context=context)
company_currency = exp.company_id.currency_id.id
for line in exp.line_ids:
mres = self.move_line_get_item(cr, uid, line, context)
if not mres:
continue
res.append(mres)
#Calculate tax according to default tax on product
taxes = []
#Taken from product_id_onchange in account.invoice
if line.product_id:
fposition_id = False
fpos_obj = self.pool.get('account.fiscal.position')
fpos = fposition_id and fpos_obj.browse(
cr, uid, fposition_id, context=context) or False
product = line.product_id
taxes = product.supplier_taxes_id
#If taxes are not related to the product, maybe they are in the account
if not taxes:
a = product.property_account_expense.id #Why is not there a check here?
if not a:
a = product.categ_id.property_account_expense_categ.id
a = fpos_obj.map_account(cr, uid, fpos, a)
taxes = a and self.pool.get('account.account').browse(
cr, uid, a, context=context).tax_ids or False
if not taxes:
continue
tax_l = []
base_tax_amount = line.total_amount
#Calculating tax on the line and creating move?
for tax in tax_obj.compute_all(cr, uid, taxes, line.unit_amount,
line.unit_quantity, line.product_id,
exp.user_id.partner_id)['taxes']:
tax_code_id = tax['base_code_id']
if not tax_code_id:
continue
res[-1]['tax_code_id'] = tax_code_id
##
is_price_include = tax_obj.read(cr, uid, tax['id'],
['price_include'],
context)['price_include']
if is_price_include:
## We need to deduce the price for the tax
res[-1]['price'] = res[-1]['price'] - tax['amount']
# tax amount countains base amount without the tax
base_tax_amount = (base_tax_amount -
tax['amount']) * tax['base_sign']
else:
base_tax_amount = base_tax_amount * tax['base_sign']
assoc_tax = {
'type': 'tax',
'name': tax['name'],
'price_unit': tax['price_unit'],
'quantity': 1,
'price': tax['amount'] or 0.0,
'account_id': tax['account_collected_id']
or mres['account_id'],
'tax_code_id': tax['tax_code_id'],
'tax_amount': tax['amount'] * tax['base_sign'],
}
tax_l.append(assoc_tax)
res[-1]['tax_amount'] = cur_obj.compute(
cr,
uid,
exp.currency_id.id,
company_currency,
base_tax_amount,
context={'date': exp.date_confirm})
res += tax_l
return res
def move_line_get_item(self, cr, uid, line, context=None):
company = line.expense_id.company_id
property_obj = self.pool.get('ir.property')
if line.product_id:
acc = line.product_id.property_account_expense
if not acc:
acc = line.product_id.categ_id.property_account_expense_categ
if not acc:
raise osv.except_osv(
_('Error!'),
_('No purchase account found for the product %s (or for his category), please configure one.'
) % (line.product_id.name))
else:
acc = property_obj.get(cr,
uid,
'property_account_expense_categ',
'product.category',
context={'force_company': company.id})
if not acc:
raise osv.except_osv(
_('Error!'),
_('Please configure Default Expense account for Product purchase: `property_account_expense_categ`.'
))
return {
'type': 'src',
'name': line.name.split('\n')[0][:64],
'price_unit': line.unit_amount,
'quantity': line.unit_quantity,
'price': line.total_amount,
'account_id': acc.id,
'product_id': line.product_id.id,
'uos_id': line.uom_id.id,
'account_analytic_id': line.analytic_account.id,
}
def action_view_move(self, cr, uid, ids, context=None):
'''
This function returns an action that display existing account.move of given expense ids.
'''
assert len(
ids
) == 1, 'This option should only be used for a single id at a time'
expense = self.browse(cr, uid, ids[0], context=context)
assert expense.account_move_id
try:
dummy, view_id = self.pool.get(
'ir.model.data').get_object_reference(cr, uid, 'account',
'view_move_form')
except ValueError, e:
view_id = False
result = {
'name': _('Expense Account Move'),
'view_type': 'form',
'view_mode': 'form',
'view_id': view_id,
'res_model': 'account.move',
'type': 'ir.actions.act_window',
'nodestroy': True,
'target': 'current',
'res_id': expense.account_move_id.id,
}
return result
class plm_relation(models.Model):
_name = 'mrp.bom'
_inherit = 'mrp.bom'
create_date = fields.Datetime(_('Creation Date'), readonly=True)
source_id = fields.Many2one('plm.document','name',ondelete='no action',readonly=True,help=_('This is the document object that declares this BoM.'))
type = fields.Selection([('normal',_('Normal BoM')),('phantom',_('Sets / Phantom')),('ebom',_('Engineering BoM')),('spbom',_('Spare BoM'))], _('BoM Type'), required=True, help=
_("Use a phantom bill of material in raw materials lines that have to be " \
"automatically computed on a production order and not one per level." \
"If you put \"Phantom/Set\" at the root level of a bill of material " \
"it is considered as a set or pack: the products are replaced by the components " \
"between the sale order to the picking without going through the production order." \
"the normal bom will generate one production order per bom level."))
weight_net = fields.Float('Weight',digits_compute=dp.get_precision(_('Stock Weight')), help=_("The BoM net weight in Kg."))
_defaults = {
'product_uom' : 1,
'weight_net' : 0.0,
}
def init(self, cr):
self._packed=[]
def _getinbom(self, cr, uid, pid, sid=False):
bomLType=self.pool.get('mrp.bom.line')
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',sid),('type','=','ebom')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',sid),('type','=','normal')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',False),('type','=','ebom')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',False),('type','=','normal')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('type','=','ebom')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('type','=','normal')])
return bomLType.browse(cr,uid,list(set(ids)),context=None)
def _getbom(self, cr, uid, pid, sid=False):
if sid==None:
sid=False
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',sid),('type','=','ebom')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',sid),('type','=','normal')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',False),('type','=','ebom')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',False),('type','=','normal')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('type','=','ebom')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('type','=','normal')])
return self.browse(cr,uid,list(set(ids)),context=None)
def getListIdsFromStructure(self, structure):
'''
Convert from [id1,[[id2,[]]]] to [id1,id2]
'''
outList = []
if isinstance(structure, (list, tuple)) and len(structure) == 2:
outList.append(structure[0])
for item in structure[1]:
outList.extend(self.getListIdsFromStructure(item))
return list(set(outList))
def _getpackdatas(self, cr, uid, relDatas):
prtDatas = {}
tmpids = self.getListIdsFromStructure(relDatas)
if len(tmpids)<1:
return prtDatas
compType=self.pool.get('product.product')
tmpDatas=compType.read(cr, uid, tmpids)
for tmpData in tmpDatas:
for keyData in tmpData.keys():
if tmpData[keyData]==None:
del tmpData[keyData]
prtDatas[str(tmpData['id'])]=tmpData
return prtDatas
def _getpackreldatas(self, cr, uid, relDatas, prtDatas):
relids={}
relationDatas={}
tmpids = self.getListIdsFromStructure(relDatas)
if len(tmpids)<1:
return prtDatas
for keyData in prtDatas.keys():
tmpData=prtDatas[keyData]
if len(tmpData['bom_ids'])>0:
relids[keyData]=tmpData['bom_ids'][0]
if len(relids)<1:
return relationDatas
for keyData in relids.keys():
relationDatas[keyData]=self.read(cr, uid, relids[keyData])
return relationDatas
def GetWhereUsed(self, cr, uid, ids, context=None):
"""
Return a list of all fathers of a Part (all levels)
"""
self._packed = []
relDatas = []
if len(ids) < 1:
return None
sid = False
if len(ids) > 1:
sid = ids[1]
oid = ids[0]
relDatas.append(oid)
relDatas.append(self._implodebom(cr, uid, self._getinbom(cr, uid, oid, sid)))
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def GetExplose(self, cr, uid, ids, context=None):
"""
Returns a list of all children in a Bom (all levels)
"""
self._packed = []
# get all ids of the children product in structured way like [[id,childids]]
relDatas = [ids[0], self._explodebom(cr, uid, self._getbom(cr, uid, ids[0]), False)]
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def _explodebom(self, cr, uid, bids, check=True):
"""
Explodes a bom entity ( check=False : all levels, check=True : one level )
"""
output = []
self._packed = []
for bid in bids:
for bom_line in bid.bom_line_ids:
if check and (bom_line.product_id.id in self._packed):
continue
innerids = self._explodebom(cr, uid, self._getbom(cr, uid, bom_line.product_id.product_tmpl_id.id), check)
self._packed.append(bom_line.product_id.id)
output.append([bom_line.product_id.id, innerids])
return(output)
def GetTmpltIdFromProductId(self, cr, uid, product_id=False):
if not product_id:
return False
tmplDict = self.pool.get('product.product').read(cr, uid, product_id, ['product_tmpl_id']) # tmplDict = {'product_tmpl_id': (tmpl_id, u'name'), 'id': product_product_id}
tmplTuple = tmplDict.get('product_tmpl_id', {})
if len(tmplTuple) == 2:
return tmplTuple[0]
def GetExploseSum(self, cr, uid, ids, context=None):
"""
Return a list of all children in a Bom taken once (all levels)
"""
self._packed = []
prodTmplId = self.GetTmpltIdFromProductId(cr, uid, ids[0])
bomId = self._getbom(cr, uid, prodTmplId)
explosedBomIds = self._explodebom(cr, uid, bomId, True)
relDatas = [ids[0], explosedBomIds]
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def _implodebom(self, cr, uid, bomObjs):
"""
Execute implosion for a a bom object
"""
pids = []
for bomObj in bomObjs:
if not bomObj.bom_id:
continue
if bomObj.bom_id.id in self._packed:
continue
self._packed.append(bomObj.bom_id.id)
bomFthObj = self.browse(cr, uid, [bomObj.bom_id.id], context=None)
innerids = self._implodebom(cr, uid, self._getinbom(cr, uid, bomFthObj.product_id.id))
pids.append((bomFthObj.product_id.id, innerids))
return (pids)
def GetWhereUsedSum(self, cr, uid, ids, context=None):
"""
Return a list of all fathers of a Part (all levels)
"""
self._packed = []
relDatas = []
if len(ids) < 1:
return None
sid = False
if len(ids) > 1:
sid = ids[1]
oid = ids[0]
relDatas.append(oid)
bomId = self._getinbom(cr, uid, oid, sid)
relDatas.append(self._implodebom(cr, uid, bomId))
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def GetExplodedBom(self, cr, uid, ids, level=0, currlevel=0):
"""
Return a list of all children in a Bom ( level = 0 one level only, level = 1 all levels)
"""
self._packed=[]
result=[]
if level==0 and currlevel>1:
return result
bomids=self.browse(cr, uid, ids)
for bomid in bomids:
for bom in bomid.bom_line_ids:
children=self.GetExplodedBom(cr, uid, [bom.id], level, currlevel+1)
result.extend(children)
if len(str(bomid.bom_id))>0:
result.append(bomid.id)
return result
def SaveStructure(self, cr, uid, relations, level=0, currlevel=0):
"""
Save EBom relations
"""
def cleanStructure(parentID=None,sourceID=None):
"""
Clean relations having sourceID
"""
if parentID==None or sourceID==None:
return None
objPart=self.pool.get('product.product').browse(cr,uid,parentID,context=None)
ids=self.search(cr,uid,[('product_id','=',objPart.id),('source_id','=',sourceID)])
self.unlink(cr,uid,ids) # Cleans mrp.bom
ids=self.search(cr,uid,[('product_tmpl_id','=',objPart.product_tmpl_id.id),('source_id','=',sourceID)])
self.unlink(cr,uid,ids) # Cleans mrp.bom
bomLType=self.pool.get('mrp.bom.line')
ids=bomLType.search(cr,uid,[('bom_id','=',parentID),('source_id','=',sourceID)])
bomLType.unlink(cr,uid,ids) # Cleans mrp.bom.line
def toCleanRelations(relations):
"""
Processes relations
"""
listedSource=[]
for parentName, parentID, tmpChildName, tmpChildID, sourceID, tempRelArgs in relations:
if (not(sourceID==None)) and (not(sourceID in listedSource)):
cleanStructure(parentID,sourceID)
listedSource.append(sourceID)
return False
def toCompute(parentName, relations):
"""
Processes relations
"""
sourceIDParent=None
sourceID=None
bomID=False
subRelations=[(a, b, c, d, e, f) for a, b, c, d, e, f in relations if a == parentName]
if len(subRelations)<1: # no relation to save
return None
parentName, parentID, tmpChildName, tmpChildID, sourceID, tempRelArgs=subRelations[0]
ids=self.search(cr,uid,[('product_id','=',parentID),('source_id','=',sourceID)])
if not ids:
bomID=saveParent(parentName, parentID, sourceID, kindBom='ebom')
for rel in subRelations:
#print "Save Relation ", rel
parentName, parentID, childName, childID, sourceID, relArgs=rel
if parentName == childName:
logging.error('toCompute : Father (%s) refers to himself' %(str(parentName)))
raise Exception(_('saveChild.toCompute : Father "%s" refers to himself' %(str(parentName))))
tmpBomId=saveChild(childName, childID, sourceID, bomID, kindBom='ebom', args=relArgs)
tmpBomId=toCompute(childName, relations)
self.RebaseProductWeight(cr, uid, bomID, self.RebaseBomWeight(cr, uid, bomID))
return bomID
def saveParent(name, partID, sourceID, kindBom=None, args=None):
"""
Saves the relation ( parent side in mrp.bom )
"""
try:
res={}
if kindBom!=None:
res['type']=kindBom
else:
res['type']='ebom'
objPart=self.pool.get('product.product').browse(cr,uid,partID,context=None)
res['product_tmpl_id']=objPart.product_tmpl_id.id
res['product_id']=partID
res['source_id']=sourceID
res['name']=name
if args!=None:
for arg in args:
res[str(arg)]=args[str(arg)]
if ('product_qty' in res):
if(type(res['product_qty'])!=types.FloatType) or (res['product_qty']<1e-6):
res['product_qty']=1.0
return self.create(cr, uid, res)
except:
logging.error("saveParent : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(args)))
raise AttributeError(_("saveParent : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(sys.exc_info()))))
def saveChild(name, partID, sourceID, bomID=None, kindBom=None, args=None):
"""
Saves the relation ( child side in mrp.bom.line )
"""
try:
res={}
if bomID!=None:
res['bom_id']=bomID
if kindBom!=None:
res['type']=kindBom
else:
res['type']='ebom'
res['product_id']=partID
res['source_id']=sourceID
res['name']=name
if args!=None:
for arg in args:
res[str(arg)]=args[str(arg)]
if ('product_qty' in res):
if(type(res['product_qty'])!=types.FloatType) or (res['product_qty']<1e-6):
res['product_qty']=1.0
return self.pool.get('mrp.bom.line').create(cr, uid, res)
except:
logging.error("saveChild : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(args)))
raise AttributeError(_("saveChild : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(sys.exc_info()))))
if len(relations)<1: # no relation to save
return False
parentName, parentID, childName, childID, sourceID, relArgs=relations[0]
toCleanRelations(relations)
tmpBomId=toCompute(parentName, relations)
return False
def _sumBomWeight(self, bomObj):
"""
Evaluates net weight for assembly, based on BoM object
"""
weight=0.0
for bom_line in bomObj.bom_line_ids:
weight+=(bom_line.product_qty * bom_line.product_id.product_tmpl_id.weight)
return weight
def RebaseWeight(self, cr, uid, parentID, sourceID=False, context=None):
"""
Evaluates net weight for assembly, based on product ID
"""
weight=0.0
values={}
if not(parentID==None) or parentID:
objPart=self.pool.get('product.product').browse(cr,uid,parentID,context=None)
for bomID in self._getbom(cr, uid, objPart.product_tmpl_id.id, sourceID):
weight=self._sumBomWeight(bomID)
values['weight']=weight
partType=self.pool.get(bomID.product_tmpl_id._inherit)
partType.write(cr,uid,[bomID.product_tmpl_id.id],values)
return weight
def RebaseProductWeight(self, cr, uid, parentBomID, weight=0.0):
"""
Evaluates net weight for assembly, based on product ID
"""
if not(parentBomID==None) or parentBomID:
bomObj=self.browse(cr,uid,parentBomID,context=None)
self.pool.get('product.product').write(cr,uid,[bomObj.product_id.id],{'weight': weight})
def RebaseBomWeight(self, cr, uid, bomID, context=None):
"""
Evaluates net weight for assembly, based on BoM ID
"""
weight=0.0
if bomID:
for bomId in self.browse(cr, uid, bomID, context):
weight=self._sumBomWeight(bomId)
super(plm_relation,self).write(cr, uid, [bomId.id], {'weight_net': weight}, context=context)
return weight
# Overridden methods for this entity
def write(self, cr, uid, ids, vals, check=True, context=None):
ret=super(plm_relation,self).write(cr, uid, ids, vals, context=context)
for bomId in self.browse(cr,uid,ids,context=None):
self.RebaseBomWeight(cr, uid, bomId.id, context=context)
return ret
def copy(self,cr,uid,oid,defaults={},context=None):
"""
Return new object copied (removing SourceID)
"""
newId=super(plm_relation,self).copy(cr,uid,oid,defaults,context=context)
if newId:
compType=self.pool.get('product.product')
bomLType=self.pool.get('mrp.bom.line')
newOid=self.browse(cr,uid,newId,context=context)
for bom_line in newOid.bom_line_ids:
lateRevIdC=compType.GetLatestIds(cr,uid,[(bom_line.product_id.product_tmpl_id.engineering_code,False,False)],context=context) # Get Latest revision of each Part
bomLType.write(cr,uid,[bom_line.id],{'source_id':False,'name':bom_line.product_id.product_tmpl_id.name,'product_id':lateRevIdC[0]},context=context)
self.write(cr,uid,[newId],{'source_id':False,'name':newOid.product_tmpl_id.name,},check=False,context=context)
return newId
class mrp_product_produce(osv.osv_memory):
_name = "mrp.product.produce"
_description = "Product Produce"
_columns = {
'product_id':
fields.many2one('product.product', type='many2one'),
'product_qty':
fields.float(
'Select Quantity',
digits_compute=dp.get_precision('Product Unit of Measure'),
required=True),
'mode':
fields.selection(
[('consume_produce', 'Consume & Produce'),
('consume', 'Consume Only')],
'Mode',
required=True,
help=
"'Consume only' mode will only consume the products with the quantity selected.\n"
"'Consume & Produce' mode will consume as well as produce the products with the quantity selected "
"and it will finish the production order when total ordered quantities are produced."
),
'lot_id':
fields.many2one(
'stock.production.lot', 'Lot'
), #Should only be visible when it is consume and produce mode
'consume_lines':
fields.one2many('mrp.product.produce.line', 'produce_id',
'Products Consumed'),
'tracking':
fields.related('product_id',
'tracking',
type='selection',
selection=[('serial', 'By Unique Serial Number'),
('lot', 'By Lots'),
('none', 'No Tracking')]),
}
def on_change_qty(self,
cr,
uid,
ids,
product_qty,
consume_lines,
context=None):
"""
When changing the quantity of products to be produced it will
recalculate the number of raw materials needed according
to the scheduled products and the already consumed/produced products
It will return the consume lines needed for the products to be produced
which the user can still adapt
"""
prod_obj = self.pool.get("mrp.production")
uom_obj = self.pool.get("product.uom")
production = prod_obj.browse(cr,
uid,
context['active_id'],
context=context)
consume_lines = []
new_consume_lines = []
if product_qty > 0.0:
product_uom_qty = uom_obj._compute_qty(
cr, uid, production.product_uom.id, product_qty,
production.product_id.uom_id.id)
consume_lines = prod_obj._calculate_qty(
cr,
uid,
production,
product_qty=product_uom_qty,
context=context)
for consume in consume_lines:
new_consume_lines.append([0, False, consume])
return {'value': {'consume_lines': new_consume_lines}}
def _get_product_qty(self, cr, uid, context=None):
""" To obtain product quantity
@param self: The object pointer.
@param cr: A database cursor
@param uid: ID of the user currently logged in
@param context: A standard dictionary
@return: Quantity
"""
if context is None:
context = {}
prod = self.pool.get('mrp.production').browse(cr,
uid,
context['active_id'],
context=context)
done = 0.0
for move in prod.move_created_ids2:
if move.product_id == prod.product_id:
if not move.scrapped:
done += move.product_uom_qty # As uom of produced products and production order should correspond
return prod.product_qty - done
def _get_product_id(self, cr, uid, context=None):
""" To obtain product id
@return: id
"""
prod = False
if context and context.get("active_id"):
prod = self.pool.get('mrp.production').browse(cr,
uid,
context['active_id'],
context=context)
return prod and prod.product_id.id or False
def _get_track(self, cr, uid, context=None):
prod = self._get_product_id(cr, uid, context=context)
prod_obj = self.pool.get("product.product")
return prod and prod_obj.browse(cr, uid, prod,
context=context).tracking or 'none'
_defaults = {
'product_qty': _get_product_qty,
'mode': lambda *x: 'consume_produce',
'product_id': _get_product_id,
'tracking': _get_track,
}
def do_produce(self, cr, uid, ids, context=None):
production_id = context.get('active_id', False)
assert production_id, "Production Id should be specified in context as a Active ID."
data = self.browse(cr, uid, ids[0], context=context)
self.pool.get('mrp.production').action_produce(cr,
uid,
production_id,
data.product_qty,
data.mode,
data,
context=context)
return {}
class SaleOrderLine(models.Model):
_name = 'sale.order.line'
_description = 'Sales Order Line'
_order = 'order_id desc, sequence, id'
@api.depends('state', 'product_uom_qty', 'qty_delivered', 'qty_to_invoice', 'qty_invoiced')
def _compute_invoice_status(self):
"""
Compute the invoice status of a SO line. Possible statuses:
- no: if the SO is not in status 'sale' or 'done', we consider that there is nothing to
invoice. This is also hte default value if the conditions of no other status is met.
- to invoice: we refer to the quantity to invoice of the line. Refer to method
`_get_to_invoice_qty()` for more information on how this quantity is calculated.
- upselling: this is possible only for a product invoiced on ordered quantities for which
we delivered more than expected. The could arise if, for example, a project took more
time than expected but we decided not to invoice the extra cost to the client. This
occurs onyl in state 'sale', so that when a SO is set to done, the upselling opportunity
is removed from the list.
- invoiced: the quantity invoiced is larger or equal to the quantity ordered.
"""
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
for line in self:
if line.state not in ('sale', 'done'):
line.invoice_status = 'no'
elif not float_is_zero(line.qty_to_invoice, precision_digits=precision):
line.invoice_status = 'to invoice'
elif line.state == 'sale' and line.product_id.invoice_policy == 'order' and\
float_compare(line.qty_delivered, line.product_uom_qty, precision_digits=precision) == 1:
line.invoice_status = 'upselling'
elif float_compare(line.qty_invoiced, line.product_uom_qty, precision_digits=precision) >= 0:
line.invoice_status = 'invoiced'
else:
line.invoice_status = 'no'
@api.depends('product_uom_qty', 'discount', 'price_unit', 'tax_id')
def _compute_amount(self):
"""
Compute the amounts of the SO line.
"""
for line in self:
price = line.price_unit * (1 - (line.discount or 0.0) / 100.0)
taxes = line.tax_id.compute_all(price, line.order_id.currency_id, line.product_uom_qty, product=line.product_id, partner=line.order_id.partner_id)
line.update({
'price_tax': taxes['total_included'] - taxes['total_excluded'],
'price_total': taxes['total_included'],
'price_subtotal': taxes['total_excluded'],
})
@api.depends('product_id.invoice_policy', 'order_id.state')
def _compute_qty_delivered_updateable(self):
for line in self:
line.qty_delivered_updateable = line.product_id.invoice_policy in ('order', 'delivery') and line.order_id.state == 'sale' and line.product_id.track_service == 'manual'
@api.depends('qty_invoiced', 'qty_delivered', 'product_uom_qty', 'order_id.state')
def _get_to_invoice_qty(self):
"""
Compute the quantity to invoice. If the invoice policy is order, the quantity to invoice is
calculated from the ordered quantity. Otherwise, the quantity delivered is used.
"""
for line in self:
if line.order_id.state in ['sale', 'done']:
if line.product_id.invoice_policy == 'order':
line.qty_to_invoice = line.product_uom_qty - line.qty_invoiced
else:
line.qty_to_invoice = line.qty_delivered - line.qty_invoiced
else:
line.qty_to_invoice = 0
@api.depends('invoice_lines.invoice_id.state', 'invoice_lines.quantity')
def _get_invoice_qty(self):
"""
Compute the quantity invoiced. If case of a refund, the quantity invoiced is decreased. Note
that this is the case only if the refund is generated from the SO and that is intentional: if
a refund made would automatically decrease the invoiced quantity, then there is a risk of reinvoicing
it automatically, which may not be wanted at all. That's why the refund has to be created from the SO
"""
for line in self:
qty_invoiced = 0.0
for invoice_line in line.invoice_lines:
if invoice_line.invoice_id.state != 'cancel':
if invoice_line.invoice_id.type == 'out_invoice':
qty_invoiced += invoice_line.quantity
elif invoice_line.invoice_id.type == 'out_refund':
qty_invoiced -= invoice_line.quantity
line.qty_invoiced = qty_invoiced
@api.depends('price_subtotal', 'product_uom_qty')
def _get_price_reduce(self):
for line in self:
line.price_reduce = line.price_subtotal / line.product_uom_qty if line.product_uom_qty else 0.0
@api.multi
def _compute_tax_id(self):
for line in self:
fpos = line.order_id.fiscal_position_id or line.order_id.partner_id.property_account_position_id
if fpos:
# The superuser is used by website_sale in order to create a sale order. We need to make
# sure we only select the taxes related to the company of the partner. This should only
# apply if the partner is linked to a company.
if self.env.uid == SUPERUSER_ID and line.order_id.company_id:
taxes = fpos.map_tax(line.product_id.taxes_id).filtered(lambda r: r.company_id == line.order_id.company_id)
else:
taxes = fpos.map_tax(line.product_id.taxes_id)
line.tax_id = taxes
else:
line.tax_id = line.product_id.taxes_id if line.product_id.taxes_id else False
@api.multi
def _prepare_order_line_procurement(self, group_id=False):
self.ensure_one()
return {
'name': self.name,
'origin': self.order_id.name,
'date_planned': datetime.strptime(self.order_id.date_order, DEFAULT_SERVER_DATETIME_FORMAT) + timedelta(days=self.customer_lead),
'product_id': self.product_id.id,
'product_qty': self.product_uom_qty,
'product_uom': self.product_uom.id,
'company_id': self.order_id.company_id.id,
'group_id': group_id,
'sale_line_id': self.id
}
@api.multi
def _action_procurement_create(self):
"""
Create procurements based on quantity ordered. If the quantity is increased, new
procurements are created. If the quantity is decreased, no automated action is taken.
"""
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
new_procs = self.env['procurement.order'] #Empty recordset
for line in self:
if line.state != 'sale' or not line.product_id._need_procurement():
continue
qty = 0.0
for proc in line.procurement_ids:
qty += proc.product_qty
if float_compare(qty, line.product_uom_qty, precision_digits=precision) >= 0:
return False
if not line.order_id.procurement_group_id:
vals = line.order_id._prepare_procurement_group()
line.order_id.procurement_group_id = self.env["procurement.group"].create(vals)
vals = line._prepare_order_line_procurement(group_id=line.order_id.procurement_group_id.id)
vals['product_qty'] = line.product_uom_qty - qty
new_proc = self.env["procurement.order"].create(vals)
new_procs += new_proc
new_procs.run()
return new_procs
@api.model
def _get_analytic_invoice_policy(self):
return ['cost']
@api.model
def _get_analytic_track_service(self):
return []
@api.model
def create(self, values):
line = super(SaleOrderLine, self).create(values)
if line.state == 'sale':
if line.product_id.track_service in self._get_analytic_track_service() or line.product_id.invoice_policy in self._get_analytic_invoice_policy() and not line.order_id.project_id:
line.order_id._create_analytic_account()
line._action_procurement_create()
return line
@api.multi
def write(self, values):
lines = False
if 'product_uom_qty' in values:
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
lines = self.filtered(
lambda r: r.state == 'sale' and float_compare(r.product_uom_qty, values['product_uom_qty'], precision_digits=precision) == -1)
result = super(SaleOrderLine, self).write(values)
if lines:
lines._action_procurement_create()
return result
order_id = fields.Many2one('sale.order', string='Order Reference', required=True, ondelete='cascade', index=True, copy=False)
name = fields.Text(string='Description', required=True)
sequence = fields.Integer(string='Sequence', default=10)
invoice_lines = fields.Many2many('account.invoice.line', 'sale_order_line_invoice_rel', 'order_line_id', 'invoice_line_id', string='Invoice Lines', copy=False)
invoice_status = fields.Selection([
('upselling', 'Upselling Opportunity'),
('invoiced', 'Fully Invoiced'),
('to invoice', 'To Invoice'),
('no', 'Nothing to Invoice')
], string='Invoice Status', compute='_compute_invoice_status', store=True, readonly=True, default='no')
price_unit = fields.Float('Unit Price', required=True, digits=dp.get_precision('Product Price'), default=0.0)
price_subtotal = fields.Monetary(compute='_compute_amount', string='Subtotal', readonly=True, store=True)
price_tax = fields.Monetary(compute='_compute_amount', string='Taxes', readonly=True, store=True)
price_total = fields.Monetary(compute='_compute_amount', string='Total', readonly=True, store=True)
price_reduce = fields.Monetary(compute='_get_price_reduce', string='Price Reduce', readonly=True, store=True)
tax_id = fields.Many2many('account.tax', string='Taxes')
discount = fields.Float(string='Discount (%)', digits=dp.get_precision('Discount'), default=0.0)
product_id = fields.Many2one('product.product', string='Product', domain=[('sale_ok', '=', True)], change_default=True, ondelete='restrict', required=True)
product_uom_qty = fields.Float(string='Quantity', digits=dp.get_precision('Product Unit of Measure'), required=True, default=1.0)
product_uom = fields.Many2one('product.uom', string='Unit of Measure', required=True)
qty_delivered_updateable = fields.Boolean(compute='_compute_qty_delivered_updateable', string='Can Edit Delivered', readonly=True, default=True)
qty_delivered = fields.Float(string='Delivered', copy=False, digits=dp.get_precision('Product Unit of Measure'), default=0.0)
qty_to_invoice = fields.Float(
compute='_get_to_invoice_qty', string='To Invoice', store=True, readonly=True,
digits=dp.get_precision('Product Unit of Measure'), default=0.0)
qty_invoiced = fields.Float(
compute='_get_invoice_qty', string='Invoiced', store=True, readonly=True,
digits=dp.get_precision('Product Unit of Measure'), default=0.0)
salesman_id = fields.Many2one(related='order_id.user_id', store=True, string='Salesperson', readonly=True)
currency_id = fields.Many2one(related='order_id.currency_id', store=True, string='Currency', readonly=True)
company_id = fields.Many2one(related='order_id.company_id', string='Company', store=True, readonly=True)
order_partner_id = fields.Many2one(related='order_id.partner_id', store=True, string='Customer')
state = fields.Selection([
('draft', 'Quotation'),
('sent', 'Quotation Sent'),
('sale', 'Sale Order'),
('done', 'Done'),
('cancel', 'Cancelled'),
], related='order_id.state', string='Order Status', readonly=True, copy=False, store=True, default='draft')
customer_lead = fields.Float(
'Delivery Lead Time', required=True, default=0.0,
help="Number of days between the order confirmation and the shipping of the products to the customer", oldname="delay")
procurement_ids = fields.One2many('procurement.order', 'sale_line_id', string='Procurements')
@api.multi
def _prepare_invoice_line(self, qty):
"""
Prepare the dict of values to create the new invoice line for a sales order line.
:param qty: float quantity to invoice
"""
self.ensure_one()
res = {}
account = self.product_id.property_account_income_id or self.product_id.categ_id.property_account_income_categ_id
if not account:
raise UserError(_('Please define income account for this product: "%s" (id:%d) - or for its category: "%s".') % \
(self.product_id.name, self.product_id.id, self.product_id.categ_id.name))
fpos = self.order_id.fiscal_position_id or self.order_id.partner_id.property_account_position_id
if fpos:
account = fpos.map_account(account)
res = {
'name': self.name,
'sequence': self.sequence,
'origin': self.order_id.name,
'account_id': account.id,
'price_unit': self.price_unit,
'quantity': qty,
'discount': self.discount,
'uom_id': self.product_uom.id,
'product_id': self.product_id.id or False,
'invoice_line_tax_ids': [(6, 0, self.tax_id.ids)],
'account_analytic_id': self.order_id.project_id.id,
}
return res
@api.multi
def invoice_line_create(self, invoice_id, qty):
"""
Create an invoice line. The quantity to invoice can be positive (invoice) or negative
(refund).
:param invoice_id: integer
:param qty: float quantity to invoice
"""
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
for line in self:
if not float_is_zero(qty, precision_digits=precision):
vals = line._prepare_invoice_line(qty=qty)
vals.update({'invoice_id': invoice_id, 'sale_line_ids': [(6, 0, [line.id])]})
self.env['account.invoice.line'].create(vals)
@api.multi
@api.onchange('product_id')
def product_id_change(self):
if not self.product_id:
return {'domain': {'product_uom': []}}
vals = {}
domain = {'product_uom': [('category_id', '=', self.product_id.uom_id.category_id.id)]}
if not (self.product_uom and (self.product_id.uom_id.category_id.id == self.product_uom.category_id.id)):
vals['product_uom'] = self.product_id.uom_id
product = self.product_id.with_context(
lang=self.order_id.partner_id.lang,
partner=self.order_id.partner_id.id,
quantity=self.product_uom_qty,
date=self.order_id.date_order,
pricelist=self.order_id.pricelist_id.id,
uom=self.product_uom.id
)
name = product.name_get()[0][1]
if product.description_sale:
name += '\n' + product.description_sale
vals['name'] = name
self._compute_tax_id()
if self.order_id.pricelist_id and self.order_id.partner_id:
vals['price_unit'] = self.env['account.tax']._fix_tax_included_price(product.price, product.taxes_id, self.tax_id)
self.update(vals)
return {'domain': domain}
@api.onchange('product_uom', 'product_uom_qty')
def product_uom_change(self):
if not self.product_uom:
self.price_unit = 0.0
return
if self.order_id.pricelist_id and self.order_id.partner_id:
product = self.product_id.with_context(
lang=self.order_id.partner_id.lang,
partner=self.order_id.partner_id.id,
quantity=self.product_uom_qty,
date_order=self.order_id.date_order,
pricelist=self.order_id.pricelist_id.id,
uom=self.product_uom.id
)
self.price_unit = self.env['account.tax']._fix_tax_included_price(product.price, product.taxes_id, self.tax_id)
@api.multi
def unlink(self):
if self.filtered(lambda x: x.state in ('sale', 'done')):
raise UserError(_('You can not remove a sale order line.\nDiscard changes and try setting the quantity to 0.'))
return super(SaleOrderLine, self).unlink()
@api.multi
def _get_delivered_qty(self):
'''
Intended to be overridden in sale_stock and sale_mrp
:return: the quantity delivered
:rtype: float
'''
return 0.0
class res_company(osv.osv):
_inherit = 'res.company'
_columns = {
'plafond_secu': fields.float('Plafond de la Securite Sociale', digits_compute=dp.get_precision('Payroll')),
'nombre_employes': fields.integer('Nombre d\'employes'),
'cotisation_prevoyance': fields.float('Cotisation Patronale Prevoyance', digits_compute=dp.get_precision('Payroll')),
'org_ss': fields.char('Organisme de securite sociale'),
'conv_coll': fields.char('Convention collective'),
}
class ProcurementSaleForecastLine(models.Model):
_name = 'procurement.sale.forecast.line'
@api.one
@api.depends('unit_price', 'qty')
def _get_subtotal(self):
self.subtotal = self.unit_price * self.qty
@api.one
@api.onchange('product_id')
def onchange_product(self):
if self.product_id:
self.unit_price = self.product_id.list_price
product_id = fields.Many2one('product.product', string='Product')
product_category_id = fields.Many2one('product.category',
string='Product Category')
qty = fields.Float('Quantity',
default=1,
digits_compute=dp.get_precision('Product Unit of'
' Measure'))
unit_price = fields.Float('Unit Price',
digits_compute=dp.get_precision('Product Price'))
subtotal = fields.Float('Subtotal',
compute=_get_subtotal,
store=True,
digits_compute=dp.get_precision('Product Price'))
partner_id = fields.Many2one("res.partner", string="Partner")
date_from = fields.Date(string="Date from",
store=True,
related="forecast_id.date_from")
date_to = fields.Date(string="Date to",
related="forecast_id.date_to",
store=True)
forecast_id = fields.Many2one('procurement.sale.forecast',
string='Forecast')
procurement_id = fields.Many2one('procurement.order', string="Procurement")
date = fields.Date("Date", required=True)
_order = 'date asc'
@api.multi
def request_procurement(self):
self.ensure_one()
value_dict = {
'product_id': self.product_id.id,
'uom_id': self.product_id.uom_id.id,
'date_planned': self.date,
'qty': self.qty,
'warehouse_id': self.forecast_id.warehouse_id.id
}
res_id = self.env['make.procurement'].create(value_dict)
return {
'view_type': 'form',
'view_mode': 'form',
'res_model': 'make.procurement',
'res_id': res_id.id,
'view_id': False,
'type': 'ir.actions.act_window',
'target': 'new',
}
class SaleAdvancePaymentInv(models.TransientModel):
_name = "sale.advance.payment.inv"
_description = "Sales Advance Payment Invoice"
@api.model
def _count(self):
return len(self._context.get('active_ids', []))
@api.model
def _get_advance_payment_method(self):
if self._count() == 1:
sale_obj = self.env['sale.order']
order = sale_obj.browse(self._context.get('active_ids'))[0]
if all([
line.product_id.invoice_policy == 'order'
for line in order.order_line
]):
return 'all'
return 'delivered'
advance_payment_method = fields.Selection(
[('delivered', 'Invoiceable lines'),
('all', 'Invoiceable lines (deduct down payments)'),
('percentage', 'Down payment (percentage)'),
('fixed', 'Down payment (fixed amount)')],
string='What do you want to invoice?',
default=_get_advance_payment_method,
required=True)
product_id = fields.Many2one('product.product', string='Down Payment Product', domain=[('type', '=', 'service')],\
default=lambda self: self.env['ir.values'].get_default('sale.config.settings', 'deposit_product_id_setting'))
count = fields.Integer(default=_count, string='# of Orders')
amount = fields.Float(
'Down Payment Amount',
digits=dp.get_precision('Account'),
help="The amount to be invoiced in advance, taxes excluded.")
deposit_account_id = fields.Many2one("account.account", string="Income Account", domain=[('deprecated', '=', False)],\
help="Account used for deposits")
deposit_taxes_id = fields.Many2many("account.tax",
string="Customer Taxes",
help="Taxes used for deposits")
@api.onchange('advance_payment_method')
def onchange_advance_payment_method(self):
if self.advance_payment_method == 'percentage':
return {'value': {'amount': 0, 'product_id': False}}
return {}
@api.multi
def _create_invoice(self, order, so_line, amount):
inv_obj = self.env['account.invoice']
ir_property_obj = self.env['ir.property']
account_id = False
if self.product_id.id:
account_id = self.product_id.property_account_income_id.id
if not account_id:
prop = ir_property_obj.get('property_account_income_categ_id',
'product.category')
prop_id = prop and prop.id or False
account_id = order.fiscal_position_id.map_account(prop_id)
if not account_id:
raise UserError(
_('There is no income account defined for this product: "%s". You may have to install a chart of account from Accounting app, settings menu.') % \
(self.product_id.name,))
if self.amount <= 0.00:
raise UserError(
_('The value of the down payment amount must be positive.'))
if self.advance_payment_method == 'percentage':
amount = order.amount_untaxed * self.amount / 100
name = _("Down payment of %s%%") % (self.amount, )
else:
amount = self.amount
name = _('Down Payment')
invoice = inv_obj.create({
'name':
order.client_order_ref or order.name,
'origin':
order.name,
'type':
'out_invoice',
'reference':
False,
'account_id':
order.partner_id.property_account_receivable_id.id,
'partner_id':
order.partner_invoice_id.id,
'invoice_line_ids': [(0, 0, {
'name':
name,
'origin':
order.name,
'account_id':
account_id,
'price_unit':
amount,
'quantity':
1.0,
'discount':
0.0,
'uom_id':
self.product_id.uom_id.id,
'product_id':
self.product_id.id,
'sale_line_ids': [(6, 0, [so_line.id])],
'invoice_line_tax_ids':
[(6, 0, [x.id for x in self.product_id.taxes_id])],
'account_analytic_id':
order.project_id.id or False,
})],
'currency_id':
order.pricelist_id.currency_id.id,
'payment_term_id':
order.payment_term_id.id,
'fiscal_position_id':
order.fiscal_position_id.id
or order.partner_id.property_account_position_id.id,
'team_id':
order.team_id.id,
})
invoice.compute_taxes()
return invoice
@api.multi
def create_invoices(self):
sale_orders = self.env['sale.order'].browse(
self._context.get('active_ids', []))
if self.advance_payment_method == 'delivered':
sale_orders.action_invoice_create()
elif self.advance_payment_method == 'all':
sale_orders.action_invoice_create(final=True)
else:
# Create deposit product if necessary
if not self.product_id:
vals = self._prepare_deposit_product()
self.product_id = self.env['product.product'].create(vals)
self.env['ir.values'].set_default(
'sale.config.settings', 'deposit_product_id_setting',
self.product_id.id)
sale_line_obj = self.env['sale.order.line']
for order in sale_orders:
if self.advance_payment_method == 'percentage':
amount = order.amount_untaxed * self.amount / 100
else:
amount = self.amount
if self.product_id.invoice_policy != 'order':
raise UserError(
_('The product used to invoice a down payment should have an invoice policy set to "Ordered quantities". Please update your deposit product to be able to create a deposit invoice.'
))
if self.product_id.type != 'service':
raise UserError(
_("The product used to invoice a down payment should be of type 'Service'. Please use another product or update this product."
))
so_line = sale_line_obj.create({
'name':
_('Advance: %s') % (time.strftime('%m %Y'), ),
'price_unit':
amount,
'product_uom_qty':
0.0,
'order_id':
order.id,
'discount':
0.0,
'product_uom':
self.product_id.uom_id.id,
'product_id':
self.product_id.id,
'tax_id': [(6, 0, self.product_id.taxes_id.ids)],
})
self._create_invoice(order, so_line, amount)
if self._context.get('open_invoices', False):
return sale_orders.action_view_invoice()
return {'type': 'ir.actions.act_window_close'}
def _prepare_deposit_product(self):
return {
'name': 'Down payment',
'type': 'service',
'invoice_policy': 'order',
'property_account_income_id': self.deposit_account_id.id,
'taxes_id': [(6, 0, self.deposit_taxes_id.ids)],
}
class hr_expense_line(osv.osv):
_name = "hr.expense8.line"
_description = "Expense Line"
def _amount(self, cr, uid, ids, field_name, arg, context=None):
if not ids:
return {}
cr.execute(
"SELECT l.id,COALESCE(SUM(l.unit_amount*l.unit_quantity),0) AS amount FROM hr_expense8_line l WHERE id IN %s GROUP BY l.id ",
(tuple(ids), ))
res = dict(cr.fetchall())
return res
def _get_uom_id(self, cr, uid, context=None):
result = self.pool.get('ir.model.data').get_object_reference(
cr, uid, 'product', 'product_uom_unit')
return result and result[1] or False
_columns = {
'name':
fields.char('Expense Note', required=True),
'date_value':
fields.date('Date', required=True),
'expense_id':
fields.many2one('hr.expense8.expense',
'Expense',
ondelete='cascade',
select=True),
'total_amount':
fields.function(_amount,
string='Total',
digits_compute=dp.get_precision('Account')),
'unit_amount':
fields.float('Unit Price',
digits_compute=dp.get_precision('Product Price')),
'unit_quantity':
fields.float(
'Quantities',
digits_compute=dp.get_precision('Product Unit of Measure')),
'product_id':
fields.many2one('product.product',
'Product',
domain=[('hr_expense_ok', '=', True)]),
'uom_id':
fields.many2one('product.uom', 'Unit of Measure', required=True),
'description':
fields.text('Description'),
'analytic_account':
fields.many2one('account.analytic.account', 'Analytic account'),
'ref':
fields.char('Reference'),
'sequence':
fields.integer(
'Sequence',
select=True,
help=
"Gives the sequence order when displaying a list of expense lines."
),
}
_defaults = {
'unit_quantity': 1,
'date_value': lambda *a: time.strftime('%Y-%m-%d'),
'uom_id': _get_uom_id,
}
_order = "sequence, date_value desc"
def onchange_product_id(self, cr, uid, ids, product_id, context=None):
res = {}
if product_id:
product = self.pool.get('product.product').browse(cr,
uid,
product_id,
context=context)
res['name'] = product.name
amount_unit = product.price_get('standard_price')[product.id]
res['unit_amount'] = amount_unit
res['uom_id'] = product.uom_id.id
return {'value': res}
def onchange_uom(self, cr, uid, ids, product_id, uom_id, context=None):
res = {'value': {}}
if not uom_id or not product_id:
return res
product = self.pool.get('product.product').browse(cr,
uid,
product_id,
context=context)
uom = self.pool.get('product.uom').browse(cr,
uid,
uom_id,
context=context)
if uom.category_id.id != product.uom_id.category_id.id:
res['warning'] = {
'title':
_('Warning'),
'message':
_('Selected Unit of Measure does not belong to the same category as the product Unit of Measure'
)
}
res['value'].update({'uom_id': product.uom_id.id})
return res
class sale_quote_option(osv.osv):
_name = "sale.quote.option"
_description = "Quotation Option"
_columns = {
'template_id':
fields.many2one('sale.quote.template',
'Quotation Template Reference',
ondelete='cascade',
select=True,
required=True),
'name':
fields.text('Description', required=True, translate=True),
'product_id':
fields.many2one('product.product',
'Product',
domain=[('sale_ok', '=', True)],
required=True),
'website_description':
fields.html('Option Description', translate=True),
'price_unit':
fields.float('Unit Price',
required=True,
digits_compute=dp.get_precision('Product Price')),
'discount':
fields.float('Discount (%)',
digits_compute=dp.get_precision('Discount')),
'uom_id':
fields.many2one('product.uom', 'Unit of Measure ', required=True),
'quantity':
fields.float('Quantity',
required=True,
digits_compute=dp.get_precision('Product UoS')),
}
_defaults = {
'quantity': 1,
}
def on_change_product_id(self,
cr,
uid,
ids,
product,
uom_id=None,
context=None):
vals, domain = {}, []
product_obj = self.pool.get('product.product').browse(cr,
uid,
product,
context=context)
name = product_obj.name
if product_obj.description_sale:
name += '\n' + product_obj.description_sale
vals.update({
'price_unit': product_obj.list_price,
'website_description':
product_obj.product_tmpl_id.quote_description,
'name': name,
'uom_id': uom_id or product_obj.uom_id.id,
})
uom_obj = self.pool.get('product.uom')
if vals['uom_id'] != product_obj.uom_id.id:
selected_uom = uom_obj.browse(cr,
uid,
vals['uom_id'],
context=context)
new_price = uom_obj._compute_price(cr, uid, product_obj.uom_id.id,
vals['price_unit'],
vals['uom_id'])
vals['price_unit'] = new_price
if not uom_id:
domain = {
'uom_id':
[('category_id', '=', product_obj.uom_id.category_id.id)]
}
return {'value': vals, 'domain': domain}
def product_uom_change(self, cr, uid, ids, product, uom_id, context=None):
if not uom_id:
return {'value': {'price_unit': 0.0, 'uom_id': False}}
return self.on_change_product_id(cr,
uid,
ids,
product,
uom_id=uom_id,
context=context)
class mrp_repair_line(osv.osv, ProductChangeMixin):
_name = 'mrp.repair.line'
_description = 'Repair Line'
def _amount_line(self, cr, uid, ids, field_name, arg, context=None):
""" Calculates amount.
@param field_name: Name of field.
@param arg: Argument
@return: Dictionary of values.
"""
res = {}
tax_obj = self.pool.get('account.tax')
# cur_obj = self.pool.get('res.currency')
for line in self.browse(cr, uid, ids, context=context):
if line.to_invoice:
cur = line.repair_id.pricelist_id.currency_id
taxes = tax_obj.compute_all(cr, uid, line.tax_id, line.price_unit, cur.id, line.product_uom_qty, line.product_id.id, line.repair_id.partner_id.id)
#res[line.id] = cur_obj.round(cr, uid, cur, taxes['total'])
res[line.id] = taxes['total_included']
else:
res[line.id] = 0
return res
_columns = {
'name': fields.char('Description', required=True),
'repair_id': fields.many2one('mrp.repair', 'Repair Order Reference', ondelete='cascade', select=True),
'type': fields.selection([('add', 'Add'), ('remove', 'Remove')], 'Type', required=True),
'to_invoice': fields.boolean('To Invoice'),
'product_id': fields.many2one('product.product', 'Product', required=True),
'invoiced': fields.boolean('Invoiced', readonly=True, copy=False),
'price_unit': fields.float('Unit Price', required=True, digits_compute=dp.get_precision('Product Price')),
'price_subtotal': fields.function(_amount_line, string='Subtotal', digits=0),
'tax_id': fields.many2many('account.tax', 'repair_operation_line_tax', 'repair_operation_line_id', 'tax_id', 'Taxes'),
'product_uom_qty': fields.float('Quantity', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True),
'invoice_line_id': fields.many2one('account.invoice.line', 'Invoice Line', readonly=True, copy=False),
'location_id': fields.many2one('stock.location', 'Source Location', required=True, select=True),
'location_dest_id': fields.many2one('stock.location', 'Dest. Location', required=True, select=True),
'move_id': fields.many2one('stock.move', 'Inventory Move', readonly=True, copy=False),
'lot_id': fields.many2one('stock.production.lot', 'Lot'),
'state': fields.selection([
('draft', 'Draft'),
('confirmed', 'Confirmed'),
('done', 'Done'),
('cancel', 'Cancelled')], 'Status', required=True, readonly=True, copy=False,
help=' * The \'Draft\' status is set automatically as draft when repair order in draft status. \
\n* The \'Confirmed\' status is set automatically as confirm when repair order in confirm status. \
\n* The \'Done\' status is set automatically when repair order is completed.\
\n* The \'Cancelled\' status is set automatically when user cancel repair order.'),
}
_defaults = {
'state': lambda *a: 'draft',
'product_uom_qty': lambda *a: 1,
}
def onchange_operation_type(self, cr, uid, ids, type, guarantee_limit, company_id=False, context=None):
""" On change of operation type it sets source location, destination location
and to invoice field.
@param product: Changed operation type.
@param guarantee_limit: Guarantee limit of current record.
@return: Dictionary of values.
"""
if not type:
return {'value': {
'location_id': False,
'location_dest_id': False
}}
location_obj = self.pool.get('stock.location')
warehouse_obj = self.pool.get('stock.warehouse')
location_id = location_obj.search(cr, uid, [('usage', '=', 'production')], context=context)
location_id = location_id and location_id[0] or False
if type == 'add':
# TOCHECK: Find stock location for user's company warehouse or
# repair order's company's warehouse (company_id field is added in fix of lp:831583)
args = company_id and [('company_id', '=', company_id)] or []
warehouse_ids = warehouse_obj.search(cr, uid, args, context=context)
stock_id = False
if warehouse_ids:
stock_id = warehouse_obj.browse(cr, uid, warehouse_ids[0], context=context).lot_stock_id.id
to_invoice = (guarantee_limit and datetime.strptime(guarantee_limit, '%Y-%m-%d') < datetime.now())
return {'value': {
'to_invoice': to_invoice,
'location_id': stock_id,
'location_dest_id': location_id
}}
scrap_location_ids = location_obj.search(cr, uid, [('scrap_location', '=', True)], context=context)
return {'value': {
'to_invoice': False,
'location_id': location_id,
'location_dest_id': scrap_location_ids and scrap_location_ids[0] or False,
}}
class SaleOrder(models.Model):
_inherit = 'sale.order'
@api.one
@api.depends('amount_total', 'payment_ids.credit', 'payment_ids.debit')
def _compute_amount(self):
paid_amount = sum(line.credit - line.debit
for line in self.payment_ids)
self.amount_paid = paid_amount
self.residual = self.amount_total - paid_amount
payment_ids = fields.Many2many(
comodel_name='account.move.line',
string='Payments Entries',
domain=[('account_id.type', '=', 'receivable')],
copy=False,
)
payment_method_id = fields.Many2one(
comodel_name='payment.method',
string='Payment Method',
ondelete='restrict',
)
residual = fields.Float(
compute='_compute_amount',
digits_compute=dp.get_precision('Account'),
string='Balance',
store=False,
)
amount_paid = fields.Float(
compute='_compute_amount',
digits_compute=dp.get_precision('Account'),
string='Amount Paid',
store=False,
)
@api.multi
def action_cancel(self):
for sale in self:
if sale.payment_ids:
raise exceptions.Warning(
_('Cannot cancel this sales order '
'because automatic payment entries '
'are linked with it.'))
return super(SaleOrder, self).action_cancel()
@api.multi
def automatic_payment(self, amount=None):
""" Create the payment entries to pay a sale order, respecting
the payment terms.
If no amount is defined, it will pay the residual amount of the sale
order.
"""
self.ensure_one()
method = self.payment_method_id
if not method:
raise exceptions.Warning(
_("An automatic payment can not be created for the sale "
"order %s because it has no payment method.") % self.name)
if not method.journal_id:
raise exceptions.Warning(
_("An automatic payment should be created for the sale order"
" %s but the payment method '%s' has no journal defined.") %
(self.name, method.name))
journal = method.journal_id
date = self.date_order[:10]
if amount is None:
amount = self.residual
if self.payment_term:
amounts = self.payment_term.compute(amount, date_ref=date)[0]
else:
amounts = [(date, amount)]
# reversed is cosmetic, compute returns terms in the 'wrong' order
for date, amount in reversed(amounts):
self._add_payment(journal, amount, date)
return True
@api.multi
def add_payment(self, journal_id, amount, date=None, description=None):
""" Generate payment move lines of a certain amount linked
with the sale order.
"""
self.ensure_one()
journal_model = self.env['account.journal']
if date is None:
date = self.date_order
journal = journal_model.browse(journal_id)
self._add_payment(journal, amount, date, description)
return True
@api.multi
def _add_payment(self, journal, amount, date, description=None):
""" Generate move lines entries to pay the sale order. """
move_model = self.env['account.move']
period_model = self.env['account.period']
period = period_model.find(dt=date)
move_name = description or self._get_payment_move_name(journal, period)
move_vals = self._prepare_payment_move(move_name, journal, period,
date)
move_lines = self._prepare_payment_move_lines(move_name, journal,
period, amount, date)
move_vals['line_id'] = [(0, 0, line) for line in move_lines]
move_model.create(move_vals)
@api.model
def _get_payment_move_name(self, journal, period):
sequence = journal.sequence_id
if not sequence:
raise exceptions.Warning(
_('Please define a sequence on the '
'journal %s.') % journal.name)
if not sequence.active:
raise exceptions.Warning(
_('Please activate the sequence of the '
'journal %s.') % journal.name)
sequence = sequence.with_context(fiscalyear_id=period.fiscalyear_id.id)
# next_by_id not compatible with new api
sequence_model = self.pool['ir.sequence']
name = sequence_model.next_by_id(self.env.cr,
self.env.uid,
sequence.id,
context=self.env.context)
return name
@api.multi
def _prepare_payment_move(self, move_name, journal, period, date):
return {
'name': move_name,
'journal_id': journal.id,
'date': date,
'ref': self.name,
'period_id': period.id,
}
@api.multi
def _prepare_payment_move_line(self, move_name, journal, period, amount,
date):
# to remove in v9
_logger.warning('Deprecated: _prepare_payment_move_line has been '
'deprecated in favor of _prepare_payment_move_lines')
return self._prepare_payment_move_lines(move_name, journal, period,
amount, date)
@api.multi
def _prepare_payment_move_lines(self, move_name, journal, period, amount,
date):
partner = self.partner_id.commercial_partner_id
company = journal.company_id
currency = self.env['res.currency'].browse()
# if the lines are not in a different currency,
# the amount_currency stays at 0.0
amount_currency = 0.0
if journal.currency and journal.currency != company.currency_id:
# when the journal have a currency, we have to convert
# the amount to the currency of the company and set
# the journal's currency on the lines
currency = journal.currency
company_amount = currency.compute(amount, company.currency_id)
amount_currency, amount = amount, company_amount
# payment line (bank / cash)
debit_line = {
'name': move_name,
'debit': amount,
'credit': 0.0,
'account_id': journal.default_credit_account_id.id,
'journal_id': journal.id,
'period_id': period.id,
'partner_id': partner.id,
'date': date,
'amount_currency': amount_currency,
'currency_id': currency.id,
}
# payment line (receivable)
credit_line = {
'name': move_name,
'debit': 0.0,
'credit': amount,
'account_id': partner.property_account_receivable.id,
'journal_id': journal.id,
'period_id': period.id,
'partner_id': partner.id,
'date': date,
'amount_currency': -amount_currency,
'currency_id': currency.id,
'sale_ids': [(4, self.id)],
}
return debit_line, credit_line
@api.onchange('payment_method_id')
def onchange_payment_method_id_set_payment_term(self):
if not self.payment_method_id:
return
method = self.payment_method_id
if method.payment_term_id:
self.payment_term = method.payment_term_id.id
@api.multi
def action_view_payments(self):
""" Return an action to display the payment linked
with the sale order """
self.ensure_one()
moves = self.mapped('payment_ids.move_id')
xmlid = ('account', 'action_move_journal_line')
action = self.env['ir.actions.act_window'].for_xml_id(*xmlid)
if len(moves) > 1:
action['domain'] = [('id', 'in', moves.ids)]
else:
ref = self.env.ref('account.view_move_form')
action['views'] = [(ref.id, 'form')]
action['res_id'] = moves.id if moves else False
return action
class mrp_repair(osv.osv):
_name = 'mrp.repair'
_inherit = 'mail.thread'
_description = 'Repair Order'
def _amount_untaxed(self, cr, uid, ids, field_name, arg, context=None):
""" Calculates untaxed amount.
@param self: The object pointer
@param cr: The current row, from the database cursor,
@param uid: The current user ID for security checks
@param ids: List of selected IDs
@param field_name: Name of field.
@param arg: Argument
@param context: A standard dictionary for contextual values
@return: Dictionary of values.
"""
res = {}
cur_obj = self.pool.get('res.currency')
for repair in self.browse(cr, uid, ids, context=context):
res[repair.id] = 0.0
for line in repair.operations:
res[repair.id] += line.price_subtotal
for line in repair.fees_lines:
res[repair.id] += line.price_subtotal
cur = repair.pricelist_id.currency_id
res[repair.id] = cur_obj.round(cr, uid, cur, res[repair.id])
return res
def _amount_tax(self, cr, uid, ids, field_name, arg, context=None):
""" Calculates taxed amount.
@param field_name: Name of field.
@param arg: Argument
@return: Dictionary of values.
"""
res = {}
#return {}.fromkeys(ids, 0)
cur_obj = self.pool.get('res.currency')
tax_obj = self.pool.get('account.tax')
for repair in self.browse(cr, uid, ids, context=context):
val = 0.0
cur = repair.pricelist_id.currency_id
for line in repair.operations:
#manage prices with tax included use compute_all instead of compute
if line.to_invoice and line.tax_id:
tax_calculate = tax_obj.compute_all(cr, uid, line.tax_id, line.price_unit, cur, line.product_uom_qty, line.product_id.id, repair.partner_id.id)
for c in tax_calculate['taxes']:
val += c['amount']
for line in repair.fees_lines:
if line.to_invoice and line.tax_id:
tax_calculate = tax_obj.compute_all(cr, uid, line.tax_id, line.price_unit, cur, line.product_uom_qty, line.product_id.id, repair.partner_id.id)
for c in tax_calculate['taxes']:
val += c['amount']
res[repair.id] = cur_obj.round(cr, uid, cur, val)
return res
def _amount_total(self, cr, uid, ids, field_name, arg, context=None):
""" Calculates total amount.
@param field_name: Name of field.
@param arg: Argument
@return: Dictionary of values.
"""
res = {}
untax = self._amount_untaxed(cr, uid, ids, field_name, arg, context=context)
tax = self._amount_tax(cr, uid, ids, field_name, arg, context=context)
cur_obj = self.pool.get('res.currency')
for id in ids:
repair = self.browse(cr, uid, id, context=context)
cur = repair.pricelist_id.currency_id
res[id] = cur_obj.round(cr, uid, cur, untax.get(id, 0.0) + tax.get(id, 0.0))
return res
def _get_default_address(self, cr, uid, ids, field_name, arg, context=None):
res = {}
partner_obj = self.pool.get('res.partner')
for data in self.browse(cr, uid, ids, context=context):
adr_id = False
if data.partner_id:
adr_id = partner_obj.address_get(cr, uid, [data.partner_id.id], ['contact'])['contact']
res[data.id] = adr_id
return res
def _get_lines(self, cr, uid, ids, context=None):
return self.pool['mrp.repair'].search(cr, uid, [('operations', 'in', ids)], context=context)
def _get_fee_lines(self, cr, uid, ids, context=None):
return self.pool['mrp.repair'].search(cr, uid, [('fees_lines', 'in', ids)], context=context)
_columns = {
'name': fields.char('Repair Reference', required=True, states={'confirmed': [('readonly', True)]}, copy=False),
'product_id': fields.many2one('product.product', string='Product to Repair', required=True, readonly=True, states={'draft': [('readonly', False)]}),
'product_qty': fields.float('Product Quantity', digits_compute=dp.get_precision('Product Unit of Measure'),
required=True, readonly=True, states={'draft': [('readonly', False)]}),
'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True, readonly=True, states={'draft': [('readonly', False)]}),
'partner_id': fields.many2one('res.partner', 'Partner', select=True, help='Choose partner for whom the order will be invoiced and delivered.', states={'confirmed': [('readonly', True)]}),
'address_id': fields.many2one('res.partner', 'Delivery Address', domain="[('parent_id','=',partner_id)]", states={'confirmed': [('readonly', True)]}),
'default_address_id': fields.function(_get_default_address, type="many2one", relation="res.partner"),
'state': fields.selection([
('draft', 'Quotation'),
('cancel', 'Cancelled'),
('confirmed', 'Confirmed'),
('under_repair', 'Under Repair'),
('ready', 'Ready to Repair'),
('2binvoiced', 'To be Invoiced'),
('invoice_except', 'Invoice Exception'),
('done', 'Repaired')
], 'Status', readonly=True, track_visibility='onchange', copy=False,
help=' * The \'Draft\' status is used when a user is encoding a new and unconfirmed repair order. \
\n* The \'Confirmed\' status is used when a user confirms the repair order. \
\n* The \'Ready to Repair\' status is used to start to repairing, user can start repairing only after repair order is confirmed. \
\n* The \'To be Invoiced\' status is used to generate the invoice before or after repairing done. \
\n* The \'Done\' status is set when repairing is completed.\
\n* The \'Cancelled\' status is used when user cancel repair order.'),
'location_id': fields.many2one('stock.location', 'Current Location', select=True, required=True, readonly=True, states={'draft': [('readonly', False)], 'confirmed': [('readonly', True)]}),
'location_dest_id': fields.many2one('stock.location', 'Delivery Location', readonly=True, required=True, states={'draft': [('readonly', False)], 'confirmed': [('readonly', True)]}),
'lot_id': fields.many2one('stock.production.lot', 'Repaired Lot', domain="[('product_id','=', product_id)]", help="Products repaired are all belonging to this lot", oldname="prodlot_id"),
'guarantee_limit': fields.date('Warranty Expiration', states={'confirmed': [('readonly', True)]}),
'operations': fields.one2many('mrp.repair.line', 'repair_id', 'Operation Lines', readonly=True, states={'draft': [('readonly', False)]}, copy=True),
'pricelist_id': fields.many2one('product.pricelist', 'Pricelist', help='Pricelist of the selected partner.'),
'partner_invoice_id': fields.many2one('res.partner', 'Invoicing Address'),
'invoice_method': fields.selection([
("none", "No Invoice"),
("b4repair", "Before Repair"),
("after_repair", "After Repair")
], "Invoice Method",
select=True, required=True, states={'draft': [('readonly', False)]}, readonly=True, help='Selecting \'Before Repair\' or \'After Repair\' will allow you to generate invoice before or after the repair is done respectively. \'No invoice\' means you don\'t want to generate invoice for this repair order.'),
'invoice_id': fields.many2one('account.invoice', 'Invoice', readonly=True, track_visibility="onchange", copy=False),
'move_id': fields.many2one('stock.move', 'Move', readonly=True, help="Move created by the repair order", track_visibility="onchange", copy=False),
'fees_lines': fields.one2many('mrp.repair.fee', 'repair_id', 'Fees', readonly=True, states={'draft': [('readonly', False)]}, copy=True),
'internal_notes': fields.text('Internal Notes'),
'quotation_notes': fields.text('Quotation Notes'),
'company_id': fields.many2one('res.company', 'Company'),
'invoiced': fields.boolean('Invoiced', readonly=True, copy=False),
'repaired': fields.boolean('Repaired', readonly=True, copy=False),
'amount_untaxed': fields.function(_amount_untaxed, string='Untaxed Amount',
store={
'mrp.repair': (lambda self, cr, uid, ids, c={}: ids, ['operations', 'fees_lines'], 10),
'mrp.repair.line': (_get_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
'mrp.repair.fee': (_get_fee_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
}),
'amount_tax': fields.function(_amount_tax, string='Taxes',
store={
'mrp.repair': (lambda self, cr, uid, ids, c={}: ids, ['operations', 'fees_lines'], 10),
'mrp.repair.line': (_get_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
'mrp.repair.fee': (_get_fee_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
}),
'amount_total': fields.function(_amount_total, string='Total',
store={
'mrp.repair': (lambda self, cr, uid, ids, c={}: ids, ['operations', 'fees_lines'], 10),
'mrp.repair.line': (_get_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
'mrp.repair.fee': (_get_fee_lines, ['price_unit', 'price_subtotal', 'product_id', 'tax_id', 'product_uom_qty', 'product_uom'], 10),
}),
}
def _default_stock_location(self, cr, uid, context=None):
try:
warehouse = self.pool.get('ir.model.data').get_object(cr, uid, 'stock', 'warehouse0')
return warehouse.lot_stock_id.id
except:
return False
_defaults = {
'state': lambda *a: 'draft',
'name': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').next_by_code(cr, uid, 'mrp.repair'),
'invoice_method': lambda *a: 'none',
'company_id': lambda self, cr, uid, context: self.pool.get('res.company')._company_default_get(cr, uid, 'mrp.repair', context=context),
'pricelist_id': lambda self, cr, uid, context: self.pool['product.pricelist'].search(cr, uid, [], limit=1)[0],
'product_qty': 1.0,
'location_id': _default_stock_location,
}
_sql_constraints = [
('name', 'unique (name)', 'The name of the Repair Order must be unique!'),
]
def onchange_product_id(self, cr, uid, ids, product_id=None):
""" On change of product sets some values.
@param product_id: Changed product
@return: Dictionary of values.
"""
product = False
if product_id:
product = self.pool.get("product.product").browse(cr, uid, product_id)
return {'value': {
'guarantee_limit': False,
'lot_id': False,
'product_uom': product and product.uom_id.id or False,
}
}
def onchange_product_uom(self, cr, uid, ids, product_id, product_uom, context=None):
res = {'value': {}}
if not product_uom or not product_id:
return res
product = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
uom = self.pool.get('product.uom').browse(cr, uid, product_uom, context=context)
if uom.category_id.id != product.uom_id.category_id.id:
res['warning'] = {'title': _('Warning'), 'message': _('The Product Unit of Measure you chose has a different category than in the product form.')}
res['value'].update({'product_uom': product.uom_id.id})
return res
def onchange_location_id(self, cr, uid, ids, location_id=None):
""" On change of location
"""
return {'value': {'location_dest_id': location_id}}
def button_dummy(self, cr, uid, ids, context=None):
return True
def onchange_partner_id(self, cr, uid, ids, part, address_id):
""" On change of partner sets the values of partner address,
partner invoice address and pricelist.
@param part: Changed id of partner.
@param address_id: Address id from current record.
@return: Dictionary of values.
"""
part_obj = self.pool.get('res.partner')
pricelist_obj = self.pool.get('product.pricelist')
if not part:
return {'value': {
'address_id': False,
'partner_invoice_id': False,
'pricelist_id': pricelist_obj.search(cr, uid, [], limit=1)[0]
}
}
addr = part_obj.address_get(cr, uid, [part], ['delivery', 'invoice', 'contact'])
partner = part_obj.browse(cr, uid, part)
pricelist = partner.property_product_pricelist and partner.property_product_pricelist.id or False
return {'value': {
'address_id': addr['delivery'] or addr['contact'],
'partner_invoice_id': addr['invoice'],
'pricelist_id': pricelist
}
}
def action_cancel_draft(self, cr, uid, ids, *args):
""" Cancels repair order when it is in 'Draft' state.
@param *arg: Arguments
@return: True
"""
if not len(ids):
return False
mrp_line_obj = self.pool.get('mrp.repair.line')
for repair in self.browse(cr, uid, ids):
mrp_line_obj.write(cr, uid, [l.id for l in repair.operations], {'state': 'draft'})
self.write(cr, uid, ids, {'state': 'draft'})
return self.create_workflow(cr, uid, ids)
def action_confirm(self, cr, uid, ids, *args):
""" Repair order state is set to 'To be invoiced' when invoice method
is 'Before repair' else state becomes 'Confirmed'.
@param *arg: Arguments
@return: True
"""
mrp_line_obj = self.pool.get('mrp.repair.line')
for o in self.browse(cr, uid, ids):
if (o.invoice_method == 'b4repair'):
self.write(cr, uid, [o.id], {'state': '2binvoiced'})
else:
self.write(cr, uid, [o.id], {'state': 'confirmed'})
for line in o.operations:
if line.product_id.tracking != 'none' and not line.lot_id:
raise UserError(_("Serial number is required for operation line with product '%s'") % (line.product_id.name))
mrp_line_obj.write(cr, uid, [l.id for l in o.operations], {'state': 'confirmed'})
return True
def action_cancel(self, cr, uid, ids, context=None):
""" Cancels repair order.
@return: True
"""
mrp_line_obj = self.pool.get('mrp.repair.line')
for repair in self.browse(cr, uid, ids, context=context):
if not repair.invoiced:
mrp_line_obj.write(cr, uid, [l.id for l in repair.operations], {'state': 'cancel'}, context=context)
else:
raise UserError(_('Repair order is already invoiced.'))
return self.write(cr, uid, ids, {'state': 'cancel'})
def wkf_invoice_create(self, cr, uid, ids, *args):
self.action_invoice_create(cr, uid, ids)
return True
def action_invoice_create(self, cr, uid, ids, group=False, context=None):
""" Creates invoice(s) for repair order.
@param group: It is set to true when group invoice is to be generated.
@return: Invoice Ids.
"""
res = {}
invoices_group = {}
inv_line_obj = self.pool.get('account.invoice.line')
inv_obj = self.pool.get('account.invoice')
repair_line_obj = self.pool.get('mrp.repair.line')
repair_fee_obj = self.pool.get('mrp.repair.fee')
for repair in self.browse(cr, uid, ids, context=context):
res[repair.id] = False
if repair.state in ('draft', 'cancel') or repair.invoice_id:
continue
if not (repair.partner_id.id and repair.partner_invoice_id.id):
raise UserError(_('You have to select a Partner Invoice Address in the repair form!'))
comment = repair.quotation_notes
if (repair.invoice_method != 'none'):
if group and repair.partner_invoice_id.id in invoices_group:
inv_id = invoices_group[repair.partner_invoice_id.id]
invoice = inv_obj.browse(cr, uid, inv_id)
invoice_vals = {
'name': invoice.name + ', ' + repair.name,
'origin': invoice.origin + ', ' + repair.name,
'comment': (comment and (invoice.comment and invoice.comment + "\n" + comment or comment)) or (invoice.comment and invoice.comment or ''),
}
inv_obj.write(cr, uid, [inv_id], invoice_vals, context=context)
else:
if not repair.partner_id.property_account_receivable_id:
raise UserError(_('No account defined for partner "%s".') % repair.partner_id.name)
account_id = repair.partner_id.property_account_receivable_id.id
inv = {
'name': repair.name,
'origin': repair.name,
'type': 'out_invoice',
'account_id': account_id,
'partner_id': repair.partner_invoice_id.id or repair.partner_id.id,
'currency_id': repair.pricelist_id.currency_id.id,
'comment': repair.quotation_notes,
'fiscal_position_id': repair.partner_id.property_account_position_id.id
}
inv_id = inv_obj.create(cr, uid, inv)
invoices_group[repair.partner_invoice_id.id] = inv_id
self.write(cr, uid, repair.id, {'invoiced': True, 'invoice_id': inv_id})
for operation in repair.operations:
if operation.to_invoice:
if group:
name = repair.name + '-' + operation.name
else:
name = operation.name
if operation.product_id.property_account_income_id:
account_id = operation.product_id.property_account_income_id.id
elif operation.product_id.categ_id.property_account_income_categ_id:
account_id = operation.product_id.categ_id.property_account_income_categ_id.id
else:
raise UserError(_('No account defined for product "%s".') % operation.product_id.name)
invoice_line_id = inv_line_obj.create(cr, uid, {
'invoice_id': inv_id,
'name': name,
'origin': repair.name,
'account_id': account_id,
'quantity': operation.product_uom_qty,
'invoice_line_tax_ids': [(6, 0, [x.id for x in operation.tax_id])],
'uom_id': operation.product_uom.id,
'price_unit': operation.price_unit,
'price_subtotal': operation.product_uom_qty * operation.price_unit,
'product_id': operation.product_id and operation.product_id.id or False
})
repair_line_obj.write(cr, uid, [operation.id], {'invoiced': True, 'invoice_line_id': invoice_line_id})
for fee in repair.fees_lines:
if fee.to_invoice:
if group:
name = repair.name + '-' + fee.name
else:
name = fee.name
if not fee.product_id:
raise UserError(_('No product defined on Fees!'))
if fee.product_id.property_account_income_id:
account_id = fee.product_id.property_account_income_id.id
elif fee.product_id.categ_id.property_account_income_categ_id:
account_id = fee.product_id.categ_id.property_account_income_categ_id.id
else:
raise UserError(_('No account defined for product "%s".') % fee.product_id.name)
invoice_fee_id = inv_line_obj.create(cr, uid, {
'invoice_id': inv_id,
'name': name,
'origin': repair.name,
'account_id': account_id,
'quantity': fee.product_uom_qty,
'invoice_line_tax_ids': [(6, 0, [x.id for x in fee.tax_id])],
'uom_id': fee.product_uom.id,
'product_id': fee.product_id and fee.product_id.id or False,
'price_unit': fee.price_unit,
'price_subtotal': fee.product_uom_qty * fee.price_unit
})
repair_fee_obj.write(cr, uid, [fee.id], {'invoiced': True, 'invoice_line_id': invoice_fee_id})
#inv_obj.button_reset_taxes(cr, uid, inv_id, context=context)
res[repair.id] = inv_id
return res
def action_repair_ready(self, cr, uid, ids, context=None):
""" Writes repair order state to 'Ready'
@return: True
"""
for repair in self.browse(cr, uid, ids, context=context):
self.pool.get('mrp.repair.line').write(cr, uid, [l.id for
l in repair.operations], {'state': 'confirmed'}, context=context)
self.write(cr, uid, [repair.id], {'state': 'ready'})
return True
def action_repair_start(self, cr, uid, ids, context=None):
""" Writes repair order state to 'Under Repair'
@return: True
"""
repair_line = self.pool.get('mrp.repair.line')
for repair in self.browse(cr, uid, ids, context=context):
repair_line.write(cr, uid, [l.id for
l in repair.operations], {'state': 'confirmed'}, context=context)
repair.write({'state': 'under_repair'})
return True
def action_repair_end(self, cr, uid, ids, context=None):
""" Writes repair order state to 'To be invoiced' if invoice method is
After repair else state is set to 'Ready'.
@return: True
"""
for order in self.browse(cr, uid, ids, context=context):
val = {}
val['repaired'] = True
if (not order.invoiced and order.invoice_method == 'after_repair'):
val['state'] = '2binvoiced'
elif (not order.invoiced and order.invoice_method == 'b4repair'):
val['state'] = 'ready'
else:
pass
self.write(cr, uid, [order.id], val)
return True
def wkf_repair_done(self, cr, uid, ids, *args):
self.action_repair_done(cr, uid, ids)
return True
def action_repair_done(self, cr, uid, ids, context=None):
""" Creates stock move for operation and stock move for final product of repair order.
@return: Move ids of final products
"""
res = {}
move_obj = self.pool.get('stock.move')
repair_line_obj = self.pool.get('mrp.repair.line')
for repair in self.browse(cr, uid, ids, context=context):
move_ids = []
for move in repair.operations:
move_id = move_obj.create(cr, uid, {
'name': move.name,
'product_id': move.product_id.id,
'restrict_lot_id': move.lot_id.id,
'product_uom_qty': move.product_uom_qty,
'product_uom': move.product_uom.id,
'partner_id': repair.address_id and repair.address_id.id or False,
'location_id': move.location_id.id,
'location_dest_id': move.location_dest_id.id,
})
move_ids.append(move_id)
repair_line_obj.write(cr, uid, [move.id], {'move_id': move_id, 'state': 'done'}, context=context)
move_id = move_obj.create(cr, uid, {
'name': repair.name,
'product_id': repair.product_id.id,
'product_uom': repair.product_uom.id or repair.product_id.uom_id.id,
'product_uom_qty': repair.product_qty,
'partner_id': repair.address_id and repair.address_id.id or False,
'location_id': repair.location_id.id,
'location_dest_id': repair.location_dest_id.id,
'restrict_lot_id': repair.lot_id.id,
})
move_ids.append(move_id)
move_obj.action_done(cr, uid, move_ids, context=context)
self.write(cr, uid, [repair.id], {'state': 'done', 'move_id': move_id}, context=context)
res[repair.id] = move_id
return res
class sale_order_option(osv.osv):
_name = "sale.order.option"
_description = "Sale Options"
_columns = {
'order_id':
fields.many2one('sale.order',
'Sale Order Reference',
ondelete='cascade',
select=True),
'line_id':
fields.many2one('sale.order.line', on_delete="set null"),
'name':
fields.text('Description', required=True),
'product_id':
fields.many2one('product.product',
'Product',
domain=[('sale_ok', '=', True)]),
'website_description':
fields.html('Line Description'),
'price_unit':
fields.float('Unit Price',
required=True,
digits_compute=dp.get_precision('Product Price')),
'discount':
fields.float('Discount (%)',
digits_compute=dp.get_precision('Discount')),
'uom_id':
fields.many2one('product.uom', 'Unit of Measure ', required=True),
'quantity':
fields.float('Quantity',
required=True,
digits_compute=dp.get_precision('Product UoS')),
}
_defaults = {
'quantity': 1,
}
# TODO master: to remove, replaced by onchange of the new api
def on_change_product_id(self,
cr,
uid,
ids,
product,
uom_id=None,
context=None):
vals, domain = {}, []
if not product:
return vals
product_obj = self.pool.get('product.product').browse(cr,
uid,
product,
context=context)
name = product_obj.name
if product_obj.description_sale:
name += '\n' + product_obj.description_sale
vals.update({
'price_unit':
product_obj.list_price,
'website_description':
product_obj and
(product_obj.quote_description or product_obj.website_description),
'name':
name,
'uom_id':
uom_id or product_obj.uom_id.id,
})
uom_obj = self.pool.get('product.uom')
if vals['uom_id'] != product_obj.uom_id.id:
selected_uom = uom_obj.browse(cr,
uid,
vals['uom_id'],
context=context)
new_price = uom_obj._compute_price(cr, uid, product_obj.uom_id.id,
vals['price_unit'],
vals['uom_id'])
vals['price_unit'] = new_price
if not uom_id:
domain = {
'uom_id':
[('category_id', '=', product_obj.uom_id.category_id.id)]
}
return {'value': vals, 'domain': domain}
# TODO master: to remove, replaced by onchange of the new api
def product_uom_change(self, cr, uid, ids, product, uom_id, context=None):
context = context or {}
if not uom_id:
return {'value': {'price_unit': 0.0, 'uom_id': False}}
return self.on_change_product_id(cr,
uid,
ids,
product,
uom_id=uom_id,
context=context)
@api.onchange('product_id', 'uom_id')
def _onchange_product_id(self):
if not self.product_id:
return
product = self.product_id.with_context(
lang=self.order_id.partner_id.lang)
self.price_unit = product.list_price
self.website_description = product.quote_description or product.website_description
self.name = product.name
if product.description_sale:
self.name += '\n' + product.description_sale
self.uom_id = product.product_tmpl_id.uom_id
if product and self.order_id.pricelist_id:
partner_id = self.order_id.partner_id.id
pricelist = self.order_id.pricelist_id.id
self.price_unit = self.order_id.pricelist_id.price_get(
product.id, self.quantity, partner_id)[pricelist]
if self.uom_id and self.uom_id != self.product_id.uom_id:
self.price_unit = self.product_id.uom_id._compute_price(
self.price_unit, self.uom_id.id)
domain = {
'uom_id':
[('category_id', '=', self.product_id.uom_id.category_id.id)]
}
return {'domain': domain}
class procurement_order(osv.osv):
"""
Procurement Orders
"""
_name = "procurement.order"
_description = "Procurement"
_order = 'priority desc, date_planned, id asc'
_inherit = ['mail.thread', 'ir.needaction_mixin']
_log_create = False
_columns = {
'name':
fields.text('Description', required=True),
'origin':
fields.char(
'Source Document',
help="Reference of the document that created this Procurement.\n"
"This is automatically completed by YuanCloud."),
'company_id':
fields.many2one('res.company', 'Company', required=True),
# These two fields are used for shceduling
'priority':
fields.selection(PROCUREMENT_PRIORITIES,
'Priority',
required=True,
select=True,
track_visibility='onchange'),
'date_planned':
fields.datetime('Scheduled Date',
required=True,
select=True,
track_visibility='onchange'),
'group_id':
fields.many2one('procurement.group', 'Procurement Group'),
'rule_id':
fields.many2one(
'procurement.rule',
'Rule',
track_visibility='onchange',
help=
"Chosen rule for the procurement resolution. Usually chosen by the system but can be manually set by the procurement manager to force an unusual behavior."
),
'product_id':
fields.many2one('product.product',
'Product',
required=True,
states={'confirmed': [('readonly', False)]},
readonly=True),
'product_qty':
fields.float(
'Quantity',
digits_compute=dp.get_precision('Product Unit of Measure'),
required=True,
states={'confirmed': [('readonly', False)]},
readonly=True),
'product_uom':
fields.many2one('product.uom',
'Product Unit of Measure',
required=True,
states={'confirmed': [('readonly', False)]},
readonly=True),
'state':
fields.selection([('cancel', 'Cancelled'), ('confirmed', 'Confirmed'),
('exception', 'Exception'), ('running', 'Running'),
('done', 'Done')],
'Status',
required=True,
track_visibility='onchange',
copy=False),
}
_defaults = {
'state':
'confirmed',
'priority':
'1',
'date_planned':
lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
'company_id':
lambda self, cr, uid, c: self.pool.get('res.company').
_company_default_get(cr, uid, 'procurement.order', context=c)
}
def _needaction_domain_get(self, cr, uid, context=None):
return [('state', '=', 'exception')]
def unlink(self, cr, uid, ids, context=None):
procurements = self.read(cr, uid, ids, ['state'], context=context)
unlink_ids = []
for s in procurements:
if s['state'] == 'cancel':
unlink_ids.append(s['id'])
else:
raise UserError(
_('Cannot delete Procurement Order(s) which are in %s state.'
) % s['state'])
return osv.osv.unlink(self, cr, uid, unlink_ids, context=context)
def create(self, cr, uid, vals, context=None):
context = context or {}
procurement_id = super(procurement_order, self).create(cr,
uid,
vals,
context=context)
if not context.get('procurement_autorun_defer'):
self.run(cr, uid, [procurement_id], context=context)
return procurement_id
def do_view_procurements(self, cr, uid, ids, context=None):
'''
This function returns an action that display existing procurement orders
of same procurement group of given ids.
'''
act_obj = self.pool.get('ir.actions.act_window')
action_id = self.pool.get('ir.model.data').xmlid_to_res_id(
cr,
uid,
'procurement.do_view_procurements',
raise_if_not_found=True)
result = act_obj.read(cr, uid, [action_id], context=context)[0]
group_ids = set([
proc.group_id.id
for proc in self.browse(cr, uid, ids, context=context)
if proc.group_id
])
result['domain'] = "[('group_id','in',[" + ','.join(
map(str, list(group_ids))) + "])]"
return result
def onchange_product_id(self, cr, uid, ids, product_id, context=None):
""" Finds UoM of changed product.
@param product_id: Changed id of product.
@return: Dictionary of values.
"""
if product_id:
w = self.pool.get('product.product').browse(cr,
uid,
product_id,
context=context)
v = {
'product_uom': w.uom_id.id,
}
return {'value': v}
return {}
def get_cancel_ids(self, cr, uid, ids, context=None):
return [
proc.id for proc in self.browse(cr, uid, ids, context=context)
if proc.state != 'done'
]
def cancel(self, cr, uid, ids, context=None):
#cancel only the procurements that aren't done already
to_cancel_ids = self.get_cancel_ids(cr, uid, ids, context=context)
if to_cancel_ids:
return self.write(cr,
uid,
to_cancel_ids, {'state': 'cancel'},
context=context)
def reset_to_confirmed(self, cr, uid, ids, context=None):
return self.write(cr,
uid,
ids, {'state': 'confirmed'},
context=context)
@api.v8
def run(self, autocommit=False):
return self._model.run(self._cr,
self._uid,
self.ids,
autocommit=False,
context=self._context)
@api.v7
def run(self, cr, uid, ids, autocommit=False, context=None):
for procurement_id in ids:
#we intentionnaly do the browse under the for loop to avoid caching all ids which would be resource greedy
#and useless as we'll make a refresh later that will invalidate all the cache (and thus the next iteration
#will fetch all the ids again)
procurement = self.browse(cr, uid, procurement_id, context=context)
if procurement.state not in ("running", "done"):
try:
if self._assign(cr, uid, procurement, context=context):
res = self._run(cr,
uid,
procurement,
context=context or {})
if res:
self.write(cr,
uid, [procurement.id],
{'state': 'running'},
context=context)
else:
self.write(cr,
uid, [procurement.id],
{'state': 'exception'},
context=context)
else:
self.message_post(
cr,
uid, [procurement.id],
body=_('No rule matching this procurement'),
context=context)
self.write(cr,
uid, [procurement.id],
{'state': 'exception'},
context=context)
if autocommit:
cr.commit()
except OperationalError:
if autocommit:
cr.rollback()
continue
else:
raise
return True
def check(self, cr, uid, ids, autocommit=False, context=None):
done_ids = []
for procurement in self.browse(cr, uid, ids, context=context):
try:
result = self._check(cr, uid, procurement, context=context)
if result:
done_ids.append(procurement.id)
if autocommit:
cr.commit()
except OperationalError:
if autocommit:
cr.rollback()
continue
else:
raise
if done_ids:
self.write(cr, uid, done_ids, {'state': 'done'}, context=context)
return done_ids
#
# Method to overwrite in different procurement modules
#
def _find_suitable_rule(self, cr, uid, procurement, context=None):
'''This method returns a procurement.rule that depicts what to do with the given procurement
in order to complete its needs. It returns False if no suiting rule is found.
:param procurement: browse record
:rtype: int or False
'''
return False
def _assign(self, cr, uid, procurement, context=None):
'''This method check what to do with the given procurement in order to complete its needs.
It returns False if no solution is found, otherwise it stores the matching rule (if any) and
returns True.
:param procurement: browse record
:rtype: boolean
'''
#if the procurement already has a rule assigned, we keep it (it has a higher priority as it may have been chosen manually)
if procurement.rule_id:
return True
elif procurement.product_id.type not in ('service', 'digital'):
rule_id = self._find_suitable_rule(cr,
uid,
procurement,
context=context)
if rule_id:
self.write(cr,
uid, [procurement.id], {'rule_id': rule_id},
context=context)
return True
return False
def _run(self, cr, uid, procurement, context=None):
'''This method implements the resolution of the given procurement
:param procurement: browse record
:returns: True if the resolution of the procurement was a success, False otherwise to set it in exception
'''
return True
def _check(self, cr, uid, procurement, context=None):
'''Returns True if the given procurement is fulfilled, False otherwise
:param procurement: browse record
:rtype: boolean
'''
return False
#
# Scheduler
#
def run_scheduler(self,
cr,
uid,
use_new_cursor=False,
company_id=False,
context=None):
'''
Call the scheduler to check the procurement order. This is intented to be done for all existing companies at
the same time, so we're running all the methods as SUPERUSER to avoid intercompany and access rights issues.
@param self: The object pointer
@param cr: The current row, from the database cursor,
@param uid: The current user ID for security checks
@param ids: List of selected IDs
@param use_new_cursor: if set, use a dedicated cursor and auto-commit after processing each procurement.
This is appropriate for batch jobs only.
@param context: A standard dictionary for contextual values
@return: Dictionary of values
'''
if context is None:
context = {}
try:
if use_new_cursor:
cr = yuancloud.registry(cr.dbname).cursor()
# Run confirmed procurements
dom = [('state', '=', 'confirmed')]
if company_id:
dom += [('company_id', '=', company_id)]
prev_ids = []
while True:
ids = self.search(cr, SUPERUSER_ID, dom, context=context)
if not ids or prev_ids == ids:
break
else:
prev_ids = ids
self.run(cr,
SUPERUSER_ID,
ids,
autocommit=use_new_cursor,
context=context)
if use_new_cursor:
cr.commit()
# Check if running procurements are done
offset = 0
dom = [('state', '=', 'running')]
if company_id:
dom += [('company_id', '=', company_id)]
prev_ids = []
while True:
ids = self.search(cr,
SUPERUSER_ID,
dom,
offset=offset,
context=context)
if not ids or prev_ids == ids:
break
else:
prev_ids = ids
self.check(cr,
SUPERUSER_ID,
ids,
autocommit=use_new_cursor,
context=context)
if use_new_cursor:
cr.commit()
finally:
if use_new_cursor:
try:
cr.close()
except Exception:
pass
return {}
class change_standard_price(osv.osv_memory):
_name = "stock.change.standard.price"
_description = "Change Standard Price"
_columns = {
'new_price':
fields.float(
'Price',
required=True,
digits_compute=dp.get_precision('Product Price'),
help=
"If cost price is increased, stock variation account will be debited "
"and stock output account will be credited with the value = (difference of amount * quantity available).\n"
"If cost price is decreased, stock variation account will be creadited and stock input account will be debited."
),
}
def default_get(self, cr, uid, fields, context=None):
""" To get default values for the object.
@param self: The object pointer.
@param cr: A database cursor
@param uid: ID of the user currently logged in
@param fields: List of fields for which we want default values
@param context: A standard dictionary
@return: A dictionary which of fields with values.
"""
if context is None:
context = {}
if context.get("active_model") == 'product.product':
product_pool = self.pool.get('product.product')
else:
product_pool = self.pool.get('product.template')
product_obj = product_pool.browse(cr, uid,
context.get('active_id', False))
res = super(change_standard_price, self).default_get(cr,
uid,
fields,
context=context)
price = product_obj.standard_price
if 'new_price' in fields:
res.update({'new_price': price})
return res
def change_price(self, cr, uid, ids, context=None):
""" Changes the Standard Price of Product.
And creates an account move accordingly.
@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:
"""
if context is None:
context = {}
rec_id = context.get('active_id', False)
assert rec_id, _('Active ID is not set in Context.')
if context.get("active_model") == 'product.product':
prod_obj = self.pool.get('product.product')
rec_id = prod_obj.browse(cr, uid, rec_id,
context=context).product_tmpl_id.id
prod_obj = self.pool.get('product.template')
res = self.browse(cr, uid, ids, context=context)
prod_obj.do_change_standard_price(cr, uid, [rec_id], res[0].new_price,
context)
return {'type': 'ir.actions.act_window_close'}
