class StockValuationLayer(models.Model):
"""Stock Valuation Layer"""
_name = 'stock.valuation.layer'
_description = 'Stock Valuation Layer'
_order = 'create_date, id'
_rec_name = 'product_id'
active = fields.Boolean(related='product_id.active')
company_id = fields.Many2one('res.company',
'Company',
readonly=True,
required=True)
product_id = fields.Many2one('product.product',
'Product',
readonly=True,
required=True,
check_company=True)
categ_id = fields.Many2one('product.category',
related='product_id.categ_id')
product_tmpl_id = fields.Many2one('product.template',
related='product_id.product_tmpl_id')
quantity = fields.Float('Quantity',
digits=0,
help='Quantity',
readonly=True)
uom_id = fields.Many2one(related='product_id.uom_id',
readonly=True,
required=True)
currency_id = fields.Many2one('res.currency',
'Currency',
related='company_id.currency_id',
readonly=True,
required=True)
unit_cost = fields.Monetary('Unit Value', readonly=True)
value = fields.Monetary('Total Value', readonly=True)
remaining_qty = fields.Float(digits=0, readonly=True)
remaining_value = fields.Monetary('Remaining Value', readonly=True)
description = fields.Char('Description', readonly=True)
stock_valuation_layer_id = fields.Many2one('stock.valuation.layer',
'Linked To',
readonly=True,
check_company=True)
stock_valuation_layer_ids = fields.One2many('stock.valuation.layer',
'stock_valuation_layer_id')
stock_move_id = fields.Many2one('stock.move',
'Stock Move',
readonly=True,
check_company=True)
account_move_id = fields.Many2one('account.move',
'Journal Entry',
readonly=True,
check_company=True)
class Digest(models.Model):
_inherit = 'digest.digest'
kpi_pos_total = fields.Boolean('POS Sales')
kpi_pos_total_value = fields.Monetary(
compute='_compute_kpi_pos_total_value')
def _compute_kpi_pos_total_value(self):
if not self.env.user.has_group('point_of_sale.group_pos_user'):
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()
record.kpi_pos_total_value = sum(self.env['pos.order'].search([
('date_order', '>=', start), ('date_order', '<', end),
('state', 'not in', ['draft', 'cancel', 'invoiced']),
('company_id', '=', company.id)
]).mapped('amount_total'))
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_pos_total'] = 'point_of_sale.action_pos_sale_graph&menu_id=%s' % self.env.ref(
'point_of_sale.menu_point_root').id
return res
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()
account_moves = self.env['account.move'].read_group(
[('journal_id.type', '=', 'sale'),
('company_id', '=', company.id), ('date', '>=', start),
('date', '<', end)], ['journal_id', 'amount'], ['journal_id'])
record.kpi_account_total_revenue_value = sum(
[account_move['amount'] for account_move in account_moves])
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_account_total_revenue'] = 'account.action_invoice_tree1&menu_id=%s' % self.env.ref(
'account.menu_finance').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')
account_id = fields.Many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='restrict', index=True)
partner_id = fields.Many2one('res.partner', string='Partner')
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)
company_id = fields.Many2one('res.company', string='Company', required=True, readonly=True, default=lambda self: self.env.user.company_id)
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.multi
@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 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 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 FloatModel(models.Model):
_name = name('float')
_description = 'Tests: Base Import Model Float'
value = fields.Float()
value2 = fields.Monetary()
currency_id = fields.Many2one('res.currency')
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 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 HrEmployee(models.Model):
_inherit = 'hr.employee'
timesheet_cost = fields.Monetary('Timesheet Cost',
currency_field='currency_id',
default=0.0)
currency_id = fields.Many2one('res.currency',
related='company_id.currency_id',
readonly=True)
class ComplexModel(models.Model):
_name = name('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 accountInvoice(models.Model):
_inherit = 'account.invoice'
balance = fields.Monetary("Balance",
coumpute='get_party_balance',
store="True")
@api.onchange('partner_id')
def get_party_balance(self):
for rec in self:
if rec.partner_id:
rec.balance = self.partner_id.balance
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 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 ReportJournalLedgerMoveLine(models.TransientModel):
_name = 'report_journal_ledger_move_line'
_inherit = 'account_financial_report_abstract'
_order = 'partner_id desc, account_id desc'
report_id = fields.Many2one(comodel_name='report_journal_ledger',
required=True,
ondelete='cascade')
report_journal_ledger_id = fields.Many2one(
comodel_name='report_journal_ledger_journal',
required=True,
ondelete='cascade',
)
report_move_id = fields.Many2one(
comodel_name='report_journal_ledger_move',
required=True,
ondelete='cascade',
)
move_line_id = fields.Many2one(
comodel_name='account.move.line',
required=True,
ondelete='cascade',
)
account_id = fields.Many2one(
comodel_name='account.account',
string='Account ID',
)
account = fields.Char()
account_code = fields.Char()
account_type = fields.Char()
partner = fields.Char()
partner_id = fields.Many2one(
comodel_name='res.partner',
string='Partner ID',
)
date = fields.Date()
entry = fields.Char()
label = fields.Char()
debit = fields.Float(digits=DIGITS, )
credit = fields.Float(digits=DIGITS, )
company_currency_id = fields.Many2one(comodel_name='res.currency', )
amount_currency = fields.Monetary(currency_field='currency_id', )
currency_id = fields.Many2one(comodel_name='res.currency', )
currency_name = fields.Char()
taxes_description = fields.Char()
tax_id = fields.Many2one(comodel_name='account.tax')
company_id = fields.Many2one(comodel_name='res.company',
required=True,
ondelete='cascade')
class CrmLead(models.Model):
_inherit = 'crm.lead'
sale_amount_total = fields.Monetary(compute='_compute_sale_amount_total', string="Sum of Orders", help="Untaxed Total of Confirmed Orders", currency_field='company_currency')
sale_number = fields.Integer(compute='_compute_sale_amount_total', string="Number of Quotations")
order_ids = fields.One2many('sale.order', 'opportunity_id', string='Orders')
@api.depends('order_ids')
def _compute_sale_amount_total(self):
for lead in self:
total = 0.0
nbr = 0
company_currency = lead.company_currency or self.env.user.company_id.currency_id
for order in lead.order_ids:
if order.state in ('draft', 'sent'):
nbr += 1
if order.state not in ('draft', 'sent', 'cancel'):
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.sale_number = nbr
@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', 'in', ['open', 'in_payment', 'paid']),
('user_id', '=', self.env.uid),
('date_invoice', '>=', date_today.replace(day=1) - relativedelta(months=+1)),
('type', 'in', ['out_invoice', 'out_refund'])
]
invoice_data = self.env['account.invoice'].search_read(account_invoice_domain, ['date_invoice', 'amount_untaxed_signed'])
for invoice in invoice_data:
if invoice['date_invoice']:
invoice_date = fields.Date.from_string(invoice['date_invoice'])
if invoice_date <= date_today and invoice_date >= date_today.replace(day=1):
res['invoiced']['this_month'] += invoice['amount_untaxed_signed']
elif invoice_date < date_today.replace(day=1) and invoice_date >= date_today.replace(day=1) - relativedelta(months=+1):
res['invoiced']['last_month'] += invoice['amount_untaxed_signed']
res['invoiced']['target'] = self.env.user.target_sales_invoiced
return res
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 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([
('confirmation_date', '>=', start),
('confirmation_date', '<', end),
('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 CrmClaim(models.Model):
_inherit = 'crm.claim'
analytic_account_id = fields.Many2one(
comodel_name='account.analytic.account', string='Analytic Account')
analytic_amount = fields.Monetary(string='Amount',
compute='_compute_analytic_amount')
currency_id = fields.Many2one(related='company_id.currency_id',
string='Currency',
readonly=True,
store=True,
compute_sudo=True)
@api.multi
def _compute_analytic_amount(self):
line_obj = self.env['account.analytic.line']
for claim in self:
lines = line_obj.search([('claim_id', '=', claim.id)])
claim.analytic_amount = sum(lines.mapped('amount'))
@api.multi
def button_account_analytic_line_action(self):
self.ensure_one()
action = self.env.ref('analytic.account_analytic_line_action_entries')
action_dict = action.read()[0] if action else {}
action_dict['context'] = safe_eval(action_dict.get('context', '{}'),
{'datetime': datetime})
action_dict['context'].update({
'search_default_claim_id':
self.id,
'default_claim_id':
self.id,
'default_account_id':
self.analytic_account_id.id,
})
domain = expression.AND([[('account_id', '=',
self.analytic_account_id.id)],
safe_eval(action.domain or '[]')])
action_dict.update({'domain': domain})
return action_dict
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_website_sale_total = fields.Boolean('eCommerce Sales')
kpi_website_sale_total_value = fields.Monetary(compute='_compute_kpi_website_sale_total_value')
def _compute_kpi_website_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()
confirmed_website_sales = self.env['sale.order'].search([
('date_order', '>=', start),
('date_order', '<', end),
('state', 'not in', ['draft', 'cancel', 'sent']),
('website_id', '!=', False),
('company_id', '=', company.id)
])
record.kpi_website_sale_total_value = sum(confirmed_website_sales.mapped('amount_total'))
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_website_sale_total'] = 'website.backend_dashboard&menu_id=%s' % self.env.ref('website.menu_website_configuration').id
return res
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 PosSession(models.Model):
_name = 'pos.session'
_order = 'id desc'
_description = 'Point of Sale Session'
POS_SESSION_STATE = [
('opening_control',
'Opening Control'), # method action_pos_session_open
('opened', 'In Progress'), # method action_pos_session_closing_control
('closing_control',
'Closing Control'), # method action_pos_session_close
('closed', 'Closed & Posted'),
]
def _confirm_orders(self):
for session in self:
company_id = session.config_id.journal_id.company_id.id
orders = session.order_ids.filtered(
lambda order: order.state == 'paid')
journal_id = self.env['ir.config_parameter'].sudo().get_param(
'pos.closing.journal_id_%s' % company_id,
default=session.config_id.journal_id.id)
if not journal_id:
raise UserError(
_("You have to set a Sale Journal for the POS:%s") %
(session.config_id.name, ))
move = self.env['pos.order'].with_context(
force_company=company_id)._create_account_move(
session.start_at, session.name, int(journal_id),
company_id)
orders.with_context(
force_company=company_id)._create_account_move_line(
session, move)
for order in session.order_ids.filtered(
lambda o: o.state not in ['done', 'invoiced']):
if order.state not in ('paid'):
raise UserError(
_("You cannot confirm all orders of this session, because they have not the 'paid' status.\n"
"{reference} is in state {state}, total amount: {total}, paid: {paid}"
).format(
reference=order.pos_reference or order.name,
state=order.state,
total=order.amount_total,
paid=order.amount_paid,
))
order.action_pos_order_done()
orders_to_reconcile = session.order_ids._filtered_for_reconciliation(
)
orders_to_reconcile.sudo()._reconcile_payments()
config_id = fields.Many2one(
'pos.config',
string='Point of Sale',
help="The physical point of sale you will use.",
required=True,
index=True)
name = fields.Char(string='Session ID',
required=True,
readonly=True,
default='/')
user_id = fields.Many2one(
'res.users',
string='Responsible',
required=True,
index=True,
readonly=True,
states={'opening_control': [('readonly', False)]},
default=lambda self: self.env.uid)
currency_id = fields.Many2one('res.currency',
related='config_id.currency_id',
string="Currency",
readonly=False)
start_at = fields.Datetime(string='Opening Date', readonly=True)
stop_at = fields.Datetime(string='Closing Date', readonly=True, copy=False)
state = fields.Selection(POS_SESSION_STATE,
string='Status',
required=True,
readonly=True,
index=True,
copy=False,
default='opening_control')
sequence_number = fields.Integer(
string='Order Sequence Number',
help='A sequence number that is incremented with each order',
default=1)
login_number = fields.Integer(
string='Login Sequence Number',
help=
'A sequence number that is incremented each time a user resumes the pos session',
default=0)
cash_control = fields.Boolean(compute='_compute_cash_all',
string='Has Cash Control')
cash_journal_id = fields.Many2one('account.journal',
compute='_compute_cash_all',
string='Cash Journal',
store=True)
cash_register_id = fields.Many2one('account.bank.statement',
compute='_compute_cash_all',
string='Cash Register',
store=True)
cash_register_balance_end_real = fields.Monetary(
related='cash_register_id.balance_end_real',
string="Ending Balance",
help="Total of closing cash control lines.",
readonly=True)
cash_register_balance_start = fields.Monetary(
related='cash_register_id.balance_start',
string="Starting Balance",
help="Total of opening cash control lines.",
readonly=True)
cash_register_total_entry_encoding = fields.Monetary(
related='cash_register_id.total_entry_encoding',
string='Total Cash Transaction',
readonly=True,
help="Total of all paid sales orders")
cash_register_balance_end = fields.Monetary(
related='cash_register_id.balance_end',
digits=0,
string="Theoretical Closing Balance",
help="Sum of opening balance and transactions.",
readonly=True)
cash_register_difference = fields.Monetary(
related='cash_register_id.difference',
string='Difference',
help=
"Difference between the theoretical closing balance and the real closing balance.",
readonly=True)
journal_ids = fields.Many2many('account.journal',
related='config_id.journal_ids',
readonly=True,
string='Available Payment Methods')
order_ids = fields.One2many('pos.order', 'session_id', string='Orders')
statement_ids = fields.One2many('account.bank.statement',
'pos_session_id',
string='Bank Statement',
readonly=True)
picking_count = fields.Integer(compute='_compute_picking_count')
rescue = fields.Boolean(
string='Recovery Session',
help="Auto-generated session for orphan orders, ignored in constraints",
readonly=True,
copy=False)
_sql_constraints = [('uniq_name', 'unique(name)',
"The name of this POS Session must be unique !")]
@api.multi
def _compute_picking_count(self):
for pos in self:
pickings = pos.order_ids.mapped('picking_id').filtered(
lambda x: x.state != 'done')
pos.picking_count = len(pickings.ids)
@api.multi
def action_stock_picking(self):
pickings = self.order_ids.mapped('picking_id').filtered(
lambda x: x.state != 'done')
action_picking = self.env.ref('stock.action_picking_tree_ready')
action = action_picking.read()[0]
action['context'] = {}
action['domain'] = [('id', 'in', pickings.ids)]
return action
@api.depends('config_id', 'statement_ids')
def _compute_cash_all(self):
for session in self:
session.cash_journal_id = session.cash_register_id = session.cash_control = False
if session.config_id.cash_control:
for statement in session.statement_ids:
if statement.journal_id.type == 'cash':
session.cash_control = True
session.cash_journal_id = statement.journal_id.id
session.cash_register_id = statement.id
if not session.cash_control and session.state != 'closed':
raise UserError(
_("Cash control can only be applied to cash journals.")
)
@api.constrains('user_id', 'state')
def _check_unicity(self):
# open if there is no session in 'opening_control', 'opened', 'closing_control' for one user
if self.search_count([('state', 'not in',
('closed', 'closing_control')),
('user_id', '=', self.user_id.id),
('rescue', '=', False)]) > 1:
raise ValidationError(
_("You cannot create two active sessions with the same responsible."
))
@api.constrains('config_id')
def _check_pos_config(self):
if self.search_count([('state', '!=', 'closed'),
('config_id', '=', self.config_id.id),
('rescue', '=', False)]) > 1:
raise ValidationError(
_("Another session is already opened for this point of sale."))
@api.model
def create(self, values):
config_id = values.get('config_id') or self.env.context.get(
'default_config_id')
if not config_id:
raise UserError(
_("You should assign a Point of Sale to your session."))
# journal_id is not required on the pos_config because it does not
# exists at the installation. If nothing is configured at the
# installation we do the minimal configuration. Impossible to do in
# the .xml files as the CoA is not yet installed.
pos_config = self.env['pos.config'].browse(config_id)
ctx = dict(self.env.context, company_id=pos_config.company_id.id)
if not pos_config.journal_id:
default_journals = pos_config.with_context(ctx).default_get(
['journal_id', 'invoice_journal_id'])
if (not default_journals.get('journal_id')
or not default_journals.get('invoice_journal_id')):
raise UserError(
_("Unable to open the session. You have to assign a sales journal to your point of sale."
))
pos_config.with_context(ctx).sudo().write({
'journal_id':
default_journals['journal_id'],
'invoice_journal_id':
default_journals['invoice_journal_id']
})
# define some cash journal if no payment method exists
if not pos_config.journal_ids:
Journal = self.env['account.journal']
journals = Journal.with_context(ctx).search([
('journal_user', '=', True), ('type', '=', 'cash')
])
if not journals:
journals = Journal.with_context(ctx).search([('type', '=',
'cash')])
if not journals:
journals = Journal.with_context(ctx).search([
('journal_user', '=', True)
])
if not journals:
raise ValidationError(
_("No payment method configured! \nEither no Chart of Account is installed or no payment method is configured for this POS."
))
journals.sudo().write({'journal_user': True})
pos_config.sudo().write({'journal_ids': [(6, 0, journals.ids)]})
pos_name = self.env['ir.sequence'].with_context(ctx).next_by_code(
'pos.session')
if values.get('name'):
pos_name += ' ' + values['name']
statements = []
ABS = self.env['account.bank.statement']
uid = SUPERUSER_ID if self.env.user.has_group(
'point_of_sale.group_pos_user') else self.env.user.id
for journal in pos_config.journal_ids:
# set the journal_id which should be used by
# account.bank.statement to set the opening balance of the
# newly created bank statement
ctx['journal_id'] = journal.id if pos_config.cash_control and journal.type == 'cash' else False
st_values = {
'journal_id':
journal.id,
'user_id':
self.env.user.id,
'name':
pos_name,
'balance_start':
self.env["account.bank.statement"]._get_opening_balance(
journal.id) if journal.type == 'cash' else 0
}
statements.append(
ABS.with_context(ctx).sudo(uid).create(st_values).id)
values.update({
'name': pos_name,
'statement_ids': [(6, 0, statements)],
'config_id': config_id
})
res = super(PosSession,
self.with_context(ctx).sudo(uid)).create(values)
if not pos_config.cash_control:
res.action_pos_session_open()
return res
@api.multi
def unlink(self):
for session in self.filtered(lambda s: s.statement_ids):
session.statement_ids.unlink()
return super(PosSession, self).unlink()
@api.multi
def login(self):
self.ensure_one()
self.write({
'login_number': self.login_number + 1,
})
@api.multi
def action_pos_session_open(self):
# second browse because we need to refetch the data from the DB for cash_register_id
# we only open sessions that haven't already been opened
for session in self.filtered(
lambda session: session.state == 'opening_control'):
values = {}
if not session.start_at:
values['start_at'] = fields.Datetime.now()
values['state'] = 'opened'
session.write(values)
session.statement_ids.button_open()
return True
@api.multi
def action_pos_session_closing_control(self):
self._check_pos_session_balance()
for session in self:
session.write({
'state': 'closing_control',
'stop_at': fields.Datetime.now()
})
if not session.config_id.cash_control:
session.action_pos_session_close()
@api.multi
def _check_pos_session_balance(self):
for session in self:
for statement in session.statement_ids:
if (statement != session.cash_register_id) and (
statement.balance_end != statement.balance_end_real):
statement.write(
{'balance_end_real': statement.balance_end})
@api.multi
def action_pos_session_validate(self):
self._check_pos_session_balance()
self.action_pos_session_close()
@api.multi
def action_pos_session_close(self):
# Close CashBox
for session in self:
company_id = session.config_id.company_id.id
ctx = dict(self.env.context,
force_company=company_id,
company_id=company_id)
ctx_notrack = dict(ctx, mail_notrack=True)
for st in session.statement_ids:
if abs(st.difference) > st.journal_id.amount_authorized_diff:
# The pos manager can close statements with maximums.
if not self.user_has_groups(
"point_of_sale.group_pos_manager"):
raise UserError(
_("Your ending balance is too different from the theoretical cash closing (%.2f), the maximum allowed is: %.2f. You can contact your manager to force it."
) % (st.difference,
st.journal_id.amount_authorized_diff))
if (st.journal_id.type not in ['bank', 'cash']):
raise UserError(
_("The journal type for your payment method should be bank or cash."
))
st.with_context(ctx_notrack).sudo().button_confirm_bank()
self.with_context(ctx)._confirm_orders()
self.write({'state': 'closed'})
return {
'type': 'ir.actions.client',
'name': 'Point of Sale Menu',
'tag': 'reload',
'params': {
'menu_id': self.env.ref('point_of_sale.menu_point_root').id
},
}
@api.multi
def open_frontend_cb(self):
if not self.ids:
return {}
for session in self.filtered(lambda s: s.user_id.id != self.env.uid):
raise UserError(
_("You cannot use the session of another user. This session is owned by %s. "
"Please first close this one to use this point of sale.") %
session.user_id.name)
return {
'type': 'ir.actions.act_url',
'target': 'self',
'url': '/pos/web/',
}
@api.multi
def open_cashbox(self):
self.ensure_one()
context = dict(self._context)
balance_type = context.get('balance') or 'start'
context['bank_statement_id'] = self.cash_register_id.id
context['balance'] = balance_type
context['default_pos_id'] = self.config_id.id
action = {
'name': _('Cash Control'),
'view_type': 'form',
'view_mode': 'form',
'res_model': 'account.bank.statement.cashbox',
'view_id':
self.env.ref('account.view_account_bnk_stmt_cashbox').id,
'type': 'ir.actions.act_window',
'context': context,
'target': 'new'
}
cashbox_id = None
if balance_type == 'start':
cashbox_id = self.cash_register_id.cashbox_start_id.id
else:
cashbox_id = self.cash_register_id.cashbox_end_id.id
if cashbox_id:
action['res_id'] = cashbox_id
return action
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 account_abstract_payment(models.AbstractModel):
_name = "account.abstract.payment"
_description = "Contains the logic shared between models which allows to register payments"
invoice_ids = fields.Many2many('account.invoice',
string='Invoices',
copy=False)
multi = fields.Boolean(
string='Multi',
help=
'Technical field indicating if the user selected invoices from multiple partners or from different types.'
)
payment_type = fields.Selection([('outbound', 'Send Money'),
('inbound', 'Receive Money')],
string='Payment Type',
required=True)
payment_method_id = fields.Many2one('account.payment.method', string='Payment Method Type', required=True, oldname="payment_method",
help="Manual: Get paid by cash, check or any other method outside of Eagle.\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 Eagle.\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 Eagle, 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')])
partner_id = fields.Many2one('res.partner', string='Partner')
amount = fields.Monetary(string='Payment Amount', required=True)
currency_id = fields.Many2one(
'res.currency',
string='Currency',
required=True,
default=lambda self: self.env.user.company_id.currency_id)
payment_date = fields.Date(string='Payment Date',
default=fields.Date.context_today,
required=True,
copy=False)
communication = fields.Char(string='Memo')
journal_id = fields.Many2one('account.journal',
string='Payment Journal',
required=True,
domain=[('type', 'in', ('bank', 'cash'))])
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)],
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")
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'
)
@api.model
def default_get(self, fields):
rec = super(account_abstract_payment, self).default_get(fields)
active_ids = self._context.get('active_ids')
active_model = self._context.get('active_model')
# Check for selected invoices ids
if not active_ids or active_model != 'account.invoice':
return rec
invoices = self.env['account.invoice'].browse(active_ids)
# Check all invoices are open
if any(invoice.state != 'open' for invoice in invoices):
raise UserError(
_("You can only register payments for open invoices"))
# Check all invoices have the same currency
if any(inv.currency_id != invoices[0].currency_id for inv in invoices):
raise UserError(
_("In order to pay multiple invoices at once, they must use the same currency."
))
# 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."
))
# Look if we are mixin multiple commercial_partner or customer invoices with vendor bills
multi = any(
inv.commercial_partner_id != invoices[0].commercial_partner_id
or MAP_INVOICE_TYPE_PARTNER_TYPE[
inv.type] != MAP_INVOICE_TYPE_PARTNER_TYPE[invoices[0].type]
or inv.account_id != invoices[0].account_id
or inv.partner_bank_id != invoices[0].partner_bank_id
for inv in invoices)
currency = invoices[0].currency_id
total_amount = self._compute_payment_amount(invoices=invoices,
currency=currency)
rec.update({
'amount':
abs(total_amount),
'currency_id':
currency.id,
'payment_type':
total_amount > 0 and 'inbound' or 'outbound',
'partner_id':
False if multi else invoices[0].commercial_partner_id.id,
'partner_type':
False
if multi else MAP_INVOICE_TYPE_PARTNER_TYPE[invoices[0].type],
'communication':
' '.join([ref for ref in invoices.mapped('reference')
if ref])[:2000],
'invoice_ids': [(6, 0, invoices.ids)],
'multi':
multi,
})
return rec
@api.one
@api.constrains('amount')
def _check_amount(self):
if self.amount < 0:
raise ValidationError(_('The payment amount cannot be negative.'))
@api.model
def _get_method_codes_using_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(
) and not self.multi
@api.multi
@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')
def _compute_payment_difference(self):
for pay in self.filtered(lambda p: p.invoice_ids):
payment_amount = -pay.amount if pay.payment_type == 'outbound' else pay.amount
pay.payment_difference = pay._compute_payment_amount(
) - payment_amount
@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.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'
return {
'domain': {
'payment_method_id': [('payment_type', '=', payment_type),
('id', 'in', payment_methods_list)]
}
}
return {}
@api.onchange('partner_id')
def _onchange_partner_id(self):
if not self.multi and self.invoice_ids and self.invoice_ids[
0].partner_bank_id:
self.partner_bank_account_id = self.invoice_ids[0].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
])]
}
}
def _compute_journal_domain_and_types(self):
journal_type = ['bank', 'cash']
domain = []
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.journal_id.type not in journal_types:
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())
# Set by default the first liquidity journal having this currency if exists.
if self.journal_id:
return
journal = self.env['account.journal'].search(
[('type', 'in', ('bank', 'cash')),
('currency_id', '=', self.currency_id.id)],
limit=1)
if journal:
return {'value': {'journal_id': journal.id}}
@api.multi
def _compute_payment_amount(self, invoices=None, currency=None):
'''Compute the total amount for the payment wizard.
:param invoices: If not specified, pick all the invoices.
:param currency: If not specified, search a default currency on wizard/journal.
:return: The total amount to pay the invoices.
'''
# Get the payment invoices
if not invoices:
invoices = self.invoice_ids
# Get the payment currency
if not currency:
currency = self.currency_id or self.journal_id.currency_id or self.journal_id.company_id.currency_id or invoices and invoices[
0].currency_id
# Avoid currency rounding issues by summing the amounts according to the company_currency_id before
invoice_datas = invoices.read_group(
[('id', 'in', invoices.ids)],
['currency_id', 'type', 'residual_signed'],
['currency_id', 'type'],
lazy=False)
total = 0.0
for invoice_data in invoice_datas:
amount_total = MAP_INVOICE_TYPE_PAYMENT_SIGN[
invoice_data['type']] * invoice_data['residual_signed']
payment_currency = self.env['res.currency'].browse(
invoice_data['currency_id'][0])
if payment_currency == currency:
total += amount_total
else:
total += payment_currency._convert(
amount_total, currency, self.env.user.company_id,
self.payment_date or fields.Date.today())
return total
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 Eagle 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 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 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 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
