import time
from lxml import etree
-import decimal_precision as dp
+import openerp.addons.decimal_precision as dp
+import openerp.exceptions
-import netsvc
-import pooler
-from osv import fields, osv, orm
-from tools.translate import _
+from openerp.osv import fields, osv, orm
+from openerp.tools.translate import _
class account_invoice(osv.osv):
def _amount_all(self, cr, uid, ids, name, args, context=None):
def _reconciled(self, cr, uid, ids, name, args, context=None):
res = {}
- for id in ids:
- res[id] = self.test_paid(cr, uid, [id])
+ for inv in self.browse(cr, uid, ids, context=context):
+ res[inv.id] = self.test_paid(cr, uid, [inv.id])
+ if not res[inv.id] and inv.state == 'paid':
+ self.signal_open_test(cr, uid, [inv.id])
return res
def _get_reference_type(self, cr, uid, context=None):
for m in invoice.move_id.line_id:
if m.account_id.type in ('receivable','payable'):
result[invoice.id] += m.amount_residual_currency
+ #prevent the residual amount on the invoice to be less than 0
+ result[invoice.id] = max(result[invoice.id], 0.0)
return result
# Give Journal Items related to the payment reconciled to this invoice
_inherit = ['mail.thread']
_description = 'Invoice'
_order = "id desc"
-
+ _track = {
+ 'type': {
+ },
+ 'state': {
+ 'account.mt_invoice_paid': lambda self, cr, uid, obj, ctx=None: obj['state'] == 'paid' and obj['type'] in ('out_invoice', 'out_refund'),
+ 'account.mt_invoice_validated': lambda self, cr, uid, obj, ctx=None: obj['state'] == 'open' and obj['type'] in ('out_invoice', 'out_refund'),
+ },
+ }
_columns = {
'name': fields.char('Description', size=64, select=True, readonly=True, states={'draft':[('readonly',False)]}),
'origin': fields.char('Source Document', size=64, help="Reference of the document that produced this invoice.", readonly=True, states={'draft':[('readonly',False)]}),
('in_invoice','Supplier Invoice'),
('out_refund','Customer Refund'),
('in_refund','Supplier Refund'),
- ],'Type', readonly=True, select=True, change_default=True),
+ ],'Type', readonly=True, select=True, change_default=True, track_visibility='always'),
'number': fields.related('move_id','name', type='char', readonly=True, size=64, relation='account.move', store=True, string='Number'),
'internal_number': fields.char('Invoice Number', size=32, readonly=True, help="Unique number of the invoice, computed automatically when the invoice is created."),
('open','Open'),
('paid','Paid'),
('cancel','Cancelled'),
- ],'Status', select=True, readonly=True,
+ ],'Status', select=True, readonly=True, track_visibility='onchange',
help=' * The \'Draft\' status is used when a user is encoding a new and unconfirmed Invoice. \
\n* The \'Pro-forma\' when invoice is in Pro-forma status,invoice does not have an invoice number. \
\n* The \'Open\' status is used when user create invoice,a invoice number is generated.Its in open status till user does not pay invoice. \
'date_invoice': fields.date('Invoice Date', readonly=True, states={'draft':[('readonly',False)]}, select=True, help="Keep empty to use the current date"),
'date_due': fields.date('Due Date', readonly=True, states={'draft':[('readonly',False)]}, select=True,
help="If you use payment terms, the due date will be computed automatically at the generation "\
- "of accounting entries. If you want to force a due date, make sure that the payment term is not set on the invoice. If you keep the payment term and the due date empty, it means direct payment."),
- 'partner_id': fields.many2one('res.partner', 'Partner', change_default=True, readonly=True, required=True, states={'draft':[('readonly',False)]}),
- 'payment_term': fields.many2one('account.payment.term', 'Payment Term',readonly=True, states={'draft':[('readonly',False)]},
+ "of accounting entries. The payment term may compute several due dates, for example 50% now and 50% in one month, but if you want to force a due date, make sure that the payment term is not set on the invoice. If you keep the payment term and the due date empty, it means direct payment."),
+ 'partner_id': fields.many2one('res.partner', 'Partner', change_default=True, readonly=True, required=True, states={'draft':[('readonly',False)]}, track_visibility='always'),
+ 'payment_term': fields.many2one('account.payment.term', 'Payment Terms',readonly=True, states={'draft':[('readonly',False)]},
help="If you use payment terms, the due date will be computed automatically at the generation "\
"of accounting entries. If you keep the payment term and the due date empty, it means direct payment. "\
"The payment term may compute several due dates, for example 50% now, 50% in one month."),
'tax_line': fields.one2many('account.invoice.tax', 'invoice_id', 'Tax Lines', readonly=True, states={'draft':[('readonly',False)]}),
'move_id': fields.many2one('account.move', 'Journal Entry', readonly=True, select=1, ondelete='restrict', help="Link to the automatically generated Journal Items."),
- 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Untaxed',
+ 'amount_untaxed': fields.function(_amount_all, digits_compute=dp.get_precision('Account'), string='Subtotal', track_visibility='always',
store={
'account.invoice': (lambda self, cr, uid, ids, c={}: ids, ['invoice_line'], 20),
'account.invoice.tax': (_get_invoice_tax, None, 20),
'account.invoice.line': (_get_invoice_line, ['price_unit','invoice_line_tax_id','quantity','discount','invoice_id'], 20),
},
multi='all'),
- 'currency_id': fields.many2one('res.currency', 'Currency', required=True, readonly=True, states={'draft':[('readonly',False)]}),
+ 'currency_id': fields.many2one('res.currency', 'Currency', required=True, readonly=True, states={'draft':[('readonly',False)]}, track_visibility='always'),
'journal_id': fields.many2one('account.journal', 'Journal', required=True, readonly=True, states={'draft':[('readonly',False)]}),
'company_id': fields.many2one('res.company', 'Company', required=True, change_default=True, readonly=True, states={'draft':[('readonly',False)]}),
'check_total': fields.float('Verification Total', digits_compute=dp.get_precision('Account'), readonly=True, states={'draft':[('readonly',False)]}),
help="Remaining amount due."),
'payment_ids': fields.function(_compute_lines, relation='account.move.line', type="many2many", string='Payments'),
'move_name': fields.char('Journal Entry', size=64, readonly=True, states={'draft':[('readonly',False)]}),
- 'user_id': fields.many2one('res.users', 'Salesperson', readonly=True, states={'draft':[('readonly',False)]}),
- 'fiscal_position': fields.many2one('account.fiscal.position', 'Fiscal Position', readonly=True, states={'draft':[('readonly',False)]})
+ 'user_id': fields.many2one('res.users', 'Salesperson', readonly=True, track_visibility='onchange', states={'draft':[('readonly',False)]}),
+ 'fiscal_position': fields.many2one('account.fiscal.position', 'Fiscal Position', readonly=True, states={'draft':[('readonly',False)]}),
+ 'commercial_partner_id': fields.related('partner_id', 'commercial_partner_id', string='Commercial Entity', type='many2one',
+ relation='res.partner', store=True, readonly=True,
+ help="The commercial entity that will be used on Journal Entries for this invoice")
}
_defaults = {
'type': _get_type,
('number_uniq', 'unique(number, company_id, journal_id, type)', 'Invoice Number must be unique per Company!'),
]
+
+
+
def fields_view_get(self, cr, uid, view_id=None, view_type=False, context=None, toolbar=False, submenu=False):
journal_obj = self.pool.get('account.journal')
if context is None:
context = {}
if context.get('active_model', '') in ['res.partner'] and context.get('active_ids', False) and context['active_ids']:
- partner = self.pool.get(context['active_model']).read(cr, uid, context['active_ids'], ['supplier','customer'])[0]
+ partner = self.pool[context['active_model']].read(cr, uid, context['active_ids'], ['supplier','customer'])[0]
if not view_type:
view_id = self.pool.get('ir.ui.view').search(cr, uid, [('name', '=', 'account.invoice.tree')])
view_type = 'tree'
context['view_id'] = view_id
return context
- def create(self, cr, uid, vals, context=None):
- if context is None:
- context = {}
- try:
- res = super(account_invoice, self).create(cr, uid, vals, context)
- if res:
- self.create_send_note(cr, uid, [res], context=context)
- return res
- except Exception, e:
- if '"journal_id" viol' in e.args[0]:
- raise orm.except_orm(_('Configuration Error!'),
- _('There is no Sale/Purchase Journal(s) defined.'))
- else:
- raise orm.except_orm(_('Unknown Error!'), str(e))
-
def invoice_print(self, cr, uid, ids, context=None):
'''
This function prints the invoice and mark it as sent, so that we can see more easily the next step of the workflow
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
+ compose_form_id = False
ctx = dict(context)
ctx.update({
'default_model': 'account.invoice',
'mark_invoice_as_sent': True,
})
return {
+ 'name': _('Compose Email'),
'type': 'ir.actions.act_window',
'view_type': 'form',
'view_mode': 'form',
if context is None:
context = {}
self.write(cr, uid, ids, {'state':'paid'}, context=context)
- self.confirm_paid_send_note(cr, uid, ids, context=context)
return True
def unlink(self, cr, uid, ids, context=None):
context = {}
invoices = self.read(cr, uid, ids, ['state','internal_number'], context=context)
unlink_ids = []
+
for t in invoices:
- if t['state'] in ('draft', 'cancel') and t['internal_number']== False:
- unlink_ids.append(t['id'])
+ if t['state'] not in ('draft', 'cancel'):
+ raise openerp.exceptions.Warning(_('You cannot delete an invoice which is not draft or cancelled. You should refund it instead.'))
+ elif t['internal_number']:
+ raise openerp.exceptions.Warning(_('You cannot delete an invoice after it has been validated (and received a number). You can set it back to "Draft" state and modify its content, then re-confirm it.'))
else:
- raise osv.except_osv(_('Invalid Action!'), _('You can not delete an invoice which is not cancelled. You should refund it instead.'))
+ unlink_ids.append(t['id'])
+
osv.osv.unlink(self, cr, uid, unlink_ids, context=context)
return True
def onchange_partner_id(self, cr, uid, ids, type, partner_id,\
date_invoice=False, payment_term=False, partner_bank_id=False, company_id=False):
- invoice_addr_id = False
partner_payment_term = False
acc_id = False
bank_id = False
if partner_id:
opt.insert(0, ('id', partner_id))
- res = self.pool.get('res.partner').address_get(cr, uid, [partner_id], ['invoice'])
- invoice_addr_id = res['invoice']
p = self.pool.get('res.partner').browse(cr, uid, partner_id)
if company_id:
if (p.property_account_receivable.company_id and (p.property_account_receivable.company_id.id != company_id)) and (p.property_account_payable.company_id and (p.property_account_payable.company_id.id != company_id)):
def onchange_payment_term_date_invoice(self, cr, uid, ids, payment_term_id, date_invoice):
res = {}
- if not payment_term_id:
- return res
if not date_invoice:
date_invoice = time.strftime('%Y-%m-%d')
+ if not payment_term_id:
+ return {'value':{'date_due': date_invoice}} #To make sure the invoice has a due date when no payment term
pterm_list = self.pool.get('account.payment.term').compute(cr, uid, payment_term_id, value=1, date_ref=date_invoice)
if pterm_list:
pterm_list = [line[0] for line in pterm_list]
def onchange_partner_bank(self, cursor, user, ids, partner_bank_id=False):
return {'value': {}}
- def onchange_company_id(self, cr, uid, ids, company_id, part_id, type, invoice_line, currency_id):
+ def onchange_company_id(self, cr, uid, ids, company_id, part_id, type, invoice_line, currency_id, context=None):
val = {}
dom = {}
obj_journal = self.pool.get('account.journal')
account_obj = self.pool.get('account.account')
inv_line_obj = self.pool.get('account.invoice.line')
+
if company_id and part_id and type:
acc_id = False
- partner_obj = self.pool.get('res.partner').browse(cr,uid,part_id)
+ partner_obj = self.pool.get('res.partner').browse(cr, uid, part_id, context=context)
+
if partner_obj.property_account_payable and partner_obj.property_account_receivable:
if partner_obj.property_account_payable.company_id.id != company_id and partner_obj.property_account_receivable.company_id.id != company_id:
property_obj = self.pool.get('ir.property')
rec_pro_id = property_obj.search(cr, uid, [('name','=','property_account_receivable'),('res_id','=','res.partner,'+str(part_id)+''),('company_id','=',company_id)])
pay_pro_id = property_obj.search(cr, uid, [('name','=','property_account_payable'),('res_id','=','res.partner,'+str(part_id)+''),('company_id','=',company_id)])
+
if not rec_pro_id:
rec_pro_id = property_obj.search(cr, uid, [('name','=','property_account_receivable'),('company_id','=',company_id)])
if not pay_pro_id:
pay_pro_id = property_obj.search(cr, uid, [('name','=','property_account_payable'),('company_id','=',company_id)])
+
rec_line_data = property_obj.read(cr, uid, rec_pro_id, ['name','value_reference','res_id'])
pay_line_data = property_obj.read(cr, uid, pay_pro_id, ['name','value_reference','res_id'])
rec_res_id = rec_line_data and rec_line_data[0].get('value_reference',False) and int(rec_line_data[0]['value_reference'].split(',')[1]) or False
pay_res_id = pay_line_data and pay_line_data[0].get('value_reference',False) and int(pay_line_data[0]['value_reference'].split(',')[1]) or False
+
if not rec_res_id and not pay_res_id:
- raise osv.except_osv(_('Configuration Error!'),
- _('Cannot find a chart of account, you should create one from Settings\Configuration\Accounting menu.'))
+ raise self.pool.get('res.config.settings').get_config_warning(cr, _('Cannot find any chart of account: you can create a new one from %(menu:account.menu_account_config)s.'), context=context)
+
if type in ('out_invoice', 'out_refund'):
acc_id = rec_res_id
else:
acc_id = pay_res_id
+
val= {'account_id': acc_id}
if ids:
if company_id:
# go from canceled state to draft state
def action_cancel_draft(self, cr, uid, ids, *args):
self.write(cr, uid, ids, {'state':'draft'})
- wf_service = netsvc.LocalService("workflow")
- for inv_id in ids:
- wf_service.trg_delete(uid, 'account.invoice', inv_id, cr)
- wf_service.trg_create(uid, 'account.invoice', inv_id, cr)
+ self.delete_workflow(cr, uid, ids)
+ self.create_workflow(cr, uid, ids)
return True
+ # ----------------------------------------
+ # Mail related methods
+ # ----------------------------------------
+
+ def _get_formview_action(self, cr, uid, id, context=None):
+ """ Update form view id of action to open the invoice """
+ action = super(account_invoice, self)._get_formview_action(cr, uid, id, context=context)
+ obj = self.browse(cr, uid, id, context=context)
+ if obj.type == 'in_invoice':
+ model, view_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account', 'invoice_supplier_form')
+ action.update({
+ 'views': [(view_id, 'form')],
+ })
+ else:
+ model, view_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account', 'invoice_form')
+ action.update({
+ 'views': [(view_id, 'form')],
+ })
+ return action
+
# Workflow stuff
#################
date = inv.date_invoice or time.strftime('%Y-%m-%d')
- #if the chosen partner is not a company and has a parent company, use the parent for the journal entries
- #because you want to invoice 'Agrolait, accounting department' but the journal items are for 'Agrolait'
- part = inv.partner_id
- if part.parent_id and not part.is_company:
- part = part.parent_id
+ part = self.pool.get("res.partner")._find_accounting_partner(inv.partner_id)
line = map(lambda x:(0,0,self.line_get_convert(cr, uid, x, part.id, date, context=ctx)),iml)
'narration':inv.comment
}
period_id = inv.period_id and inv.period_id.id or False
- ctx.update({'company_id': inv.company_id.id})
+ ctx.update(company_id=inv.company_id.id)
if not period_id:
period_ids = period_obj.find(cr, uid, inv.date_invoice, context=ctx)
period_id = period_ids and period_ids[0] or False
self.write(cr, uid, ids, {})
for obj_inv in self.browse(cr, uid, ids, context=context):
- id = obj_inv.id
invtype = obj_inv.type
number = obj_inv.number
move_id = obj_inv.move_id and obj_inv.move_id.id or False
reference = obj_inv.reference or ''
- self.write(cr, uid, ids, {'internal_number':number})
+ self.write(cr, uid, ids, {'internal_number': number})
if invtype in ('in_invoice', 'in_refund'):
if not reference:
'WHERE account_move_line.move_id = %s ' \
'AND account_analytic_line.move_id = account_move_line.id',
(ref, move_id))
-
- for inv_id, name in self.name_get(cr, uid, [id]):
- ctx = context.copy()
- if obj_inv.type in ('out_invoice', 'out_refund'):
- ctx = self.get_log_context(cr, uid, context=ctx)
- message = _("Invoice '%s' is validated.") % name
- self.message_post(cr, uid, [inv_id], body=message, context=context)
return True
def action_cancel(self, cr, uid, ids, context=None):
# will be automatically deleted too
account_move_obj.unlink(cr, uid, move_ids, context=context)
self._log_event(cr, uid, ids, -1.0, 'Cancel Invoice')
- self.invoice_cancel_send_note(cr, uid, ids, context=context)
return True
###################
ids = self.search(cr, user, [('name',operator,name)] + args, limit=limit, context=context)
return self.name_get(cr, user, ids, context)
- def _refund_cleanup_lines(self, cr, uid, lines):
+ def _refund_cleanup_lines(self, cr, uid, lines, context=None):
+ """Convert records to dict of values suitable for one2many line creation
+
+ :param list(browse_record) lines: records to convert
+ :return: list of command tuple for one2many line creation [(0, 0, dict of valueis), ...]
+ """
+ clean_lines = []
for line in lines:
- del line['id']
- del line['invoice_id']
- for field in ('company_id', 'partner_id', 'account_id', 'product_id',
- 'uos_id', 'account_analytic_id', 'tax_code_id', 'base_code_id'):
- if line.get(field):
- line[field] = line[field][0]
- if 'invoice_line_tax_id' in line:
- line['invoice_line_tax_id'] = [(6,0, line.get('invoice_line_tax_id', [])) ]
- return map(lambda x: (0,0,x), lines)
-
- def refund(self, cr, uid, ids, date=None, period_id=None, description=None, journal_id=None):
- invoices = self.read(cr, uid, ids, ['name', 'type', 'number', 'reference', 'comment', 'date_due', 'partner_id', 'partner_contact', 'partner_insite', 'partner_ref', 'payment_term', 'account_id', 'currency_id', 'invoice_line', 'tax_line', 'journal_id', 'company_id'])
- obj_invoice_line = self.pool.get('account.invoice.line')
- obj_invoice_tax = self.pool.get('account.invoice.tax')
+ clean_line = {}
+ for field in line._all_columns.keys():
+ if line._all_columns[field].column._type == 'many2one':
+ clean_line[field] = line[field].id
+ elif line._all_columns[field].column._type not in ['many2many','one2many']:
+ clean_line[field] = line[field]
+ elif field == 'invoice_line_tax_id':
+ tax_list = []
+ for tax in line[field]:
+ tax_list.append(tax.id)
+ clean_line[field] = [(6,0, tax_list)]
+ clean_lines.append(clean_line)
+ return map(lambda x: (0,0,x), clean_lines)
+
+ def _prepare_refund(self, cr, uid, invoice, date=None, period_id=None, description=None, journal_id=None, context=None):
+ """Prepare the dict of values to create the new refund from the invoice.
+ This method may be overridden to implement custom
+ refund generation (making sure to call super() to establish
+ a clean extension chain).
+
+ :param integer invoice_id: id of the invoice to refund
+ :param dict invoice: read of the invoice to refund
+ :param string date: refund creation date from the wizard
+ :param integer period_id: force account.period from the wizard
+ :param string description: description of the refund from the wizard
+ :param integer journal_id: account.journal from the wizard
+ :return: dict of value to create() the refund
+ """
obj_journal = self.pool.get('account.journal')
- new_ids = []
- for invoice in invoices:
- del invoice['id']
-
- type_dict = {
- 'out_invoice': 'out_refund', # Customer Invoice
- 'in_invoice': 'in_refund', # Supplier Invoice
- 'out_refund': 'out_invoice', # Customer Refund
- 'in_refund': 'in_invoice', # Supplier Refund
- }
- invoice_lines = obj_invoice_line.read(cr, uid, invoice['invoice_line'])
- invoice_lines = self._refund_cleanup_lines(cr, uid, invoice_lines)
-
- tax_lines = obj_invoice_tax.read(cr, uid, invoice['tax_line'])
- tax_lines = filter(lambda l: l['manual'], tax_lines)
- tax_lines = self._refund_cleanup_lines(cr, uid, tax_lines)
- if journal_id:
- refund_journal_ids = [journal_id]
- elif invoice['type'] == 'in_invoice':
- refund_journal_ids = obj_journal.search(cr, uid, [('type','=','purchase_refund')])
+ type_dict = {
+ 'out_invoice': 'out_refund', # Customer Invoice
+ 'in_invoice': 'in_refund', # Supplier Invoice
+ 'out_refund': 'out_invoice', # Customer Refund
+ 'in_refund': 'in_invoice', # Supplier Refund
+ }
+ invoice_data = {}
+ for field in ['name', 'reference', 'comment', 'date_due', 'partner_id', 'company_id',
+ 'account_id', 'currency_id', 'payment_term', 'user_id', 'fiscal_position']:
+ if invoice._all_columns[field].column._type == 'many2one':
+ invoice_data[field] = invoice[field].id
else:
- refund_journal_ids = obj_journal.search(cr, uid, [('type','=','sale_refund')])
-
- if not date:
- date = time.strftime('%Y-%m-%d')
- invoice.update({
- 'type': type_dict[invoice['type']],
- 'date_invoice': date,
- 'state': 'draft',
- 'number': False,
- 'invoice_line': invoice_lines,
- 'tax_line': tax_lines,
- 'journal_id': refund_journal_ids
- })
- if period_id:
- invoice.update({
- 'period_id': period_id,
- })
- if description:
- invoice.update({
- 'name': description,
- })
- # take the id part of the tuple returned for many2one fields
- for field in ('partner_id', 'company_id',
- 'account_id', 'currency_id', 'payment_term', 'journal_id'):
- invoice[field] = invoice[field] and invoice[field][0]
+ invoice_data[field] = invoice[field] if invoice[field] else False
+
+ invoice_lines = self._refund_cleanup_lines(cr, uid, invoice.invoice_line, context=context)
+
+ tax_lines = filter(lambda l: l['manual'], invoice.tax_line)
+ tax_lines = self._refund_cleanup_lines(cr, uid, tax_lines, context=context)
+ if journal_id:
+ refund_journal_ids = [journal_id]
+ elif invoice['type'] == 'in_invoice':
+ refund_journal_ids = obj_journal.search(cr, uid, [('type','=','purchase_refund')], context=context)
+ else:
+ refund_journal_ids = obj_journal.search(cr, uid, [('type','=','sale_refund')], context=context)
+
+ if not date:
+ date = time.strftime('%Y-%m-%d')
+ invoice_data.update({
+ 'type': type_dict[invoice['type']],
+ 'date_invoice': date,
+ 'state': 'draft',
+ 'number': False,
+ 'invoice_line': invoice_lines,
+ 'tax_line': tax_lines,
+ 'journal_id': refund_journal_ids and refund_journal_ids[0] or False,
+ })
+ if period_id:
+ invoice_data['period_id'] = period_id
+ if description:
+ invoice_data['name'] = description
+ return invoice_data
+
+ def refund(self, cr, uid, ids, date=None, period_id=None, description=None, journal_id=None, context=None):
+ new_ids = []
+ for invoice in self.browse(cr, uid, ids, context=context):
+ invoice = self._prepare_refund(cr, uid, invoice,
+ date=date,
+ period_id=period_id,
+ description=description,
+ journal_id=journal_id,
+ context=context)
# create the new invoice
- new_ids.append(self.create(cr, uid, invoice))
+ new_ids.append(self.create(cr, uid, invoice, context=context))
return new_ids
ref = invoice.reference
else:
ref = self._convert_ref(cr, uid, invoice.number)
- partner = invoice.partner_id
- if partner.parent_id and not partner.is_company:
- partner = partner.parent_id
+ partner = self.pool['res.partner']._find_accounting_partner(invoice.partner_id)
# Pay attention to the sign for both debit/credit AND amount_currency
l1 = {
'debit': direction * pay_amount>0 and direction * pay_amount,
else:
code = invoice.currency_id.symbol
# TODO: use currency's formatting function
- msg = _("Invoice '%s' is paid partially: %s%s of %s%s (%s%s remaining).") % \
- (name, pay_amount, code, invoice.amount_total, code, total, code)
+ msg = _("Invoice partially paid: %s%s of %s%s (%s%s remaining).") % \
+ (pay_amount, code, invoice.amount_total, code, total, code)
self.message_post(cr, uid, [inv_id], body=msg, context=context)
self.pool.get('account.move.line').reconcile_partial(cr, uid, line_ids, 'manual', context)
self.pool.get('account.invoice').write(cr, uid, ids, {}, context=context)
return True
- # -----------------------------------------
- # OpenChatter notifications and need_action
- # -----------------------------------------
-
- def _get_document_type(self, type):
- type_dict = {
- # Translation markers will have no effect at runtime, only used to properly flag export
- 'out_invoice': _('Customer invoice'),
- 'in_invoice': _('Supplier invoice'),
- 'out_refund': _('Customer Refund'),
- 'in_refund': _('Supplier Refund'),
- }
- return type_dict.get(type, 'Invoice')
-
- def create_send_note(self, cr, uid, ids, context=None):
- for obj in self.browse(cr, uid, ids, context=context):
- self.message_post(cr, uid, [obj.id], body=_("%s <b>created</b>.") % (self._get_document_type(obj.type)),
- subtype="account.mt_invoice_new", context=context)
-
- def confirm_paid_send_note(self, cr, uid, ids, context=None):
- for obj in self.browse(cr, uid, ids, context=context):
- self.message_post(cr, uid, [obj.id], body=_("%s <b>paid</b>.") % (self._get_document_type(obj.type)),
- subtype="account.mt_invoice_paid", context=context)
-
- def invoice_cancel_send_note(self, cr, uid, ids, context=None):
- for obj in self.browse(cr, uid, ids, context=context):
- self.message_post(cr, uid, [obj.id], body=_("%s <b>cancelled</b>.") % (self._get_document_type(obj.type)),
- context=context)
-
class account_invoice_line(osv.osv):
'product_id': fields.many2one('product.product', 'Product', ondelete='set null', select=True),
'account_id': fields.many2one('account.account', 'Account', required=True, domain=[('type','<>','view'), ('type', '<>', 'closed')], help="The income or expense account related to the selected product."),
'price_unit': fields.float('Unit Price', required=True, digits_compute= dp.get_precision('Product Price')),
- 'price_subtotal': fields.function(_amount_line, string='Subtotal', type="float",
+ 'price_subtotal': fields.function(_amount_line, string='Amount', type="float",
digits_compute= dp.get_precision('Account'), store=True),
'quantity': fields.float('Quantity', digits_compute= dp.get_precision('Product Unit of Measure'), required=True),
'discount': fields.float('Discount (%)', digits_compute= dp.get_precision('Discount')),
# XXX this gets the default account for the user's company,
# it should get the default account for the invoice's company
# however, the invoice's company does not reach this point
- prop = self.pool.get('ir.property').get(cr, uid, 'property_account_income_categ', 'product.category', context=context)
+ if context is None:
+ context = {}
+ if context.get('type') in ('out_invoice','out_refund'):
+ prop = self.pool.get('ir.property').get(cr, uid, 'property_account_income_categ', 'product.category', context=context)
+ else:
+ prop = self.pool.get('ir.property').get(cr, uid, 'property_account_expense_categ', 'product.category', context=context)
return prop and prop.id or False
_defaults = {
res['arch'] = etree.tostring(doc)
return res
- def product_id_change(self, cr, uid, ids, product, uom, qty=0, name='', type='out_invoice', partner_id=False, fposition_id=False, price_unit=False, currency_id=False, context=None, company_id=None):
+ def product_id_change(self, cr, uid, ids, product, uom_id, qty=0, name='', type='out_invoice', partner_id=False, fposition_id=False, price_unit=False, currency_id=False, context=None, company_id=None):
if context is None:
context = {}
company_id = company_id if company_id != None else context.get('company_id',False)
res = self.pool.get('product.product').browse(cr, uid, product, context=context)
if type in ('out_invoice','out_refund'):
- a = res.product_tmpl_id.property_account_income.id
+ a = res.property_account_income.id
if not a:
a = res.categ_id.property_account_income_categ.id
else:
- a = res.product_tmpl_id.property_account_expense.id
+ a = res.property_account_expense.id
if not a:
a = res.categ_id.property_account_expense_categ.id
a = fpos_obj.map_account(cr, uid, fpos, a)
result.update({'price_unit': res.list_price, 'invoice_line_tax_id': tax_id})
result['name'] = res.partner_ref
- domain = {}
- result['uos_id'] = res.uom_id.id or uom or False
+ result['uos_id'] = uom_id or res.uom_id.id
if res.description:
result['name'] += '\n'+res.description
- if result['uos_id']:
- res2 = res.uom_id.category_id.id
- if res2:
- domain = {'uos_id':[('category_id','=',res2 )]}
+
+ domain = {'uos_id':[('category_id','=',res.uom_id.category_id.id)]}
res_final = {'value':result, 'domain':domain}
new_price = res_final['value']['price_unit'] * currency.rate
res_final['value']['price_unit'] = new_price
- if uom:
- uom = self.pool.get('product.uom').browse(cr, uid, uom, context=context)
- if res.uom_id.category_id.id == uom.category_id.id:
- new_price = res_final['value']['price_unit'] * uom.factor_inv
- res_final['value']['price_unit'] = new_price
+ if result['uos_id'] and result['uos_id'] != res.uom_id.id:
+ selected_uom = self.pool.get('product.uom').browse(cr, uid, result['uos_id'], context=context)
+ new_price = self.pool.get('product.uom')._compute_price(cr, uid, res.uom_id.id, res_final['value']['price_unit'], result['uos_id'])
+ res_final['value']['price_unit'] = new_price
return res_final
def uos_id_change(self, cr, uid, ids, product, uom, qty=0, name='', type='out_invoice', partner_id=False, fposition_id=False, price_unit=False, currency_id=False, context=None, company_id=None):
context.update({'company_id': company_id})
warning = {}
res = self.product_id_change(cr, uid, ids, product, uom, qty, name, type, partner_id, fposition_id, price_unit, currency_id, context=context)
- if 'uos_id' in res['value']:
- del res['value']['uos_id']
if not uom:
res['value']['price_unit'] = 0.0
if product and uom:
unique_tax_ids = product_change_result['value']['invoice_line_tax_id']
return {'value':{'invoice_line_tax_id': unique_tax_ids}}
-account_invoice_line()
class account_invoice_tax(osv.osv):
_name = "account.invoice.tax"
'invoice_ids': fields.one2many('account.invoice.line', 'partner_id', 'Invoices', readonly=True),
}
+ def _find_accounting_partner(self, partner):
+ '''
+ Find the partner for which the accounting entries will be created
+ '''
+ return partner.commercial_partner_id
+
def copy(self, cr, uid, id, default=None, context=None):
default = default or {}
default.update({'invoice_ids' : []})
return super(res_partner, self).copy(cr, uid, id, default, context)
-class mail_compose_message(osv.osv):
+class mail_compose_message(osv.Model):
_inherit = 'mail.compose.message'
def send_mail(self, cr, uid, ids, context=None):
context = context or {}
if context.get('default_model') == 'account.invoice' and context.get('default_res_id') and context.get('mark_invoice_as_sent'):
+ context = dict(context, mail_post_autofollow=True)
self.pool.get('account.invoice').write(cr, uid, [context['default_res_id']], {'sent': True}, context=context)
+ self.pool.get('account.invoice').message_post(cr, uid, [context['default_res_id']], body=_("Invoice sent"), context=context)
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