400 lines
16 KiB
Python
400 lines
16 KiB
Python
# Copyright 2011-2016 Akretion
|
|
# Copyright 2011-2019 Camptocamp SA
|
|
# Copyright 2013 Savoir-faire Linux
|
|
# Copyright 2014 ACSONE SA/NV
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html)
|
|
import os
|
|
import sys
|
|
import traceback
|
|
|
|
from odoo import _, fields, models
|
|
from odoo.exceptions import UserError, ValidationError
|
|
|
|
from ..parser.parser import new_move_parser
|
|
|
|
|
|
class AccountJournal(models.Model):
|
|
_name = "account.journal"
|
|
_inherit = ["account.journal", "mail.thread"]
|
|
_order = "sequence"
|
|
|
|
used_for_import = fields.Boolean(string="Journal used for import")
|
|
|
|
commission_account_id = fields.Many2one(
|
|
comodel_name="account.account", string="Commission account"
|
|
)
|
|
|
|
import_type = fields.Selection(
|
|
[("generic_csvxls_so", "Generic .csv/.xls based on SO Name")],
|
|
string="Type of import",
|
|
default="generic_csvxls_so",
|
|
help="Choose here the method by which you want to import account "
|
|
"moves for this journal.",
|
|
)
|
|
|
|
last_import_date = fields.Datetime()
|
|
|
|
partner_id = fields.Many2one(
|
|
comodel_name="res.partner",
|
|
string="Bank/Payment Office partner",
|
|
help="Put a partner if you want to have it on the commission move "
|
|
"(and optionaly on the counterpart of the intermediate/"
|
|
"banking move if you tick the corresponding checkbox).",
|
|
)
|
|
|
|
receivable_account_id = fields.Many2one(
|
|
comodel_name="account.account",
|
|
string="Receivable/Payable Account",
|
|
help="Choose a receivable/payable account to use as the default "
|
|
"debit/credit account.",
|
|
)
|
|
|
|
used_for_completion = fields.Boolean(string="Journal used for completion")
|
|
|
|
rule_ids = fields.Many2many(
|
|
comodel_name="account.move.completion.rule",
|
|
string="Auto-completion rules",
|
|
relation="account_journal_completion_rule_rel",
|
|
)
|
|
|
|
launch_import_completion = fields.Boolean(
|
|
string="Launch completion after import",
|
|
help="Tick that box to automatically launch the completion "
|
|
"on each imported file using this journal.",
|
|
)
|
|
|
|
create_counterpart = fields.Boolean(
|
|
help="Tick that box to automatically create the move counterpart",
|
|
default=True,
|
|
)
|
|
|
|
split_counterpart = fields.Boolean(
|
|
help="Two counterparts will be automatically created : one for "
|
|
"the refunds and one for the payments",
|
|
)
|
|
|
|
commission_analytic_account_id = fields.Many2one(
|
|
comodel_name="account.analytic.account",
|
|
string="Commission Analytic Account",
|
|
help="Choose an analytic account to be used on the commission line.",
|
|
)
|
|
autovalidate_completed_move = fields.Boolean(
|
|
string="Validate fully completed moves",
|
|
help="Tick that box to automatically validate the journal entries "
|
|
"after the completion",
|
|
)
|
|
|
|
def _prepare_counterpart_line(self, move, amount, date):
|
|
if amount > 0.0:
|
|
account_id = self.default_account_id.id
|
|
credit = 0.0
|
|
debit = amount
|
|
else:
|
|
account_id = self.default_account_id.id
|
|
credit = -amount
|
|
debit = 0.0
|
|
counterpart_values = {
|
|
"date_maturity": date,
|
|
"credit": credit,
|
|
"debit": debit,
|
|
"partner_id": self.partner_id.id,
|
|
"move_id": move.id,
|
|
"account_id": account_id,
|
|
"already_completed": True,
|
|
"journal_id": self.id,
|
|
"company_id": self.company_id.id,
|
|
"currency_id": self.currency_id.id or move.currency_id.id,
|
|
"company_currency_id": self.company_id.currency_id.id,
|
|
"amount_residual": amount,
|
|
}
|
|
return counterpart_values
|
|
|
|
def _get_counterpart_vals_list(self, parser, move, line_vals_list):
|
|
refund = 0.0
|
|
payment = 0.0
|
|
commission = 0.0
|
|
transfer_lines = []
|
|
for move_line_vals in line_vals_list:
|
|
if move_line_vals[
|
|
"account_id"
|
|
] == self.commission_account_id.id and move_line_vals.get(
|
|
"already_completed"
|
|
):
|
|
commission -= move_line_vals["debit"]
|
|
else:
|
|
refund -= move_line_vals["debit"]
|
|
payment += move_line_vals["credit"]
|
|
if self.split_counterpart:
|
|
if refund:
|
|
transfer_lines.append(refund)
|
|
if payment:
|
|
transfer_lines.append(payment + commission)
|
|
else:
|
|
total_amount = refund + payment + commission
|
|
if total_amount:
|
|
transfer_lines.append(total_amount)
|
|
counterpart_date = parser.get_move_vals().get("date") or fields.Date.today()
|
|
transfer_line_count = len(transfer_lines)
|
|
vals_list = []
|
|
for amount in transfer_lines:
|
|
transfer_line_count -= 1
|
|
vals_list.append(
|
|
self._prepare_counterpart_line(move, amount, counterpart_date)
|
|
)
|
|
return vals_list
|
|
|
|
def _get_global_commission_amount(self, parser):
|
|
global_commission_amount = 0.0
|
|
commmission_field = parser.commission_field
|
|
if commmission_field:
|
|
for row in parser.result_row_list:
|
|
global_commission_amount += float(row.get(commmission_field, "0.0"))
|
|
# If commission amount is positive in field, inverse the sign
|
|
if parser.commission_sign == "+":
|
|
global_commission_amount = -global_commission_amount
|
|
return global_commission_amount
|
|
|
|
def _get_extra_move_line_vals_list(self, parser, move):
|
|
"""Insert extra lines after the main statement lines.
|
|
|
|
After the main statement lines have been created, you can override this
|
|
method to create extra statement lines.
|
|
|
|
:param: browse_record of the current parser
|
|
:param: result_row_list: [{'key':value}]
|
|
:param: profile: browserecord of account.statement.profile
|
|
:param: statement_id: int/long of the current importing
|
|
statement ID
|
|
:param: context: global context
|
|
"""
|
|
vals_list = []
|
|
global_commission_amount = self._get_global_commission_amount(parser)
|
|
partner_id = self.partner_id.id
|
|
# Commission line
|
|
if global_commission_amount > 0.0:
|
|
raise UserError(_("Commission amount should not be positive."))
|
|
elif global_commission_amount < 0.0:
|
|
if not self.commission_account_id:
|
|
raise UserError(_("No commission account is set on the journal."))
|
|
else:
|
|
commission_account_id = self.commission_account_id.id
|
|
comm_values = {
|
|
"name": _("Commission line"),
|
|
"date_maturity": (
|
|
parser.get_move_vals().get("date") or fields.Date.today()
|
|
),
|
|
"debit": -global_commission_amount,
|
|
"partner_id": partner_id,
|
|
"move_id": move.id,
|
|
"account_id": commission_account_id,
|
|
"already_completed": True,
|
|
}
|
|
if self.currency_id and self.currency_id != self.company_id.currency_id:
|
|
# the commission we are reading is in the currency of the
|
|
# journal: use the amount in the amount_currency field, and
|
|
# set credit / debit to the value in company currency at
|
|
# the date of the move.
|
|
currency = self.currency_id.with_context(date=move.date)
|
|
company_currency = self.company_id.currency_id
|
|
comm_values["amount_currency"] = comm_values["debit"]
|
|
comm_values["debit"] = currency.compute(
|
|
comm_values["debit"], company_currency
|
|
)
|
|
comm_values["currency_id"] = currency.id
|
|
if self.commission_analytic_account_id:
|
|
comm_values.update(
|
|
{"analytic_account_id": self.commission_analytic_account_id.id}
|
|
)
|
|
vals_list.append(comm_values)
|
|
return vals_list
|
|
|
|
def write_logs_after_import(self, move, num_lines):
|
|
"""Write the log in the logger
|
|
|
|
:param int/long statement_id: ID of the concerned
|
|
account.bank.statement
|
|
:param int/long num_lines: Number of line that have been parsed
|
|
:return: True
|
|
"""
|
|
self.message_post(
|
|
body=_("Move %(move_name)s have been imported with %(num_lines)s " "lines.")
|
|
% {"move_name": move.name, "num_lines": num_lines}
|
|
)
|
|
return True
|
|
|
|
def prepare_move_line_vals(self, parser_vals, move):
|
|
"""Hook to build the values of a line from the parser returned values.
|
|
At least it fulfills the basic values. Override it to add your own
|
|
completion if needed.
|
|
|
|
:param dict of vals from parser for account.bank.statement.line
|
|
(called by parser.get_st_line_vals)
|
|
:param int/long statement_id: ID of the concerned
|
|
account.bank.statement
|
|
:return: dict of vals that will be passed to create method of
|
|
statement line.
|
|
"""
|
|
move_line_obj = self.env["account.move.line"]
|
|
values = parser_vals
|
|
if not values.get("account_id", False):
|
|
values["account_id"] = self.receivable_account_id.id
|
|
account = self.env["account.account"].browse(values["account_id"])
|
|
if self.currency_id and self.currency_id != self.company_id.currency_id:
|
|
# the debit and credit we are reading are in the currency of the
|
|
# journal: use the amount in the amount_currency field, and set
|
|
# credit / debit to the value in company currency at the date of
|
|
# the move.
|
|
currency = self.currency_id.with_context(date=move.date)
|
|
company_currency = self.company_id.currency_id
|
|
values["amount_currency"] = values["debit"] - values["credit"]
|
|
values["debit"] = currency.compute(values["debit"], company_currency)
|
|
values["credit"] = currency.compute(values["credit"], company_currency)
|
|
if account.reconcile:
|
|
values["amount_residual"] = values["debit"] - values["credit"]
|
|
else:
|
|
values["amount_residual"] = 0
|
|
values.update(
|
|
{
|
|
"company_id": self.company_id.id,
|
|
"currency_id": self.currency_id.id or move.currency_id.id,
|
|
"company_currency_id": self.company_id.currency_id.id,
|
|
"journal_id": self.id,
|
|
"account_id": account.id,
|
|
"move_id": move.id,
|
|
"date": move.date,
|
|
"balance": values["debit"] - values["credit"],
|
|
"amount_residual_currency": 0,
|
|
"reconciled": False,
|
|
}
|
|
)
|
|
values = move_line_obj._add_missing_default_values(values)
|
|
return values
|
|
|
|
def prepare_move_vals(self, result_row_list, parser):
|
|
"""Hook to build the values of the statement from the parser and
|
|
the profile.
|
|
"""
|
|
vals = {
|
|
"journal_id": self.id,
|
|
"currency_id": self.currency_id.id or self.company_id.currency_id.id,
|
|
"import_partner_id": self.partner_id.id,
|
|
}
|
|
vals.update(parser.get_move_vals())
|
|
return vals
|
|
|
|
def _get_attachment_data(self, moves, file_stream, ftype):
|
|
attachment_data = {
|
|
"name": "statement file",
|
|
"datas": file_stream,
|
|
"store_fname": "{}.{}".format(fields.Date.today(), ftype),
|
|
"res_model": "account.move",
|
|
"res_id": moves[0].id,
|
|
}
|
|
return attachment_data
|
|
|
|
def multi_move_import(self, file_stream, ftype="csv"):
|
|
"""Create multiple bank statements from values given by the parser for
|
|
the given profile.
|
|
|
|
:param int/long profile_id: ID of the profile used to import the file
|
|
:param filebuffer file_stream: binary of the provided file
|
|
:param char: ftype represent the file extension (csv by default)
|
|
:return: list: list of ids of the created account.bank.statement
|
|
"""
|
|
filename = self._context.get("file_name", None)
|
|
attachment_obj = self.env["ir.attachment"]
|
|
if filename:
|
|
(filename, __) = os.path.splitext(filename)
|
|
parser = new_move_parser(self, ftype=ftype, move_ref=filename)
|
|
res = self.env["account.move"]
|
|
for result_row_list in parser.parse(file_stream):
|
|
move = self._move_import(
|
|
parser,
|
|
file_stream,
|
|
result_row_list=result_row_list,
|
|
ftype=ftype,
|
|
)
|
|
res |= move
|
|
if res:
|
|
attachment_vals = self._get_attachment_data(res, file_stream, ftype)
|
|
if attachment_vals:
|
|
attachment_obj.create(attachment_vals)
|
|
return res
|
|
|
|
def _move_import(self, parser, file_stream, result_row_list=None, ftype="csv"):
|
|
"""Create a bank statement with the given profile and parser. It will
|
|
fulfill the bank statement with the values of the file provided, but
|
|
will not complete data (like finding the partner, or the right
|
|
account). This will be done in a second step with the completion rules.
|
|
|
|
:param prof : The profile used to import the file
|
|
:param parser: the parser
|
|
:param filebuffer file_stream: binary of the provided file
|
|
:param char: ftype represent the file extension (csv by default)
|
|
:return: ID of the created account.bank.statement
|
|
"""
|
|
move_obj = self.env["account.move"]
|
|
move_line_obj = self.env["account.move.line"]
|
|
attachment_obj = self.env["ir.attachment"]
|
|
if result_row_list is None:
|
|
result_row_list = parser.result_row_list
|
|
# Check all key are present in account.bank.statement.line!!
|
|
if not result_row_list:
|
|
raise UserError(_("Nothing to import: " "The file is empty"))
|
|
parsed_cols = list(parser.get_move_line_vals(result_row_list[0]).keys())
|
|
for col in parsed_cols:
|
|
if col not in move_line_obj._fields:
|
|
raise UserError(
|
|
_(
|
|
"Missing column! Column %s you try to import is not "
|
|
"present in the move line!"
|
|
)
|
|
% col
|
|
)
|
|
move_vals = self.prepare_move_vals(result_row_list, parser)
|
|
move = move_obj.create(move_vals)
|
|
try:
|
|
# Record every line in the bank statement
|
|
move_store = []
|
|
for line in result_row_list:
|
|
parser_vals = parser.get_move_line_vals(line)
|
|
values = self.prepare_move_line_vals(parser_vals, move)
|
|
move_store.append(values)
|
|
move_store += self._get_extra_move_line_vals_list(parser, move)
|
|
if self.create_counterpart:
|
|
move_store += self._get_counterpart_vals_list(parser, move, move_store)
|
|
# Check if move is balanced
|
|
container = {"records": move}
|
|
with move._check_balanced(container):
|
|
move_line_obj.create(move_store)
|
|
# Computed total amount of the move
|
|
# move._amount_compute()
|
|
# Attach data to the move
|
|
attachment_data = {
|
|
"name": "statement file",
|
|
"datas": file_stream,
|
|
"store_fname": "{}.{}".format(fields.Date.today(), ftype),
|
|
"res_model": "account.move",
|
|
"res_id": move.id,
|
|
}
|
|
attachment_obj.create(attachment_data)
|
|
# If user ask to launch completion at end of import, do it!
|
|
if self.launch_import_completion:
|
|
move.button_auto_completion()
|
|
# Write the needed log infos on profile
|
|
self.write_logs_after_import(move, len(result_row_list))
|
|
except UserError:
|
|
# "Clean" exception, raise as such
|
|
raise
|
|
except Exception:
|
|
error_type, error_value, trbk = sys.exc_info()
|
|
st = "Error: {}\nDescription: {}\nTraceback:".format(
|
|
error_type.__name__,
|
|
error_value,
|
|
)
|
|
st += "".join(traceback.format_tb(trbk, 30))
|
|
raise ValidationError(
|
|
_("Statement import error " "The statement cannot be created: %s") % st
|
|
) from None
|
|
return move
|