from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta
import time
-import pooler
-from osv import fields, osv
-from tools.translate import _
-from tools import DEFAULT_SERVER_DATE_FORMAT, DEFAULT_SERVER_DATETIME_FORMAT, float_compare
-import decimal_precision as dp
-import netsvc
+from openerp import pooler
+from openerp.osv import fields, osv
+from openerp.tools.translate import _
+from openerp.tools import DEFAULT_SERVER_DATE_FORMAT, DEFAULT_SERVER_DATETIME_FORMAT, DATETIME_FORMATS_MAP, float_compare
+import openerp.addons.decimal_precision as dp
+from openerp import netsvc
class sale_shop(osv.osv):
_name = "sale.shop"
_columns = {
'name': fields.char('Shop Name', size=64, required=True),
'payment_default_id': fields.many2one('account.payment.term', 'Default Payment Term', required=True),
- 'warehouse_id': fields.many2one('stock.warehouse', 'Warehouse'),
'pricelist_id': fields.many2one('product.pricelist', 'Pricelist'),
'project_id': fields.many2one('account.analytic.account', 'Analytic Account', domain=[('parent_id', '!=', False)]),
'company_id': fields.many2one('res.company', 'Company', required=False),
class sale_order(osv.osv):
_name = "sale.order"
+ _inherit = ['mail.thread', 'ir.needaction_mixin']
_description = "Sales Order"
+ _track = {
+ 'state': {
+ 'sale.mt_order_confirmed': lambda self, cr, uid, obj, ctx=None: obj['state'] in ['manual', 'progress'],
+ 'sale.mt_order_sent': lambda self, cr, uid, obj, ctx=None: obj['state'] in ['sent']
+ },
+ }
+
+ def onchange_shop_id(self, cr, uid, ids, shop_id, context=None):
+ v = {}
+ if shop_id:
+ shop = self.pool.get('sale.shop').browse(cr, uid, shop_id, context=context)
+ if shop.project_id.id:
+ v['project_id'] = shop.project_id.id
+ if shop.pricelist_id.id:
+ v['pricelist_id'] = shop.pricelist_id.id
+ return {'value': v}
def copy(self, cr, uid, id, default=None, context=None):
if not default:
default = {}
default.update({
'state': 'draft',
- 'shipped': False,
'invoice_ids': [],
- 'picking_ids': [],
'date_confirm': False,
'name': self.pool.get('ir.sequence').get(cr, uid, 'sale.order'),
})
def _amount_line_tax(self, cr, uid, line, context=None):
val = 0.0
- for c in self.pool.get('account.tax').compute_all(cr, uid, line.tax_id, line.price_unit * (1-(line.discount or 0.0)/100.0), line.product_uom_qty, line.order_id.partner_invoice_id.id, line.product_id, line.order_id.partner_id)['taxes']:
+ for c in self.pool.get('account.tax').compute_all(cr, uid, line.tax_id, line.price_unit * (1-(line.discount or 0.0)/100.0), line.product_uom_qty, line.product_id, line.order_id.partner_id)['taxes']:
val += c.get('amount', 0.0)
return val
res[order.id]['amount_total'] = res[order.id]['amount_untaxed'] + res[order.id]['amount_tax']
return res
- # This is False
- def _picked_rate(self, cr, uid, ids, name, arg, context=None):
- if not ids:
- return {}
- res = {}
- tmp = {}
- for id in ids:
- tmp[id] = {'picked': 0.0, 'total': 0.0}
- cr.execute('''SELECT
- p.sale_id as sale_order_id, sum(m.product_qty) as nbr, mp.state as procurement_state, m.state as move_state, p.type as picking_type
- FROM
- stock_move m
- LEFT JOIN
- stock_picking p on (p.id=m.picking_id)
- LEFT JOIN
- procurement_order mp on (mp.move_id=m.id)
- WHERE
- p.sale_id IN %s GROUP BY m.state, mp.state, p.sale_id, p.type''', (tuple(ids),))
-
- for item in cr.dictfetchall():
- if item['move_state'] == 'cancel':
- continue
-
- if item['picking_type'] == 'in':#this is a returned picking
- tmp[item['sale_order_id']]['total'] -= item['nbr'] or 0.0 # Deducting the return picking qty
- if item['procurement_state'] == 'done' or item['move_state'] == 'done':
- tmp[item['sale_order_id']]['picked'] -= item['nbr'] or 0.0
- else:
- tmp[item['sale_order_id']]['total'] += item['nbr'] or 0.0
- if item['procurement_state'] == 'done' or item['move_state'] == 'done':
- tmp[item['sale_order_id']]['picked'] += item['nbr'] or 0.0
-
- for order in self.browse(cr, uid, ids, context=context):
- if order.shipped:
- res[order.id] = 100.0
- else:
- res[order.id] = tmp[order.id]['total'] and (100.0 * tmp[order.id]['picked'] / tmp[order.id]['total']) or 0.0
- return res
def _invoiced_rate(self, cursor, user, ids, name, arg, context=None):
res = {}
res[sale.id] = 0.0
return res
+ def _invoice_exists(self, cursor, user, ids, name, arg, context=None):
+ res = {}
+ for sale in self.browse(cursor, user, ids, context=context):
+ res[sale.id] = False
+ if sale.invoice_ids:
+ res[sale.id] = True
+ return res
+
def _invoiced(self, cursor, user, ids, name, arg, context=None):
res = {}
for sale in self.browse(cursor, user, ids, context=context):
if invoice.state != 'paid':
res[sale.id] = False
break
- if not invoice_existence:
+ if not invoice_existence or sale.state == 'manual':
res[sale.id] = False
return res
result[line.order_id.id] = True
return result.keys()
+ def _get_default_shop(self, cr, uid, context=None):
+ company_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.id
+ shop_ids = self.pool.get('sale.shop').search(cr, uid, [('company_id','=',company_id)], context=context)
+ if not shop_ids:
+ raise osv.except_osv(_('Error!'), _('There is no default shop for the current user\'s company!'))
+ return shop_ids[0]
+
_columns = {
'name': fields.char('Order Reference', size=64, required=True,
- readonly=True, states={'draft': [('readonly', False)]}, select=True),
- 'shop_id': fields.many2one('sale.shop', 'Shop', required=True, readonly=True, states={'draft': [('readonly', False)]}),
+ readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, select=True),
+ 'shop_id': fields.many2one('sale.shop', 'Shop', required=True, readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}),
'origin': fields.char('Source Document', size=64, help="Reference of the document that generated this sales order request."),
'client_order_ref': fields.char('Customer Reference', size=64),
'state': fields.selection([
- ('draft', 'Quotation'),
+ ('draft', 'Draft Quotation'),
+ ('sent', 'Quotation Sent'),
+ ('cancel', 'Cancelled'),
('waiting_date', 'Waiting Schedule'),
- ('manual', 'To Invoice'),
- ('progress', 'In Progress'),
- ('shipping_except', 'Shipping Exception'),
+ ('progress', 'Sales Order'),
+ ('manual', 'Sale to Invoice'),
('invoice_except', 'Invoice Exception'),
('done', 'Done'),
- ('cancel', 'Cancelled')
- ], 'Order State', readonly=True, help="Gives the state of the quotation or sales order. \nThe exception state is automatically set when a cancel operation occurs in the invoice validation (Invoice Exception) or in the picking list process (Shipping Exception). \nThe 'Waiting Schedule' state is set when the invoice is confirmed but waiting for the scheduler to run on the order date.", select=True),
- 'date_order': fields.date('Date', required=True, readonly=True, select=True, states={'draft': [('readonly', False)]}),
+ ], 'Status', readonly=True, track_visibility='onchange',
+ help="Gives the status of the quotation or sales order. \nThe exception status is automatically set when a cancel operation occurs in the processing of a document linked to the sales order. \nThe 'Waiting Schedule' status is set when the invoice is confirmed but waiting for the scheduler to run on the order date.", select=True),
+ 'date_order': fields.date('Date', required=True, readonly=True, select=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}),
'create_date': fields.datetime('Creation Date', readonly=True, select=True, help="Date on which sales order is created."),
'date_confirm': fields.date('Confirmation Date', readonly=True, select=True, help="Date on which sales order is confirmed."),
- 'user_id': fields.many2one('res.users', 'Salesman', states={'draft': [('readonly', False)]}, select=True),
- 'partner_id': fields.many2one('res.partner', 'Customer', readonly=True, states={'draft': [('readonly', False)]}, required=True, change_default=True, select=True),
- 'partner_invoice_id': fields.many2one('res.partner.address', 'Invoice Address', readonly=True, required=True, states={'draft': [('readonly', False)]}, help="Invoice address for current sales order."),
- 'partner_order_id': fields.many2one('res.partner.address', 'Ordering Contact', readonly=True, required=True, states={'draft': [('readonly', False)]}, help="The name and address of the contact who requested the order or quotation."),
- 'partner_shipping_id': fields.many2one('res.partner.address', 'Shipping Address', readonly=True, required=True, states={'draft': [('readonly', False)]}, help="Shipping address for current sales order."),
-
- 'incoterm': fields.many2one('stock.incoterms', 'Incoterm', help="Incoterm which stands for 'International Commercial terms' implies its a series of sales terms which are used in the commercial transaction."),
- 'picking_policy': fields.selection([('direct', 'Deliver each product when available'), ('one', 'Deliver all products at once')],
- 'Picking Policy', required=True, readonly=True, states={'draft': [('readonly', False)]}, help="""If you don't have enough stock available to deliver all at once, do you accept partial shipments or not?"""),
+ 'user_id': fields.many2one('res.users', 'Salesperson', states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, select=True, track_visibility='onchange'),
+ 'partner_id': fields.many2one('res.partner', 'Customer', readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, required=True, change_default=True, select=True, track_visibility='always'),
+ 'partner_invoice_id': fields.many2one('res.partner', 'Invoice Address', readonly=True, required=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, help="Invoice address for current sales order."),
+ 'partner_shipping_id': fields.many2one('res.partner', 'Delivery Address', readonly=True, required=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, help="Delivery address for current sales order."),
'order_policy': fields.selection([
- ('prepaid', 'Pay before delivery'),
- ('manual', 'Deliver & invoice on demand'),
- ('picking', 'Invoice based on deliveries'),
- ('postpaid', 'Invoice on order after delivery'),
- ], 'Invoice Policy', required=True, readonly=True, states={'draft': [('readonly', False)]},
- help="""The Invoice Policy is used to synchronise invoice and delivery operations.
- - The 'Pay before delivery' choice will first generate the invoice and then generate the picking order after the payment of this invoice.
- - The 'Deliver & Invoice on demand' will create the picking order directly and wait for the user to manually click on the 'Invoice' button to generate the draft invoice based on the sale order or the sale order lines.
- - The 'Invoice on order after delivery' choice will generate the draft invoice based on sales order after all picking lists have been finished.
- - The 'Invoice based on deliveries' choice is used to create an invoice during the picking process."""),
- 'pricelist_id': fields.many2one('product.pricelist', 'Pricelist', required=True, readonly=True, states={'draft': [('readonly', False)]}, help="Pricelist for current sales order."),
- 'project_id': fields.many2one('account.analytic.account', 'Contract/Analytic Account', readonly=True, states={'draft': [('readonly', False)]}, help="The analytic account related to a sales order."),
-
- 'order_line': fields.one2many('sale.order.line', 'order_id', 'Order Lines', readonly=True, states={'draft': [('readonly', False)]}),
+ ('manual', 'On Demand'),
+ ], 'Create Invoice', required=True, readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]},
+ help="""This field controls how invoice and delivery operations are synchronized.
+ - With 'Before Delivery', a draft invoice is created, and it must be paid before delivery."""),
+ 'pricelist_id': fields.many2one('product.pricelist', 'Pricelist', required=True, readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, help="Pricelist for current sales order."),
+ 'currency_id': fields.related('pricelist_id', 'currency_id', type="many2one", relation="res.currency", string="Currency", readonly=True, required=True),
+ 'project_id': fields.many2one('account.analytic.account', 'Contract / Analytic', readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}, help="The analytic account related to a sales order."),
+
+ 'order_line': fields.one2many('sale.order.line', 'order_id', 'Order Lines', readonly=True, states={'draft': [('readonly', False)], 'sent': [('readonly', False)]}),
'invoice_ids': fields.many2many('account.invoice', 'sale_order_invoice_rel', 'order_id', 'invoice_id', 'Invoices', readonly=True, help="This is the list of invoices that have been generated for this sales order. The same sales order may have been invoiced in several times (by line for example)."),
- 'picking_ids': fields.one2many('stock.picking', 'sale_id', 'Related Picking', readonly=True, help="This is a list of picking that has been generated for this sales order."),
- 'shipped': fields.boolean('Delivered', readonly=True, help="It indicates that the sales order has been delivered. This field is updated only after the scheduler(s) have been launched."),
- 'picked_rate': fields.function(_picked_rate, string='Picked', type='float'),
- 'invoiced_rate': fields.function(_invoiced_rate, string='Invoiced', type='float'),
+ 'invoiced_rate': fields.function(_invoiced_rate, string='Invoiced Ratio', type='float'),
'invoiced': fields.function(_invoiced, string='Paid',
fnct_search=_invoiced_search, type='boolean', help="It indicates that an invoice has been paid."),
- 'note': fields.text('Notes'),
+ 'invoice_exists': fields.function(_invoice_exists, string='Invoiced',
+ fnct_search=_invoiced_search, type='boolean', help="It indicates that sales order has at least one invoice."),
+ 'note': fields.text('Terms and conditions'),
- 'amount_untaxed': fields.function(_amount_all, digits_compute= dp.get_precision('Sale Price'), string='Untaxed Amount',
- store = {
+ 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Untaxed Amount',
+ store={
'sale.order': (lambda self, cr, uid, ids, c={}: ids, ['order_line'], 10),
'sale.order.line': (_get_order, ['price_unit', 'tax_id', 'discount', 'product_uom_qty'], 10),
},
- multi='sums', help="The amount without tax."),
- 'amount_tax': fields.function(_amount_all, digits_compute= dp.get_precision('Sale Price'), string='Taxes',
- store = {
+ multi='sums', help="The amount without tax.", track_visibility='always'),
+ 'amount_tax': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Taxes',
+ store={
'sale.order': (lambda self, cr, uid, ids, c={}: ids, ['order_line'], 10),
'sale.order.line': (_get_order, ['price_unit', 'tax_id', 'discount', 'product_uom_qty'], 10),
},
multi='sums', help="The tax amount."),
- 'amount_total': fields.function(_amount_all, digits_compute= dp.get_precision('Sale Price'), string='Total',
- store = {
+ 'amount_total': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Total',
+ store={
'sale.order': (lambda self, cr, uid, ids, c={}: ids, ['order_line'], 10),
'sale.order.line': (_get_order, ['price_unit', 'tax_id', 'discount', 'product_uom_qty'], 10),
},
multi='sums', help="The total amount."),
- 'invoice_quantity': fields.selection([('order', 'Ordered Quantities'), ('procurement', 'Shipped Quantities')], 'Invoice on', help="The sale order will automatically create the invoice proposition (draft invoice). Ordered and delivered quantities may not be the same. You have to choose if you want your invoice based on ordered or shipped quantities. If the product is a service, shipped quantities means hours spent on the associated tasks.", required=True, readonly=True, states={'draft': [('readonly', False)]}),
+ 'invoice_quantity': fields.selection([('order', 'Ordered Quantities')], 'Invoice on', help="The sales order will automatically create the invoice proposition (draft invoice).", required=True, readonly=True, states={'draft': [('readonly', False)]}),
'payment_term': fields.many2one('account.payment.term', 'Payment Term'),
'fiscal_position': fields.many2one('account.fiscal.position', 'Fiscal Position'),
'company_id': fields.related('shop_id','company_id',type='many2one',relation='res.company',string='Company',store=True,readonly=True)
}
_defaults = {
- 'picking_policy': 'direct',
'date_order': fields.date.context_today,
'order_policy': 'manual',
'state': 'draft',
'user_id': lambda obj, cr, uid, context: uid,
- 'name': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'sale.order'),
+ 'name': lambda obj, cr, uid, context: '/',
'invoice_quantity': 'order',
+ 'shop_id': _get_default_shop,
'partner_invoice_id': lambda self, cr, uid, context: context.get('partner_id', False) and self.pool.get('res.partner').address_get(cr, uid, [context['partner_id']], ['invoice'])['invoice'],
- 'partner_order_id': lambda self, cr, uid, context: context.get('partner_id', False) and self.pool.get('res.partner').address_get(cr, uid, [context['partner_id']], ['contact'])['contact'],
'partner_shipping_id': lambda self, cr, uid, context: context.get('partner_id', False) and self.pool.get('res.partner').address_get(cr, uid, [context['partner_id']], ['delivery'])['delivery'],
}
_sql_constraints = [
if s['state'] in ['draft', 'cancel']:
unlink_ids.append(s['id'])
else:
- raise osv.except_osv(_('Invalid action !'), _('In order to delete a confirmed sale order, you must cancel it before ! To cancel a sale order, you must first cancel related picking or delivery orders.'))
+ raise osv.except_osv(_('Invalid Action!'), _('In order to delete a confirmed sales order, you must cancel it before !'))
return osv.osv.unlink(self, cr, uid, unlink_ids, context=context)
- def onchange_shop_id(self, cr, uid, ids, shop_id):
- v = {}
- if shop_id:
- shop = self.pool.get('sale.shop').browse(cr, uid, shop_id)
- v['project_id'] = shop.project_id.id
- # Que faire si le client a une pricelist a lui ?
- if shop.pricelist_id.id:
- v['pricelist_id'] = shop.pricelist_id.id
- return {'value': v}
-
- def action_cancel_draft(self, cr, uid, ids, *args):
- if not len(ids):
- return False
- cr.execute('select id from sale_order_line where order_id IN %s and state=%s', (tuple(ids), 'cancel'))
- line_ids = map(lambda x: x[0], cr.fetchall())
- self.write(cr, uid, ids, {'state': 'draft', 'invoice_ids': [], 'shipped': 0})
- self.pool.get('sale.order.line').write(cr, uid, line_ids, {'invoiced': False, 'state': 'draft', 'invoice_lines': [(6, 0, [])]})
- wf_service = netsvc.LocalService("workflow")
- for inv_id in ids:
- # Deleting the existing instance of workflow for SO
- wf_service.trg_delete(uid, 'sale.order', inv_id, cr)
- wf_service.trg_create(uid, 'sale.order', inv_id, cr)
- for (id,name) in self.name_get(cr, uid, ids):
- message = _("The sales order '%s' has been set in draft state.") %(name,)
- self.log(cr, uid, id, message)
- return True
+ def copy_quotation(self, cr, uid, ids, context=None):
+ id = self.copy(cr, uid, ids[0], context=None)
+ view_ref = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'sale', 'view_order_form')
+ view_id = view_ref and view_ref[1] or False,
+ return {
+ 'type': 'ir.actions.act_window',
+ 'name': _('Sales Order'),
+ 'res_model': 'sale.order',
+ 'res_id': id,
+ 'view_type': 'form',
+ 'view_mode': 'form',
+ 'view_id': view_id,
+ 'target': 'current',
+ 'nodestroy': True,
+ }
- def onchange_pricelist_id(self, cr, uid, ids, pricelist_id, order_lines, context={}):
- if (not pricelist_id) or (not order_lines):
+ def onchange_pricelist_id(self, cr, uid, ids, pricelist_id, order_lines, context=None):
+ context = context or {}
+ if not pricelist_id:
return {}
+ value = {
+ 'currency_id': self.pool.get('product.pricelist').browse(cr, uid, pricelist_id, context=context).currency_id.id
+ }
+ if not order_lines:
+ return {'value': value}
warning = {
'title': _('Pricelist Warning!'),
'message' : _('If you change the pricelist of this order (and eventually the currency), prices of existing order lines will not be updated.')
}
- return {'warning': warning}
+ return {'warning': warning, 'value': value}
- def onchange_partner_order_id(self, cr, uid, ids, order_id, invoice_id=False, shipping_id=False, context={}):
- if not order_id:
- return {}
- val = {}
- if not invoice_id:
- val['partner_invoice_id'] = order_id
- if not shipping_id:
- val['partner_shipping_id'] = order_id
- return {'value': val}
-
- def onchange_partner_id(self, cr, uid, ids, part):
+ def onchange_partner_id(self, cr, uid, ids, part, context=None):
if not part:
- return {'value': {'partner_invoice_id': False, 'partner_shipping_id': False, 'partner_order_id': False, 'payment_term': False, 'fiscal_position': False}}
-
- addr = self.pool.get('res.partner').address_get(cr, uid, [part], ['delivery', 'invoice', 'contact'])
- part = self.pool.get('res.partner').browse(cr, uid, part)
+ return {'value': {'partner_invoice_id': False, 'partner_shipping_id': False, 'payment_term': False, 'fiscal_position': False}}
+
+ part = self.pool.get('res.partner').browse(cr, uid, part, context=context)
+ #if the chosen partner is not a company and has a parent company, use the parent to choose the delivery, the
+ #invoicing addresses and all the fields related to the partner.
+ if part.parent_id and not part.is_company:
+ part = part.parent_id
+ addr = self.pool.get('res.partner').address_get(cr, uid, [part.id], ['delivery', 'invoice', 'contact'])
pricelist = part.property_product_pricelist and part.property_product_pricelist.id or False
payment_term = part.property_payment_term and part.property_payment_term.id or False
fiscal_position = part.property_account_position and part.property_account_position.id or False
dedicated_salesman = part.user_id and part.user_id.id or uid
val = {
'partner_invoice_id': addr['invoice'],
- 'partner_order_id': addr['contact'],
'partner_shipping_id': addr['delivery'],
'payment_term': payment_term,
'fiscal_position': fiscal_position,
val['pricelist_id'] = pricelist
return {'value': val}
- def shipping_policy_change(self, cr, uid, ids, policy, context=None):
- if not policy:
- return {}
- inv_qty = 'order'
- if policy == 'prepaid':
- inv_qty = 'order'
- elif policy == 'picking':
- inv_qty = 'procurement'
- return {'value': {'invoice_quantity': inv_qty}}
-
- def write(self, cr, uid, ids, vals, context=None):
- if vals.get('order_policy', False):
- if vals['order_policy'] == 'prepaid':
- vals.update({'invoice_quantity': 'order'})
- elif vals['order_policy'] == 'picking':
- vals.update({'invoice_quantity': 'procurement'})
- return super(sale_order, self).write(cr, uid, ids, vals, context=context)
-
def create(self, cr, uid, vals, context=None):
- if vals.get('order_policy', False):
- if vals['order_policy'] == 'prepaid':
- vals.update({'invoice_quantity': 'order'})
- if vals['order_policy'] == 'picking':
- vals.update({'invoice_quantity': 'procurement'})
+ if vals.get('name','/')=='/':
+ vals['name'] = self.pool.get('ir.sequence').get(cr, uid, 'sale.order') or '/'
return super(sale_order, self).create(cr, uid, vals, context=context)
def button_dummy(self, cr, uid, ids, context=None):
def _prepare_invoice(self, cr, uid, order, lines, context=None):
"""Prepare the dict of values to create the new invoice for a
- sale order. This method may be overridden to implement custom
+ sales order. This method may be overridden to implement custom
invoice generation (making sure to call super() to establish
a clean extension chain).
[('type', '=', 'sale'), ('company_id', '=', order.company_id.id)],
limit=1)
if not journal_ids:
- raise osv.except_osv(_('Error !'),
- _('There is no sales journal defined for this company: "%s" (id:%d)') % (order.company_id.name, order.company_id.id))
-
+ raise osv.except_osv(_('Error!'),
+ _('Please define sales journal for this company: "%s" (id:%d).') % (order.company_id.name, order.company_id.id))
invoice_vals = {
'name': order.client_order_ref or '',
'origin': order.name,
'type': 'out_invoice',
'reference': order.client_order_ref or order.name,
'account_id': order.partner_id.property_account_receivable.id,
- 'partner_id': order.partner_id.id,
+ 'partner_id': order.partner_invoice_id.id,
'journal_id': journal_ids[0],
- 'address_invoice_id': order.partner_invoice_id.id,
- 'address_contact_id': order.partner_order_id.id,
'invoice_line': [(6, 0, lines)],
'currency_id': order.pricelist_id.currency_id.id,
'comment': order.note,
# Care for deprecated _inv_get() hook - FIXME: to be removed after 6.1
invoice_vals.update(self._inv_get(cr, uid, order, context=context))
-
return invoice_vals
def _make_invoice(self, cr, uid, order, lines, context=None):
inv_obj.button_compute(cr, uid, [inv_id])
return inv_id
+ def print_quotation(self, cr, uid, ids, context=None):
+ '''
+ This function prints the sales order and mark it as sent, so that we can see more easily the next step of the workflow
+ '''
+ assert len(ids) == 1, 'This option should only be used for a single id at a time'
+ wf_service = netsvc.LocalService("workflow")
+ wf_service.trg_validate(uid, 'sale.order', ids[0], 'quotation_sent', cr)
+ datas = {
+ 'model': 'sale.order',
+ 'ids': ids,
+ 'form': self.read(cr, uid, ids[0], context=context),
+ }
+ return {'type': 'ir.actions.report.xml', 'report_name': 'sale.order', 'datas': datas, 'nodestroy': True}
+
def manual_invoice(self, cr, uid, ids, context=None):
+ """ create invoices for the given sales orders (ids), and open the form
+ view of one of the newly created invoices
+ """
mod_obj = self.pool.get('ir.model.data')
wf_service = netsvc.LocalService("workflow")
- inv_ids = set()
- inv_ids1 = set()
- for id in ids:
- for record in self.pool.get('sale.order').browse(cr, uid, id).invoice_ids:
- inv_ids.add(record.id)
- # inv_ids would have old invoices if any
+
+ # create invoices through the sales orders' workflow
+ inv_ids0 = set(inv.id for sale in self.browse(cr, uid, ids, context) for inv in sale.invoice_ids)
for id in ids:
wf_service.trg_validate(uid, 'sale.order', id, 'manual_invoice', cr)
- for record in self.pool.get('sale.order').browse(cr, uid, id).invoice_ids:
- inv_ids1.add(record.id)
- inv_ids = list(inv_ids1.difference(inv_ids))
+ inv_ids1 = set(inv.id for sale in self.browse(cr, uid, ids, context) for inv in sale.invoice_ids)
+ # determine newly created invoices
+ new_inv_ids = list(inv_ids1 - inv_ids0)
res = mod_obj.get_object_reference(cr, uid, 'account', 'invoice_form')
res_id = res and res[1] or False,
'type': 'ir.actions.act_window',
'nodestroy': True,
'target': 'current',
- 'res_id': inv_ids and inv_ids[0] or False,
+ 'res_id': new_inv_ids and new_inv_ids[0] or False,
}
- def action_invoice_create(self, cr, uid, ids, grouped=False, states=['confirmed', 'done', 'exception'], date_inv = False, context=None):
+ def action_view_invoice(self, cr, uid, ids, context=None):
+ '''
+ This function returns an action that display existing invoices of given sales order ids. It can either be a in a list or in a form view, if there is only one invoice to show.
+ '''
+ mod_obj = self.pool.get('ir.model.data')
+ act_obj = self.pool.get('ir.actions.act_window')
+
+ result = mod_obj.get_object_reference(cr, uid, 'account', 'action_invoice_tree1')
+ id = result and result[1] or False
+ result = act_obj.read(cr, uid, [id], context=context)[0]
+ #compute the number of invoices to display
+ inv_ids = []
+ for so in self.browse(cr, uid, ids, context=context):
+ inv_ids += [invoice.id for invoice in so.invoice_ids]
+ #choose the view_mode accordingly
+ if len(inv_ids)>1:
+ result['domain'] = "[('id','in',["+','.join(map(str, inv_ids))+"])]"
+ else:
+ res = mod_obj.get_object_reference(cr, uid, 'account', 'invoice_form')
+ result['views'] = [(res and res[1] or False, 'form')]
+ result['res_id'] = inv_ids and inv_ids[0] or False
+ return result
+
+ def test_no_product(self, cr, uid, order, context):
+ for line in order.order_line:
+ if line.product_id and (line.product_id.type<>'service'):
+ return False
+ return True
+
+ def action_invoice_create(self, cr, uid, ids, grouped=False, states=None, date_invoice = False, context=None):
+ if states is None:
+ states = ['confirmed', 'done', 'exception']
res = False
invoices = {}
invoice_ids = []
- picking_obj = self.pool.get('stock.picking')
invoice = self.pool.get('account.invoice')
obj_sale_order_line = self.pool.get('sale.order.line')
partner_currency = {}
context = {}
# If date was specified, use it as date invoiced, usefull when invoices are generated this month and put the
# last day of the last month as invoice date
- if date_inv:
- context['date_inv'] = date_inv
+ if date_invoice:
+ context['date_invoice'] = date_invoice
for o in self.browse(cr, uid, ids, context=context):
currency_id = o.pricelist_id.currency_id.id
if (o.partner_id.id in partner_currency) and (partner_currency[o.partner_id.id] <> currency_id):
raise osv.except_osv(
- _('Error !'),
+ _('Error!'),
_('You cannot group sales having different currencies for the same partner.'))
partner_currency[o.partner_id.id] = currency_id
for o, l in val:
invoice_ref += o.name + '|'
self.write(cr, uid, [o.id], {'state': 'progress'})
- if o.order_policy == 'picking':
- picking_obj.write(cr, uid, map(lambda x: x.id, o.picking_ids), {'invoice_state': 'invoiced'})
cr.execute('insert into sale_order_invoice_rel (order_id,invoice_id) values (%s,%s)', (o.id, res))
invoice.write(cr, uid, [res], {'origin': invoice_ref, 'name': invoice_ref})
else:
res = self._make_invoice(cr, uid, order, il, context=context)
invoice_ids.append(res)
self.write(cr, uid, [order.id], {'state': 'progress'})
- if order.order_policy == 'picking':
- picking_obj.write(cr, uid, map(lambda x: x.id, order.picking_ids), {'invoice_state': 'invoiced'})
cr.execute('insert into sale_order_invoice_rel (order_id,invoice_id) values (%s,%s)', (order.id, res))
return res
def action_invoice_cancel(self, cr, uid, ids, context=None):
- if context is None:
- context = {}
- for sale in self.browse(cr, uid, ids, context=context):
- for line in sale.order_line:
- #
- # Check if the line is invoiced (has asociated invoice
- # lines from non-cancelled invoices).
- #
- invoiced = False
- for iline in line.invoice_lines:
- if iline.invoice_id and iline.invoice_id.state != 'cancel':
- invoiced = True
- break
- # Update the line (only when needed)
- if line.invoiced != invoiced:
- self.pool.get('sale.order.line').write(cr, uid, [line.id], {'invoiced': invoiced}, context=context)
- self.write(cr, uid, ids, {'state': 'invoice_except', 'invoice_ids': False}, context=context)
+ self.write(cr, uid, ids, {'state': 'invoice_except'}, context=context)
return True
def action_invoice_end(self, cr, uid, ids, context=None):
- for order in self.browse(cr, uid, ids, context=context):
- #
- # Update the sale order lines state (and invoiced flag).
- #
- for line in order.order_line:
- vals = {}
- #
- # Check if the line is invoiced (has asociated invoice
- # lines from non-cancelled invoices).
- #
- invoiced = False
- for iline in line.invoice_lines:
- if iline.invoice_id and iline.invoice_id.state != 'cancel':
- invoiced = True
- break
- if line.invoiced != invoiced:
- vals['invoiced'] = invoiced
- # If the line was in exception state, now it gets confirmed.
+ for this in self.browse(cr, uid, ids, context=context):
+ for line in this.order_line:
if line.state == 'exception':
- vals['state'] = 'confirmed'
- # Update the line (only when needed).
- if vals:
- self.pool.get('sale.order.line').write(cr, uid, [line.id], vals, context=context)
- #
- # Update the sales order state.
- #
- if order.state == 'invoice_except':
- self.write(cr, uid, [order.id], {'state': 'progress'}, context=context)
+ line.write({'state': 'confirmed'})
+ if this.state == 'invoice_except':
+ this.write({'state': 'progress'})
return True
def action_cancel(self, cr, uid, ids, context=None):
if context is None:
context = {}
sale_order_line_obj = self.pool.get('sale.order.line')
- proc_obj = self.pool.get('procurement.order')
for sale in self.browse(cr, uid, ids, context=context):
- for pick in sale.picking_ids:
- if pick.state not in ('draft', 'cancel'):
- raise osv.except_osv(
- _('Could not cancel sales order !'),
- _('You must first cancel all picking attached to this sales order.'))
- if pick.state == 'cancel':
- for mov in pick.move_lines:
- proc_ids = proc_obj.search(cr, uid, [('move_id', '=', mov.id)])
- if proc_ids:
- for proc in proc_ids:
- wf_service.trg_validate(uid, 'procurement.order', proc, 'button_check', cr)
- for r in self.read(cr, uid, ids, ['picking_ids']):
- for pick in r['picking_ids']:
- wf_service.trg_validate(uid, 'stock.picking', pick, 'button_cancel', cr)
for inv in sale.invoice_ids:
if inv.state not in ('draft', 'cancel'):
raise osv.except_osv(
- _('Could not cancel this sales order !'),
- _('You must first cancel all invoices attached to this sales order.'))
+ _('Cannot cancel this sales order!'),
+ _('First cancel all invoices attached to this sales order.'))
for r in self.read(cr, uid, ids, ['invoice_ids']):
for inv in r['invoice_ids']:
wf_service.trg_validate(uid, 'account.invoice', inv, 'invoice_cancel', cr)
sale_order_line_obj.write(cr, uid, [l.id for l in sale.order_line],
{'state': 'cancel'})
- message = _("The sales order '%s' has been cancelled.") % (sale.name,)
- self.log(cr, uid, sale.id, message)
self.write(cr, uid, ids, {'state': 'cancel'})
return True
+ def action_button_confirm(self, cr, uid, ids, context=None):
+ assert len(ids) == 1, 'This option should only be used for a single id at a time.'
+ wf_service = netsvc.LocalService('workflow')
+ wf_service.trg_validate(uid, 'sale.order', ids[0], 'order_confirm', cr)
+
+ # redisplay the record as a sales order
+ view_ref = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'sale', 'view_order_form')
+ view_id = view_ref and view_ref[1] or False,
+ return {
+ 'type': 'ir.actions.act_window',
+ 'name': _('Sales Order'),
+ 'res_model': 'sale.order',
+ 'res_id': ids[0],
+ 'view_type': 'form',
+ 'view_mode': 'form',
+ 'view_id': view_id,
+ 'target': 'current',
+ 'nodestroy': True,
+ }
+
def action_wait(self, cr, uid, ids, context=None):
+ context = context or {}
for o in self.browse(cr, uid, ids):
if not o.order_line:
- raise osv.except_osv(_('Error !'),_('You cannot confirm a sale order which has no line.'))
- if (o.order_policy == 'manual'):
+ raise osv.except_osv(_('Error!'),_('You cannot confirm a sales order which has no line.'))
+ noprod = self.test_no_product(cr, uid, o, context)
+ if (o.order_policy == 'manual') or noprod:
self.write(cr, uid, [o.id], {'state': 'manual', 'date_confirm': fields.date.context_today(self, cr, uid, context=context)})
else:
self.write(cr, uid, [o.id], {'state': 'progress', 'date_confirm': fields.date.context_today(self, cr, uid, context=context)})
self.pool.get('sale.order.line').button_confirm(cr, uid, [x.id for x in o.order_line])
- message = _("The quotation '%s' has been converted to a sales order.") % (o.name,)
- self.log(cr, uid, o.id, message)
return True
- def procurement_lines_get(self, cr, uid, ids, *args):
- res = []
- for order in self.browse(cr, uid, ids, context={}):
- for line in order.order_line:
- if line.procurement_id:
- res.append(line.procurement_id.id)
- return res
-
- # if mode == 'finished':
- # returns True if all lines are done, False otherwise
- # if mode == 'canceled':
- # returns True if there is at least one canceled line, False otherwise
- def test_state(self, cr, uid, ids, mode, *args):
- assert mode in ('finished', 'canceled'), _("invalid mode for test_state")
- finished = True
- canceled = False
- notcanceled = False
- write_done_ids = []
- write_cancel_ids = []
- for order in self.browse(cr, uid, ids, context={}):
- for line in order.order_line:
- if (not line.procurement_id) or (line.procurement_id.state=='done'):
- if line.state != 'done':
- write_done_ids.append(line.id)
- else:
- finished = False
- if line.procurement_id:
- if (line.procurement_id.state == 'cancel'):
- canceled = True
- if line.state != 'exception':
- write_cancel_ids.append(line.id)
- else:
- notcanceled = True
- if write_done_ids:
- self.pool.get('sale.order.line').write(cr, uid, write_done_ids, {'state': 'done'})
- if write_cancel_ids:
- self.pool.get('sale.order.line').write(cr, uid, write_cancel_ids, {'state': 'exception'})
-
- if mode == 'finished':
- return finished
- elif mode == 'canceled':
- return canceled
- if notcanceled:
- return False
- return canceled
-
- def _prepare_order_line_procurement(self, cr, uid, order, line, move_id, date_planned, context=None):
- return {
- 'name': line.name,
- 'origin': order.name,
- 'date_planned': date_planned,
- 'product_id': line.product_id.id,
- 'product_qty': line.product_uom_qty,
- 'product_uom': line.product_uom.id,
- 'product_uos_qty': (line.product_uos and line.product_uos_qty)\
- or line.product_uom_qty,
- 'product_uos': (line.product_uos and line.product_uos.id)\
- or line.product_uom.id,
- 'location_id': order.shop_id.warehouse_id.lot_stock_id.id,
- 'procure_method': line.type,
- 'move_id': move_id,
- 'company_id': order.company_id.id,
- 'note': line.notes
- }
-
- def _prepare_order_line_move(self, cr, uid, order, line, picking_id, date_planned, context=None):
- location_id = order.shop_id.warehouse_id.lot_stock_id.id
- output_id = order.shop_id.warehouse_id.lot_output_id.id
- return {
- 'name': line.name[:250],
- 'picking_id': picking_id,
- 'product_id': line.product_id.id,
- 'date': date_planned,
- 'date_expected': date_planned,
- 'product_qty': line.product_uom_qty,
- 'product_uom': line.product_uom.id,
- 'product_uos_qty': (line.product_uos and line.product_uos_qty) or line.product_uom_qty,
- 'product_uos': (line.product_uos and line.product_uos.id)\
- or line.product_uom.id,
- 'product_packaging': line.product_packaging.id,
- 'address_id': line.address_allotment_id.id or order.partner_shipping_id.id,
- 'location_id': location_id,
- 'location_dest_id': output_id,
- 'sale_line_id': line.id,
- 'tracking_id': False,
- 'state': 'draft',
- #'state': 'waiting',
- 'note': line.notes,
- 'company_id': order.company_id.id,
- 'price_unit': line.product_id.standard_price or 0.0
- }
-
- def _prepare_order_picking(self, cr, uid, order, context=None):
- pick_name = self.pool.get('ir.sequence').get(cr, uid, 'stock.picking.out')
+ def action_quotation_send(self, cr, uid, ids, context=None):
+ '''
+ This function opens a window to compose an email, with the edi sale template message loaded by default
+ '''
+ assert len(ids) == 1, 'This option should only be used for a single id at a time.'
+ ir_model_data = self.pool.get('ir.model.data')
+ try:
+ template_id = ir_model_data.get_object_reference(cr, uid, 'sale', 'email_template_edi_sale')[1]
+ except ValueError:
+ template_id = False
+ try:
+ compose_form_id = ir_model_data.get_object_reference(cr, uid, 'mail', 'email_compose_message_wizard_form')[1]
+ except ValueError:
+ compose_form_id = False
+ ctx = dict(context)
+ ctx.update({
+ 'default_model': 'sale.order',
+ 'default_res_id': ids[0],
+ 'default_use_template': bool(template_id),
+ 'default_template_id': template_id,
+ 'default_composition_mode': 'comment',
+ 'mark_so_as_sent': True
+ })
return {
- 'name': pick_name,
- 'origin': order.name,
- 'date': order.date_order,
- 'type': 'out',
- 'state': 'auto',
- 'move_type': order.picking_policy,
- 'sale_id': order.id,
- 'address_id': order.partner_shipping_id.id,
- 'note': order.note,
- 'invoice_state': (order.order_policy=='picking' and '2binvoiced') or 'none',
- 'company_id': order.company_id.id,
+ 'type': 'ir.actions.act_window',
+ 'view_type': 'form',
+ 'view_mode': 'form',
+ 'res_model': 'mail.compose.message',
+ 'views': [(compose_form_id, 'form')],
+ 'view_id': compose_form_id,
+ 'target': 'new',
+ 'context': ctx,
}
- def ship_recreate(self, cr, uid, order, line, move_id, proc_id):
- # FIXME: deals with potentially cancelled shipments, seems broken (specially if shipment has production lot)
- """
- Define ship_recreate for process after shipping exception
- param order: sale order to which the order lines belong
- param line: sale order line records to procure
- param move_id: the ID of stock move
- param proc_id: the ID of procurement
- """
- move_obj = self.pool.get('stock.move')
- if order.state == 'shipping_except':
- for pick in order.picking_ids:
- for move in pick.move_lines:
- if move.state == 'cancel':
- mov_ids = move_obj.search(cr, uid, [('state', '=', 'cancel'),('sale_line_id', '=', line.id),('picking_id', '=', pick.id)])
- if mov_ids:
- for mov in move_obj.browse(cr, uid, mov_ids):
- # FIXME: the following seems broken: what if move_id doesn't exist? What if there are several mov_ids? Shouldn't that be a sum?
- move_obj.write(cr, uid, [move_id], {'product_qty': mov.product_qty, 'product_uos_qty': mov.product_uos_qty})
- self.pool.get('procurement.order').write(cr, uid, [proc_id], {'product_qty': mov.product_qty, 'product_uos_qty': mov.product_uos_qty})
- return True
+ def action_done(self, cr, uid, ids, context=None):
+ return self.write(cr, uid, ids, {'state': 'done'}, context=context)
- def _get_date_planned(self, cr, uid, order, line, start_date, context=None):
- date_planned = datetime.strptime(start_date, DEFAULT_SERVER_DATE_FORMAT) + relativedelta(days=line.delay or 0.0)
- date_planned = (date_planned - timedelta(days=order.company_id.security_lead)).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
- return date_planned
-
- def _create_pickings_and_procurements(self, cr, uid, order, order_lines, picking_id=False, context=None):
- """Create the required procurements to supply sale order lines, also connecting
- the procurements to appropriate stock moves in order to bring the goods to the
- sale order's requested location.
-
- If ``picking_id`` is provided, the stock moves will be added to it, otherwise
- a standard outgoing picking will be created to wrap the stock moves, as returned
- by :meth:`~._prepare_order_picking`.
-
- Modules that wish to customize the procurements or partition the stock moves over
- multiple stock pickings may override this method and call ``super()`` with
- different subsets of ``order_lines`` and/or preset ``picking_id`` values.
-
- :param browse_record order: sale order to which the order lines belong
- :param list(browse_record) order_lines: sale order line records to procure
- :param int picking_id: optional ID of a stock picking to which the created stock moves
- will be added. A new picking will be created if ommitted.
- :return: True
- """
- move_obj = self.pool.get('stock.move')
- picking_obj = self.pool.get('stock.picking')
- procurement_obj = self.pool.get('procurement.order')
- proc_ids = []
-
- for line in order_lines:
- if line.state == 'done':
- continue
- date_planned = self._get_date_planned(cr, uid, order, line, order.date_order, context=context)
-
- if line.product_id:
- if line.product_id.product_tmpl_id.type in ('product', 'consu'):
- if not picking_id:
- picking_id = picking_obj.create(cr, uid, self._prepare_order_picking(cr, uid, order, context=context))
- move_id = move_obj.create(cr, uid, self._prepare_order_line_move(cr, uid, order, line, picking_id, date_planned, context=context))
- else:
- # a service has no stock move
- move_id = False
-
- proc_id = procurement_obj.create(cr, uid, self._prepare_order_line_procurement(cr, uid, order, line, move_id, date_planned, context=context))
- proc_ids.append(proc_id)
- line.write({'procurement_id': proc_id})
- self.ship_recreate(cr, uid, order, line, move_id, proc_id)
-
- wf_service = netsvc.LocalService("workflow")
- if picking_id:
- wf_service.trg_validate(uid, 'stock.picking', picking_id, 'button_confirm', cr)
-
- for proc_id in proc_ids:
- wf_service.trg_validate(uid, 'procurement.order', proc_id, 'button_confirm', cr)
-
- val = {}
- if order.state == 'shipping_except':
- val['state'] = 'progress'
- val['shipped'] = False
-
- if (order.order_policy == 'manual'):
- for line in order.order_line:
- if (not line.invoiced) and (line.state not in ('cancel', 'draft')):
- val['state'] = 'manual'
- break
- order.write(val)
- return True
-
- def action_ship_create(self, cr, uid, ids, context=None):
- for order in self.browse(cr, uid, ids, context=context):
- self._create_pickings_and_procurements(cr, uid, order, order.order_line, None, context=context)
- return True
-
- def action_ship_end(self, cr, uid, ids, context=None):
- for order in self.browse(cr, uid, ids, context=context):
- val = {'shipped': True}
- if order.state == 'shipping_except':
- val['state'] = 'progress'
- if (order.order_policy == 'manual'):
- for line in order.order_line:
- if (not line.invoiced) and (line.state not in ('cancel', 'draft')):
- val['state'] = 'manual'
- break
- for line in order.order_line:
- towrite = []
- if line.state == 'exception':
- towrite.append(line.id)
- if towrite:
- self.pool.get('sale.order.line').write(cr, uid, towrite, {'state': 'done'}, context=context)
- self.write(cr, uid, [order.id], val)
- return True
-
- def _log_event(self, cr, uid, ids, factor=0.7, name='Open Order'):
- invs = self.read(cr, uid, ids, ['date_order', 'partner_id', 'amount_untaxed'])
- for inv in invs:
- part = inv['partner_id'] and inv['partner_id'][0]
- pr = inv['amount_untaxed'] or 0.0
- partnertype = 'customer'
- eventtype = 'sale'
- event = {
- 'name': 'Order: '+name,
- 'som': False,
- 'description': 'Order '+str(inv['id']),
- 'document': '',
- 'partner_id': part,
- 'date': time.strftime(DEFAULT_SERVER_DATE_FORMAT),
- 'user_id': uid,
- 'partner_type': partnertype,
- 'probability': 1.0,
- 'planned_revenue': pr,
- 'planned_cost': 0.0,
- 'type': eventtype
- }
- self.pool.get('res.partner.event').create(cr, uid, event)
-
- def has_stockable_products(self, cr, uid, ids, *args):
- for order in self.browse(cr, uid, ids):
- for order_line in order.order_line:
- if order_line.product_id and order_line.product_id.product_tmpl_id.type in ('product', 'consu'):
- return True
- return False
-sale_order()
# TODO add a field price_unit_uos
# - update it on change product and unit price
context = {}
for line in self.browse(cr, uid, ids, context=context):
price = line.price_unit * (1 - (line.discount or 0.0) / 100.0)
- taxes = tax_obj.compute_all(cr, uid, line.tax_id, price, line.product_uom_qty, line.order_id.partner_invoice_id.id, line.product_id, line.order_id.partner_id)
+ taxes = tax_obj.compute_all(cr, uid, line.tax_id, price, line.product_uom_qty, line.product_id, line.order_id.partner_id)
cur = line.order_id.pricelist_id.currency_id
res[line.id] = cur_obj.round(cr, uid, cur, taxes['total'])
return res
- def _number_packages(self, cr, uid, ids, field_name, arg, context=None):
- res = {}
- for line in self.browse(cr, uid, ids, context=context):
- try:
- res[line.id] = int((line.product_uom_qty+line.product_packaging.qty-0.0001) / line.product_packaging.qty)
- except:
- res[line.id] = 1
- return res
-
def _get_uom_id(self, cr, uid, *args):
try:
proxy = self.pool.get('ir.model.data')
except Exception, ex:
return False
+ def _fnct_line_invoiced(self, cr, uid, ids, field_name, args, context=None):
+ res = dict.fromkeys(ids, False)
+ for this in self.browse(cr, uid, ids, context=context):
+ res[this.id] = this.invoice_lines and \
+ all(iline.invoice_id.state != 'cancel' for iline in this.invoice_lines)
+ return res
+
+ def _order_lines_from_invoice(self, cr, uid, ids, context=None):
+ # direct access to the m2m table is the less convoluted way to achieve this (and is ok ACL-wise)
+ cr.execute("""SELECT DISTINCT sol.id FROM sale_order_invoice_rel rel JOIN
+ sale_order_line sol ON (sol.order_id = rel.order_id)
+ WHERE rel.invoice_id = ANY(%s)""", (list(ids),))
+ return [i[0] for i in cr.fetchall()]
+
_name = 'sale.order.line'
_description = 'Sales Order Line'
_columns = {
'order_id': fields.many2one('sale.order', 'Order Reference', required=True, ondelete='cascade', select=True, readonly=True, states={'draft':[('readonly',False)]}),
- 'name': fields.char('Description', size=256, required=True, select=True, readonly=True, states={'draft': [('readonly', False)]}),
+ 'name': fields.text('Description', required=True, select=True, readonly=True, states={'draft': [('readonly', False)]}),
'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of sales order lines."),
- 'delay': fields.float('Delivery Lead Time', required=True, help="Number of days between the order confirmation the shipping of the products to the customer", readonly=True, states={'draft': [('readonly', False)]}),
'product_id': fields.many2one('product.product', 'Product', domain=[('sale_ok', '=', True)], change_default=True),
'invoice_lines': fields.many2many('account.invoice.line', 'sale_order_line_invoice_rel', 'order_line_id', 'invoice_id', 'Invoice Lines', readonly=True),
- 'invoiced': fields.boolean('Invoiced', readonly=True),
- 'procurement_id': fields.many2one('procurement.order', 'Procurement'),
- 'price_unit': fields.float('Unit Price', required=True, digits_compute= dp.get_precision('Sale Price'), readonly=True, states={'draft': [('readonly', False)]}),
- 'price_subtotal': fields.function(_amount_line, string='Subtotal', digits_compute= dp.get_precision('Sale Price')),
- 'tax_id': fields.many2many('account.tax', 'sale_order_tax', 'order_line_id', 'tax_id', 'Taxes', readonly=True, states={'draft': [('readonly', False)]}),
+ 'invoiced': fields.function(_fnct_line_invoiced, string='Invoiced', type='boolean',
+ store={'account.invoice': (_order_lines_from_invoice, ['state'], 10)}),
+ 'price_unit': fields.float('Unit Price', required=True, digits_compute= dp.get_precision('Product Price'), readonly=True, states={'draft': [('readonly', False)]}),
'type': fields.selection([('make_to_stock', 'from stock'), ('make_to_order', 'on order')], 'Procurement Method', required=True, readonly=True, states={'draft': [('readonly', False)]},
- help="If 'on order', it triggers a procurement when the sale order is confirmed to create a task, purchase order or manufacturing order linked to this sale order line."),
- 'property_ids': fields.many2many('mrp.property', 'sale_order_line_property_rel', 'order_id', 'property_id', 'Properties', readonly=True, states={'draft': [('readonly', False)]}),
- 'address_allotment_id': fields.many2one('res.partner.address', 'Allotment Partner'),
- 'product_uom_qty': fields.float('Quantity (UoM)', digits_compute= dp.get_precision('Product UoS'), required=True, readonly=True, states={'draft': [('readonly', False)]}),
+ help="From stock: When needed, the product is taken from the stock or we wait for replenishment.\nOn order: When needed, the product is purchased or produced."),
+ 'price_subtotal': fields.function(_amount_line, string='Subtotal', digits_compute= dp.get_precision('Account')),
+ 'tax_id': fields.many2many('account.tax', 'sale_order_tax', 'order_line_id', 'tax_id', 'Taxes', readonly=True, states={'draft': [('readonly', False)]}),
+ 'address_allotment_id': fields.many2one('res.partner', 'Allotment Partner',help="A partner to whom the particular product needs to be allotted."),
+ 'product_uom_qty': fields.float('Quantity', digits_compute= dp.get_precision('Product UoS'), required=True, readonly=True, states={'draft': [('readonly', False)]}),
'product_uom': fields.many2one('product.uom', 'Unit of Measure ', required=True, readonly=True, states={'draft': [('readonly', False)]}),
'product_uos_qty': fields.float('Quantity (UoS)' ,digits_compute= dp.get_precision('Product UoS'), readonly=True, states={'draft': [('readonly', False)]}),
'product_uos': fields.many2one('product.uom', 'Product UoS'),
- 'product_packaging': fields.many2one('product.packaging', 'Packaging'),
- 'move_ids': fields.one2many('stock.move', 'sale_line_id', 'Inventory Moves', readonly=True),
- 'discount': fields.float('Discount (%)', digits=(16, 2), readonly=True, states={'draft': [('readonly', False)]}),
- 'number_packages': fields.function(_number_packages, type='integer', string='Number Packages'),
- 'notes': fields.text('Notes'),
+ 'discount': fields.float('Discount (%)', digits_compute= dp.get_precision('Discount'), readonly=True, states={'draft': [('readonly', False)]}),
'th_weight': fields.float('Weight', readonly=True, states={'draft': [('readonly', False)]}),
- 'state': fields.selection([('cancel', 'Cancelled'),('draft', 'Draft'),('confirmed', 'Confirmed'),('exception', 'Exception'),('done', 'Done')], 'State', required=True, readonly=True,
- help='* The \'Draft\' state is set when the related sales order in draft state. \
- \n* The \'Confirmed\' state is set when the related sales order is confirmed. \
- \n* The \'Exception\' state is set when the related sales order is set as exception. \
- \n* The \'Done\' state is set when the sales order line has been picked. \
- \n* The \'Cancelled\' state is set when a user cancel the sales order related.'),
+ 'state': fields.selection([('cancel', 'Cancelled'),('draft', 'Draft'),('confirmed', 'Confirmed'),('exception', 'Exception'),('done', 'Done')], 'Status', required=True, readonly=True,
+ help='* The \'Draft\' status is set when the related sales order in draft status. \
+ \n* The \'Confirmed\' status is set when the related sales order is confirmed. \
+ \n* The \'Exception\' status is set when the related sales order is set as exception. \
+ \n* The \'Done\' status is set when the sales order line has been picked. \
+ \n* The \'Cancelled\' status is set when a user cancel the sales order related.'),
'order_partner_id': fields.related('order_id', 'partner_id', type='many2one', relation='res.partner', store=True, string='Customer'),
- 'salesman_id':fields.related('order_id', 'user_id', type='many2one', relation='res.users', store=True, string='Salesman'),
+ 'salesman_id':fields.related('order_id', 'user_id', type='many2one', relation='res.users', store=True, string='Salesperson'),
'company_id': fields.related('order_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
}
- _order = 'sequence, id'
+ _order = 'order_id desc, sequence'
_defaults = {
'product_uom' : _get_uom_id,
'discount': 0.0,
- 'delay': 0.0,
'product_uom_qty': 1,
'product_uos_qty': 1,
'sequence': 10,
- 'invoiced': 0,
'state': 'draft',
'type': 'make_to_stock',
- 'product_packaging': False,
'price_unit': 0.0,
}
+ def _get_line_qty(self, cr, uid, line, context=None):
+ if (line.order_id.invoice_quantity=='order'):
+ if line.product_uos:
+ return line.product_uos_qty or 0.0
+ return line.product_uom_qty
+
+ def _get_line_uom(self, cr, uid, line, context=None):
+ if (line.order_id.invoice_quantity=='order'):
+ if line.product_uos:
+ return line.product_uos.id
+ return line.product_uom.id
+
def _prepare_order_line_invoice_line(self, cr, uid, line, account_id=False, context=None):
"""Prepare the dict of values to create the new invoice line for a
- sale order line. This method may be overridden to implement custom
+ sales order line. This method may be overridden to implement custom
invoice generation (making sure to call super() to establish
a clean extension chain).
(this is used for returning products including service)
:return: dict of values to create() the invoice line
"""
-
- def _get_line_qty(line):
- if (line.order_id.invoice_quantity=='order') or not line.procurement_id:
- if line.product_uos:
- return line.product_uos_qty or 0.0
- return line.product_uom_qty
- else:
- return self.pool.get('procurement.order').quantity_get(cr, uid,
- line.procurement_id.id, context=context)
-
- def _get_line_uom(line):
- if (line.order_id.invoice_quantity=='order') or not line.procurement_id:
- if line.product_uos:
- return line.product_uos.id
- return line.product_uom.id
- else:
- return self.pool.get('procurement.order').uom_get(cr, uid,
- line.procurement_id.id, context=context)
-
+ res = {}
if not line.invoiced:
if not account_id:
if line.product_id:
- account_id = line.product_id.product_tmpl_id.property_account_income.id
+ account_id = line.product_id.property_account_income.id
if not account_id:
account_id = line.product_id.categ_id.property_account_income_categ.id
if not account_id:
- raise osv.except_osv(_('Error !'),
- _('There is no income account defined for this product: "%s" (id:%d)') % \
+ raise osv.except_osv(_('Error!'),
+ _('Please define income account for this product: "%s" (id:%d).') % \
(line.product_id.name, line.product_id.id,))
else:
prop = self.pool.get('ir.property').get(cr, uid,
'property_account_income_categ', 'product.category',
context=context)
account_id = prop and prop.id or False
- uosqty = _get_line_qty(line)
- uos_id = _get_line_uom(line)
+ uosqty = self._get_line_qty(cr, uid, line, context=context)
+ uos_id = self._get_line_uom(cr, uid, line, context=context)
pu = 0.0
if uosqty:
pu = round(line.price_unit * line.product_uom_qty / uosqty,
- self.pool.get('decimal.precision').precision_get(cr, uid, 'Sale Price'))
+ self.pool.get('decimal.precision').precision_get(cr, uid, 'Product Price'))
fpos = line.order_id.fiscal_position or False
account_id = self.pool.get('account.fiscal.position').map_account(cr, uid, fpos, account_id)
if not account_id:
- raise osv.except_osv(_('Error !'),
- _('There is no income category account defined in default Properties for Product Category or Fiscal Position is not defined !'))
- return {
+ raise osv.except_osv(_('Error!'),
+ _('There is no Fiscal Position defined or Income category account defined for default properties of Product categories.'))
+ res = {
'name': line.name,
+ 'sequence': line.sequence,
'origin': line.order_id.name,
'account_id': account_id,
'price_unit': pu,
'uos_id': uos_id,
'product_id': line.product_id.id or False,
'invoice_line_tax_id': [(6, 0, [x.id for x in line.tax_id])],
- 'note': line.notes,
'account_analytic_id': line.order_id.project_id and line.order_id.project_id.id or False,
}
- return False
+ return res
def invoice_line_create(self, cr, uid, ids, context=None):
if context is None:
if vals:
inv_id = self.pool.get('account.invoice.line').create(cr, uid, vals, context=context)
cr.execute('insert into sale_order_line_invoice_rel (order_line_id,invoice_id) values (%s,%s)', (line.id, inv_id))
- self.write(cr, uid, [line.id], {'invoiced': True})
sales.add(line.order_id.id)
create_ids.append(inv_id)
# Trigger workflow events
def button_cancel(self, cr, uid, ids, context=None):
for line in self.browse(cr, uid, ids, context=context):
if line.invoiced:
- raise osv.except_osv(_('Invalid action !'), _('You cannot cancel a sale order line that has already been invoiced!'))
- for move_line in line.move_ids:
- if move_line.state != 'cancel':
- raise osv.except_osv(
- _('Could not cancel sales order line!'),
- _('You must first cancel stock moves attached to this sales order line.'))
+ raise osv.except_osv(_('Invalid Action!'), _('You cannot cancel a sales order line that has already been invoiced.'))
return self.write(cr, uid, ids, {'state': 'cancel'})
def button_confirm(self, cr, uid, ids, context=None):
def copy_data(self, cr, uid, id, default=None, context=None):
if not default:
default = {}
- default.update({'state': 'draft', 'move_ids': [], 'invoiced': False, 'invoice_lines': []})
+ default.update({'state': 'draft', 'invoice_lines': []})
return super(sale_order_line, self).copy_data(cr, uid, id, default, context=context)
- def product_packaging_change(self, cr, uid, ids, pricelist, product, qty=0, uom=False,
- partner_id=False, packaging=False, flag=False, context=None):
- if not product:
- return {'value': {'product_packaging': False}}
- product_obj = self.pool.get('product.product')
- product_uom_obj = self.pool.get('product.uom')
- pack_obj = self.pool.get('product.packaging')
- warning = {}
- result = {}
- warning_msgs = ''
- if flag:
- res = self.product_id_change(cr, uid, ids, pricelist=pricelist,
- product=product, qty=qty, uom=uom, partner_id=partner_id,
- packaging=packaging, flag=False, context=context)
- warning_msgs = res.get('warning') and res['warning']['message']
-
- products = product_obj.browse(cr, uid, product, context=context)
- if not products.packaging:
- packaging = result['product_packaging'] = False
- elif not packaging and products.packaging and not flag:
- packaging = products.packaging[0].id
- result['product_packaging'] = packaging
-
- if packaging:
- default_uom = products.uom_id and products.uom_id.id
- pack = pack_obj.browse(cr, uid, packaging, context=context)
- q = product_uom_obj._compute_qty(cr, uid, uom, pack.qty, default_uom)
-# qty = qty - qty % q + q
- if qty and (q and not (qty % q) == 0):
- ean = pack.ean or _('(n/a)')
- qty_pack = pack.qty
- type_ul = pack.ul
- if not warning_msgs:
- warn_msg = _("You selected a quantity of %d Units.\n"
- "But it's not compatible with the selected packaging.\n"
- "Here is a proposition of quantities according to the packaging:\n"
- "EAN: %s Quantity: %s Type of ul: %s") % \
- (qty, ean, qty_pack, type_ul.name)
- warning_msgs += _("Picking Information ! : ") + warn_msg + "\n\n"
- warning = {
- 'title': _('Configuration Error !'),
- 'message': warning_msgs
- }
- result['product_uom_qty'] = qty
-
- return {'value': result, 'warning': warning}
-
def product_id_change(self, cr, uid, ids, pricelist, product, qty=0,
uom=False, qty_uos=0, uos=False, name='', partner_id=False,
lang=False, update_tax=True, date_order=False, packaging=False, fiscal_position=False, flag=False, context=None):
- """
- onchange handler for product_id.
-
- :param dict context: 'force_product_uom' key in context override
- default onchange behaviour to force using the UoM
- defined on the provided product
- """
- if context is None:
- context = {}
+ context = context or {}
lang = lang or context.get('lang',False)
if not partner_id:
- raise osv.except_osv(_('No Customer Defined !'), _('You have to select a customer in the sales form !\nPlease set one customer before choosing a product.'))
+ raise osv.except_osv(_('No Customer Defined !'), _('Before choosing a product,\n select a customer in the sales form.'))
warning = {}
product_uom_obj = self.pool.get('product.uom')
partner_obj = self.pool.get('res.partner')
product_obj = self.pool.get('product.product')
- context = dict(context, lang=lang, partner_id=partner_id)
+ context = {'lang': lang, 'partner_id': partner_id}
if partner_id:
- lang = partner_obj.browse(cr, uid, partner_id, context=context).lang
- context_partner = dict(context, lang=lang)
+ lang = partner_obj.browse(cr, uid, partner_id).lang
+ context_partner = {'lang': lang, 'partner_id': partner_id}
if not product:
- return {'value': {'th_weight': 0, 'product_packaging': False,
+ return {'value': {'th_weight': 0,
'product_uos_qty': qty}, 'domain': {'product_uom': [],
'product_uos': []}}
if not date_order:
date_order = time.strftime(DEFAULT_SERVER_DATE_FORMAT)
- res = self.product_packaging_change(cr, uid, ids, pricelist, product, qty, uom, partner_id, packaging, context=context)
- result = res.get('value', {})
- warning_msgs = res.get('warning') and res['warning']['message'] or ''
- product_obj = product_obj.browse(cr, uid, product, context=context)
+ result = {}
+ warning_msgs = {}
+ product_obj = product_obj.browse(cr, uid, product, context=context_partner)
uom2 = False
if uom:
- uom2 = product_uom_obj.browse(cr, uid, uom, context=context)
- if product_obj.uom_id.category_id.id != uom2.category_id.id or context.get('force_product_uom'):
+ uom2 = product_uom_obj.browse(cr, uid, uom)
+ if product_obj.uom_id.category_id.id != uom2.category_id.id:
uom = False
- uom2 = False
if uos:
if product_obj.uos_id:
- uos2 = product_uom_obj.browse(cr, uid, uos, context=context)
+ uos2 = product_uom_obj.browse(cr, uid, uos)
if product_obj.uos_id.category_id.id != uos2.category_id.id:
uos = False
else:
uos = False
- if product_obj.description_sale:
- result['notes'] = product_obj.description_sale
- fpos = fiscal_position and self.pool.get('account.fiscal.position').browse(cr, uid, fiscal_position, context=context) or False
+ fpos = fiscal_position and self.pool.get('account.fiscal.position').browse(cr, uid, fiscal_position) or False
if update_tax: #The quantity only have changed
- result['delay'] = (product_obj.sale_delay or 0.0)
result['tax_id'] = self.pool.get('account.fiscal.position').map_tax(cr, uid, fpos, product_obj.taxes_id)
- result.update({'type': product_obj.procure_method})
if not flag:
result['name'] = self.pool.get('product.product').name_get(cr, uid, [product_obj.id], context=context_partner)[0][1]
+ if product_obj.description_sale:
+ result['name'] += '\n'+product_obj.description_sale
domain = {}
if (not uom) and (not uos):
result['product_uom'] = product_obj.uom_id.id
[('category_id', '=', product_obj.uom_id.category_id.id)],
'product_uos':
[('category_id', '=', uos_category_id)]}
-
elif uos and not uom: # only happens if uom is False
result['product_uom'] = product_obj.uom_id and product_obj.uom_id.id
result['product_uom_qty'] = qty_uos / product_obj.uos_coeff
elif uom: # whether uos is set or not
default_uom = product_obj.uom_id and product_obj.uom_id.id
q = product_uom_obj._compute_qty(cr, uid, uom, qty, default_uom)
+ result['product_uom'] = default_uom
if product_obj.uos_id:
result['product_uos'] = product_obj.uos_id.id
result['product_uos_qty'] = qty * product_obj.uos_coeff
if not uom2:
uom2 = product_obj.uom_id
- compare_qty = float_compare(product_obj.virtual_available * uom2.factor, qty * product_obj.uom_id.factor, precision_rounding=product_obj.uom_id.rounding)
- if (product_obj.type=='product') and int(compare_qty) == -1 \
- and (product_obj.procure_method=='make_to_stock'):
- warn_msg = _('You plan to sell %.2f %s but you only have %.2f %s available !\nThe real stock is %.2f %s. (without reservations)') % \
- (qty, uom2 and uom2.name or product_obj.uom_id.name,
- max(0,product_obj.virtual_available), product_obj.uom_id.name,
- max(0,product_obj.qty_available), product_obj.uom_id.name)
- warning_msgs += _("Not enough stock ! : ") + warn_msg + "\n\n"
# get unit price
if not pricelist:
warning_msgs += _("No Pricelist ! : ") + warn_msg +"\n\n"
else:
price = self.pool.get('product.pricelist').price_get(cr, uid, [pricelist],
- product, qty or 1.0, partner_id, dict(context,
- uom=uom or result.get('product_uom'),
- date=date_order,
- ))[pricelist]
+ product, qty or 1.0, partner_id, {
+ 'uom': uom or result.get('product_uom'),
+ 'date': date_order,
+ })[pricelist]
if price is False:
- warn_msg = _("Couldn't find a pricelist line matching this product and quantity.\n"
+ warn_msg = _("Cannot find a pricelist line matching this product and quantity.\n"
"You have to change either the product, the quantity or the pricelist.")
warning_msgs += _("No valid pricelist line found ! :") + warn_msg +"\n\n"
result.update({'price_unit': price})
if warning_msgs:
warning = {
- 'title': _('Configuration Error !'),
+ 'title': _('Configuration Error!'),
'message' : warning_msgs
}
return {'value': result, 'domain': domain, 'warning': warning}
def product_uom_change(self, cursor, user, ids, pricelist, product, qty=0,
uom=False, qty_uos=0, uos=False, name='', partner_id=False,
lang=False, update_tax=True, date_order=False, context=None):
- if context is None:
- context = {}
- lang = lang or context.get('lang',False)
- res = self.product_id_change(cursor, user, ids, pricelist, product,
+ context = context or {}
+ lang = lang or ('lang' in context and context['lang'])
+ if not uom:
+ return {'value': {'price_unit': 0.0, 'product_uom' : uom or False}}
+ return self.product_id_change(cursor, user, ids, pricelist, product,
qty=qty, uom=uom, qty_uos=qty_uos, uos=uos, name=name,
partner_id=partner_id, lang=lang, update_tax=update_tax,
date_order=date_order, context=context)
- if 'product_uom' in res['value']:
- del res['value']['product_uom']
- if not uom:
- res['value']['price_unit'] = 0.0
- return res
def unlink(self, cr, uid, ids, context=None):
if context is None:
"""Allows to delete sales order lines in draft,cancel states"""
for rec in self.browse(cr, uid, ids, context=context):
if rec.state not in ['draft', 'cancel']:
- raise osv.except_osv(_('Invalid action !'), _('Cannot delete a sales order line which is in state \'%s\'!') %(rec.state,))
+ raise osv.except_osv(_('Invalid Action!'), _('Cannot delete a sales order line which is in state \'%s\'.') %(rec.state,))
return super(sale_order_line, self).unlink(cr, uid, ids, context=context)
-sale_order_line()
-
-class sale_config_picking_policy(osv.osv_memory):
- _name = 'sale.config.picking_policy'
- _inherit = 'res.config'
- _columns = {
- 'name': fields.char('Name', size=64),
- 'sale_orders': fields.boolean('Based on Sales Orders',),
- 'deli_orders': fields.boolean('Based on Delivery Orders'),
- 'task_work': fields.boolean('Based on Tasks\' Work'),
- 'timesheet': fields.boolean('Based on Timesheet'),
- 'order_policy': fields.selection([
- ('manual', 'Invoice Based on Sales Orders'),
- ('picking', 'Invoice Based on Deliveries'),
- ], 'Main Method Based On', required=True, help="You can generate invoices based on sales orders or based on shippings."),
- 'charge_delivery': fields.boolean('Do you charge the delivery?'),
- 'time_unit': fields.many2one('product.uom','Main Working Time Unit')
- }
- _defaults = {
- 'order_policy': 'manual',
- 'time_unit': lambda self, cr, uid, c: self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c) and self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c)[0] or False,
- }
+class mail_compose_message(osv.Model):
+ _inherit = 'mail.compose.message'
- def onchange_order(self, cr, uid, ids, sale, deli, context=None):
- res = {}
- if sale:
- res.update({'order_policy': 'manual'})
- elif deli:
- res.update({'order_policy': 'picking'})
- return {'value':res}
-
- def execute(self, cr, uid, ids, context=None):
- ir_values_obj = self.pool.get('ir.values')
- data_obj = self.pool.get('ir.model.data')
- menu_obj = self.pool.get('ir.ui.menu')
- module_obj = self.pool.get('ir.module.module')
- module_upgrade_obj = self.pool.get('base.module.upgrade')
- module_name = []
-
- group_id = data_obj.get_object(cr, uid, 'base', 'group_sale_salesman').id
-
- wizard = self.browse(cr, uid, ids)[0]
-
- if wizard.sale_orders:
- menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_invoicing_sales_order_lines').id
- menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]})
-
- if wizard.deli_orders:
- menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_action_picking_list_to_invoice').id
- menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]})
-
- if wizard.task_work:
- module_name.append('project_timesheet')
- module_name.append('project_mrp')
- module_name.append('account_analytic_analysis')
-
- if wizard.timesheet:
- module_name.append('account_analytic_analysis')
-
- if wizard.charge_delivery:
- module_name.append('delivery')
-
- if len(module_name):
- module_ids = []
- need_install = False
- module_ids = []
- for module in module_name:
- data_id = module_obj.name_search(cr, uid , module, [], '=')
- module_ids.append(data_id[0][0])
-
- for module in module_obj.browse(cr, uid, module_ids):
- if module.state == 'uninstalled':
- module_obj.state_update(cr, uid, [module.id], 'to install', ['uninstalled'], context)
- need_install = True
- cr.commit()
- if need_install:
- pooler.restart_pool(cr.dbname, update_module=True)[1]
-
- if wizard.time_unit:
- prod_id = data_obj.get_object(cr, uid, 'product', 'product_consultant').id
- product_obj = self.pool.get('product.product')
- product_obj.write(cr, uid, prod_id, {'uom_id':wizard.time_unit.id, 'uom_po_id': wizard.time_unit.id})
-
- ir_values_obj.set(cr, uid, 'default', False, 'order_policy', ['sale.order'], wizard.order_policy)
- if wizard.task_work and wizard.time_unit:
- company_id = self.pool.get('res.users').browse(cr, uid, uid).company_id.id
- self.pool.get('res.company').write(cr, uid, [company_id], {
- 'project_time_mode_id': wizard.time_unit.id
- }, context=context)
-
-sale_config_picking_policy()
+ def send_mail(self, cr, uid, ids, context=None):
+ context = context or {}
+ if context.get('default_model') == 'sale.order' and context.get('default_res_id') and context.get('mark_so_as_sent'):
+ context = dict(context, mail_post_autofollow=True)
+ wf_service = netsvc.LocalService("workflow")
+ wf_service.trg_validate(uid, 'sale.order', context['default_res_id'], 'quotation_sent', cr)
+ return super(mail_compose_message, self).send_mail(cr, uid, ids, context=context)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
projects / odoo / odoo.git / blobdiff