class AccountMoveLine(models.Model):
_inherit = 'account.move.line'
l10n_latam_document_type_id = fields.Many2one(
related='move_id.l10n_latam_document_type_id',
auto_join=True,
store=True,
index=True)
l10n_latam_price_unit = fields.Monetary(
compute='compute_l10n_latam_prices_and_taxes')
l10n_latam_price_subtotal = fields.Monetary(
compute='compute_l10n_latam_prices_and_taxes')
l10n_latam_price_net = fields.Monetary(
compute='compute_l10n_latam_prices_and_taxes')
l10n_latam_tax_ids = fields.One2many(
compute="compute_l10n_latam_prices_and_taxes",
comodel_name='account.tax')
@api.depends('price_unit', 'price_subtotal',
'move_id.l10n_latam_document_type_id')
def compute_l10n_latam_prices_and_taxes(self):
for line in self:
invoice = line.move_id
included_taxes = \
invoice.l10n_latam_document_type_id and invoice.l10n_latam_document_type_id._filter_taxes_included(
line.tax_ids)
if not included_taxes:
price_unit = line.tax_ids.with_context(
round=False).compute_all(line.price_unit,
invoice.currency_id, 1.0,
line.product_id,
invoice.partner_id)
l10n_latam_price_unit = price_unit['total_excluded']
l10n_latam_price_subtotal = line.price_subtotal
not_included_taxes = line.tax_ids
l10n_latam_price_net = l10n_latam_price_unit * (
1 - (line.discount or 0.0) / 100.0)
else:
not_included_taxes = line.tax_ids - included_taxes
l10n_latam_price_unit = included_taxes.compute_all(
line.price_unit, invoice.currency_id, 1.0, line.product_id,
invoice.partner_id)['total_included']
l10n_latam_price_net = l10n_latam_price_unit * (
1 - (line.discount or 0.0) / 100.0)
price = line.price_unit * (1 - (line.discount or 0.0) / 100.0)
l10n_latam_price_subtotal = included_taxes.compute_all(
price, invoice.currency_id, line.quantity, line.product_id,
invoice.partner_id)['total_included']
line.l10n_latam_price_subtotal = l10n_latam_price_subtotal
line.l10n_latam_price_unit = l10n_latam_price_unit
line.l10n_latam_price_net = l10n_latam_price_net
line.l10n_latam_tax_ids = not_included_taxes
class Company(models.Model):
_inherit = 'res.company'
po_lead = fields.Float(
string='Purchase Lead Time',
required=True,
help="Margin of error for vendor lead times. When the system "
"generates Purchase Orders for procuring products, "
"they will be scheduled that many days earlier "
"to cope with unexpected vendor delays.",
default=0.0)
po_lock = fields.Selection(
[('edit', 'Allow to edit purchase orders'),
('lock', 'Confirmed purchase orders are not editable')],
string="Purchase Order Modification",
default="edit",
help=
'Purchase Order Modification used when you want to purchase order editable after confirm'
)
po_double_validation = fields.Selection(
[('one_step', 'Confirm purchase orders in one step'),
('two_step', 'Get 2 levels of approvals to confirm a purchase order')
],
string="Levels of Approvals",
default='one_step',
help="Provide a double validation mechanism for purchases")
po_double_validation_amount = fields.Monetary(
string='Double validation amount',
default=5000,
help="Minimum amount for which a double validation is required")
class Digest(models.Model):
_inherit = 'digest.digest'
kpi_all_sale_total = fields.Boolean('All Sales')
kpi_all_sale_total_value = fields.Monetary(
compute='_compute_kpi_sale_total_value')
def _compute_kpi_sale_total_value(self):
if not self.env.user.has_group(
'sales_team.group_sale_salesman_all_leads'):
raise AccessError(
_("Do not have access, skip this data for user's digest email")
)
for record in self:
start, end, company = record._get_kpi_compute_parameters()
all_channels_sales = self.env['sale.report'].read_group(
[('date', '>=', start), ('date', '<', end),
('state', 'not in', ['draft', 'cancel', 'sent']),
('company_id', '=', company.id)], ['price_total'],
['price_total'])
record.kpi_all_sale_total_value = sum([
channel_sale['price_total']
for channel_sale in all_channels_sales
])
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_all_sale_total'] = 'sale.report_all_channels_sales_action&menu_id=%s' % self.env.ref(
'sale.sale_menu_root').id
return res
class AccountAnalyticLine(models.Model):
_name = 'account.analytic.line'
_description = 'Analytic Line'
_order = 'date desc, id desc'
@api.model
def _default_user(self):
return self.env.context.get('user_id', self.env.user.id)
name = fields.Char('Description', required=True)
date = fields.Date('Date', required=True, index=True, default=fields.Date.context_today)
amount = fields.Monetary('Amount', required=True, default=0.0)
unit_amount = fields.Float('Quantity', default=0.0)
product_uom_id = fields.Many2one('uom.uom', string='Unit of Measure', domain="[('category_id', '=', product_uom_category_id)]")
product_uom_category_id = fields.Many2one(related='product_uom_id.category_id', readonly=True)
account_id = fields.Many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='restrict', index=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
partner_id = fields.Many2one('res.partner', string='Partner', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
user_id = fields.Many2one('res.users', string='User', default=_default_user)
tag_ids = fields.Many2many('account.analytic.tag', 'account_analytic_line_tag_rel', 'line_id', 'tag_id', string='Tags', copy=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
company_id = fields.Many2one('res.company', string='Company', required=True, readonly=True, default=lambda self: self.env.company)
currency_id = fields.Many2one(related="company_id.currency_id", string="Currency", readonly=True, store=True, compute_sudo=True)
group_id = fields.Many2one('account.analytic.group', related='account_id.group_id', store=True, readonly=True, compute_sudo=True)
@api.constrains('company_id', 'account_id')
def _check_company_id(self):
for line in self:
if line.account_id.company_id and line.company_id.id != line.account_id.company_id.id:
raise ValidationError(_('The selected account belongs to another company that the one you\'re trying to create an analytic item for'))
class Digest(models.Model):
_inherit = 'digest.digest'
kpi_account_total_revenue = fields.Boolean('Revenue')
kpi_account_total_revenue_value = fields.Monetary(
compute='_compute_kpi_account_total_revenue_value')
def _compute_kpi_account_total_revenue_value(self):
if not self.env.user.has_group('account.group_account_invoice'):
raise AccessError(
_("Do not have access, skip this data for user's digest email")
)
for record in self:
start, end, company = record._get_kpi_compute_parameters()
self._cr.execute(
'''
SELECT SUM(line.debit)
FROM account_move_line line
JOIN account_move move ON move.id = line.move_id
JOIN account_journal journal ON journal.id = move.journal_id
WHERE line.company_id = %s AND line.date >= %s AND line.date < %s
AND journal.type = 'sale'
''', [company.id, start, end])
query_res = self._cr.fetchone()
record.kpi_account_total_revenue_value = query_res and query_res[
0] or 0.0
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_account_total_revenue'] = 'account.action_move_out_invoice_type&menu_id=%s' % self.env.ref(
'account.menu_finance').id
return res
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
lock_confirmed_po = fields.Boolean(
"Lock Confirmed Orders",
default=lambda self: self.env.company.po_lock == 'lock')
po_lock = fields.Selection(related='company_id.po_lock',
string="Purchase Order Modification *",
readonly=False)
po_order_approval = fields.Boolean("Purchase Order Approval",
default=lambda self: self.env.company.
po_double_validation == 'two_step')
po_double_validation = fields.Selection(
related='company_id.po_double_validation',
string="Levels of Approvals *",
readonly=False)
po_double_validation_amount = fields.Monetary(
related='company_id.po_double_validation_amount',
string="Minimum Amount",
currency_field='company_currency_id',
readonly=False)
company_currency_id = fields.Many2one(
'res.currency',
related='company_id.currency_id',
string="Company Currency",
readonly=True,
help='Utility field to express amount currency')
default_purchase_method = fields.Selection(
[
('purchase', 'Ordered quantities'),
('receive', 'Received quantities'),
],
string="Bill Control",
default_model="product.template",
help="This default value is applied to any new product created. "
"This can be changed in the product detail form.",
default="receive")
group_warning_purchase = fields.Boolean(
"Purchase Warnings", implied_group='purchase.group_warning_purchase')
module_account_3way_match = fields.Boolean(
"3-way matching: purchases, receptions and bills")
module_purchase_requisition = fields.Boolean("Purchase Agreements")
module_purchase_product_matrix = fields.Boolean("Purchase Grid Entry")
po_lead = fields.Float(related='company_id.po_lead', readonly=False)
use_po_lead = fields.Boolean(
string="Security Lead Time for Purchase",
config_parameter='purchase.use_po_lead',
help=
"Margin of error for vendor lead times. When the system generates Purchase Orders for reordering products,they will be scheduled that many days earlier to cope with unexpected vendor delays."
)
@api.onchange('use_po_lead')
def _onchange_use_po_lead(self):
if not self.use_po_lead:
self.po_lead = 0.0
def set_values(self):
super(ResConfigSettings, self).set_values()
self.po_lock = 'lock' if self.lock_confirmed_po else 'edit'
self.po_double_validation = 'two_step' if self.po_order_approval else 'one_step'
class FloatModel(models.Model):
_name = model('float')
_description = 'Tests: Base Import Model Float'
value = fields.Float()
value2 = fields.Monetary()
currency_id = fields.Many2one('res.currency')
class MonetaryCustom(models.Model):
_name = 'test_new_api.monetary_custom'
_description = 'Monetary Related Custom'
monetary_id = fields.Many2one('test_new_api.monetary_base')
x_currency_id = fields.Many2one('res.currency',
related='monetary_id.base_currency_id')
x_amount = fields.Monetary(related='monetary_id.amount')
class SaleOrder(models.Model):
_inherit = "sale.order"
margin = fields.Monetary(compute='_product_margin', help="It gives profitability by calculating the difference between the Unit Price and the cost.", currency_field='currency_id', store=True)
@api.depends('order_line.margin')
def _product_margin(self):
for order in self:
order.margin = sum(order.order_line.filtered(lambda r: r.state != 'cancel').mapped('margin'))
class ComplexModel(models.Model):
_name = model('complex')
_description = 'Tests: Base Import Model Complex'
f = fields.Float()
m = fields.Monetary()
c = fields.Char()
currency_id = fields.Many2one('res.currency')
d = fields.Date()
dt = fields.Datetime()
class ResPartner(models.Model):
"""User inherits partner, so we are implicitly adding these fields to User
This essentially reproduces the (sad) situation introduced by account.
"""
_name = 'res.partner'
_inherit = 'res.partner'
currency_id = fields.Many2one('res.currency',
compute='_get_company_currency',
readonly=True)
monetary = fields.Monetary(
) # implicitly depends on currency_id as currency_field
def _get_company_currency(self):
for partner in self:
partner.currency_id = partner.sudo().company_id.currency_id
class MixedModel(models.Model):
_name = 'test_new_api.mixed'
_description = 'Test New API Mixed'
number = fields.Float(digits=(10, 2), default=3.14)
number2 = fields.Float(digits='New API Precision')
date = fields.Date()
moment = fields.Datetime()
now = fields.Datetime(compute='_compute_now')
lang = fields.Selection(string='Language', selection='_get_lang')
reference = fields.Reference(string='Related Document',
selection='_reference_models')
comment1 = fields.Html(sanitize=False)
comment2 = fields.Html(sanitize_attributes=True, strip_classes=False)
comment3 = fields.Html(sanitize_attributes=True, strip_classes=True)
comment4 = fields.Html(sanitize_attributes=True, strip_style=True)
currency_id = fields.Many2one(
'res.currency', default=lambda self: self.env.ref('base.EUR'))
amount = fields.Monetary()
def _compute_now(self):
# this is a non-stored computed field without dependencies
for message in self:
message.now = fields.Datetime.now()
@api.model
def _get_lang(self):
return self.env['res.lang'].get_installed()
@api.model
def _reference_models(self):
models = self.env['ir.model'].sudo().search([('state', '!=', 'manual')
])
return [(model.model, model.name) for model in models
if not model.model.startswith('ir.')]
class Contract(models.Model):
_name = 'hr.contract'
_description = 'Contract'
_inherit = ['mail.thread', 'mail.activity.mixin']
name = fields.Char('Contract Reference', required=True)
active = fields.Boolean(default=True)
employee_id = fields.Many2one(
'hr.employee',
string='Employee',
tracking=True,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
department_id = fields.Many2one(
'hr.department',
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
string="Department")
job_id = fields.Many2one(
'hr.job',
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
string='Job Position')
date_start = fields.Date('Start Date',
required=True,
default=fields.Date.today,
help="Start date of the contract.")
date_end = fields.Date(
'End Date',
help="End date of the contract (if it's a fixed-term contract).")
trial_date_end = fields.Date(
'End of Trial Period',
help="End date of the trial period (if there is one).")
resource_calendar_id = fields.Many2one(
'resource.calendar',
'Working Schedule',
default=lambda self: self.env.company.resource_calendar_id.id,
copy=False,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
wage = fields.Monetary('Wage',
required=True,
tracking=True,
help="Employee's monthly gross wage.")
advantages = fields.Text('Advantages')
notes = fields.Text('Notes')
state = fields.Selection([('draft', 'New'), ('open', 'Running'),
('close', 'Expired'), ('cancel', 'Cancelled')],
string='Status',
group_expand='_expand_states',
copy=False,
tracking=True,
help='Status of the contract',
default='draft')
company_id = fields.Many2one('res.company',
default=lambda self: self.env.company,
required=True)
"""
kanban_state:
* draft + green = "Incoming" state (will be set as Open once the contract has started)
* open + red = "Pending" state (will be set as Closed once the contract has ended)
* red = Shows a warning on the employees kanban view
"""
kanban_state = fields.Selection([('normal', 'Grey'), ('done', 'Green'),
('blocked', 'Red')],
string='Kanban State',
default='normal',
tracking=True,
copy=False)
currency_id = fields.Many2one(string="Currency",
related='company_id.currency_id',
readonly=True)
permit_no = fields.Char('Work Permit No',
related="employee_id.permit_no",
readonly=False)
visa_no = fields.Char('Visa No',
related="employee_id.visa_no",
readonly=False)
visa_expire = fields.Date('Visa Expire Date',
related="employee_id.visa_expire",
readonly=False)
hr_responsible_id = fields.Many2one(
'res.users',
'HR Responsible',
tracking=True,
help='Person responsible for validating the employee\'s contracts.')
calendar_mismatch = fields.Boolean(compute='_compute_calendar_mismatch')
@api.depends('employee_id.resource_calendar_id', 'resource_calendar_id')
def _compute_calendar_mismatch(self):
for contract in self:
contract.calendar_mismatch = contract.resource_calendar_id != contract.employee_id.resource_calendar_id
def _expand_states(self, states, domain, order):
return [key for key, val in type(self).state.selection]
@api.onchange('employee_id')
def _onchange_employee_id(self):
if self.employee_id:
self.job_id = self.employee_id.job_id
self.department_id = self.employee_id.department_id
self.resource_calendar_id = self.employee_id.resource_calendar_id
self.company_id = self.employee_id.company_id
@api.constrains('employee_id', 'state', 'kanban_state', 'date_start',
'date_end')
def _check_current_contract(self):
""" Two contracts in state [incoming | open | close] cannot overlap """
for contract in self.filtered(
lambda c: c.state not in ['draft', 'cancel'] or c.state ==
'draft' and c.kanban_state == 'done'):
domain = [
('id', '!=', contract.id),
('employee_id', '=', contract.employee_id.id),
'|',
('state', 'in', ['open', 'close']),
'&',
('state', '=', 'draft'),
('kanban_state', '=', 'done') # replaces incoming
]
if not contract.date_end:
start_domain = []
end_domain = [
'|', ('date_end', '>=', contract.date_start),
('date_end', '=', False)
]
else:
start_domain = [('date_start', '<=', contract.date_end)]
end_domain = [
'|', ('date_end', '>', contract.date_start),
('date_end', '=', False)
]
domain = expression.AND([domain, start_domain, end_domain])
if self.search_count(domain):
raise ValidationError(
_('An employee can only have one contract at the same time. (Excluding Draft and Cancelled contracts)'
))
@api.constrains('date_start', 'date_end')
def _check_dates(self):
if self.filtered(lambda c: c.date_end and c.date_start > c.date_end):
raise ValidationError(
_('Contract start date must be earlier than contract end date.'
))
@api.model
def update_state(self):
self.search([
('state', '=', 'open'),
'|',
'&',
('date_end', '<=',
fields.Date.to_string(date.today() + relativedelta(days=7))),
('date_end', '>=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
'&',
('visa_expire', '<=',
fields.Date.to_string(date.today() + relativedelta(days=60))),
('visa_expire', '>=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
]).write({'kanban_state': 'blocked'})
self.search([
('state', '=', 'open'),
'|',
('date_end', '<=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
('visa_expire', '<=',
fields.Date.to_string(date.today() + relativedelta(days=1))),
]).write({'state': 'close'})
self.search([
('state', '=', 'draft'),
('kanban_state', '=', 'done'),
('date_start', '<=', fields.Date.to_string(date.today())),
]).write({'state': 'open'})
return True
def _assign_open_contract(self):
for contract in self:
contract.employee_id.sudo().write({'contract_id': contract.id})
def write(self, vals):
res = super(Contract, self).write(vals)
if vals.get('state') == 'open':
self._assign_open_contract()
calendar = vals.get('resource_calendar_id')
if calendar and (self.state == 'open' or
(self.state == 'draft'
and self.kanban_state == 'done')):
self.mapped('employee_id').write(
{'resource_calendar_id': calendar})
if 'state' in vals and 'kanban_state' not in vals:
self.write({'kanban_state': 'normal'})
return res
@api.model
def create(self, vals):
contracts = super(Contract, self).create(vals)
if vals.get('state') == 'open':
contracts._assign_open_contract()
open_contracts = contracts.filtered(
lambda c: c.state == 'open' or c.state == 'draft' and c.
kanban_state == 'done')
# sync contract calendar -> calendar employee
for contract in open_contracts.filtered(
lambda c: c.resource_calendar_id):
contract.employee_id.resource_calendar_id = contract.resource_calendar_id
return contracts
def _track_subtype(self, init_values):
self.ensure_one()
if 'state' in init_values and self.state == 'open' and 'kanban_state' in init_values and self.kanban_state == 'blocked':
return self.env.ref('hr_contract.mt_contract_pending')
elif 'state' in init_values and self.state == 'close':
return self.env.ref('hr_contract.mt_contract_close')
return super(Contract, self)._track_subtype(init_values)
class MonetaryBase(models.Model):
_name = 'test_new_api.monetary_base'
_description = 'Monetary Base'
base_currency_id = fields.Many2one('res.currency')
amount = fields.Monetary(currency_field='base_currency_id')
class TaxAdjustments(models.TransientModel):
_name = 'tax.adjustments.wizard'
_description = 'Tax Adjustments Wizard'
def _get_default_journal(self):
return self.env['account.journal'].search([('type', '=', 'general')],
limit=1).id
reason = fields.Char(string='Justification', required=True)
journal_id = fields.Many2one('account.journal',
string='Journal',
required=True,
default=_get_default_journal,
domain=[('type', '=', 'general')])
date = fields.Date(required=True, default=fields.Date.context_today)
debit_account_id = fields.Many2one('account.account',
string='Debit account',
required=True,
domain=[('deprecated', '=', False)])
credit_account_id = fields.Many2one('account.account',
string='Credit account',
required=True,
domain=[('deprecated', '=', False)])
amount = fields.Monetary(currency_field='company_currency_id',
required=True)
adjustment_type = fields.Selection(
[('debit', 'Applied on debit journal item'),
('credit', 'Applied on credit journal item')],
string="Adjustment Type",
required=True)
tax_report_line_id = fields.Many2one(
string="Report Line",
comodel_name='account.tax.report.line',
required=True,
help="The report line to make an adjustment for.")
company_currency_id = fields.Many2one(
'res.currency',
readonly=True,
default=lambda x: x.env.company.currency_id)
country_id = fields.Many2one(string="Country",
comodel_name='res.country',
readonly=True,
default=lambda x: x.env.company.country_id)
def create_move(self):
move_line_vals = []
is_debit = self.adjustment_type == 'debit'
sign_multiplier = (self.amount < 0 and -1 or
1) * (self.adjustment_type == 'credit' and -1 or 1)
filter_lambda = (sign_multiplier < 0) and (lambda x: x.tax_negate) or (
lambda x: not x.tax_negate)
adjustment_tag = self.tax_report_line_id.tag_ids.filtered(
filter_lambda)
# Vals for the amls corresponding to the ajustment tag
move_line_vals.append((0, 0, {
'name':
self.reason,
'debit':
is_debit and abs(self.amount) or 0,
'credit':
not is_debit and abs(self.amount) or 0,
'account_id':
is_debit and self.debit_account_id.id or self.credit_account_id.id,
'tag_ids': [(6, False, [adjustment_tag.id])],
}))
# Vals for the counterpart line
move_line_vals.append((0, 0, {
'name':
self.reason,
'debit':
not is_debit and abs(self.amount) or 0,
'credit':
is_debit and abs(self.amount) or 0,
'account_id':
is_debit and self.credit_account_id.id or self.debit_account_id.id,
}))
# Create the move
vals = {
'journal_id': self.journal_id.id,
'date': self.date,
'state': 'draft',
'line_ids': move_line_vals,
}
move = self.env['account.move'].create(vals)
move.post()
# Return an action opening the created move
action = self.env.ref(
self.env.context.get('action', 'account.action_move_line_form'))
result = action.read()[0]
result['views'] = [(False, 'form')]
result['res_id'] = move.id
return result
class AccountMove(models.Model):
_inherit = "account.move"
l10n_latam_amount_untaxed = fields.Monetary(
compute='_compute_l10n_latam_amount_and_taxes')
l10n_latam_tax_ids = fields.One2many(
compute="_compute_l10n_latam_amount_and_taxes",
comodel_name='account.move.line')
l10n_latam_available_document_type_ids = fields.Many2many(
'l10n_latam.document.type',
compute='_compute_l10n_latam_available_document_types')
l10n_latam_document_type_id = fields.Many2one(
'l10n_latam.document.type',
string='Document Type',
copy=False,
readonly=False,
auto_join=True,
index=True,
states={'posted': [('readonly', True)]},
compute='_compute_l10n_latam_document_type',
store=True)
l10n_latam_sequence_id = fields.Many2one(
'ir.sequence', compute='_compute_l10n_latam_sequence')
l10n_latam_document_number = fields.Char(
compute='_compute_l10n_latam_document_number',
inverse='_inverse_l10n_latam_document_number',
string='Document Number',
readonly=True,
states={'draft': [('readonly', False)]})
l10n_latam_use_documents = fields.Boolean(
related='journal_id.l10n_latam_use_documents')
l10n_latam_country_code = fields.Char(
related='company_id.country_id.code',
help=
'Technical field used to hide/show fields regarding the localization')
def _get_sequence_prefix(self):
""" If we use documents we update sequences only from journal """
return super(AccountMove,
self.filtered(lambda x: not x.l10n_latam_use_documents)
)._get_sequence_prefix()
@api.depends('name')
def _compute_l10n_latam_document_number(self):
recs_with_name = self.filtered(lambda x: x.name != '/')
for rec in recs_with_name:
name = rec.name
doc_code_prefix = rec.l10n_latam_document_type_id.doc_code_prefix
if doc_code_prefix and name:
name = name.split(" ", 1)[-1]
rec.l10n_latam_document_number = name
remaining = self - recs_with_name
remaining.l10n_latam_document_number = False
@api.onchange('l10n_latam_document_type_id', 'l10n_latam_document_number')
def _inverse_l10n_latam_document_number(self):
for rec in self.filtered('l10n_latam_document_type_id'):
if not rec.l10n_latam_document_number:
rec.name = '/'
else:
l10n_latam_document_number = rec.l10n_latam_document_type_id._format_document_number(
rec.l10n_latam_document_number)
if rec.l10n_latam_document_number != l10n_latam_document_number:
rec.l10n_latam_document_number = l10n_latam_document_number
rec.name = "%s %s" % (
rec.l10n_latam_document_type_id.doc_code_prefix,
l10n_latam_document_number)
@api.depends('l10n_latam_document_type_id', 'journal_id')
def _compute_l10n_latam_sequence(self):
recs_with_journal_id = self.filtered('journal_id')
for rec in recs_with_journal_id:
rec.l10n_latam_sequence_id = rec._get_document_type_sequence()
remaining = self - recs_with_journal_id
remaining.l10n_latam_sequence_id = False
def _compute_l10n_latam_amount_and_taxes(self):
recs_invoice = self.filtered(lambda x: x.is_invoice())
for invoice in recs_invoice:
tax_lines = invoice.line_ids.filtered('tax_line_id')
included_taxes = invoice.l10n_latam_document_type_id and \
invoice.l10n_latam_document_type_id._filter_taxes_included(tax_lines.mapped('tax_line_id'))
if not included_taxes:
l10n_latam_amount_untaxed = invoice.amount_untaxed
not_included_invoice_taxes = tax_lines
else:
included_invoice_taxes = tax_lines.filtered(
lambda x: x.tax_line_id in included_taxes)
not_included_invoice_taxes = tax_lines - included_invoice_taxes
if invoice.is_inbound():
sign = -1
else:
sign = 1
l10n_latam_amount_untaxed = invoice.amount_untaxed + sign * sum(
included_invoice_taxes.mapped('balance'))
invoice.l10n_latam_amount_untaxed = l10n_latam_amount_untaxed
invoice.l10n_latam_tax_ids = not_included_invoice_taxes
remaining = self - recs_invoice
remaining.l10n_latam_amount_untaxed = False
remaining.l10n_latam_tax_ids = []
def _compute_invoice_sequence_number_next(self):
""" If journal use documents disable the next number header"""
with_latam_document_number = self.filtered('l10n_latam_use_documents')
with_latam_document_number.invoice_sequence_number_next_prefix = False
with_latam_document_number.invoice_sequence_number_next = False
return super(AccountMove, self - with_latam_document_number
)._compute_invoice_sequence_number_next()
def post(self):
for rec in self.filtered(lambda x: x.l10n_latam_use_documents and
(not x.name or x.name == '/')):
if not rec.l10n_latam_sequence_id:
raise UserError(
_('No sequence or document number linked to invoice id %s')
% rec.id)
if rec.type in ('in_receipt', 'out_receipt'):
raise UserError(
_('We do not accept the usage of document types on receipts yet. '
))
rec.l10n_latam_document_number = rec.l10n_latam_sequence_id.next_by_id(
)
return super().post()
@api.constrains('name', 'journal_id', 'state')
def _check_unique_sequence_number(self):
""" Do not apply unique sequence number for vendoer bills and refunds.
Also apply constraint when state change """
vendor = self.filtered(lambda x: x.type in ['in_refund', 'in_invoice'])
try:
return super(AccountMove,
self - vendor)._check_unique_sequence_number()
except ValidationError:
raise ValidationError(
_('Duplicated invoice number detected. You probably added twice the same vendor'
' bill/debit note.'))
@api.constrains('state', 'l10n_latam_document_type_id')
def _check_l10n_latam_documents(self):
validated_invoices = self.filtered(lambda x: x.l10n_latam_use_documents
and x.state in ['open', 'done'])
without_doc_type = validated_invoices.filtered(
lambda x: not x.l10n_latam_document_type_id)
if without_doc_type:
raise ValidationError(
_('The journal require a document type but not document type has been selected on invoices %s.'
% (without_doc_type.ids)))
without_number = validated_invoices.filtered(
lambda x: not x.l10n_latam_document_number and not x.
l10n_latam_sequence_id)
if without_number:
raise ValidationError(
_('Please set the document number on the following invoices %s.'
% (without_number.ids)))
@api.constrains('type', 'l10n_latam_document_type_id')
def _check_invoice_type_document_type(self):
for rec in self.filtered('l10n_latam_document_type_id.internal_type'):
internal_type = rec.l10n_latam_document_type_id.internal_type
invoice_type = rec.type
if internal_type in ['debit_note', 'invoice'] and invoice_type in [
'out_refund', 'in_refund'
]:
raise ValidationError(
_('You can not use a %s document type with a refund invoice'
) % internal_type)
elif internal_type == 'credit_note' and invoice_type in [
'out_invoice', 'in_invoice'
]:
raise ValidationError(
_('You can not use a %s document type with a invoice') %
(internal_type))
def _get_l10n_latam_documents_domain(self):
self.ensure_one()
if self.type in ['out_refund', 'in_refund']:
internal_types = ['credit_note']
else:
internal_types = ['invoice', 'debit_note']
return [('internal_type', 'in', internal_types),
('country_id', '=', self.company_id.country_id.id)]
@api.depends('journal_id', 'partner_id', 'company_id', 'type')
def _compute_l10n_latam_available_document_types(self):
self.l10n_latam_available_document_type_ids = False
for rec in self.filtered(lambda x: x.journal_id and x.
l10n_latam_use_documents and x.partner_id):
rec.l10n_latam_available_document_type_ids = self.env[
'l10n_latam.document.type'].search(
rec._get_l10n_latam_documents_domain())
@api.depends('l10n_latam_available_document_type_ids')
@api.depends_context('internal_type')
def _compute_l10n_latam_document_type(self):
internal_type = self._context.get('internal_type', False)
for rec in self.filtered(lambda x: x.state == 'draft' and x.
l10n_latam_available_document_type_ids):
document_types = rec.l10n_latam_available_document_type_ids._origin
document_types = internal_type and document_types.filtered(
lambda x: x.internal_type == internal_type) or document_types
rec.l10n_latam_document_type_id = document_types and document_types[
0].id
def _compute_invoice_taxes_by_group(self):
report_or_portal_view = 'commit_assetsbundle' in self.env.context or \
not self.env.context.get('params', {}).get('view_type') == 'form'
if not report_or_portal_view:
return super()._compute_invoice_taxes_by_group()
move_with_doc_type = self.filtered('l10n_latam_document_type_id')
for move in move_with_doc_type:
lang_env = move.with_context(lang=move.partner_id.lang).env
tax_lines = move.l10n_latam_tax_ids
res = {}
# There are as many tax line as there are repartition lines
done_taxes = set()
for line in tax_lines:
res.setdefault(line.tax_line_id.tax_group_id, {
'base': 0.0,
'amount': 0.0
})
res[line.tax_line_id.
tax_group_id]['amount'] += line.price_subtotal
tax_key_add_base = tuple(
move._get_tax_key_for_group_add_base(line))
if tax_key_add_base not in done_taxes:
# The base should be added ONCE
res[line.tax_line_id.
tax_group_id]['base'] += line.tax_base_amount
done_taxes.add(tax_key_add_base)
res = sorted(res.items(), key=lambda l: l[0].sequence)
move.amount_by_group = [(
group.name,
amounts['amount'],
amounts['base'],
formatLang(lang_env,
amounts['amount'],
currency_obj=move.currency_id),
formatLang(lang_env,
amounts['base'],
currency_obj=move.currency_id),
len(res),
group.id,
) for group, amounts in res]
super(AccountMove,
self - move_with_doc_type)._compute_invoice_taxes_by_group()
def _get_document_type_sequence(self):
""" Method to be inherited by different localizations. """
self.ensure_one()
return self.env['ir.sequence']
@api.constrains('name', 'partner_id', 'company_id')
def _check_unique_vendor_number(self):
""" The constraint _check_unique_sequence_number is valid for customer bills but not valid for us on vendor
bills because the uniqueness must be per partner and also because we want to validate on entry creation and
not on entry validation """
for rec in self.filtered(lambda x: x.is_purchase_document(
) and x.l10n_latam_use_documents and x.l10n_latam_document_number):
domain = [
('type', '=', rec.type),
# by validating name we validate l10n_latam_document_number and l10n_latam_document_type_id
('name', '=', rec.name),
('company_id', '=', rec.company_id.id),
('id', '!=', rec.id),
('commercial_partner_id', '=', rec.commercial_partner_id.id)
]
if rec.search(domain):
raise ValidationError(
_('Vendor bill number must be unique per vendor and company.'
))
class PurchaseOrder(models.Model):
_name = "purchase.order"
_inherit = ['mail.thread', 'mail.activity.mixin', 'portal.mixin']
_description = "Purchase Order"
_order = 'date_order desc, id desc'
@api.depends('order_line.price_total')
def _amount_all(self):
for order in self:
amount_untaxed = amount_tax = 0.0
for line in order.order_line:
amount_untaxed += line.price_subtotal
amount_tax += line.price_tax
order.update({
'amount_untaxed': order.currency_id.round(amount_untaxed),
'amount_tax': order.currency_id.round(amount_tax),
'amount_total': amount_untaxed + amount_tax,
})
@api.depends('state', 'order_line.qty_invoiced', 'order_line.qty_received', 'order_line.product_qty')
def _get_invoiced(self):
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
for order in self:
if order.state not in ('purchase', 'done'):
order.invoice_status = 'no'
continue
if any(float_compare(line.qty_invoiced, line.product_qty if line.product_id.purchase_method == 'purchase' else line.qty_received, precision_digits=precision) == -1 for line in order.order_line):
order.invoice_status = 'to invoice'
elif all(float_compare(line.qty_invoiced, line.product_qty if line.product_id.purchase_method == 'purchase' else line.qty_received, precision_digits=precision) >= 0 for line in order.order_line) and order.invoice_ids:
order.invoice_status = 'invoiced'
else:
order.invoice_status = 'no'
@api.depends('order_line.invoice_lines.move_id')
def _compute_invoice(self):
for order in self:
invoices = order.mapped('order_line.invoice_lines.move_id')
order.invoice_ids = invoices
order.invoice_count = len(invoices)
READONLY_STATES = {
'purchase': [('readonly', True)],
'done': [('readonly', True)],
'cancel': [('readonly', True)],
}
name = fields.Char('Order Reference', required=True, index=True, copy=False, default='New')
origin = fields.Char('Source Document', copy=False,
help="Reference of the document that generated this purchase order "
"request (e.g. a sales order)")
partner_ref = fields.Char('Vendor Reference', copy=False,
help="Reference of the sales order or bid sent by the vendor. "
"It's used to do the matching when you receive the "
"products as this reference is usually written on the "
"delivery order sent by your vendor.")
date_order = fields.Datetime('Order Date', required=True, states=READONLY_STATES, index=True, copy=False, default=fields.Datetime.now,\
help="Depicts the date where the Quotation should be validated and converted into a purchase order.")
date_approve = fields.Datetime('Confirmation Date', readonly=1, index=True, copy=False)
partner_id = fields.Many2one('res.partner', string='Vendor', required=True, states=READONLY_STATES, change_default=True, tracking=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]", help="You can find a vendor by its Name, TIN, Email or Internal Reference.")
dest_address_id = fields.Many2one('res.partner', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]", string='Drop Ship Address', states=READONLY_STATES,
help="Put an address if you want to deliver directly from the vendor to the customer. "
"Otherwise, keep empty to deliver to your own company.")
currency_id = fields.Many2one('res.currency', 'Currency', required=True, states=READONLY_STATES,
default=lambda self: self.env.company.currency_id.id)
state = fields.Selection([
('draft', 'RFQ'),
('sent', 'RFQ Sent'),
('to approve', 'To Approve'),
('purchase', 'Purchase Order'),
('done', 'Locked'),
('cancel', 'Cancelled')
], string='Status', readonly=True, index=True, copy=False, default='draft', tracking=True)
order_line = fields.One2many('purchase.order.line', 'order_id', string='Order Lines', states={'cancel': [('readonly', True)], 'done': [('readonly', True)]}, copy=True)
notes = fields.Text('Terms and Conditions')
invoice_count = fields.Integer(compute="_compute_invoice", string='Bill Count', copy=False, default=0, store=True)
invoice_ids = fields.Many2many('account.move', compute="_compute_invoice", string='Bills', copy=False, store=True)
invoice_status = fields.Selection([
('no', 'Nothing to Bill'),
('to invoice', 'Waiting Bills'),
('invoiced', 'Fully Billed'),
], string='Billing Status', compute='_get_invoiced', store=True, readonly=True, copy=False, default='no')
# There is no inverse function on purpose since the date may be different on each line
date_planned = fields.Datetime(string='Receipt Date', index=True)
amount_untaxed = fields.Monetary(string='Untaxed Amount', store=True, readonly=True, compute='_amount_all', tracking=True)
amount_tax = fields.Monetary(string='Taxes', store=True, readonly=True, compute='_amount_all')
amount_total = fields.Monetary(string='Total', store=True, readonly=True, compute='_amount_all')
fiscal_position_id = fields.Many2one('account.fiscal.position', string='Fiscal Position', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
payment_term_id = fields.Many2one('account.payment.term', 'Payment Terms', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
incoterm_id = fields.Many2one('account.incoterms', 'Incoterm', states={'done': [('readonly', True)]}, help="International Commercial Terms are a series of predefined commercial terms used in international transactions.")
product_id = fields.Many2one('product.product', related='order_line.product_id', string='Product', readonly=False)
user_id = fields.Many2one(
'res.users', string='Purchase Representative', index=True, tracking=True,
default=lambda self: self.env.user, check_company=True)
company_id = fields.Many2one('res.company', 'Company', required=True, index=True, states=READONLY_STATES, default=lambda self: self.env.company.id)
currency_rate = fields.Float("Currency Rate", compute='_compute_currency_rate', compute_sudo=True, store=True, readonly=True, help='Ratio between the purchase order currency and the company currency')
@api.constrains('company_id', 'order_line')
def _check_order_line_company_id(self):
for order in self:
companies = order.order_line.product_id.company_id
if companies and companies != order.company_id:
bad_products = order.order_line.product_id.filtered(lambda p: p.company_id and p.company_id != order.company_id)
raise ValidationError((_("Your quotation contains products from company %s whereas your quotation belongs to company %s. \n Please change the company of your quotation or remove the products from other companies (%s).") % (', '.join(companies.mapped('display_name')), order.company_id.display_name, ', '.join(bad_products.mapped('display_name')))))
def _compute_access_url(self):
super(PurchaseOrder, self)._compute_access_url()
for order in self:
order.access_url = '/my/purchase/%s' % (order.id)
@api.model
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
args = args or []
domain = []
if name:
domain = ['|', ('name', operator, name), ('partner_ref', operator, name)]
purchase_order_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid)
return models.lazy_name_get(self.browse(purchase_order_ids).with_user(name_get_uid))
@api.depends('date_order', 'currency_id', 'company_id', 'company_id.currency_id')
def _compute_currency_rate(self):
for order in self:
order.currency_rate = self.env['res.currency']._get_conversion_rate(order.company_id.currency_id, order.currency_id, order.company_id, order.date_order)
@api.depends('name', 'partner_ref')
def name_get(self):
result = []
for po in self:
name = po.name
if po.partner_ref:
name += ' (' + po.partner_ref + ')'
if self.env.context.get('show_total_amount') and po.amount_total:
name += ': ' + formatLang(self.env, po.amount_total, currency_obj=po.currency_id)
result.append((po.id, name))
return result
@api.model
def create(self, vals):
if vals.get('name', 'New') == 'New':
seq_date = None
if 'date_order' in vals:
seq_date = fields.Datetime.context_timestamp(self, fields.Datetime.to_datetime(vals['date_order']))
vals['name'] = self.env['ir.sequence'].next_by_code('purchase.order', sequence_date=seq_date) or '/'
return super(PurchaseOrder, self).create(vals)
def write(self, vals):
res = super(PurchaseOrder, self).write(vals)
if vals.get('date_planned'):
self.order_line.filtered(lambda line: not line.display_type).date_planned = vals['date_planned']
return res
def unlink(self):
for order in self:
if not order.state == 'cancel':
raise UserError(_('In order to delete a purchase order, you must cancel it first.'))
return super(PurchaseOrder, self).unlink()
def copy(self, default=None):
new_po = super(PurchaseOrder, self).copy(default=default)
for line in new_po.order_line:
if new_po.date_planned:
line.date_planned = new_po.date_planned
elif line.product_id:
seller = line.product_id._select_seller(
partner_id=line.partner_id, quantity=line.product_qty,
date=line.order_id.date_order and line.order_id.date_order.date(), uom_id=line.product_uom)
line.date_planned = line._get_date_planned(seller)
return new_po
def _track_subtype(self, init_values):
self.ensure_one()
if 'state' in init_values and self.state == 'purchase':
return self.env.ref('purchase.mt_rfq_approved')
elif 'state' in init_values and self.state == 'to approve':
return self.env.ref('purchase.mt_rfq_confirmed')
elif 'state' in init_values and self.state == 'done':
return self.env.ref('purchase.mt_rfq_done')
return super(PurchaseOrder, self)._track_subtype(init_values)
@api.onchange('partner_id', 'company_id')
def onchange_partner_id(self):
# Ensures all properties and fiscal positions
# are taken with the company of the order
# if not defined, force_company doesn't change anything.
self = self.with_context(force_company=self.company_id.id)
if not self.partner_id:
self.fiscal_position_id = False
self.payment_term_id = False
self.currency_id = self.env.company.currency_id.id
else:
self.fiscal_position_id = self.env['account.fiscal.position'].get_fiscal_position(self.partner_id.id)
self.payment_term_id = self.partner_id.property_supplier_payment_term_id.id
self.currency_id = self.partner_id.property_purchase_currency_id.id or self.env.company.currency_id.id
return {}
@api.onchange('fiscal_position_id')
def _compute_tax_id(self):
"""
Trigger the recompute of the taxes if the fiscal position is changed on the PO.
"""
for order in self:
order.order_line._compute_tax_id()
@api.onchange('partner_id')
def onchange_partner_id_warning(self):
if not self.partner_id or not self.env.user.has_group('purchase.group_warning_purchase'):
return
warning = {}
title = False
message = False
partner = self.partner_id
# If partner has no warning, check its company
if partner.purchase_warn == 'no-message' and partner.parent_id:
partner = partner.parent_id
if partner.purchase_warn and partner.purchase_warn != 'no-message':
# Block if partner only has warning but parent company is blocked
if partner.purchase_warn != 'block' and partner.parent_id and partner.parent_id.purchase_warn == 'block':
partner = partner.parent_id
title = _("Warning for %s") % partner.name
message = partner.purchase_warn_msg
warning = {
'title': title,
'message': message
}
if partner.purchase_warn == 'block':
self.update({'partner_id': False})
return {'warning': warning}
return {}
def action_rfq_send(self):
'''
This function opens a window to compose an email, with the edi purchase template message loaded by default
'''
self.ensure_one()
ir_model_data = self.env['ir.model.data']
try:
if self.env.context.get('send_rfq', False):
template_id = ir_model_data.get_object_reference('purchase', 'email_template_edi_purchase')[1]
else:
template_id = ir_model_data.get_object_reference('purchase', 'email_template_edi_purchase_done')[1]
except ValueError:
template_id = False
try:
compose_form_id = ir_model_data.get_object_reference('mail', 'email_compose_message_wizard_form')[1]
except ValueError:
compose_form_id = False
ctx = dict(self.env.context or {})
ctx.update({
'default_model': 'purchase.order',
'active_model': 'purchase.order',
'active_id': self.ids[0],
'default_res_id': self.ids[0],
'default_use_template': bool(template_id),
'default_template_id': template_id,
'default_composition_mode': 'comment',
'custom_layout': "mail.mail_notification_paynow",
'force_email': True,
'mark_rfq_as_sent': True,
})
# In the case of a RFQ or a PO, we want the "View..." button in line with the state of the
# object. Therefore, we pass the model description in the context, in the language in which
# the template is rendered.
lang = self.env.context.get('lang')
if {'default_template_id', 'default_model', 'default_res_id'} <= ctx.keys():
template = self.env['mail.template'].browse(ctx['default_template_id'])
if template and template.lang:
lang = template._render_template(template.lang, ctx['default_model'], ctx['default_res_id'])
self = self.with_context(lang=lang)
if self.state in ['draft', 'sent']:
ctx['model_description'] = _('Request for Quotation')
else:
ctx['model_description'] = _('Purchase Order')
return {
'name': _('Compose Email'),
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_model': 'mail.compose.message',
'views': [(compose_form_id, 'form')],
'view_id': compose_form_id,
'target': 'new',
'context': ctx,
}
@api.returns('mail.message', lambda value: value.id)
def message_post(self, **kwargs):
if self.env.context.get('mark_rfq_as_sent'):
self.filtered(lambda o: o.state == 'draft').write({'state': 'sent'})
return super(PurchaseOrder, self.with_context(mail_post_autofollow=True)).message_post(**kwargs)
def print_quotation(self):
self.write({'state': "sent"})
return self.env.ref('purchase.report_purchase_quotation').report_action(self)
def button_approve(self, force=False):
self.write({'state': 'purchase', 'date_approve': fields.Date.context_today(self)})
self.filtered(lambda p: p.company_id.po_lock == 'lock').write({'state': 'done'})
return {}
def button_draft(self):
self.write({'state': 'draft'})
return {}
def button_confirm(self):
for order in self:
if order.state not in ['draft', 'sent']:
continue
order._add_supplier_to_product()
# Deal with double validation process
if order.company_id.po_double_validation == 'one_step'\
or (order.company_id.po_double_validation == 'two_step'\
and order.amount_total < self.env.company.currency_id._convert(
order.company_id.po_double_validation_amount, order.currency_id, order.company_id, order.date_order or fields.Date.today()))\
or order.user_has_groups('purchase.group_purchase_manager'):
order.button_approve()
else:
order.write({'state': 'to approve'})
return True
def button_cancel(self):
for order in self:
for inv in order.invoice_ids:
if inv and inv.state not in ('cancel', 'draft'):
raise UserError(_("Unable to cancel this purchase order. You must first cancel the related vendor bills."))
self.write({'state': 'cancel'})
def button_unlock(self):
self.write({'state': 'purchase'})
def button_done(self):
self.write({'state': 'done'})
def _add_supplier_to_product(self):
# Add the partner in the supplier list of the product if the supplier is not registered for
# this product. We limit to 10 the number of suppliers for a product to avoid the mess that
# could be caused for some generic products ("Miscellaneous").
for line in self.order_line:
# Do not add a contact as a supplier
partner = self.partner_id if not self.partner_id.parent_id else self.partner_id.parent_id
if line.product_id and partner not in line.product_id.seller_ids.mapped('name') and len(line.product_id.seller_ids) <= 10:
# Convert the price in the right currency.
currency = partner.property_purchase_currency_id or self.env.company.currency_id
price = self.currency_id._convert(line.price_unit, currency, line.company_id, line.date_order or fields.Date.today(), round=False)
# Compute the price for the template's UoM, because the supplier's UoM is related to that UoM.
if line.product_id.product_tmpl_id.uom_po_id != line.product_uom:
default_uom = line.product_id.product_tmpl_id.uom_po_id
price = line.product_uom._compute_price(price, default_uom)
supplierinfo = {
'name': partner.id,
'sequence': max(line.product_id.seller_ids.mapped('sequence')) + 1 if line.product_id.seller_ids else 1,
'min_qty': 0.0,
'price': price,
'currency_id': currency.id,
'delay': 0,
}
# In case the order partner is a contact address, a new supplierinfo is created on
# the parent company. In this case, we keep the product name and code.
seller = line.product_id._select_seller(
partner_id=line.partner_id,
quantity=line.product_qty,
date=line.order_id.date_order and line.order_id.date_order.date(),
uom_id=line.product_uom)
if seller:
supplierinfo['product_name'] = seller.product_name
supplierinfo['product_code'] = seller.product_code
vals = {
'seller_ids': [(0, 0, supplierinfo)],
}
try:
line.product_id.write(vals)
except AccessError: # no write access rights -> just ignore
break
def action_view_invoice(self):
'''
This function returns an action that display existing vendor bills of given purchase order ids.
When only one found, show the vendor bill immediately.
'''
action = self.env.ref('account.action_move_in_invoice_type')
result = action.read()[0]
create_bill = self.env.context.get('create_bill', False)
# override the context to get rid of the default filtering
result['context'] = {
'default_type': 'in_invoice',
'default_company_id': self.company_id.id,
'default_purchase_id': self.id,
}
# choose the view_mode accordingly
if len(self.invoice_ids) > 1 and not create_bill:
result['domain'] = "[('id', 'in', " + str(self.invoice_ids.ids) + ")]"
else:
res = self.env.ref('account.view_move_form', False)
form_view = [(res and res.id or False, 'form')]
if 'views' in result:
result['views'] = form_view + [(state,view) for state,view in action['views'] if view != 'form']
else:
result['views'] = form_view
# Do not set an invoice_id if we want to create a new bill.
if not create_bill:
result['res_id'] = self.invoice_ids.id or False
result['context']['default_origin'] = self.name
result['context']['default_reference'] = self.partner_ref
return result
class AccountClosing(models.Model):
"""
This object holds an interval total and a grand total of the accounts of type receivable for a company,
as well as the last account_move that has been counted in a previous object
It takes its earliest brother to infer from when the computation needs to be done
in order to compute its own data.
"""
_name = 'account.sale.closing'
_order = 'date_closing_stop desc, sequence_number desc'
_description = "Sale Closing"
name = fields.Char(help="Frequency and unique sequence number",
required=True)
company_id = fields.Many2one('res.company',
string='Company',
readonly=True,
required=True)
date_closing_stop = fields.Datetime(
string="Closing Date",
help='Date to which the values are computed',
readonly=True,
required=True)
date_closing_start = fields.Datetime(
string="Starting Date",
help='Date from which the total interval is computed',
readonly=True,
required=True)
frequency = fields.Selection(string='Closing Type',
selection=[('daily', 'Daily'),
('monthly', 'Monthly'),
('annually', 'Annual')],
readonly=True,
required=True)
total_interval = fields.Monetary(
string="Period Total",
help=
'Total in receivable accounts during the interval, excluding overlapping periods',
readonly=True,
required=True)
cumulative_total = fields.Monetary(
string="Cumulative Grand Total",
help='Total in receivable accounts since the beginnig of times',
readonly=True,
required=True)
sequence_number = fields.Integer('Sequence #',
readonly=True,
required=True)
last_order_id = fields.Many2one(
'pos.order',
string='Last Pos Order',
help='Last Pos order included in the grand total',
readonly=True)
last_order_hash = fields.Char(
string='Last Order entry\'s inalteralbility hash', readonly=True)
currency_id = fields.Many2one('res.currency',
string='Currency',
help="The company's currency",
readonly=True,
related='company_id.currency_id',
store=True)
def _query_for_aml(self, company, first_move_sequence_number, date_start):
params = {'company_id': company.id}
query = '''WITH aggregate AS (SELECT m.id AS move_id,
aml.balance AS balance,
aml.id as line_id
FROM account_move_line aml
JOIN account_journal j ON aml.journal_id = j.id
JOIN account_account acc ON acc.id = aml.account_id
JOIN account_account_type t ON (t.id = acc.user_type_id AND t.type = 'receivable')
JOIN account_move m ON m.id = aml.move_id
WHERE j.type = 'sale'
AND aml.company_id = %(company_id)s
AND m.state = 'posted' '''
if first_move_sequence_number is not False and first_move_sequence_number is not None:
params['first_move_sequence_number'] = first_move_sequence_number
query += '''AND m.secure_sequence_number > %(first_move_sequence_number)s'''
elif date_start:
#the first time we compute the closing, we consider only from the installation of the module
params['date_start'] = date_start
query += '''AND m.date >= %(date_start)s'''
query += " ORDER BY m.secure_sequence_number DESC) "
query += '''SELECT array_agg(move_id) AS move_ids,
array_agg(line_id) AS line_ids,
sum(balance) AS balance
FROM aggregate'''
self.env.cr.execute(query, params)
return self.env.cr.dictfetchall()[0]
def _compute_amounts(self, frequency, company):
"""
Method used to compute all the business data of the new object.
It will search for previous closings of the same frequency to infer the move from which
account move lines should be fetched.
@param {string} frequency: a valid value of the selection field on the object (daily, monthly, annually)
frequencies are literal (daily means 24 hours and so on)
@param {recordset} company: the company for which the closing is done
@return {dict} containing {field: value} for each business field of the object
"""
interval_dates = self._interval_dates(frequency, company)
previous_closing = self.search([('frequency', '=', frequency),
('company_id', '=', company.id)],
limit=1,
order='sequence_number desc')
first_order = self.env['pos.order']
date_start = interval_dates['interval_from']
cumulative_total = 0
if previous_closing:
first_order = previous_closing.last_order_id
date_start = previous_closing.create_date
cumulative_total += previous_closing.cumulative_total
domain = [('company_id', '=', company.id),
('state', 'in', ('paid', 'done', 'invoiced'))]
if first_order.l10n_fr_secure_sequence_number is not False and first_order.l10n_fr_secure_sequence_number is not None:
domain = AND([
domain,
[('l10n_fr_secure_sequence_number', '>',
first_order.l10n_fr_secure_sequence_number)]
])
elif date_start:
#the first time we compute the closing, we consider only from the installation of the module
domain = AND([domain, [('date_order', '>=', date_start)]])
orders = self.env['pos.order'].search(domain, order='date_order desc')
total_interval = sum(orders.mapped('amount_total'))
cumulative_total += total_interval
# We keep the reference to avoid gaps (like daily object during the weekend)
last_order = first_order
if orders:
last_order = orders[0]
return {
'total_interval':
total_interval,
'cumulative_total':
cumulative_total,
'last_order_id':
last_order.id,
'last_order_hash':
last_order.l10n_fr_secure_sequence_number,
'date_closing_stop':
interval_dates['date_stop'],
'date_closing_start':
date_start,
'name':
interval_dates['name_interval'] + ' - ' +
interval_dates['date_stop'][:10]
}
def _interval_dates(self, frequency, company):
"""
Method used to compute the theoretical date from which account move lines should be fetched
@param {string} frequency: a valid value of the selection field on the object (daily, monthly, annually)
frequencies are literal (daily means 24 hours and so on)
@param {recordset} company: the company for which the closing is done
@return {dict} the theoretical date from which account move lines are fetched.
date_stop date to which the move lines are fetched, always now()
the dates are in their COffice Database string representation
"""
date_stop = datetime.utcnow()
interval_from = None
name_interval = ''
if frequency == 'daily':
interval_from = date_stop - timedelta(days=1)
name_interval = _('Daily Closing')
elif frequency == 'monthly':
month_target = date_stop.month > 1 and date_stop.month - 1 or 12
year_target = month_target < 12 and date_stop.year or date_stop.year - 1
interval_from = date_stop.replace(year=year_target,
month=month_target)
name_interval = _('Monthly Closing')
elif frequency == 'annually':
year_target = date_stop.year - 1
interval_from = date_stop.replace(year=year_target)
name_interval = _('Annual Closing')
return {
'interval_from': FieldDateTime.to_string(interval_from),
'date_stop': FieldDateTime.to_string(date_stop),
'name_interval': name_interval
}
def write(self, vals):
raise UserError(
_('Sale Closings are not meant to be written or deleted under any circumstances.'
))
def unlink(self):
raise UserError(
_('Sale Closings are not meant to be written or deleted under any circumstances.'
))
@api.model
def _automated_closing(self, frequency='daily'):
"""To be executed by the CRON to create an object of the given frequency for each company that needs it
@param {string} frequency: a valid value of the selection field on the object (daily, monthly, annually)
frequencies are literal (daily means 24 hours and so on)
@return {recordset} all the objects created for the given frequency
"""
res_company = self.env['res.company'].search([])
account_closings = self.env['account.sale.closing']
for company in res_company.filtered(
lambda c: c._is_accounting_unalterable()):
new_sequence_number = company.l10n_fr_closing_sequence_id.next_by_id(
)
values = self._compute_amounts(frequency, company)
values['frequency'] = frequency
values['company_id'] = company.id
values['sequence_number'] = new_sequence_number
account_closings |= account_closings.create(values)
return account_closings
class account_payment(models.Model):
_name = "account.payment"
_inherit = ['mail.thread', 'mail.activity.mixin']
_description = "Payments"
_order = "payment_date desc, name desc"
name = fields.Char(readonly=True, copy=False) # The name is attributed upon post()
payment_reference = fields.Char(copy=False, readonly=True, help="Reference of the document used to issue this payment. Eg. check number, file name, etc.")
move_name = fields.Char(string='Journal Entry Name', readonly=True,
default=False, copy=False,
help="Technical field holding the number given to the journal entry, automatically set when the statement line is reconciled then stored to set the same number again if the line is cancelled, set to draft and re-processed again.")
# Money flows from the journal_id's default_debit_account_id or default_credit_account_id to the destination_account_id
destination_account_id = fields.Many2one('account.account', compute='_compute_destination_account_id', readonly=True)
# For money transfer, money goes from journal_id to a transfer account, then from the transfer account to destination_journal_id
destination_journal_id = fields.Many2one('account.journal', string='Transfer To', domain="[('type', 'in', ('bank', 'cash')), ('company_id', '=', company_id)]", readonly=True, states={'draft': [('readonly', False)]})
invoice_ids = fields.Many2many('account.move', 'account_invoice_payment_rel', 'payment_id', 'invoice_id', string="Invoices", copy=False, readonly=True,
help="""Technical field containing the invoice for which the payment has been generated.
This does not especially correspond to the invoices reconciled with the payment,
as it can have been generated first, and reconciled later""")
reconciled_invoice_ids = fields.Many2many('account.move', string='Reconciled Invoices', compute='_compute_reconciled_invoice_ids', help="Invoices whose journal items have been reconciled with these payments.")
has_invoices = fields.Boolean(compute="_compute_reconciled_invoice_ids", help="Technical field used for usability purposes")
reconciled_invoices_count = fields.Integer(compute="_compute_reconciled_invoice_ids")
move_line_ids = fields.One2many('account.move.line', 'payment_id', readonly=True, copy=False, ondelete='restrict')
move_reconciled = fields.Boolean(compute="_get_move_reconciled", readonly=True)
state = fields.Selection([('draft', 'Draft'), ('posted', 'Validated'), ('sent', 'Sent'), ('reconciled', 'Reconciled'), ('cancelled', 'Cancelled')], readonly=True, default='draft', copy=False, string="Status")
payment_type = fields.Selection([('outbound', 'Send Money'), ('inbound', 'Receive Money'), ('transfer', 'Internal Transfer')], string='Payment Type', required=True, readonly=True, states={'draft': [('readonly', False)]})
payment_method_id = fields.Many2one('account.payment.method', string='Payment Method', required=True, readonly=True, states={'draft': [('readonly', False)]},
help="Manual: Get paid by cash, check or any other method outside of Coffice.\n"\
"Electronic: Get paid automatically through a payment acquirer by requesting a transaction on a card saved by the customer when buying or subscribing online (payment token).\n"\
"Check: Pay bill by check and print it from Coffice.\n"\
"Batch Deposit: Encase several customer checks at once by generating a batch deposit to submit to your bank. When encoding the bank statement in Coffice, you are suggested to reconcile the transaction with the batch deposit.To enable batch deposit, module account_batch_payment must be installed.\n"\
"SEPA Credit Transfer: Pay bill from a SEPA Credit Transfer file you submit to your bank. To enable sepa credit transfer, module account_sepa must be installed ")
payment_method_code = fields.Char(related='payment_method_id.code',
help="Technical field used to adapt the interface to the payment type selected.", readonly=True)
partner_type = fields.Selection([('customer', 'Customer'), ('supplier', 'Vendor')], tracking=True, readonly=True, states={'draft': [('readonly', False)]})
partner_id = fields.Many2one('res.partner', string='Partner', tracking=True, readonly=True, states={'draft': [('readonly', False)]}, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
amount = fields.Monetary(string='Amount', required=True, readonly=True, states={'draft': [('readonly', False)]}, tracking=True)
currency_id = fields.Many2one('res.currency', string='Currency', required=True, readonly=True, states={'draft': [('readonly', False)]}, default=lambda self: self.env.company.currency_id)
payment_date = fields.Date(string='Date', default=fields.Date.context_today, required=True, readonly=True, states={'draft': [('readonly', False)]}, copy=False, tracking=True)
communication = fields.Char(string='Memo', readonly=True, states={'draft': [('readonly', False)]})
journal_id = fields.Many2one('account.journal', string='Journal', required=True, readonly=True, states={'draft': [('readonly', False)]}, tracking=True, domain="[('type', 'in', ('bank', 'cash')), ('company_id', '=', company_id)]")
company_id = fields.Many2one('res.company', related='journal_id.company_id', string='Company', readonly=True)
hide_payment_method = fields.Boolean(compute='_compute_hide_payment_method',
help="Technical field used to hide the payment method if the "
"selected journal has only one available which is 'manual'")
payment_difference = fields.Monetary(compute='_compute_payment_difference', readonly=True)
payment_difference_handling = fields.Selection([('open', 'Keep open'), ('reconcile', 'Mark invoice as fully paid')], default='open', string="Payment Difference Handling", copy=False)
writeoff_account_id = fields.Many2one('account.account', string="Difference Account", domain="[('deprecated', '=', False), ('company_id', '=', company_id)]", copy=False)
writeoff_label = fields.Char(
string='Journal Item Label',
help='Change label of the counterpart that will hold the payment difference',
default='Write-Off')
partner_bank_account_id = fields.Many2one('res.partner.bank', string="Recipient Bank Account", readonly=True, states={'draft': [('readonly', False)]}, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
show_partner_bank_account = fields.Boolean(compute='_compute_show_partner_bank', help='Technical field used to know whether the field `partner_bank_account_id` needs to be displayed or not in the payments form views')
require_partner_bank_account = fields.Boolean(compute='_compute_show_partner_bank', help='Technical field used to know whether the field `partner_bank_account_id` needs to be required or not in the payments form views')
@api.model
def default_get(self, default_fields):
rec = super(account_payment, self).default_get(default_fields)
active_ids = self._context.get('active_ids') or self._context.get('active_id')
active_model = self._context.get('active_model')
# Check for selected invoices ids
if not active_ids or active_model != 'account.move':
return rec
invoices = self.env['account.move'].browse(active_ids).filtered(lambda move: move.is_invoice(include_receipts=True))
# Check all invoices are open
if not invoices or any(invoice.state != 'posted' for invoice in invoices):
raise UserError(_("You can only register payments for open invoices"))
# Check if, in batch payments, there are not negative invoices and positive invoices
dtype = invoices[0].type
for inv in invoices[1:]:
if inv.type != dtype:
if ((dtype == 'in_refund' and inv.type == 'in_invoice') or
(dtype == 'in_invoice' and inv.type == 'in_refund')):
raise UserError(_("You cannot register payments for vendor bills and supplier refunds at the same time."))
if ((dtype == 'out_refund' and inv.type == 'out_invoice') or
(dtype == 'out_invoice' and inv.type == 'out_refund')):
raise UserError(_("You cannot register payments for customer invoices and credit notes at the same time."))
amount = self._compute_payment_amount(invoices, invoices[0].currency_id, invoices[0].journal_id, rec.get('payment_date') or fields.Date.today())
rec.update({
'currency_id': invoices[0].currency_id.id,
'amount': abs(amount),
'payment_type': 'inbound' if amount > 0 else 'outbound',
'partner_id': invoices[0].commercial_partner_id.id,
'partner_type': MAP_INVOICE_TYPE_PARTNER_TYPE[invoices[0].type],
'communication': invoices[0].invoice_payment_ref or invoices[0].ref or invoices[0].name,
'invoice_ids': [(6, 0, invoices.ids)],
})
return rec
@api.constrains('amount')
def _check_amount(self):
for payment in self:
if payment.amount < 0:
raise ValidationError(_('The payment amount cannot be negative.'))
@api.model
def _get_method_codes_using_bank_account(self):
return []
@api.model
def _get_method_codes_needing_bank_account(self):
return []
@api.depends('payment_method_code')
def _compute_show_partner_bank(self):
""" Computes if the destination bank account must be displayed in the payment form view. By default, it
won't be displayed but some modules might change that, depending on the payment type."""
for payment in self:
payment.show_partner_bank_account = payment.payment_method_code in self._get_method_codes_using_bank_account()
payment.require_partner_bank_account = payment.payment_method_code in self._get_method_codes_needing_bank_account()
@api.depends('payment_type', 'journal_id')
def _compute_hide_payment_method(self):
for payment in self:
if not payment.journal_id or payment.journal_id.type not in ['bank', 'cash']:
payment.hide_payment_method = True
continue
journal_payment_methods = payment.payment_type == 'inbound'\
and payment.journal_id.inbound_payment_method_ids\
or payment.journal_id.outbound_payment_method_ids
payment.hide_payment_method = len(journal_payment_methods) == 1 and journal_payment_methods[0].code == 'manual'
@api.depends('invoice_ids', 'amount', 'payment_date', 'currency_id', 'payment_type')
def _compute_payment_difference(self):
draft_payments = self.filtered(lambda p: p.invoice_ids and p.state == 'draft')
for pay in draft_payments:
payment_amount = -pay.amount if pay.payment_type == 'outbound' else pay.amount
pay.payment_difference = pay._compute_payment_amount(pay.invoice_ids, pay.currency_id, pay.journal_id, pay.payment_date) - payment_amount
(self - draft_payments).payment_difference = 0
@api.onchange('journal_id')
def _onchange_journal(self):
if self.journal_id:
if self.journal_id.currency_id:
self.currency_id = self.journal_id.currency_id
# Set default payment method (we consider the first to be the default one)
payment_methods = self.payment_type == 'inbound' and self.journal_id.inbound_payment_method_ids or self.journal_id.outbound_payment_method_ids
payment_methods_list = payment_methods.ids
default_payment_method_id = self.env.context.get('default_payment_method_id')
if default_payment_method_id:
# Ensure the domain will accept the provided default value
payment_methods_list.append(default_payment_method_id)
else:
self.payment_method_id = payment_methods and payment_methods[0] or False
# Set payment method domain (restrict to methods enabled for the journal and to selected payment type)
payment_type = self.payment_type in ('outbound', 'transfer') and 'outbound' or 'inbound'
domain = {'payment_method_id': [('payment_type', '=', payment_type), ('id', 'in', payment_methods_list)]}
if self.env.context.get('active_model') == 'account.move':
active_ids = self._context.get('active_ids')
invoices = self.env['account.move'].browse(active_ids)
self.amount = abs(self._compute_payment_amount(invoices, self.currency_id, self.journal_id, self.payment_date))
return {'domain': domain}
return {}
@api.onchange('partner_id')
def _onchange_partner_id(self):
if self.invoice_ids and self.invoice_ids[0].invoice_partner_bank_id:
self.partner_bank_account_id = self.invoice_ids[0].invoice_partner_bank_id
elif self.partner_id != self.partner_bank_account_id.partner_id:
# This condition ensures we use the default value provided into
# context for partner_bank_account_id properly when provided with a
# default partner_id. Without it, the onchange recomputes the bank account
# uselessly and might assign a different value to it.
if self.partner_id and len(self.partner_id.bank_ids) > 0:
self.partner_bank_account_id = self.partner_id.bank_ids[0]
elif self.partner_id and len(self.partner_id.commercial_partner_id.bank_ids) > 0:
self.partner_bank_account_id = self.partner_id.commercial_partner_id.bank_ids[0]
else:
self.partner_bank_account_id = False
return {'domain': {'partner_bank_account_id': [('partner_id', 'in', [self.partner_id.id, self.partner_id.commercial_partner_id.id])]}}
@api.onchange('payment_type')
def _onchange_payment_type(self):
if not self.invoice_ids and not self.partner_type:
# Set default partner type for the payment type
if self.payment_type == 'inbound':
self.partner_type = 'customer'
elif self.payment_type == 'outbound':
self.partner_type = 'supplier'
elif self.payment_type not in ('inbound', 'outbound'):
self.partner_type = False
# Set payment method domain
res = self._onchange_journal()
if not res.get('domain', {}):
res['domain'] = {}
jrnl_filters = self._compute_journal_domain_and_types()
journal_types = jrnl_filters['journal_types']
journal_types.update(['bank', 'cash'])
res['domain']['journal_id'] = jrnl_filters['domain'] + [('type', 'in', list(journal_types))]
return res
def _compute_journal_domain_and_types(self):
journal_type = ['bank', 'cash']
domain = []
if self.invoice_ids:
domain.append(('company_id', '=', self.invoice_ids[0].company_id.id))
if self.currency_id.is_zero(self.amount) and self.has_invoices:
# In case of payment with 0 amount, allow to select a journal of type 'general' like
# 'Miscellaneous Operations' and set this journal by default.
journal_type = ['general']
self.payment_difference_handling = 'reconcile'
else:
if self.payment_type == 'inbound':
domain.append(('at_least_one_inbound', '=', True))
else:
domain.append(('at_least_one_outbound', '=', True))
return {'domain': domain, 'journal_types': set(journal_type)}
@api.onchange('amount', 'currency_id')
def _onchange_amount(self):
jrnl_filters = self._compute_journal_domain_and_types()
journal_types = jrnl_filters['journal_types']
domain_on_types = [('type', 'in', list(journal_types))]
if self.invoice_ids:
domain_on_types.append(('company_id', '=', self.invoice_ids[0].company_id.id))
if self.journal_id.type not in journal_types or (self.invoice_ids and self.journal_id.company_id != self.invoice_ids[0].company_id):
self.journal_id = self.env['account.journal'].search(domain_on_types, limit=1)
return {'domain': {'journal_id': jrnl_filters['domain'] + domain_on_types}}
@api.onchange('currency_id')
def _onchange_currency(self):
self.amount = abs(self._compute_payment_amount(self.invoice_ids, self.currency_id, self.journal_id, self.payment_date))
if self.journal_id: # TODO: only return if currency differ?
return
# Set by default the first liquidity journal having this currency if exists.
domain = [('type', 'in', ('bank', 'cash')), ('currency_id', '=', self.currency_id.id)]
if self.invoice_ids:
domain.append(('company_id', '=', self.invoice_ids[0].company_id.id))
journal = self.env['account.journal'].search(domain, limit=1)
if journal:
return {'value': {'journal_id': journal.id}}
@api.model
def _compute_payment_amount(self, invoices, currency, journal, date):
'''Compute the total amount for the payment wizard.
:param invoices: Invoices on which compute the total as an account.invoice recordset.
:param currency: The payment's currency as a res.currency record.
:param journal: The payment's journal as an account.journal record.
:param date: The payment's date as a datetime.date object.
:return: The total amount to pay the invoices.
'''
company = journal.company_id
currency = currency or journal.currency_id or company.currency_id
date = date or fields.Date.today()
if not invoices:
return 0.0
self.env['account.move'].flush(['type', 'currency_id'])
self.env['account.move.line'].flush(['amount_residual', 'amount_residual_currency', 'move_id', 'account_id'])
self.env['account.account'].flush(['user_type_id'])
self.env['account.account.type'].flush(['type'])
self._cr.execute('''
SELECT
move.type AS type,
move.currency_id AS currency_id,
SUM(line.amount_residual) AS amount_residual,
SUM(line.amount_residual_currency) AS residual_currency
FROM account_move move
LEFT JOIN account_move_line line ON line.move_id = move.id
LEFT JOIN account_account account ON account.id = line.account_id
LEFT JOIN account_account_type account_type ON account_type.id = account.user_type_id
WHERE move.id IN %s
AND account_type.type IN ('receivable', 'payable')
GROUP BY move.id, move.type
''', [tuple(invoices.ids)])
query_res = self._cr.dictfetchall()
total = 0.0
for res in query_res:
move_currency = self.env['res.currency'].browse(res['currency_id'])
if move_currency == currency and move_currency != company.currency_id:
total += res['residual_currency']
else:
total += company.currency_id._convert(res['amount_residual'], currency, company, date)
return total
def name_get(self):
return [(payment.id, payment.name or _('Draft Payment')) for payment in self]
@api.model
def _get_move_name_transfer_separator(self):
return '§§'
@api.depends('move_line_ids.reconciled')
def _get_move_reconciled(self):
for payment in self:
rec = True
for aml in payment.move_line_ids.filtered(lambda x: x.account_id.reconcile):
if not aml.reconciled:
rec = False
break
payment.move_reconciled = rec
def open_payment_matching_screen(self):
# Open reconciliation view for customers/suppliers
move_line_id = False
for move_line in self.move_line_ids:
if move_line.account_id.reconcile:
move_line_id = move_line.id
break
if not self.partner_id:
raise UserError(_("Payments without a customer can't be matched"))
action_context = {'company_ids': [self.company_id.id], 'partner_ids': [self.partner_id.commercial_partner_id.id]}
if self.partner_type == 'customer':
action_context.update({'mode': 'customers'})
elif self.partner_type == 'supplier':
action_context.update({'mode': 'suppliers'})
if move_line_id:
action_context.update({'move_line_id': move_line_id})
return {
'type': 'ir.actions.client',
'tag': 'manual_reconciliation_view',
'context': action_context,
}
@api.depends('invoice_ids', 'payment_type', 'partner_type', 'partner_id')
def _compute_destination_account_id(self):
for payment in self:
if payment.invoice_ids:
payment.destination_account_id = payment.invoice_ids[0].mapped(
'line_ids.account_id').filtered(
lambda account: account.user_type_id.type in ('receivable', 'payable'))[0]
elif payment.payment_type == 'transfer':
if not payment.company_id.transfer_account_id.id:
raise UserError(_('There is no Transfer Account defined in the accounting settings. Please define one to be able to confirm this transfer.'))
payment.destination_account_id = payment.company_id.transfer_account_id.id
elif payment.partner_id:
if payment.partner_type == 'customer':
payment.destination_account_id = payment.partner_id.property_account_receivable_id.id
else:
payment.destination_account_id = payment.partner_id.property_account_payable_id.id
elif payment.partner_type == 'customer':
default_account = self.env['ir.property'].get('property_account_receivable_id', 'res.partner')
payment.destination_account_id = default_account.id
elif payment.partner_type == 'supplier':
default_account = self.env['ir.property'].get('property_account_payable_id', 'res.partner')
payment.destination_account_id = default_account.id
@api.depends('move_line_ids.matched_debit_ids', 'move_line_ids.matched_credit_ids')
def _compute_reconciled_invoice_ids(self):
for record in self:
reconciled_moves = record.move_line_ids.mapped('matched_debit_ids.debit_move_id.move_id')\
+ record.move_line_ids.mapped('matched_credit_ids.credit_move_id.move_id')
record.reconciled_invoice_ids = reconciled_moves.filtered(lambda move: move.is_invoice())
record.has_invoices = bool(record.reconciled_invoice_ids)
record.reconciled_invoices_count = len(record.reconciled_invoice_ids)
def action_register_payment(self):
active_ids = self.env.context.get('active_ids')
if not active_ids:
return ''
return {
'name': _('Register Payment'),
'res_model': len(active_ids) == 1 and 'account.payment' or 'account.payment.register',
'view_mode': 'form',
'view_id': len(active_ids) != 1 and self.env.ref('account.view_account_payment_form_multi').id or self.env.ref('account.view_account_payment_invoice_form').id,
'context': self.env.context,
'target': 'new',
'type': 'ir.actions.act_window',
}
def button_journal_entries(self):
return {
'name': _('Journal Items'),
'view_mode': 'tree,form',
'res_model': 'account.move.line',
'view_id': False,
'type': 'ir.actions.act_window',
'domain': [('payment_id', 'in', self.ids)],
}
def button_invoices(self):
return {
'name': _('Paid Invoices'),
'view_mode': 'tree,form',
'res_model': 'account.move',
'view_id': False,
'views': [(self.env.ref('account.view_move_tree').id, 'tree'), (self.env.ref('account.view_move_form').id, 'form')],
'type': 'ir.actions.act_window',
'domain': [('id', 'in', [x.id for x in self.reconciled_invoice_ids])],
'context': {'create': False},
}
def unreconcile(self):
""" Set back the payments in 'posted' or 'sent' state, without deleting the journal entries.
Called when cancelling a bank statement line linked to a pre-registered payment.
"""
for payment in self:
if payment.payment_reference:
payment.write({'state': 'sent'})
else:
payment.write({'state': 'posted'})
def cancel(self):
self.write({'state': 'cancelled'})
def unlink(self):
if any(bool(rec.move_line_ids) for rec in self):
raise UserError(_("You cannot delete a payment that is already posted."))
if any(rec.move_name for rec in self):
raise UserError(_('It is not allowed to delete a payment that already created a journal entry since it would create a gap in the numbering. You should create the journal entry again and cancel it thanks to a regular revert.'))
return super(account_payment, self).unlink()
def _prepare_payment_moves(self):
''' Prepare the creation of journal entries (account.move) by creating a list of python dictionary to be passed
to the 'create' method.
Example 1: outbound with write-off:
Account | Debit | Credit
---------------------------------------------------------
BANK | 900.0 |
RECEIVABLE | | 1000.0
WRITE-OFF ACCOUNT | 100.0 |
Example 2: internal transfer from BANK to CASH:
Account | Debit | Credit
---------------------------------------------------------
BANK | | 1000.0
TRANSFER | 1000.0 |
CASH | 1000.0 |
TRANSFER | | 1000.0
:return: A list of Python dictionary to be passed to env['account.move'].create.
'''
all_move_vals = []
for payment in self:
company_currency = payment.company_id.currency_id
move_names = payment.move_name.split(payment._get_move_name_transfer_separator()) if payment.move_name else None
# Compute amounts.
write_off_amount = payment.payment_difference_handling == 'reconcile' and -payment.payment_difference or 0.0
if payment.payment_type in ('outbound', 'transfer'):
counterpart_amount = payment.amount
liquidity_line_account = payment.journal_id.default_debit_account_id
else:
counterpart_amount = -payment.amount
liquidity_line_account = payment.journal_id.default_credit_account_id
# Manage currency.
if payment.currency_id == company_currency:
# Single-currency.
balance = counterpart_amount
write_off_balance = write_off_amount
counterpart_amount = write_off_amount = 0.0
currency_id = False
else:
# Multi-currencies.
balance = payment.currency_id._convert(counterpart_amount, company_currency, payment.company_id, payment.payment_date)
write_off_balance = payment.currency_id._convert(write_off_amount, company_currency, payment.company_id, payment.payment_date)
currency_id = payment.currency_id.id
# Manage custom currency on journal for liquidity line.
if payment.journal_id.currency_id and payment.currency_id != payment.journal_id.currency_id:
# Custom currency on journal.
if payment.journal_id.currency_id == company_currency:
# Single-currency
liquidity_line_currency_id = False
else:
liquidity_line_currency_id = payment.journal_id.currency_id.id
liquidity_amount = company_currency._convert(
balance, payment.journal_id.currency_id, payment.company_id, payment.payment_date)
else:
# Use the payment currency.
liquidity_line_currency_id = currency_id
liquidity_amount = counterpart_amount
# Compute 'name' to be used in receivable/payable line.
rec_pay_line_name = ''
if payment.payment_type == 'transfer':
rec_pay_line_name = payment.name
else:
if payment.partner_type == 'customer':
if payment.payment_type == 'inbound':
rec_pay_line_name += _("Customer Payment")
elif payment.payment_type == 'outbound':
rec_pay_line_name += _("Customer Credit Note")
elif payment.partner_type == 'supplier':
if payment.payment_type == 'inbound':
rec_pay_line_name += _("Vendor Credit Note")
elif payment.payment_type == 'outbound':
rec_pay_line_name += _("Vendor Payment")
if payment.invoice_ids:
rec_pay_line_name += ': %s' % ', '.join(payment.invoice_ids.mapped('name'))
# Compute 'name' to be used in liquidity line.
if payment.payment_type == 'transfer':
liquidity_line_name = _('Transfer to %s') % payment.destination_journal_id.name
else:
liquidity_line_name = payment.name
# ==== 'inbound' / 'outbound' ====
move_vals = {
'date': payment.payment_date,
'ref': payment.communication,
'journal_id': payment.journal_id.id,
'currency_id': payment.journal_id.currency_id.id or payment.company_id.currency_id.id,
'partner_id': payment.partner_id.id,
'line_ids': [
# Receivable / Payable / Transfer line.
(0, 0, {
'name': rec_pay_line_name,
'amount_currency': counterpart_amount + write_off_amount if currency_id else 0.0,
'currency_id': currency_id,
'debit': balance + write_off_balance > 0.0 and balance + write_off_balance or 0.0,
'credit': balance + write_off_balance < 0.0 and -balance - write_off_balance or 0.0,
'date_maturity': payment.payment_date,
'partner_id': payment.partner_id.id,
'account_id': payment.destination_account_id.id,
'payment_id': payment.id,
}),
# Liquidity line.
(0, 0, {
'name': liquidity_line_name,
'amount_currency': -liquidity_amount if liquidity_line_currency_id else 0.0,
'currency_id': liquidity_line_currency_id,
'debit': balance < 0.0 and -balance or 0.0,
'credit': balance > 0.0 and balance or 0.0,
'date_maturity': payment.payment_date,
'partner_id': payment.partner_id.id,
'account_id': liquidity_line_account.id,
'payment_id': payment.id,
}),
],
}
if write_off_balance:
# Write-off line.
move_vals['line_ids'].append((0, 0, {
'name': payment.writeoff_label,
'amount_currency': -write_off_amount,
'currency_id': currency_id,
'debit': write_off_balance < 0.0 and -write_off_balance or 0.0,
'credit': write_off_balance > 0.0 and write_off_balance or 0.0,
'date_maturity': payment.payment_date,
'partner_id': payment.partner_id.id,
'account_id': payment.writeoff_account_id.id,
'payment_id': payment.id,
}))
if move_names:
move_vals['name'] = move_names[0]
all_move_vals.append(move_vals)
# ==== 'transfer' ====
if payment.payment_type == 'transfer':
journal = payment.destination_journal_id
# Manage custom currency on journal for liquidity line.
if journal.currency_id and payment.currency_id != journal.currency_id:
# Custom currency on journal.
liquidity_line_currency_id = journal.currency_id.id
transfer_amount = company_currency._convert(balance, journal.currency_id, payment.company_id, payment.payment_date)
else:
# Use the payment currency.
liquidity_line_currency_id = currency_id
transfer_amount = counterpart_amount
transfer_move_vals = {
'date': payment.payment_date,
'ref': payment.communication,
'partner_id': payment.partner_id.id,
'journal_id': payment.destination_journal_id.id,
'line_ids': [
# Transfer debit line.
(0, 0, {
'name': payment.name,
'amount_currency': -counterpart_amount if currency_id else 0.0,
'currency_id': currency_id,
'debit': balance < 0.0 and -balance or 0.0,
'credit': balance > 0.0 and balance or 0.0,
'date_maturity': payment.payment_date,
'partner_id': payment.partner_id.id,
'account_id': payment.company_id.transfer_account_id.id,
'payment_id': payment.id,
}),
# Liquidity credit line.
(0, 0, {
'name': _('Transfer from %s') % payment.journal_id.name,
'amount_currency': transfer_amount if liquidity_line_currency_id else 0.0,
'currency_id': liquidity_line_currency_id,
'debit': balance > 0.0 and balance or 0.0,
'credit': balance < 0.0 and -balance or 0.0,
'date_maturity': payment.payment_date,
'partner_id': payment.partner_id.id,
'account_id': payment.destination_journal_id.default_credit_account_id.id,
'payment_id': payment.id,
}),
],
}
if move_names and len(move_names) == 2:
transfer_move_vals['name'] = move_names[1]
all_move_vals.append(transfer_move_vals)
return all_move_vals
def post(self):
""" Create the journal items for the payment and update the payment's state to 'posted'.
A journal entry is created containing an item in the source liquidity account (selected journal's default_debit or default_credit)
and another in the destination reconcilable account (see _compute_destination_account_id).
If invoice_ids is not empty, there will be one reconcilable move line per invoice to reconcile with.
If the payment is a transfer, a second journal entry is created in the destination journal to receive money from the transfer account.
"""
AccountMove = self.env['account.move'].with_context(default_type='entry')
for rec in self:
if rec.state != 'draft':
raise UserError(_("Only a draft payment can be posted."))
if any(inv.state != 'posted' for inv in rec.invoice_ids):
raise ValidationError(_("The payment cannot be processed because the invoice is not open!"))
# keep the name in case of a payment reset to draft
if not rec.name:
# Use the right sequence to set the name
if rec.payment_type == 'transfer':
sequence_code = 'account.payment.transfer'
else:
if rec.partner_type == 'customer':
if rec.payment_type == 'inbound':
sequence_code = 'account.payment.customer.invoice'
if rec.payment_type == 'outbound':
sequence_code = 'account.payment.customer.refund'
if rec.partner_type == 'supplier':
if rec.payment_type == 'inbound':
sequence_code = 'account.payment.supplier.refund'
if rec.payment_type == 'outbound':
sequence_code = 'account.payment.supplier.invoice'
rec.name = self.env['ir.sequence'].next_by_code(sequence_code, sequence_date=rec.payment_date)
if not rec.name and rec.payment_type != 'transfer':
raise UserError(_("You have to define a sequence for %s in your company.") % (sequence_code,))
moves = AccountMove.create(rec._prepare_payment_moves())
moves.filtered(lambda move: move.journal_id.post_at != 'bank_rec').post()
# Update the state / move before performing any reconciliation.
move_name = self._get_move_name_transfer_separator().join(moves.mapped('name'))
rec.write({'state': 'posted', 'move_name': move_name})
if rec.payment_type in ('inbound', 'outbound'):
# ==== 'inbound' / 'outbound' ====
if rec.invoice_ids:
(moves[0] + rec.invoice_ids).line_ids \
.filtered(lambda line: not line.reconciled and line.account_id == rec.destination_account_id)\
.reconcile()
elif rec.payment_type == 'transfer':
# ==== 'transfer' ====
moves.mapped('line_ids')\
.filtered(lambda line: line.account_id == rec.company_id.transfer_account_id)\
.reconcile()
return True
def action_draft(self):
moves = self.mapped('move_line_ids.move_id')
moves.filtered(lambda move: move.state == 'posted').button_draft()
moves.with_context(force_delete=True).unlink()
self.write({'state': 'draft'})
def _get_invoice_payment_amount(self, inv):
"""
Computes the amount covered by the current payment in the given invoice.
:param inv: an invoice object
:returns: the amount covered by the payment in the invoice
"""
self.ensure_one()
return sum([
data['amount']
for data in inv._get_reconciled_info_JSON_values()
if data['account_payment_id'] == self.id
])
class HrEmployee(models.Model):
_inherit = 'hr.employee'
timesheet_cost = fields.Monetary('Timesheet Cost', currency_field='currency_id',
groups="hr.group_hr_user", default=0.0)
currency_id = fields.Many2one('res.currency', related='company_id.currency_id', readonly=True)
class SaleAdvancePaymentInv(models.TransientModel):
_name = "sale.advance.payment.inv"
_description = "Sales Advance Payment Invoice"
@api.model
def _count(self):
return len(self._context.get('active_ids', []))
@api.model
def _default_product_id(self):
product_id = self.env['ir.config_parameter'].sudo().get_param(
'sale.default_deposit_product_id')
return self.env['product.product'].browse(int(product_id)).exists()
@api.model
def _default_deposit_account_id(self):
return self._default_product_id().property_account_income_id
@api.model
def _default_deposit_taxes_id(self):
return self._default_product_id().taxes_id
@api.model
def _default_has_down_payment(self):
if self._context.get(
'active_model') == 'sale.order' and self._context.get(
'active_id', False):
sale_order = self.env['sale.order'].browse(
self._context.get('active_id'))
return sale_order.order_line.filtered(
lambda sale_order_line: sale_order_line.is_downpayment)
return False
@api.model
def _default_currency_id(self):
if self._context.get(
'active_model') == 'sale.order' and self._context.get(
'active_id', False):
sale_order = self.env['sale.order'].browse(
self._context.get('active_id'))
return sale_order.currency_id
advance_payment_method = fields.Selection(
[('delivered', 'Regular invoice'),
('percentage', 'Down payment (percentage)'),
('fixed', 'Down payment (fixed amount)')],
string='Create Invoice',
default='delivered',
required=True,
help=
"A standard invoice is issued with all the order lines ready for invoicing, \
according to their invoicing policy (based on ordered or delivered quantity)."
)
deduct_down_payments = fields.Boolean('Deduct down payments', default=True)
has_down_payments = fields.Boolean('Has down payments',
default=_default_has_down_payment,
readonly=True)
product_id = fields.Many2one('product.product',
string='Down Payment Product',
domain=[('type', '=', 'service')],
default=_default_product_id)
count = fields.Integer(default=_count, string='Order Count')
amount = fields.Float(
'Down Payment Amount',
digits='Account',
help=
"The percentage of amount to be invoiced in advance, taxes excluded.")
currency_id = fields.Many2one('res.currency',
string='Currency',
default=_default_currency_id)
fixed_amount = fields.Monetary(
'Down Payment Amount(Fixed)',
help="The fixed amount to be invoiced in advance, taxes excluded.")
deposit_account_id = fields.Many2one("account.account",
string="Income Account",
domain=[('deprecated', '=', False)],
help="Account used for deposits",
default=_default_deposit_account_id)
deposit_taxes_id = fields.Many2many("account.tax",
string="Customer Taxes",
help="Taxes used for deposits",
default=_default_deposit_taxes_id)
@api.onchange('advance_payment_method')
def onchange_advance_payment_method(self):
if self.advance_payment_method == 'percentage':
return {'value': {'amount': 0}}
return {}
def _create_invoice(self, order, so_line, amount):
if (self.advance_payment_method == 'percentage' and
self.amount <= 0.00) or (self.advance_payment_method == 'fixed'
and self.fixed_amount <= 0.00):
raise UserError(
_('The value of the down payment amount must be positive.'))
if self.advance_payment_method == 'percentage':
amount = order.amount_untaxed * self.amount / 100
name = _("Down payment of %s%%") % (self.amount, )
else:
amount = self.fixed_amount
name = _('Down Payment')
invoice_vals = {
'type':
'out_invoice',
'invoice_origin':
order.name,
'invoice_user_id':
order.user_id.id,
'narration':
order.note,
'partner_id':
order.partner_invoice_id.id,
'fiscal_position_id':
order.fiscal_position_id.id
or order.partner_id.property_account_position_id.id,
'partner_shipping_id':
order.partner_shipping_id.id,
'currency_id':
order.pricelist_id.currency_id.id,
'invoice_payment_ref':
order.client_order_ref,
'invoice_payment_term_id':
order.payment_term_id.id,
'invoice_partner_bank_id':
order.company_id.partner_id.bank_ids[:1],
'team_id':
order.team_id.id,
'campaign_id':
order.campaign_id.id,
'medium_id':
order.medium_id.id,
'source_id':
order.source_id.id,
'invoice_line_ids': [(0, 0, {
'name':
name,
'price_unit':
amount,
'quantity':
1.0,
'product_id':
self.product_id.id,
'product_uom_id':
so_line.product_uom.id,
'tax_ids': [(6, 0, so_line.tax_id.ids)],
'sale_line_ids': [(6, 0, [so_line.id])],
'analytic_tag_ids': [(6, 0, so_line.analytic_tag_ids.ids)],
'analytic_account_id':
order.analytic_account_id.id or False,
})],
}
if order.fiscal_position_id:
invoice_vals['fiscal_position_id'] = order.fiscal_position_id.id
invoice = self.env['account.move'].create(invoice_vals)
invoice.message_post_with_view(
'mail.message_origin_link',
values={
'self': invoice,
'origin': order
},
subtype_id=self.env.ref('mail.mt_note').id)
return invoice
def create_invoices(self):
sale_orders = self.env['sale.order'].browse(
self._context.get('active_ids', []))
if self.advance_payment_method == 'delivered':
sale_orders._create_invoices(final=self.deduct_down_payments)
else:
# Create deposit product if necessary
if not self.product_id:
vals = self._prepare_deposit_product()
self.product_id = self.env['product.product'].create(vals)
self.env['ir.config_parameter'].sudo().set_param(
'sale.default_deposit_product_id', self.product_id.id)
sale_line_obj = self.env['sale.order.line']
for order in sale_orders:
if self.advance_payment_method == 'percentage':
amount = order.amount_untaxed * self.amount / 100
else:
amount = self.fixed_amount
if self.product_id.invoice_policy != 'order':
raise UserError(
_('The product used to invoice a down payment should have an invoice policy set to "Ordered quantities". Please update your deposit product to be able to create a deposit invoice.'
))
if self.product_id.type != 'service':
raise UserError(
_("The product used to invoice a down payment should be of type 'Service'. Please use another product or update this product."
))
taxes = self.product_id.taxes_id.filtered(
lambda r: not order.company_id or r.company_id == order.
company_id)
if order.fiscal_position_id and taxes:
tax_ids = order.fiscal_position_id.map_tax(
taxes, self.product_id, order.partner_shipping_id).ids
else:
tax_ids = taxes.ids
context = {'lang': order.partner_id.lang}
analytic_tag_ids = []
for line in order.order_line:
analytic_tag_ids = [
(4, analytic_tag.id, None)
for analytic_tag in line.analytic_tag_ids
]
so_line = sale_line_obj.create({
'name':
_('Down Payment: %s') % (time.strftime('%m %Y'), ),
'price_unit':
amount,
'product_uom_qty':
0.0,
'order_id':
order.id,
'discount':
0.0,
'product_uom':
self.product_id.uom_id.id,
'product_id':
self.product_id.id,
'analytic_tag_ids':
analytic_tag_ids,
'tax_id': [(6, 0, tax_ids)],
'is_downpayment':
True,
})
del context
self._create_invoice(order, so_line, amount)
if self._context.get('open_invoices', False):
return sale_orders.action_view_invoice()
return {'type': 'ir.actions.act_window_close'}
def _prepare_deposit_product(self):
return {
'name': 'Down payment',
'type': 'service',
'invoice_policy': 'order',
'property_account_income_id': self.deposit_account_id.id,
'taxes_id': [(6, 0, self.deposit_taxes_id.ids)],
'company_id': False,
}
class PurchaseOrderLine(models.Model):
_name = 'purchase.order.line'
_description = 'Purchase Order Line'
_order = 'order_id, sequence, id'
name = fields.Text(string='Description', required=True)
sequence = fields.Integer(string='Sequence', default=10)
product_qty = fields.Float(string='Quantity', digits='Product Unit of Measure', required=True)
product_uom_qty = fields.Float(string='Total Quantity', compute='_compute_product_uom_qty', store=True)
date_planned = fields.Datetime(string='Scheduled Date', index=True)
taxes_id = fields.Many2many('account.tax', string='Taxes', domain=['|', ('active', '=', False), ('active', '=', True)])
product_uom = fields.Many2one('uom.uom', string='Unit of Measure', domain="[('category_id', '=', product_uom_category_id)]")
product_uom_category_id = fields.Many2one(related='product_id.uom_id.category_id')
product_id = fields.Many2one('product.product', string='Product', domain=[('purchase_ok', '=', True)], change_default=True)
product_type = fields.Selection(related='product_id.type', readonly=True)
price_unit = fields.Float(string='Unit Price', required=True, digits='Product Price')
price_subtotal = fields.Monetary(compute='_compute_amount', string='Subtotal', store=True)
price_total = fields.Monetary(compute='_compute_amount', string='Total', store=True)
price_tax = fields.Float(compute='_compute_amount', string='Tax', store=True)
order_id = fields.Many2one('purchase.order', string='Order Reference', index=True, required=True, ondelete='cascade')
account_analytic_id = fields.Many2one('account.analytic.account', string='Analytic Account')
analytic_tag_ids = fields.Many2many('account.analytic.tag', string='Analytic Tags')
company_id = fields.Many2one('res.company', related='order_id.company_id', string='Company', store=True, readonly=True)
state = fields.Selection(related='order_id.state', store=True, readonly=False)
invoice_lines = fields.One2many('account.move.line', 'purchase_line_id', string="Bill Lines", readonly=True, copy=False)
# Replace by invoiced Qty
qty_invoiced = fields.Float(compute='_compute_qty_invoiced', string="Billed Qty", digits='Product Unit of Measure', store=True)
qty_received_method = fields.Selection([('manual', 'Manual')], string="Received Qty Method", compute='_compute_qty_received_method', store=True,
help="According to product configuration, the recieved quantity can be automatically computed by mechanism :\n"
" - Manual: the quantity is set manually on the line\n"
" - Stock Moves: the quantity comes from confirmed pickings\n")
qty_received = fields.Float("Received Qty", compute='_compute_qty_received', inverse='_inverse_qty_received', compute_sudo=True, store=True, digits='Product Unit of Measure')
qty_received_manual = fields.Float("Manual Received Qty", digits='Product Unit of Measure', copy=False)
partner_id = fields.Many2one('res.partner', related='order_id.partner_id', string='Partner', readonly=True, store=True)
currency_id = fields.Many2one(related='order_id.currency_id', store=True, string='Currency', readonly=True)
date_order = fields.Datetime(related='order_id.date_order', string='Order Date', readonly=True)
display_type = fields.Selection([
('line_section', "Section"),
('line_note', "Note")], default=False, help="Technical field for UX purpose.")
_sql_constraints = [
('accountable_required_fields',
"CHECK(display_type IS NOT NULL OR (product_id IS NOT NULL AND product_uom IS NOT NULL AND date_planned IS NOT NULL))",
"Missing required fields on accountable purchase order line."),
('non_accountable_null_fields',
"CHECK(display_type IS NULL OR (product_id IS NULL AND price_unit = 0 AND product_uom_qty = 0 AND product_uom IS NULL AND date_planned is NULL))",
"Forbidden values on non-accountable purchase order line"),
]
@api.depends('product_qty', 'price_unit', 'taxes_id')
def _compute_amount(self):
for line in self:
vals = line._prepare_compute_all_values()
taxes = line.taxes_id.compute_all(
vals['price_unit'],
vals['currency_id'],
vals['product_qty'],
vals['product'],
vals['partner'])
line.update({
'price_tax': sum(t.get('amount', 0.0) for t in taxes.get('taxes', [])),
'price_total': taxes['total_included'],
'price_subtotal': taxes['total_excluded'],
})
def _prepare_compute_all_values(self):
# Hook method to returns the different argument values for the
# compute_all method, due to the fact that discounts mechanism
# is not implemented yet on the purchase orders.
# This method should disappear as soon as this feature is
# also introduced like in the sales module.
self.ensure_one()
return {
'price_unit': self.price_unit,
'currency_id': self.order_id.currency_id,
'product_qty': self.product_qty,
'product': self.product_id,
'partner': self.order_id.partner_id,
}
def _compute_tax_id(self):
for line in self:
fpos = line.order_id.fiscal_position_id or line.order_id.partner_id.with_context(force_company=line.company_id.id).property_account_position_id
# If company_id is set, always filter taxes by the company
taxes = line.product_id.supplier_taxes_id.filtered(lambda r: not line.company_id or r.company_id == line.company_id)
line.taxes_id = fpos.map_tax(taxes, line.product_id, line.order_id.partner_id) if fpos else taxes
@api.depends('invoice_lines.move_id.state', 'invoice_lines.quantity')
def _compute_qty_invoiced(self):
for line in self:
qty = 0.0
for inv_line in line.invoice_lines:
if inv_line.move_id.state not in ['cancel']:
if inv_line.move_id.type == 'in_invoice':
qty += inv_line.product_uom_id._compute_quantity(inv_line.quantity, line.product_uom)
elif inv_line.move_id.type == 'in_refund':
qty -= inv_line.product_uom_id._compute_quantity(inv_line.quantity, line.product_uom)
line.qty_invoiced = qty
@api.depends('product_id')
def _compute_qty_received_method(self):
for line in self:
if line.product_id and line.product_id.type in ['consu', 'service']:
line.qty_received_method = 'manual'
else:
line.qty_received_method = False
@api.depends('qty_received_method', 'qty_received_manual')
def _compute_qty_received(self):
for line in self:
if line.qty_received_method == 'manual':
line.qty_received = line.qty_received_manual or 0.0
else:
line.qty_received = 0.0
@api.onchange('qty_received')
def _inverse_qty_received(self):
""" When writing on qty_received, if the value should be modify manually (`qty_received_method` = 'manual' only),
then we put the value in `qty_received_manual`. Otherwise, `qty_received_manual` should be False since the
received qty is automatically compute by other mecanisms.
"""
for line in self:
if line.qty_received_method == 'manual':
line.qty_received_manual = line.qty_received
else:
line.qty_received_manual = 0.0
@api.model
def create(self, values):
if values.get('display_type', self.default_get(['display_type'])['display_type']):
values.update(product_id=False, price_unit=0, product_uom_qty=0, product_uom=False, date_planned=False)
order_id = values.get('order_id')
if 'date_planned' not in values:
order = self.env['purchase.order'].browse(order_id)
if order.date_planned:
values['date_planned'] = order.date_planned
line = super(PurchaseOrderLine, self).create(values)
if line.order_id.state == 'purchase':
msg = _("Extra line with %s ") % (line.product_id.display_name,)
line.order_id.message_post(body=msg)
return line
def write(self, values):
if 'display_type' in values and self.filtered(lambda line: line.display_type != values.get('display_type')):
raise UserError("You cannot change the type of a purchase order line. Instead you should delete the current line and create a new line of the proper type.")
if 'product_qty' in values:
for line in self:
if line.order_id.state == 'purchase':
line.order_id.message_post_with_view('purchase.track_po_line_template',
values={'line': line, 'product_qty': values['product_qty']},
subtype_id=self.env.ref('mail.mt_note').id)
return super(PurchaseOrderLine, self).write(values)
def unlink(self):
for line in self:
if line.order_id.state in ['purchase', 'done']:
raise UserError(_('Cannot delete a purchase order line which is in state \'%s\'.') % (line.state,))
return super(PurchaseOrderLine, self).unlink()
@api.model
def _get_date_planned(self, seller, po=False):
"""Return the datetime value to use as Schedule Date (``date_planned``) for
PO Lines that correspond to the given product.seller_ids,
when ordered at `date_order_str`.
:param Model seller: used to fetch the delivery delay (if no seller
is provided, the delay is 0)
:param Model po: purchase.order, necessary only if the PO line is
not yet attached to a PO.
:rtype: datetime
:return: desired Schedule Date for the PO line
"""
date_order = po.date_order if po else self.order_id.date_order
if date_order:
return date_order + relativedelta(days=seller.delay if seller else 0)
else:
return datetime.today() + relativedelta(days=seller.delay if seller else 0)
@api.onchange('product_id')
def onchange_product_id(self):
if not self.product_id:
return
# Reset date, price and quantity since _onchange_quantity will provide default values
self.date_planned = datetime.today().strftime(DEFAULT_SERVER_DATETIME_FORMAT)
self.price_unit = self.product_qty = 0.0
self._product_id_change()
self._suggest_quantity()
self._onchange_quantity()
def _product_id_change(self):
if not self.product_id:
return
self.product_uom = self.product_id.uom_po_id or self.product_id.uom_id
product_lang = self.product_id.with_context(
lang=self.partner_id.lang,
partner_id=self.partner_id.id,
company_id=self.company_id.id,
)
self.name = self._get_product_purchase_description(product_lang)
self._compute_tax_id()
@api.onchange('product_id')
def onchange_product_id_warning(self):
if not self.product_id or not self.env.user.has_group('purchase.group_warning_purchase'):
return
warning = {}
title = False
message = False
product_info = self.product_id
if product_info.purchase_line_warn != 'no-message':
title = _("Warning for %s") % product_info.name
message = product_info.purchase_line_warn_msg
warning['title'] = title
warning['message'] = message
if product_info.purchase_line_warn == 'block':
self.product_id = False
return {'warning': warning}
return {}
@api.onchange('product_qty', 'product_uom')
def _onchange_quantity(self):
if not self.product_id:
return
params = {'order_id': self.order_id}
seller = self.product_id._select_seller(
partner_id=self.partner_id,
quantity=self.product_qty,
date=self.order_id.date_order and self.order_id.date_order.date(),
uom_id=self.product_uom,
params=params)
if seller or not self.date_planned:
self.date_planned = self._get_date_planned(seller).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
if not seller:
if self.product_id.seller_ids.filtered(lambda s: s.name.id == self.partner_id.id):
self.price_unit = 0.0
return
price_unit = self.env['account.tax']._fix_tax_included_price_company(seller.price, self.product_id.supplier_taxes_id, self.taxes_id, self.company_id) if seller else 0.0
if price_unit and seller and self.order_id.currency_id and seller.currency_id != self.order_id.currency_id:
price_unit = seller.currency_id._convert(
price_unit, self.order_id.currency_id, self.order_id.company_id, self.date_order or fields.Date.today())
if seller and self.product_uom and seller.product_uom != self.product_uom:
price_unit = seller.product_uom._compute_price(price_unit, self.product_uom)
self.price_unit = price_unit
@api.depends('product_uom', 'product_qty', 'product_id.uom_id')
def _compute_product_uom_qty(self):
for line in self:
if line.product_id and line.product_id.uom_id != line.product_uom:
line.product_uom_qty = line.product_uom._compute_quantity(line.product_qty, line.product_id.uom_id)
else:
line.product_uom_qty = line.product_qty
def _suggest_quantity(self):
'''
Suggest a minimal quantity based on the seller
'''
if not self.product_id:
return
seller_min_qty = self.product_id.seller_ids\
.filtered(lambda r: r.name == self.order_id.partner_id and (not r.product_id or r.product_id == self.product_id))\
.sorted(key=lambda r: r.min_qty)
if seller_min_qty:
self.product_qty = seller_min_qty[0].min_qty or 1.0
self.product_uom = seller_min_qty[0].product_uom
else:
self.product_qty = 1.0
def _get_product_purchase_description(self, product_lang):
self.ensure_one()
name = product_lang.display_name
if product_lang.description_purchase:
name += '\n' + product_lang.description_purchase
return name
def _prepare_account_move_line(self, move):
self.ensure_one()
if self.product_id.purchase_method == 'purchase':
qty = self.product_qty - self.qty_invoiced
else:
qty = self.qty_received - self.qty_invoiced
if float_compare(qty, 0.0, precision_rounding=self.product_uom.rounding) <= 0:
qty = 0.0
if self.currency_id == move.company_id.currency_id:
currency = False
else:
currency = move.currency_id
return {
'name': '%s: %s' % (self.order_id.name, self.name),
'move_id': move.id,
'currency_id': currency and currency.id or False,
'purchase_line_id': self.id,
'date_maturity': move.invoice_date_due,
'product_uom_id': self.product_uom.id,
'product_id': self.product_id.id,
'price_unit': self.price_unit,
'quantity': qty,
'partner_id': move.partner_id.id,
'analytic_account_id': self.account_analytic_id.id,
'analytic_tag_ids': [(6, 0, self.analytic_tag_ids.ids)],
'tax_ids': [(6, 0, self.taxes_id.ids)],
'display_type': self.display_type,
}
class AccountMoveReversal(models.TransientModel):
"""
Account move reversal wizard, it cancel an account move by reversing it.
"""
_name = 'account.move.reversal'
_description = 'Account Move Reversal'
move_id = fields.Many2one('account.move',
string='Journal Entry',
domain=[('state', '=', 'posted'),
('type', 'not in', ('out_refund',
'in_refund'))])
date = fields.Date(string='Reversal date',
default=fields.Date.context_today,
required=True)
reason = fields.Char(string='Reason')
refund_method = fields.Selection(
selection=[('refund', 'Partial Refund'), ('cancel', 'Full Refund'),
('modify', 'Full refund and new draft invoice')],
string='Credit Method',
required=True,
help=
'Choose how you want to credit this invoice. You cannot "modify" nor "cancel" if the invoice is already reconciled.'
)
journal_id = fields.Many2one(
'account.journal',
string='Use Specific Journal',
help='If empty, uses the journal of the journal entry to be reversed.')
# computed fields
residual = fields.Monetary(compute="_compute_from_moves")
currency_id = fields.Many2one('res.currency',
compute="_compute_from_moves")
move_type = fields.Char(compute="_compute_from_moves")
@api.model
def default_get(self, fields):
res = super(AccountMoveReversal, self).default_get(fields)
move_ids = self.env['account.move'].browse(
self.env.context['active_ids']) if self.env.context.get(
'active_model') == 'account.move' else self.env['account.move']
res['refund_method'] = (len(move_ids) > 1 or move_ids.type
== 'entry') and 'cancel' or 'refund'
res['residual'] = len(move_ids) == 1 and move_ids.amount_residual or 0
res['currency_id'] = len(
move_ids.currency_id) == 1 and move_ids.currency_id.id or False
res['move_type'] = len(move_ids) == 1 and move_ids.type or False
return res
@api.depends('move_id')
def _compute_from_moves(self):
move_ids = self.env['account.move'].browse(
self.env.context['active_ids']) if self.env.context.get(
'active_model') == 'account.move' else self.move_id
for record in self:
record.residual = len(
move_ids) == 1 and move_ids.amount_residual or 0
record.currency_id = len(
move_ids.currency_id) == 1 and move_ids.currency_id or False
record.move_type = len(move_ids) == 1 and move_ids.type or False
def reverse_moves(self):
moves = self.env['account.move'].browse(
self.env.context['active_ids']) if self.env.context.get(
'active_model') == 'account.move' else self.move_id
# Create default values.
default_values_list = []
for move in moves:
default_values_list.append({
'ref':
_('Reversal of: %s, %s') % (move.name, self.reason)
if self.reason else _('Reversal of: %s') % (move.name),
'date':
self.date or move.date,
'invoice_date':
move.is_invoice(include_receipts=True) and
(self.date or move.date) or False,
'journal_id':
self.journal_id and self.journal_id.id or move.journal_id.id,
'invoice_payment_term_id':
None,
'auto_post':
True if self.date > fields.Date.context_today(self) else False,
})
# Handle reverse method.
if self.refund_method == 'cancel':
if any(
[vals.get('auto_post', False)
for vals in default_values_list]):
new_moves = moves._reverse_moves(default_values_list)
else:
new_moves = moves._reverse_moves(default_values_list,
cancel=True)
elif self.refund_method == 'modify':
moves._reverse_moves(default_values_list, cancel=True)
moves_vals_list = []
for move in moves.with_context(include_business_fields=True):
moves_vals_list.append(
move.copy_data({
'invoice_payment_ref': move.name,
'date': self.date or move.date,
})[0])
new_moves = self.env['account.move'].create(moves_vals_list)
elif self.refund_method == 'refund':
new_moves = moves._reverse_moves(default_values_list)
else:
return
# Create action.
action = {
'name': _('Reverse Moves'),
'type': 'ir.actions.act_window',
'res_model': 'account.move',
}
if len(new_moves) == 1:
action.update({
'view_mode': 'form',
'res_id': new_moves.id,
})
else:
action.update({
'view_mode': 'tree,form',
'domain': [('id', 'in', new_moves.ids)],
})
return action
class AccrualAccountingWizard(models.TransientModel):
_name = 'account.accrual.accounting.wizard'
_description = 'Create accrual entry.'
date = fields.Date(required=True)
company_id = fields.Many2one('res.company', required=True)
account_type = fields.Selection([('income', 'Revenue'), ('expense', 'Expense')])
active_move_line_ids = fields.Many2many('account.move.line')
journal_id = fields.Many2one('account.journal', required=True, readonly=False,
domain="[('company_id', '=', company_id), ('type', '=', 'general')]",
related="company_id.accrual_default_journal_id")
expense_accrual_account = fields.Many2one('account.account', readonly=False,
domain="[('company_id', '=', company_id), ('internal_type', 'not in', ('receivable', 'payable')), ('internal_group', '=', 'liability'), ('reconcile', '=', True)]",
related="company_id.expense_accrual_account_id")
revenue_accrual_account = fields.Many2one('account.account', readonly=False,
domain="[('company_id', '=', company_id), ('internal_type', 'not in', ('receivable', 'payable')), ('internal_group', '=', 'asset'), ('reconcile', '=', True)]",
related="company_id.revenue_accrual_account_id")
percentage = fields.Float("Percentage", default=100.0)
total_amount = fields.Monetary(compute="_compute_total_amount", currency_field='company_currency_id')
company_currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
@api.constrains('percentage')
def _constraint_percentage(self):
for record in self:
if not (0.0 < record.percentage <= 100.0):
raise UserError(_("Percentage must be between 0 and 100"))
@api.depends('percentage', 'active_move_line_ids')
def _compute_total_amount(self):
for record in self:
record.total_amount = sum(record.active_move_line_ids.mapped(lambda l: record.percentage * (l.debit + l.credit) / 100))
@api.model
def default_get(self, fields):
if self.env.context.get('active_model') != 'account.move.line' or not self.env.context.get('active_ids'):
raise UserError(_('This can only be used on journal items'))
rec = super(AccrualAccountingWizard, self).default_get(fields)
active_move_line_ids = self.env['account.move.line'].browse(self.env.context['active_ids'])
rec['active_move_line_ids'] = active_move_line_ids.ids
if any(move.state != 'posted' for move in active_move_line_ids.mapped('move_id')):
raise UserError(_('You can only change the period for posted journal items.'))
if any(move_line.reconciled for move_line in active_move_line_ids):
raise UserError(_('You can only change the period for items that are not yet reconciled.'))
if any(line.account_id.user_type_id != active_move_line_ids[0].account_id.user_type_id for line in active_move_line_ids):
raise UserError(_('All accounts on the lines must be from the same type.'))
if any(line.company_id != active_move_line_ids[0].company_id for line in active_move_line_ids):
raise UserError(_('All lines must be from the same company.'))
rec['company_id'] = active_move_line_ids[0].company_id.id
account_types_allowed = self.env.ref('account.data_account_type_expenses') + self.env.ref('account.data_account_type_revenue') + self.env.ref('account.data_account_type_other_income')
if active_move_line_ids[0].account_id.user_type_id not in account_types_allowed:
raise UserError(_('You can only change the period for items in these types of accounts: ') + ", ".join(account_types_allowed.mapped('name')))
rec['account_type'] = active_move_line_ids[0].account_id.user_type_id.internal_group
return rec
def amend_entries(self):
# set the accrual account on the selected journal items
accrual_account = self.revenue_accrual_account if self.account_type == 'income' else self.expense_accrual_account
# Generate journal entries.
move_data = {}
for aml in self.active_move_line_ids:
ref1 = _('Accrual Adjusting Entry (%s recognized) for invoice: %s') % (self.percentage, aml.move_id.name)
ref2 = _('Accrual Adjusting Entry (%s recognized) for invoice: %s') % (100 - self.percentage, aml.move_id.name)
move_data.setdefault(aml.move_id, (
[
# Values to create moves.
{
'date': self.date,
'ref': ref1,
'journal_id': self.journal_id.id,
'line_ids': [],
},
{
'date': aml.move_id.date,
'ref': ref2,
'journal_id': self.journal_id.id,
'line_ids': [],
},
], [
# Messages to log on the chatter.
(_('Accrual Adjusting Entry ({percent}% recognized) for invoice:') + ' <a href=# data-oe-model=account.move data-oe-id={id}>{name}</a>').format(
percent=self.percentage,
id=aml.move_id.id,
name=aml.move_id.name,
),
(_('Accrual Adjusting Entry ({percent}% recognized) for invoice:') + ' <a href=# data-oe-model=account.move data-oe-id={id}>{name}</a>').format(
percent=100 - self.percentage,
id=aml.move_id.id,
name=aml.move_id.name,
),
]
))
reported_debit = aml.company_id.currency_id.round((self.percentage / 100) * aml.debit)
reported_credit = aml.company_id.currency_id.round((self.percentage / 100) * aml.credit)
if aml.currency_id:
reported_amount_currency = aml.currency_id.round((self.percentage / 100) * aml.amount_currency)
else:
reported_amount_currency = 0.0
move_data[aml.move_id][0][0]['line_ids'] += [
(0, 0, {
'name': aml.name,
'debit': reported_debit,
'credit': reported_credit,
'amount_currency': reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': aml.account_id.id,
'partner_id': aml.partner_id.id,
}),
(0, 0, {
'name': ref1,
'debit': reported_credit,
'credit': reported_debit,
'amount_currency': -reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': accrual_account.id,
'partner_id': aml.partner_id.id,
}),
]
move_data[aml.move_id][0][1]['line_ids'] += [
(0, 0, {
'name': aml.name,
'debit': aml.debit - reported_debit,
'credit': aml.credit - reported_credit,
'amount_currency': aml.amount_currency - reported_amount_currency,
'currency_id': aml.currency_id.id,
'account_id': aml.account_id.id,
'partner_id': aml.partner_id.id,
}),
(0, 0, {
'name': ref2,
'debit': aml.credit - reported_credit,
'credit': aml.debit - reported_debit,
'amount_currency': reported_amount_currency - aml.amount_currency,
'currency_id': aml.currency_id.id,
'account_id': accrual_account.id,
'partner_id': aml.partner_id.id,
}),
]
# Update the account of selected journal items.
self.active_move_line_ids.write({'account_id': accrual_account.id})
# When the percentage is 100%, the second move is not needed.
if self.percentage < 100:
move_vals = []
log_messages = []
for v in move_data.values():
move_vals += v[0]
log_messages += v[1]
else:
move_vals = [v[0][0] for k, v in move_data.items()]
log_messages = [v[1][0] for k, v in move_data.items()]
created_moves = self.env['account.move'].create(move_vals)
created_moves.post()
# Reconcile.
index = 0
for move in self.active_move_line_ids.mapped('move_id'):
if self.percentage < 100:
accrual_moves = created_moves[index:index + 2]
index += 2
else:
accrual_moves = created_moves[index:index + 1]
index += 1
to_reconcile = self.active_move_line_ids.filtered(lambda line: line.move_id == move)
to_reconcile += accrual_moves.mapped('line_ids').filtered(lambda line: line.account_id == accrual_account and not line.reconciled)
to_reconcile.reconcile()
# Log messages.
for created_move, log_message in zip(created_moves, log_messages):
created_move.message_post(body=log_message)
# open the generated entries
action = {
'name': _('Generated Entries'),
'domain': [('id', 'in', created_moves.ids)],
'res_model': 'account.move',
'view_mode': 'tree,form',
'type': 'ir.actions.act_window',
'views': [(self.env.ref('account.view_move_tree').id, 'tree'), (False, 'form')],
}
if len(created_moves) == 1:
action.update({'view_mode': 'form', 'res_id': created_moves.id})
return action
class HrExpenseSheetRegisterPaymentWizard(models.TransientModel):
_name = "hr.expense.sheet.register.payment.wizard"
_description = "Expense Register Payment Wizard"
@api.model
def default_get(self, fields):
result = super(HrExpenseSheetRegisterPaymentWizard,
self).default_get(fields)
active_model = self._context.get('active_model')
if active_model != 'hr.expense.sheet':
raise UserError(
_('You can only apply this action from an expense report.'))
active_id = self._context.get('active_id')
if 'expense_sheet_id' in fields and active_id:
result['expense_sheet_id'] = active_id
if 'partner_id' in fields and active_id and not result.get(
'partner_id'):
expense_sheet = self.env['hr.expense.sheet'].browse(active_id)
result[
'partner_id'] = expense_sheet.address_id.id or expense_sheet.employee_id.id and expense_sheet.employee_id.address_home_id.id
return result
expense_sheet_id = fields.Many2one('hr.expense.sheet',
string="Expense Report",
required=True)
partner_id = fields.Many2one(
'res.partner',
string='Partner',
required=True,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
partner_bank_account_id = fields.Many2one(
'res.partner.bank',
string="Recipient Bank Account",
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
journal_id = fields.Many2one(
'account.journal',
string='Payment Method',
required=True,
domain=
"[('type', 'in', ('bank', 'cash')), ('company_id', '=', company_id)]")
company_id = fields.Many2one('res.company',
related='expense_sheet_id.company_id',
string='Company',
readonly=True)
payment_method_id = fields.Many2one('account.payment.method',
string='Payment Type',
required=True)
amount = fields.Monetary(string='Payment Amount', required=True)
currency_id = fields.Many2one(
'res.currency',
string='Currency',
required=True,
default=lambda self: self.env.company.currency_id)
payment_date = fields.Date(string='Payment Date',
default=fields.Date.context_today,
required=True)
communication = fields.Char(string='Memo')
hide_payment_method = fields.Boolean(
compute='_compute_hide_payment_method',
help=
"Technical field used to hide the payment method if the selected journal has only one available which is 'manual'"
)
show_partner_bank_account = fields.Boolean(
compute='_compute_show_partner_bank',
help=
'Technical field used to know whether the field `partner_bank_account_id` needs to be displayed or not in the payments form views'
)
require_partner_bank_account = fields.Boolean(
compute='_compute_show_partner_bank',
help=
'Technical field used to know whether the field `partner_bank_account_id` needs to be required or not in the payments form views'
)
@api.onchange('partner_id')
def _onchange_partner_id(self):
expense_sheet = self.expense_sheet_id
if expense_sheet.employee_id.id and expense_sheet.employee_id.sudo(
).bank_account_id.id:
self.partner_bank_account_id = expense_sheet.employee_id.sudo(
).bank_account_id.id
elif self.partner_id and len(self.partner_id.bank_ids) > 0:
self.partner_bank_account_id = self.partner_id.bank_ids[0]
else:
self.partner_bank_account_id = False
@api.constrains('amount')
def _check_amount(self):
for wizard in self:
if not wizard.amount > 0.0:
raise ValidationError(
_('The payment amount must be strictly positive.'))
@api.depends('payment_method_id')
def _compute_show_partner_bank(self):
""" Computes if the destination bank account must be displayed in the payment form view. By default, it
won't be displayed but some modules might change that, depending on the payment type."""
for payment in self:
payment.show_partner_bank_account = payment.payment_method_id.code in self.env[
'account.payment']._get_method_codes_using_bank_account()
payment.require_partner_bank_account = payment.payment_method_id.code in self.env[
'account.payment']._get_method_codes_needing_bank_account()
@api.depends('journal_id')
def _compute_hide_payment_method(self):
for wizard in self:
if not wizard.journal_id:
wizard.hide_payment_method = True
else:
journal_payment_methods = wizard.journal_id.outbound_payment_method_ids
wizard.hide_payment_method = (
len(journal_payment_methods) == 1
and journal_payment_methods[0].code == 'manual')
@api.onchange('journal_id')
def _onchange_journal(self):
if self.journal_id:
# Set default payment method (we consider the first to be the default one)
payment_methods = self.journal_id.outbound_payment_method_ids
self.payment_method_id = payment_methods and payment_methods[
0] or False
# Set payment method domain (restrict to methods enabled for the journal and to selected payment type)
return {
'domain': {
'payment_method_id': [('payment_type', '=', 'outbound'),
('id', 'in', payment_methods.ids)]
}
}
return {}
def _get_payment_vals(self):
""" Hook for extension """
return {
'partner_type': 'supplier',
'payment_type': 'outbound',
'partner_id': self.partner_id.id,
'partner_bank_account_id': self.partner_bank_account_id.id,
'journal_id': self.journal_id.id,
'company_id': self.company_id.id,
'payment_method_id': self.payment_method_id.id,
'amount': self.amount,
'currency_id': self.currency_id.id,
'payment_date': self.payment_date,
'communication': self.communication
}
def expense_post_payment(self):
self.ensure_one()
context = dict(self._context or {})
active_ids = context.get('active_ids', [])
expense_sheet = self.env['hr.expense.sheet'].browse(active_ids)
# Create payment and post it
payment = self.env['account.payment'].create(self._get_payment_vals())
payment.post()
# Log the payment in the chatter
body = (_(
"A payment of %s %s with the reference <a href='/mail/view?%s'>%s</a> related to your expense %s has been made."
) % (payment.amount, payment.currency_id.symbol,
url_encode({
'model': 'account.payment',
'res_id': payment.id
}), payment.name, expense_sheet.name))
expense_sheet.message_post(body=body)
# Reconcile the payment and the expense, i.e. lookup on the payable account move lines
account_move_lines_to_reconcile = self.env['account.move.line']
for line in payment.move_line_ids + expense_sheet.account_move_id.line_ids:
if line.account_id.internal_type == 'payable' and not line.reconciled:
account_move_lines_to_reconcile |= line
account_move_lines_to_reconcile.reconcile()
return {'type': 'ir.actions.act_window_close'}
class ProjectCreateInvoice(models.TransientModel):
_name = 'project.create.invoice'
_description = "Create Invoice from project"
@api.model
def default_get(self, fields):
result = super(ProjectCreateInvoice, self).default_get(fields)
active_model = self._context.get('active_model')
if active_model != 'project.project':
raise UserError(
_('You can only apply this action from a project.'))
active_id = self._context.get('active_id')
if 'project_id' in fields and active_id:
result['project_id'] = active_id
return result
project_id = fields.Many2one('project.project',
"Project",
help="Project to make billable",
required=True)
sale_order_id = fields.Many2one('sale.order',
string="Choose the Sales Order to invoice",
required=True)
amount_to_invoice = fields.Monetary(
"Amount to invoice",
compute='_compute_amount_to_invoice',
currency_field='currency_id',
help=
"Total amount to invoice on the sales order, including all items (services, storables, expenses, ...)"
)
currency_id = fields.Many2one(related='sale_order_id.currency_id',
readonly=True)
@api.onchange('project_id')
def _onchange_project_id(self):
sale_orders = self.project_id.tasks.mapped(
'sale_line_id.order_id').filtered(
lambda so: so.invoice_status == 'to invoice')
return {
'domain': {
'sale_order_id': [('id', 'in', sale_orders.ids)]
},
}
@api.depends('sale_order_id')
def _compute_amount_to_invoice(self):
for wizard in self:
amount_untaxed = 0.0
amount_tax = 0.0
for line in wizard.sale_order_id.order_line.filtered(
lambda sol: sol.invoice_status == 'to invoice'):
amount_untaxed += line.price_reduce * line.qty_to_invoice
amount_tax += line.price_tax
wizard.amount_to_invoice = amount_untaxed + amount_tax
def action_create_invoice(self):
if not self.sale_order_id and self.sale_order_id.invoice_status != 'to invoice':
raise UserError(
_("The selected Sales Order should contain something to invoice."
))
action = self.env.ref(
'sale.action_view_sale_advance_payment_inv').read()[0]
action['context'] = {'active_ids': self.sale_order_id.ids}
return action
class AccountAnalyticAccount(models.Model):
_name = 'account.analytic.account'
_inherit = ['mail.thread']
_description = 'Analytic Account'
_order = 'code, name asc'
@api.model
def read_group(self, domain, fields, groupby, offset=0, limit=None, orderby=False, lazy=True):
"""
Override read_group to calculate the sum of the non-stored fields that depend on the user context
"""
res = super(AccountAnalyticAccount, self).read_group(domain, fields, groupby, offset=offset, limit=limit, orderby=orderby, lazy=lazy)
accounts = self.env['account.analytic.account']
for line in res:
if '__domain' in line:
accounts = self.search(line['__domain'])
if 'balance' in fields:
line['balance'] = sum(accounts.mapped('balance'))
if 'debit' in fields:
line['debit'] = sum(accounts.mapped('debit'))
if 'credit' in fields:
line['credit'] = sum(accounts.mapped('credit'))
return res
@api.depends('line_ids.amount')
def _compute_debit_credit_balance(self):
Curr = self.env['res.currency']
analytic_line_obj = self.env['account.analytic.line']
domain = [('account_id', 'in', self.ids)]
if self._context.get('from_date', False):
domain.append(('date', '>=', self._context['from_date']))
if self._context.get('to_date', False):
domain.append(('date', '<=', self._context['to_date']))
if self._context.get('tag_ids'):
tag_domain = expression.OR([[('tag_ids', 'in', [tag])] for tag in self._context['tag_ids']])
domain = expression.AND([domain, tag_domain])
if self._context.get('company_ids'):
domain.append(('company_id', 'in', self._context['company_ids']))
user_currency = self.env.company.currency_id
credit_groups = analytic_line_obj.read_group(
domain=domain + [('amount', '>=', 0.0)],
fields=['account_id', 'currency_id', 'amount'],
groupby=['account_id', 'currency_id'],
lazy=False,
)
data_credit = defaultdict(float)
for l in credit_groups:
data_credit[l['account_id'][0]] += Curr.browse(l['currency_id'][0])._convert(
l['amount'], user_currency, self.env.company, fields.Date.today())
debit_groups = analytic_line_obj.read_group(
domain=domain + [('amount', '<', 0.0)],
fields=['account_id', 'currency_id', 'amount'],
groupby=['account_id', 'currency_id'],
lazy=False,
)
data_debit = defaultdict(float)
for l in debit_groups:
data_debit[l['account_id'][0]] += Curr.browse(l['currency_id'][0])._convert(
l['amount'], user_currency, self.env.company, fields.Date.today())
for account in self:
account.debit = abs(data_debit.get(account.id, 0.0))
account.credit = data_credit.get(account.id, 0.0)
account.balance = account.credit - account.debit
name = fields.Char(string='Analytic Account', index=True, required=True, tracking=True)
code = fields.Char(string='Reference', index=True, tracking=True)
active = fields.Boolean('Active', help="If the active field is set to False, it will allow you to hide the account without removing it.", default=True)
group_id = fields.Many2one('account.analytic.group', string='Group', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
line_ids = fields.One2many('account.analytic.line', 'account_id', string="Analytic Lines")
company_id = fields.Many2one('res.company', string='Company', default=lambda self: self.env.company)
# use auto_join to speed up name_search call
partner_id = fields.Many2one('res.partner', string='Customer', auto_join=True, tracking=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
balance = fields.Monetary(compute='_compute_debit_credit_balance', string='Balance')
debit = fields.Monetary(compute='_compute_debit_credit_balance', string='Debit')
credit = fields.Monetary(compute='_compute_debit_credit_balance', string='Credit')
currency_id = fields.Many2one(related="company_id.currency_id", string="Currency", readonly=True)
def name_get(self):
res = []
for analytic in self:
name = analytic.name
if analytic.code:
name = '[' + analytic.code + '] ' + name
if analytic.partner_id:
name = name + ' - ' + analytic.partner_id.commercial_partner_id.name
res.append((analytic.id, name))
return res
@api.model
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
if operator not in ('ilike', 'like', '=', '=like', '=ilike'):
return super(AccountAnalyticAccount, self)._name_search(name, args, operator, limit, name_get_uid=name_get_uid)
args = args or []
if operator == 'ilike' and not (name or '').strip():
domain = []
else:
# `partner_id` is in auto_join and the searches using ORs with auto_join fields doesn't work
# we have to cut the search in two searches ... https://github.com/coffice/coffice/issues/25175
partner_ids = self.env['res.partner']._search([('name', operator, name)], limit=limit, access_rights_uid=name_get_uid)
domain = ['|', '|', ('code', operator, name), ('name', operator, name), ('partner_id', 'in', partner_ids)]
analytic_account_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid)
return models.lazy_name_get(self.browse(analytic_account_ids).with_user(name_get_uid))
class ResPartner(models.Model):
_name = 'res.partner'
_inherit = 'res.partner'
@api.depends_context('force_company')
def _credit_debit_get(self):
tables, where_clause, where_params = self.env['account.move.line'].with_context(state='posted', company_id=self.env.company.id)._query_get()
where_params = [tuple(self.ids)] + where_params
if where_clause:
where_clause = 'AND ' + where_clause
self._cr.execute("""SELECT account_move_line.partner_id, act.type, SUM(account_move_line.amount_residual)
FROM """ + tables + """
LEFT JOIN account_account a ON (account_move_line.account_id=a.id)
LEFT JOIN account_account_type act ON (a.user_type_id=act.id)
WHERE act.type IN ('receivable','payable')
AND account_move_line.partner_id IN %s
AND account_move_line.reconciled IS FALSE
""" + where_clause + """
GROUP BY account_move_line.partner_id, act.type
""", where_params)
treated = self.browse()
for pid, type, val in self._cr.fetchall():
partner = self.browse(pid)
if type == 'receivable':
partner.credit = val
partner.debit = False
treated |= partner
elif type == 'payable':
partner.debit = -val
partner.credit = False
treated |= partner
remaining = (self - treated)
remaining.debit = False
remaining.credit = False
def _asset_difference_search(self, account_type, operator, operand):
if operator not in ('<', '=', '>', '>=', '<='):
return []
if type(operand) not in (float, int):
return []
sign = 1
if account_type == 'payable':
sign = -1
res = self._cr.execute('''
SELECT partner.id
FROM res_partner partner
LEFT JOIN account_move_line aml ON aml.partner_id = partner.id
JOIN account_move move ON move.id = aml.move_id
RIGHT JOIN account_account acc ON aml.account_id = acc.id
WHERE acc.internal_type = %s
AND NOT acc.deprecated AND acc.company_id = %s
AND move.state = 'posted'
GROUP BY partner.id
HAVING %s * COALESCE(SUM(aml.amount_residual), 0) ''' + operator + ''' %s''', (account_type, self.env.user.company_id.id, sign, operand))
res = self._cr.fetchall()
if not res:
return [('id', '=', '0')]
return [('id', 'in', [r[0] for r in res])]
@api.model
def _credit_search(self, operator, operand):
return self._asset_difference_search('receivable', operator, operand)
@api.model
def _debit_search(self, operator, operand):
return self._asset_difference_search('payable', operator, operand)
def _invoice_total(self):
account_invoice_report = self.env['account.invoice.report']
if not self.ids:
return True
user_currency_id = self.env.company.currency_id.id
all_partners_and_children = {}
all_partner_ids = []
for partner in self:
# price_total is in the company currency
all_partners_and_children[partner] = self.with_context(active_test=False).search([('id', 'child_of', partner.id)]).ids
all_partner_ids += all_partners_and_children[partner]
# searching account.invoice.report via the ORM is comparatively expensive
# (generates queries "id in []" forcing to build the full table).
# In simple cases where all invoices are in the same currency than the user's company
# access directly these elements
# generate where clause to include multicompany rules
where_query = account_invoice_report._where_calc([
('partner_id', 'in', all_partner_ids), ('state', 'not in', ['draft', 'cancel']),
('type', 'in', ('out_invoice', 'out_refund'))
])
account_invoice_report._apply_ir_rules(where_query, 'read')
from_clause, where_clause, where_clause_params = where_query.get_sql()
# price_total is in the company currency
query = """
SELECT SUM(price_subtotal) as total, partner_id
FROM account_invoice_report account_invoice_report
WHERE %s
GROUP BY partner_id
""" % where_clause
self.env.cr.execute(query, where_clause_params)
price_totals = self.env.cr.dictfetchall()
for partner, child_ids in all_partners_and_children.items():
partner.total_invoiced = sum(price['total'] for price in price_totals if price['partner_id'] in child_ids)
def _compute_journal_item_count(self):
AccountMoveLine = self.env['account.move.line']
for partner in self:
partner.journal_item_count = AccountMoveLine.search_count([('partner_id', '=', partner.id)])
def _compute_has_unreconciled_entries(self):
for partner in self:
# Avoid useless work if has_unreconciled_entries is not relevant for this partner
if not partner.active or not partner.is_company and partner.parent_id:
partner.has_unreconciled_entries = False
continue
self.env.cr.execute(
""" SELECT 1 FROM(
SELECT
p.last_time_entries_checked AS last_time_entries_checked,
MAX(l.write_date) AS max_date
FROM
account_move_line l
RIGHT JOIN account_account a ON (a.id = l.account_id)
RIGHT JOIN res_partner p ON (l.partner_id = p.id)
WHERE
p.id = %s
AND EXISTS (
SELECT 1
FROM account_move_line l
WHERE l.account_id = a.id
AND l.partner_id = p.id
AND l.amount_residual > 0
)
AND EXISTS (
SELECT 1
FROM account_move_line l
WHERE l.account_id = a.id
AND l.partner_id = p.id
AND l.amount_residual < 0
)
GROUP BY p.last_time_entries_checked
) as s
WHERE (last_time_entries_checked IS NULL OR max_date > last_time_entries_checked)
""", (partner.id,))
partner.has_unreconciled_entries = self.env.cr.rowcount == 1
def mark_as_reconciled(self):
self.env['account.partial.reconcile'].check_access_rights('write')
return self.sudo().with_context(company_id=self.env.company.id).write({'last_time_entries_checked': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)})
def _get_company_currency(self):
for partner in self:
if partner.company_id:
partner.currency_id = partner.sudo().company_id.currency_id
else:
partner.currency_id = self.env.company.currency_id
credit = fields.Monetary(compute='_credit_debit_get', search=_credit_search,
string='Total Receivable', help="Total amount this customer owes you.")
debit = fields.Monetary(compute='_credit_debit_get', search=_debit_search, string='Total Payable',
help="Total amount you have to pay to this vendor.")
debit_limit = fields.Monetary('Payable Limit')
total_invoiced = fields.Monetary(compute='_invoice_total', string="Total Invoiced",
groups='account.group_account_invoice')
currency_id = fields.Many2one('res.currency', compute='_get_company_currency', readonly=True,
string="Currency", help='Utility field to express amount currency')
journal_item_count = fields.Integer(compute='_compute_journal_item_count', string="Journal Items", type="integer")
property_account_payable_id = fields.Many2one('account.account', company_dependent=True,
string="Account Payable",
domain="[('internal_type', '=', 'payable'), ('deprecated', '=', False)]",
help="This account will be used instead of the default one as the payable account for the current partner",
required=True)
property_account_receivable_id = fields.Many2one('account.account', company_dependent=True,
string="Account Receivable",
domain="[('internal_type', '=', 'receivable'), ('deprecated', '=', False)]",
help="This account will be used instead of the default one as the receivable account for the current partner",
required=True)
property_account_position_id = fields.Many2one('account.fiscal.position', company_dependent=True,
string="Fiscal Position",
help="The fiscal position determines the taxes/accounts used for this contact.")
property_payment_term_id = fields.Many2one('account.payment.term', company_dependent=True,
string='Customer Payment Terms',
help="This payment term will be used instead of the default one for sales orders and customer invoices")
property_supplier_payment_term_id = fields.Many2one('account.payment.term', company_dependent=True,
string='Vendor Payment Terms',
help="This payment term will be used instead of the default one for purchase orders and vendor bills")
ref_company_ids = fields.One2many('res.company', 'partner_id',
string='Companies that refers to partner')
has_unreconciled_entries = fields.Boolean(compute='_compute_has_unreconciled_entries',
help="The partner has at least one unreconciled debit and credit since last time the invoices & payments matching was performed.")
last_time_entries_checked = fields.Datetime(
string='Latest Invoices & Payments Matching Date', readonly=True, copy=False,
help='Last time the invoices & payments matching was performed for this partner. '
'It is set either if there\'s not at least an unreconciled debit and an unreconciled credit '
'or if you click the "Done" button.')
invoice_ids = fields.One2many('account.move', 'partner_id', string='Invoices', readonly=True, copy=False)
contract_ids = fields.One2many('account.analytic.account', 'partner_id', string='Partner Contracts', readonly=True)
bank_account_count = fields.Integer(compute='_compute_bank_count', string="Bank")
trust = fields.Selection([('good', 'Good Debtor'), ('normal', 'Normal Debtor'), ('bad', 'Bad Debtor')], string='Degree of trust you have in this debtor', default='normal', company_dependent=True)
invoice_warn = fields.Selection(WARNING_MESSAGE, 'Invoice', help=WARNING_HELP, default="no-message")
invoice_warn_msg = fields.Text('Message for Invoice')
# Computed fields to order the partners as suppliers/customers according to the
# amount of their generated incoming/outgoing account moves
supplier_rank = fields.Integer(default=0)
customer_rank = fields.Integer(default=0)
def _get_name_search_order_by_fields(self):
res = super()._get_name_search_order_by_fields()
partner_search_mode = self.env.context.get('res_partner_search_mode')
if not partner_search_mode in ('customer', 'supplier'):
return res
order_by_field = 'COALESCE(res_partner.%s, 0) DESC,'
if partner_search_mode == 'customer':
field = 'customer_rank'
else:
field = 'supplier_rank'
order_by_field = order_by_field % field
return '%s, %s' % (res, order_by_field % field) if res else order_by_field
def _compute_bank_count(self):
bank_data = self.env['res.partner.bank'].read_group([('partner_id', 'in', self.ids)], ['partner_id'], ['partner_id'])
mapped_data = dict([(bank['partner_id'][0], bank['partner_id_count']) for bank in bank_data])
for partner in self:
partner.bank_account_count = mapped_data.get(partner.id, 0)
def _find_accounting_partner(self, partner):
''' Find the partner for which the accounting entries will be created '''
return partner.commercial_partner_id
@api.model
def _commercial_fields(self):
return super(ResPartner, self)._commercial_fields() + \
['debit_limit', 'property_account_payable_id', 'property_account_receivable_id', 'property_account_position_id',
'property_payment_term_id', 'property_supplier_payment_term_id', 'last_time_entries_checked']
def action_view_partner_invoices(self):
self.ensure_one()
action = self.env.ref('account.action_move_out_invoice_type').read()[0]
action['domain'] = [
('type', 'in', ('out_invoice', 'out_refund')),
('state', '=', 'posted'),
('partner_id', 'child_of', self.id),
]
action['context'] = {'default_type':'out_invoice', 'type':'out_invoice', 'journal_type': 'sale', 'search_default_unpaid': 1}
return action
@api.onchange('company_id')
def _onchange_company_id(self):
if self.company_id:
company = self.company_id
else:
company = self.env.company
return {'domain': {'property_account_position_id': [('company_id', 'in', [company.id, False])]}}
def can_edit_vat(self):
''' Can't edit `vat` if there is (non draft) issued invoices. '''
can_edit_vat = super(ResPartner, self).can_edit_vat()
if not can_edit_vat:
return can_edit_vat
has_invoice = self.env['account.move'].search([
('type', 'in', ['out_invoice', 'out_refund']),
('partner_id', 'child_of', self.commercial_partner_id.id),
('state', '=', 'posted')
], limit=1)
return can_edit_vat and not (bool(has_invoice))
@api.model_create_multi
def create(self, vals_list):
search_partner_mode = self.env.context.get('res_partner_search_mode')
is_customer = search_partner_mode == 'customer'
is_supplier = search_partner_mode == 'supplier'
if search_partner_mode:
for vals in vals_list:
if is_customer and 'customer_rank' not in vals:
vals['customer_rank'] = 1
elif is_supplier and 'supplier_rank' not in vals:
vals['supplier_rank'] = 1
return super().create(vals_list)
def _increase_rank(self, field):
if self.ids and field in ['customer_rank', 'supplier_rank']:
try:
with self.env.cr.savepoint():
query = sql.SQL("""
SELECT {field} FROM res_partner WHERE ID IN %(partner_ids)s FOR UPDATE NOWAIT;
UPDATE res_partner SET {field} = {field} + 1
WHERE id IN %(partner_ids)s
""").format(field=sql.Identifier(field))
self.env.cr.execute(query, {'partner_ids': tuple(self.ids)})
for partner in self:
self.env.cache.remove(partner, partner._fields[field])
except DatabaseError as e:
if e.pgcode == '55P03':
_logger.debug('Another transaction already locked partner rows. Cannot update partner ranks.')
else:
raise e
class CrmLead(models.Model):
_inherit = 'crm.lead'
sale_amount_total = fields.Monetary(compute='_compute_sale_data', string="Sum of Orders", help="Untaxed Total of Confirmed Orders", currency_field='company_currency')
quotation_count = fields.Integer(compute='_compute_sale_data', string="Number of Quotations")
sale_order_count = fields.Integer(compute='_compute_sale_data', string="Number of Sale Orders")
order_ids = fields.One2many('sale.order', 'opportunity_id', string='Orders')
@api.depends('order_ids.state', 'order_ids.currency_id', 'order_ids.amount_untaxed', 'order_ids.date_order', 'order_ids.company_id')
def _compute_sale_data(self):
for lead in self:
total = 0.0
quotation_cnt = 0
sale_order_cnt = 0
company_currency = lead.company_currency or self.env.company.currency_id
for order in lead.order_ids:
if order.state in ('draft', 'sent'):
quotation_cnt += 1
if order.state not in ('draft', 'sent', 'cancel'):
sale_order_cnt += 1
total += order.currency_id._convert(
order.amount_untaxed, company_currency, order.company_id, order.date_order or fields.Date.today())
lead.sale_amount_total = total
lead.quotation_count = quotation_cnt
lead.sale_order_count = sale_order_cnt
@api.model
def retrieve_sales_dashboard(self):
res = super(CrmLead, self).retrieve_sales_dashboard()
date_today = fields.Date.from_string(fields.Date.context_today(self))
res['invoiced'] = {
'this_month': 0,
'last_month': 0,
}
account_invoice_domain = [
('state', '=', 'posted'),
('invoice_user_id', '=', self.env.uid),
('invoice_date', '>=', date_today.replace(day=1) - relativedelta(months=+1)),
('type', 'in', ['out_invoice', 'out_refund'])
]
invoice_data = self.env['account.move'].search_read(account_invoice_domain, ['invoice_date', 'amount_untaxed', 'type'])
for invoice in invoice_data:
if invoice['invoice_date']:
invoice_date = fields.Date.from_string(invoice['invoice_date'])
sign = 1 if invoice['type'] == 'out_invoice' else -1
if invoice_date <= date_today and invoice_date >= date_today.replace(day=1):
res['invoiced']['this_month'] += sign * invoice['amount_untaxed']
elif invoice_date < date_today.replace(day=1) and invoice_date >= date_today.replace(day=1) - relativedelta(months=+1):
res['invoiced']['last_month'] += sign * invoice['amount_untaxed']
res['invoiced']['target'] = self.env.user.target_sales_invoiced
return res
def action_sale_quotations_new(self):
if not self.partner_id:
return self.env.ref("sale_crm.crm_quotation_partner_action").read()[0]
else:
return self.action_new_quotation()
def action_new_quotation(self):
action = self.env.ref("sale_crm.sale_action_quotations_new").read()[0]
action['context'] = {
'search_default_opportunity_id': self.id,
'default_opportunity_id': self.id,
'search_default_partner_id': self.partner_id.id,
'default_partner_id': self.partner_id.id,
'default_team_id': self.team_id.id,
'default_campaign_id': self.campaign_id.id,
'default_medium_id': self.medium_id.id,
'default_origin': self.name,
'default_source_id': self.source_id.id,
'default_company_id': self.company_id.id or self.env.company.id,
}
return action
def action_view_sale_quotation(self):
action = self.env.ref('sale.action_quotations_with_onboarding').read()[0]
action['context'] = {
'search_default_draft': 1,
'search_default_partner_id': self.partner_id.id,
'default_partner_id': self.partner_id.id,
'default_opportunity_id': self.id
}
action['domain'] = [('opportunity_id', '=', self.id), ('state', 'in', ['draft', 'sent'])]
quotations = self.mapped('order_ids').filtered(lambda l: l.state in ('draft', 'sent'))
if len(quotations) == 1:
action['views'] = [(self.env.ref('sale.view_order_form').id, 'form')]
action['res_id'] = quotations.id
return action
def action_view_sale_order(self):
action = self.env.ref('sale.action_orders').read()[0]
action['context'] = {
'search_default_partner_id': self.partner_id.id,
'default_partner_id': self.partner_id.id,
'default_opportunity_id': self.id,
}
action['domain'] = [('opportunity_id', '=', self.id), ('state', 'not in', ('draft', 'sent', 'cancel'))]
orders = self.mapped('order_ids').filtered(lambda l: l.state not in ('draft', 'sent', 'cancel'))
if len(orders) == 1:
action['views'] = [(self.env.ref('sale.view_order_form').id, 'form')]
action['res_id'] = orders.id
return action
