size
int64 0
304k
| ext
stringclasses 1
value | lang
stringclasses 1
value | branch
stringclasses 1
value | content
stringlengths 0
304k
| avg_line_length
float64 0
238
| max_line_length
int64 0
304k
|
|---|---|---|---|---|---|---|
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
1,174 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Document Page",
"version": "15.0.1.3.1",
"category": "Knowledge Management",
"author": "OpenERP SA, Odoo Community Association (OCA)",
"images": [
"images/category_list.png",
"images/create_category.png",
"images/page_list.png",
"images/create_page.png",
"images/customer_invoice.jpeg",
"images/page_history.png",
],
"website": "https://github.com/OCA/knowledge",
"license": "AGPL-3",
"depends": ["mail", "knowledge"],
"data": [
"security/document_page_security.xml",
"security/ir.model.access.csv",
"wizard/document_page_create_menu.xml",
"wizard/document_page_show_diff.xml",
"views/document_page.xml",
"views/document_page_category.xml",
"views/document_page_history.xml",
"views/report_document_page.xml",
],
"demo": ["demo/document_page.xml"],
"assets": {
"web.assets_backend": [
"document_page/static/src/scss/document_page.scss",
],
},
}
| 31.72973 | 1,174 |
2,327 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests import common
class TestDocumentPage(common.TransactionCase):
def setUp(self):
super(TestDocumentPage, self).setUp()
self.page_obj = self.env["document.page"]
self.history_obj = self.env["document.page.history"]
self.category1 = self.env.ref("document_page.demo_category1")
self.page1 = self.env.ref("document_page.demo_page1")
def test_page_creation(self):
page = self.page_obj.create(
{
"name": "Test Page 1",
"parent_id": self.category1.id,
"content": "<p>Test content</p>",
}
)
self.assertEqual(page.content, "<p>Test content</p>")
self.assertEqual(len(page.history_ids), 1)
page.content = "<p>New content for Demo Page</p>"
self.assertEqual(len(page.history_ids), 2)
def test_category_template(self):
page = self.page_obj.create(
{"name": "Test Page 2", "parent_id": self.category1.id}
)
page._onchange_parent_id()
self.assertEqual(page.content, self.category1.template)
def test_page_history_diff(self):
page = self.page_obj.create({"name": "Test Page 3", "content": "Test content"})
page.content = "New content"
self.assertIsNotNone(page.history_ids[0].diff)
def test_page_link(self):
page = self.page_obj.create({"name": "Test Page 3", "content": "Test content"})
self.assertEqual(
page.backend_url,
"/web#id={}&model=document.page&view_type=form".format(page.id),
)
menu = self.env.ref("knowledge.menu_document")
page.menu_id = menu
self.assertEqual(
page.backend_url,
"/web#id={}&model=document.page&view_type=form&action={}".format(
page.id, menu.action.id
),
)
def test_page_copy(self):
page = self.page_obj.create({"name": "Test Page 3", "content": "Test content"})
page_copy = page.copy()
self.assertEqual(page_copy.name, page.name + " (copy)")
self.assertEqual(page_copy.content, page.content)
self.assertEqual(page_copy.draft_name, "1.0")
self.assertEqual(page_copy.draft_summary, "summary")
| 39.440678 | 2,327 |
995 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests import common
class TestDocumentPageCreateMenu(common.TransactionCase):
"""document_page_create_menu test class."""
def test_page_menu_creation(self):
"""Test page menu creation."""
menu_parent = self.env.ref("knowledge.menu_document")
menu_created = self.env["document.page.create.menu"].create(
{"menu_name": "Wiki Test menu", "menu_parent_id": menu_parent.id}
)
menu = self.env["document.page.create.menu"].search(
[("id", "=", menu_created.id)]
)
menu.with_context(
active_id=[self.ref("document_page.demo_page1")]
).document_page_menu_create()
fields_list = ["menu_name", "menu_name"]
res = menu.with_context(
active_id=[self.ref("document_page.demo_page1")]
).default_get(fields_list)
self.assertEqual(res["menu_name"], "Odoo 15.0 Functional Demo")
| 34.310345 | 995 |
1,116 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.exceptions import UserError
from odoo.tests import common
class TestDocumentPageShowDiff(common.TransactionCase):
"""document_page_show_diff test class."""
def test_show_demo_page1_diff(self):
"""Show test page history difference."""
page = self.env.ref("document_page.demo_page1")
show_diff_object = self.env["wizard.document.page.history.show_diff"]
history_document = self.env["document.page.history"]
history_pages = history_document.search([("page_id", "=", page.id)])
self.assertTrue(
show_diff_object.with_context(
active_ids=[i.id for i in history_pages]
)._get_diff()
)
page.write({"content": "Text content updated"})
page.write({"content": "Text updated"})
history_pages = history_document.search([("page_id", "=", page.id)])
with self.assertRaises(UserError):
show_diff_object.with_context(
active_ids=[i.id for i in history_pages]
)._get_diff()
| 34.875 | 1,116 |
806 |
py
|
PYTHON
|
15.0
|
from odoo.tests import common
class TestDocumentPageHistory(common.TransactionCase):
"""document_page_history test class."""
def test_page_history_demo_page1(self):
"""Test page history demo page1."""
page = self.env.ref("document_page.demo_page1")
page.content = "Test content updated"
history_document = self.env["document.page.history"]
history_pages = history_document.search([("page_id", "=", page.id)])
active_ids = [i.id for i in history_pages]
result = history_document._get_diff(active_ids[0], active_ids[0])
self.assertEqual(result, "There are no changes in revisions.")
result = history_document._get_diff(active_ids[0], active_ids[1])
self.assertNotEqual(result, "There are no changes in revisions.")
| 42.421053 | 806 |
1,034 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, fields, models
from odoo.exceptions import UserError
class DocumentPageShowDiff(models.TransientModel):
"""Display Difference for History."""
_name = "wizard.document.page.history.show_diff"
_description = "Document Page Show Diff"
def _get_diff(self):
"""Return the Difference between two documents"""
history = self.env["document.page.history"]
ids = self.env.context.get("active_ids", [])
diff = False
if len(ids) == 2:
if ids[0] > ids[1]:
diff = history._get_diff(ids[1], ids[0])
else:
diff = history._get_diff(ids[0], ids[1])
elif len(ids) == 1:
diff = history.browse(ids[0]).diff
else:
raise UserError(_("Select one or maximum two history revisions!"))
return diff
diff = fields.Html(readonly=True, default=_get_diff)
| 34.466667 | 1,034 |
2,205 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class DocumentPageCreateMenu(models.TransientModel):
"""Create Menu."""
_name = "document.page.create.menu"
_description = "Wizard Create Menu"
menu_name = fields.Char(required=True)
menu_parent_id = fields.Many2one("ir.ui.menu", "Parent Menu", required=True)
@api.model
def default_get(self, fields_list):
"""Get Page name of the menu."""
res = super().default_get(fields_list)
page_id = self.env.context.get("active_id")
obj_page = self.env["document.page"]
page = obj_page.browse(page_id)
res["menu_name"] = page.name
return res
def document_page_menu_create(self):
"""Menu creation."""
obj_page = self.env["document.page"]
obj_menu = self.env["ir.ui.menu"]
obj_action = self.env["ir.actions.act_window"]
obj_model_data = self.env["ir.model.data"]
page_id = self.env.context.get("active_id", False)
page = obj_page.browse(page_id)
data = self[0]
view_id = obj_model_data._xmlid_to_res_id("document_page.view_wiki_menu_form")
value = {
"name": "Document Page",
"view_mode": "form,tree",
"res_model": "document.page",
"view_id": view_id,
"type": "ir.actions.act_window",
"target": "current",
}
value["domain"] = "[('parent_id','=',%d)]" % page.id
value["res_id"] = page.id
# only the super user is allowed to create menu due to security rules
# on ir.values
# see.: http://goo.gl/Y99S7V
action_id = obj_action.sudo().create(value)
menu_id = obj_menu.sudo().create(
{
"name": data.menu_name,
"parent_id": data.menu_parent_id.id,
"action": "ir.actions.act_window," + str(action_id.id),
}
)
if page.menu_id:
page.menu_id.unlink()
page.write({"menu_id": menu_id.id})
return {"type": "ir.actions.client", "tag": "reload"}
| 35 | 2,205 |
5,986 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class DocumentPage(models.Model):
"""This class is use to manage Document."""
_name = "document.page"
_inherit = ["mail.thread", "mail.activity.mixin"]
_description = "Document Page"
_order = "name"
_HTML_WIDGET_DEFAULT_VALUE = "<p><br></p>"
name = fields.Char("Title", required=True)
type = fields.Selection(
[("content", "Content"), ("category", "Category")],
help="Page type",
default="content",
)
active = fields.Boolean(default=True)
parent_id = fields.Many2one(
"document.page", "Category", domain=[("type", "=", "category")]
)
child_ids = fields.One2many("document.page", "parent_id", "Children")
content = fields.Html(
compute="_compute_content",
inverse="_inverse_content",
search="_search_content",
sanitize=False,
)
draft_name = fields.Char(
string="Name",
help="Name for the changes made",
related="history_head.name",
readonly=False,
)
draft_summary = fields.Char(
string="Summary",
help="Describe the changes made",
related="history_head.summary",
readonly=False,
)
template = fields.Html(
help="Template that will be used as a content template "
"for all new page of this category.",
)
history_head = fields.Many2one(
"document.page.history",
"HEAD",
compute="_compute_history_head",
store=True,
auto_join=True,
)
history_ids = fields.One2many(
"document.page.history",
"page_id",
"History",
readonly=True,
)
menu_id = fields.Many2one("ir.ui.menu", "Menu", readonly=True)
content_date = fields.Datetime(
"Last Contribution Date",
related="history_head.create_date",
store=True,
index=True,
readonly=True,
)
content_uid = fields.Many2one(
"res.users",
"Last Contributor",
related="history_head.create_uid",
store=True,
index=True,
readonly=True,
)
company_id = fields.Many2one(
"res.company",
"Company",
help="If set, page is accessible only from this company",
index=True,
ondelete="cascade",
default=lambda self: self.env.company,
)
backend_url = fields.Char(
string="Backend URL",
help="Use it to link resources univocally",
compute="_compute_backend_url",
)
@api.depends("menu_id", "parent_id.menu_id")
def _compute_backend_url(self):
tmpl = "/web#id={}&model=document.page&view_type=form"
for rec in self:
url = tmpl.format(rec.id)
# retrieve action
action = None
parent = rec
while not action and parent:
action = parent.menu_id.action
parent = parent.parent_id
if action:
url += "&action={}".format(action.id)
rec.backend_url = url
@api.constrains("parent_id")
def _check_parent_id(self):
if not self._check_recursion():
raise ValidationError(_("You cannot create recursive categories."))
def _get_page_index(self, link=True):
"""Return the index of a document."""
self.ensure_one()
index = [
"<li>" + subpage._get_page_index() + "</li>" for subpage in self.child_ids
]
r = ""
if link:
r = '<a href="{}">{}</a>'.format(self.backend_url, self.name)
if index:
r += "<ul>" + "".join(index) + "</ul>"
return r
@api.depends("history_head")
def _compute_content(self):
for rec in self:
if rec.type == "category":
rec.content = rec._get_page_index(link=False)
else:
if rec.history_head:
rec.content = rec.history_head.content
else:
# html widget's default, so it doesn't trigger ghost save
rec.content = self._HTML_WIDGET_DEFAULT_VALUE
def _inverse_content(self):
for rec in self:
if rec.type == "content" and rec.content != rec.history_head.content:
rec._create_history(
{
"page_id": rec.id,
"name": rec.draft_name,
"summary": rec.draft_summary,
"content": rec.content,
}
)
def _create_history(self, vals):
self.ensure_one()
return self.env["document.page.history"].create(vals)
def _search_content(self, operator, value):
return [("history_head.content", operator, value)]
@api.depends("history_ids")
def _compute_history_head(self):
for rec in self:
if rec.history_ids:
rec.history_head = rec.history_ids[0]
else:
rec.history_head = False
@api.onchange("parent_id")
def _onchange_parent_id(self):
"""We Set it the right content to the new parent."""
if (
self.content in (False, self._HTML_WIDGET_DEFAULT_VALUE)
and self.parent_id.type == "category"
):
self.content = self.parent_id.template
def unlink(self):
menus = self.mapped("menu_id")
res = super().unlink()
menus.unlink()
return res
def copy(self, default=None):
default = dict(
default or {},
name=_("%s (copy)") % self.name,
content=self.content,
draft_name="1.0",
draft_summary=_("summary"),
)
return super(DocumentPage, self).copy(default=default)
| 31.177083 | 5,986 |
2,382 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import difflib
from odoo import _, api, fields, models
class DocumentPageHistory(models.Model):
"""This model is necessary to manage a document history."""
_name = "document.page.history"
_description = "Document Page History"
_order = "id DESC"
page_id = fields.Many2one("document.page", "Page", ondelete="cascade")
name = fields.Char(index=True)
summary = fields.Char(index=True)
content = fields.Html(sanitize=False)
diff = fields.Html(compute="_compute_diff")
company_id = fields.Many2one(
"res.company",
"Company",
help="If set, page is accessible only from this company",
related="page_id.company_id",
store=True,
index=True,
readonly=True,
)
def _compute_diff(self):
"""Shows a diff between this version and the previous version"""
history = self.env["document.page.history"]
for rec in self:
prev = history.search(
[
("page_id", "=", rec.page_id.id),
("create_date", "<", rec.create_date),
],
limit=1,
order="create_date DESC",
)
rec.diff = self._get_diff(prev.id, rec.id)
@api.model
def _get_diff(self, v1, v2):
"""Return the difference between two version of document version."""
text1 = v1 and self.browse(v1).content or ""
text2 = v2 and self.browse(v2).content or ""
# Include line breaks to make it more readable
# TODO: consider using a beautify library directly on the content
text1 = text1.replace("</p><p>", "</p>\r\n<p>")
text2 = text2.replace("</p><p>", "</p>\r\n<p>")
line1 = text1.splitlines(True)
line2 = text2.splitlines(True)
if line1 == line2:
return _("There are no changes in revisions.")
else:
diff = difflib.HtmlDiff()
return diff.make_table(
line1,
line2,
"Revision-{}".format(v1),
"Revision-{}".format(v2),
context=True,
)
def name_get(self):
return [(rec.id, "%s #%i" % (rec.page_id.name, rec.id)) for rec in self]
| 34.028571 | 2,382 |
479 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Document Page Group",
"summary": """
Define access groups on documents""",
"version": "15.0.1.0.1",
"license": "AGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/knowledge",
"depends": ["document_page"],
"data": ["security/document_page_security.xml", "views/document_page.xml"],
}
| 34.214286 | 479 |
1,666 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests.common import TransactionCase
class TestDocumentPageGroup(TransactionCase):
def setUp(self):
super(TestDocumentPageGroup, self).setUp()
knowledge_group = self.browse_ref("knowledge.group_document_user").id
self.user_id = self.env["res.users"].create(
{
"name": "user",
"login": "login",
"email": "email",
"groups_id": [(4, knowledge_group)],
}
)
self.group = self.browse_ref("document_page.group_document_manager")
self.categ_1 = self.env["document.page"].create(
{"name": "Categ 1", "type": "category"}
)
self.categ_2 = self.env["document.page"].create(
{"name": "Categ 2", "type": "category", "parent_id": self.categ_1.id}
)
self.page = self.env["document.page"].create(
{"name": "Page 1", "type": "content", "parent_id": self.categ_1.id}
)
def test_document_page_group(self):
pages = (
self.env["document.page"]
.with_user(user=self.user_id.id)
.search([("type", "=", "content")])
)
self.assertIn(self.page.id, pages.ids)
self.categ_1.write({"direct_group_ids": [(4, self.group.id)]})
self.assertIn(self.group.id, self.categ_2.group_ids.ids)
pages = (
self.env["document.page"]
.with_user(user=self.user_id.id)
.search([("type", "=", "content")])
)
self.assertNotIn(self.page.id, pages.ids)
| 35.446809 | 1,666 |
1,036 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class DocumentPage(models.Model):
_inherit = "document.page"
group_ids = fields.Many2many(
"res.groups",
store=True,
recursive=True,
relation="document_page_direct_group",
column1="document_page_id",
column2="group_id",
compute="_compute_group_ids",
)
direct_group_ids = fields.Many2many(
"res.groups",
string="Visible to",
help="Set the groups that can view this category and its childs",
relation="document_page_group",
column1="document_page_id",
column2="group_id",
)
@api.depends("direct_group_ids", "parent_id", "parent_id.group_ids")
def _compute_group_ids(self):
for record in self:
groups = record.direct_group_ids
if record.parent_id:
groups |= record.parent_id.group_ids
record.group_ids = groups
| 29.6 | 1,036 |
716 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Knowledge",
"version": "15.0.1.0.2",
"author": "OpenERP SA,"
"MONK Software, "
"Tecnativa, "
"ForgeFlow, "
"Odoo Community Association (OCA)",
"category": "Knowledge",
"license": "AGPL-3",
"website": "https://github.com/OCA/knowledge",
"depends": ["base"],
"data": [
"data/ir_module_category.xml",
"security/knowledge_security.xml",
"data/res_users.xml",
"views/knowledge.xml",
"views/res_config.xml",
],
"demo": ["demo/knowledge.xml"],
"installable": True,
"application": True,
}
| 28.64 | 716 |
335 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class IrAttachment(models.Model):
_inherit = "ir.attachment"
# Add index to res_model because filtering on it is a common use case
res_model = fields.Char(index=True)
| 30.454545 | 335 |
1,720 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class KnowledgeConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
module_attachment_indexation = fields.Boolean(
"Attachments List and Document Indexation",
help="Document indexation, full text search of attachements.\n"
"- This installs the module attachment_indexation.",
)
group_ir_attachment_user = fields.Boolean(
string="Central access to Documents",
help="When you set this field all users will be able to manage "
"attachments centrally, from the Knowledge/Documents menu.",
implied_group="knowledge.group_ir_attachment_user",
)
module_document_page = fields.Boolean(
"Manage document pages (Wiki)",
help="Provide document page and category as a wiki.\n"
"- This installs the module document_page.",
)
module_document_page_approval = fields.Boolean(
"Manage documents approval",
help="Add workflow on documents per category.\n"
"- This installs the module document_page_approval.",
)
module_cmis_read = fields.Boolean(
"Attach files from an external DMS into Odoo",
help="Connect Odoo with a CMIS compatible server to attach files\n"
"to an Odoo record.\n"
"- This installs the module cmis_read.",
)
module_cmis_write = fields.Boolean(
"Store attachments in an external DMS instead of the Odoo Filestore",
help="Connect Odoo with a CMIS compatible server to store files.\n"
"- This installs the module cmis_write.",
)
| 37.391304 | 1,720 |
733 |
py
|
PYTHON
|
15.0
|
# Copyright 2014 Tecnativa - Pedro M. Baeza
# Copyright 2020 Tecnativa - Manuel Calero
{
"name": "URL attachment",
"version": "15.0.1.1.1",
"category": "Tools",
"author": "Tecnativa, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/knowledge",
"license": "AGPL-3",
"depends": ["mail"],
"data": [
"security/ir.model.access.csv",
"view/document_url_view.xml",
],
"assets": {
"web.assets_backend": [
"document_url/static/src/js/url.esm.js",
"document_url/static/src/scss/document_url.scss",
],
"web.assets_qweb": [
"document_url/static/src/xml/url.xml",
],
},
"installable": True,
}
| 29.32 | 733 |
384 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
openupgrade.logged_query(
env.cr,
"""
UPDATE ir_attachment
SET mimetype = 'application/link'
WHERE type = 'link'
""",
)
| 23.875 | 382 |
1,180 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
class TestDocumentUrl(common.TransactionCase):
def setUp(self):
super().setUp()
wizard_add_url = self.env["ir.attachment.add_url"]
self.wizard_add_url = wizard_add_url.with_context(
active_model="res.users",
active_id=self.env.ref("base.user_demo").id,
active_ids=[self.env.ref("base.user_demo").id],
).create({"name": "Demo User (Website)", "url": "http://www.odoodemouser.com"})
def test_add_url_attachment(self):
self.wizard_add_url.action_add_url()
domain = [
("type", "=", "url"),
("name", "=", "Demo User (Website)"),
("url", "=", "http://www.odoodemouser.com"),
("res_model", "=", "res.users"),
("res_id", "=", self.env.ref("base.user_demo").id),
]
attachment_added_count = self.env["ir.attachment"].search_count(domain)
self.assertEqual(attachment_added_count, 1)
attachment = self.env["ir.attachment"].search(domain)
self.assertEqual(attachment.mimetype, "application/link")
| 40.689655 | 1,180 |
1,258 |
py
|
PYTHON
|
15.0
|
# Copyright 2014 Tecnativa - Pedro M. Baeza
# Copyright 2020 Tecnativa - Manuel Calero
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
from urllib import parse
from odoo import fields, models
class AddUrlWizard(models.TransientModel):
_name = "ir.attachment.add_url"
_description = "Wizard to add URL attachment"
name = fields.Char(required=True)
url = fields.Char("URL", required=True)
def action_add_url(self):
"""Adds the URL with the given name as an ir.attachment record."""
if not self.env.context.get("active_model"):
return
attachment_obj = self.env["ir.attachment"]
for form in self:
url = parse.urlparse(form.url)
if not url.scheme:
url = parse.urlparse("{}{}".format("http://", form.url))
for active_id in self.env.context.get("active_ids", []):
attachment = {
"name": form.name,
"type": "url",
"url": url.geturl(),
"res_id": active_id,
"res_model": self.env.context["active_model"],
}
attachment_obj.create(attachment)
return {"type": "ir.actions.act_window_close"}
| 37 | 1,258 |
401 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import models
class IrAttachment(models.Model):
_inherit = "ir.attachment"
def _compute_mimetype(self, values):
if values.get("url") and values.get("type", "url") == "url":
return "application/link"
return super()._compute_mimetype(values)
| 30.692308 | 399 |
763 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
{
"name": "Bank statement import move lines",
"version": "15.0.1.0.0",
"category": "Accounting",
"summary": "Import journal items into bank statement",
"author": "Tecnativa, " "Odoo Community Association (OCA)",
"maintainers": ["pedrobaeza"],
"website": "https://github.com/OCA/bank-statement-import",
"depends": ["account"],
"data": [
"security/ir.model.access.csv",
"wizards/account_statement_line_create_view.xml",
"views/account_bank_statement_view.xml",
],
"license": "AGPL-3",
"development_status": "Production/Stable",
"installable": True,
"auto_install": False,
}
| 34.681818 | 763 |
3,105 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0
from odoo import fields
from odoo.tests import TransactionCase
class TestAccountBankStatementImportMoveLine(TransactionCase):
@classmethod
def setUpClass(cls):
super(TestAccountBankStatementImportMoveLine, cls).setUpClass()
cls.account_type = cls.env["account.account.type"].create(
{"name": "Test Account Type", "type": "other", "internal_group": "asset"}
)
cls.a_receivable = cls.env["account.account"].create(
{
"code": "TAA",
"name": "Test Receivable Account",
"internal_type": "receivable",
"user_type_id": cls.account_type.id,
}
)
cls.partner = cls.env["res.partner"].create(
{"name": "Test Partner 2", "parent_id": False}
)
cls.journal = cls.env["account.journal"].create(
{"name": "Test Journal", "type": "sale", "code": "TJS0"}
)
cls.journal_bank = cls.env["account.journal"].create(
{"name": "Test Journal Bank", "type": "bank", "code": "TJB0"}
)
cls.invoice = cls.env["account.move"].create(
{
"name": "Test Invoice 3",
"partner_id": cls.partner.id,
"move_type": "out_invoice",
"journal_id": cls.journal.id,
"ref": "Test",
"invoice_line_ids": [
(
0,
0,
{
"account_id": cls.a_receivable.id,
"name": "Test line",
"quantity": 1.0,
"price_unit": 100.00,
},
)
],
}
)
cls.statement = cls.env["account.bank.statement"].create(
{"journal_id": cls.journal_bank.id}
)
def test_global(self):
self.invoice.action_post()
self.assertTrue(self.invoice.id)
wizard_o = self.env["account.statement.line.create"]
context = wizard_o._context.copy()
context.update(
{"active_model": "account.bank.statement", "active_id": self.statement.id}
)
wizard = wizard_o.with_context(**context).create(
{
"statement_id": self.statement.id,
"partner_id": self.partner.id,
"journal_ids": [(4, self.journal.id)],
"allow_blocked": True,
"date_type": "move",
"move_date": fields.Date.today(),
"invoice": False,
}
)
wizard.populate()
self.assertEqual(len(wizard.move_line_ids), 1)
line = wizard.move_line_ids
self.assertEqual(line.debit, self.invoice.amount_total)
wizard.create_statement_lines()
line = self.statement.line_ids[0]
self.assertEqual(line.amount, self.invoice.amount_total)
| 36.964286 | 3,105 |
1,187 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from odoo import models
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
def _prepare_statement_line_vals(self, statement):
self.ensure_one()
amount = 0.0
if self.debit > 0:
amount = self.debit
elif self.credit > 0:
amount = -self.credit
vals = {
"name": self.name or "?",
"amount": amount,
"partner_id": self.partner_id.id,
"statement_id": statement.id,
"payment_ref": self.ref,
"date": self.date_maturity,
"currency_id": self.currency_id.id,
}
if statement.currency_id != self.currency_id:
vals.update(
{
"amount_currency": self.amount_currency,
}
)
return vals
def create_statement_line_from_move_line(self, statement):
abslo = self.env["account.bank.statement.line"]
for mline in self:
abslo.create(mline._prepare_statement_line_vals(statement))
return
| 31.236842 | 1,187 |
4,646 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from odoo import _, api, fields, models
class AccountStatementLineCreate(models.TransientModel):
_name = "account.statement.line.create"
_description = "Wizard to create statement lines"
statement_id = fields.Many2one("account.bank.statement", string="Bank Statement")
partner_id = fields.Many2one(
"res.partner",
string="Partner Related",
domain=["|", ("parent_id", "=", False), ("is_company", "=", True)],
)
journal_ids = fields.Many2many("account.journal", string="Journals Filter")
target_move = fields.Selection(
[("posted", "All Posted Entries"), ("all", "All Entries")],
string="Target Moves",
)
allow_blocked = fields.Boolean(string="Allow Litigation Move Lines")
invoice = fields.Boolean(string="Linked to an Invoice or Refund")
date_type = fields.Selection(
[("due", "Due Date"), ("move", "Move Date")],
string="Type of Date Filter",
required=True,
)
due_date = fields.Date(default=fields.Date.context_today)
move_date = fields.Date(default=fields.Date.context_today)
move_line_ids = fields.Many2many("account.move.line", string="Move Lines")
@api.model
def default_get(self, field_list):
res = super().default_get(field_list)
active_model = self.env.context.get("active_model")
if active_model == "account.bank.statement":
statement = (
self.env[active_model]
.browse(self.env.context.get("active_id"))
.exists()
)
if statement:
res.update(
{
"target_move": "posted",
"date_type": "due",
"invoice": True,
"statement_id": statement.id,
}
)
return res
def _prepare_move_line_domain(self):
self.ensure_one()
domain = [
("reconciled", "=", False),
("account_id.internal_type", "in", ("payable", "receivable")),
("company_id", "=", self.env.company.id),
]
if self.journal_ids:
domain += [("journal_id", "in", self.journal_ids.ids)]
else:
journals = self.env["account.journal"].search([])
domain += [("journal_id", "in", journals.ids)]
if self.partner_id:
domain += [("partner_id", "=", self.partner_id.id)]
if self.target_move == "posted":
domain += [("move_id.state", "=", "posted")]
if not self.allow_blocked:
domain += [("blocked", "!=", True)]
if self.date_type == "due":
domain += [
"|",
("date_maturity", "<=", self.due_date),
("date_maturity", "=", False),
]
elif self.date_type == "move":
domain.append(("date", "<=", self.move_date))
if self.invoice:
domain.append(("move_id", "!=", False))
paylines = self.env["account.payment"].search(
[
("state", "in", ("draft", "posted", "sent")),
("line_ids", "!=", False),
]
)
if paylines:
move_in_payment_ids = paylines.mapped("line_ids.id")
domain += [("id", "not in", move_in_payment_ids)]
return domain
def populate(self):
domain = self._prepare_move_line_domain()
lines = self.env["account.move.line"].search(domain)
self.move_line_ids = False
self.move_line_ids = lines
action = {
"name": _("Select Move Lines to Create Statement"),
"type": "ir.actions.act_window",
"res_model": "account.statement.line.create",
"view_mode": "form",
"target": "new",
"res_id": self.id,
"context": self._context,
}
return action
@api.onchange(
"date_type",
"move_date",
"due_date",
"journal_ids",
"invoice",
"target_move",
"allow_blocked",
"partner_id",
)
def move_line_filters_change(self):
domain = self._prepare_move_line_domain()
res = {"domain": {"move_line_ids": domain}}
return res
def create_statement_lines(self):
for rec in self:
if rec.move_line_ids and rec.statement_id:
rec.move_line_ids.create_statement_line_from_move_line(rec.statement_id)
return True
| 36.296875 | 4,646 |
522 |
py
|
PYTHON
|
15.0
|
{
"name": "Import OFX Bank Statement",
"category": "Banking addons",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Odoo SA,"
"Akretion,"
"La Louve,"
"GRAP,"
"Nicolas JEUDY,"
"Le Filament,"
"Odoo Community Association (OCA)",
"website": "https://github.com/OCA/bank-statement-import",
"depends": ["account_statement_import"],
"data": ["views/account_statement_import.xml"],
"external_dependencies": {"python": ["ofxparse"]},
"installable": True,
}
| 29 | 522 |
3,939 |
py
|
PYTHON
|
15.0
|
import base64
import datetime
from odoo.modules.module import get_module_resource
from odoo.tests.common import TransactionCase
class TestOfxFile(TransactionCase):
"""Tests for import bank statement ofx file format
(account.bank.statement.import)
"""
def setUp(self):
super(TestOfxFile, self).setUp()
self.asi_model = self.env["account.statement.import"]
self.abs_model = self.env["account.bank.statement"]
self.j_model = self.env["account.journal"]
self.absl_model = self.env["account.bank.statement.line"]
cur = self.env.ref("base.USD")
# self.env.ref("base.main_company").currency_id = cur.id
bank = self.env["res.partner.bank"].create(
{
"acc_number": "123456",
"partner_id": self.env.ref("base.main_partner").id,
"company_id": self.env.ref("base.main_company").id,
"bank_id": self.env.ref("base.res_bank_1").id,
}
)
self.env["account.journal"].create(
{
"name": "Bank Journal TEST OFX",
"code": "BNK12",
"type": "bank",
"bank_account_id": bank.id,
"currency_id": cur.id,
}
)
bank_iban_ofx = self.env["res.partner.bank"].create(
{
"acc_number": "FR7630001007941234567890185",
"partner_id": self.env.ref("base.main_partner").id,
"company_id": self.env.ref("base.main_company").id,
"bank_id": self.env.ref("base.res_bank_1").id,
}
)
self.env["account.journal"].create(
{
"name": "FR7630001007941234567890185",
"code": "BNK13",
"type": "bank",
"bank_account_id": bank_iban_ofx.id,
"currency_id": cur.id,
}
)
def test_wrong_ofx_file_import(self):
ofx_file_path = get_module_resource(
"account_statement_import_ofx",
"tests/test_ofx_file/",
"test_ofx_wrong.ofx",
)
ofx_file_wrong = base64.b64encode(open(ofx_file_path, "rb").read())
bank_statement = self.asi_model.create(
{
"statement_file": ofx_file_wrong,
"statement_filename": "test_ofx_wrong.ofx",
}
)
self.assertFalse(bank_statement._check_ofx(data_file=ofx_file_wrong))
def test_ofx_file_import(self):
ofx_file_path = get_module_resource(
"account_statement_import_ofx", "tests/test_ofx_file/", "test_ofx.ofx"
)
ofx_file = base64.b64encode(open(ofx_file_path, "rb").read())
bank_statement = self.asi_model.create(
{
"statement_file": ofx_file,
"statement_filename": "test_ofx.ofx",
}
)
bank_statement.import_file_button()
bank_st_record = self.abs_model.search([("name", "like", "123456")])[0]
self.assertEqual(bank_st_record.balance_start, 2516.56)
self.assertEqual(bank_st_record.balance_end_real, 2156.56)
line = self.absl_model.search(
[
("payment_ref", "=", "Agrolait"),
("statement_id", "=", bank_st_record.id),
]
)[0]
self.assertEqual(line.date, datetime.date(2013, 8, 24))
def test_check_journal_bank_account(self):
ofx_file_path = get_module_resource(
"account_statement_import_ofx",
"tests/test_ofx_file/",
"test_ofx_iban.ofx",
)
ofx_file = base64.b64encode(open(ofx_file_path, "rb").read())
bank_st = self.asi_model.create(
{
"statement_file": ofx_file,
"statement_filename": "test_ofx_iban.ofx",
}
)
bank_st.import_file_button()
| 35.809091 | 3,939 |
2,864 |
py
|
PYTHON
|
15.0
|
import io
import logging
from odoo import _, api, models
from odoo.exceptions import UserError
_logger = logging.getLogger(__name__)
try:
from ofxparse import OfxParser
except ImportError:
_logger.debug("ofxparse not found.")
OfxParser = None
class AccountStatementImport(models.TransientModel):
_inherit = "account.statement.import"
@api.model
def _check_ofx(self, data_file):
if not OfxParser:
return False
try:
ofx = OfxParser.parse(io.BytesIO(data_file))
except Exception as e:
_logger.debug(e)
return False
return ofx
@api.model
def _prepare_ofx_transaction_line(self, transaction):
# Since ofxparse doesn't provide account numbers,
# we cannot provide the key 'bank_account_id',
# nor the key 'account_number'
# If you read odoo10/addons/account_bank_statement_import/
# account_bank_statement_import.py, it's the only 2 keys
# we can provide to match a partner.
payment_ref = transaction.payee
if transaction.checknum:
payment_ref += " " + transaction.checknum
if transaction.memo:
payment_ref += " : " + transaction.memo
vals = {
"date": transaction.date,
"payment_ref": payment_ref,
"amount": float(transaction.amount),
"unique_import_id": transaction.id,
}
return vals
def _parse_file(self, data_file):
ofx = self._check_ofx(data_file)
if not ofx:
return super()._parse_file(data_file)
result = []
try:
for account in ofx.accounts:
transactions = []
total_amt = 0.00
if not account.statement.transactions:
continue
for transaction in account.statement.transactions:
vals = self._prepare_ofx_transaction_line(transaction)
if vals:
transactions.append(vals)
total_amt += vals["amount"]
balance = float(account.statement.balance)
vals_bank_statement = {
"name": account.number,
"transactions": transactions,
"balance_start": balance - total_amt,
"balance_end_real": balance,
}
result.append(
(account.statement.currency, account.number, [vals_bank_statement])
)
except Exception as e:
raise UserError(
_(
"The following problem occurred during import. "
"The file might not be valid.\n\n %s"
)
% str(e)
) from e
return result
| 32.545455 | 2,864 |
327 |
py
|
PYTHON
|
15.0
|
from odoo import models
class AccountJournal(models.Model):
_inherit = "account.journal"
def _get_bank_statements_available_import_formats(self):
"""Adds ofx to supported import formats."""
rslt = super()._get_bank_statements_available_import_formats()
rslt.append("ofx")
return rslt
| 29.727273 | 327 |
647 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# Licence LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl-3.0).
{
"name": "Base module for Bank Statement Import",
"category": "Accounting",
"version": "15.0.1.0.0",
"license": "LGPL-3",
"depends": ["account"],
"author": "Akretion, Odoo Community Association (OCA)",
"maintainers": ["alexis-via"],
"development_status": "Mature",
"website": "https://github.com/OCA/bank-statement-import",
"data": [
"views/account_bank_statement_line.xml",
],
"installable": True,
}
| 34.052632 | 647 |
2,885 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
from odoo import api, models
from odoo.addons.base.models.res_bank import sanitize_account_number
class AccountJournal(models.Model):
_inherit = "account.journal"
def _statement_line_import_speeddict(self):
"""This method is designed to be inherited by reconciliation modules.
These modules can take advantage of this method to pre-fetch data
that will later be used for many statement lines (to avoid
searching data for each statement line).
The goal is to improve performances.
"""
self.ensure_one()
speeddict = {"account_number": {}}
partner_banks = self.env["res.partner.bank"].search_read(
[("company_id", "in", (False, self.company_id.id))],
["acc_number", "partner_id"],
)
for partner_bank in partner_banks:
speeddict["account_number"][partner_bank["acc_number"]] = {
"partner_id": partner_bank["partner_id"][0],
"partner_bank_id": partner_bank["id"],
}
return speeddict
def _statement_line_import_update_hook(self, st_line_vals, speeddict):
"""This method is designed to be inherited by reconciliation modules.
In this method you can:
- update the partner of the line by writing st_line_vals['partner_id']
- set an automated counter-part via counterpart_account_id by writing
st_line_vals['counterpart_account_id']
- do anythink you want with the statement line
"""
self.ensure_one()
if st_line_vals.get("account_number"):
st_line_vals["account_number"] = self._sanitize_bank_account_number(
st_line_vals["account_number"]
)
if not st_line_vals.get("partner_id") and speeddict["account_number"].get(
st_line_vals["account_number"]
):
st_line_vals.update(
speeddict["account_number"][st_line_vals["account_number"]]
)
def _statement_line_import_update_unique_import_id(
self, st_line_vals, account_number
):
self.ensure_one()
if st_line_vals.get("unique_import_id"):
sanitized_acc_number = self._sanitize_bank_account_number(account_number)
st_line_vals["unique_import_id"] = (
(sanitized_acc_number and sanitized_acc_number + "-" or "")
+ str(self.id)
+ "-"
+ st_line_vals["unique_import_id"]
)
@api.model
def _sanitize_bank_account_number(self, account_number):
"""Hook for extension"""
return sanitize_account_number(account_number)
| 41.811594 | 2,885 |
751 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class AccountBankStatementLine(models.Model):
_inherit = "account.bank.statement.line"
# Ensure transactions can be imported only once
# if the import format provides unique transaction IDs
unique_import_id = fields.Char(string="Import ID", readonly=True, copy=False)
raw_data = fields.Text(readonly=True, copy=False)
_sql_constraints = [
(
"unique_import_id",
"unique(unique_import_id)",
"A bank account transaction can be imported only once!",
)
]
| 34.136364 | 751 |
1,066 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow, S.L.
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Bank Statement TXT/CSV/XLSX Import",
"summary": "Import TXT/CSV or XLSX files as Bank Statements in Odoo",
"version": "15.0.2.0.1",
"category": "Accounting",
"website": "https://github.com/OCA/bank-statement-import",
"author": "ForgeFlow, CorporateHub, Odoo Community Association (OCA)",
"maintainers": ["alexey-pelykh"],
"license": "AGPL-3",
"installable": True,
"depends": [
"account_statement_import",
"multi_step_wizard",
"web_widget_dropdown_dynamic",
],
"external_dependencies": {"python": ["xlrd", "chardet"]},
"data": [
"security/ir.model.access.csv",
"data/map_data.xml",
"views/account_statement_import_sheet_mapping.xml",
"views/account_statement_import.xml",
"views/account_journal_views.xml",
"wizards/account_statement_import_sheet_mapping_wizard.xml",
],
}
| 36.758621 | 1,066 |
1,206 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 AppsToGROW - Henrik Norlin
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from openupgradelib import openupgrade
_fields_to_add = [
(
"amount_debit_column",
"account.statement.import.sheet.mapping",
"account_statement_import_sheet_mapping",
"char",
"varchar",
"account_statement_import_txt_xlsx",
),
(
"amount_credit_column",
"account.statement.import.sheet.mapping",
"account_statement_import_sheet_mapping",
"char",
"varchar",
"account_statement_import_txt_xlsx",
),
]
def add_fields_and_drop_not_null(env):
cr = env.cr
sql_debit_exists = """SELECT count(id) FROM ir_model_fields
WHERE name = 'amount_debit_column'
AND model = 'account.statement.import.sheet.mapping';"""
cr.execute(sql_debit_exists)
if cr.fetchone()[0] > 0:
openupgrade.add_fields(env, _fields_to_add)
cr.execute(
"""ALTER TABLE account_statement_import_sheet_mapping
ALTER COLUMN amount_column DROP NOT NULL;"""
)
@openupgrade.migrate()
def migrate(env, version):
add_fields_and_drop_not_null(env)
| 28.714286 | 1,206 |
18,085 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow, S.L.
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from base64 import b64encode
from os import path
from odoo import fields
from odoo.exceptions import UserError
from odoo.tests import common
class TestAccountBankStatementImportTxtXlsx(common.TransactionCase):
def setUp(self):
super().setUp()
self.now = fields.Datetime.now()
self.currency_eur = self.env.ref("base.EUR")
self.currency_usd = self.env.ref("base.USD")
# Activate EUR for unit test, by default is not active
self.currency_eur.active = True
self.sample_statement_map = self.env.ref(
"account_statement_import_txt_xlsx.sample_statement_map"
)
self.AccountJournal = self.env["account.journal"]
self.AccountBankStatement = self.env["account.bank.statement"]
self.AccountStatementImport = self.env["account.statement.import"]
self.AccountStatementImportSheetMapping = self.env[
"account.statement.import.sheet.mapping"
]
self.AccountStatementImportSheetMappingWizard = self.env[
"account.statement.import.sheet.mapping.wizard"
]
self.suspense_account = self.env["account.account"].create(
{
"code": "987654",
"name": "Suspense Account",
"user_type_id": self.env.ref(
"account.data_account_type_current_assets"
).id,
}
)
def _data_file(self, filename, encoding=None):
mode = "rt" if encoding else "rb"
with open(path.join(path.dirname(__file__), filename), mode) as file:
data = file.read()
if encoding:
data = data.encode(encoding)
return b64encode(data)
def test_import_csv_file(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/sample_statement_en.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/sample_statement_en.csv",
"statement_file": data,
"sheet_mapping_id": self.sample_statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 2)
def test_import_empty_csv_file(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/empty_statement_en.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/empty_statement_en.csv",
"statement_file": data,
"sheet_mapping_id": self.sample_statement_map.id,
}
)
with self.assertRaises(UserError):
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 0)
def test_import_xlsx_file(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/sample_statement_en.xlsx")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/sample_statement_en.xlsx",
"statement_file": data,
"sheet_mapping_id": self.sample_statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 2)
def test_import_empty_xlsx_file(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/empty_statement_en.xlsx")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/empty_statement_en.xlsx",
"statement_file": data,
"sheet_mapping_id": self.sample_statement_map.id,
}
)
with self.assertRaises(UserError):
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 0)
def test_mapping_import_wizard_xlsx(self):
with common.Form(self.AccountStatementImportSheetMappingWizard) as form:
attachment = self.env["ir.attachment"].create(
{
"name": "fixtures/empty_statement_en.xlsx",
"datas": self._data_file("fixtures/empty_statement_en.xlsx"),
}
)
form.attachment_ids.add(attachment)
self.assertEqual(len(form.header), 90)
self.assertEqual(
len(
self.AccountStatementImportSheetMappingWizard.with_context(
header=form.header,
).statement_columns()
),
7,
)
form.timestamp_column = "Date"
form.amount_column = "Amount"
wizard = form.save()
wizard.import_mapping()
def test_mapping_import_wizard_csv(self):
with common.Form(self.AccountStatementImportSheetMappingWizard) as form:
attachment = self.env["ir.attachment"].create(
{
"name": "fixtures/empty_statement_en.csv",
"datas": self._data_file("fixtures/empty_statement_en.csv"),
}
)
form.attachment_ids.add(attachment)
self.assertEqual(len(form.header), 90)
self.assertEqual(
len(
self.AccountStatementImportSheetMappingWizard.with_context(
header=form.header,
).statement_columns()
),
7,
)
form.timestamp_column = "Date"
form.amount_column = "Amount"
wizard = form.save()
wizard.import_mapping()
def test_original_currency(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/original_currency.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/original_currency.csv",
"statement_file": data,
"sheet_mapping_id": self.sample_statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 1)
line = statement.line_ids
self.assertEqual(line.currency_id, self.currency_usd)
self.assertEqual(line.amount, 1525.0)
self.assertEqual(line.foreign_currency_id, self.currency_eur)
self.assertEqual(line.amount_currency, 1000.0)
def test_original_currency_no_header(self):
no_header_statement_map = self.AccountStatementImportSheetMapping.create(
{
"name": "Sample Statement",
"float_thousands_sep": "comma",
"float_decimal_sep": "dot",
"delimiter": "comma",
"quotechar": '"',
"timestamp_format": "%m/%d/%Y",
"no_header": True,
"timestamp_column": "0",
"amount_column": "3",
"original_currency_column": "2",
"original_amount_column": "4",
"description_column": "1,7",
"partner_name_column": "5",
"bank_account_column": "6",
}
)
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/original_currency_no_header.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/original_currency.csv",
"statement_file": data,
"sheet_mapping_id": no_header_statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 1)
line = statement.line_ids
self.assertEqual(line.currency_id, self.currency_usd)
self.assertEqual(line.foreign_currency_id, self.currency_eur)
self.assertEqual(line.amount_currency, 1000.0)
self.assertEqual(line.payment_ref, "Your payment INV0001")
def test_original_currency_empty(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
data = self._data_file("fixtures/original_currency_empty.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/original_currency_empty.csv",
"statement_file": data,
"sheet_mapping_id": self.sample_statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 1)
line = statement.line_ids
self.assertFalse(line.foreign_currency_id)
self.assertEqual(line.amount_currency, 0.0)
def test_multi_currency(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
statement_map = self.sample_statement_map.copy(
{
"currency_column": "Currency",
"original_currency_column": None,
"original_amount_column": None,
}
)
data = self._data_file("fixtures/multi_currency.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/multi_currency.csv",
"statement_file": data,
"sheet_mapping_id": statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 1)
line = statement.line_ids
self.assertFalse(line.foreign_currency_id)
self.assertEqual(line.amount, -33.5)
def test_balance(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
statement_map = self.sample_statement_map.copy(
{
"balance_column": "Balance",
"original_currency_column": None,
"original_amount_column": None,
}
)
data = self._data_file("fixtures/balance.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/balance.csv",
"statement_file": data,
"sheet_mapping_id": statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 2)
self.assertEqual(statement.balance_start, 10.0)
self.assertEqual(statement.balance_end_real, 1510.0)
self.assertEqual(statement.balance_end, 1510.0)
def test_debit_credit(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
statement_map = self.sample_statement_map.copy(
{
"balance_column": "Balance",
"original_currency_column": None,
"original_amount_column": None,
"debit_credit_column": "D/C",
"debit_value": "D",
"credit_value": "C",
}
)
data = self._data_file("fixtures/debit_credit.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/debit_credit.csv",
"statement_file": data,
"sheet_mapping_id": statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 2)
self.assertEqual(statement.balance_start, 10.0)
self.assertEqual(statement.balance_end_real, 1510.0)
self.assertEqual(statement.balance_end, 1510.0)
def test_debit_credit_amount(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_usd.id,
"suspense_account_id": self.suspense_account.id,
}
)
statement_map = self.sample_statement_map.copy(
{
"amount_debit_column": "Debit",
"amount_credit_column": "Credit",
"balance_column": "Balance",
"amount_column": None,
"original_currency_column": None,
"original_amount_column": None,
}
)
data = self._data_file("fixtures/debit_credit_amount.csv", "utf-8")
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/debit_credit_amount.csv",
"statement_file": data,
"sheet_mapping_id": statement_map.id,
}
)
wizard.with_context(
account_statement_import_txt_xlsx_test=True
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 4)
self.assertEqual(statement.balance_start, 10.0)
self.assertEqual(statement.balance_end_real, 1510.0)
self.assertEqual(statement.balance_end, 1510.0)
| 40.011062 | 18,085 |
6,191 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow, S.L.
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class AccountStatementImportSheetMapping(models.Model):
_name = "account.statement.import.sheet.mapping"
_description = "Bank Statement Import Sheet Mapping"
name = fields.Char(
required=True,
)
float_thousands_sep = fields.Selection(
string="Thousands Separator",
selection=[("dot", "dot (.)"), ("comma", "comma (,)"), ("none", "none")],
default="dot",
)
float_decimal_sep = fields.Selection(
string="Decimals Separator",
selection=[("dot", "dot (.)"), ("comma", "comma (,)"), ("none", "none")],
default="comma",
)
file_encoding = fields.Selection(
string="Encoding",
selection=[
("utf-8", "UTF-8"),
("utf-8-sig", "UTF-8 (with BOM)"),
("utf-16", "UTF-16"),
("utf-16-sig", "UTF-16 (with BOM)"),
("windows-1252", "Western (Windows-1252)"),
("iso-8859-1", "Western (Latin-1 / ISO 8859-1)"),
("iso-8859-2", "Central European (Latin-2 / ISO 8859-2)"),
("iso-8859-4", "Baltic (Latin-4 / ISO 8859-4)"),
("big5", "Traditional Chinese (big5)"),
("gb18030", "Unified Chinese (gb18030)"),
("shift_jis", "Japanese (Shift JIS)"),
("windows-1251", "Cyrillic (Windows-1251)"),
("koi8_r", "Cyrillic (KOI8-R)"),
("koi8_u", "Cyrillic (KOI8-U)"),
],
default="utf-8",
)
delimiter = fields.Selection(
selection=[
("dot", "dot (.)"),
("comma", "comma (,)"),
("semicolon", "semicolon (;)"),
("tab", "tab"),
("space", "space"),
("n/a", "N/A"),
],
default="comma",
)
quotechar = fields.Char(string="Text qualifier", size=1, default='"')
timestamp_format = fields.Char(required=True)
no_header = fields.Boolean(
string="File does not contain header line",
help="When this occurs please indicate the column number in the Columns section "
"instead of the column name, considering that the first column is 0",
)
timestamp_column = fields.Char(required=True)
currency_column = fields.Char(
help=(
"In case statement is multi-currency, column to get currency of "
"transaction from"
),
)
amount_column = fields.Char(
help="Amount of transaction in journal's currency",
)
amount_debit_column = fields.Char(
string="Debit amount column",
help="Debit amount of transaction in journal's currency",
)
amount_credit_column = fields.Char(
string="Credit amount column",
help="Credit amount of transaction in journal's currency",
)
balance_column = fields.Char(
help="Balance after transaction in journal's currency",
)
original_currency_column = fields.Char(
help=(
"In case statement provides original currency for transactions "
"with automatic currency conversion, column to get original "
"currency of transaction from"
),
)
original_amount_column = fields.Char(
help=(
"In case statement provides original currency for transactions "
"with automatic currency conversion, column to get original "
"transaction amount in original transaction currency from"
),
)
debit_credit_column = fields.Char(
string="Debit/credit column",
help=(
"Some statement formats use absolute amount value and indicate sign"
"of the transaction by specifying if it was a debit or a credit one"
),
)
debit_value = fields.Char(
help="Value of debit/credit column that indicates if it's a debit",
default="D",
)
credit_value = fields.Char(
help="Value of debit/credit column that indicates if it's a credit",
default="C",
)
transaction_id_column = fields.Char(
string="Unique transaction ID column",
)
description_column = fields.Char()
notes_column = fields.Char()
reference_column = fields.Char()
partner_name_column = fields.Char()
bank_name_column = fields.Char(
help="Partner's bank",
)
bank_account_column = fields.Char(
help="Partner's bank account",
)
_sql_constraints = [
(
"check_amount_columns",
(
"CHECK("
"amount_column IS NULL "
"OR (amount_debit_column IS NULL AND amount_credit_column IS NULL)"
")"
),
"Use amount_column OR (amount_debit_column AND amount_credit_column).",
),
]
@api.onchange("float_thousands_sep")
def onchange_thousands_separator(self):
if "dot" == self.float_thousands_sep == self.float_decimal_sep:
self.float_decimal_sep = "comma"
elif "comma" == self.float_thousands_sep == self.float_decimal_sep:
self.float_decimal_sep = "dot"
@api.onchange("float_decimal_sep")
def onchange_decimal_separator(self):
if "dot" == self.float_thousands_sep == self.float_decimal_sep:
self.float_thousands_sep = "comma"
elif "comma" == self.float_thousands_sep == self.float_decimal_sep:
self.float_thousands_sep = "dot"
def _get_float_separators(self):
self.ensure_one()
separators = {
"dot": ".",
"comma": ",",
"none": "",
}
return (
separators[self.float_thousands_sep],
separators[self.float_decimal_sep],
)
@api.model
def _decode_column_delimiter_character(self, delimiter):
return (
{"dot": ".", "comma": ",", "semicolon": ";", "tab": "\t", "space": " "}
).get(delimiter)
def _get_column_delimiter_character(self):
return self._decode_column_delimiter_character(self.delimiter)
| 35.786127 | 6,191 |
562 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow, S.L.
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class AccountJournal(models.Model):
_inherit = "account.journal"
default_sheet_mapping_id = fields.Many2one(
comodel_name="account.statement.import.sheet.mapping",
)
def _get_bank_statements_available_import_formats(self):
res = super()._get_bank_statements_available_import_formats()
res.append("TXT/CSV/XSLX")
return res
| 31.222222 | 562 |
15,711 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow, S.L.
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import itertools
import logging
from datetime import datetime
from decimal import Decimal
from io import StringIO
from os import path
from odoo import _, api, models
from odoo.exceptions import UserError
_logger = logging.getLogger(__name__)
try:
from csv import reader
import xlrd
from xlrd.xldate import xldate_as_datetime
except (ImportError, IOError) as err: # pragma: no cover
_logger.error(err)
try:
import chardet
except ImportError:
_logger.warning(
"chardet library not found, please install it "
"from http://pypi.python.org/pypi/chardet"
)
class AccountStatementImportSheetParser(models.TransientModel):
_name = "account.statement.import.sheet.parser"
_description = "Bank Statement Import Sheet Parser"
@api.model
def parse_header(self, data_file, encoding, csv_options):
try:
workbook = xlrd.open_workbook(
file_contents=data_file,
encoding_override=encoding if encoding else None,
)
sheet = workbook.sheet_by_index(0)
values = sheet.row_values(0)
return [str(value) for value in values]
except xlrd.XLRDError:
_logger.error("Pass this method")
data = StringIO(data_file.decode(encoding or "utf-8"))
csv_data = reader(data, **csv_options)
return list(next(csv_data))
@api.model
def parse(self, data_file, mapping, filename):
journal = self.env["account.journal"].browse(self.env.context.get("journal_id"))
currency_code = (journal.currency_id or journal.company_id.currency_id).name
account_number = journal.bank_account_id.acc_number
lines = self._parse_lines(mapping, data_file, currency_code)
if not lines:
return currency_code, account_number, [{"transactions": []}]
lines = list(sorted(lines, key=lambda line: line["timestamp"]))
first_line = lines[0]
last_line = lines[-1]
data = {
"date": first_line["timestamp"].date(),
"name": _("%(code)s: %(filename)s")
% {
"code": journal.code,
"filename": path.basename(filename),
},
}
if mapping.balance_column:
balance_start = first_line["balance"]
balance_start -= first_line["amount"]
balance_end = last_line["balance"]
data.update(
{
"balance_start": float(balance_start),
"balance_end_real": float(balance_end),
}
)
transactions = list(
itertools.chain.from_iterable(
map(lambda line: self._convert_line_to_transactions(line), lines)
)
)
data.update({"transactions": transactions})
return currency_code, account_number, [data]
def _get_column_indexes(self, header, column_name, mapping):
column_indexes = []
if mapping[column_name] and "," in mapping[column_name]:
# We have to concatenate the values
column_names_or_indexes = mapping[column_name].split(",")
else:
column_names_or_indexes = [mapping[column_name]]
for column_name_or_index in column_names_or_indexes:
if not column_name_or_index:
continue
column_index = None
if mapping.no_header:
try:
column_index = int(column_name_or_index)
# pylint: disable=except-pass
except Exception:
pass
if column_index is not None:
column_indexes.append(column_index)
else:
if column_name_or_index:
column_indexes.append(header.index(column_name_or_index))
return column_indexes
def _get_column_names(self):
return [
"timestamp_column",
"currency_column",
"amount_column",
"amount_debit_column",
"amount_credit_column",
"balance_column",
"original_currency_column",
"original_amount_column",
"debit_credit_column",
"transaction_id_column",
"description_column",
"notes_column",
"reference_column",
"partner_name_column",
"bank_name_column",
"bank_account_column",
]
def _parse_lines(self, mapping, data_file, currency_code):
columns = dict()
try:
workbook = xlrd.open_workbook(
file_contents=data_file,
encoding_override=(
mapping.file_encoding if mapping.file_encoding else None
),
)
csv_or_xlsx = (
workbook,
workbook.sheet_by_index(0),
)
except xlrd.XLRDError:
csv_options = {}
csv_delimiter = mapping._get_column_delimiter_character()
if csv_delimiter:
csv_options["delimiter"] = csv_delimiter
if mapping.quotechar:
csv_options["quotechar"] = mapping.quotechar
try:
decoded_file = data_file.decode(mapping.file_encoding or "utf-8")
except UnicodeDecodeError:
# Try auto guessing the format
detected_encoding = chardet.detect(data_file).get("encoding", False)
if not detected_encoding:
raise UserError(
_("No valid encoding was found for the attached file")
) from None
decoded_file = data_file.decode(detected_encoding)
csv_or_xlsx = reader(StringIO(decoded_file), **csv_options)
header = False
if not mapping.no_header:
if isinstance(csv_or_xlsx, tuple):
header = [str(value) for value in csv_or_xlsx[1].row_values(0)]
else:
header = [value.strip() for value in next(csv_or_xlsx)]
for column_name in self._get_column_names():
columns[column_name] = self._get_column_indexes(
header, column_name, mapping
)
return self._parse_rows(mapping, currency_code, csv_or_xlsx, columns)
def _get_values_from_column(self, values, columns, column_name):
indexes = columns[column_name]
content_l = []
max_index = len(values) - 1
for index in indexes:
if isinstance(index, int):
if index <= max_index:
content_l.append(values[index])
else:
if index in values:
content_l.append(values[index])
if all(isinstance(content, str) for content in content_l):
return " ".join(content_l)
return content_l[0]
def _parse_rows(self, mapping, currency_code, csv_or_xlsx, columns): # noqa: C901
if isinstance(csv_or_xlsx, tuple):
rows = range(1, csv_or_xlsx[1].nrows)
else:
rows = csv_or_xlsx
lines = []
for row in rows:
if isinstance(csv_or_xlsx, tuple):
book = csv_or_xlsx[0]
sheet = csv_or_xlsx[1]
values = []
for col_index in range(sheet.row_len(row)):
cell_type = sheet.cell_type(row, col_index)
cell_value = sheet.cell_value(row, col_index)
if cell_type == xlrd.XL_CELL_DATE:
cell_value = xldate_as_datetime(cell_value, book.datemode)
values.append(cell_value)
else:
values = list(row)
timestamp = self._get_values_from_column(
values, columns, "timestamp_column"
)
currency = (
self._get_values_from_column(values, columns, "currency_column")
if columns["currency_column"]
else currency_code
)
def _decimal(column_name):
if columns[column_name]:
return self._parse_decimal(
self._get_values_from_column(values, columns, column_name),
mapping,
)
amount = _decimal("amount_column")
if not amount:
amount = abs(_decimal("amount_debit_column") or 0)
if not amount:
amount = -abs(_decimal("amount_credit_column") or 0)
balance = (
self._get_values_from_column(values, columns, "balance_column")
if columns["balance_column"]
else None
)
original_currency = (
self._get_values_from_column(
values, columns, "original_currency_column"
)
if columns["original_currency_column"]
else None
)
original_amount = (
self._get_values_from_column(values, columns, "original_amount_column")
if columns["original_amount_column"]
else None
)
debit_credit = (
self._get_values_from_column(values, columns, "debit_credit_column")
if columns["debit_credit_column"]
else None
)
transaction_id = (
self._get_values_from_column(values, columns, "transaction_id_column")
if columns["transaction_id_column"]
else None
)
description = (
self._get_values_from_column(values, columns, "description_column")
if columns["description_column"]
else None
)
notes = (
self._get_values_from_column(values, columns, "notes_column")
if columns["notes_column"]
else None
)
reference = (
self._get_values_from_column(values, columns, "reference_column")
if columns["reference_column"]
else None
)
partner_name = (
self._get_values_from_column(values, columns, "partner_name_column")
if columns["partner_name_column"]
else None
)
bank_name = (
self._get_values_from_column(values, columns, "bank_name_column")
if columns["bank_name_column"]
else None
)
bank_account = (
self._get_values_from_column(values, columns, "bank_account_column")
if columns["bank_account_column"]
else None
)
if currency != currency_code:
continue
if isinstance(timestamp, str):
timestamp = datetime.strptime(timestamp, mapping.timestamp_format)
if balance:
balance = self._parse_decimal(balance, mapping)
else:
balance = None
if debit_credit:
amount = amount.copy_abs()
if debit_credit == mapping.debit_value:
amount = -amount
if original_amount:
original_amount = self._parse_decimal(
original_amount, mapping
).copy_sign(amount)
else:
original_amount = 0.0
line = {
"timestamp": timestamp,
"amount": amount,
"currency": currency,
"original_amount": original_amount,
"original_currency": original_currency,
}
if balance is not None:
line["balance"] = balance
if transaction_id is not None:
line["transaction_id"] = transaction_id
if description is not None:
line["description"] = description
if notes is not None:
line["notes"] = notes
if reference is not None:
line["reference"] = reference
if partner_name is not None:
line["partner_name"] = partner_name
if bank_name is not None:
line["bank_name"] = bank_name
if bank_account is not None:
line["bank_account"] = bank_account
lines.append(line)
return lines
@api.model
def _convert_line_to_transactions(self, line): # noqa: C901
"""Hook for extension"""
timestamp = line["timestamp"]
amount = line["amount"]
currency = line["currency"]
original_amount = line["original_amount"]
original_currency = line["original_currency"]
transaction_id = line.get("transaction_id")
description = line.get("description")
notes = line.get("notes")
reference = line.get("reference")
partner_name = line.get("partner_name")
bank_name = line.get("bank_name")
bank_account = line.get("bank_account")
transaction = {
"date": timestamp,
"amount": str(amount),
}
if original_currency == currency:
original_currency = None
if not amount:
amount = original_amount
original_amount = "0.0"
if original_currency:
original_currency = self.env["res.currency"].search(
[("name", "=", original_currency)],
limit=1,
)
if original_currency:
transaction["foreign_currency_id"] = original_currency.id
if original_amount:
transaction["amount_currency"] = str(original_amount)
if currency:
currency = self.env["res.currency"].search(
[("name", "=", currency)],
limit=1,
)
if currency:
transaction["currency_id"] = currency.id
if transaction_id:
transaction["unique_import_id"] = "{}-{}".format(
transaction_id,
int(timestamp.timestamp()),
)
transaction["payment_ref"] = description or _("N/A")
if reference:
transaction["ref"] = reference
note = ""
if bank_name:
note += _("Bank: %s; ") % (bank_name,)
if bank_account:
note += _("Account: %s; ") % (bank_account,)
if transaction_id:
note += _("Transaction ID: %s; ") % (transaction_id,)
if note and notes:
note = "{}\n{}".format(notes, note.strip())
elif note:
note = note.strip()
elif notes:
note = notes
if note:
transaction["narration"] = note
if partner_name:
transaction["partner_name"] = partner_name
if bank_account:
transaction["account_number"] = bank_account
return [transaction]
@api.model
def _parse_decimal(self, value, mapping):
if isinstance(value, Decimal):
return value
elif isinstance(value, float):
return Decimal(value)
thousands, decimal = mapping._get_float_separators()
value = value.replace(thousands, "")
value = value.replace(decimal, ".")
return Decimal(value)
| 36.117241 | 15,711 |
1,805 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from odoo import fields, models
_logger = logging.getLogger(__name__)
class AccountStatementImport(models.TransientModel):
_inherit = "account.statement.import"
def _get_default_mapping_id(self):
return (
self.env["account.journal"]
.browse(self.env.context.get("journal_id"))
.default_sheet_mapping_id
)
sheet_mapping_id = fields.Many2one(
string="Sheet mapping",
comodel_name="account.statement.import.sheet.mapping",
default=_get_default_mapping_id,
)
def _parse_file(self, data_file):
self.ensure_one()
if self.sheet_mapping_id:
try:
Parser = self.env["account.statement.import.sheet.parser"]
return Parser.parse(
data_file, self.sheet_mapping_id, self.statement_filename
)
except BaseException:
if self.env.context.get("account_statement_import_txt_xlsx_test"):
raise
_logger.warning("Sheet parser error", exc_info=True)
return super()._parse_file(data_file)
def _create_bank_statements(self, stmts_vals, result):
"""Set balance_end_real if not already provided by the file."""
res = super()._create_bank_statements(stmts_vals, result)
statements = self.env["account.bank.statement"].browse(result["statement_ids"])
for statement in statements:
if not statement.balance_end_real:
amount = sum(statement.line_ids.mapped("amount"))
statement.balance_end_real = statement.balance_start + amount
return res
| 36.836735 | 1,805 |
6,594 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ForgeFlow, S.L.
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import json
from base64 import b64decode
from os import path
from odoo import _, api, fields, models
class AccountStatementImportSheetMappingWizard(models.TransientModel):
_name = "account.statement.import.sheet.mapping.wizard"
_description = "Bank Statement Import Sheet Mapping Wizard"
_inherit = ["multi.step.wizard.mixin"]
attachment_ids = fields.Many2many(
comodel_name="ir.attachment",
string="Files",
required=True,
relation="account_statement_import_sheet_mapping_wiz_attachment_rel",
)
header = fields.Char()
file_encoding = fields.Selection(
string="Encoding",
selection=lambda self: self._selection_file_encoding(),
)
delimiter = fields.Selection(
selection=lambda self: self._selection_delimiter(),
)
quotechar = fields.Char(
string="Text qualifier",
size=1,
)
timestamp_column = fields.Char()
currency_column = fields.Char(
help=(
"In case statement is multi-currency, column to get currency of "
"transaction from"
),
)
amount_column = fields.Char(
help="Amount of transaction in journal's currency",
)
amount_debit_column = fields.Char(
string="Debit amount column",
help="Debit amount of transaction in journal's currency",
)
amount_credit_column = fields.Boolean(
string="Credit amount column",
help="Credit amount of transaction in journal's currency",
)
balance_column = fields.Char(
help="Balance after transaction in journal's currency",
)
original_currency_column = fields.Char(
help=(
"In case statement provides original currency for transactions "
"with automatic currency conversion, column to get original "
"currency of transaction from"
),
)
original_amount_column = fields.Char(
help=(
"In case statement provides original currency for transactions "
"with automatic currency conversion, column to get original "
"transaction amount in original transaction currency from"
),
)
debit_credit_column = fields.Char(
string="Debit/credit column",
help=(
"Some statement formats use absolute amount value and indicate sign"
"of the transaction by specifying if it was a debit or a credit one"
),
)
debit_value = fields.Char(
help="Value of debit/credit column that indicates if it's a debit",
default="D",
)
credit_value = fields.Char(
help="Value of debit/credit column that indicates if it's a credit",
default="C",
)
transaction_id_column = fields.Char(
string="Unique transaction ID column",
)
description_column = fields.Char()
notes_column = fields.Char()
reference_column = fields.Char()
partner_name_column = fields.Char()
bank_name_column = fields.Char(
help="Partner's bank",
)
bank_account_column = fields.Char(
help="Partner's bank account",
)
@api.model
def _selection_file_encoding(self):
return (
self.env["account.statement.import.sheet.mapping"]
._fields["file_encoding"]
.selection
)
@api.model
def _selection_delimiter(self):
return (
self.env["account.statement.import.sheet.mapping"]
._fields["delimiter"]
.selection
)
@api.onchange("attachment_ids")
def _onchange_attachment_ids(self):
Parser = self.env["account.statement.import.sheet.parser"]
Mapping = self.env["account.statement.import.sheet.mapping"]
if not self.attachment_ids:
return
csv_options = {}
if self.delimiter:
csv_options["delimiter"] = Mapping._decode_column_delimiter_character(
self.delimiter
)
if self.quotechar:
csv_options["quotechar"] = self.quotechar
header = []
for data_file in self.attachment_ids:
header += Parser.parse_header(
b64decode(data_file.datas), self.file_encoding, csv_options
)
header = list(set(header))
self.header = json.dumps(header)
@api.model
def statement_columns(self):
header = self.env.context.get("header")
if not header:
return []
return [(x, x) for x in json.loads(header)]
def _get_mapping_values(self):
"""Hook for extension"""
self.ensure_one()
filename = "& ".join(self.attachment_ids.mapped("name"))
return {
"name": _("Mapping from %s") % path.basename(filename),
"float_thousands_sep": "comma",
"float_decimal_sep": "dot",
"file_encoding": self.file_encoding,
"delimiter": self.delimiter,
"quotechar": self.quotechar,
"timestamp_format": "%d/%m/%Y",
"timestamp_column": self.timestamp_column,
"currency_column": self.currency_column,
"amount_column": self.amount_column,
"balance_column": self.balance_column,
"original_currency_column": self.original_currency_column,
"original_amount_column": self.original_amount_column,
"debit_credit_column": self.debit_credit_column,
"debit_value": self.debit_value,
"credit_value": self.credit_value,
"transaction_id_column": self.transaction_id_column,
"description_column": self.description_column,
"notes_column": self.notes_column,
"reference_column": self.reference_column,
"partner_name_column": self.partner_name_column,
"bank_name_column": self.bank_name_column,
"bank_account_column": self.bank_account_column,
}
def import_mapping(self):
self.ensure_one()
mapping = self.env["account.statement.import.sheet.mapping"].create(
self._get_mapping_values()
)
return {
"type": "ir.actions.act_window",
"name": _("Imported Mapping"),
"res_model": "account.statement.import.sheet.mapping",
"res_id": mapping.id,
"view_mode": "form",
"view_id": False,
"target": "current",
}
| 35.451613 | 6,594 |
1,100 |
py
|
PYTHON
|
15.0
|
# Copyright 2004-2020 Odoo S.A.
# Copyright 2020 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# Licence LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl-3.0).
{
"name": "Import Statement Files",
"category": "Accounting",
"version": "15.0.3.1.0",
"license": "LGPL-3",
"depends": ["account_statement_import_base"],
"author": "Odoo SA, Akretion, Odoo Community Association (OCA)",
"maintainers": ["alexis-via"],
"development_status": "Mature",
"website": "https://github.com/OCA/bank-statement-import",
"data": [
"security/ir.model.access.csv",
"wizard/account_statement_import_view.xml",
"views/account_journal.xml",
],
"demo": [
"demo/partner_bank.xml",
],
"installable": True,
"assets": {
"web.assets_backend": [
"account_statement_import/static/src/js/account_dashboard_kanban.js",
],
"web.assets_qweb": [
"account_statement_import/static/src/xml/account_dashboard_kanban.xml"
],
},
}
| 33.333333 | 1,100 |
1,122 |
py
|
PYTHON
|
15.0
|
# pylint: disable=C7902
# Copyright 2022 ForgeFlow S.L. <https://www.forgeflow.com>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
if openupgrade.column_exists(
env.cr, "account_bank_statement_line", "partner_bank_id"
):
# during v14, a partner_bank_id field was added to statement lines,
# but later we realized it is not needed.
# As we remove the explicit partner_bank_id in statement line, we need to transfer the
# values to the move for getting them through delegated inheritance
openupgrade.logged_query(
env.cr,
"""
UPDATE account_move am
SET partner_bank_id = absl.partner_bank_id
FROM account_bank_statement_line absl
WHERE am.statement_line_id = absl.id
AND am.partner_bank_id IS NULL AND absl.partner_bank_id IS NOT NULL""",
)
openupgrade.lift_constraints(
env.cr, "account_bank_statement_line", "partner_bank_id"
)
| 41.555556 | 1,122 |
15,177 |
py
|
PYTHON
|
15.0
|
# Copyright 2004-2020 Odoo S.A.
# Licence LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl-3.0).
import base64
import logging
from odoo import _, api, fields, models
from odoo.exceptions import UserError
from odoo.addons.base.models.res_bank import sanitize_account_number
logger = logging.getLogger(__name__)
class AccountStatementImport(models.TransientModel):
_name = "account.statement.import"
_description = "Import Bank Statement Files"
statement_file = fields.Binary(
required=True,
help="Get you bank statements in electronic format from your bank "
"and select them here.",
)
statement_filename = fields.Char()
def _import_file(self):
self.ensure_one()
result = {
"statement_ids": [],
"notifications": [],
}
logger.info("Start to import bank statement file %s", self.statement_filename)
file_data = base64.b64decode(self.statement_file)
self.import_single_file(file_data, result)
logger.debug("result=%s", result)
if not result["statement_ids"]:
raise UserError(
_(
"You have already imported this file, or this file "
"only contains already imported transactions."
)
)
self.env["ir.attachment"].create(self._prepare_create_attachment(result))
return result
def import_file_button(self):
"""Process the file chosen in the wizard, create bank statement(s)
and return an action."""
result = self._import_file()
action = self.env["ir.actions.actions"]._for_xml_id(
"account.action_bank_statement_tree"
)
if len(result["statement_ids"]) == 1:
action.update(
{
"view_mode": "form,tree",
"views": False,
"res_id": result["statement_ids"][0],
}
)
else:
action["domain"] = [("id", "in", result["statement_ids"])]
return action
def _prepare_create_attachment(self, result):
# Attach to first bank statement
res_id = result["statement_ids"][0]
st = self.env["account.bank.statement"].browse(res_id)
vals = {
"name": self.statement_filename,
"res_id": res_id,
"company_id": st.company_id.id,
"res_model": "account.bank.statement",
"datas": self.statement_file,
}
return vals
def import_single_file(self, file_data, result):
parsing_data = self.with_context(active_id=self.ids[0])._parse_file(file_data)
if not isinstance(parsing_data, list): # for backward compatibility
parsing_data = [parsing_data]
logger.info(
"Bank statement file %s contains %d accounts",
self.statement_filename,
len(parsing_data),
)
i = 0
for single_statement_data in parsing_data:
i += 1
logger.debug(
"account %d: single_statement_data=%s", i, single_statement_data
)
self.import_single_statement(single_statement_data, result)
def import_single_statement(self, single_statement_data, result):
if not isinstance(single_statement_data, tuple):
raise UserError(
_("The parsing of the statement file returned an invalid result.")
)
currency_code, account_number, stmts_vals = single_statement_data
# Check raw data
if not self._check_parsed_data(stmts_vals):
return False
if not currency_code:
raise UserError(_("Missing currency code in the bank statement file."))
# account_number can be None (example : QIF)
currency = self._match_currency(currency_code)
journal = self._match_journal(account_number, currency)
if not journal.default_account_id:
raise UserError(
_("The Bank Accounting Account is not set on the journal '%s'.")
% journal.display_name
)
# Prepare statement data to be used for bank statements creation
stmts_vals = self._complete_stmts_vals(stmts_vals, journal, account_number)
# Create the bank statements
self._create_bank_statements(stmts_vals, result)
# Now that the import worked out, set it as the bank_statements_source
# of the journal
if journal.bank_statements_source != "file_import":
# Use sudo() because only 'account.group_account_manager'
# has write access on 'account.journal', but 'account.group_account_user'
# must be able to import bank statement files
journal.sudo().write({"bank_statements_source": "file_import"})
def _parse_file(self, data_file):
"""Each module adding a file support must extends this method.
It processes the file if it can, returns super otherwise,
resulting in a chain of responsability.
This method parses the given file and returns the data required
by the bank statement import process, as specified below.
rtype: triplet
- currency code: string (e.g: 'EUR')
The ISO 4217 currency code, case insensitive
- account number: string (e.g: 'BE1234567890')
The number of the bank account which the statement belongs to
None if it can't be retreived from the statement file
- bank statements data: list of dict containing
(optional items marked by o) :
- 'name': string (e.g: '000000123')
- 'date': date (e.g: 2013-06-26)
-o 'balance_start': float (e.g: 8368.56)
-o 'balance_end_real': float (e.g: 8888.88)
- 'transactions': list of dict containing :
- 'payment_ref': string (label of the line)
- 'date': date
- 'amount': float
- 'unique_import_id': string
-o 'account_number': string
Will be used to find/create the res.partner.bank in odoo
-o 'partner_name': string
If the file is a multi-statement file, this method must return
a list of triplets.
"""
raise UserError(
_(
"This bank statement file format is not supported.\n"
"Did you install the Odoo module to support this format?"
)
)
def _check_parsed_data(self, stmts_vals):
"""
Basic and structural verifications.
Return False when empty data (don't raise en error, because we
support multi-statement files and we don't want one empty
statement to block the import of others)
"""
if len(stmts_vals) == 0:
return False
no_st_line = True
for vals in stmts_vals:
if vals["transactions"] and len(vals["transactions"]) > 0:
no_st_line = False
break
if no_st_line:
return False
return True
@api.model
def _match_currency(self, currency_code):
currency = self.env["res.currency"].search(
[("name", "=ilike", currency_code)], limit=1
)
if not currency:
raise UserError(
_(
"The bank statement file uses currency '%s' "
"but there is no such currency in Odoo."
)
% currency_code
)
return currency
@api.model
def _match_journal(self, account_number, currency):
company = self.env.company
journal_obj = self.env["account.journal"]
if not account_number: # exemple : QIF
if not self.env.context.get("journal_id"):
raise UserError(
_(
"The format of this bank statement file doesn't "
"contain the bank account number, so you must "
"start the wizard from the right bank journal "
"in the dashboard."
)
)
journal = journal_obj.browse(self.env.context.get("journal_id"))
else:
sanitized_account_number = sanitize_account_number(account_number)
journal = journal_obj.search(
[
("type", "=", "bank"),
(
"bank_account_id.sanitized_acc_number",
"ilike",
sanitized_account_number,
),
],
limit=1,
)
journal_id = self.env.context.get("journal_id")
if journal_id and journal.id != journal_id:
raise UserError(
_(
"The journal found for the file is not consistent with the "
"selected journal. You should use the proper journal or "
"use the generic button on the top of the Accounting Dashboard"
)
)
if not journal:
bank_accounts = self.env["res.partner.bank"].search(
[
("partner_id", "=", company.partner_id.id),
("sanitized_acc_number", "ilike", sanitized_account_number),
],
limit=1,
)
if bank_accounts:
raise UserError(
_(
"The bank account with number '%(account_number)s' exists in Odoo "
"but it is not set on any bank journal. You should "
"set it on the related bank journal. If the related "
"bank journal doesn't exist yet, you should create "
"a new one.",
account_number=account_number,
)
)
else:
raise UserError(
_(
"Could not find any bank account with number '%(account_number)s' "
"linked to partner '%(partner_name)s'. You should create the bank "
"account and set it on the related bank journal. "
"If the related bank journal doesn't exist yet, you "
"should create a new one.",
account_number=account_number,
partner_name=company.partner_id.display_name,
)
)
# We support multi-file and multi-statement in a file
# so self.env.context.get('journal_id') doesn't mean much
# I don't think we should really use it
journal_currency = journal.currency_id or company.currency_id
if journal_currency != currency:
raise UserError(
_(
"The currency of the bank statement (%(currency_name)s) "
"is not the same as the currency of the journal "
"'%(journal_name)s' (%(journal_currency_name)s).",
currency_name=currency.name,
journal_name=journal.display_name,
journal_currency_name=journal_currency.name,
)
)
return journal
def _complete_stmts_vals(self, stmts_vals, journal, account_number):
speeddict = journal._statement_line_import_speeddict()
for st_vals in stmts_vals:
st_vals["journal_id"] = journal.id
for lvals in st_vals["transactions"]:
journal._statement_line_import_update_unique_import_id(
lvals, account_number
)
journal._statement_line_import_update_hook(lvals, speeddict)
if not lvals.get("payment_ref"):
raise UserError(_("Missing payment_ref on a transaction."))
return stmts_vals
def _create_bank_statements(self, stmts_vals, result):
"""Create new bank statements from imported values,
filtering out already imported transactions,
and return data used by the reconciliation widget"""
abs_obj = self.env["account.bank.statement"]
absl_obj = self.env["account.bank.statement.line"]
# Filter out already imported transactions and create statements
statement_ids = []
existing_st_line_ids = {}
for st_vals in stmts_vals:
st_lines_to_create = []
for lvals in st_vals["transactions"]:
existing_line = False
if lvals.get("unique_import_id"):
existing_line = absl_obj.sudo().search(
[
("unique_import_id", "=", lvals["unique_import_id"]),
],
limit=1,
)
# we can only have 1 anyhow because we have a unicity SQL constraint
if existing_line:
existing_st_line_ids[existing_line.id] = True
if "balance_start" in st_vals:
st_vals["balance_start"] += float(lvals["amount"])
else:
st_lines_to_create.append(lvals)
if len(st_lines_to_create) > 0:
if not st_lines_to_create[0].get("sequence"):
for seq, vals in enumerate(st_lines_to_create, start=1):
vals["sequence"] = seq
# Remove values that won't be used to create records
st_vals.pop("transactions", None)
# Create the statement with lines
st_vals["line_ids"] = [[0, False, line] for line in st_lines_to_create]
statement = abs_obj.create(st_vals)
statement_ids.append(statement.id)
if not statement_ids:
return False
result["statement_ids"].extend(statement_ids)
# Prepare import feedback
num_ignored = len(existing_st_line_ids)
if num_ignored > 0:
result["notifications"].append(
{
"type": "warning",
"message": _(
"%d transactions had already been imported and were ignored."
)
% num_ignored
if num_ignored > 1
else _("1 transaction had already been imported and was ignored."),
"details": {
"name": _("Already imported items"),
"model": "account.bank.statement.line",
"ids": list(existing_st_line_ids.keys()),
},
}
)
| 42.275766 | 15,177 |
717 |
py
|
PYTHON
|
15.0
|
# Copyright 2004-2020 Odoo S.A.
# Licence LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl-3.0).
from odoo import models
class AccountSetupBankManualConfig(models.TransientModel):
_inherit = "account.setup.bank.manual.config"
def validate(self):
"""Default the bank statement source of new bank journals as 'file_import'"""
super().validate()
if (
self.num_journals_without_account == 0
or self.linked_journal_id.bank_statements_source == "undefined"
) and self.env[
"account.journal"
]._get_bank_statements_available_import_formats():
self.linked_journal_id.bank_statements_source = "file_import"
return
| 35.85 | 717 |
1,305 |
py
|
PYTHON
|
15.0
|
# Copyright 2004-2020 Odoo S.A.
# Copyright 2020 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# Licence LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl-3.0).
from odoo import _, models
class AccountJournal(models.Model):
_inherit = "account.journal"
def _get_bank_statements_available_import_formats(self):
"""Returns a list of strings representing the supported import formats."""
return []
def __get_bank_statements_available_sources(self):
rslt = super().__get_bank_statements_available_sources()
formats_list = self._get_bank_statements_available_import_formats()
if formats_list:
formats_list.sort()
import_formats_str = ", ".join(formats_list)
rslt.append(("file_import", _("Import") + "(" + import_formats_str + ")"))
return rslt
def import_account_statement(self):
"""return action to import bank/cash statements.
This button should be called only on journals with type =='bank'"""
action = (
self.env.ref("account_statement_import.account_statement_import_action")
.sudo()
.read()[0]
)
action["context"] = {"journal_id": self.id}
return action
| 38.382353 | 1,305 |
487 |
py
|
PYTHON
|
15.0
|
# Copyright 2013-2017 Therp BV <https://therp.nl>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "CAMT Format Bank Statements Import",
"version": "15.0.1.0.1",
"license": "AGPL-3",
"author": "Therp BV, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/bank-statement-import",
"category": "Banking addons",
"depends": ["account_statement_import"],
"data": ["views/account_bank_statement_import.xml"],
}
| 40.583333 | 487 |
6,225 |
py
|
PYTHON
|
15.0
|
# Copyright 2013-2016 Therp BV <https://therp.nl>
# Copyright 2017 Open Net Sàrl
# Copyright 2020 Camptocamp
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import base64
import difflib
import pprint
import tempfile
from datetime import date
from odoo.modules.module import get_module_resource
from odoo.tests.common import TransactionCase
class TestParser(TransactionCase):
"""Tests for the camt parser itself."""
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.parser = cls.env["account.statement.import.camt.parser"]
def _do_parse_test(self, inputfile, goldenfile):
testfile = get_module_resource(
"account_statement_import_camt", "test_files", inputfile
)
with open(testfile, "rb") as data:
res = self.parser.parse(data.read())
with tempfile.NamedTemporaryFile(mode="w+", suffix=".pydata") as temp:
pprint.pprint(res, temp, width=160)
goldenfile_res = get_module_resource(
"account_statement_import_camt", "test_files", goldenfile
)
with open(goldenfile_res, "r") as golden:
temp.seek(0)
diff = list(
difflib.unified_diff(
golden.readlines(), temp.readlines(), golden.name, temp.name
)
)
if len(diff) > 2:
self.fail(
"actual output doesn't match expected "
+ "output:\n%s" % "".join(diff)
)
def test_parse(self):
self._do_parse_test("test-camt053", "golden-camt053.pydata")
def test_parse_camt054(self):
self._do_parse_test("test-camt054", "golden-camt054.pydata")
def test_parse_txdtls(self):
self._do_parse_test("test-camt053-txdtls", "golden-camt053-txdtls.pydata")
def test_parse_no_ntry(self):
self._do_parse_test("test-camt053-no-ntry", "golden-camt053-no-ntry.pydata")
class TestImport(TransactionCase):
"""Run test to import camt import."""
transactions = [
{
"account_number": "NL46ABNA0499998748",
"amount": -754.25,
"date": date(year=2014, month=1, day=5),
"ref": "435005714488-ABNO33052620",
},
{
"remote_account": "NL46ABNA0499998748",
"transferred_amount": -564.05,
"value_date": date(year=2014, month=1, day=5),
"ref": "TESTBANK/NL/20141229/01206408",
},
{
"remote_account": "NL46ABNA0499998748",
"transferred_amount": -100.0,
"value_date": date(year=2014, month=1, day=5),
"ref": "TESTBANK/NL/20141229/01206407",
},
{
"remote_account": "NL69ABNA0522123643",
"transferred_amount": 1405.31,
"value_date": date(year=2014, month=1, day=5),
"ref": "115",
},
]
@classmethod
def setUpClass(cls):
super().setUpClass()
eur = cls.env.ref("base.EUR")
eur.write({"active": True})
bank = cls.env["res.partner.bank"].create(
{
"acc_number": "NL77ABNA0574908765",
"partner_id": cls.env.ref("base.main_partner").id,
"company_id": cls.env.ref("base.main_company").id,
"bank_id": cls.env.ref("base.res_bank_1").id,
}
)
cls.env["res.partner.bank"].create(
{
"acc_number": "NL46ABNA0499998748",
"partner_id": cls.env.ref("base.main_partner").id,
"company_id": cls.env.ref("base.main_company").id,
"bank_id": cls.env.ref("base.res_bank_1").id,
}
)
cls.env["account.journal"].create(
{
"name": "Bank Journal - (test camt)",
"code": "TBNKCAMT",
"type": "bank",
"bank_account_id": bank.id,
"currency_id": eur.id,
}
)
def test_statement_import(self):
"""Test correct creation of single statement."""
testfile = get_module_resource(
"account_statement_import_camt", "test_files", "test-camt053"
)
with open(testfile, "rb") as datafile:
camt_file = base64.b64encode(datafile.read())
self.env["account.statement.import"].create(
{
"statement_filename": "test import",
"statement_file": camt_file,
}
).import_file_button()
bank_st_record = self.env["account.bank.statement"].search(
[("name", "=", "1234Test/1")], limit=1
)
statement_lines = bank_st_record.line_ids
self.assertTrue(
any(
all(
line[key] == self.transactions[0][key]
for key in ["amount", "date", "ref"]
)
# TODO and bank_account_id was removed from line
# and line.bank_account_id.acc_number
# == self.transactions[0]["account_number"]
for line in statement_lines
)
)
def test_zip_import(self):
"""Test import of multiple statements from zip file."""
testfile = get_module_resource(
"account_statement_import_camt", "test_files", "test-camt053.zip"
)
with open(testfile, "rb") as datafile:
camt_file = base64.b64encode(datafile.read())
self.env["account.statement.import"].create(
{"statement_filename": "test import", "statement_file": camt_file}
).import_file_button()
bank_st_record = self.env["account.bank.statement"].search(
[("name", "in", ["1234Test/2", "1234Test/3"])]
)
self.assertTrue(all([st.line_ids for st in bank_st_record]))
self.assertEqual(bank_st_record[0].line_ids.mapped("sequence"), [1, 2, 3])
| 37.047619 | 6,224 |
480 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 ACSONE SA/NV <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, models
class AccountJournal(models.Model):
_inherit = "account.journal"
def _get_bank_statements_available_import_formats(self):
res = super(
AccountJournal, self
)._get_bank_statements_available_import_formats()
res.extend([_("camt.053.001.02"), _("camt.054.001.02")])
return res
| 32 | 480 |
10,603 |
py
|
PYTHON
|
15.0
|
"""Class to parse camt files."""
# Copyright 2013-2016 Therp BV <https://therp.nl>
# Copyright 2017 Open Net Sàrl
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import re
from lxml import etree
from odoo import models
class CamtParser(models.AbstractModel):
_name = "account.statement.import.camt.parser"
_description = "Account Bank Statement Import CAMT parser"
def parse_amount(self, ns, node):
"""Parse element that contains Amount and CreditDebitIndicator."""
if node is None:
return 0.0
sign = 1
amount = 0.0
sign_node = node.xpath("ns:CdtDbtInd", namespaces={"ns": ns})
if not sign_node:
sign_node = node.xpath("../../ns:CdtDbtInd", namespaces={"ns": ns})
if sign_node and sign_node[0].text == "DBIT":
sign = -1
amount_node = node.xpath("ns:Amt", namespaces={"ns": ns})
if not amount_node:
amount_node = node.xpath(
"./ns:AmtDtls/ns:TxAmt/ns:Amt", namespaces={"ns": ns}
)
if amount_node:
amount = sign * float(amount_node[0].text)
return amount
def add_value_from_node(self, ns, node, xpath_str, obj, attr_name, join_str=None):
"""Add value to object from first or all nodes found with xpath.
If xpath_str is a list (or iterable), it will be seen as a series
of search path's in order of preference. The first item that results
in a found node will be used to set a value."""
if not isinstance(xpath_str, (list, tuple)):
xpath_str = [xpath_str]
for search_str in xpath_str:
found_node = node.xpath(search_str, namespaces={"ns": ns})
if found_node:
if isinstance(found_node[0], str):
attr_value = found_node[0]
elif join_str is None:
attr_value = found_node[0].text
else:
attr_value = join_str.join([x.text for x in found_node])
obj[attr_name] = attr_value
break
def parse_transaction_details(self, ns, node, transaction):
"""Parse TxDtls node."""
# message
self.add_value_from_node(
ns,
node,
[
"./ns:RmtInf/ns:Ustrd|./ns:RtrInf/ns:AddtlInf",
"./ns:AddtlNtryInf",
"./ns:Refs/ns:InstrId",
],
transaction,
"payment_ref",
join_str="\n",
)
# name
self.add_value_from_node(
ns, node, ["./ns:AddtlTxInf"], transaction, "payment_ref", join_str="\n"
)
# eref
self.add_value_from_node(
ns,
node,
[
"./ns:RmtInf/ns:Strd/ns:CdtrRefInf/ns:Ref",
"./ns:Refs/ns:EndToEndId",
"./ns:Ntry/ns:AcctSvcrRef",
],
transaction,
"ref",
)
amount = self.parse_amount(ns, node)
if amount != 0.0:
transaction["amount"] = amount
# remote party values
party_type = "Dbtr"
party_type_node = node.xpath("../../ns:CdtDbtInd", namespaces={"ns": ns})
if party_type_node and party_type_node[0].text != "CRDT":
party_type = "Cdtr"
party_node = node.xpath(
"./ns:RltdPties/ns:%s" % party_type, namespaces={"ns": ns}
)
if party_node:
name_node = node.xpath(
"./ns:RltdPties/ns:{pt}/ns:Nm | ./ns:RltdPties/ns:{pt}/ns:Pty/ns:Nm".format(
pt=party_type
),
namespaces={"ns": ns},
)
if name_node:
transaction["partner_name"] = name_node[0].text
else:
self.add_value_from_node(
ns,
party_node[0],
"./ns:PstlAdr/ns:AdrLine",
transaction,
"partner_name",
)
# Get remote_account from iban or from domestic account:
account_node = node.xpath(
"./ns:RltdPties/ns:%sAcct/ns:Id" % party_type, namespaces={"ns": ns}
)
if account_node:
iban_node = account_node[0].xpath("./ns:IBAN", namespaces={"ns": ns})
if iban_node:
transaction["account_number"] = iban_node[0].text
else:
self.add_value_from_node(
ns,
account_node[0],
"./ns:Othr/ns:Id",
transaction,
"account_number",
)
def parse_entry(self, ns, node):
"""Parse an Ntry node and yield transactions"""
transaction = {"payment_ref": "/", "amount": 0} # fallback defaults
self.add_value_from_node(ns, node, "./ns:BookgDt/ns:Dt", transaction, "date")
amount = self.parse_amount(ns, node)
if amount != 0.0:
transaction["amount"] = amount
self.add_value_from_node(
ns, node, "./ns:AddtlNtryInf", transaction, "narration"
)
self.add_value_from_node(
ns,
node,
[
"./ns:NtryDtls/ns:RmtInf/ns:Strd/ns:CdtrRefInf/ns:Ref",
"./ns:NtryDtls/ns:Btch/ns:PmtInfId",
"./ns:NtryDtls/ns:TxDtls/ns:Refs/ns:AcctSvcrRef",
],
transaction,
"ref",
)
details_nodes = node.xpath("./ns:NtryDtls/ns:TxDtls", namespaces={"ns": ns})
if len(details_nodes) == 0:
yield transaction
return
transaction_base = transaction
for node in details_nodes:
transaction = transaction_base.copy()
self.parse_transaction_details(ns, node, transaction)
yield transaction
def get_balance_amounts(self, ns, node):
"""Return opening and closing balance.
Depending on kind of balance and statement, the balance might be in a
different kind of node:
OPBD = OpeningBalance
PRCD = PreviousClosingBalance
ITBD = InterimBalance (first ITBD is start-, second is end-balance)
CLBD = ClosingBalance
"""
start_balance_node = None
end_balance_node = None
for node_name in ["OPBD", "PRCD", "CLBD", "ITBD"]:
code_expr = (
'./ns:Bal/ns:Tp/ns:CdOrPrtry/ns:Cd[text()="%s"]/../../..' % node_name
)
balance_node = node.xpath(code_expr, namespaces={"ns": ns})
if balance_node:
if node_name in ["OPBD", "PRCD"]:
start_balance_node = balance_node[0]
elif node_name == "CLBD":
end_balance_node = balance_node[0]
else:
if not start_balance_node:
start_balance_node = balance_node[0]
if not end_balance_node:
end_balance_node = balance_node[-1]
return (
self.parse_amount(ns, start_balance_node),
self.parse_amount(ns, end_balance_node),
)
def parse_statement(self, ns, node):
"""Parse a single Stmt node."""
result = {}
self.add_value_from_node(
ns,
node,
["./ns:Acct/ns:Id/ns:IBAN", "./ns:Acct/ns:Id/ns:Othr/ns:Id"],
result,
"account_number",
)
self.add_value_from_node(ns, node, "./ns:Id", result, "name")
self.add_value_from_node(
ns,
node,
[
"./ns:Acct/ns:Ccy",
"./ns:Bal/ns:Amt/@Ccy",
"./ns:Ntry/ns:Amt/@Ccy",
],
result,
"currency",
)
result["balance_start"], result["balance_end_real"] = self.get_balance_amounts(
ns, node
)
entry_nodes = node.xpath("./ns:Ntry", namespaces={"ns": ns})
transactions = []
for entry_node in entry_nodes:
transactions.extend(self.parse_entry(ns, entry_node))
result["transactions"] = transactions
result["date"] = None
if transactions:
result["date"] = sorted(
transactions, key=lambda x: x["date"], reverse=True
)[0]["date"]
return result
def check_version(self, ns, root):
"""Validate validity of camt file."""
# Check whether it is camt at all:
re_camt = re.compile(r"(^urn:iso:std:iso:20022:tech:xsd:camt." r"|^ISO:camt.)")
if not re_camt.search(ns):
raise ValueError("no camt: " + ns)
# Check whether version 052 ,053 or 054:
re_camt_version = re.compile(
r"(^urn:iso:std:iso:20022:tech:xsd:camt.054."
r"|^urn:iso:std:iso:20022:tech:xsd:camt.053."
r"|^urn:iso:std:iso:20022:tech:xsd:camt.052."
r"|^ISO:camt.054."
r"|^ISO:camt.053."
r"|^ISO:camt.052.)"
)
if not re_camt_version.search(ns):
raise ValueError("no camt 052 or 053 or 054: " + ns)
# Check GrpHdr element:
root_0_0 = root[0][0].tag[len(ns) + 2 :] # strip namespace
if root_0_0 != "GrpHdr":
raise ValueError("expected GrpHdr, got: " + root_0_0)
def parse(self, data):
"""Parse a camt.052 or camt.053 or camt.054 file."""
try:
root = etree.fromstring(data, parser=etree.XMLParser(recover=True))
except etree.XMLSyntaxError:
try:
# ABNAmro is known to mix up encodings
root = etree.fromstring(data.decode("iso-8859-15").encode("utf-8"))
except etree.XMLSyntaxError:
root = None
if root is None:
raise ValueError("Not a valid xml file, or not an xml file at all.")
ns = root.tag[1 : root.tag.index("}")]
self.check_version(ns, root)
statements = []
currency = None
account_number = None
for node in root[0][1:]:
statement = self.parse_statement(ns, node)
if len(statement["transactions"]):
if "currency" in statement:
currency = statement.pop("currency")
if "account_number" in statement:
account_number = statement.pop("account_number")
statements.append(statement)
return currency, account_number, statements
| 37.864286 | 10,602 |
406 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
class AccountBankStatement(models.Model):
_inherit = "account.bank.statement"
def reconciliation_widget_preprocess(self):
return super(
AccountBankStatement, self.with_context(no_reassign_empty_name=True)
).reconciliation_widget_preprocess()
| 31.230769 | 406 |
1,451 |
py
|
PYTHON
|
15.0
|
# Copyright 2013-2016 Therp BV <https://therp.nl>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import logging
import zipfile
from io import BytesIO
from odoo import models
_logger = logging.getLogger(__name__)
class AccountBankStatementImport(models.TransientModel):
_inherit = "account.statement.import"
def _parse_file(self, data_file):
"""Parse a CAMT053 XML file."""
try:
parser = self.env["account.statement.import.camt.parser"]
_logger.debug("Try parsing with camt.")
return parser.parse(data_file)
except ValueError:
try:
with zipfile.ZipFile(BytesIO(data_file)) as data:
currency = None
account_number = None
transactions = []
for member in data.namelist():
currency, account_number, new = self._parse_file(
data.open(member).read()
)
transactions.extend(new)
return currency, account_number, transactions
# pylint: disable=except-pass
except (zipfile.BadZipFile, ValueError):
pass
# Not a camt file, returning super will call next candidate:
_logger.debug("Statement file was not a camt file.", exc_info=True)
return super()._parse_file(data_file)
| 38.184211 | 1,451 |
907 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
class AccountBankStatementLine(models.Model):
_inherit = "account.bank.statement.line"
def write(self, vals):
"""
Purpose of this hook is catch updates for records with name == '/'
In reconciliation_widget_preprocess, there is attempt to assign
partner into statement line, this assignment relies on name,
during import name setup to '/' for records without it
and this makes search results wrong and partner assignment randomly
"""
if (
self.env.context.get("no_reassign_empty_name")
and len(self) == 1
and len(vals.keys()) == 1
and "partner_id" in vals
and self.name == "/"
):
return True
return super().write(vals)
| 33.592593 | 907 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
1,292 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-bank-statement-import",
description="Meta package for oca-bank-statement-import Odoo addons",
version=version,
install_requires=[
'odoo-addon-account_bank_statement_clear_partner>=15.0dev,<15.1dev',
'odoo-addon-account_bank_statement_import_move_line>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_base>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_camt54>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_camt>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_ofx>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_online>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_online_paypal>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_online_ponto>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_paypal>=15.0dev,<15.1dev',
'odoo-addon-account_statement_import_txt_xlsx>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 44.551724 | 1,292 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
681 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020-2021 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Online Bank Statements: PayPal.com",
"version": "15.0.1.1.1",
"author": "CorporateHub, Odoo Community Association (OCA)",
"maintainers": ["alexey-pelykh"],
"website": "https://github.com/OCA/bank-statement-import",
"license": "AGPL-3",
"category": "Accounting",
"summary": "Online bank statements for PayPal.com",
"depends": ["account_statement_import_online"],
"data": ["views/online_bank_statement_provider.xml"],
"installable": True,
}
| 40.058824 | 681 |
29,337 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2021-2022 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import json
from datetime import datetime
from decimal import Decimal
from unittest import mock
from urllib.error import HTTPError
from dateutil.relativedelta import relativedelta
from odoo import fields
from odoo.exceptions import UserError
from odoo.tests import common
_module_ns = "odoo.addons.account_statement_import_online_paypal"
_provider_class = (
_module_ns
+ ".models.online_bank_statement_provider_paypal"
+ ".OnlineBankStatementProviderPayPal"
)
class FakeHTTPError(HTTPError):
def __init__(self, content):
self.content = content
# pylint: disable=method-required-super
def read(self):
return self.content.encode("utf-8")
class UrlopenRetValMock:
def __init__(self, content, throw=False):
self.content = content
self.throw = throw
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
pass
# pylint: disable=method-required-super
def read(self):
if self.throw:
raise FakeHTTPError(self.content)
return self.content.encode("utf-8")
class TestAccountBankAccountStatementImportOnlinePayPal(common.TransactionCase):
def setUp(self):
super().setUp()
self.now = fields.Datetime.now()
self.now_isoformat = self.now.isoformat() + "+0000"
self.today = datetime(self.now.year, self.now.month, self.now.day)
self.today_isoformat = self.today.isoformat() + "+0000"
self.today_timestamp = str(int(self.today.timestamp()))
self.yesterday = self.today - relativedelta(days=1)
self.yesterday_isoformat = self.yesterday.isoformat() + "+0000"
self.yesterday_timestamp = str(int(self.yesterday.timestamp()))
self.currency_eur = self.env.ref("base.EUR")
self.currency_usd = self.env.ref("base.USD")
self.AccountJournal = self.env["account.journal"]
self.OnlineBankStatementProvider = self.env["online.bank.statement.provider"]
self.AccountBankStatement = self.env["account.bank.statement"]
self.AccountBankStatementLine = self.env["account.bank.statement.line"]
Provider = self.OnlineBankStatementProvider
self.paypal_parse_transaction = lambda payload: (
Provider._paypal_transaction_to_lines(
Provider._paypal_preparse_transaction(
json.loads(
payload,
parse_float=Decimal,
)
)
)
)
self.mock_token = lambda: mock.patch(
_provider_class + "._paypal_get_token",
return_value="--TOKEN--",
)
def test_good_token(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = json.loads(
"""{
"scope": "https://uri.paypal.com/services/reporting/search/read",
"access_token": "---TOKEN---",
"token_type": "Bearer",
"app_id": "APP-1234567890",
"expires_in": 32400,
"nonce": "---NONCE---"
}""",
parse_float=Decimal,
)
token = None
with mock.patch(
_provider_class + "._paypal_retrieve",
return_value=mocked_response,
):
token = provider._paypal_get_token()
self.assertEqual(token, "---TOKEN---")
def test_bad_token_scope(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = json.loads(
"""{
"scope": "openid https://uri.paypal.com/services/applications/webhooks",
"access_token": "---TOKEN---",
"token_type": "Bearer",
"app_id": "APP-1234567890",
"expires_in": 32400,
"nonce": "---NONCE---"
}""",
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
return_value=mocked_response,
):
with self.assertRaisesRegex(
UserError, "PayPal App features are configured incorrectly!"
):
provider._paypal_get_token()
def test_bad_token_type(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = json.loads(
"""{
"scope": "https://uri.paypal.com/services/reporting/search/read",
"access_token": "---TOKEN---",
"token_type": "NotBearer",
"app_id": "APP-1234567890",
"expires_in": 32400,
"nonce": "---NONCE---"
}""",
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
return_value=mocked_response,
):
with self.assertRaisesRegex(UserError, "Invalid token type!"):
provider._paypal_get_token()
def test_no_token(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = json.loads(
"""{
"scope": "https://uri.paypal.com/services/reporting/search/read",
"token_type": "Bearer",
"app_id": "APP-1234567890",
"expires_in": 32400,
"nonce": "---NONCE---"
}""",
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
return_value=mocked_response,
):
with self.assertRaisesRegex(
UserError, "Failed to acquire token using Client ID and Secret!"
):
provider._paypal_get_token()
def test_no_data_on_monday(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response_1 = UrlopenRetValMock(
"""{
"debug_id": "eec890ebd5798",
"details": "xxxxxx",
"links": "xxxxxx",
"message": "Data for the given start date is not available.",
"name": "INVALID_REQUEST"
}""",
throw=True,
)
mocked_response_2 = UrlopenRetValMock(
"""{
"balances": [
{
"currency": "EUR",
"primary": true,
"total_balance": {
"currency_code": "EUR",
"value": "0.75"
},
"available_balance": {
"currency_code": "EUR",
"value": "0.75"
},
"withheld_balance": {
"currency_code": "EUR",
"value": "0.00"
}
}
],
"account_id": "1234567890",
"as_of_time": "%s",
"last_refresh_time": "%s"
}"""
% (
self.now_isoformat,
self.now_isoformat,
)
)
with mock.patch(
_provider_class + "._paypal_urlopen",
side_effect=[mocked_response_1, mocked_response_2],
), self.mock_token():
data = provider.with_context(
test_account_statement_import_online_paypal_monday=True,
)._obtain_statement_data(
self.now - relativedelta(hours=1),
self.now,
)
self.assertEqual(data, None)
def test_error_handling_1(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = UrlopenRetValMock(
"""{
"message": "MESSAGE",
"name": "ERROR"
}""",
throw=True,
)
with mock.patch(
_provider_class + "._paypal_urlopen",
return_value=mocked_response,
):
with self.assertRaises(UserError):
provider._paypal_retrieve("https://url", "")
def test_error_handling_2(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = UrlopenRetValMock(
"""{
"error_description": "ERROR DESCRIPTION",
"error": "ERROR"
}""",
throw=True,
)
with mock.patch(
_provider_class + "._paypal_urlopen",
return_value=mocked_response,
):
with self.assertRaises(UserError):
provider._paypal_retrieve("https://url", "")
def test_dont_create_empty_paypal_statements(self):
"""Test the default behavior of not creating empty PayPal
statements ('Allow empty statements' field is unchecked).
"""
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response_1 = json.loads(
"""{
"transaction_details": [],
"account_number": "1234567890",
"start_date": "%s",
"end_date": "%s",
"last_refreshed_datetime": "%s",
"page": 1,
"total_items": 0,
"total_pages": 0
}"""
% (
self.now_isoformat,
self.now_isoformat,
self.now_isoformat,
),
parse_float=Decimal,
)
mocked_response_2 = json.loads(
"""{
"balances": [
{
"currency": "EUR",
"primary": true,
"total_balance": {
"currency_code": "EUR",
"value": "0.75"
},
"available_balance": {
"currency_code": "EUR",
"value": "0.75"
},
"withheld_balance": {
"currency_code": "EUR",
"value": "0.00"
}
}
],
"account_id": "1234567890",
"as_of_time": "%s",
"last_refresh_time": "%s"
}"""
% (
self.now_isoformat,
self.now_isoformat,
),
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
side_effect=[mocked_response_1, mocked_response_2],
), self.mock_token():
data = provider._obtain_statement_data(
self.now - relativedelta(hours=1),
self.now,
)
self.assertEqual(data, None)
def test_create_empty_paypal_statements(self):
"""Test creating empty PayPal statements
('Allow empty statements' field is checked).
"""
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
provider.allow_empty_statements = True
mocked_response_1 = json.loads(
"""{
"transaction_details": [],
"account_number": "1234567890",
"start_date": "%s",
"end_date": "%s",
"last_refreshed_datetime": "%s",
"page": 1,
"total_items": 0,
"total_pages": 0
}"""
% (
self.now_isoformat,
self.now_isoformat,
self.now_isoformat,
),
parse_float=Decimal,
)
mocked_response_2 = json.loads(
"""{
"balances": [
{
"currency": "EUR",
"primary": true,
"total_balance": {
"currency_code": "EUR",
"value": "0.75"
},
"available_balance": {
"currency_code": "EUR",
"value": "0.75"
},
"withheld_balance": {
"currency_code": "EUR",
"value": "0.00"
}
}
],
"account_id": "1234567890",
"as_of_time": "%s",
"last_refresh_time": "%s"
}"""
% (
self.now_isoformat,
self.now_isoformat,
),
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
side_effect=[mocked_response_1, mocked_response_2],
), self.mock_token():
data = provider._obtain_statement_data(
self.now - relativedelta(hours=1),
self.now,
)
self.assertEqual(data, ([], {"balance_start": 0.75, "balance_end_real": 0.75}))
def test_ancient_pull(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = json.loads(
"""{
"transaction_details": [],
"account_number": "1234567890",
"start_date": "%s",
"end_date": "%s",
"last_refreshed_datetime": "%s",
"page": 1,
"total_items": 0,
"total_pages": 0
}"""
% (
self.now_isoformat,
self.now_isoformat,
self.now_isoformat,
),
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
return_value=mocked_response,
), self.mock_token():
with self.assertRaisesRegex(
UserError,
"PayPal allows retrieving transactions only up to 3 years in "
"the past. Please import older transactions manually.",
):
provider._obtain_statement_data(
self.now - relativedelta(years=5),
self.now,
)
def test_pull(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"currency_id": self.currency_eur.id,
"bank_statements_source": "online",
"online_bank_statement_provider": "paypal",
}
)
provider = journal.online_bank_statement_provider_id
mocked_response = json.loads(
"""{
"transaction_details": [{
"transaction_info": {
"paypal_account_id": "1234567890",
"transaction_id": "1234567890",
"transaction_event_code": "T1234",
"transaction_initiation_date": "%s",
"transaction_updated_date": "%s",
"transaction_amount": {
"currency_code": "USD",
"value": "1000.00"
},
"fee_amount": {
"currency_code": "USD",
"value": "-100.00"
},
"transaction_status": "S",
"transaction_subject": "Payment for Invoice(s) 1",
"ending_balance": {
"currency_code": "USD",
"value": "900.00"
},
"available_balance": {
"currency_code": "USD",
"value": "900.00"
},
"invoice_id": "1"
},
"payer_info": {
"account_id": "1234567890",
"email_address": "[email protected]",
"address_status": "Y",
"payer_status": "N",
"payer_name": {
"alternate_full_name": "Acme, Inc."
},
"country_code": "US"
},
"shipping_info": {},
"cart_info": {},
"store_info": {},
"auction_info": {},
"incentive_info": {}
}, {
"transaction_info": {
"paypal_account_id": "1234567890",
"transaction_id": "1234567891",
"transaction_event_code": "T1234",
"transaction_initiation_date": "%s",
"transaction_updated_date": "%s",
"transaction_amount": {
"currency_code": "USD",
"value": "1000.00"
},
"fee_amount": {
"currency_code": "USD",
"value": "-100.00"
},
"transaction_status": "S",
"transaction_subject": "Payment for Invoice(s) 1",
"ending_balance": {
"currency_code": "USD",
"value": "900.00"
},
"available_balance": {
"currency_code": "USD",
"value": "900.00"
},
"invoice_id": "1"
},
"payer_info": {
"account_id": "1234567890",
"email_address": "[email protected]",
"address_status": "Y",
"payer_status": "N",
"payer_name": {
"alternate_full_name": "Acme, Inc."
},
"country_code": "US"
},
"shipping_info": {},
"cart_info": {},
"store_info": {},
"auction_info": {},
"incentive_info": {}
}],
"account_number": "1234567890",
"start_date": "%s",
"end_date": "%s",
"last_refreshed_datetime": "%s",
"page": 1,
"total_items": 1,
"total_pages": 1
}"""
% (
self.yesterday_isoformat,
self.yesterday_isoformat,
self.today_isoformat,
self.today_isoformat,
self.yesterday_isoformat,
self.today_isoformat,
self.now_isoformat,
),
parse_float=Decimal,
)
with mock.patch(
_provider_class + "._paypal_retrieve",
return_value=mocked_response,
), self.mock_token():
data = provider._obtain_statement_data(
self.yesterday,
self.today,
)
self.assertEqual(len(data[0]), 2)
del data[0][0]["raw_data"]
self.assertEqual(
data[0][0],
{
"date": self.yesterday,
"amount": "1000.00",
"ref": "Invoice 1",
"payment_ref": "1234567890: Payment for Invoice(s) 1",
"partner_name": "Acme, Inc.",
"unique_import_id": "1234567890-%s" % (self.yesterday_timestamp,),
},
)
self.assertEqual(
data[0][1],
{
"date": self.yesterday,
"amount": "-100.00",
"ref": "Fee for Invoice 1",
"payment_ref": "Transaction fee for 1234567890: Payment for Invoice(s) 1",
"partner_name": "PayPal",
"unique_import_id": "1234567890-%s-FEE" % (self.yesterday_timestamp,),
},
)
self.assertEqual(data[1], {"balance_start": 0.0, "balance_end_real": 900.0})
def test_transaction_parse_1(self):
lines = self.paypal_parse_transaction(
"""{
"transaction_info": {
"paypal_account_id": "1234567890",
"transaction_id": "1234567890",
"transaction_event_code": "T1234",
"transaction_initiation_date": "%s",
"transaction_updated_date": "%s",
"transaction_amount": {
"currency_code": "USD",
"value": "1000.00"
},
"fee_amount": {
"currency_code": "USD",
"value": "0.00"
},
"transaction_status": "S",
"transaction_subject": "Payment for Invoice(s) 1",
"ending_balance": {
"currency_code": "USD",
"value": "1000.00"
},
"available_balance": {
"currency_code": "USD",
"value": "1000.00"
},
"invoice_id": "1"
},
"payer_info": {
"account_id": "1234567890",
"email_address": "[email protected]",
"address_status": "Y",
"payer_status": "N",
"payer_name": {
"alternate_full_name": "Acme, Inc."
},
"country_code": "US"
},
"shipping_info": {},
"cart_info": {},
"store_info": {},
"auction_info": {},
"incentive_info": {}
}"""
% (
self.today_isoformat,
self.today_isoformat,
)
)
self.assertEqual(len(lines), 1)
del lines[0]["raw_data"]
self.assertEqual(
lines[0],
{
"date": self.today,
"amount": "1000.00",
"ref": "Invoice 1",
"payment_ref": "1234567890: Payment for Invoice(s) 1",
"partner_name": "Acme, Inc.",
"unique_import_id": "1234567890-%s" % (self.today_timestamp,),
},
)
def test_transaction_parse_2(self):
lines = self.paypal_parse_transaction(
"""{
"transaction_info": {
"paypal_account_id": "1234567890",
"transaction_id": "1234567890",
"transaction_event_code": "T1234",
"transaction_initiation_date": "%s",
"transaction_updated_date": "%s",
"transaction_amount": {
"currency_code": "USD",
"value": "1000.00"
},
"fee_amount": {
"currency_code": "USD",
"value": "0.00"
},
"transaction_status": "S",
"transaction_subject": "Payment for Invoice(s) 1",
"ending_balance": {
"currency_code": "USD",
"value": "1000.00"
},
"available_balance": {
"currency_code": "USD",
"value": "1000.00"
},
"invoice_id": "1"
},
"payer_info": {
"account_id": "1234567890",
"email_address": "[email protected]",
"address_status": "Y",
"payer_status": "N",
"payer_name": {
"alternate_full_name": "Acme, Inc."
},
"country_code": "US"
},
"shipping_info": {},
"cart_info": {},
"store_info": {},
"auction_info": {},
"incentive_info": {}
}"""
% (
self.today_isoformat,
self.today_isoformat,
)
)
self.assertEqual(len(lines), 1)
del lines[0]["raw_data"]
self.assertEqual(
lines[0],
{
"date": self.today,
"amount": "1000.00",
"ref": "Invoice 1",
"payment_ref": "1234567890: Payment for Invoice(s) 1",
"partner_name": "Acme, Inc.",
"unique_import_id": "1234567890-%s" % (self.today_timestamp,),
},
)
def test_transaction_parse_3(self):
lines = self.paypal_parse_transaction(
"""{
"transaction_info": {
"paypal_account_id": "1234567890",
"transaction_id": "1234567890",
"transaction_event_code": "T1234",
"transaction_initiation_date": "%s",
"transaction_updated_date": "%s",
"transaction_amount": {
"currency_code": "USD",
"value": "1000.00"
},
"fee_amount": {
"currency_code": "USD",
"value": "-100.00"
},
"transaction_status": "S",
"transaction_subject": "Payment for Invoice(s) 1",
"ending_balance": {
"currency_code": "USD",
"value": "900.00"
},
"available_balance": {
"currency_code": "USD",
"value": "900.00"
},
"invoice_id": "1"
},
"payer_info": {
"account_id": "1234567890",
"email_address": "[email protected]",
"address_status": "Y",
"payer_status": "N",
"payer_name": {
"alternate_full_name": "Acme, Inc."
},
"country_code": "US"
},
"shipping_info": {},
"cart_info": {},
"store_info": {},
"auction_info": {},
"incentive_info": {}
}"""
% (
self.today_isoformat,
self.today_isoformat,
)
)
self.assertEqual(len(lines), 2)
del lines[0]["raw_data"]
self.assertEqual(
lines[0],
{
"date": self.today,
"amount": "1000.00",
"ref": "Invoice 1",
"payment_ref": "1234567890: Payment for Invoice(s) 1",
"partner_name": "Acme, Inc.",
"unique_import_id": "1234567890-%s" % (self.today_timestamp,),
},
)
self.assertEqual(
lines[1],
{
"date": self.today,
"amount": "-100.00",
"ref": "Fee for Invoice 1",
"payment_ref": "Transaction fee for 1234567890: Payment for Invoice(s) 1",
"partner_name": "PayPal",
"unique_import_id": "1234567890-%s-FEE" % (self.today_timestamp,),
},
)
def test_transaction_parse_4(self):
lines = self.paypal_parse_transaction(
"""{
"transaction_info": {
"paypal_account_id": "1234567890",
"transaction_id": "1234567890",
"transaction_event_code": "T1234",
"transaction_initiation_date": "%s",
"transaction_updated_date": "%s",
"transaction_amount": {
"currency_code": "USD",
"value": "1000.00"
},
"transaction_status": "S",
"transaction_subject": "Payment for Invoice(s) 1",
"ending_balance": {
"currency_code": "USD",
"value": "1000.00"
},
"available_balance": {
"currency_code": "USD",
"value": "1000.00"
},
"invoice_id": "1"
},
"payer_info": {
"account_id": "1234567890",
"email_address": "[email protected]",
"address_status": "Y",
"payer_status": "N",
"payer_name": {
"alternate_full_name": "Acme, Inc."
},
"country_code": "US"
},
"shipping_info": {},
"cart_info": {},
"store_info": {},
"auction_info": {},
"incentive_info": {}
}"""
% (
self.today_isoformat,
self.today_isoformat,
)
)
self.assertEqual(len(lines), 1)
del lines[0]["raw_data"]
self.assertEqual(
lines[0],
{
"date": self.today,
"amount": "1000.00",
"ref": "Invoice 1",
"payment_ref": "1234567890: Payment for Invoice(s) 1",
"partner_name": "Acme, Inc.",
"unique_import_id": "1234567890-%s" % (self.today_timestamp,),
},
)
| 31.044444 | 29,337 |
22,041 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2021 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import itertools
import json
import urllib.request
from base64 import b64encode
from datetime import datetime
from decimal import Decimal
from urllib.error import HTTPError
from urllib.parse import urlencode
import dateutil.parser
import pytz
from dateutil.relativedelta import relativedelta
from odoo import _, api, models
from odoo.exceptions import UserError
PAYPAL_API_BASE = "https://api.paypal.com"
TRANSACTIONS_SCOPE = "https://uri.paypal.com/services/reporting/search/read"
EVENT_DESCRIPTIONS = {
"T0000": _("General PayPal-to-PayPal payment"),
"T0001": _("MassPay payment"),
"T0002": _("Subscription payment"),
"T0003": _("Pre-approved payment (BillUser API)"),
"T0004": _("eBay auction payment"),
"T0005": _("Direct payment API"),
"T0006": _("PayPal Checkout APIs"),
"T0007": _("Website payments standard payment"),
"T0008": _("Postage payment to carrier"),
"T0009": _("Gift certificate payment, purchase of gift certificate"),
"T0010": _("Third-party auction payment"),
"T0011": _("Mobile payment, made through a mobile phone"),
"T0012": _("Virtual terminal payment"),
"T0013": _("Donation payment"),
"T0014": _("Rebate payments"),
"T0015": _("Third-party payout"),
"T0016": _("Third-party recoupment"),
"T0017": _("Store-to-store transfers"),
"T0018": _("PayPal Here payment"),
"T0019": _("Generic instrument-funded payment"),
"T0100": _("General non-payment fee"),
"T0101": _("Website payments. Pro account monthly fee"),
"T0102": _("Foreign bank withdrawal fee"),
"T0103": _("WorldLink check withdrawal fee"),
"T0104": _("Mass payment batch fee"),
"T0105": _("Check withdrawal"),
"T0106": _("Chargeback processing fee"),
"T0107": _("Payment fee"),
"T0108": _("ATM withdrawal"),
"T0109": _("Auto-sweep from account"),
"T0110": _("International credit card withdrawal"),
"T0111": _("Warranty fee for warranty purchase"),
"T0112": _("Gift certificate expiration fee"),
"T0113": _("Partner fee"),
"T0200": _("General currency conversion"),
"T0201": _("User-initiated currency conversion"),
"T0202": _("Currency conversion required to cover negative balance"),
"T0300": _("General funding of PayPal account"),
"T0301": _("PayPal balance manager funding of PayPal account"),
"T0302": _("ACH funding for funds recovery from account balance"),
"T0303": _("Electronic funds transfer (EFT)"),
"T0400": _("General withdrawal from PayPal account"),
"T0401": _("AutoSweep"),
"T0500": _("General PayPal debit card transaction"),
"T0501": _("Virtual PayPal debit card transaction"),
"T0502": _("PayPal debit card withdrawal to ATM"),
"T0503": _("Hidden virtual PayPal debit card transaction"),
"T0504": _("PayPal debit card cash advance"),
"T0505": _("PayPal debit authorization"),
"T0600": _("General credit card withdrawal"),
"T0700": _("General credit card deposit"),
"T0701": _("Credit card deposit for negative PayPal account balance"),
"T0800": _("General bonus"),
"T0801": _("Debit card cash back bonus"),
"T0802": _("Merchant referral account bonus"),
"T0803": _("Balance manager account bonus"),
"T0804": _("PayPal buyer warranty bonus"),
"T0805": _(
"PayPal protection bonus, payout for PayPal buyer protection, payout "
"for full protection with PayPal buyer credit."
),
"T0806": _("Bonus for first ACH use"),
"T0807": _("Credit card security charge refund"),
"T0808": _("Credit card cash back bonus"),
"T0900": _("General incentive or certificate redemption"),
"T0901": _("Gift certificate redemption"),
"T0902": _("Points incentive redemption"),
"T0903": _("Coupon redemption"),
"T0904": _("eBay loyalty incentive"),
"T0905": _("Offers used as funding source"),
"T1000": _("Bill pay transaction"),
"T1100": _("General reversal"),
"T1101": _("Reversal of ACH withdrawal transaction"),
"T1102": _("Reversal of debit card transaction"),
"T1103": _("Reversal of points usage"),
"T1104": _("Reversal of ACH deposit"),
"T1105": _("Reversal of general account hold"),
"T1106": _("Payment reversal, initiated by PayPal"),
"T1107": _("Payment refund, initiated by merchant"),
"T1108": _("Fee reversal"),
"T1109": _("Fee refund"),
"T1110": _("Hold for dispute investigation"),
"T1111": _("Cancellation of hold for dispute resolution"),
"T1112": _("MAM reversal"),
"T1113": _("Non-reference credit payment"),
"T1114": _("MassPay reversal transaction"),
"T1115": _("MassPay refund transaction"),
"T1116": _("Instant payment review (IPR) reversal"),
"T1117": _("Rebate or cash back reversal"),
"T1118": _("Generic instrument/Open Wallet reversals (seller side)"),
"T1119": _("Generic instrument/Open Wallet reversals (buyer side)"),
"T1200": _("General account adjustment"),
"T1201": _("Chargeback"),
"T1202": _("Chargeback reversal"),
"T1203": _("Charge-off adjustment"),
"T1204": _("Incentive adjustment"),
"T1205": _("Reimbursement of chargeback"),
"T1207": _("Chargeback re-presentment rejection"),
"T1208": _("Chargeback cancellation"),
"T1300": _("General authorization"),
"T1301": _("Reauthorization"),
"T1302": _("Void of authorization"),
"T1400": _("General dividend"),
"T1500": _("General temporary hold"),
"T1501": _("Account hold for open authorization"),
"T1502": _("Account hold for ACH deposit"),
"T1503": _("Temporary hold on available balance"),
"T1600": _("PayPal buyer credit payment funding"),
"T1601": _("BML credit, transfer from BML"),
"T1602": _("Buyer credit payment"),
"T1603": _("Buyer credit payment withdrawal, transfer to BML"),
"T1700": _("General withdrawal to non-bank institution"),
"T1701": _("WorldLink withdrawal"),
"T1800": _("General buyer credit payment"),
"T1801": _("BML withdrawal, transfer to BML"),
"T1900": _("General adjustment without business-related event"),
"T2000": _("General intra-account transfer"),
"T2001": _("Settlement consolidation"),
"T2002": _("Transfer of funds from payable"),
"T2003": _("Transfer to external GL entity"),
"T2101": _("General hold"),
"T2102": _("General hold release"),
"T2103": _("Reserve hold"),
"T2104": _("Reserve release"),
"T2105": _("Payment review hold"),
"T2106": _("Payment review release"),
"T2107": _("Payment hold"),
"T2108": _("Payment hold release"),
"T2109": _("Gift certificate purchase"),
"T2110": _("Gift certificate redemption"),
"T2111": _("Funds not yet available"),
"T2112": _("Funds available"),
"T2113": _("Blocked payments"),
"T2201": _("Transfer to and from a credit-card-funded restricted balance"),
"T3000": _("Generic instrument/Open Wallet transaction"),
"T5000": _("Deferred disbursement, funds collected for disbursement"),
"T5001": _("Delayed disbursement, funds disbursed"),
"T9700": _("Account receivable for shipping"),
"T9701": _("Funds payable: PayPal-provided funds that must be paid back"),
"T9702": _("Funds receivable: PayPal-provided funds that are being paid back"),
"T9800": _("Display only transaction"),
"T9900": _("Other"),
}
NO_DATA_FOR_DATE_AVAIL_MSG = "Data for the given start date is not available."
class OnlineBankStatementProviderPayPal(models.Model):
_inherit = "online.bank.statement.provider"
@api.model
def _get_available_services(self):
return super()._get_available_services() + [
("paypal", "PayPal.com"),
]
def _obtain_statement_data(self, date_since, date_until):
self.ensure_one()
if self.service != "paypal":
return super()._obtain_statement_data(
date_since,
date_until,
) # pragma: no cover
currency = (self.currency_id or self.company_id.currency_id).name
if date_since.tzinfo:
date_since = date_since.astimezone(pytz.utc).replace(tzinfo=None)
if date_until.tzinfo:
date_until = date_until.astimezone(pytz.utc).replace(tzinfo=None)
if date_since < datetime.utcnow() - relativedelta(years=3):
raise UserError(
_(
"PayPal allows retrieving transactions only up to 3 years in "
"the past. Please import older transactions manually. See "
"https://www.paypal.com/us/smarthelp/article/why-can't-i"
"-access-transaction-history-greater-than-3-years-ts2241"
)
)
token = self._paypal_get_token()
transactions = self._paypal_get_transactions(
token, currency, date_since, date_until
)
if not transactions:
if self.allow_empty_statements:
balance = self._paypal_get_balance(token, currency, date_since)
return [], {"balance_start": balance, "balance_end_real": balance}
else:
return None
# Normalize transactions, sort by date, and get lines
transactions = list(
sorted(
transactions,
key=lambda transaction: self._paypal_get_transaction_date(transaction),
)
)
lines = list(
itertools.chain.from_iterable(
map(lambda x: self._paypal_transaction_to_lines(x), transactions)
)
)
first_transaction = transactions[0]
first_transaction_id = first_transaction["transaction_info"]["transaction_id"]
first_transaction_date = self._paypal_get_transaction_date(first_transaction)
first_transaction = self._paypal_get_transaction(
token, first_transaction_id, first_transaction_date
)
if not first_transaction:
raise UserError(
_(
"Failed to resolve transaction %(first_transaction_id)s "
"(%(first_transaction_date)s)",
first_transaction_id=first_transaction_id,
first_transaction_date=first_transaction_date,
)
)
balance_start = self._paypal_get_transaction_ending_balance(first_transaction)
balance_start -= self._paypal_get_transaction_total_amount(first_transaction)
balance_start -= self._paypal_get_transaction_fee_amount(first_transaction)
last_transaction = transactions[-1]
last_transaction_id = last_transaction["transaction_info"]["transaction_id"]
last_transaction_date = self._paypal_get_transaction_date(last_transaction)
last_transaction = self._paypal_get_transaction(
token, last_transaction_id, last_transaction_date
)
if not last_transaction:
raise UserError(
_(
"Failed to resolve transaction %(last_transaction_id)s "
"(%(last_transaction_date)s)",
last_transaction_id=last_transaction_id,
last_transaction_date=last_transaction_date,
)
)
balance_end = self._paypal_get_transaction_ending_balance(last_transaction)
return lines, {"balance_start": balance_start, "balance_end_real": balance_end}
@api.model
def _paypal_preparse_transaction(self, transaction):
date = (
dateutil.parser.parse(self._paypal_get_transaction_date(transaction))
.astimezone(pytz.utc)
.replace(tzinfo=None)
)
transaction["transaction_info"]["transaction_updated_date"] = date
return transaction
@api.model
def _paypal_transaction_to_lines(self, data):
transaction = data["transaction_info"]
payer = data["payer_info"]
transaction_id = transaction["transaction_id"]
event_code = transaction["transaction_event_code"]
date = self._paypal_get_transaction_date(data)
total_amount = self._paypal_get_transaction_total_amount(data)
fee_amount = self._paypal_get_transaction_fee_amount(data)
transaction_subject = transaction.get("transaction_subject")
transaction_note = transaction.get("transaction_note")
invoice = transaction.get("invoice_id")
payer_name = payer.get("payer_name", {})
payer_email = payer_name.get("email_address")
if invoice:
invoice = _("Invoice %s") % invoice
note = transaction_id
if transaction_subject or transaction_note:
note = "{}: {}".format(note, transaction_subject or transaction_note)
if payer_email:
note += " (%s)" % payer_email
unique_import_id = "{}-{}".format(transaction_id, int(date.timestamp()))
name = (
invoice
or transaction_subject
or transaction_note
or EVENT_DESCRIPTIONS.get(event_code)
or ""
)
line = {
"ref": name,
"amount": str(total_amount),
"date": date,
"payment_ref": note,
"unique_import_id": unique_import_id,
"raw_data": transaction,
}
payer_full_name = payer_name.get("full_name") or payer_name.get(
"alternate_full_name"
)
if payer_full_name:
line.update({"partner_name": payer_full_name})
lines = [line]
if fee_amount:
lines += [
{
"ref": _("Fee for %s") % (name or transaction_id),
"amount": str(fee_amount),
"date": date,
"partner_name": "PayPal",
"unique_import_id": "%s-FEE" % unique_import_id,
"payment_ref": _("Transaction fee for %s") % note,
}
]
return lines
def _paypal_get_token(self):
self.ensure_one()
data = self._paypal_retrieve(
(self.api_base or PAYPAL_API_BASE) + "/v1/oauth2/token",
(self.username, self.password),
data=urlencode({"grant_type": "client_credentials"}).encode("utf-8"),
)
if "scope" not in data or TRANSACTIONS_SCOPE not in data["scope"]:
raise UserError(_("PayPal App features are configured incorrectly!"))
if "token_type" not in data or data["token_type"] != "Bearer":
raise UserError(_("Invalid token type!"))
if "access_token" not in data:
raise UserError(_("Failed to acquire token using Client ID and Secret!"))
return data["access_token"]
def _paypal_get_balance(self, token, currency, as_of_timestamp):
self.ensure_one()
url = (
self.api_base or PAYPAL_API_BASE
) + "/v1/reporting/balances?currency_code={}&as_of_time={}".format(
currency,
as_of_timestamp.isoformat() + "Z",
)
data = self._paypal_retrieve(url, token)
available_balance = data["balances"][0].get("available_balance")
if not available_balance:
return Decimal()
return Decimal(available_balance["value"])
def _paypal_get_transaction(self, token, transaction_id, timestamp):
self.ensure_one()
transaction_date = timestamp.isoformat() + "Z"
url = (
(self.api_base or PAYPAL_API_BASE)
+ "/v1/reporting/transactions"
+ ("?start_date=%s" "&end_date=%s" "&fields=all")
% (
transaction_date,
transaction_date,
)
)
data = self._paypal_retrieve(url, token)
transactions = data["transaction_details"]
for transaction in transactions:
if transaction["transaction_info"]["transaction_id"] != transaction_id:
continue
return transaction
return None
def _paypal_get_transactions(self, token, currency, since, until):
self.ensure_one()
# NOTE: Not more than 31 days in a row
# NOTE: start_date <= date <= end_date, thus check every transaction
interval_step = relativedelta(days=31)
interval_start = since
transactions = []
while interval_start < until:
interval_end = min(interval_start + interval_step, until)
page = 1
total_pages = None
while total_pages is None or page <= total_pages:
url = (
(self.api_base or PAYPAL_API_BASE)
+ "/v1/reporting/transactions"
+ (
"?transaction_currency=%s"
"&start_date=%s"
"&end_date=%s"
"&fields=all"
"&balance_affecting_records_only=Y"
"&page_size=500"
"&page=%d"
% (
currency,
interval_start.isoformat() + "Z",
interval_end.isoformat() + "Z",
page,
)
)
)
# NOTE: Workaround for INVALID_REQUEST (see ROADMAP.rst)
invalid_data_workaround = self.env.context.get(
"test_account_statement_import_online_paypal_monday",
interval_start.weekday() == 0
and (datetime.utcnow() - interval_start).total_seconds() < 28800,
)
data = self.with_context(
invalid_data_workaround=invalid_data_workaround,
)._paypal_retrieve(url, token)
interval_transactions = map(
lambda transaction: self._paypal_preparse_transaction(transaction),
data["transaction_details"],
)
transactions += list(
filter(
lambda transaction: interval_start
<= self._paypal_get_transaction_date(transaction)
< interval_end,
interval_transactions,
)
)
total_pages = data["total_pages"]
page += 1
interval_start += interval_step
return transactions
@api.model
def _paypal_get_transaction_date(self, transaction):
# NOTE: CSV reports from PayPal use this date, search as well
return transaction["transaction_info"]["transaction_updated_date"]
@api.model
def _paypal_get_transaction_total_amount(self, transaction):
transaction_amount = transaction["transaction_info"].get("transaction_amount")
if not transaction_amount:
return Decimal()
return Decimal(transaction_amount["value"])
@api.model
def _paypal_get_transaction_fee_amount(self, transaction):
fee_amount = transaction["transaction_info"].get("fee_amount")
if not fee_amount:
return Decimal()
return Decimal(fee_amount["value"])
@api.model
def _paypal_get_transaction_ending_balance(self, transaction):
# NOTE: 'available_balance' instead of 'ending_balance' as per CSV file
transaction_amount = transaction["transaction_info"].get("available_balance")
if not transaction_amount:
return Decimal()
return Decimal(transaction_amount["value"])
@api.model
def _paypal_decode_error(self, content):
if "name" in content:
return UserError(
"%s: %s"
% (
content["name"],
content.get("message", _("Unknown error")),
)
)
if "error" in content:
return UserError(
"%s: %s"
% (
content["error"],
content.get("error_description", _("Unknown error")),
)
)
return None
@api.model
def _paypal_retrieve(self, url, auth, data=None):
try:
with self._paypal_urlopen(url, auth, data) as response:
content = response.read().decode("utf-8")
except HTTPError as e:
content = json.loads(e.read().decode("utf-8"))
# NOTE: Workaround for INVALID_REQUEST (see ROADMAP.rst)
if (
self.env.context.get("invalid_data_workaround")
and content.get("name") == "INVALID_REQUEST"
and content.get("message") == NO_DATA_FOR_DATE_AVAIL_MSG
):
return {
"transaction_details": [],
"page": 1,
"total_items": 0,
"total_pages": 0,
}
raise self._paypal_decode_error(content) or e from None
return json.loads(content)
@api.model
def _paypal_urlopen(self, url, auth, data=None):
if not auth:
raise UserError(_("No authentication specified!"))
request = urllib.request.Request(url, data=data)
if isinstance(auth, tuple):
request.add_header(
"Authorization",
"Basic %s"
% str(
b64encode(("{}:{}".format(auth[0], auth[1])).encode("utf-8")),
"utf-8",
),
)
elif isinstance(auth, str):
request.add_header("Authorization", "Bearer %s" % auth)
else:
raise UserError(_("Unknown authentication specified!"))
return urllib.request.urlopen(request)
| 41.508475 | 22,041 |
580 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - João Marques
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Clear all partners in bank statement lines",
"version": "15.0.1.0.1",
# see https://odoo-community.org/page/development-status
"development_status": "Production/Stable",
"category": "Invoicing Management",
"website": "https://github.com/OCA/bank-statement-import",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["account"],
"data": ["views/account_bank_statement_views.xml"],
}
| 41.357143 | 579 |
4,465 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - João Marques
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0
from odoo.tests import common
class TestAccountBankStatementClearPartner(common.SavepointCase):
@classmethod
def setup_multi_currency_data(cls, default_values=None, rate2016=3.0, rate2017=2.0):
default_values = default_values or {}
foreign_currency = cls.env["res.currency"].search(
[("active", "=", False)], limit=1
)
rate1 = cls.env["res.currency.rate"].create(
{
"name": "2016-01-01",
"rate": rate2016,
"currency_id": foreign_currency.id,
"company_id": cls.env.company.id,
}
)
rate2 = cls.env["res.currency.rate"].create(
{
"name": "2017-01-01",
"rate": rate2017,
"currency_id": foreign_currency.id,
"company_id": cls.env.company.id,
}
)
return {
"currency": foreign_currency,
"rates": rate1 + rate2,
}
@classmethod
def setUpClass(cls):
super(TestAccountBankStatementClearPartner, cls).setUpClass()
cls.partner_1 = cls.env["res.partner"].create({"name": "Partner 1"})
cls.partner_2 = cls.env["res.partner"].create({"name": "Partner 2"})
cls.currency_data = cls.setup_multi_currency_data()
cls.account_type_1 = cls.env["account.account.type"].create(
{"name": "Test Account Type 1", "type": "other", "internal_group": "income"}
)
cls.account_1 = cls.env["account.account"].create(
{
"name": "Test Account 1",
"code": "AAAAAAAAAAAAAAAA",
"user_type_id": cls.account_type_1.id,
}
)
cls.sequence_1 = cls.env["ir.sequence"].create({"name": "Test Sequence 1"})
cls.journal_1 = cls.env["account.journal"].create(
{
"name": "Test Journal 1",
"type": "bank",
"secure_sequence_id": cls.sequence_1.id,
}
)
cls.statement_1 = cls.env["account.bank.statement"].create(
{"name": "Test Bank Statement 1", "journal_id": cls.journal_1.id}
)
cls.currency_2 = cls.currency_data["currency"]
line_obj = cls.env["account.bank.statement.line"]
cls.st_line_w_partner_not_reconciled = line_obj.create(
{
"name": "Test Account Bank Statement 1",
"statement_id": cls.statement_1.id,
"partner_id": cls.partner_1.id,
"payment_ref": "REF-TEST-1",
"foreign_currency_id": cls.currency_2.id,
"amount": 1250.0,
"amount_currency": 2500.0,
}
)
cls.st_line_wo_partner_not_reconciled = line_obj.create(
{
"name": "Test Account Bank Statement 2",
"statement_id": cls.statement_1.id,
"partner_id": False,
"payment_ref": "REF-TEST-2",
}
)
cls.st_line_w_partner_reconciled = line_obj.create(
{
"name": "Test Account Bank Statement 3",
"statement_id": cls.statement_1.id,
"partner_id": cls.partner_2.id,
"payment_ref": "REF-TEST-3",
}
)
cls.account_move_1 = cls.env["account.move"].create(
{
"move_type": "entry",
"journal_id": cls.journal_1.id,
"invoice_line_ids": [
(
0,
0,
{
"name": "50 to pay",
"account_id": cls.account_1.id,
"amount_residual": 1,
"statement_line_id": cls.st_line_w_partner_reconciled.id,
},
)
],
}
)
def test_bank_statements_clear_partner(self):
self.statement_1.clear_partners()
# Confirm statement_line_1 has no parter
self.assertFalse(self.st_line_w_partner_not_reconciled.partner_id)
# Confirm statement_line_3 still has partner because it was already reconciled
self.assertTrue(self.st_line_w_partner_reconciled.partner_id)
| 38.153846 | 4,464 |
384 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - João Marques
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import models
class AccountBankStatementClearPartner(models.Model):
_inherit = "account.bank.statement"
def clear_partners(self):
for line in self.line_ids:
if not line.is_reconciled:
line.write({"partner_id": False})
| 29.461538 | 383 |
1,055 |
py
|
PYTHON
|
15.0
|
# Copyright 2014-2017 Akretion (http://www.akretion.com).
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "PayPal CSV Format Bank Statements Import",
"summary": "Import PayPal CSV files as Bank Statements in Odoo",
"version": "15.0.1.0.1",
"category": "Accounting",
"website": "https://github.com/OCA/bank-statement-import",
"author": "Akretion, CorporateHub, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": [
"account_statement_import",
"multi_step_wizard",
"web_widget_dropdown_dynamic",
],
"data": [
"security/ir.model.access.csv",
"data/maps.xml",
"views/account_statement_import_paypal_mapping.xml",
"views/account_statement_import.xml",
"wizards/account_statement_import_paypal_mapping_wizard.xml",
],
}
| 37.678571 | 1,055 |
1,094 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Carlos Roca
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from openupgradelib import openupgrade
_model_renames = [
(
"account.bank.statement.import.paypal.mapping",
"account.statement.import.paypal.mapping",
),
(
"account.bank.statement.import.paypal.parser",
"account.statement.import.paypal.parser",
),
(
"account.bank.statement.import.paypal.mapping.wizard",
"account.statement.import.paypal.mapping.wizard",
),
]
_table_renames = [
(
"account_bank_statement_import_paypal_mapping",
"account_statement_import_paypal_mapping",
),
(
"account_bank_statement_import_paypal_parser",
"account_statement_import_paypal_parser",
),
(
"account_bank_statement_import_paypal_mapping_wizard",
"account_statement_import_paypal_mapping_wizard",
),
]
@openupgrade.migrate()
def migrate(env, version):
openupgrade.rename_models(env.cr, _model_renames)
openupgrade.rename_tables(env.cr, _table_renames)
| 27.35 | 1,094 |
7,692 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from base64 import b64encode
from os import path
from odoo import fields
from odoo.exceptions import UserError
from odoo.tests import common
class TestAccountBankStatementImportPayPal(common.TransactionCase):
def setUp(self):
super().setUp()
self.now = fields.Datetime.now()
self.currency_eur = self.env.ref("base.EUR")
self.currency_usd = self.env.ref("base.USD")
self.paypal_statement_map_en = self.env.ref(
"account_statement_import_paypal.paypal_statement_map_en"
)
self.paypal_statement_map_es = self.env.ref(
"account_statement_import_paypal.paypal_statement_map_es"
)
self.paypal_activity_map_en = self.env.ref(
"account_statement_import_paypal.paypal_activity_map_en"
)
self.AccountJournal = self.env["account.journal"]
self.AccountBankStatement = self.env["account.bank.statement"]
self.AccountStatementImport = self.env["account.statement.import"]
self.AccountStatementImportPayPalMapping = self.env[
"account.statement.import.paypal.mapping"
]
self.AccountStatementImportPayPalMappingWizard = self.env[
"account.statement.import.paypal.mapping.wizard"
]
self.env.ref("base.EUR").write({"active": True})
def _data_file(self, filename):
with open(path.join(path.dirname(__file__), filename)) as file:
return b64encode(file.read().encode("utf-8"))
def test_import_statement_en_usd(self):
journal = self.AccountJournal.create(
{
"name": "PayPal",
"type": "bank",
"code": "PP",
"currency_id": self.currency_usd.id,
}
)
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/statement_en.csv",
"statement_file": self._data_file("fixtures/statement_en.csv"),
"paypal_mapping_id": self.paypal_statement_map_en.id,
}
)
wizard.with_context(
journal_id=journal.id,
account_statement_import_paypal_test=True,
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 18)
def test_import_statement_en_eur(self):
journal = self.AccountJournal.create(
{
"name": "PayPal",
"type": "bank",
"code": "PP",
"currency_id": self.currency_eur.id,
}
)
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/statement_en.csv",
"statement_file": self._data_file("fixtures/statement_en.csv"),
"paypal_mapping_id": self.paypal_statement_map_en.id,
}
)
wizard.with_context(
journal_id=journal.id,
account_statement_import_paypal_test=True,
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 8)
def test_import_statement_es(self):
journal = self.AccountJournal.create(
{
"name": "PayPal",
"type": "bank",
"code": "PP",
"currency_id": self.currency_eur.id,
}
)
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/statement_es.csv",
"statement_file": self._data_file("fixtures/statement_es.csv"),
"paypal_mapping_id": self.paypal_statement_map_es.id,
}
)
wizard.with_context(
journal_id=journal.id,
account_statement_import_paypal_test=True,
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 8)
def test_import_activity_en(self):
journal = self.AccountJournal.create(
{
"name": "PayPal",
"type": "bank",
"code": "PP",
"currency_id": self.currency_usd.id,
}
)
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/activity_en.csv",
"statement_file": self._data_file("fixtures/activity_en.csv"),
"paypal_mapping_id": self.paypal_activity_map_en.id,
}
)
wizard.with_context(
journal_id=journal.id,
account_statement_import_paypal_test=True,
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
self.assertEqual(len(statement.line_ids), 71)
def test_import_empty_activity(self):
journal = self.AccountJournal.create(
{
"name": "PayPal",
"type": "bank",
"code": "PP",
"currency_id": self.currency_usd.id,
}
)
wizard = self.AccountStatementImport.with_context(journal_id=journal.id).create(
{
"statement_filename": "fixtures/empty_activity.csv",
"statement_file": self._data_file("fixtures/empty_activity.csv"),
"paypal_mapping_id": self.paypal_activity_map_en.id,
}
)
with self.assertRaises(UserError):
wizard.with_context(
journal_id=journal.id,
account_statement_import_paypal_test=True,
).import_file_button()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 0)
def test_import_activity_mapping_en(self):
with common.Form(self.AccountStatementImportPayPalMappingWizard) as form:
form.filename = "fixtures/activity_en.csv"
form.data_file = self._data_file("fixtures/activity_en.csv")
self.assertEqual(
len(
self.AccountStatementImportPayPalMappingWizard.with_context(
header=form.header,
).statement_columns()
),
22,
)
wizard = form.save()
wizard.import_mapping()
def test_import_statement_mapping_en(self):
with common.Form(self.AccountStatementImportPayPalMappingWizard) as form:
form.filename = "fixtures/statement_en.csv"
form.data_file = self._data_file("fixtures/statement_en.csv")
self.assertEqual(
len(
self.AccountStatementImportPayPalMappingWizard.with_context(
header=form.header,
).statement_columns()
),
18,
)
wizard = form.save()
wizard.import_mapping()
| 39.854922 | 7,692 |
3,581 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class AccountBankStatementImportPayPalMapping(models.Model):
_name = "account.statement.import.paypal.mapping"
_description = "Account Statement Import PayPal Mapping"
name = fields.Char(
required=True,
)
float_thousands_sep = fields.Selection(
string="Thousands Separator",
selection=[("dot", "dot (.)"), ("comma", "comma (,)"), ("none", "none")],
default="dot",
required=True,
)
float_decimal_sep = fields.Selection(
string="Decimals Separator",
selection=[("dot", "dot (.)"), ("comma", "comma (,)"), ("none", "none")],
default="comma",
required=True,
)
date_format = fields.Char(
required=True,
)
time_format = fields.Char(
required=True,
)
date_column = fields.Char(
string='"Date" column',
required=True,
)
time_column = fields.Char(
string='"Time" column',
required=True,
)
tz_column = fields.Char(
string='"Timezone" column',
required=True,
)
name_column = fields.Char(
string='"Name" column',
required=True,
)
currency_column = fields.Char(
string='"Currency" column',
required=True,
)
gross_column = fields.Char(
string='"Gross" column',
required=True,
)
fee_column = fields.Char(
string='"Fee" column',
required=True,
)
balance_column = fields.Char(
string='"Balance" column',
required=True,
)
transaction_id_column = fields.Char(
string='"Transaction ID" column',
required=True,
)
description_column = fields.Char(
string='"Description" column',
)
type_column = fields.Char(
string='"Type" column',
)
from_email_address_column = fields.Char(
string='"From Email Address" column',
)
to_email_address_column = fields.Char(
string='"To Email Address" column',
)
invoice_id_column = fields.Char(
string='"Invoice ID" column',
)
subject_column = fields.Char(
string='"Subject" column',
)
note_column = fields.Char(
string='"Note" column',
)
bank_name_column = fields.Char(
string='"Bank Name" column',
)
bank_account_column = fields.Char(
string='"Bank Account" column',
)
@api.onchange("float_thousands_sep")
def onchange_thousands_separator(self):
if "dot" == self.float_thousands_sep == self.float_decimal_sep:
self.float_decimal_sep = "comma"
elif "comma" == self.float_thousands_sep == self.float_decimal_sep:
self.float_decimal_sep = "dot"
@api.onchange("float_decimal_sep")
def onchange_decimal_separator(self):
if "dot" == self.float_thousands_sep == self.float_decimal_sep:
self.float_thousands_sep = "comma"
elif "comma" == self.float_thousands_sep == self.float_decimal_sep:
self.float_thousands_sep = "dot"
def _get_float_separators(self):
self.ensure_one()
separators = {
"dot": ".",
"comma": ",",
"none": "",
}
return (
separators[self.float_thousands_sep],
separators[self.float_decimal_sep],
)
| 29.352459 | 3,581 |
9,151 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import itertools
import logging
from datetime import datetime
from decimal import Decimal
from io import StringIO
from os import path
from pytz import timezone, utc
from odoo import _, api, models
_logger = logging.getLogger(__name__)
try:
from csv import reader
except (ImportError, IOError) as err:
_logger.error(err)
class AccountBankStatementImportPayPalParser(models.TransientModel):
_name = "account.statement.import.paypal.parser"
_description = "Account Statement Import PayPal Parser"
@api.model
def parse_header(self, data_file):
data = StringIO(data_file.decode("utf-8-sig"))
csv_data = reader(data)
return list(next(csv_data))
@api.model
def parse(self, mapping, data_file, filename):
journal = self.env["account.journal"].browse(self.env.context.get("journal_id"))
currency_code = (journal.currency_id or journal.company_id.currency_id).name
account_number = journal.bank_account_id.acc_number
name = _("%(code)s: %(path)s") % {
"code": journal.code,
"path": path.basename(filename),
}
lines = self._parse_lines(mapping, data_file, currency_code)
if not lines:
return currency_code, account_number, [{"name": name, "transactions": []}]
lines = list(sorted(lines, key=lambda line: line["timestamp"]))
first_line = lines[0]
balance_start = first_line["balance_amount"]
balance_start -= first_line["gross_amount"]
balance_start -= first_line["fee_amount"]
last_line = lines[-1]
balance_end = last_line["balance_amount"]
transactions = list(
itertools.chain.from_iterable(
map(lambda line: self._convert_line_to_transactions(line), lines)
)
)
return (
currency_code,
account_number,
[
{
"name": name,
"date": first_line["timestamp"].date(),
"balance_start": float(balance_start),
"balance_end_real": float(balance_end),
"transactions": transactions,
}
],
)
def _data_dict_constructor(self, mapping, header):
required_list = [
"date_column",
"time_column",
"tz_column",
"name_column",
"currency_column",
"gross_column",
"fee_column",
"balance_column",
"transaction_id_column",
]
optional_list = [
"description_column",
"type_column",
"from_email_address_column",
"to_email_address_column",
"invoice_id_column",
"subject_column",
"note_column",
"bank_name_column",
"bank_account_column",
]
data_dict = {}
for key in required_list:
data_dict[key] = header.index(getattr(mapping, key))
for key in optional_list:
try:
data_dict[key] = header.index(getattr(mapping, key))
except ValueError:
data_dict[key] = None
return data_dict
def _parse_lines(self, mapping, data_file, currency_code):
data = StringIO(data_file.decode("utf-8-sig"))
csv_data = reader(data)
header = list(next(csv_data))
data_dict = self._data_dict_constructor(mapping, header)
return self._calculate_lines(csv_data, data_dict, mapping, currency_code)
def _calculate_lines(self, csv_data, data_dict, mapping, currency_code):
lines = []
for row in csv_data:
row = list(row)
dict_values = {}
for key in data_dict:
dict_values[key] = (
row[data_dict.get(key)] if data_dict.get(key) is not None else None
)
if dict_values.get("currency_column") != currency_code:
continue
date = datetime.strptime(
dict_values.get("date_column"), mapping.date_format
).date()
time = datetime.strptime(
dict_values.get("time_column"), mapping.time_format
).time()
timestamp = datetime.combine(date, time)
tz_value = self._normalize_tz(dict_values.get("tz_column"))
tz = timezone(tz_value)
timestamp = timestamp.replace(tzinfo=tz)
timestamp = timestamp.astimezone(utc).replace(tzinfo=None)
gross_amount = self._parse_decimal(dict_values.get("gross_column"), mapping)
fee_amount = self._parse_decimal(dict_values.get("fee_column"), mapping)
balance_amount = self._parse_decimal(
dict_values.get("balance_column"), mapping
)
bank = (
"{} - {}".format(
dict_values.get("bank_name_column"),
dict_values.get("bank_account_column"),
)
if dict_values.get("bank_name_column")
and dict_values.get("bank_account_column")
else None
)
if data_dict.get("to_email_address_column") is None:
payer_email = dict_values.get("from_email_address_column")
else:
payer_email = (
dict_values.get("to_email_address_column")
if gross_amount < 0.0
else dict_values.get("from_email_address_column")
)
lines.append(
{
"transaction_id": dict_values.get("transaction_id_column"),
"invoice": dict_values.get("invoice_id_column"),
"description": dict_values.get("description_column")
or dict_values.get("type_column"),
"details": dict_values.get("subject_column")
or dict_values.get("note_column")
or bank,
"timestamp": timestamp,
"gross_amount": gross_amount,
"fee_amount": fee_amount,
"balance_amount": balance_amount,
"payer_name": dict_values.get("name_column"),
"payer_email": payer_email,
"partner_bank_name": dict_values.get("bank_name_column"),
"partner_bank_account": dict_values.get("bank_account_column"),
}
)
return lines
@api.model
def _convert_line_to_transactions(self, line):
transactions = []
transaction_id = line["transaction_id"]
invoice = line["invoice"]
description = line["description"]
details = line["details"]
timestamp = line["timestamp"]
gross_amount = line["gross_amount"]
fee_amount = line["fee_amount"]
payer_name = line["payer_name"]
payer_email = line["payer_email"]
partner_bank_account = line["partner_bank_account"]
if invoice:
invoice = _("Invoice %s") % invoice
note = "{} {}".format(description, transaction_id)
if details:
note += ": %s" % details
if payer_email:
note += " (%s)" % payer_email
unique_import_id = "{}-{}".format(transaction_id, int(timestamp.timestamp()))
name = (invoice or details or description or "",)
transaction = {
"name": invoice or details or description or "",
"amount": str(gross_amount),
"date": timestamp,
"payment_ref": note,
"unique_import_id": unique_import_id,
}
if payer_name:
line.update({"partner_name": payer_name})
if partner_bank_account:
line.update({"account_number": partner_bank_account})
transactions.append(transaction)
if fee_amount:
transactions.append(
{
"name": _("Fee for %s") % (name or transaction_id),
"amount": str(fee_amount),
"date": timestamp,
"partner_name": "PayPal",
"unique_import_id": "%s-FEE" % unique_import_id,
"payment_ref": _("Transaction fee for %s") % note,
}
)
return transactions
@api.model
def _parse_decimal(self, value, mapping):
thousands, decimal = mapping._get_float_separators()
value = value.replace(thousands, "")
value = value.replace(decimal, ".")
return Decimal(value)
@api.model
def _normalize_tz(self, value):
if value in ["PDT", "PST"]:
return "America/Los_Angeles"
elif value in ["CET", "CEST"]:
return "Europe/Paris"
return value
| 36.604 | 9,151 |
509 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import models
class AccountJournal(models.Model):
_inherit = "account.journal"
def _get_bank_statements_available_import_formats(self):
res = super()._get_bank_statements_available_import_formats()
res.append("PayPal Reports")
return res
| 33.933333 | 509 |
1,383 |
py
|
PYTHON
|
15.0
|
# Copyright 2014-2017 Akretion (http://www.akretion.com).
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from odoo import fields, models
_logger = logging.getLogger(__name__)
class AccountStatementImport(models.TransientModel):
_inherit = "account.statement.import"
paypal_mapping_id = fields.Many2one(
string="PayPal mapping",
comodel_name="account.statement.import.paypal.mapping",
)
def _parse_file(self, data_file):
self.ensure_one()
if self.paypal_mapping_id:
try:
Parser = self.env["account.statement.import.paypal.parser"]
logging.warning(
Parser.parse(
self.paypal_mapping_id, data_file, self.statement_filename
)
)
return Parser.parse(
self.paypal_mapping_id, data_file, self.statement_filename
)
except Exception:
if self.env.context.get("account_statement_import_paypal_test"):
raise
_logger.warning("PayPal parser error", exc_info=True)
return super()._parse_file(data_file)
| 35.461538 | 1,383 |
5,838 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Vicent Cubells
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import json
from base64 import b64decode
from os import path
from odoo import _, api, fields, models
class AccountBankStatementImportPayPalMappingWizard(models.TransientModel):
_name = "account.statement.import.paypal.mapping.wizard"
_description = "Account Statement Import PayPal Mapping Wizard"
_inherit = ["multi.step.wizard.mixin"]
data_file = fields.Binary(
string="PayPal Report File",
required=True,
)
filename = fields.Char()
header = fields.Char()
date_column = fields.Char(
string='"Date" column',
)
time_column = fields.Char(
string='"Time" column',
)
tz_column = fields.Char(
string='"Timezone" column',
)
name_column = fields.Char(
string='"Name" column',
)
currency_column = fields.Char(
string='"Currency" column',
)
gross_column = fields.Char(
string='"Gross" column',
)
fee_column = fields.Char(
string='"Fee" column',
)
balance_column = fields.Char(
string='"Balance" column',
)
transaction_id_column = fields.Char(
string='"Transaction ID" column',
)
description_column = fields.Char(
string='"Description" column',
)
type_column = fields.Char(
string='"Type" column',
)
from_email_address_column = fields.Char(
string='"From Email Address" column',
)
to_email_address_column = fields.Char(
string='"To Email Address" column',
)
invoice_id_column = fields.Char(
string='"Invoice ID" column',
)
subject_column = fields.Char(
string='"Subject" column',
)
note_column = fields.Char(
string='"Note" column',
)
bank_name_column = fields.Char(
string='"Bank Name" column',
)
bank_account_column = fields.Char(
string='"Bank Account" column',
)
@api.onchange("data_file")
def _onchange_data_file(self):
Parser = self.env["account.statement.import.paypal.parser"]
if not self.data_file:
return
header = Parser.parse_header(b64decode(self.data_file))
header = [column for column in header if column]
self.header = json.dumps(header)
if len(header) == 22:
self.date_column = header[0]
self.time_column = header[1]
self.tz_column = header[2]
self.name_column = header[3]
self.currency_column = header[6]
self.gross_column = header[7]
self.fee_column = header[8]
self.balance_column = header[18]
self.transaction_id_column = header[12]
self.type_column = header[4]
self.from_email_address_column = header[10]
self.to_email_address_column = header[11]
self.invoice_id_column = header[16]
self.subject_column = header[20]
self.note_column = header[21]
elif len(header) == 18:
self.date_column = header[0]
self.time_column = header[1]
self.tz_column = header[2]
self.name_column = header[11]
self.currency_column = header[4]
self.gross_column = header[5]
self.fee_column = header[6]
self.balance_column = header[8]
self.transaction_id_column = header[9]
self.description_column = header[3]
self.from_email_address_column = header[10]
self.invoice_id_column = header[16]
self.bank_name_column = header[12]
self.bank_account_column = header[13]
@api.model
def statement_columns(self):
header = self.env.context.get("header")
if not header:
return []
return [(x, x) for x in json.loads(header)]
def _get_mapping_values(self):
"""Hook for extension"""
self.ensure_one()
return {
"name": _("Mapping from %s") % path.basename(self.filename),
"float_thousands_sep": "comma",
"float_decimal_sep": "dot",
"date_format": "%d/%m/%Y",
"time_format": "%H:%M:%S",
"date_column": self.date_column,
"time_column": self.time_column,
"tz_column": self.tz_column,
"name_column": self.name_column,
"currency_column": self.currency_column,
"gross_column": self.gross_column,
"fee_column": self.fee_column,
"balance_column": self.balance_column,
"transaction_id_column": self.transaction_id_column,
"description_column": self.description_column,
"type_column": self.type_column,
"from_email_address_column": self.from_email_address_column,
"to_email_address_column": self.to_email_address_column,
"invoice_id_column": self.invoice_id_column,
"subject_column": self.subject_column,
"note_column": self.note_column,
"bank_name_column": self.bank_name_column,
"bank_account_column": self.bank_account_column,
}
def import_mapping(self):
self.ensure_one()
mapping = self.env["account.statement.import.paypal.mapping"].create(
self._get_mapping_values()
)
return {
"type": "ir.actions.act_window",
"name": _("Imported Mapping"),
"res_model": "account.statement.import.paypal.mapping",
"res_id": mapping.id,
"view_mode": "form",
"view_id": False,
"target": "current",
}
| 34.75 | 5,838 |
426 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Bank Account Camt54 Import",
"version": "15.0.1.0.0",
"category": "Account",
"website": "https://github.com/OCA/bank-statement-import",
"author": "camptocamp, " "Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": ["account_statement_import_camt"],
}
| 35.5 | 426 |
2,598 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.exceptions import UserError
from odoo.tests import common
class TestGetPartnerRef(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.Parser = cls.env["account.statement.import.camt.parser"]
cls.ICP = cls.env["ir.config_parameter"]
def test_no_ICP(self):
"""Test no partner ref is read if param is not set"""
ref = "11 11111 11111 11111 11111 11111".replace(" ", "")
partner_ref = self.Parser._get_partner_ref(ref)
self.assertFalse(partner_ref)
def test_ICP_empty(self):
self.ICP.set_param("isr_partner_ref", "")
ref = "11 11111 11111 11111 11111 11111".replace(" ", "")
partner_ref = self.Parser._get_partner_ref(ref)
self.assertFalse(partner_ref)
def test_ICP_no_len(self):
"""Test a default len of 6 is set if not provided"""
self.ICP.set_param("isr_partner_ref", "12")
ref = "11 11111 11112 34567 11111 11111".replace(" ", "")
partner_ref = self.Parser._get_partner_ref(ref)
self.assertEqual(partner_ref, "234567")
def test_ICP_full(self):
"""Test full format of partner ref definition"""
self.ICP.set_param("isr_partner_ref", "12,6")
ref = "11 11111 11112 34567 11111 11111".replace(" ", "")
partner_ref = self.Parser._get_partner_ref(ref)
self.assertEqual(partner_ref, "234567")
def test_zero_stripped(self):
"""Test full format of partner ref definition"""
self.ICP.set_param("isr_partner_ref", "12,6")
ref = "11 11111 11110 00560 11111 11111".replace(" ", "")
partner_ref = self.Parser._get_partner_ref(ref)
self.assertEqual(partner_ref, "560")
def test_bad_ICP(self):
"""Test ir config parameter validation"""
self.ICP.set_param("isr_partner_ref", "")
ref = "11 11111 11111 11111 11111 11111".replace(" ", "")
self.ICP.set_param("isr_partner_ref", "A")
with self.assertRaises(UserError):
self.Parser._get_partner_ref(ref)
self.ICP.set_param("isr_partner_ref", "A,B")
with self.assertRaises(UserError):
self.Parser._get_partner_ref(ref)
self.ICP.set_param("isr_partner_ref", "1,X")
with self.assertRaises(UserError):
self.Parser._get_partner_ref(ref)
self.ICP.set_param("isr_partner_ref", "A,8")
with self.assertRaises(UserError):
self.Parser._get_partner_ref(ref)
| 39.363636 | 2,598 |
2,553 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import base64
from odoo.modules.module import get_module_resource
from odoo.tests.common import TransactionCase
class TestGenerateBankStatement(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
eur = cls.env.ref("base.EUR")
eur.write({"active": True})
bank = cls.env["res.partner.bank"].create(
{
"acc_number": "NL77ABNA0574908765",
"partner_id": cls.env.ref("base.main_partner").id,
"company_id": cls.env.ref("base.main_company").id,
"bank_id": cls.env.ref("base.res_bank_1").id,
}
)
cls.env["res.partner.bank"].create(
{
"acc_number": "NL46ABNA0499998748",
"partner_id": cls.env.ref("base.main_partner").id,
"company_id": cls.env.ref("base.main_company").id,
"bank_id": cls.env.ref("base.res_bank_1").id,
}
)
cls.journal = cls.env["account.journal"].create(
{
"name": "Bank Journal - (test camt)",
"code": "TBNKCAMT",
"type": "bank",
"bank_account_id": bank.id,
"currency_id": eur.id,
}
)
def _load_statement(self):
testfile = get_module_resource(
"account_statement_import_camt", "test_files", "test-camt053"
)
with open(testfile, "rb") as datafile:
camt_file = base64.b64encode(datafile.read())
self.env["account.statement.import"].create(
{
"statement_filename": "test import",
"statement_file": camt_file,
}
).import_file_button()
bank_st_record = self.env["account.bank.statement"].search(
[("name", "=", "1234Test/1")], limit=1
)
statement_lines = bank_st_record.line_ids
return statement_lines
def test_statement_import(self):
self.journal.transfer_line = True
lines = self._load_statement()
self.assertEqual(len(lines), 5)
self.assertAlmostEqual(sum(lines.mapped("amount")), 0)
self.journal.transfer_line = False
lines = self._load_statement()
self.assertEqual(len(lines), 4)
self.assertAlmostEqual(sum(lines.mapped("amount")), -12.99)
| 37.544118 | 2,553 |
363 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class AccountBankStatementImport(models.Model):
_inherit = "account.journal"
transfer_line = fields.Boolean(
string="Add balance Line",
help="Generate balance line on total of bank statement import",
)
| 25.928571 | 363 |
3,605 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, exceptions, models
class CamtParser(models.AbstractModel):
"""Parser for camt bank statement import files."""
_inherit = "account.statement.import.camt.parser"
def _get_partner_ref(self, isr):
ICP = self.env["ir.config_parameter"]
ref_format = ICP.sudo().get_param("isr_partner_ref")
if not ref_format:
return
config = ref_format.split(",")
if len(config) == 2:
start, size = config
elif len(config) == 1:
start = config[0]
size = 6
else:
raise exceptions.UserError(
_(
"Config parameter `isr_partner_ref` is wrong.\n"
"It must be in format `i[,n]` \n"
"where `i` is the position of the first digit and\n"
"`n` the number of digit in the reference,"
" by default 6.\n"
'e.g. "13,6"'
)
)
try:
start = int(start) - 1 # count from 1 instead of 0
size = int(size)
end = start + size
except ValueError as err:
raise exceptions.UserError(
_(
"Config parameter `isr_partner_ref` is wrong.\n"
"It must be in format `i[,n]` \n"
"`i` and `n` must be integers.\n"
'e.g. "13,6"'
)
) from err
return isr[start:end].lstrip("0")
def parse_transaction_details(self, ns, node, transaction):
"""Put ESR in label and add aditional information to label
if no esr is available
"""
super().parse_transaction_details(ns, node, transaction)
# put the esr in the label. odoo reconciles based on the label,
# if there is no esr it tries to use the information textfield
isr_number = node.xpath(
"./ns:RmtInf/ns:Strd/ns:CdtrRefInf/ns:Ref", namespaces={"ns": ns}
)
if len(isr_number):
transaction["payment_ref"] = isr_number[0].text
partner_ref = self._get_partner_ref(isr_number[0].text)
if partner_ref:
transaction["partner_ref"] = partner_ref
else:
xpath_exprs = [
"./ns:RmtInf/ns:Ustrd|./ns:RtrInf/ns:AddtlInf",
"./ns:AddtlNtryInf",
"/ns:Refs/ns:InstrId",
]
payment_ref = transaction["payment_ref"]
for xpath_expr in xpath_exprs:
found_node = node.xpath(xpath_expr, namespaces={"ns": ns})
if found_node:
payment_ref = found_node[0].text
break
trans_id_node = (
node.getparent()
.getparent()
.xpath("./ns:AcctSvcrRef", namespaces={"ns": ns})
)
if trans_id_node:
payment_ref = "{} ({})".format(payment_ref, trans_id_node[0].text)
if payment_ref:
transaction["payment_ref"] = payment_ref
# End add esr to the label.
# add transaction id to ref
self.add_value_from_node(
ns,
node,
[
"./../../ns:AcctSvcrRef",
"./ns:RmtInf/ns:Strd/ns:CdtrRefInf/ns:Ref",
"./ns:Refs/ns:EndToEndId",
],
transaction,
"ref",
)
return True
| 36.05 | 3,605 |
1,997 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from odoo import models
_logger = logging.getLogger(__name__)
class AccountStatementImport(models.TransientModel):
"""Add process_camt method to account.bank.statement.import."""
_inherit = "account.statement.import"
def _create_bank_statements(self, stmts_vals, result):
"""Create additional line in statement to set bank statement statement
to 0 balance"""
super()._create_bank_statements(stmts_vals, result)
statements = self.env["account.bank.statement"].browse(result["statement_ids"])
for statement in statements:
amount = sum(statement.line_ids.mapped("amount"))
if statement.journal_id.transfer_line:
if amount != 0:
amount = -amount
statement.line_ids.create(
{
"amount": amount,
"statement_id": statement.id,
"date": statement.date,
"payment_ref": statement.name,
}
)
statement.balance_end_real = statement.balance_start
else:
statement.balance_end_real = statement.balance_start + amount
return
def _complete_stmts_vals(self, stmts_vals, journal, account_number):
"""Search partner from partner reference"""
stmts_vals = super()._complete_stmts_vals(stmts_vals, journal, account_number)
for st_vals in stmts_vals:
for line_vals in st_vals["transactions"]:
if "partner_ref" in line_vals:
partner_ref = line_vals.pop("partner_ref")
partner = self.env["res.partner"].search(
[("ref", "=", partner_ref)], limit=1
)
line_vals["partner_id"] = partner.id
return stmts_vals
| 39.156863 | 1,997 |
998 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Online Bank Statements",
"version": "15.0.3.0.0",
"author": "CorporateHub, Odoo Community Association (OCA)",
"maintainers": ["alexey-pelykh"],
"website": "https://github.com/OCA/bank-statement-import",
"license": "AGPL-3",
"category": "Accounting",
"summary": "Online bank statements update",
"depends": [
"account_statement_import_base",
"web_widget_dropdown_dynamic",
],
"data": [
"data/account_statement_import_online.xml",
"security/ir.model.access.csv",
"security/online_bank_statement_provider.xml",
"wizards/online_bank_statement_pull_wizard.xml",
"views/actions.xml",
"views/account_journal.xml",
"views/online_bank_statement_provider.xml",
],
"installable": True,
}
| 35.642857 | 998 |
542 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from openupgradelib import openupgrade
_column_renames = {
"account_bank_statement_line": [
("online_raw_data", None),
]
}
@openupgrade.migrate()
def migrate(env, version):
if openupgrade.column_exists(
env.cr, "account_bank_statement_line", "online_raw_data"
):
openupgrade.rename_columns(env.cr, _column_renames)
| 28.526316 | 542 |
623 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
column = openupgrade.get_legacy_name("online_raw_data")
if openupgrade.column_exists(env.cr, "account_bank_statement_line", column):
openupgrade.logged_query(
env.cr,
"UPDATE account_bank_statement_line SET raw_data={online_raw_data}".format(
online_raw_data=column,
),
)
| 36.647059 | 623 |
2,834 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2019-2020 Dataplug (https://dataplug.io)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from datetime import datetime, timedelta
from random import randrange
from dateutil.relativedelta import relativedelta
from pytz import timezone
from odoo import fields, models
class OnlineBankStatementProviderDummy(models.Model):
_inherit = "online.bank.statement.provider"
def _obtain_statement_data(self, date_since, date_until):
self.ensure_one()
if self.service != "dummy":
return super()._obtain_statement_data(
date_since,
date_until,
) # pragma: no cover
if self.env.context.get("crash", False):
exception = self.env.context.get("exception", Exception("Expected"))
raise exception
line_step_options = self.env.context.get("step", {"minutes": 5})
line_step = relativedelta(**line_step_options)
expand_by = self.env.context.get("expand_by", 0)
data_since = self.env.context.get("data_since", date_since)
data_until = self.env.context.get("data_until", date_until)
data_since -= expand_by * line_step
data_until += expand_by * line_step
balance_start = self.env.context.get(
"balance_start", randrange(-10000, 10000, 1) * 0.1
)
balance = balance_start
tz = self.env.context.get("tz")
if tz:
tz = timezone(tz)
timestamp_mode = self.env.context.get("timestamp_mode")
lines = []
date = data_since
while date < data_until:
amount = self.env.context.get("amount", randrange(-100, 100, 1) * 0.1)
transaction_date = date.replace(tzinfo=tz)
if timestamp_mode == "date":
transaction_date = transaction_date.date()
elif timestamp_mode == "str":
transaction_date = fields.Datetime.to_string(transaction_date)
lines.append(
{
"payment_ref": "payment",
"amount": amount,
"date": transaction_date,
"unique_import_id": str(
int((date - datetime(1970, 1, 1)) / timedelta(seconds=1))
),
"partner_name": "John Doe",
"account_number": "XX00 0000 0000 0000",
}
)
balance += amount
date += line_step
balance_end = balance
statement = {}
if self.env.context.get("balance", True):
statement.update(
{"balance_start": balance_start, "balance_end_real": balance_end}
)
return lines, statement
| 36.805195 | 2,834 |
27,159 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2019-2020 Dataplug (https://dataplug.io)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from datetime import date, datetime
from unittest import mock
from urllib.error import HTTPError
from dateutil.relativedelta import relativedelta
from odoo_test_helper import FakeModelLoader
from psycopg2 import IntegrityError
from odoo import fields
from odoo.tests import common
from odoo.tools import mute_logger
mock_obtain_statement_data = (
"odoo.addons.account_statement_import_online.tests."
+ "online_bank_statement_provider_dummy.OnlineBankStatementProviderDummy."
+ "_obtain_statement_data"
)
class TestAccountBankAccountStatementImportOnline(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# Load fake model
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
cls.addClassCleanup(cls.loader.restore_registry)
from .online_bank_statement_provider_dummy import (
OnlineBankStatementProviderDummy,
)
cls.loader.update_registry((OnlineBankStatementProviderDummy,))
cls.now = fields.Datetime.now()
cls.AccountJournal = cls.env["account.journal"]
cls.OnlineBankStatementProvider = cls.env["online.bank.statement.provider"]
cls.OnlineBankStatementPullWizard = cls.env["online.bank.statement.pull.wizard"]
cls.AccountBankStatement = cls.env["account.bank.statement"]
cls.AccountBankStatementLine = cls.env["account.bank.statement.line"]
def test_provider_unlink_restricted(self):
journal = self.AccountJournal.create(
{"name": "Bank", "type": "bank", "code": "BANK"}
)
with common.Form(journal) as journal_form:
journal_form.bank_statements_source = "online"
journal_form.online_bank_statement_provider = "dummy"
journal_form.save()
with self.assertRaises(IntegrityError), mute_logger("odoo.sql_db"):
journal.online_bank_statement_provider_id.unlink()
def test_cascade_unlink(self):
journal = self.AccountJournal.create(
{"name": "Bank", "type": "bank", "code": "BANK"}
)
with common.Form(journal) as journal_form:
journal_form.bank_statements_source = "online"
journal_form.online_bank_statement_provider = "dummy"
journal_form.save()
self.assertTrue(journal.online_bank_statement_provider_id)
save_provider_id = journal.online_bank_statement_provider_id.id
journal.unlink()
self.assertFalse(
self.OnlineBankStatementProvider.search(
[
("id", "=", save_provider_id),
]
)
)
def test_source_change_cleanup(self):
journal = self.AccountJournal.create(
{"name": "Bank", "type": "bank", "code": "BANK"}
)
with common.Form(journal) as journal_form:
journal_form.bank_statements_source = "online"
journal_form.online_bank_statement_provider = "dummy"
journal_form.save()
self.assertTrue(journal.online_bank_statement_provider_id)
save_provider_id = journal.online_bank_statement_provider_id.id
# Stuff should not change when doing unrelated write.
journal.write({"code": "BIGBANK"})
self.assertTrue(journal.online_bank_statement_provider_id)
self.assertEqual(journal.online_bank_statement_provider_id.id, save_provider_id)
with common.Form(journal) as journal_form:
journal_form.bank_statements_source = "undefined"
journal_form.save()
self.assertFalse(journal.online_bank_statement_provider_id)
self.assertFalse(
self.OnlineBankStatementProvider.search(
[
("id", "=", save_provider_id),
]
)
)
def test_pull_mode_daily(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "daily"
provider.with_context(step={"hours": 2})._pull(
self.now - relativedelta(days=1),
self.now,
)
self.assertEqual(
len(self.AccountBankStatement.search([("journal_id", "=", journal.id)])), 2
)
def test_pull_mode_weekly(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "weekly"
provider.with_context(step={"hours": 8})._pull(
self.now - relativedelta(weeks=1),
self.now,
)
self.assertEqual(
len(self.AccountBankStatement.search([("journal_id", "=", journal.id)])), 2
)
def test_pull_mode_monthly(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "monthly"
provider.with_context(step={"hours": 8})._pull(
self.now - relativedelta(months=1),
self.now,
)
self.assertEqual(
len(self.AccountBankStatement.search([("journal_id", "=", journal.id)])), 2
)
def test_pull_scheduled(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.next_run = self.now - relativedelta(days=15)
self.assertFalse(
self.AccountBankStatement.search([("journal_id", "=", journal.id)])
)
provider.with_context(step={"hours": 8})._scheduled_pull()
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
def test_pull_skip_duplicates_by_unique_import_id(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "weekly"
provider.with_context(
step={"hours": 8},
data_since=self.now - relativedelta(weeks=2),
data_until=self.now,
)._pull(
self.now - relativedelta(weeks=2),
self.now,
)
self.assertEqual(
len(
self.AccountBankStatementLine.search([("journal_id", "=", journal.id)])
),
14 * (24 / 8),
)
provider.with_context(
step={"hours": 8},
data_since=self.now - relativedelta(weeks=3),
data_until=self.now - relativedelta(weeks=1),
)._pull(
self.now - relativedelta(weeks=3),
self.now - relativedelta(weeks=1),
)
self.assertEqual(
len(
self.AccountBankStatementLine.search([("journal_id", "=", journal.id)])
),
21 * (24 / 8),
)
provider.with_context(
step={"hours": 8},
data_since=self.now - relativedelta(weeks=1),
data_until=self.now,
)._pull(
self.now - relativedelta(weeks=1),
self.now,
)
self.assertEqual(
len(
self.AccountBankStatementLine.search([("journal_id", "=", journal.id)])
),
21 * (24 / 8),
)
def test_interval_type_minutes(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.interval_type = "minutes"
provider._compute_update_schedule()
def test_interval_type_hours(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.interval_type = "hours"
provider._compute_update_schedule()
def test_interval_type_days(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.interval_type = "days"
provider._compute_update_schedule()
def test_interval_type_weeks(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.interval_type = "weeks"
provider._compute_update_schedule()
def test_pull_no_crash(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "weekly"
provider.with_context(crash=True, scheduled=True)._pull(
self.now - relativedelta(hours=1),
self.now,
)
self.assertFalse(
self.AccountBankStatement.search([("journal_id", "=", journal.id)])
)
def test_pull_crash(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "weekly"
with self.assertRaisesRegex(Exception, "Expected"):
provider.with_context(crash=True)._pull(
self.now - relativedelta(hours=1),
self.now,
)
def test_pull_httperror(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "weekly"
with self.assertRaises(HTTPError):
provider.with_context(
crash=True,
exception=HTTPError(None, 500, "Error", None, None),
)._pull(
self.now - relativedelta(hours=1),
self.now,
)
def test_pull_no_balance(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "daily"
provider.with_context(
step={"hours": 2},
balance_start=0,
amount=100.0,
balance=False,
)._pull(
self.now - relativedelta(days=1),
self.now,
)
statements = self.AccountBankStatement.search(
[("journal_id", "=", journal.id)],
order="date asc",
)
self.assertFalse(statements[0].balance_start)
self.assertTrue(statements[0].balance_end)
self.assertTrue(statements[1].balance_start)
def test_wizard(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
vals = self.OnlineBankStatementPullWizard.with_context(
active_model="account.journal", active_id=journal.id
).default_get(fields_list=["provider_ids"])
vals["date_since"] = self.now - relativedelta(hours=1)
vals["date_until"] = self.now
wizard = self.OnlineBankStatementPullWizard.create(vals)
self.assertTrue(wizard.provider_ids)
wizard.action_pull()
self.assertTrue(
self.AccountBankStatement.search([("journal_id", "=", journal.id)])
)
def test_pull_statement_partially(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "monthly"
provider_context = {
"step": {"hours": 24},
"data_since": datetime(2020, 1, 1),
"amount": 1.0,
"balance_start": 0,
}
provider.with_context(
**provider_context,
data_until=datetime(2020, 1, 31),
)._pull(
datetime(2020, 1, 1),
datetime(2020, 1, 31),
)
statements = self.AccountBankStatement.search(
[("journal_id", "=", journal.id)],
order="date asc",
)
self.assertEqual(len(statements), 1)
self.assertEqual(statements[0].balance_start, 0.0)
self.assertEqual(statements[0].balance_end_real, 30.0)
provider.with_context(
**provider_context,
data_until=datetime(2020, 2, 15),
)._pull(
datetime(2020, 1, 1),
datetime(2020, 2, 29),
)
statements = self.AccountBankStatement.search(
[("journal_id", "=", journal.id)],
order="date asc",
)
self.assertEqual(len(statements), 2)
self.assertEqual(statements[0].balance_start, 0.0)
self.assertEqual(statements[0].balance_end_real, 31.0)
self.assertEqual(statements[1].balance_start, 31.0)
self.assertEqual(statements[1].balance_end_real, 45.0)
provider.with_context(
**provider_context,
data_until=datetime(2020, 2, 29),
)._pull(
datetime(2020, 1, 1),
datetime(2020, 2, 29),
)
statements = self.AccountBankStatement.search(
[("journal_id", "=", journal.id)],
order="date asc",
)
self.assertEqual(len(statements), 2)
self.assertEqual(statements[0].balance_start, 0.0)
self.assertEqual(statements[0].balance_end_real, 31.0)
self.assertEqual(statements[1].balance_start, 31.0)
self.assertEqual(statements[1].balance_end_real, 59.0)
def test_tz_utc(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.tz = "UTC"
provider.with_context(
step={"hours": 1},
data_since=datetime(2020, 4, 17, 22, 0),
data_until=datetime(2020, 4, 18, 2, 0),
tz="UTC",
)._pull(
datetime(2020, 4, 17, 22, 0),
datetime(2020, 4, 18, 2, 0),
)
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 2)
lines = statement.mapped("line_ids").sorted()
self.assertEqual(len(lines), 4)
self.assertEqual(lines[0].date, date(2020, 4, 17))
self.assertEqual(lines[1].date, date(2020, 4, 17))
self.assertEqual(lines[2].date, date(2020, 4, 18))
self.assertEqual(lines[3].date, date(2020, 4, 18))
def test_tz_non_utc(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.tz = "Etc/GMT-2"
provider.with_context(
step={"hours": 1},
data_since=datetime(2020, 4, 17, 22, 0),
data_until=datetime(2020, 4, 18, 2, 0),
tz="UTC",
)._pull(
datetime(2020, 4, 17, 22, 0),
datetime(2020, 4, 18, 2, 0),
)
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 2)
lines = statement.mapped("line_ids").sorted()
self.assertEqual(len(lines), 4)
self.assertEqual(lines[0].date, date(2020, 4, 18))
self.assertEqual(lines[1].date, date(2020, 4, 18))
self.assertEqual(lines[2].date, date(2020, 4, 18))
self.assertEqual(lines[3].date, date(2020, 4, 18))
def test_other_tz_to_utc(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.with_context(
step={"hours": 1},
tz="Etc/GMT-2",
data_since=datetime(2020, 4, 18, 0, 0),
data_until=datetime(2020, 4, 18, 4, 0),
)._pull(
datetime(2020, 4, 17, 22, 0),
datetime(2020, 4, 18, 2, 0),
)
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 2)
lines = statement.mapped("line_ids").sorted()
self.assertEqual(len(lines), 4)
self.assertEqual(lines[0].date, date(2020, 4, 17))
self.assertEqual(lines[1].date, date(2020, 4, 17))
self.assertEqual(lines[2].date, date(2020, 4, 18))
self.assertEqual(lines[3].date, date(2020, 4, 18))
def test_timestamp_date_only_date(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.with_context(step={"hours": 1}, timestamp_mode="date")._pull(
datetime(2020, 4, 18, 0, 0),
datetime(2020, 4, 18, 4, 0),
)
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
lines = statement.line_ids
self.assertEqual(len(lines), 24)
for line in lines:
self.assertEqual(line.date, date(2020, 4, 18))
def test_timestamp_date_only_str(self):
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.with_context(
step={"hours": 1},
data_since=datetime(2020, 4, 18, 0, 0),
data_until=datetime(2020, 4, 18, 4, 0),
timestamp_mode="str",
)._pull(
datetime(2020, 4, 18, 0, 0),
datetime(2020, 4, 18, 4, 0),
)
statement = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statement), 1)
lines = statement.line_ids
self.assertEqual(len(lines), 4)
self.assertEqual(lines[0].date, date(2020, 4, 18))
self.assertEqual(lines[1].date, date(2020, 4, 18))
self.assertEqual(lines[2].date, date(2020, 4, 18))
self.assertEqual(lines[3].date, date(2020, 4, 18))
def _get_statement_line_data(self, statement_date):
return [
{
"payment_ref": "payment",
"amount": 100,
"date": statement_date,
"unique_import_id": str(statement_date),
"partner_name": "John Doe",
"account_number": "XX00 0000 0000 0000",
}
], {}
def test_dont_create_empty_statements(self):
"""Test the default behavior of not creating empty bank
statements ('Allow empty statements' field is uncheck at the
provider level.).
"""
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.statement_creation_mode = "daily"
with mock.patch(mock_obtain_statement_data) as mock_data:
mock_data.side_effect = [
self._get_statement_line_data(date(2021, 8, 10)),
([], {}), # August 8th, doesn't have statement
([], {}), # August 9th, doesn't have statement
self._get_statement_line_data(date(2021, 8, 13)),
]
provider._pull(datetime(2021, 8, 10), datetime(2021, 8, 14))
statements = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
self.assertEqual(len(statements), 2)
self.assertEqual(statements[1].balance_start, 0)
self.assertEqual(statements[1].balance_end_real, 100)
self.assertEqual(len(statements[1].line_ids), 1)
self.assertEqual(statements[0].balance_start, 100)
self.assertEqual(statements[0].balance_end_real, 200)
self.assertEqual(len(statements[0].line_ids), 1)
def test_create_empty_statements(self):
"""Test creating empty bank statements
('Allow empty statements' field is check at the provider level).
"""
journal = self.AccountJournal.create(
{
"name": "Bank",
"type": "bank",
"code": "BANK",
"bank_statements_source": "online",
"online_bank_statement_provider": "dummy",
}
)
provider = journal.online_bank_statement_provider_id
provider.active = True
provider.allow_empty_statements = True
provider.statement_creation_mode = "daily"
with mock.patch(mock_obtain_statement_data) as mock_data:
mock_data.side_effect = [
self._get_statement_line_data(date(2021, 8, 10)),
([], {}), # August 8th, doesn't have statement
([], {}), # August 9th, doesn't have statement
self._get_statement_line_data(date(2021, 8, 13)),
]
provider._pull(datetime(2021, 8, 10), datetime(2021, 8, 14))
statements = self.AccountBankStatement.search([("journal_id", "=", journal.id)])
# 4 Statements: 2 with movements and 2 empty
self.assertEqual(len(statements), 4)
# With movement
self.assertEqual(statements[3].balance_start, 0)
self.assertEqual(statements[3].balance_end_real, 100)
self.assertEqual(len(statements[3].line_ids), 1)
# Empty
self.assertEqual(statements[2].balance_start, 100)
self.assertEqual(statements[2].balance_end_real, 100)
self.assertEqual(len(statements[2].line_ids), 0)
# Empty
self.assertEqual(statements[1].balance_start, 100)
self.assertEqual(statements[1].balance_end_real, 100)
self.assertEqual(len(statements[1].line_ids), 0)
# With movement
self.assertEqual(statements[0].balance_start, 100)
self.assertEqual(statements[0].balance_end_real, 200)
self.assertEqual(len(statements[0].line_ids), 1)
| 35.409387 | 27,159 |
835 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Therp BV (https://therp.nl).
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from unittest.mock import patch
from odoo.tests import common
class TestAccountJournal(common.TransactionCase):
"""Test some functions adde d to account.journal model."""
def setUp(self):
super().setUp()
self.AccountJournal = self.env["account.journal"]
def test_values_online_bank_statement_provider(self):
"""Check method to retrieve provider types."""
# Make sure the users seems to have the group_no_one.
with patch.object(
self.AccountJournal.__class__, "user_has_groups", return_value=True
):
values = self.AccountJournal.values_online_bank_statement_provider()
self.assertIn("dummy", [entry[0] for entry in values])
| 37.954545 | 835 |
14,664 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2019-2020 Dataplug (https://dataplug.io)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import logging
from datetime import datetime
from decimal import Decimal
from html import escape
from dateutil.relativedelta import MO, relativedelta
from pytz import timezone, utc
from odoo import _, api, fields, models
from odoo.addons.base.models.res_partner import _tz_get
_logger = logging.getLogger(__name__)
class OnlineBankStatementProvider(models.Model):
_name = "online.bank.statement.provider"
_inherit = ["mail.thread"]
_description = "Online Bank Statement Provider"
company_id = fields.Many2one(related="journal_id.company_id", store=True)
active = fields.Boolean(default=True)
name = fields.Char(compute="_compute_name", store=True)
journal_id = fields.Many2one(
comodel_name="account.journal",
required=True,
readonly=True,
ondelete="cascade",
domain=[("type", "=", "bank")],
)
currency_id = fields.Many2one(related="journal_id.currency_id")
account_number = fields.Char(
related="journal_id.bank_account_id.sanitized_acc_number"
)
tz = fields.Selection(
selection=_tz_get,
string="Timezone",
default=lambda self: self.env.context.get("tz"),
help=(
"Timezone to convert transaction timestamps to prior being"
" saved into a statement."
),
)
service = fields.Selection(
selection=lambda self: self._selection_service(),
required=True,
readonly=True,
)
interval_type = fields.Selection(
selection=[
("minutes", "Minute(s)"),
("hours", "Hour(s)"),
("days", "Day(s)"),
("weeks", "Week(s)"),
],
default="hours",
required=True,
)
interval_number = fields.Integer(
string="Scheduled update interval",
default=1,
required=True,
)
update_schedule = fields.Char(
compute="_compute_update_schedule",
)
last_successful_run = fields.Datetime(string="Last successful pull")
next_run = fields.Datetime(
string="Next scheduled pull",
default=fields.Datetime.now,
required=True,
)
statement_creation_mode = fields.Selection(
selection=[
("daily", "Daily statements"),
("weekly", "Weekly statements"),
("monthly", "Monthly statements"),
],
default="daily",
required=True,
)
api_base = fields.Char()
origin = fields.Char()
username = fields.Char()
password = fields.Char()
key = fields.Binary()
certificate = fields.Binary()
passphrase = fields.Char()
certificate_public_key = fields.Text()
certificate_private_key = fields.Text()
certificate_chain = fields.Text()
allow_empty_statements = fields.Boolean()
_sql_constraints = [
(
"journal_id_uniq",
"UNIQUE(journal_id)",
"Only one online banking statement provider per journal!",
),
(
"valid_interval_number",
"CHECK(interval_number > 0)",
"Scheduled update interval must be greater than zero!",
),
]
@api.model
def _get_available_services(self):
"""Hook for extension"""
return []
@api.model
def _selection_service(self):
return self._get_available_services() + [("dummy", "Dummy")]
@api.model
def values_service(self):
return self._get_available_services()
@api.depends("service", "journal_id.name")
def _compute_name(self):
"""We can have multiple providers/journals for the same service."""
for provider in self:
provider.name = " ".join([provider.journal_id.name, provider.service])
@api.depends("active", "interval_type", "interval_number")
def _compute_update_schedule(self):
for provider in self:
if not provider.active:
provider.update_schedule = _("Inactive")
continue
provider.update_schedule = _("%(number)s %(type)s") % {
"number": provider.interval_number,
"type": list(
filter(
lambda x: x[0] == provider.interval_type,
self._fields["interval_type"].selection,
)
)[0][1],
}
def _pull(self, date_since, date_until):
is_scheduled = self.env.context.get("scheduled")
for provider in self:
statement_date_since = provider._get_statement_date_since(date_since)
while statement_date_since < date_until:
statement_date_until = (
statement_date_since + provider._get_statement_date_step()
)
try:
data = provider._obtain_statement_data(
statement_date_since, statement_date_until
)
except BaseException as e:
if is_scheduled:
_logger.warning(
'Online Bank Statement Provider "%s" failed to'
" obtain statement data since %s until %s"
% (
provider.name,
statement_date_since,
statement_date_until,
),
exc_info=True,
)
provider.message_post(
body=_(
"Failed to obtain statement data for period "
"since {since} until {until}: {exception}. See server logs for "
"more details."
).format(
since=statement_date_since,
until=statement_date_until,
exception=escape(str(e)) or _("N/A"),
),
subject=_("Issue with Online Bank Statement Provider"),
)
break
raise
provider._create_or_update_statement(
data, statement_date_since, statement_date_until
)
statement_date_since = statement_date_until
if is_scheduled:
provider._schedule_next_run()
def _create_or_update_statement(
self, data, statement_date_since, statement_date_until
):
"""Create or update bank statement with the data retrieved from provider."""
self.ensure_one()
AccountBankStatement = self.env["account.bank.statement"]
is_scheduled = self.env.context.get("scheduled")
if is_scheduled:
AccountBankStatement = AccountBankStatement.with_context(
tracking_disable=True,
)
if not data:
data = ([], {})
if not data[0] and not data[1] and not self.allow_empty_statements:
return
lines_data, statement_values = data
if not lines_data:
lines_data = []
if not statement_values:
statement_values = {}
statement_date = self._get_statement_date(
statement_date_since,
statement_date_until,
)
statement = AccountBankStatement.search(
[
("journal_id", "=", self.journal_id.id),
("state", "=", "open"),
("date", "=", statement_date),
],
limit=1,
)
if not statement:
statement_values.update(
{
"name": "%s/%s"
% (self.journal_id.code, statement_date.strftime("%Y-%m-%d")),
"journal_id": self.journal_id.id,
"date": statement_date,
}
)
statement = AccountBankStatement.with_context(
journal_id=self.journal_id.id,
).create(
# NOTE: This is needed since create() alters values
statement_values.copy()
)
filtered_lines = self._get_statement_filtered_lines(
lines_data, statement_values, statement_date_since, statement_date_until
)
statement_values.update(
{"line_ids": [[0, False, line] for line in filtered_lines]}
)
if "balance_start" in statement_values:
statement_values["balance_start"] = float(statement_values["balance_start"])
if "balance_end_real" in statement_values:
statement_values["balance_end_real"] = float(
statement_values["balance_end_real"]
)
statement.write(statement_values)
def _get_statement_filtered_lines(
self, lines_data, statement_values, statement_date_since, statement_date_until
):
"""Get lines from line data, but only for the right date."""
AccountBankStatementLine = self.env["account.bank.statement.line"]
provider_tz = timezone(self.tz) if self.tz else utc
journal = self.journal_id
speeddict = journal._statement_line_import_speeddict()
filtered_lines = []
for line_values in lines_data:
date = line_values["date"]
if not isinstance(date, datetime):
date = fields.Datetime.from_string(date)
if date.tzinfo is None:
date = date.replace(tzinfo=utc)
date = date.astimezone(utc).replace(tzinfo=None)
if date < statement_date_since:
if "balance_start" in statement_values:
statement_values["balance_start"] = Decimal(
statement_values["balance_start"]
) + Decimal(line_values["amount"])
continue
elif date >= statement_date_until:
if "balance_end_real" in statement_values:
statement_values["balance_end_real"] = Decimal(
statement_values["balance_end_real"]
) - Decimal(line_values["amount"])
continue
date = date.replace(tzinfo=utc)
date = date.astimezone(provider_tz).replace(tzinfo=None)
line_values["date"] = date
journal._statement_line_import_update_unique_import_id(
line_values, self.account_number
)
unique_import_id = line_values.get("unique_import_id")
if unique_import_id:
if AccountBankStatementLine.sudo().search(
[("unique_import_id", "=", unique_import_id)], limit=1
):
continue
if not line_values.get("payment_ref"):
line_values["payment_ref"] = line_values.get("ref")
journal._statement_line_import_update_hook(line_values, speeddict)
filtered_lines.append(line_values)
return filtered_lines
def _schedule_next_run(self):
self.ensure_one()
self.last_successful_run = self.next_run
self.next_run += self._get_next_run_period()
def _get_statement_date_since(self, date):
self.ensure_one()
date = date.replace(hour=0, minute=0, second=0, microsecond=0)
if self.statement_creation_mode == "daily":
return date
elif self.statement_creation_mode == "weekly":
return date + relativedelta(weekday=MO(-1))
elif self.statement_creation_mode == "monthly":
return date.replace(day=1)
def _get_statement_date_step(self):
self.ensure_one()
if self.statement_creation_mode == "daily":
return relativedelta(days=1, hour=0, minute=0, second=0, microsecond=0)
elif self.statement_creation_mode == "weekly":
return relativedelta(
weeks=1,
weekday=MO,
hour=0,
minute=0,
second=0,
microsecond=0,
)
elif self.statement_creation_mode == "monthly":
return relativedelta(
months=1,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0,
)
def _get_statement_date(self, date_since, date_until):
self.ensure_one()
# NOTE: Statement date is treated by Odoo as start of period. Details
# - addons/account/models/account_journal_dashboard.py
# - def get_line_graph_datas()
tz = timezone(self.tz) if self.tz else utc
date_since = date_since.replace(tzinfo=utc).astimezone(tz)
return date_since.date()
def _get_next_run_period(self):
self.ensure_one()
if self.interval_type == "minutes":
return relativedelta(minutes=self.interval_number)
elif self.interval_type == "hours":
return relativedelta(hours=self.interval_number)
elif self.interval_type == "days":
return relativedelta(days=self.interval_number)
elif self.interval_type == "weeks":
return relativedelta(weeks=self.interval_number)
@api.model
def _scheduled_pull(self):
_logger.info("Scheduled pull of online bank statements...")
providers = self.search(
[("active", "=", True), ("next_run", "<=", fields.Datetime.now())]
)
if providers:
_logger.info(
"Pulling online bank statements of: %s"
% ", ".join(providers.mapped("journal_id.name"))
)
for provider in providers.with_context(**{"scheduled": True}):
date_since = (
(provider.last_successful_run)
if provider.last_successful_run
else (provider.next_run - provider._get_next_run_period())
)
date_until = provider.next_run
provider._pull(date_since, date_until)
_logger.info("Scheduled pull of online bank statements complete.")
def _obtain_statement_data(self, date_since, date_until):
"""Hook for extension"""
# Check tests/online_bank_statement_provider_dummy.py for reference
self.ensure_one()
return []
| 38.1875 | 14,664 |
3,277 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2019-2020 Dataplug (https://dataplug.io)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import logging
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class AccountJournal(models.Model):
_inherit = "account.journal"
online_bank_statement_provider = fields.Selection(
selection=lambda self: self.env[
"account.journal"
]._selection_online_bank_statement_provider(),
help="Select the type of service provider (a model)",
)
online_bank_statement_provider_id = fields.Many2one(
string="Statement Provider",
comodel_name="online.bank.statement.provider",
ondelete="restrict",
copy=False,
help="Select the actual instance of a configured provider (a record).\n"
"Selecting a type of provider will automatically create a provider"
" record linked to this journal.",
)
def __get_bank_statements_available_sources(self):
result = super().__get_bank_statements_available_sources()
result.append(("online", _("Online (OCA)")))
return result
@api.model
def _selection_online_bank_statement_provider(self):
return self.env["online.bank.statement.provider"]._get_available_services() + [
("dummy", "Dummy")
]
@api.model
def values_online_bank_statement_provider(self):
"""Return values for provider type selection in the form view."""
res = self.env["online.bank.statement.provider"]._get_available_services()
if self.user_has_groups("base.group_no_one"):
res += [("dummy", "Dummy")]
return res
def _update_online_bank_statement_provider_id(self):
"""Keep provider synchronized with journal."""
OnlineBankStatementProvider = self.env["online.bank.statement.provider"]
for journal in self.filtered("id"):
provider_id = journal.online_bank_statement_provider_id
if journal.bank_statements_source != "online":
journal.online_bank_statement_provider_id = False
if provider_id:
provider_id.unlink()
continue
if provider_id.service == journal.online_bank_statement_provider:
continue
journal.online_bank_statement_provider_id = False
if provider_id:
provider_id.unlink()
# fmt: off
journal.online_bank_statement_provider_id = \
OnlineBankStatementProvider.create({
"journal_id": journal.id,
"service": journal.online_bank_statement_provider,
})
# fmt: on
@api.model
def create(self, vals):
rec = super().create(vals)
if "bank_statements_source" in vals or "online_bank_statement_provider" in vals:
rec._update_online_bank_statement_provider_id()
return rec
def write(self, vals):
res = super().write(vals)
if "bank_statements_source" in vals or "online_bank_statement_provider" in vals:
self._update_online_bank_statement_provider_id()
return res
| 39.011905 | 3,277 |
2,388 |
py
|
PYTHON
|
15.0
|
# Copyright 2019-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2019-2020 Dataplug (https://dataplug.io)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class OnlineBankStatementPullWizard(models.TransientModel):
_name = "online.bank.statement.pull.wizard"
_description = "Online Bank Statement Pull Wizard"
date_since = fields.Datetime(
string="From",
required=True,
default=fields.Datetime.now,
)
date_until = fields.Datetime(
string="To",
required=True,
default=fields.Datetime.now,
)
# The link to providers is Many2many, because you can select multiple
# journals for the action to pull statements.
provider_ids = fields.Many2many(
string="Providers",
comodel_name="online.bank.statement.provider",
column1="wizard_id",
column2="provider_id",
relation="online_bank_statement_provider_pull_wizard_rel",
)
@api.model
def default_get(self, fields_list):
"""Retrieve providers from the journals for which this wizard is launched."""
res = super().default_get(fields_list)
journal_ids = []
if self.env.context.get("active_model") == "account.journal":
if self.env.context.get("active_ids"):
journal_ids = self.env.context["active_ids"]
elif self.env.context.get("active_id"):
journal_ids = [self.env.context["active_id"]]
if journal_ids:
journals = self.env["account.journal"].browse(journal_ids)
res["provider_ids"] = [journals.online_bank_statement_provider_id.id]
return res
def action_pull(self):
"""Pull statements from providers and then show list of statements."""
self.ensure_one()
self.with_context(active_test=False).provider_ids._pull(
self.date_since, self.date_until
)
action = self.env.ref("account.action_bank_statement_tree").sudo().read([])[0]
if len(self.provider_ids) == 1:
action["context"] = {
"search_default_journal_id": self.provider_ids[0].journal_id.id
}
else:
action["domain"] = [
("journal_id", "in", [o.journal_id.id for o in self.provider_ids])
]
return action
| 38.516129 | 2,388 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.