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
|
|---|---|---|---|---|---|---|
1,227 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
mapping_function_record_data = {
(
"_get_and_send_voxel_report",
env.ref("edi_voxel_oca.channel_voxel_export").id,
): "job_function_get_and_send_voxel_report",
(
"_update_error_status",
env.ref("edi_voxel_oca.channel_voxel_status").id,
): "job_function_update_error_status",
}
vals_list = []
domain = [("model_id", "=", env.ref("account.model_account_move").id)]
function = env["queue.job.function"].search(domain)
for record in function:
key = (record.method, record.channel_id.id)
if key in mapping_function_record_data:
vals_list.append(
{
"noupdate": True,
"name": mapping_function_record_data[key],
"module": "edi_voxel_account_invoice_oca",
"model": "queue.job.function",
"res_id": record.id,
}
)
env["ir.model.data"].create(vals_list)
| 36.088235 | 1,227 |
9,614 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from datetime import date, datetime
from odoo.tests import TransactionCase
class TestVoxelAccountInvoice(TransactionCase):
@classmethod
def setUpClass(cls):
super(TestVoxelAccountInvoice, cls).setUpClass()
# Invoice line account
# Invoice company
cls.main_company = cls.env.ref("base.main_company")
cls.main_company.write(
{
"vat": "US1234567890",
"street": "Street 1",
"street2": "Street 2",
"name": "YourCompany",
"city": "City",
"zip": "99999",
"state_id": cls.env.ref("base.state_es_m").id,
"country_id": cls.env.ref("base.es").id,
"email": "[email protected]",
}
)
# Set to false to avoid compare distinct data than expected
cls.env["ir.config_parameter"].sudo().set_param(
"account.use_invoice_terms", False
)
# Invoice client
partner = cls.env["res.partner"].create(
{
"ref": "C01",
"vat": "BE0123456789",
"name": "Client (test)",
"email": "[email protected]",
"street": "Street 1",
"street2": "Street 2",
"city": "City (test)",
"zip": "10000",
"state_id": cls.env.ref("base.state_us_49").id,
"country_id": cls.env.ref("base.us").id,
}
)
# Invoice products
product_obj = cls.env["product.product"]
product_1 = product_obj.create(
{"default_code": "DC_001", "name": "Product 1 (test)"}
)
cls.env["product.customerinfo"].create(
{
"name": partner.id,
"product_tmpl_id": product_1.product_tmpl_id.id,
"product_id": product_1.id,
"product_code": "1234567891234",
}
)
product_2 = product_obj.create(
{"default_code": "DC_002", "name": "Product 2 (test)"}
)
product_3 = product_obj.create(
{"default_code": "DC_003", "name": "Product 3 (test)"}
)
tax_15 = cls.env["account.tax"].create(
{
"name": "Tax 15%",
"type_tax_use": "sale",
"amount_type": "percent",
"amount": 15,
"tax_group_id": cls.env.ref("account.tax_group_taxes").id,
}
)
tax_30 = cls.env["account.tax"].create(
{
"name": "Tax 30.00%",
"type_tax_use": "sale",
"amount_type": "percent",
"amount": 30,
"tax_group_id": cls.env.ref("account.tax_group_taxes").id,
}
)
# Invoice
cls.invoice = cls.env["account.move"].create(
{
"partner_id": partner.id,
"move_type": "out_invoice",
"currency_id": cls.main_company.currency_id.id,
"invoice_date": date(2019, 4, 13),
"company_id": cls.main_company.id,
"invoice_line_ids": [
(
0,
0,
{
"product_id": product_1.id,
"quantity": 2,
"price_unit": 750,
"name": "Product 1",
"product_uom_id": cls.env.ref("uom.product_uom_unit").id,
},
),
(
0,
0,
{
"product_id": product_2.id,
"quantity": 3,
"price_unit": 147,
"discount": 20,
"tax_ids": [(6, 0, (tax_15 | tax_30).ids)],
"name": "Product 2",
"product_uom_id": product_2.uom_id.id,
},
),
(
0,
0,
{
"product_id": product_3.id,
"quantity": 0,
"price_unit": 0,
"name": "Product 3",
"product_uom_id": product_3.uom_id.id,
},
),
],
}
)
def test_get_voxel_filename(self):
bef = datetime.now()
bef = datetime(
bef.year,
bef.month,
bef.day,
bef.hour,
bef.minute,
bef.second,
(bef.microsecond // 1000) * 1000,
)
filename = self.invoice._get_voxel_filename()
document_type, date_time = filename[:-4].split("_", 1)
date_time = datetime.strptime(date_time, "%Y%m%d_%H%M%S_%f")
self.assertEqual(document_type, "Factura")
self.assertGreaterEqual(date_time, bef)
def test_get_report_values(self):
# Get report data
model_name = "report.edi_voxel_account_invoice_oca.template_voxel_invoice"
report_edi_obj = self.env[model_name]
report_data = report_edi_obj._get_report_values(self.invoice.ids)
# Get expected data
expected_report_data = self._get_invoice_data()
# Check data
self.assertDictEqual(report_data, expected_report_data)
def _get_invoice_data(self):
return {
"general": self._get_general_data(),
"supplier": self._get_suplier_data(),
"client": self._get_client_data(),
"customers": self._get_customers_data(),
"comments": self._get_comments_data(),
"references": self._get_references_data(),
"products": self._get_products_data(),
"taxes": self._get_taxes_data(),
"tota_summary": self._get_total_summary_data(),
}
# report data. Auxiliary methods
# ------------------------------
def _get_general_data(self):
return {
"Type": "FacturaComercial",
"Ref": "INV/2019/00001",
"Date": "2019-04-13",
# Set currency code from company for resilient tests
"Currency": self.main_company.currency_id.name,
}
def _get_suplier_data(self):
return {
"CIF": "US1234567890",
"Company": "YourCompany",
"Address": "Street 1, Street 2",
"City": "City",
"PC": "99999",
"Province": "Madrid",
"Country": "ESP",
"Email": "[email protected]",
}
def _get_client_data(self):
return {
"SupplierClientID": "C01",
"CIF": "BE0123456789",
"Company": "Client (test)",
"Address": "Street 1, Street 2",
"City": "City (test)",
"PC": "10000",
"Province": "West Virginia",
"Country": "USA",
"Email": "[email protected]",
}
def _get_customers_data(self):
return []
def _get_comments_data(self):
return []
def _get_references_data(self):
return []
def _get_products_data(self):
return [
{
"product": {
"SupplierSKU": "DC_001",
"CustomerSKU": "1234567891234",
"Item": "Product 1 (test)",
"Qty": "2.0",
"MU": "Unidades",
"UP": "750.0",
"Total": "1500.0",
},
"taxes": [],
"discounts": [],
},
{
"product": {
"SupplierSKU": "DC_002",
"CustomerSKU": False,
"Item": "Product 2 (test)",
"Qty": "3.0",
"MU": "Unidades",
"UP": "147.0",
"Total": "352.8",
},
"taxes": [
{"Rate": "15.0", "Type": False},
{"Rate": "30.0", "Type": False},
],
"discounts": [
{
"Amount": "-29.4",
"Qualifier": "Descuento",
"Rate": "20.0",
"Type": "Comercial",
}
],
},
{
"product": {
"SupplierSKU": "DC_003",
"CustomerSKU": False,
"Item": "Product 3 (test)",
"Qty": "0.0",
"MU": "Unidades",
"UP": "0.0",
"Total": "0.0",
},
"taxes": [],
"discounts": [],
},
]
def _get_taxes_data(self):
return [
{"Amount": "52.92", "Rate": "15.0", "Type": False},
{"Amount": "105.84", "Rate": "30.0", "Type": False},
]
def _get_total_summary_data(self):
return {
"Tax": "158.76",
"SubTotal": "1852.8",
"Total": "2011.56",
}
| 33.971731 | 9,614 |
2,252 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class AccountMove(models.Model):
_name = "account.move"
_inherit = ["account.move", "voxel.mixin"]
voxel_enabled = fields.Boolean(
compute="_compute_voxel_enabled",
search="_search_voxel_enabled",
)
voxel_job_ids = fields.Many2many(
comodel_name="queue.job",
relation="account_invoice_voxel_job_rel",
column1="invoice_id",
column2="voxel_job_id",
string="Jobs",
copy=False,
)
def get_voxel_login(self, company=None):
"""This method overwrites the one defined in voxel.mixin to provide
the login for this specific model (account.invoice)
"""
return (company or self.company_id).voxel_invoice_login_id
def _compute_voxel_enabled(self):
for record in self:
record.voxel_enabled = (
record.company_id.voxel_enabled and record.partner_id.voxel_enabled
)
def _search_voxel_enabled(self, operator, value):
if (operator == "=" and value) or (operator == "!=" and not value):
domain = [
("company_id.voxel_enabled", "=", True),
("partner_id.voxel_enabled", "=", True),
]
else:
domain = [
"|",
("company_id.voxel_enabled", "=", False),
("partner_id.voxel_enabled", "=", False),
]
return [("id", "in", self.search(domain).ids)]
def post(self):
res = super().post()
self.action_send_to_voxel()
return res
def button_draft(self):
res = super().button_draft()
self._cancel_voxel_jobs()
return res
def action_send_to_voxel(self):
invoices = self.filtered(
lambda inv: inv.is_sale_document() and inv.voxel_enabled
)
if invoices:
invoices.enqueue_voxel_report(
"edi_voxel_account_invoice_oca.report_voxel_invoice"
)
def get_document_type(self):
"""Document type name to be used in the name of the Voxel report"""
return "Factura"
| 31.71831 | 2,252 |
313 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class Company(models.Model):
_inherit = "res.company"
voxel_invoice_login_id = fields.Many2one(
string="Invoice login", comodel_name="voxel.login"
)
| 26.083333 | 313 |
349 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
voxel_invoice_login_id = fields.Many2one(
related="company_id.voxel_invoice_login_id", readonly=False
)
| 29.083333 | 349 |
7,062 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from datetime import date, datetime
from operator import itemgetter
from odoo import api, fields, models
class ReportVoxelInvoice(models.AbstractModel):
_name = "report.edi_voxel_account_invoice_oca.template_voxel_invoice"
_inherit = "report.report_xml.abstract"
_description = "Edi Voxel Account Invoice Report"
@api.model
def _get_report_values(self, docids, data=None):
docs = self.env["account.move"].browse(docids)[:1]
data = {
"general": self._get_general_data(docs),
"supplier": self._get_suplier_data(docs),
"client": self._get_client_data(docs),
"customers": self._get_customers_data(docs),
"comments": self._get_comments_data(docs),
"references": self._get_references_data(docs),
"products": self._get_products_data(docs),
"taxes": self._get_taxes_data(docs),
"tota_summary": self._get_total_summary_data(docs),
}
return data
# report data. Auxiliary methods
def _get_general_data(self, invoice):
type_mapping = {"out_invoice": "FacturaComercial", "out_refund": "FacturaAbono"}
return {
"Type": type_mapping.get(invoice.move_type),
"Ref": invoice.name,
"Date": invoice.invoice_date
and datetime.strftime(invoice.invoice_date, "%Y-%m-%d"),
"Currency": invoice.currency_id.name,
}
def _get_suplier_data(self, invoice):
supplier = invoice.company_id.partner_id
return {
"CIF": supplier._get_voxel_vat(),
"Company": supplier.name,
"Address": ", ".join(filter(None, [supplier.street, supplier.street2])),
"City": supplier.city,
"PC": supplier.zip,
"Province": supplier.state_id.name,
"Country": supplier.country_id.code_alpha3,
"Email": supplier.email,
}
def _get_client_data(self, invoice):
client = invoice.partner_id
return {
"SupplierClientID": client.ref,
"CIF": client._get_voxel_vat(),
"Company": client.commercial_partner_id.name,
"Address": ", ".join(filter(None, [client.street, client.street2])),
"City": client.city,
"PC": client.zip,
"Province": client.state_id.name,
"Country": client.country_id.code_alpha3,
"Email": client.email,
}
def _get_customers_data(self, invoice):
return [
{
"SupplierClientID": invoice.partner_id.ref,
"SupplierCustomerID": customer.ref,
"Customer": customer.name,
"Address": ", ".join(filter(None, [customer.street, customer.street2])),
"City": customer.city,
"PC": customer.zip,
"Province": customer.state_id.name,
"Country": customer.country_id.code_alpha3,
"Email": customer.email,
}
for customer in (
invoice.mapped("picking_ids.partner_id") or invoice.partner_shipping_id
)
]
def _get_comments_data(self, invoice):
return invoice.narration and [{"Msg": invoice.narration}] or []
def _get_references_data(self, invoice):
references = []
if invoice.picking_ids:
for picking in invoice.picking_ids:
picking_date = fields.Datetime.from_string(picking.date)
references.append(
{
"DNRef": picking.name,
"PORef": (
picking.sale_id.client_order_ref or picking.sale_id.name
),
"DNRefDate": picking_date
and datetime.strftime(picking_date, "%Y-%m-%d"),
}
)
else:
orders = invoice.invoice_line_ids.mapped("sale_line_ids.order_id")
for order in orders:
references.append(
{
"DNRef": invoice.name,
"PORef": order.client_order_ref or order.name,
"DNRefDate": invoice.invoice_date
and date.strftime(invoice.invoice_date, "%Y-%m-%d"),
}
)
return references
def _get_products_data(self, invoice):
return [
{
"product": self._get_product_data(line),
"taxes": self._get_product_taxes_data(line),
"discounts": self._get_product_discounts_data(line),
}
for line in invoice.invoice_line_ids
]
def _get_product_data(self, line):
customer_sku = line.move_id._get_customer_product_sku(
line.product_id, line.mapped("move_line_ids.picking_id.partner_id")[:1]
)
if not customer_sku:
customer_sku = line.move_id._get_customer_product_sku(
line.product_id, line.move_id.partner_id
)
return {
"SupplierSKU": line.product_id.default_code,
"CustomerSKU": customer_sku,
"Item": line.product_id.name,
"Qty": str(line.quantity),
"MU": line.product_uom_id.voxel_code,
"UP": str(line.price_unit),
"Total": str(round(line.price_subtotal, 2)),
}
def _get_product_discounts_data(self, line):
taxes = []
if line.discount:
amount = round(line.price_subtotal / line.quantity - line.price_unit, 2)
taxes.append(
{
"Qualifier": line.discount > 0.0 and "Descuento" or "Cargo",
"Type": line.discount > 0.0 and "Comercial" or "Otro",
"Rate": str(line.discount),
"Amount": str(amount),
}
)
return taxes
def _get_product_taxes_data(self, line):
taxes = []
for tax in line.tax_ids:
rate = tax.amount_type != "group" and str(tax.amount) or False
taxes.append({"Type": tax.voxel_tax_code, "Rate": rate})
return taxes
def _get_taxes_data(self, invoice):
taxes = []
for move_line in invoice.line_ids.filtered("tax_line_id"):
taxes.append(
{
"Type": move_line.tax_line_id.voxel_tax_code,
"Rate": str(move_line.tax_line_id.amount),
"Amount": str(abs(move_line.balance)),
}
)
return sorted(taxes, key=itemgetter("Type", "Rate", "Amount"))
def _get_total_summary_data(self, invoice):
return {
"SubTotal": str(invoice.amount_untaxed),
"Tax": str(invoice.amount_tax),
"Total": str(invoice.amount_total),
}
| 38.380435 | 7,062 |
663 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2021 Akretion France (http://www.akretion.com)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Account e-invoice Generate",
"version": "15.0.1.0.0",
"category": "Accounting & Finance",
"license": "AGPL-3",
"summary": "Technical module to generate PDF invoices with " "embedded XML file",
"author": "Akretion,Onestein,Odoo Community Association (OCA)",
"maintainers": ["alexis-via"],
"website": "https://github.com/OCA/edi",
"depends": ["account"],
"data": ["views/res_config_settings.xml"],
"installable": True,
}
| 39 | 663 |
642 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Onestein (<https://www.onestein.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests.common import TransactionCase
class TestEInvoiceGenerate(TransactionCase):
def test_config(self):
"""Test configuration of Electronic Invoices."""
conf = self.env["res.config.settings"].create(
{"xml_format_in_pdf_invoice": "none"}
)
conf.execute()
self.assertTrue(self.env.company.xml_format_in_pdf_invoice)
conf.xml_format_in_pdf_invoice = False
conf.execute()
self.assertFalse(self.env.company.xml_format_in_pdf_invoice)
| 37.764706 | 642 |
1,294 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2020 Akretion France
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, models
class AccountMove(models.Model):
_inherit = "account.move"
def get_payment_identifier(self):
"""This method is designed to be inherited in localization modules"""
self.ensure_one()
return None
@api.model
def _get_invoice_report_names(self):
return ["account.report_invoice", "account.report_invoice_with_payments"]
def _xml_format_in_pdf_invoice(self):
"""Returns the format if it is possible to generate the XML
Otherwize return False"""
self.ensure_one()
xml_format = self.company_id.xml_format_in_pdf_invoice
# I want to allow embedded XML even on draft invoice
# So I write here the conditions to be able to generate a valid XML
if (
xml_format
and xml_format != "none"
and self.move_type in ("out_invoice", "out_refund")
and self.partner_id
and self.state != "cancel"
and self.invoice_line_ids.filtered(lambda x: not x.display_type)
):
return xml_format
else:
return False
| 34.972973 | 1,294 |
406 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2021 Akretion (http://www.akretion.com)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResCompany(models.Model):
_inherit = "res.company"
xml_format_in_pdf_invoice = fields.Selection(
[("none", "None")], string="XML Format embedded in PDF invoice"
)
| 31.230769 | 406 |
429 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2021 Akretion (http://www.akretion.com)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
xml_format_in_pdf_invoice = fields.Selection(
related="company_id.xml_format_in_pdf_invoice", readonly=False
)
| 33 | 429 |
667 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Edi Account",
"summary": """
Define EDI Configuration for Account Moves""",
"version": "15.0.1.0.1",
"license": "LGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"maintainers": ["etobella"],
"development_status": "Beta",
"website": "https://github.com/OCA/edi",
"depends": ["account", "edi_oca", "component_event"],
"data": [
"views/account_journal.xml",
"views/res_partner.xml",
"views/account_move.xml",
"views/edi_exchange_record.xml",
],
"demo": [],
}
| 30.318182 | 667 |
3,845 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from odoo import fields
from odoo.tests.common import tagged
from odoo.addons.account.tests.common import AccountTestInvoicingCommon
from odoo.addons.component.core import Component
from odoo.addons.component.tests.common import TransactionComponentRegistryCase
_logger = logging.getLogger(__name__)
@tagged("-at_install", "post_install")
class EDIBackendTestCase(AccountTestInvoicingCommon, TransactionComponentRegistryCase):
@classmethod
def setUpClass(cls, chart_template_ref=None):
super().setUpClass(chart_template_ref=chart_template_ref)
cls._setup_registry(cls)
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
class AccountMoveEventListenerDemo(Component):
_name = "account.move.event.listener.demo"
_inherit = "base.event.listener"
def on_post_account_move(self, move):
move.name = "new_name"
def on_paid_account_move(self, move):
move.name = "paid"
def on_cancel_account_move(self, move):
move.name = "cancelled"
AccountMoveEventListenerDemo._build_component(cls.comp_registry)
cls.comp_registry._cache.clear()
cls.test_move = (
cls.env["account.move"]
.with_context(components_registry=cls.comp_registry)
.create(
{
"move_type": "out_invoice",
"partner_id": cls.partner_a.id,
"date": fields.Date.from_string("2016-01-01"),
"invoice_line_ids": [
(
0,
None,
{
"name": "revenue line 1",
"account_id": cls.company_data[
"default_account_revenue"
].id,
"quantity": 1.0,
"price_unit": 100.0,
},
),
(
0,
None,
{
"name": "revenue line 2",
"account_id": cls.company_data[
"default_account_revenue"
].id,
"quantity": 1.0,
"price_unit": 100.0,
"tax_ids": [
(6, 0, cls.company_data["default_tax_sale"].ids)
],
},
),
],
}
)
)
cls.test_move.refresh()
def test_paid_move(self):
self.test_move.action_post()
self.assertEqual(self.test_move.name, "new_name")
payment_action = self.test_move.action_register_payment()
payment = (
self.env[payment_action["res_model"]]
.with_context(**payment_action["context"])
.create(
{
"journal_id": self.company_data["default_journal_bank"].id,
}
)
)
payment.with_context(
components_registry=self.comp_registry
).action_create_payments()
self.assertEqual(self.test_move.name, "paid")
def test_cancel_move(self):
self.test_move.action_post()
self.assertEqual(self.test_move.name, "new_name")
self.test_move.button_cancel()
self.assertEqual(self.test_move.name, "cancelled")
| 36.971154 | 3,845 |
1,205 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class AccountMove(models.Model):
_name = "account.move"
_inherit = ["account.move", "edi.exchange.consumer.mixin"]
disable_edi_auto = fields.Boolean(
help="When marked, EDI could be avoided",
readonly=True,
states={"draft": [("readonly", False)]},
)
def _post(self, soft=True):
result = super()._post(soft=soft)
# We will use this event to know which documents needs to be executed
if self:
self._event("on_post_account_move").notify(self)
return result
def button_cancel(self):
"""This could be used to notify our provider that we are not accepting the
invoice"""
result = super().button_cancel()
if self:
self._event("on_cancel_account_move").notify(self)
return result
def action_invoice_paid(self):
"""This could be used to notify our provider that we are paying"""
result = super().action_invoice_paid()
if self:
self._event("on_paid_account_move").notify(self)
return result
| 32.567568 | 1,205 |
1,550 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# Copyright 2021 Camptocamp
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "EDI",
"summary": """
Define backends, exchange types, exchange records,
basic automation and views for handling EDI exchanges.
""",
"version": "15.0.1.5.0",
"website": "https://github.com/OCA/edi",
"development_status": "Beta",
"license": "LGPL-3",
"author": "ACSONE,Creu Blanca,Camptocamp,Odoo Community Association (OCA)",
"maintainers": ["simahawk", "etobella"],
"depends": [
"base_edi",
"component_event",
"mail",
"base_sparse_field",
"queue_job",
],
"external_dependencies": {"python": ["PyYAML"]},
"data": [
"wizards/edi_exchange_record_create_wiz.xml",
"data/cron.xml",
"data/sequence.xml",
"data/job_channel.xml",
"data/job_function.xml",
"security/res_groups.xml",
"security/ir_model_access.xml",
"views/edi_backend_views.xml",
"views/edi_backend_type_views.xml",
"views/edi_exchange_record_views.xml",
"views/edi_exchange_type_views.xml",
"views/menuitems.xml",
"templates/exchange_chatter_msg.xml",
"templates/exchange_mixin_buttons.xml",
],
"assets": {
"web.assets_backend": ["edi_oca/static/src/js/widget_edi.js"],
"web.assets_qweb": ["edi_oca/static/src/xml/widget_edi.xml"],
},
"demo": ["demo/edi_backend_demo.xml"],
}
| 32.978723 | 1,550 |
356 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.http_routing.models.ir_http import slugify
def normalize_string(a_string, sep="_"):
"""Normalize given string, replace dashes with given separator."""
return slugify(a_string).replace("-", sep)
| 35.6 | 356 |
222 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
class EDIValidationError(Exception):
"""Thrown when a document validation fails."""
| 31.714286 | 222 |
643 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Camptocamp SA (http://www.camptocamp.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from odoo import SUPERUSER_ID, api
_logger = logging.getLogger(__name__)
def migrate(cr, version):
if not version:
return
env = api.Environment(cr, SUPERUSER_ID, {})
# For backward compat, enable buttons on all exc types that had a model conf.
domain = [("model_ids", "!=", False), ("model_manual_btn", "=", False)]
env["edi.exchange.type"].search(domain).write({"model_manual_btn": True})
_logger.info("Activate model manual button on existing `edi.exchange.type`")
| 33.842105 | 643 |
2,842 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import base64
from freezegun import freeze_time
from odoo import fields
from odoo.exceptions import UserError
from odoo.tools import mute_logger
from .common import EDIBackendCommonComponentRegistryTestCase
from .fake_components import FakeInputProcess
class EDIBackendTestCase(EDIBackendCommonComponentRegistryTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._build_components(
# TODO: test all components lookup
cls,
FakeInputProcess,
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
"exchange_file": base64.b64encode(b"1234"),
}
cls.record = cls.backend.create_record("test_csv_input", vals)
def setUp(self):
super().setUp()
FakeInputProcess.reset_faked()
def test_process_record(self):
self.record.write({"edi_exchange_state": "input_received"})
with freeze_time("2020-10-22 10:00:00"):
self.record.action_exchange_process()
self.assertTrue(FakeInputProcess.check_called_for(self.record))
self.assertRecordValues(
self.record, [{"edi_exchange_state": "input_processed"}]
)
self.assertEqual(
fields.Datetime.to_string(self.record.exchanged_on), "2020-10-22 10:00:00"
)
def test_process_record_with_error(self):
self.record.write({"edi_exchange_state": "input_received"})
self.record._set_file_content("TEST %d" % self.record.id)
self.record.with_context(
test_break_process="OOPS! Something went wrong :("
).action_exchange_process()
self.assertTrue(FakeInputProcess.check_called_for(self.record))
self.assertRecordValues(
self.record,
[
{
"edi_exchange_state": "input_processed_error",
"exchange_error": "OOPS! Something went wrong :(",
}
],
)
@mute_logger("odoo.models.unlink")
def test_process_no_file_record(self):
self.record.write({"edi_exchange_state": "input_received"})
self.record.exchange_file = False
with self.assertRaises(UserError):
self.record.action_exchange_process()
def test_process_outbound_record(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_output", vals)
record._set_file_content("TEST %d" % record.id)
with self.assertRaises(UserError):
record.action_exchange_process()
# TODO: test ack file are processed
| 34.240964 | 2,842 |
7,158 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# @author: Enric Tobella
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo_test_helper import FakeModelLoader
from odoo.exceptions import AccessError
from odoo.tools import mute_logger
from .common import EDIBackendCommonTestCase
class TestEDIExchangeRecordSecurity(EDIBackendCommonTestCase):
@classmethod
def _setup_env(cls):
# Load fake models ->/
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .fake_models import EdiExchangeConsumerTest
cls.loader.update_registry((EdiExchangeConsumerTest,))
return super()._setup_env()
# pylint: disable=W8110
@classmethod
def _setup_records(cls):
super()._setup_records()
cls.group = cls.env["res.groups"].create({"name": "Demo Group"})
cls.ir_access = cls.env["ir.model.access"].create(
{
"name": "model access",
"model_id": cls.env.ref("edi_oca.model_edi_exchange_consumer_test").id,
"group_id": cls.group.id,
"perm_read": True,
"perm_write": True,
"perm_create": True,
"perm_unlink": True,
}
)
cls.rule = cls.env["ir.rule"].create(
{
"name": "Exchange Record rule demo",
"model_id": cls.env.ref("edi_oca.model_edi_exchange_consumer_test").id,
"domain_force": "[('name', '=', 'test')]",
"groups": [(4, cls.group.id)],
}
)
cls.user = (
cls.env["res.users"]
.with_context(no_reset_password=True, mail_notrack=True)
.create(
{
"name": "Poor Partner (not integrating one)",
"email": "[email protected]",
"login": "poorpartner",
"groups_id": [(6, 0, [cls.env.ref("base.group_user").id])],
}
)
)
cls.consumer_record = cls.env["edi.exchange.consumer.test"].create(
{"name": "test"}
)
cls.exchange_type_out.exchange_filename_pattern = "{record.id}"
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
super().tearDownClass()
def create_record(self, user=False):
vals = {
"model": self.consumer_record._name,
"res_id": self.consumer_record.id,
}
backend = self.backend
if user:
backend = backend.with_user(user)
return backend.create_record("test_csv_output", vals)
def test_superuser_create(self):
exchange_record = self.create_record()
self.assertTrue(exchange_record)
def test_group_create(self):
self.user.write({"groups_id": [(4, self.group.id)]})
exchange_record = self.create_record()
self.assertTrue(exchange_record)
@mute_logger("odoo.addons.base.models.ir_rule")
def test_rule_no_create(self):
self.user.write({"groups_id": [(4, self.group.id)]})
self.consumer_record.name = "no_rule"
with self.assertRaisesRegex(AccessError, "Exchange Record rule demo"):
self.create_record(self.user)
@mute_logger("odoo.addons.base.models.ir_model")
def test_no_group_no_create(self):
with self.assertRaisesRegex(AccessError, "You are not allowed to modify"):
self.create_record(self.user)
@mute_logger("odoo.addons.base.models.ir_model")
def test_no_group_no_read(self):
exchange_record = self.create_record()
with self.assertRaisesRegex(AccessError, "You are not allowed to access"):
exchange_record.with_user(self.user).read()
@mute_logger("odoo.addons.base.models.ir_rule")
def test_rule_no_read(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
self.assertTrue(exchange_record.with_user(self.user).read())
self.consumer_record.name = "no_rule"
with self.assertRaisesRegex(AccessError, "Exchange Record rule demo"):
exchange_record.with_user(self.user).read()
@mute_logger("odoo.addons.base.models.ir_model")
def test_no_group_no_unlink(self):
exchange_record = self.create_record()
with self.assertRaisesRegex(AccessError, "You are not allowed to modify"):
exchange_record.with_user(self.user).unlink()
@mute_logger("odoo.models.unlink")
def test_group_unlink(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
self.assertTrue(exchange_record.with_user(self.user).unlink())
@mute_logger("odoo.addons.base.models.ir_rule")
def test_rule_no_unlink(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
self.consumer_record.name = "no_rule"
with self.assertRaisesRegex(AccessError, "Exchange Record rule demo"):
exchange_record.with_user(self.user).unlink()
def test_no_group_no_search(self):
exchange_record = self.create_record()
self.assertEqual(
0,
self.env["edi.exchange.record"]
.with_user(self.user)
.search_count([("id", "=", exchange_record.id)]),
)
def test_group_search(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
self.assertEqual(
1,
self.env["edi.exchange.record"]
.with_user(self.user)
.search_count([("id", "=", exchange_record.id)]),
)
def test_rule_no_search(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
self.consumer_record.name = "no_rule"
self.assertEqual(
0,
self.env["edi.exchange.record"]
.with_user(self.user)
.search_count([("id", "=", exchange_record.id)]),
)
@mute_logger("odoo.addons.base.models.ir_model")
def test_no_group_no_write(self):
exchange_record = self.create_record()
with self.assertRaisesRegex(AccessError, "You are not allowed to modify"):
exchange_record.with_user(self.user).write({"external_identifier": "1234"})
def test_group_write(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
exchange_record.with_user(self.user).write({"external_identifier": "1234"})
self.assertEqual(exchange_record.external_identifier, "1234")
@mute_logger("odoo.addons.base.models.ir_rule")
def test_rule_no_write(self):
exchange_record = self.create_record()
self.user.write({"groups_id": [(4, self.group.id)]})
self.consumer_record.name = "no_rule"
with self.assertRaisesRegex(AccessError, "Exchange Record rule demo"):
exchange_record.with_user(self.user).write({"external_identifier": "1234"})
| 38.902174 | 7,158 |
444 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# @author: Enric Tobella
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class EdiExchangeConsumerTest(models.Model):
_name = "edi.exchange.consumer.test"
_inherit = ["edi.exchange.consumer.mixin"]
_description = "Model used only for test"
name = fields.Char()
def _get_edi_exchange_record_name(self, exchange_record):
return self.id
| 27.75 | 444 |
5,172 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from freezegun import freeze_time
from odoo import exceptions, fields
from odoo.tools import mute_logger
from odoo.addons.queue_job.delay import DelayableRecordset
from .common import EDIBackendCommonTestCase
class EDIRecordTestCase(EDIBackendCommonTestCase):
# TODO: test more
def test_record_identifier(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_output", vals)
self.assertTrue(
record.identifier.startswith("EDI/{}".format(fields.Date.today().year))
)
new_record = self.backend.create_record(
"test_csv_output", dict(vals, identifier=record.identifier)
)
self.assertTrue(
new_record.identifier.startswith("EDI/{}".format(fields.Date.today().year))
)
self.assertNotEqual(new_record.identifier, record.identifier)
def test_record_validate_state(self):
with self.assertRaises(exceptions.ValidationError) as err:
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
"edi_exchange_state": "output_pending",
}
self.backend.create_record("test_csv_input", vals)
self.assertEqual(
err.exception.name, "Exchange state must respect direction!"
)
def test_record_exchange_date(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
"edi_exchange_state": "output_pending",
}
record = self.backend.create_record("test_csv_output", vals)
self.assertFalse(record.exchanged_on)
with freeze_time("2020-10-21 10:00:00"):
record.edi_exchange_state = "output_sent"
self.assertEqual(
fields.Datetime.to_string(record.exchanged_on), "2020-10-21 10:00:00"
)
@mute_logger("odoo.models.unlink")
def test_record_relation(self):
# create new one to delete it later
partner = self.partner.copy({"name": "Test EDI record rel"})
vals = {
"model": partner._name,
"res_id": partner.id,
}
record = self.backend.create_record("test_csv_output", vals)
self.assertEqual(record.related_name, partner.name)
record1 = self.backend.create_record(
"test_csv_output", dict(vals, parent_id=record.id)
)
self.assertEqual(record1.related_name, partner.name)
record2 = self.backend.create_record(
"test_csv_output_ack", dict(vals, parent_id=record.id)
)
self.assertEqual(record2.related_name, partner.name)
self.assertIn(record1, record.related_exchange_ids)
self.assertIn(record2, record.related_exchange_ids)
self.assertEqual(record.ack_exchange_id, record2)
# Check deletion
partner.unlink()
self.assertFalse(record1.record)
self.assertFalse(record1.related_name)
def test_record_empty_with_parent(self):
"""Simulate child record doesn't have a model and res_id.
In this case the .record should return the record of the parent.
"""
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_output", vals)
record1 = self.backend.create_record(
"test_csv_output", dict(vals, parent_id=record.id)
)
self.assertTrue(record1.model)
self.assertEqual(record.record, record1.record)
# Don't use the vals to lets empty model and res_id
record2 = self.backend.create_record(
"test_csv_output_ack", dict(parent_id=record.id)
)
self.assertFalse(record2.model)
self.assertEqual(record.record, record2.record)
def test_with_delay_override(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_input", vals)
parent_channel = self.env["queue.job.channel"].create(
{
"name": "parent_test_chan",
"parent_id": self.env.ref("queue_job.channel_root").id,
}
)
channel = self.env["queue.job.channel"].create(
{"name": "test_chan", "parent_id": parent_channel.id}
)
self.exchange_type_in.job_channel_id = channel
# re-enable job delayed feature
delayed = record.with_context(test_queue_job_no_delay=False).with_delay()
# Silent useless warning
# `Delayable Delayable(edi.exchange.record*) was prepared but never delayed`
delayed.delayable._generated_job = object()
self.assertTrue(isinstance(delayed, DelayableRecordset))
self.assertEqual(delayed.recordset, record)
self.assertEqual(delayed.delayable.channel, "root.parent_test_chan.test_chan")
| 39.181818 | 5,172 |
1,713 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
# import mock
# from freezegun import freeze_time
# from odoo import fields
# from odoo.exceptions import UserError
from .common import EDIBackendCommonComponentRegistryTestCase
from .fake_components import FakeInputReceive
class EDIBackendTestCase(EDIBackendCommonComponentRegistryTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._build_components(
# TODO: test all components lookup
cls,
FakeInputReceive,
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
}
cls.record = cls.backend.create_record("test_csv_input", vals)
@classmethod
def _setup_context(cls):
return dict(
super()._setup_context(),
_edi_receive_break_on_error=True,
_edi_process_break_on_error=True,
)
def setUp(self):
super().setUp()
FakeInputReceive.reset_faked()
def test_receive_record_nothing_todo(self):
self.backend.with_context(fake_output="yeah!").exchange_receive(self.record)
self.assertEqual(self.record._get_file_content(), "")
self.assertRecordValues(self.record, [{"edi_exchange_state": "new"}])
def test_receive_record(self):
self.record.edi_exchange_state = "input_pending"
self.backend.with_context(fake_output="yeah!").exchange_receive(self.record)
self.assertEqual(self.record._get_file_content(), "yeah!")
self.assertRecordValues(self.record, [{"edi_exchange_state": "input_received"}])
| 33.588235 | 1,713 |
2,602 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import Component
from .common import EDIBackendCommonComponentRegistryTestCase
class EDIBackendTestCase(EDIBackendCommonComponentRegistryTestCase):
def test_component_match(self):
"""Lookup with special match method."""
class MatchByBackendTypeOnly(Component):
_name = "backend_type.only"
_inherit = "edi.component.mixin"
_usage = "generate"
_backend_type = "demo_backend"
_apply_on = ["res.partner"]
class MatchByExchangeTypeOnly(Component):
_name = "exchange_type.only"
_inherit = "edi.component.mixin"
_usage = "generate"
_exchange_type = "test_csv_output"
_apply_on = ["res.partner"]
class MatchByBackendExchangeType(Component):
_name = "backend_type.and.exchange_type"
_inherit = "edi.component.mixin"
_usage = "generate"
_backend_type = "demo_backend"
_exchange_type = "test_csv_output"
_apply_on = ["res.partner"]
self._build_components(
MatchByBackendTypeOnly,
MatchByExchangeTypeOnly,
# This one is registered last but since edi.backend
# is going to sort them by priority, we'll get the right one
# when looking for both match
MatchByBackendExchangeType,
)
# Record not relevant for these tests
work_ctx = {"exchange_record": self.env["edi.exchange.record"].browse()}
# Search by both backend and exchange type
component = self.backend._find_component(
"res.partner",
["generate"],
work_ctx=work_ctx,
backend_type="demo_backend",
exchange_type="test_csv_output",
)
self.assertEqual(component._name, MatchByBackendExchangeType._name)
# Search by backend type only
component = self.backend._find_component(
"res.partner", ["generate"], work_ctx=work_ctx, backend_type="demo_backend"
)
self.assertEqual(component._name, MatchByBackendTypeOnly._name)
# Search by exchange type only
component = self.backend._find_component(
"res.partner",
["generate"],
work_ctx=work_ctx,
exchange_type="test_csv_output",
)
self.assertEqual(component._name, MatchByExchangeTypeOnly._name)
| 36.647887 | 2,602 |
825 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import psycopg2
from odoo.tools import mute_logger
from .common import EDIBackendCommonTestCase
class EDIBackendTypeTestCase(EDIBackendCommonTestCase):
def test_type_code(self):
btype = self.backend_type_model.create(
{"name": "Test new type", "code": "Test new type"}
)
self.assertEqual(btype.code, "test_new_type")
def test_type_code_uniq(self):
existing_code = self.backend.backend_type_id.code
with mute_logger("odoo.sql_db"):
with self.assertRaises(psycopg2.IntegrityError):
self.backend_type_model.create(
{"name": "Test new type", "code": existing_code}
)
| 33 | 825 |
1,743 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.addons.queue_job.tests.common import JobMixin
from .common import EDIBackendCommonTestCase
class EDIBackendTestCase(EDIBackendCommonTestCase, JobMixin):
@classmethod
def _setup_context(cls):
return dict(super()._setup_context(), test_queue_job_no_delay=None)
def test_output(self):
job_counter = self.job_counter()
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_output", vals)
self.backend.with_delay().exchange_generate(record)
created = job_counter.search_created()
self.assertEqual(len(created), 1)
self.assertEqual(
created.name, "Generate output content for given exchange record."
)
self.backend.with_delay().exchange_send(record)
created = job_counter.search_created()
self.assertEqual(created[0].name, "Send exchange file.")
def test_input(self):
job_counter = self.job_counter()
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_input", vals)
self.backend.with_delay().exchange_receive(record)
created = job_counter.search_created()
self.assertEqual(len(created), 1)
self.assertEqual(created.name, "Retrieve an incoming document.")
self.backend.with_delay().exchange_process(record)
created = job_counter.search_created()
self.assertEqual(created[0].name, "Process an incoming document.")
| 38.733333 | 1,743 |
3,527 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import Component
class FakeComponentMixin(Component):
FAKED_COLLECTOR = []
# only for testing
_action = ""
def _fake_it(self):
self.FAKED_COLLECTOR.append(self._call_key(self.exchange_record))
if self.env.context.get("test_break_" + self._action):
exception = self.env.context.get(
"test_break_" + self._action, "YOU BROKE IT!"
)
if not isinstance(exception, Exception):
exception = ValueError(exception)
raise exception
update_values = self.env.context.get("fake_update_values")
if update_values:
self.exchange_record.write(update_values)
return self.env.context.get("fake_output", self._call_key(self.exchange_record))
@classmethod
def _call_key(cls, rec):
return "{}: {}".format(cls._name, rec.id)
@classmethod
def reset_faked(cls):
cls.FAKED_COLLECTOR = []
@classmethod
def check_called_for(cls, rec):
return cls._call_key(rec) in cls.FAKED_COLLECTOR
@classmethod
def check_not_called_for(cls, rec):
return cls._call_key(rec) not in cls.FAKED_COLLECTOR
class FakeOutputGenerator(FakeComponentMixin):
_name = "fake.output.generator"
_inherit = "edi.component.output.mixin"
_usage = "output.generate"
_backend_type = "demo_backend"
_exchange_type = "test_csv_output"
_action = "generate"
def generate(self):
return self._fake_it()
class FakeOutputSender(FakeComponentMixin):
_name = "fake.output.sender"
_inherit = "edi.component.send.mixin"
_usage = "output.send"
_backend_type = "demo_backend"
_exchange_type = "test_csv_output"
_action = "send"
def send(self):
return self._fake_it()
class FakeOutputChecker(FakeComponentMixin):
_name = "fake.output.checker"
_inherit = "edi.component.check.mixin"
_usage = "output.check"
_backend_type = "demo_backend"
_exchange_type = "test_csv_output"
_action = "check"
def check(self):
return self._fake_it()
class FakeInputProcess(FakeComponentMixin):
_name = "fake.input.process"
_inherit = "edi.component.input.mixin"
_usage = "input.process"
_backend_type = "demo_backend"
_exchange_type = "test_csv_input"
_action = "process"
def process(self):
return self._fake_it()
class FakeInputReceive(FakeComponentMixin):
_name = "fake.input.receive"
_inherit = "edi.component.input.mixin"
_usage = "input.receive"
_backend_type = "demo_backend"
_exchange_type = "test_csv_input"
_action = "receive"
def receive(self):
return self._fake_it()
class FakeOutputValidate(FakeComponentMixin):
_name = "fake.out.validate"
_inherit = "edi.component.validate.mixin"
_usage = "output.validate"
_backend_type = "demo_backend"
_exchange_type = "test_csv_output"
_action = "validate"
def validate(self, value=None):
self._fake_it()
return
class FakeInputValidate(FakeComponentMixin):
_name = "fake.in.validate"
_inherit = "edi.component.validate.mixin"
_usage = "input.validate"
_backend_type = "demo_backend"
_exchange_type = "test_csv_input"
_action = "validate"
def validate(self, value=None):
self._fake_it()
return
| 25.933824 | 3,527 |
3,404 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# Copyright 2020 Creu Blanca
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import os
from odoo.tests.common import TransactionCase, tagged
from odoo.addons.component.tests.common import (
TransactionComponentCase,
TransactionComponentRegistryCase,
)
class EDIBackendTestMixin(object):
@classmethod
def _setup_context(cls):
return dict(
cls.env.context, tracking_disable=True, test_queue_job_no_delay=True
)
@classmethod
def _setup_env(cls):
cls.env = cls.env(context=cls._setup_context())
@classmethod
def _setup_records(cls):
cls.backend = cls._get_backend()
cls.backend_type_code = cls.backend.backend_type_id.code
cls.backend_model = cls.env["edi.backend"]
cls.backend_type_model = cls.env["edi.backend.type"]
cls.exchange_type_in = cls._create_exchange_type(
name="Test CSV input",
code="test_csv_input",
direction="input",
exchange_file_ext="csv",
exchange_filename_pattern="{record.ref}-{type.code}-{dt}",
)
cls.exchange_type_out = cls._create_exchange_type(
name="Test CSV output",
code="test_csv_output",
direction="output",
exchange_file_ext="csv",
exchange_filename_pattern="{record.ref}-{type.code}-{dt}",
)
cls.exchange_type_out_ack = cls._create_exchange_type(
name="Test CSV output ACK",
code="test_csv_output_ack",
direction="output",
exchange_file_ext="txt",
exchange_filename_pattern="{record.ref}-{type.code}-{dt}",
)
cls.exchange_type_out.ack_type_id = cls.exchange_type_out_ack
cls.partner = cls.env.ref("base.res_partner_1")
cls.partner.ref = "EDI_EXC_TEST"
def read_test_file(self, filename):
path = os.path.join(os.path.dirname(__file__), "examples", filename)
with open(path, "r") as thefile:
return thefile.read()
@classmethod
def _get_backend(cls):
return cls.env.ref("edi_oca.demo_edi_backend")
@classmethod
def _create_exchange_type(cls, **kw):
model = cls.env["edi.exchange.type"]
vals = {
"name": "Test CSV exchange",
"backend_id": cls.backend.id,
"backend_type_id": cls.backend.backend_type_id.id,
}
vals.update(kw)
return model.create(vals)
@tagged("-at_install", "post_install")
class EDIBackendCommonTestCase(TransactionCase, EDIBackendTestMixin):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._setup_env()
cls._setup_records()
@tagged("-at_install", "post_install")
class EDIBackendCommonComponentTestCase(TransactionComponentCase, EDIBackendTestMixin):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._setup_env()
cls._setup_records()
@tagged("-at_install", "post_install")
class EDIBackendCommonComponentRegistryTestCase(
TransactionComponentRegistryCase, EDIBackendTestMixin
):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._setup_env()
cls._setup_records()
cls._setup_registry(cls)
cls._load_module_components(cls, "edi_oca")
| 31.813084 | 3,404 |
5,789 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# @author: Enric Tobella
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import os
import unittest
from lxml import etree
from odoo_test_helper import FakeModelLoader
from odoo.tests.common import Form
from .common import EDIBackendCommonTestCase
# This clashes w/ some setup (eg: run tests w/ pytest when edi_storage is installed)
# If you still want to run `edi` tests w/ pytest when this happens, set this env var.
@unittest.skipIf(os.getenv("SKIP_EDI_CONSUMER_CASE"), "Consumer test case disabled.")
class TestConsumerMixinCase(EDIBackendCommonTestCase):
@classmethod
def _setup_env(cls):
super()._setup_env()
# Load fake models ->/
cls.loader = FakeModelLoader(cls.env, cls.__module__)
cls.loader.backup_registry()
from .fake_models import EdiExchangeConsumerTest
cls.loader.update_registry((EdiExchangeConsumerTest,))
return super()._setup_env()
# pylint: disable=W8110
@classmethod
def _setup_records(cls):
super()._setup_records()
cls.consumer_record = cls.env["edi.exchange.consumer.test"].create(
{"name": "Test Consumer"}
)
cls.exchange_type_out.exchange_filename_pattern = "{record.id}"
cls.exchange_type_new = cls._create_exchange_type(
name="Test CSV output",
code="test_csv_new_output",
direction="output",
exchange_file_ext="csv",
backend_id=False,
exchange_filename_pattern="{record.ref}-{type.code}-{dt}",
model_ids=[(4, cls.env["ir.model"]._get_id(cls.consumer_record._name))],
enable_domain="[]",
enable_snippet="""
result = not record._has_exchange_record(exchange_type)
""",
)
cls.exchange_type_out.write(
{
"model_ids": [
(
4,
cls.env["ir.model"]._get_id(cls.consumer_record._name),
)
],
"enable_domain": "[]",
"enable_snippet": """
result = not record._has_exchange_record(exchange_type, exchange_type.backend_id)
""",
}
)
cls.backend_02 = cls.backend.copy()
@classmethod
def tearDownClass(cls):
cls.loader.restore_registry()
super().tearDownClass()
def test_mixin(self):
self.assertEqual(0, self.consumer_record.exchange_record_count)
vals = {
"model": self.consumer_record._name,
"res_id": self.consumer_record.id,
}
exchange_record = self.backend.create_record("test_csv_output", vals)
self.consumer_record.refresh()
self.assertEqual(1, self.consumer_record.exchange_record_count)
action = self.consumer_record.action_view_edi_records()
self.consumer_record.refresh()
self.assertEqual(
exchange_record, self.env["edi.exchange.record"].search(action["domain"])
)
self.consumer_record._has_exchange_record(exchange_record.type_id, self.backend)
def test_expected_configuration(self):
# no btn enabled
self.assertFalse(self.consumer_record.edi_has_form_config)
self.assertEqual(
self.consumer_record.edi_config[str(self.exchange_type_out.id)],
{"form": {}},
)
# enable it
self.exchange_type_out.model_manual_btn = True
self.consumer_record.invalidate_cache(["edi_has_form_config", "edi_config"])
self.assertEqual(
self.consumer_record.edi_config[str(self.exchange_type_out.id)],
{"form": {"btn": {"label": self.exchange_type_out.name}}},
)
action = self.consumer_record.edi_create_exchange_record(
self.exchange_type_out.id
)
self.assertEqual(action["res_model"], "edi.exchange.record")
self.consumer_record.refresh()
self.assertNotIn(
str(self.exchange_type_out.id),
self.consumer_record.edi_config,
)
self.assertTrue(self.consumer_record.exchange_record_ids)
self.assertEqual(
self.consumer_record.exchange_record_ids.type_id, self.exchange_type_out
)
def test_multiple_backend(self):
self.assertIn(
str(self.exchange_type_new.id),
self.consumer_record.edi_config,
)
action = self.consumer_record.edi_create_exchange_record(
self.exchange_type_new.id
)
self.assertNotEqual(action["res_model"], "edi.exchange.record")
self.assertEqual(action["res_model"], "edi.exchange.record.create.wiz")
wizard = (
self.env[action["res_model"]]
.with_context(**action["context"])
.create({"backend_id": self.backend_02.id})
)
wizard.create_edi()
self.consumer_record.refresh()
self.assertNotIn(
str(self.exchange_type_new.id),
self.consumer_record.edi_config,
)
self.assertTrue(self.consumer_record.exchange_record_ids)
self.assertEqual(
self.consumer_record.exchange_record_ids.type_id, self.exchange_type_new
)
def test_form(self):
"""Testing that the form has inherited the fields and inserted them
Unfortunately we are unable to test the buttons here
"""
with Form(self.consumer_record) as f:
self.assertIn("edi_has_form_config", f._values)
self.assertIn("edi_config", f._values)
form = etree.fromstring(f._view["arch"])
self.assertTrue(form.xpath("//field[@name='edi_has_form_config']"))
self.assertTrue(form.xpath("//field[@name='edi_config']"))
| 38.085526 | 5,789 |
4,035 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import mock
from freezegun import freeze_time
from odoo import fields, tools
from odoo.exceptions import UserError
from .common import EDIBackendCommonComponentRegistryTestCase
from .fake_components import FakeOutputChecker, FakeOutputGenerator, FakeOutputSender
class EDIBackendTestCase(EDIBackendCommonComponentRegistryTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._build_components(
# TODO: test all components lookup
cls,
FakeOutputGenerator,
FakeOutputSender,
FakeOutputChecker,
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
}
cls.record = cls.backend.create_record("test_csv_output", vals)
def setUp(self):
super().setUp()
FakeOutputGenerator.reset_faked()
FakeOutputSender.reset_faked()
FakeOutputChecker.reset_faked()
def test_generate_record_output(self):
self.backend.with_context(fake_output="yeah!").exchange_generate(self.record)
self.assertEqual(self.record._get_file_content(), "yeah!")
def test_generate_record_output_pdf(self):
result = tools.file_open("addons/edi_oca/tests/result.pdf", mode="rb").read()
self.backend.with_context(fake_output=result).exchange_generate(self.record)
def test_send_record(self):
self.record.write({"edi_exchange_state": "output_pending"})
self.record._set_file_content("TEST %d" % self.record.id)
self.assertFalse(self.record.exchanged_on)
with freeze_time("2020-10-21 10:00:00"):
self.record.action_exchange_send()
self.assertTrue(FakeOutputSender.check_called_for(self.record))
self.assertRecordValues(self.record, [{"edi_exchange_state": "output_sent"}])
self.assertEqual(
fields.Datetime.to_string(self.record.exchanged_on), "2020-10-21 10:00:00"
)
def test_send_record_with_error(self):
self.record.write({"edi_exchange_state": "output_pending"})
self.record._set_file_content("TEST %d" % self.record.id)
self.assertFalse(self.record.exchanged_on)
self.record.with_context(
test_break_send="OOPS! Something went wrong :("
).action_exchange_send()
self.assertTrue(FakeOutputSender.check_called_for(self.record))
self.assertRecordValues(
self.record,
[
{
"edi_exchange_state": "output_error_on_send",
"exchange_error": "OOPS! Something went wrong :(",
}
],
)
def test_send_invalid_direction(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_input", vals)
with mock.patch.object(type(self.backend), "_exchange_send") as mocked:
mocked.return_value = "AAA"
with self.assertRaises(UserError) as err:
record.action_exchange_send()
self.assertEqual(
err.exception.args[0],
"Record ID=%d is not meant to be sent!" % record.id,
)
mocked.assert_not_called()
def test_send_not_generated_record(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_output", vals)
with mock.patch.object(type(self.backend), "_exchange_send") as mocked:
mocked.return_value = "AAA"
with self.assertRaises(UserError) as err:
record.action_exchange_send()
self.assertEqual(
err.exception.args[0], "Record ID=%d has no file to send!" % record.id
)
mocked.assert_not_called()
| 38.428571 | 4,035 |
3,061 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# Copyright 2022 Camptocamp SA (https://www.camptocamp.com).
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from freezegun import freeze_time
from .common import EDIBackendCommonTestCase
class EDIExchangeTypeTestCase(EDIBackendCommonTestCase):
def test_advanced_settings(self):
settings = """
components:
foo: this
boo: that
whatever:
ok: True
"""
self.exchange_type_out.advanced_settings_edit = settings
# fmt:off
self.assertEqual(self.exchange_type_out.advanced_settings, {
"components": {
"foo": "this",
"boo": "that",
},
"whatever": {
"ok": True,
}
})
# fmt:on
def _test_exchange_filename(self, wanted_filename):
filename = self.exchange_type_out._make_exchange_filename(
exchange_record=self.env["edi.exchange.record"]
)
self.assertEqual(filename, wanted_filename)
@freeze_time("2022-04-28 08:37:24")
def test_filename_pattern_settings(self):
"""
Test filename pattern defined into advanced settings.
Example of pattern:
filename_pattern:
force_tz: Europe/Rome
date_pattern: %Y-%m-%d-%H-%M-%S
"""
self.env.user.tz = None
self.exchange_type_out.write(
{
"exchange_filename_pattern": "Test-File",
"exchange_file_ext": "csv",
"advanced_settings_edit": None,
}
)
# Test without any settings and minimal filename pattern
self._test_exchange_filename("Test-File.csv")
# Test with datetime in filename pattern
self.exchange_type_out.exchange_filename_pattern = "Test-File-{dt}"
self._test_exchange_filename("Test-File-2022-04-28-08-37-24.csv")
# Add timezone on current user
self.env.user.tz = "America/New_York" # New_York time is -4h
self._test_exchange_filename("Test-File-2022-04-28-04-37-24.csv")
# Force date pattern on advanced settings
self.exchange_type_out.advanced_settings_edit = """
filename_pattern:
date_pattern: '%Y-%m-%d-%H'
"""
self._test_exchange_filename("Test-File-2022-04-28-04.csv")
# Force timezone on advanced settings
self.exchange_type_out.advanced_settings_edit = """
filename_pattern:
# Rome time is +2h
force_tz: Europe/Rome
"""
self._test_exchange_filename("Test-File-2022-04-28-10-37-24.csv")
# Force date pattern and timezone on advanced settings
self.exchange_type_out.advanced_settings_edit = """
filename_pattern:
# Rome time is +2h
force_tz: Europe/Rome
date_pattern: '%Y-%m-%d-%H-%M'
"""
self._test_exchange_filename("Test-File-2022-04-28-10-37.csv")
| 33.271739 | 3,061 |
4,442 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.tools import mute_logger
from .common import EDIBackendCommonComponentRegistryTestCase
from .fake_components import FakeOutputChecker, FakeOutputGenerator, FakeOutputSender
LOGGERS = ("odoo.addons.edi_oca.models.edi_backend", "odoo.addons.queue_job.delay")
class EDIBackendTestCase(EDIBackendCommonComponentRegistryTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._build_components(
cls, FakeOutputGenerator, FakeOutputSender, FakeOutputChecker
)
cls.partner2 = cls.env.ref("base.res_partner_10")
cls.partner3 = cls.env.ref("base.res_partner_12")
cls.record1 = cls.backend.create_record(
"test_csv_output", {"model": cls.partner._name, "res_id": cls.partner.id}
)
cls.record2 = cls.backend.create_record(
"test_csv_output", {"model": cls.partner._name, "res_id": cls.partner2.id}
)
cls.record3 = cls.backend.create_record(
"test_csv_output", {"model": cls.partner._name, "res_id": cls.partner3.id}
)
cls.records = cls.record1 + cls.record1 + cls.record3
def setUp(self):
super().setUp()
FakeOutputGenerator.reset_faked()
FakeOutputSender.reset_faked()
FakeOutputChecker.reset_faked()
@mute_logger(*LOGGERS)
def test_exchange_generate_new_no_auto(self):
# No content ready to be sent, no auto-generate, nothing happens
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "new")
self.backend._cron_check_output_exchange_sync()
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "new")
@mute_logger(*LOGGERS)
def test_exchange_generate_new_auto_skip_send(self):
self.exchange_type_out.exchange_file_auto_generate = True
# No content ready to be sent, will get the content but not send it
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "new")
self.backend._cron_check_output_exchange_sync(skip_send=True)
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "output_pending")
self.assertTrue(FakeOutputGenerator.check_called_for(rec))
self.assertEqual(
rec._get_file_content(), FakeOutputGenerator._call_key(rec)
)
# TODO: test better?
self.assertFalse(rec.ack_exchange_id)
@mute_logger(*LOGGERS)
def test_exchange_generate_new_auto_send(self):
self.exchange_type_out.exchange_file_auto_generate = True
# No content ready to be sent, will get the content and send it
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "new")
self.backend._cron_check_output_exchange_sync()
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "output_sent")
self.assertTrue(FakeOutputGenerator.check_called_for(rec))
self.assertEqual(
rec._get_file_content(), FakeOutputGenerator._call_key(rec)
)
self.assertTrue(FakeOutputSender.check_called_for(rec))
# TODO: test better?
self.assertTrue(rec.ack_exchange_id)
@mute_logger(*LOGGERS)
def test_exchange_generate_output_ready_auto_send(self):
# No content ready to be sent, will get the content and send it
for rec in self.records:
self.assertEqual(rec.edi_exchange_state, "new")
self.record1._set_file_content("READY")
self.record1.edi_exchange_state = "output_sent"
self.backend.with_context(
fake_update_values={"edi_exchange_state": "output_sent_and_processed"}
)._cron_check_output_exchange_sync()
for rec in self.records - self.record1:
self.assertEqual(rec.edi_exchange_state, "new")
self.assertEqual(self.record1.edi_exchange_state, "output_sent_and_processed")
self.assertTrue(FakeOutputGenerator.check_not_called_for(self.record1))
self.assertTrue(FakeOutputSender.check_not_called_for(self.record1))
self.assertTrue(FakeOutputChecker.check_called_for(self.record1))
# TODO: test better?
self.assertTrue(self.record1.ack_exchange_id)
| 44.868687 | 4,442 |
2,584 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from freezegun import freeze_time
from .common import EDIBackendCommonTestCase
class EDIBackendTestCase(EDIBackendCommonTestCase):
@freeze_time("2020-10-21 10:00:00")
def test_create_record(self):
self.env.user.tz = None # Have no timezone used in generated filename
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_input", vals)
expected = {
"type_id": self.exchange_type_in.id,
"edi_exchange_state": "new",
"exchange_filename": "EDI_EXC_TEST-test_csv_"
"input-2020-10-21-10-00-00.csv",
}
self.assertRecordValues(record, [expected])
self.assertEqual(record.record, self.partner)
self.assertEqual(record.edi_exchange_state, "new")
def test_get_component_usage(self):
vals = {
"model": self.partner._name,
"res_id": self.partner.id,
}
record = self.backend.create_record("test_csv_input", vals)
candidates = self.backend._get_component_usage_candidates(record, "process")
self.assertEqual(
candidates,
["input.process"],
)
record = self.backend.create_record("test_csv_output", vals)
candidates = self.backend._get_component_usage_candidates(record, "generate")
self.assertEqual(
candidates,
["output.generate"],
)
# set advanced settings on type
settings = """
components:
generate:
usage: my.special.generate
send:
usage: my.special.send
"""
record.type_id.advanced_settings_edit = settings
candidates = self.backend._get_component_usage_candidates(record, "generate")
self.assertEqual(
candidates,
["my.special.generate", "output.generate"],
)
candidates = self.backend._get_component_usage_candidates(record, "send")
self.assertEqual(
candidates,
["my.special.send", "output.send"],
)
def test_action_view_exchanges(self):
# Just testing is not broken
self.assertTrue(self.backend.action_view_exchanges())
def test_action_view_exchange_types(self):
# Just testing is not broken
self.assertTrue(self.backend.action_view_exchange_types())
| 35.888889 | 2,584 |
3,259 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import base64
from ..exceptions import EDIValidationError
from .common import EDIBackendCommonComponentRegistryTestCase
from .fake_components import (
FakeInputReceive,
FakeInputValidate,
FakeOutputGenerator,
FakeOutputValidate,
)
class EDIBackendTestCase(EDIBackendCommonComponentRegistryTestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._build_components(
# TODO: test all components lookup
cls,
FakeInputValidate,
FakeOutputValidate,
FakeInputReceive,
FakeOutputGenerator,
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
"exchange_file": base64.b64encode(b"1234"),
}
cls.record_in = cls.backend.create_record("test_csv_input", vals)
vals.pop("exchange_file")
cls.record_out = cls.backend.create_record("test_csv_output", vals)
def setUp(self):
super().setUp()
FakeInputValidate.reset_faked()
FakeOutputValidate.reset_faked()
FakeInputReceive.reset_faked()
FakeOutputGenerator.reset_faked()
def test_receive_validate_record(self):
self.record_in.write({"edi_exchange_state": "input_pending"})
self.backend.exchange_receive(self.record_in)
self.assertTrue(FakeInputValidate.check_called_for(self.record_in))
self.assertRecordValues(
self.record_in, [{"edi_exchange_state": "input_received"}]
)
def test_receive_validate_record_error(self):
self.record_in.write({"edi_exchange_state": "input_pending"})
exc = EDIValidationError("Data seems wrong!")
self.backend.with_context(test_break_validate=exc).exchange_receive(
self.record_in
)
self.assertTrue(FakeInputValidate.check_called_for(self.record_in))
self.assertRecordValues(
self.record_in,
[
{
"edi_exchange_state": "validate_error",
"exchange_error": "Data seems wrong!",
}
],
)
def test_generate_validate_record(self):
self.record_out.write({"edi_exchange_state": "new"})
self.backend.exchange_generate(self.record_out)
self.assertTrue(FakeOutputValidate.check_called_for(self.record_out))
self.assertRecordValues(
self.record_out, [{"edi_exchange_state": "output_pending"}]
)
def test_generate_validate_record_error(self):
self.record_out.write({"edi_exchange_state": "new"})
exc = EDIValidationError("Data seems wrong!")
self.backend.with_context(test_break_validate=exc).exchange_generate(
self.record_out
)
self.assertTrue(FakeOutputValidate.check_called_for(self.record_out))
self.assertRecordValues(
self.record_out,
[
{
"edi_exchange_state": "validate_error",
"exchange_error": "Data seems wrong!",
}
],
)
| 35.043011 | 3,259 |
9,004 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# Copyright 2020 Creu Blanca
# Copyright 2022 Camptocamp SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from lxml import etree
from odoo import api, fields, models
from odoo.tools import safe_eval
from odoo.addons.base_sparse_field.models.fields import Serialized
class EDIExchangeConsumerMixin(models.AbstractModel):
"""Record that might have related EDI Exchange records"""
_name = "edi.exchange.consumer.mixin"
_description = "Abstract record where exchange records can be assigned"
exchange_record_ids = fields.One2many(
"edi.exchange.record",
inverse_name="res_id",
domain=lambda r: [("model", "=", r._name)],
)
exchange_record_count = fields.Integer(compute="_compute_exchange_record_count")
edi_config = Serialized(
compute="_compute_edi_config",
default={},
)
edi_has_form_config = fields.Boolean(compute="_compute_edi_config")
def _compute_edi_config(self):
for record in self:
config = record._edi_get_exchange_type_config()
record.edi_config = config
record.edi_has_form_config = any([x.get("form") for x in config.values()])
def _edi_get_exchange_type_config(self):
exchange_types = (
self.env["edi.exchange.type"]
.sudo()
.search([("model_ids.model", "=", self._name)])
)
result = {}
for exchange_type in exchange_types:
eval_ctx = dict(
self._get_eval_context(), record=self, exchange_type=exchange_type
)
domain = safe_eval.safe_eval(exchange_type.enable_domain or "[]", eval_ctx)
if not self.filtered_domain(domain):
continue
if exchange_type.enable_snippet:
safe_eval.safe_eval(
exchange_type.enable_snippet, eval_ctx, mode="exec", nocopy=True
)
if not eval_ctx.get("result", False):
continue
result[exchange_type.id] = self._edi_get_exchange_type_conf(exchange_type)
return result
@api.model
def _edi_get_exchange_type_conf(self, exchange_type):
conf = {"form": {}}
if exchange_type.model_manual_btn:
conf.update({"form": {"btn": {"label": exchange_type.name}}})
return conf
def _get_eval_context(self):
"""Prepare context to evalue python code snippet.
:returns: dict -- evaluation context given to safe_eval
"""
return {
"datetime": safe_eval.datetime,
"dateutil": safe_eval.dateutil,
"time": safe_eval.time,
"uid": self.env.uid,
"user": self.env.user,
}
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
res = super().fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "form":
doc = etree.XML(res["arch"])
for node in doc.xpath("//sheet"):
# TODO: add a default group
group = False
if hasattr(self, "_edi_generate_group"):
group = self._edi_generate_group
str_element = self.env["ir.qweb"]._render(
"edi_oca.edi_exchange_consumer_mixin_buttons",
{"group": group},
)
node.addprevious(etree.fromstring(str_element))
View = self.env["ir.ui.view"]
# Override context for postprocessing
if view_id and res.get("base_model", self._name) != self._name:
View = View.with_context(base_model_name=res["base_model"])
new_arch, new_fields = View.postprocess_and_fields(doc, self._name)
res["arch"] = new_arch
# We don't want to lose previous configuration, so, we only want to add
# the new fields
new_fields.update(res["fields"])
res["fields"] = new_fields
return res
def _edi_create_exchange_record_vals(self, exchange_type):
return {
"model": self._name,
"res_id": self.id,
}
def _edi_create_exchange_record(self, exchange_type, backend=None, vals=None):
backend = exchange_type.backend_id or backend
assert backend
vals = vals or {}
vals.update(self._edi_create_exchange_record_vals(exchange_type))
return backend.create_record(exchange_type.code, vals)
def edi_create_exchange_record(self, exchange_type_id):
self.ensure_one()
exchange_type = self.env["edi.exchange.type"].browse(exchange_type_id)
backend = exchange_type.backend_id
if (
not backend
and self.env["edi.backend"].search_count(
[("backend_type_id", "=", exchange_type.backend_type_id.id)]
)
== 1
):
backend = self.env["edi.backend"].search(
[("backend_type_id", "=", exchange_type.backend_type_id.id)]
)
# FIXME: here you can still have more than one backend per type.
# We should always get to the wizard w/ pre-populated values.
# Maybe this behavior can be controlled by exc type adv param.
if backend:
exchange_record = self._edi_create_exchange_record(exchange_type, backend)
self._event("on_edi_generate_manual").notify(self, exchange_record)
return exchange_record.get_formview_action()
return self._edi_get_create_record_wiz_action(exchange_type_id)
def _edi_get_create_record_wiz_action(self, exchange_type_id):
xmlid = "edi_oca.edi_exchange_record_create_act_window"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["context"] = {
"default_res_id": self.id,
"default_model": self._name,
"default_exchange_type_id": exchange_type_id,
}
return action
def _has_exchange_record(self, exchange_type, backend=False, extra_domain=False):
"""Check presence of related exchange record with a specific exchange type"""
return bool(
self.env["edi.exchange.record"].search_count(
self._has_exchange_record_domain(
exchange_type, backend=backend, extra_domain=extra_domain
)
)
)
def _has_exchange_record_domain(
self, exchange_type, backend=False, extra_domain=False
):
domain = [
("model", "=", self._name),
("res_id", "=", self.id),
("type_id", "=", exchange_type.id),
]
if backend is None:
backend = exchange_type.backend_id
if backend:
domain.append(("backend_id", "=", backend.id))
if extra_domain:
domain += extra_domain
return domain
def _get_exchange_record(self, exchange_type, backend=False, extra_domain=False):
"""Get all related exchange records matching give exchange type."""
return self.env["edi.exchange.record"].search(
self._has_exchange_record_domain(
exchange_type, backend=backend, extra_domain=extra_domain
)
)
@api.depends("exchange_record_ids")
def _compute_exchange_record_count(self):
for record in self:
record.exchange_record_count = len(record.exchange_record_ids)
def action_view_edi_records(self):
self.ensure_one()
xmlid = "edi_oca.act_open_edi_exchange_record_view"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["domain"] = [("model", "=", self._name), ("res_id", "=", self.id)]
return action
@api.model
def get_edi_access(self, doc_ids, operation, model_name=False):
"""Retrieve access policy.
The behavior is similar to `mail.thread` and `mail.message`
and it relies on the access rules defines on the related record.
The behavior can be customized on the related model
by defining `_edi_exchange_record_access`.
By default `write`, otherwise the custom permission is returned.
"""
DocModel = self.env[model_name] if model_name else self
create_allow = getattr(DocModel, "_edi_exchange_record_access", "write")
if operation in ["write", "unlink"]:
check_operation = "write"
elif operation == "create" and create_allow in [
"create",
"read",
"write",
"unlink",
]:
check_operation = create_allow
elif operation == "create":
check_operation = "write"
else:
check_operation = operation
return check_operation
| 38.478632 | 9,004 |
872 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import api, fields, models
from ..utils import normalize_string
class EDIBackendType(models.Model):
"""Define a kind of backend."""
_name = "edi.backend.type"
_description = "EDI Backend Type"
name = fields.Char(required=True)
code = fields.Char(
required=True,
inverse="_inverse_code",
)
_sql_constraints = [
("uniq_code", "unique(code)", "Backend type code must be unique!")
]
@api.onchange("name", "code")
def _onchange_code(self):
for rec in self:
rec.code = rec.code or rec.name
def _inverse_code(self):
for rec in self:
# Make sure it's always normalized
rec.code = normalize_string(rec.code)
| 25.647059 | 872 |
23,896 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# Copyright 2020 Creu Blanca
# Copyright 2021 Camptocamp SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import base64
import logging
from odoo import _, exceptions, fields, models, tools
from odoo.addons.component.exception import NoComponentError
from ..exceptions import EDIValidationError
_logger = logging.getLogger(__name__)
def _get_exception_msg(exc):
if hasattr(exc, "args") and isinstance(exc.args[0], str):
return exc.args[0]
return repr(exc)
class EDIBackend(models.Model):
"""Generic backend to control EDI exchanges.
Backends can be organized with types.
The backend should be responsible for managing records.
For each record it can generate or parse their values
depending on their direction (incoming, outgoing)
and send or receive them automatically depending on their state.
"""
_name = "edi.backend"
_description = "EDI Backend"
_inherit = ["collection.base"]
name = fields.Char(required=True)
backend_type_id = fields.Many2one(
string="EDI Backend type",
comodel_name="edi.backend.type",
required=True,
ondelete="restrict",
)
output_sent_processed_auto = fields.Boolean(
help="""
Automatically set the record as processed after sending.
Usecase: the web service you send the file to processes it on the fly.
"""
)
active = fields.Boolean(default=True)
def _get_component(self, exchange_record, key):
candidates = self._get_component_usage_candidates(exchange_record, key)
work_ctx = {"exchange_record": exchange_record}
# Inject work context from advanced settings
record_conf = self._get_component_conf_for_record(exchange_record, key)
work_ctx.update(record_conf.get("work_ctx", {}))
match_attrs = self._component_match_attrs(exchange_record, key)
# Model is not granted to be there
model = exchange_record.model or self._name
# Load additional ctx keys if any
collection = self
# TODO: document this
env_ctx = record_conf.get("env_ctx", {})
if env_ctx:
collection = collection.with_context(**env_ctx)
return collection._find_component(
model,
candidates,
work_ctx=work_ctx,
**match_attrs,
)
def _component_match_attrs(self, exchange_record, key):
"""Attributes that will be used to lookup components.
They will be set in the work context and propagated to components.
"""
return {
"backend_type": self.backend_type_id.code,
"exchange_type": exchange_record.type_id.code,
}
def _component_sort_key(self, component_class):
"""Determine the order of matched components.
The order can be very important if your implementation
allow generic / default components to be registered.
"""
return (
1 if component_class._backend_type else 0,
1 if component_class._exchange_type else 0,
)
def _find_component(self, model, usage_candidates, safe=True, work_ctx=None, **kw):
"""Retrieve component for current backend.
:param usage_candidates:
list of usage to try by priority. 1st found, 1st returned
:param safe: boolean, if true does not break if component is not found
:param work_ctx: dictionary with work context params
:param kw: keyword args to lookup for components (eg: usage)
"""
component = None
work_ctx = work_ctx or {}
if "backend" not in work_ctx:
work_ctx["backend"] = self
with self.work_on(model, **work_ctx) as work:
for usage in usage_candidates:
components, c_work_ctx = work._matching_components(usage=usage, **kw)
if not components:
continue
# Sort components and pick the 1st one matching.
# In this way we support generic components registration
# and specific components registrations
components = sorted(
components, key=lambda x: self._component_sort_key(x), reverse=True
)
component = components[0](c_work_ctx)
_logger.debug("using component", component._name)
break
if not component and not safe:
raise NoComponentError(
"No component found matching any of: {}".format(usage_candidates)
)
return component or None
def _get_component_usage_candidates(self, exchange_record, key):
"""Retrieve usage candidates for components."""
# fmt:off
base_usage = ".".join([
exchange_record.direction,
key,
])
# fmt:on
record_conf = self._get_component_conf_for_record(exchange_record, key)
candidates = [record_conf["usage"]] if record_conf else []
candidates += [
base_usage,
]
return candidates
def _get_component_conf_for_record(self, exchange_record, key):
settings = exchange_record.type_id.get_settings()
return settings.get("components", {}).get(key, {})
@property
def exchange_record_model(self):
return self.env["edi.exchange.record"]
def create_record(self, type_code, values):
"""Create an exchange record for current backend.
:param type_code: edi.exchange.type code
:param values: edi.exchange.record values
:return: edi.exchange.record record
"""
self.ensure_one()
_values = self._create_record_prepare_values(type_code, values)
return self.exchange_record_model.create(_values)
def _create_record_prepare_values(self, type_code, values):
res = values.copy() # do not pollute original dict
exchange_type = self.env["edi.exchange.type"].search(
self._get_exchange_type_domain(type_code), limit=1
)
assert exchange_type, f"Exchange type not found: {type_code}"
res["type_id"] = exchange_type.id
res["backend_id"] = self.id
return res
def _get_exchange_type_domain(self, code):
return [
("code", "=", code),
"|",
("backend_type_id", "=", self.backend_type_id.id),
("backend_id", "=", self.id),
]
def _delay_action(self, rec):
# TODO: Remove this on 16.0
_logger.warning(
"This function has been replaced by rec.with_delay(). "
"It will be removed on 16.0."
)
return self.with_delay(**rec._job_delay_params())
def exchange_generate(self, exchange_record, store=True, force=False, **kw):
"""Generate output content for given exchange record.
:param exchange_record: edi.exchange.record recordset
:param store: store output on the record itself
:param force: allow to re-genetate the content
:param kw: keyword args to be propagated to output generate handler
"""
self.ensure_one()
self._check_exchange_generate(exchange_record, force=force)
output = self._exchange_generate(exchange_record, **kw)
if output and store:
if not isinstance(output, bytes):
output = output.encode()
exchange_record.update(
{
"exchange_file": base64.b64encode(output),
"edi_exchange_state": "output_pending",
}
)
try:
# TODO: Remove this on 15.0, we will keep it in order to not break current
# installations
output = tools.pycompat.to_text(output)
except UnicodeDecodeError:
_logger.info("File is not a text, so it cannot be converted")
if output:
try:
self._validate_data(exchange_record, output)
except EDIValidationError as err:
error = _get_exception_msg(err)
state = "validate_error"
message = exchange_record._exchange_status_message("validate_ko")
exchange_record.update(
{"edi_exchange_state": state, "exchange_error": error}
)
exchange_record._notify_related_record(message)
return output
def _check_exchange_generate(self, exchange_record, force=False):
exchange_record.ensure_one()
if (
exchange_record.edi_exchange_state != "new"
and exchange_record.exchange_file
and not force
):
raise exceptions.UserError(
_(
"Exchange record ID=%d is not in draft state "
"and has already an output value."
)
% exchange_record.id
)
if exchange_record.direction != "output":
raise exceptions.UserError(
_(
"Exchange record ID=%d is not an outgoing record, "
"cannot be generated"
)
% exchange_record.id
)
if exchange_record.exchange_file:
raise exceptions.UserError(
_("Exchabge record ID=%d already has a file to process!")
% exchange_record.id
)
def _exchange_generate(self, exchange_record, **kw):
component = self._get_component(exchange_record, "generate")
if component:
return component.generate()
raise NotImplementedError("No handler for `_exchange_generate`")
# TODO: add tests
def _validate_data(self, exchange_record, value=None, **kw):
component = self._get_component(exchange_record, "validate")
if component:
return component.validate(value)
def exchange_send(self, exchange_record):
"""Send exchange file."""
self.ensure_one()
exchange_record.ensure_one()
# In case already sent: skip sending and check the state
check = self._output_check_send(exchange_record)
if not check:
return False
state = exchange_record.edi_exchange_state
error = False
message = None
try:
self._exchange_send(exchange_record)
except self._swallable_exceptions() as err:
if self.env.context.get("_edi_send_break_on_error"):
raise
error = _get_exception_msg(err)
state = "output_error_on_send"
message = exchange_record._exchange_status_message("send_ko")
res = False
else:
# TODO: maybe the send handler should return desired message and state
message = exchange_record._exchange_status_message("send_ok")
error = None
state = (
"output_sent_and_processed"
if self.output_sent_processed_auto
else "output_sent"
)
res = True
finally:
exchange_record.write(
{
"edi_exchange_state": state,
"exchange_error": error,
# FIXME: this should come from _compute_exchanged_on
# but somehow it's failing in send tests (in record tests it works).
"exchanged_on": fields.Datetime.now(),
}
)
if message:
exchange_record._notify_related_record(message)
return res
def _swallable_exceptions(self):
# TODO: improve this list
return (
ValueError,
FileNotFoundError,
exceptions.UserError,
exceptions.ValidationError,
)
def _output_check_send(self, exchange_record):
if exchange_record.direction != "output":
raise exceptions.UserError(
_("Record ID=%d is not meant to be sent!") % exchange_record.id
)
if not exchange_record.exchange_file:
raise exceptions.UserError(
_("Record ID=%d has no file to send!") % exchange_record.id
)
return exchange_record.edi_exchange_state in [
"output_pending",
"output_error_on_send",
]
def _exchange_send(self, exchange_record):
component = self._get_component(exchange_record, "send")
if component:
return component.send()
raise NotImplementedError("No handler for `_exchange_send`")
def _cron_check_output_exchange_sync(self, **kw):
for backend in self:
backend._check_output_exchange_sync(**kw)
# TODO: consider splitting cron in 2 (1 for receiving, 1 for processing)
def _check_output_exchange_sync(self, skip_send=False):
"""Lookup for pending output records and take care of them.
First work on records that need output generation.
Then work on records waiting for a state update.
:param skip_send: only generate missing output.
"""
# Generate output files
new_records = self.exchange_record_model.search(
self._output_new_records_domain()
)
_logger.info(
"EDI Exchange output sync: found %d new records to process.",
len(new_records),
)
for rec in new_records:
rec.with_delay().action_exchange_generate()
if skip_send:
return
pending_records = self.exchange_record_model.search(
self._output_pending_records_domain()
)
_logger.info(
"EDI Exchange output sync: found %d pending records to process.",
len(pending_records),
)
for rec in pending_records:
if rec.edi_exchange_state == "output_pending":
rec.with_delay().action_exchange_send()
else:
# TODO: run in job as well?
self._exchange_output_check_state(rec)
self._exchange_check_ack_needed(pending_records)
def _output_new_records_domain(self):
"""Domain for output records needing output content generation."""
return [
("backend_id", "=", self.id),
("type_id.exchange_file_auto_generate", "=", True),
("type_id.direction", "=", "output"),
("edi_exchange_state", "=", "new"),
("exchange_file", "=", False),
]
def _output_pending_records_domain(self):
"""Domain for output records needing to be sent or have errors or
ack to handle."""
states = ("output_pending", "output_sent", "output_sent_and_error")
return [
("type_id.direction", "=", "output"),
("backend_id", "=", self.id),
("edi_exchange_state", "in", states),
]
def _exchange_output_check_state(self, exchange_record):
component = self._get_component(exchange_record, "check")
if component:
return component.check()
raise NotImplementedError("No handler for `_exchange_output_check_state`")
def _exchange_process_check(self, exchange_record):
if not exchange_record.direction == "input":
raise exceptions.UserError(
_("Record ID=%d is not meant to be processed") % exchange_record.id
)
if not exchange_record.exchange_file:
raise exceptions.UserError(
_("Record ID=%d has no file to process!") % exchange_record.id
)
return exchange_record.edi_exchange_state in [
"input_received",
"input_processed_error",
]
def exchange_process(self, exchange_record):
"""Process an incoming document."""
self.ensure_one()
exchange_record.ensure_one()
# In case already processed: skip processing and check the state
check = self._exchange_process_check(exchange_record)
if not check:
return False
state = exchange_record.edi_exchange_state
error = False
try:
self._exchange_process(exchange_record)
except self._swallable_exceptions() as err:
if self.env.context.get("_edi_process_break_on_error"):
raise
error = _get_exception_msg(err)
state = "input_processed_error"
res = False
else:
error = None
state = "input_processed"
res = True
finally:
exchange_record.write(
{
"edi_exchange_state": state,
"exchange_error": error,
# FIXME: this should come from _compute_exchanged_on
# but somehow it's failing in send tests (in record tests it works).
"exchanged_on": fields.Datetime.now(),
}
)
if state == "input_processed_error":
exchange_record._notify_error("process_ko")
elif state == "input_processed":
exchange_record._notify_done()
return res
def _exchange_process(self, exchange_record):
component = self._get_component(exchange_record, "process")
if component:
return component.process()
raise NotImplementedError()
def exchange_receive(self, exchange_record):
"""Retrieve an incoming document."""
self.ensure_one()
exchange_record.ensure_one()
# In case already processed: skip processing and check the state
check = self._exchange_receive_check(exchange_record)
if not check:
return False
state = exchange_record.edi_exchange_state
error = False
message = None
content = None
try:
content = self._exchange_receive(exchange_record)
if content:
exchange_record._set_file_content(content)
self._validate_data(exchange_record)
except EDIValidationError as err:
error = _get_exception_msg(err)
state = "validate_error"
message = exchange_record._exchange_status_message("validate_ko")
res = False
except self._swallable_exceptions() as err:
if self.env.context.get("_edi_receive_break_on_error"):
raise
error = _get_exception_msg(err)
state = "input_receive_error"
message = exchange_record._exchange_status_message("receive_ko")
res = False
else:
message = exchange_record._exchange_status_message("receive_ok")
error = None
state = "input_received"
res = True
finally:
exchange_record.write(
{
"edi_exchange_state": state,
"exchange_error": error,
# FIXME: this should come from _compute_exchanged_on
# but somehow it's failing in send tests (in record tests it works).
"exchanged_on": fields.Datetime.now(),
}
)
if message:
exchange_record._notify_related_record(message)
return res
def _exchange_receive_check(self, exchange_record):
# TODO: use `filtered_domain` + _input_pending_records_domain
# and raise one single error
# do the same for all the other check cases.
if not exchange_record.direction == "input":
raise exceptions.UserError(
_("Record ID=%d is not meant to be processed") % exchange_record.id
)
return exchange_record.edi_exchange_state in [
"input_pending",
"input_receive_error",
]
def _exchange_receive(self, exchange_record):
component = self._get_component(exchange_record, "receive")
if component:
return component.receive()
raise NotImplementedError()
def _cron_check_input_exchange_sync(self, **kw):
for backend in self:
backend._check_input_exchange_sync(**kw)
# TODO: add tests
# TODO: consider splitting cron in 2 (1 for receiving, 1 for processing)
def _check_input_exchange_sync(self, **kw):
"""Lookup for pending input records and take care of them.
First work on records that need to receive input.
Then work on records waiting to be processed.
"""
pending_records = self.exchange_record_model.search(
self._input_pending_records_domain()
)
_logger.info(
"EDI Exchange input sync: found %d pending records to receive.",
len(pending_records),
)
for rec in pending_records:
rec.with_delay().action_exchange_receive()
pending_process_records = self.exchange_record_model.search(
self._input_pending_process_records_domain()
)
_logger.info(
"EDI Exchange input sync: found %d pending records to process.",
len(pending_process_records),
)
for rec in pending_process_records:
rec.with_delay().action_exchange_process()
# TODO: test it!
self._exchange_check_ack_needed(pending_process_records)
def _input_pending_records_domain(self):
return [
("backend_id", "=", self.id),
("type_id.direction", "=", "input"),
("edi_exchange_state", "=", "input_pending"),
("exchange_file", "=", False),
]
def _input_pending_process_records_domain(self):
states = ("input_received", "input_processed_error")
return [
("backend_id", "=", self.id),
("type_id.direction", "=", "input"),
("edi_exchange_state", "in", states),
]
def _exchange_check_ack_needed(self, pending_records):
ack_pending_records = pending_records.filtered(lambda x: x.needs_ack())
_logger.info(
"EDI Exchange output sync: found %d records needing ack record.",
len(ack_pending_records),
)
for rec in ack_pending_records:
rec.with_delay().exchange_create_ack_record()
def _find_existing_exchange_records(
self, exchange_type, extra_domain=None, count_only=False
):
domain = [
("backend_id", "=", self.id),
("type_id", "=", exchange_type.id),
] + extra_domain or []
return self.env["edi.exchange.record"].search(domain, count=count_only)
def action_view_exchanges(self):
xmlid = "edi_oca.act_open_edi_exchange_record_view"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["context"] = {
"search_default_backend_id": self.id,
"default_backend_id": self.id,
"default_backend_type_id": self.backend_type_id.id,
}
return action
def action_view_exchange_types(self):
xmlid = "edi_oca.act_open_edi_exchange_type_view"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["context"] = {
"search_default_backend_id": self.id,
"default_backend_id": self.id,
"default_backend_type_id": self.backend_type_id.id,
}
return action
def _is_valid_edi_action(self, action, raise_if_not=False):
try:
assert action in ("generate", "send", "process", "receive", "check")
return True
except AssertionError:
if raise_if_not:
raise
return False
| 37.750395 | 23,896 |
6,891 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# Copyright 2021 Camptocamp SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from datetime import datetime
from pytz import timezone, utc
from odoo import _, api, exceptions, fields, models
from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT as DATETIME_FORMAT
from odoo.addons.base_sparse_field.models.fields import Serialized
from odoo.addons.http_routing.models.ir_http import slugify
_logger = logging.getLogger(__name__)
try:
import yaml
except ImportError:
_logger.debug("`yaml` lib is missing")
class EDIExchangeType(models.Model):
"""
Define a kind of exchange.
"""
_name = "edi.exchange.type"
_description = "EDI Exchange Type"
backend_id = fields.Many2one(
string="Backend",
comodel_name="edi.backend",
ondelete="set null",
)
backend_type_id = fields.Many2one(
string="Backend type",
comodel_name="edi.backend.type",
required=True,
ondelete="restrict",
)
job_channel_id = fields.Many2one(
comodel_name="queue.job.channel",
)
name = fields.Char(required=True)
code = fields.Char(required=True)
direction = fields.Selection(
selection=[("input", "Input"), ("output", "Output")], required=True
)
exchange_filename_pattern = fields.Char(default="{record_name}-{type.code}-{dt}")
# TODO make required if exchange_filename_pattern is
exchange_file_ext = fields.Char()
exchange_file_auto_generate = fields.Boolean(
help="Auto generate output for records missing their payload. "
"If active, a cron will take care of generating the output when not set yet. "
)
ack_type_id = fields.Many2one(
string="Ack exchange type",
comodel_name="edi.exchange.type",
ondelete="set null",
help="Identify the type of the ack. "
"If this field is valued it means an hack is expected.",
)
advanced_settings_edit = fields.Text(
string="Advanced YAML settings",
help="""
Advanced technical settings as YAML format.
The YAML structure should reproduce a dictionary.
The backend might use these settings for automated operations.
Currently supported conf:
components:
generate:
usage: $comp_usage
# set a value for component work context
work_ctx:
opt1: True
validate:
usage: $comp_usage
env_ctx:
# set a value for the whole processing env
opt2: False
check:
usage: $comp_usage
send:
usage: $comp_usage
receive:
usage: $comp_usage
process:
usage: $comp_usage
filename_pattern:
force_tz: Europe/Rome
date_pattern: %Y-%m-%d-%H-%M-%S
In any case, you can use these settings
to provide your own configuration for whatever need you might have.
""",
)
advanced_settings = Serialized(default={}, compute="_compute_advanced_settings")
model_ids = fields.Many2many(
"ir.model",
help="""Modules to be checked for manual EDI generation""",
)
enable_domain = fields.Char(
string="Enable on domain", help="""Filter domain to be checked on Models"""
)
enable_snippet = fields.Char(
string="Enable on snippet",
help="""Snippet of code to be checked on Models,
You can use `record` and `exchange_type` here.
It will be executed if variable result has been defined as True
""",
)
model_manual_btn = fields.Boolean(
string="Manual button on form",
help="Automatically display a button on related models' form."
# TODO: "Button settings can be configured via advanced settings."
)
_sql_constraints = [
(
"code_uniq",
"unique(code, backend_id)",
"The code must be unique per backend",
)
]
@api.depends("advanced_settings_edit")
def _compute_advanced_settings(self):
for rec in self:
rec.advanced_settings = rec._load_advanced_settings()
def _load_advanced_settings(self):
# TODO: validate settings w/ a schema.
# Could be done w/ Cerberus or JSON-schema.
# This would help documenting core and custom keys.
return yaml.safe_load(self.advanced_settings_edit or "") or {}
def get_settings(self):
return self.advanced_settings
@api.constrains("backend_id", "backend_type_id")
def _check_backend(self):
for rec in self:
if not rec.backend_id:
continue
if rec.backend_id.backend_type_id != rec.backend_type_id:
raise exceptions.UserError(_("Backend should respect backend type!"))
def _make_exchange_filename_datetime(self):
"""
Returns current datetime (now) using filename pattern
which can be set using advanced settings.
Example:
filename_pattern:
force_tz: Europe/Rome
date_pattern: %Y-%m-%d-%H-%M-%S
"""
self.ensure_one()
pattern_settings = self.advanced_settings.get("filename_pattern", {})
force_tz = pattern_settings.get("force_tz", self.env.user.tz)
date_pattern = pattern_settings.get("date_pattern", DATETIME_FORMAT)
tz = timezone(force_tz) if force_tz else None
now = datetime.now(utc).astimezone(tz)
return slugify(now.strftime(date_pattern))
def _make_exchange_filename(self, exchange_record):
"""Generate filename."""
pattern = self.exchange_filename_pattern
ext = self.exchange_file_ext
pattern = pattern + ".{ext}"
dt = self._make_exchange_filename_datetime()
record_name = self._get_record_name(exchange_record)
record = exchange_record
if exchange_record.model and exchange_record.res_id:
record = exchange_record.record
return pattern.format(
exchange_record=exchange_record,
record=record,
record_name=record_name,
type=self,
dt=dt,
ext=ext,
)
def _get_record_name(self, exchange_record):
if not exchange_record.res_id or not exchange_record.model:
return slugify(exchange_record.display_name)
if hasattr(exchange_record.record, "_get_edi_exchange_record_name"):
return exchange_record.record._get_edi_exchange_record_name(exchange_record)
return slugify(exchange_record.record.display_name)
| 35.158163 | 6,891 |
402 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Camptocamp SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class EDIIdMixin(models.AbstractModel):
"""Mixin to expose identifier's features"""
_name = "edi.id.mixin"
_description = "EDI ID mixin"
edi_id = fields.Char(help="Internal or external identifier for records.")
| 28.714286 | 402 |
18,024 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# Copyright 2021 Camptocamp SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import base64
from collections import defaultdict
from odoo import _, api, exceptions, fields, models
class EDIExchangeRecord(models.Model):
"""
Define an exchange record.
"""
_name = "edi.exchange.record"
_inherit = "mail.thread"
_description = "EDI exchange Record"
_order = "exchanged_on desc"
_rec_name = "identifier"
identifier = fields.Char(required=True, index=True, readonly=True)
external_identifier = fields.Char(index=True, readonly=True)
type_id = fields.Many2one(
string="Exchange type",
comodel_name="edi.exchange.type",
required=True,
ondelete="cascade",
auto_join=True,
)
direction = fields.Selection(related="type_id.direction")
backend_id = fields.Many2one(comodel_name="edi.backend", required=True)
model = fields.Char(index=True, required=False, readonly=True)
res_id = fields.Many2oneReference(
string="Record",
index=True,
required=False,
readonly=True,
model_field="model",
)
related_name = fields.Char(compute="_compute_related_name", compute_sudo=True)
exchange_file = fields.Binary(attachment=True)
exchange_filename = fields.Char(
compute="_compute_exchange_filename", readonly=False, store=True
)
exchanged_on = fields.Datetime(
help="Sent or received on this date.",
compute="_compute_exchanged_on",
store=True,
readonly=False,
)
edi_exchange_state = fields.Selection(
string="Exchange state",
readonly=True,
default="new",
selection=[
# Common states
("new", "New"),
("validate_error", "Error on validation"),
# output exchange states
("output_pending", "Waiting to be sent"),
("output_error_on_send", "error on send"),
("output_sent", "Sent"),
("output_sent_and_processed", "Sent and processed"),
("output_sent_and_error", "Sent and error"),
# input exchange states
("input_pending", "Waiting to be received"),
("input_received", "Received"),
("input_receive_error", "Error on reception"),
("input_processed", "Processed"),
("input_processed_error", "Error on process"),
],
)
exchange_error = fields.Text(readonly=True)
# Relations w/ other records
parent_id = fields.Many2one(
comodel_name="edi.exchange.record",
help="Original exchange which originated this record",
)
related_exchange_ids = fields.One2many(
string="Related records",
comodel_name="edi.exchange.record",
inverse_name="parent_id",
)
ack_expected = fields.Boolean(compute="_compute_ack_expected")
# TODO: shall we add a constrain on the direction?
# In theory if the record is outgoing the ack should be incoming and vice versa.
ack_exchange_id = fields.Many2one(
string="ACK exchange",
comodel_name="edi.exchange.record",
help="ACK for this exchange",
compute="_compute_ack_exchange_id",
store=True,
)
ack_received_on = fields.Datetime(
string="ACK received on", related="ack_exchange_id.exchanged_on"
)
retryable = fields.Boolean(
compute="_compute_retryable",
help="The record state can be rolled back manually in case of failure.",
)
_sql_constraints = [
("identifier_uniq", "unique(identifier)", "The identifier must be unique."),
(
"external_identifier_uniq",
"unique(external_identifier, backend_id, type_id)",
"The external_identifier must be unique for a type and a backend.",
),
]
@api.depends("model", "res_id")
def _compute_related_name(self):
for rec in self:
related_record = rec.record
rec.related_name = related_record.display_name if related_record else ""
@api.depends("model", "type_id")
def _compute_exchange_filename(self):
for rec in self:
if not rec.type_id:
continue
if not rec.exchange_filename:
rec.exchange_filename = rec.type_id._make_exchange_filename(rec)
@api.depends("edi_exchange_state")
def _compute_exchanged_on(self):
for rec in self:
if rec.edi_exchange_state in ("input_received", "output_sent"):
rec.exchanged_on = fields.Datetime.now()
@api.constrains("edi_exchange_state")
def _constrain_edi_exchange_state(self):
for rec in self:
if rec.edi_exchange_state in ("new", "validate_error"):
continue
if not rec.edi_exchange_state.startswith(rec.direction):
raise exceptions.ValidationError(
_("Exchange state must respect direction!")
)
@api.depends("related_exchange_ids.type_id")
def _compute_ack_exchange_id(self):
for rec in self:
rec.ack_exchange_id = rec._get_ack_record()
def _get_ack_record(self):
if not self.type_id.ack_type_id:
return None
return self.related_exchange_ids.filtered(
lambda x: x.type_id == self.type_id.ack_type_id
)
def _compute_ack_expected(self):
for rec in self:
rec.ack_expected = bool(self.type_id.ack_type_id)
def needs_ack(self):
return self.type_id.ack_type_id and not self.ack_exchange_id
_rollback_state_mapping = {
# From: to
"output_error_on_send": "output_pending",
"output_sent_and_error": "output_pending",
"input_receive_error": "input_pending",
"input_processed_error": "input_received",
}
def _compute_retryable(self):
for rec in self:
rec.retryable = rec.edi_exchange_state in self._rollback_state_mapping
@property
def record(self):
# In some case the res_model (and res_id) could be empty so we have to load
# data from parent
if not self.model and not self.parent_id:
return None
if not self.model and self.parent_id:
return self.parent_id.record
return self.env[self.model].browse(self.res_id).exists()
def _set_file_content(
self, output_string, encoding="utf-8", field_name="exchange_file"
):
"""Handy method to no have to convert b64 back and forth."""
self.ensure_one()
if not isinstance(output_string, bytes):
output_string = bytes(output_string, encoding)
self[field_name] = base64.b64encode(output_string)
def _get_file_content(self, field_name="exchange_file", binary=True):
"""Handy method to not have to convert b64 back and forth."""
self.ensure_one()
if not self[field_name]:
return ""
if binary:
return base64.b64decode(self[field_name]).decode()
return self[field_name]
def name_get(self):
result = []
for rec in self:
rec_name = rec.identifier
if rec.res_id and rec.model:
rec_name = rec.record.display_name
name = "[{}] {}".format(rec.type_id.name, rec_name)
result.append((rec.id, name))
return result
@api.model
def create(self, vals):
vals["identifier"] = self._get_identifier()
return super().create(vals)
def _get_identifier(self):
return self.env["ir.sequence"].next_by_code("edi.exchange")
@api.constrains("backend_id", "type_id")
def _constrain_backend(self):
for rec in self:
if rec.type_id.backend_id:
if rec.type_id.backend_id != rec.backend_id:
raise exceptions.ValidationError(
_("Backend must match with exchange type's backend!")
)
else:
if rec.type_id.backend_type_id != rec.backend_id.backend_type_id:
raise exceptions.ValidationError(
_("Backend type must match with exchange type's backend type!")
)
@property
def _exchange_status_messages(self):
return {
# status: message
"send_ok": _("Exchange sent"),
"send_ko": _(
"An error happened while sending. Please check exchange record info."
),
"process_ok": _("Exchange processed successfully "),
"process_ko": _("Exchange processed with errors"),
"receive_ok": _("Exchange received successfully "),
"receive_ko": _("Exchange not received"),
"ack_received": _("ACK file received."),
"ack_missing": _("ACK file is required for this exchange but not found."),
"ack_received_error": _("ACK file received but contains errors."),
"validate_ko": _("Exchange not valid"),
}
def _exchange_status_message(self, key):
return self._exchange_status_messages[key]
def action_exchange_generate(self, **kw):
self.ensure_one()
return self.backend_id.exchange_generate(self, **kw)
def action_exchange_send(self):
self.ensure_one()
return self.backend_id.exchange_send(self)
def action_exchange_process(self):
self.ensure_one()
return self.backend_id.exchange_process(self)
def action_exchange_receive(self):
self.ensure_one()
return self.backend_id.exchange_receive(self)
def exchange_create_ack_record(self, **kw):
return self.exchange_create_child_record(
exc_type=self.type_id.ack_type_id, **kw
)
def exchange_create_child_record(self, exc_type=None, **kw):
exc_type = exc_type or self.type_id
values = self._exchange_child_record_values()
values.update(**kw)
return self.backend_id.create_record(exc_type.code, values)
def _exchange_child_record_values(self):
return {
"parent_id": self.id,
"model": self.model,
"res_id": self.res_id,
}
def action_retry(self):
for rec in self:
rec._retry_exchange_action()
def _retry_exchange_action(self):
"""Move back to precedent state to retry exchange action if failed."""
if not self.retryable:
return False
new_state = self._rollback_state_mapping[self.edi_exchange_state]
fname = "edi_exchange_state"
self[fname] = new_state
display_state = self._fields[fname].convert_to_export(self[fname], self)
self.message_post(
body=_("Action retry: state moved back to '%s'") % display_state
)
return True
def action_open_related_record(self):
self.ensure_one()
if not self.model or not self.res_id:
return {}
return self.record.get_formview_action()
def _set_related_record(self, odoo_record):
self.update({"model": odoo_record._name, "res_id": odoo_record.id})
def action_open_related_exchanges(self):
self.ensure_one()
if not self.related_exchange_ids:
return {}
xmlid = "edi_oca.act_open_edi_exchange_record_view"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["domain"] = [("id", "in", self.related_exchange_ids.ids)]
return action
def _notify_related_record(self, message, level="info"):
"""Post notification on the original record."""
if not hasattr(self.record, "message_post_with_view"):
return
self.record.message_post_with_view(
"edi_oca.message_edi_exchange_link",
values={
"backend": self.backend_id,
"exchange_record": self,
"message": message,
"level": level,
},
subtype_id=self.env.ref("mail.mt_note").id,
)
def _trigger_edi_event_make_name(self, name, suffix=None):
return "on_edi_exchange_{name}{suffix}".format(
name=name,
suffix=("_" + suffix) if suffix else "",
)
def _trigger_edi_event(self, name, suffix=None, **kw):
"""Trigger a component event linked to this backend and edi exchange."""
name = self._trigger_edi_event_make_name(name, suffix=suffix)
self._event(name).notify(self, **kw)
def _notify_done(self):
self._notify_related_record(self._exchange_status_message("process_ok"))
self._trigger_edi_event("done")
def _notify_error(self, message_key):
self._notify_related_record(
self._exchange_status_message(message_key),
level="error",
)
self._trigger_edi_event("error")
def _notify_ack_received(self):
self._notify_related_record(self._exchange_status_message("ack_received"))
self._trigger_edi_event("done", suffix="ack_received")
def _notify_ack_missing(self):
self._notify_related_record(
self._exchange_status_message("ack_missing"),
level="warning",
)
self._trigger_edi_event("done", suffix="ack_missing")
def _notify_ack_received_error(self):
self._notify_related_record(
self._exchange_status_message("ack_received_error"),
)
self._trigger_edi_event("done", suffix="ack_received_error")
@api.model
def _search(
self,
args,
offset=0,
limit=None,
order=None,
count=False,
access_rights_uid=None,
):
ids = super()._search(
args,
offset=offset,
limit=limit,
order=order,
count=False,
access_rights_uid=access_rights_uid,
)
if self.env.is_superuser():
# rules do not apply for the superuser
return len(ids) if count else ids
if not ids:
return 0 if count else []
orig_ids = ids
ids = set(ids)
result = []
model_data = defaultdict(
lambda: defaultdict(set)
) # {res_model: {res_id: set(ids)}}
for sub_ids in self._cr.split_for_in_conditions(ids):
self._cr.execute(
"""
SELECT id, res_id, model
FROM "%s"
WHERE id = ANY (%%(ids)s)"""
% self._table,
dict(ids=list(sub_ids)),
)
for eid, res_id, model in self._cr.fetchall():
if not model:
result.append(eid)
continue
model_data[model][res_id].add(eid)
for model, targets in model_data.items():
if not self.env[model].check_access_rights("read", False):
continue
target_ids = list(targets)
allowed = (
self.env[model]
.with_context(active_test=False)
._search([("id", "in", target_ids)])
)
for target_id in allowed:
result += list(targets[target_id])
if len(orig_ids) == limit and len(result) < len(orig_ids):
result.extend(
self._search(
args,
offset=offset + len(orig_ids),
limit=limit,
order=order,
count=count,
access_rights_uid=access_rights_uid,
)[: limit - len(result)]
)
# Restore original ordering
result = [x for x in orig_ids if x in result]
return len(result) if count else list(result)
def read(self, fields=None, load="_classic_read"):
"""Override to explicitely call check_access_rule, that is not called
by the ORM. It instead directly fetches ir.rules and apply them."""
self.check_access_rule("read")
return super().read(fields=fields, load=load)
def check_access_rule(self, operation):
"""In order to check if we can access a record, we are checking if we can access
the related document"""
super(EDIExchangeRecord, self).check_access_rule(operation)
if self.env.is_superuser():
return
default_checker = self.env["edi.exchange.consumer.mixin"].get_edi_access
by_model_rec_ids = defaultdict(set)
by_model_checker = {}
for exc_rec in self.sudo():
if not exc_rec.model or not exc_rec.res_id:
continue
by_model_rec_ids[exc_rec.model].add(exc_rec.res_id)
if exc_rec.model not in by_model_checker:
by_model_checker[exc_rec.model] = getattr(
self.env[exc_rec.model], "get_edi_access", default_checker
)
for model, rec_ids in by_model_rec_ids.items():
records = self.env[model].browse(rec_ids).with_user(self._uid)
checker = by_model_checker[model]
for record in records:
check_operation = checker(
[record.id], operation, model_name=record._name
)
record.check_access_rights(check_operation)
record.check_access_rule(check_operation)
def write(self, vals):
self.check_access_rule("write")
return super().write(vals)
def _job_delay_params(self):
params = {}
channel = self.type_id.sudo().job_channel_id
if channel:
params["channel"] = channel.complete_name
return params
def with_delay(self, **kw):
params = self._job_delay_params()
params.update(kw)
return super().with_delay(**params)
| 36.265594 | 18,024 |
620 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import AbstractComponent
class EDIBackendInputComponentMixin(AbstractComponent):
"""Generate input content."""
_name = "edi.component.input.mixin"
_inherit = "edi.component.mixin"
def process(self):
raise NotImplementedError()
class EDIBackendReceiveComponentMixin(AbstractComponent):
_name = "edi.component.receive.mixin"
_inherit = "edi.component.mixin"
def receive(self):
raise NotImplementedError()
| 25.833333 | 620 |
624 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import AbstractComponent
class EDIBackendValidateComponentMixin(AbstractComponent):
"""Validate exchange data."""
_name = "edi.component.validate.mixin"
_inherit = "edi.component.mixin"
_usage = "edi.validate.*"
def validate(self, value=None):
self._validate(value)
def _validate(self, value=None):
"""Return None validated, raise `edi.exceptions.EDIValidationError` if not."""
raise NotImplementedError()
| 31.2 | 624 |
2,267 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import AbstractComponent
class EDIBackendComponentMixin(AbstractComponent):
"""Generic mixin for all EDI components."""
_name = "edi.component.base.mixin"
_collection = "edi.backend"
_usage = None
_backend_type = None
_exchange_type = None
def __init__(self, work_context):
super().__init__(work_context)
self.backend = work_context.backend
@staticmethod
def _match_attrs():
"""Attributes to be used for matching this component.
By default, match by backend and exchange type.
NOTE: the class attribute must have an underscore, the name here not.
"""
return ("backend_type", "exchange_type")
@classmethod
def _component_match(cls, work, usage=None, model_name=None, **kw):
"""Override to customize match.
Registry lookup filtered by usage and model_name when landing here.
Now, narrow match to `_match_attrs` attributes.
"""
match_attrs = cls._match_attrs()
if not any([kw.get(k) for k in match_attrs]):
# No attr to check
return True
backend_type = kw.get("backend_type")
exchange_type = kw.get("exchange_type")
if cls._backend_type and cls._exchange_type:
# They must match both
return (
cls._backend_type == backend_type
and cls._exchange_type == exchange_type
)
if cls._backend_type not in (None, kw.get("backend_type")):
return False
if cls._exchange_type not in (None, kw.get("exchange_type")):
return False
return True
class EDIBackendRecordComponentMixin(AbstractComponent):
"""Generic mixin for record-bound components."""
_name = "edi.component.mixin"
_inherit = "edi.component.base.mixin"
def __init__(self, work_context):
super().__init__(work_context)
self.exchange_record = work_context.exchange_record
self.record = self.exchange_record.record
self.type_settings = self.exchange_record.type_id.get_settings()
| 31.486111 | 2,267 |
944 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import AbstractComponent
class EDIBackendOutputComponentMixin(AbstractComponent):
"""Generate output content."""
_name = "edi.component.output.mixin"
_inherit = "edi.component.mixin"
_usage = "edi.output.generate.*"
def generate(self):
raise NotImplementedError()
class EDIBackendSendComponentMixin(AbstractComponent):
"""Send output records."""
_name = "edi.component.send.mixin"
_inherit = "edi.component.mixin"
_usage = "edi.output.send.*"
def send(self):
raise NotImplementedError()
class EDIBackendCheckComponentMixin(AbstractComponent):
_name = "edi.component.check.mixin"
_inherit = "edi.component.mixin"
_usage = "edi.output.check.*"
def check(self):
raise NotImplementedError()
| 25.513514 | 944 |
955 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class EdiExchangeRecordCreateWiz(models.TransientModel):
_name = "edi.exchange.record.create.wiz"
_description = "Create an Exchange Record"
res_id = fields.Integer(required=True)
model = fields.Char(required=True)
exchange_type_id = fields.Many2one("edi.exchange.type", required=True)
backend_type_id = fields.Many2one(
"edi.backend.type", related="exchange_type_id.backend_type_id"
)
backend_id = fields.Many2one("edi.backend", required=True)
def create_edi(self):
record = self.env[self.model].browse(self.res_id)
exchange_record = record._edi_create_exchange_record(
self.exchange_type_id, self.backend_id
)
record._event("on_edi_generate_manual").notify(record, exchange_record)
return exchange_record.get_formview_action()
| 38.2 | 955 |
623 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "EDI Exchange Template",
"summary": """Allows definition of exchanges via templates.""",
"version": "15.0.1.0.1",
"development_status": "Beta",
"license": "LGPL-3",
"author": "ACSONE,Odoo Community Association (OCA)",
"maintainers": ["simahawk"],
"website": "https://github.com/OCA/edi",
"depends": ["edi_oca", "component"],
"data": [
"security/ir_model_access.xml",
"views/edi_exchange_template_output_views.xml",
],
}
| 32.789474 | 623 |
1,341 |
py
|
PYTHON
|
15.0
|
from lxml import etree
from odoo.tools import pycompat
def xml_purge_nswrapper(xml_content):
"""Purge `nswrapper` elements.
QWeb template does not allow parsing namespaced elements
without declaring namespaces on the root element.
Hence, by default you cannot define smaller re-usable templates
if the have namespaced elements.
The trick is to wrap your reusable template with `nswrapper` element
which holds the namespace for that particular sub template.
For instance:
<nswrapper xmlns:foo="http://www.unece.org/cefact/Foo">
<foo:LovelyNamespacedElement />
</nswrapper>
Then this method is going to purge these unwanted elements from the result.
"""
if not (xml_content and xml_content.strip()):
return xml_content
root = etree.XML(xml_content)
# deeper elements come after, keep the root element at the end (if any)
for nswrapper in reversed(root.xpath("//nswrapper")):
parent = nswrapper.getparent()
if parent is None:
# fmt:off
return "".join([
pycompat.to_text(etree.tostring(el))
for el in nswrapper.getchildren()
])
# fmt:on
parent.extend(nswrapper.getchildren())
parent.remove(nswrapper)
return etree.tostring(root)
| 33.525 | 1,341 |
6,025 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA/NV (<http://acsone.eu>)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
import base64
from lxml import etree
from odoo.addons.edi_oca.tests.common import EDIBackendCommonComponentTestCase
class TestEDIBackendOutputBase(EDIBackendCommonComponentTestCase):
@classmethod
def _setup_records(cls):
res = super()._setup_records()
cls.type_out1 = cls._create_exchange_type(
name="Template output 1",
direction="output",
code="test_type_out1",
exchange_file_ext="txt",
exchange_filename_pattern="{record.ref}-{type.code}-{dt}",
)
model = cls.env["edi.exchange.template.output"]
qweb_tmpl = cls.env["ir.ui.view"].create(
{
"type": "qweb",
"key": "edi_exchange.test_output1",
"arch": """
<t t-name="edi_exchange.test_output1">
<t t-esc="record.ref" /> - <t t-esc="record.name" />
</t>
""",
}
)
cls.tmpl_out1 = model.create(
{
"code": "edi.output.generate.demo_backend.test_type_out1",
"name": "Out 1",
"backend_type_id": cls.backend.backend_type_id.id,
"type_id": cls.type_out1.id,
"template_id": qweb_tmpl.id,
"output_type": "txt",
}
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
"type_id": cls.type_out1.id,
}
cls.record1 = cls.backend.create_record("test_type_out1", vals)
cls.type_out2 = cls._create_exchange_type(
name="Template output 2",
direction="output",
code="test_type_out2",
exchange_file_ext="xml",
exchange_filename_pattern="{record.ref}-{type.code}-{dt}",
)
qweb_tmpl = cls.env["ir.ui.view"].create(
{
"type": "qweb",
"key": "edi_exchange.test_output2",
"arch": """
<t t-name="edi_exchange.test_output2">
<t t-name="edi_exchange.test_output2">
<Record t-att-ref="record.ref">
<Name t-esc="record.name" />
<Custom t-att-bit="custom_bit" t-esc="baz"/>
</Record>
</t>
</t>
""",
}
)
cls.tmpl_out2 = model.create(
{
"code": "edi.output.generate.demo_backend.test_type_out2",
"name": "Out 2",
"backend_type_id": cls.backend.backend_type_id.id,
"type_id": cls.type_out2.id,
"template_id": qweb_tmpl.id,
"output_type": "xml",
"code_snippet": """
foo = "custom_var"
baz = 2
result = {"custom_bit": foo, "baz": baz}
""",
}
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
"type_id": cls.type_out2.id,
}
cls.record2 = cls.backend.create_record("test_type_out2", vals)
cls.type_out3 = cls._create_exchange_type(
name="Template output 3",
direction="output",
code="test_type_out3",
exchange_file_ext="xml",
exchange_filename_pattern="{record.id}-{type.code}-{dt}",
)
cls.report = cls.env.ref("web.action_report_externalpreview")
cls.tmpl_out3 = model.create(
{
"code": "edi.output.generate.demo_backend.test_type_out3",
"name": "Out 3",
"backend_type_id": cls.backend.backend_type_id.id,
"type_id": cls.type_out3.id,
"generator": "report",
"report_id": cls.report.id,
"output_type": "pdf",
"code_snippet": """
result = {"res_ids": record.ids}
""",
}
)
company = cls.env.ref("base.main_company")
vals = {
"model": company._name,
"res_id": company.id,
"type_id": cls.type_out2.id,
}
cls.record3 = cls.backend.create_record("test_type_out3", vals)
return res
# TODO: add more unit tests
class TestEDIBackendOutput(TestEDIBackendOutputBase):
def test_get_template(self):
self.assertEqual(
self.backend._get_output_template(self.record1), self.tmpl_out1
)
self.assertEqual(
self.backend._get_output_template(self.record2), self.tmpl_out2
)
self.assertEqual(
self.backend._get_output_template(self.record2, code=self.tmpl_out1.code),
self.tmpl_out1,
)
def test_generate_file(self):
output = self.backend.exchange_generate(self.record1)
expected = "{0.ref} - {0.name}".format(self.partner)
self.assertEqual(output.strip(), expected)
file_content = base64.b64decode(self.record1.exchange_file).decode()
self.assertEqual(file_content.strip(), expected)
output = self.backend.exchange_generate(self.record2)
doc = etree.fromstring(output)
self.assertEqual(doc.tag, "Record")
self.assertEqual(doc.attrib, {"ref": self.partner.ref})
self.assertEqual(doc.getchildren()[0].tag, "Name")
self.assertEqual(doc.getchildren()[0].text, self.partner.name)
self.assertEqual(doc.getchildren()[1].tag, "Custom")
self.assertEqual(doc.getchildren()[1].text, "2")
self.assertEqual(doc.getchildren()[1].attrib, {"bit": "custom_var"})
def test_generate_file_report(self):
output = self.backend.exchange_generate(self.record3)
self.assertTrue(output)
self.assertEqual(
self.report._render([self.record3.res_id])[0].strip().decode("UTF-8"),
output.strip(),
)
| 37.191358 | 6,025 |
1,821 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import models
class EDIBackend(models.Model):
_inherit = "edi.backend"
def _exchange_generate(self, exchange_record, **kw):
# Template take precedence over component lookup
tmpl = self._get_output_template(exchange_record)
if tmpl:
return tmpl.exchange_generate(exchange_record, **kw)
return super()._exchange_generate(exchange_record, **kw)
@property
def output_template_model(self):
return self.env["edi.exchange.template.output"]
def _get_output_template(self, exchange_record, code=None):
"""Retrieve output templates by convention.
Template's code must match the same component usage as per normal components.
"""
search = self.output_template_model.search
# TODO: maybe we can add a m2o to output templates
# but then we would need another for input templates if they are introduced.
tmpl = None
if code:
domain = [("code", "=", code)]
return search(domain, limit=1)
for domain in self._get_output_template_domains(exchange_record):
tmpl = search(domain, limit=1)
if tmpl:
break
return tmpl
def _get_output_template_domains(self, exchange_record):
"""Retrieve domains to lookup for templates by priority."""
backend_type_leaf = [("backend_type_id", "=", self.backend_type_id.id)]
exchange_type_leaf = [("type_id", "=", exchange_record.type_id.id)]
full_match_domain = backend_type_leaf + exchange_type_leaf
partial_match_domain = backend_type_leaf
return full_match_domain, partial_match_domain
| 39.586957 | 1,821 |
3,425 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import datetime
import logging
import textwrap
import pytz
from odoo import fields, models
from odoo.tools import DotDict, safe_eval
_logger = logging.getLogger(__name__)
class EDIExchangeTemplateMixin(models.AbstractModel):
"""Define a common ground for EDI exchange templates."""
_name = "edi.exchange.template.mixin"
_description = "EDI Exchange Output Mixin"
name = fields.Char(required=True)
# TODO: make unique, autocompute slugified name
code = fields.Char(required=True, index=True)
backend_type_id = fields.Many2one(
string="EDI Backend type",
comodel_name="edi.backend.type",
ondelete="restrict",
required=True,
)
type_id = fields.Many2one(
string="EDI Exchange type",
comodel_name="edi.exchange.type",
ondelete="cascade",
auto_join=True,
)
backend_id = fields.Many2one(
comodel_name="edi.backend",
ondelete="cascade",
# TODO: default to type_id if given, validate otherwise
)
# TODO: add default content w/ comment on what you can use
code_snippet = fields.Text()
code_snippet_docs = fields.Text(
compute="_compute_code_snippet_docs",
default=lambda self: self._default_code_snippet_docs(),
)
def _compute_code_snippet_docs(self):
for rec in self:
rec.code_snippet_docs = textwrap.dedent(rec._default_code_snippet_docs())
def _default_code_snippet_docs(self):
return """
Available vars:
* datetime
* dateutil
* time
* uid
* user
* DotDict
"""
def _code_snippet_valued(self):
snippet = self.code_snippet or ""
return bool(
[
not line.startswith("#")
for line in (snippet.splitlines())
if line.strip("")
]
)
@staticmethod
def _utc_now():
return datetime.datetime.utcnow().isoformat()
@staticmethod
def _date_to_string(dt, utc=True):
if utc:
dt = dt.astimezone(pytz.UTC)
return fields.Date.to_string(dt)
def _get_code_snippet_eval_context(self):
"""Prepare the context used when evaluating python code
:returns: dict -- evaluation context given to safe_eval
"""
return {
"datetime": safe_eval.datetime,
"dateutil": safe_eval.dateutil,
"time": safe_eval.time,
"uid": self.env.uid,
"user": self.env.user,
"DotDict": DotDict,
}
def _evaluate_code_snippet(self, **render_values):
if not self._code_snippet_valued():
return {}
eval_ctx = dict(render_values, **self._get_code_snippet_eval_context())
safe_eval.safe_eval(self.code_snippet, eval_ctx, mode="exec", nocopy=True)
result = eval_ctx.get("result", {})
if not isinstance(result, dict):
_logger.error("code_snippet should return a dict into `result`")
return {}
return result
def _get_validator(self, exchange_record):
# TODO: lookup for validator (
# can be to validate received file or generated file)
pass
def validate(self, exchange_record):
pass
| 29.782609 | 3,425 |
4,949 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE SA
# @author Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from odoo import fields, models
from ..utils import xml_purge_nswrapper
_logger = logging.getLogger(__name__)
class EDIExchangeOutputTemplate(models.Model):
"""Define an output template to generate outgoing records' content."""
_name = "edi.exchange.template.output"
_inherit = "edi.exchange.template.mixin"
_description = "EDI Exchange Output Template"
generator = fields.Selection(
[("qweb", "Qweb Template"), ("report", "Report")],
required=True,
default="qweb",
)
output_type = fields.Char(required=True)
# TODO: add a good domain (maybe add a new flag or category to ir.ui.view)
# Options:
# 1. add a flag "edi_template" to ir.ui.view
# 2. set model="edi.exchange.template.output" on the view
# As templates are defined using `<template />` tag
# I'm not sure this is a good option.
# 3. what else?
template_id = fields.Many2one(
string="Qweb Template",
comodel_name="ir.ui.view",
required=False,
ondelete="restrict",
)
report_id = fields.Many2one(
comodel_name="ir.actions.report",
ondelete="restrict",
)
# TODO: find a way to prevent editing "master templates"
# This would allow editing only a copy of the original template
# so that you can always check or rollback to it.
template_arch = fields.Text(
string="QWeb arch",
related="template_id.arch_db",
readonly=False,
)
template_key = fields.Char(related="template_id.xml_id", string="Template key")
def _default_code_snippet_docs(self):
return (
super()._default_code_snippet_docs()
+ """
* exchange_record (edi.exchange.record)
* record (real odoo record related to this exchange)
* backend (current backend)
* template (current template record)
* utc_now
* date_to_string
* render_edi_template
* get_info_provider
* info
"""
)
def exchange_generate(self, exchange_record, **kw):
"""Generate output for given record using related QWeb template."""
method = "_generate_" + self.generator
try:
generator = getattr(self, method)
except AttributeError:
raise NotImplementedError(f"`{method}` not found") from AttributeError
result = generator(exchange_record, **kw)
return self._post_process_output(result)
def _generate_qweb(self, exchange_record, **kw):
tmpl = self.template_id
values = self._get_render_values(exchange_record, **kw)
return tmpl._render(values)
def _generate_report(self, exchange_record, **kw):
report = self.report_id
values = self._get_render_values(exchange_record, **kw)
res_ids = values.get("res_ids", [])
return report._render(res_ids, data=values)[0]
def _get_render_values(self, exchange_record, **kw):
"""Collect values to render current template."""
values = {
"exchange_record": exchange_record,
"record": exchange_record.record,
"backend": exchange_record.backend_id,
"template": self,
"utc_now": self._utc_now,
"date_to_string": self._date_to_string,
"render_edi_template": self._render_template,
"get_info_provider": self._get_info_provider,
"info": {},
}
values.update(self._evaluate_code_snippet(**values))
values.update(kw)
return values
def _render_template(self, exchange_record, code, **kw):
"""Render another template matching `code`.
This is very handy to render templates from other templates.
"""
tmpl = self.search([("code", "=", code)], limit=1)
tmpl.ensure_one()
return tmpl.exchange_generate(exchange_record, **kw)
def _post_process_output(self, output):
"""Post process generated output."""
if self.output_type == "xml":
# TODO: lookup for components to handle this dynamically
return xml_purge_nswrapper(output)
return output
def _get_info_provider(self, exchange_record, work_ctx=None, usage=None, **kw):
"""Retrieve component providing info to render a template.
TODO: improve this description.
TODO: add tests
"""
default_work_ctx = dict(
exchange_record=exchange_record,
record=exchange_record.record,
)
default_work_ctx.update(work_ctx or {})
usage_candidates = [usage or self.code + ".info"]
provider = exchange_record.backend_id._find_component(
usage_candidates, work_ctx=default_work_ctx, **kw
)
return provider
| 35.862319 | 4,949 |
858 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.addons.component.core import AbstractComponent
class EDIExchangeInfoMixin(AbstractComponent):
"""Abstract component mixin provide info for exchanges."""
# TODO: this should be moved to core and renamed to `data`.
# A `data` component could be used for both incoming and outgoing.
_name = "edi.info.provider.mixin"
_collection = "edi.backend"
# Enable validation of work context attributes
_work_context_validate_attrs = []
def __init__(self, work_context):
super().__init__(work_context)
for key in self._work_context_validate_attrs:
if not hasattr(work_context, key):
raise AttributeError(f"`{key}` is required for this component!")
| 37.304348 | 858 |
1,073 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 ACSONE
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import datetime
import pytz
from odoo import fields
from odoo.addons.component.core import AbstractComponent
class EDIExchangeInfoOutputMixin(AbstractComponent):
"""Abstract component mixin to generate GS1 compliant XML files."""
_name = "edi.output.mixin"
_inherit = "edi.info.provider.mixin"
# Enable validation of work context attributes
_work_context_validate_attrs = ["exchange_record"]
@property
def record(self):
return self.work.exchange_record.record
def generate_info(self):
"""Generate and return data for output info.
:return: odoo.tools.DotDict
"""
raise NotImplementedError()
# helper methods
@staticmethod
def _utc_now():
return datetime.datetime.utcnow().isoformat()
@staticmethod
def date_to_string(dt, utc=True):
if utc:
dt = dt.astimezone(pytz.UTC)
return fields.Date.to_string(dt)
| 25.547619 | 1,073 |
557 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
# TODO: move it to a simple python package under OCA umbrella?
{
"name": "PDF Helper",
"version": "15.0.1.0.0",
"category": "Tools",
"license": "LGPL-3",
"summary": "Provides helpers to work w/ PDFs",
"author": "Camptocamp, Odoo Community Association (OCA)",
"maintainers": ["simahawk", "alexis-via"],
"website": "https://github.com/OCA/edi",
"depends": [
"base",
],
}
| 30.944444 | 557 |
2,406 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2021 Akretion France
# @author: Alexis de Lattre <[email protected]>
# Copyright 2022 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
import mimetypes
from io import BytesIO
from lxml import etree
_logger = logging.getLogger(__name__)
try:
import PyPDF2
except ImportError:
_logger.debug("Cannot import PyPDF2")
class PDFParser:
def __init__(self, pdf_file):
self.pdf_file = pdf_file
def get_xml_files(self):
"""Parse PDF files to extract XML content.
:param pdf_file: binary PDF file content
:returns: a dict like {$filename: $parsed_xml_file_obj}.
"""
res = {}
with BytesIO(self.pdf_file) as fd:
xmlfiles = self._extract_xml_files(fd)
for filename, xml_obj in xmlfiles.items():
root = self._extract_xml_root(xml_obj)
if root is None or not len(root):
continue
res[filename] = root
if res:
_logger.debug("Valid XML files found in PDF: %s", list(res.keys()))
return res
def _extract_xml_files(self, fd):
pdf = PyPDF2.PdfFileReader(fd)
_logger.debug("pdf.trailer=%s", pdf.trailer)
pdf_root = pdf.trailer["/Root"]
_logger.debug("pdf_root=%s", pdf_root)
# TODO add support for /Kids
embeddedfiles = pdf_root["/Names"]["/EmbeddedFiles"]["/Names"]
i = 0
xmlfiles = {} # key = filename, value = PDF obj
for embeddedfile in embeddedfiles[:-1]:
mime_res = mimetypes.guess_type(embeddedfile)
if mime_res and mime_res[0] in ["application/xml", "text/xml"]:
xmlfiles[embeddedfile] = embeddedfiles[i + 1]
i += 1
_logger.debug("xmlfiles=%s", xmlfiles)
return xmlfiles
def _extract_xml_root(self, xml_obj):
xml_root = None
try:
xml_file_dict = xml_obj.getObject()
_logger.debug("xml_file_dict=%s", xml_file_dict)
xml_string = xml_file_dict["/EF"]["/F"].getData()
xml_root = etree.fromstring(xml_string)
except Exception as err:
# TODO: can't we catch specific exceptions?
_logger.debug("_pdf_extract_xml_root failed: %s", str(err))
return xml_root
| 34.371429 | 2,406 |
1,666 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import os
from lxml import etree
from odoo.tests.common import TransactionCase, TreeCase
from odoo.addons.pdf_helper.utils import PDFParser
def read_test_file(filename, mode="r"):
path = os.path.join(os.path.dirname(__file__), "fixtures", filename)
with open(path, mode) as thefile:
return thefile.read()
# NOTE: this class could use a bare `unittest.TestCase` as base
# but w/out TreeCase Odoo won't load these tests.
class TestPDFHelperUtils(TreeCase):
def test_parse_xml(self):
pdf_content = read_test_file("pdf_with_xml_test.pdf", mode="rb")
res = PDFParser(pdf_content).get_xml_files()
fname, xml_root = tuple(res.items())[0]
self.assertEqual(fname, "factur-x.xml")
self.assertTrue(isinstance(xml_root, etree._Element))
class TestPDFHelper(TransactionCase):
def test_parse_xml(self):
pdf_content = read_test_file("pdf_with_xml_test.pdf", mode="rb")
res = self.env["pdf.helper"].pdf_get_xml_files(pdf_content)
fname, xml_root = tuple(res.items())[0]
self.assertEqual(fname, "factur-x.xml")
self.assertTrue(isinstance(xml_root, etree._Element))
def test_parse_xml_fail(self):
with self.assertLogs(
"odoo.addons.pdf_helper.models.helper", level="ERROR"
) as log_catcher:
self.env["pdf.helper"].pdf_get_xml_files(b"")
self.assertIn(
"PDF file parsing failed: Cannot read an empty file",
log_catcher.output[0],
)
| 36.217391 | 1,666 |
1,005 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from PyPDF2.utils import PdfReadError
from odoo import models
from ..utils import PDFParser
_logger = logging.getLogger(__name__)
class PDFHelper(models.AbstractModel):
_name = "pdf.helper"
_description = "PDF Helper"
_PDF_PARSER_KLASS = PDFParser
def pdf_get_xml_files(self, pdf_file):
parser = self._PDF_PARSER_KLASS(pdf_file)
try:
return parser.get_xml_files()
except self._pdf_get_xml_files_swallable_exceptions() as err:
# TODO: can't we catch specific exceptions?
# This try/except block was added to reflect what done
# in base_business_document_import till now.
_logger.error("PDF file parsing failed: %s", str(err))
return {}
def _pdf_get_xml_files_swallable_exceptions(self):
return (KeyError, PdfReadError)
| 30.454545 | 1,005 |
574 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "EDI Backend Partner",
"summary": "Add the a partner field to EDI backend",
"version": "15.0.1.0.0",
"license": "LGPL-3",
"author": "ForgeFlow, Odoo Community Association (OCA)",
"maintainers": ["LoisRForgeFlow"],
"development_status": "Beta",
"website": "https://github.com/OCA/edi",
"depends": ["edi_oca"],
"data": ["views/res_partner_views.xml", "views/edi_backend_views.xml"],
"demo": [],
}
| 35.875 | 574 |
723 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from odoo.addons.edi_oca.tests.common import EDIBackendCommonTestCase
_logger = logging.getLogger(__name__)
class EDIBackendPartnerTestCase(EDIBackendCommonTestCase):
def test_backend_partner_link(self):
partner = self.env["res.partner"].create({"name": "TEST EDI partner"})
self.assertEqual(partner.edi_backend_count, 0)
self.backend.partner_id = partner
partner.invalidate_cache()
self.assertEqual(partner.edi_backend_count, 1)
# Dummy test for action:
res = partner.action_edi_backend()
self.assertTrue(res)
| 36.15 | 723 |
282 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class EdiBackend(models.Model):
_inherit = "edi.backend"
partner_id = fields.Many2one(comodel_name="res.partner")
| 28.2 | 282 |
1,053 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class Partner(models.Model):
_inherit = "res.partner"
edi_backend_ids = fields.One2many(
comodel_name="edi.backend",
inverse_name="partner_id",
)
edi_backend_count = fields.Integer(compute="_compute_edi_backend_count")
def _compute_edi_backend_count(self):
for rec in self:
rec.edi_backend_count = len(rec.edi_backend_ids)
def action_edi_backend(self):
xmlid = "edi_oca.act_open_edi_backend_view"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
backends = self.mapped("edi_backend_ids")
if len(backends) > 1:
action["domain"] = [("id", "in", backends.ids)]
else:
res = self.env.ref("edi_oca.edi_backend_view_form", False)
action["views"] = [(res and res.id or False, "form")]
action["res_id"] = backends.id
return action
| 35.1 | 1,053 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
1,457 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-edi",
description="Meta package for oca-edi Odoo addons",
version=version,
install_requires=[
'odoo-addon-account_einvoice_generate>=15.0dev,<15.1dev',
'odoo-addon-account_invoice_facturx>=15.0dev,<15.1dev',
'odoo-addon-base_edi>=15.0dev,<15.1dev',
'odoo-addon-base_facturx>=15.0dev,<15.1dev',
'odoo-addon-base_ubl>=15.0dev,<15.1dev',
'odoo-addon-edi_account_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_backend_partner_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_exchange_template_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_stock_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_storage_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_voxel_account_invoice_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_voxel_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_voxel_secondary_unit_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_voxel_stock_picking_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_voxel_stock_picking_secondary_unit_oca>=15.0dev,<15.1dev',
'odoo-addon-edi_webservice_oca>=15.0dev,<15.1dev',
'odoo-addon-pdf_helper>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 41.628571 | 1,457 |
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 |
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 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
608 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Edi Voxel Secondary Unit Oca",
"summary": "Add Voxel UoM code to Secondary UoM model",
"version": "15.0.1.0.0",
"category": "Hidden",
"website": "https://github.com/OCA/edi",
"author": "Tecnativa, Odoo Community Association (OCA)",
"maintainers": ["ernestotejeda"],
"license": "AGPL-3",
"depends": ["product_secondary_unit", "edi_voxel_oca"],
"data": ["views/product_secondary_unit_views.xml"],
"installable": True,
"auto_install": True,
}
| 38 | 608 |
348 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
from odoo.addons.edi_voxel_oca.models.uom_uom import VOXEL_CODE
class ProductSecondaryUnit(models.Model):
_inherit = "product.secondary.unit"
voxel_code = fields.Selection(selection=VOXEL_CODE)
| 29 | 348 |
570 |
py
|
PYTHON
|
15.0
|
# © 2016-2017 Akretion (Alexis de Lattre <[email protected]>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Base UBL",
"version": "15.0.1.0.0",
"category": "Hidden",
"license": "AGPL-3",
"summary": "Base module for Universal Business Language (UBL)",
"author": "Akretion,Onestein,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/edi",
"depends": ["uom_unece", "account_tax_unece", "base_vat"],
"external_dependencies": {"python": ["PyPDF2"]},
"installable": True,
}
| 37.933333 | 569 |
13,213 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Onestein (<https://www.onestein.eu>)
# © 2017-2020 Akretion (Alexis de Lattre <[email protected]>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import mimetypes
from io import BytesIO
from lxml import etree
from PyPDF2 import PdfFileReader
from odoo.exceptions import UserError
from odoo.tests.common import HttpCase, tagged
from odoo.tools import file_open
from odoo.addons.account.tests.common import AccountTestInvoicingCommon
@tagged("-at_install", "post_install")
class TestUblInvoice(AccountTestInvoicingCommon, HttpCase):
@classmethod
def setUpClass(cls, chart_template_ref=None):
super().setUpClass(chart_template_ref=chart_template_ref)
cls.internal_user = cls.env["res.users"].create(
{
"name": "Internal User",
"login": "[email protected]",
"email": "[email protected]",
"groups_id": [
(6, 0, cls.env.user.groups_id.ids),
(4, cls.env.ref("account.group_account_user").id),
],
"company_id": cls.company_data["company"].id,
}
)
cls.invoice_tax = cls.env["account.tax"].search(
[
("company_id", "=", cls.company_data["company"].id),
("type_tax_use", "=", "sale"),
("amount_type", "=", "percent"),
],
limit=1,
)
unece_code_list_id = cls.env["unece.code.list"].create(
{"type": "tax_categ", "name": "test", "code": "test"}
)
cls.invoice_tax.unece_categ_id = unece_code_list_id
cls.invoice_tax.unece_type_id = unece_code_list_id
cls.nsmap, cls.ns = cls.env["base.ubl"]._ubl_get_nsmap_namespace("Invoice-2")
cls.xml_root = etree.Element("Invoice", nsmap=cls.nsmap)
cls.invoice = cls.create_test_invoice(cls)
cls.invoice.partner_id.vat = "BE000000000"
cls.invoice.partner_id.street2 = "Test Street 2"
cls.invoice.partner_id.parent_id = cls.invoice.company_id.partner_id
def disable_other_embeddings(self, company):
# In a test context, we may be running with other modules from this
# same repository that have activated embedding documents that we are
# not testing. So for our tests we turn them off if we know about them.
if "xml_format_in_pdf_invoice" in company._fields:
company.xml_format_in_pdf_invoice = "none"
def test_pdf_generate(self):
self.disable_other_embeddings(self.company_data["company"])
content, doc_type = (
self.env.ref("account.account_invoices")
.with_context(no_embedded_ubl_xml=True, force_report_rendering=True)
.env.ref("account.account_invoices")
._render_qweb_pdf(self.invoice.ids)
)
self.assertTrue(content)
self.assertEqual(doc_type, "pdf")
def test_ubl_generate(self):
self.env["base.ubl"]._ubl_add_supplier_party(
False,
self.invoice.company_id,
"AccountingSupplierParty",
self.xml_root,
self.ns,
)
with self.assertRaisesRegex(AssertionError, ".*partner is wrong.*"):
self.env["base.ubl"]._ubl_add_supplier_party(
self.invoice.partner_id,
self.invoice.company_id,
"AccountingSupplierParty",
self.xml_root,
self.ns,
)
self.env["base.ubl"]._ubl_add_customer_party(
False,
self.invoice.company_id,
"AccountingCustomerParty",
self.xml_root,
self.ns,
)
self.env["base.ubl"]._ubl_add_customer_party(
self.invoice.partner_id,
False,
"AccountingCustomerParty",
self.xml_root,
self.ns,
)
with self.assertRaisesRegex(AssertionError, ".*partner is wrong.*"):
self.env["base.ubl"]._ubl_add_customer_party(
self.invoice.partner_id,
self.invoice.company_id,
"AccountingCustomerParty",
self.xml_root,
self.ns,
)
self.invoice.partner_id.commercial_partner_id = (
self.invoice.company_id.partner_id
)
self.env["base.ubl"]._ubl_add_customer_party(
self.invoice.partner_id,
self.invoice.company_id,
"AccountingCustomerParty",
self.xml_root,
self.ns,
)
def test_ubl_generate_without_partner(self):
# Should fail if company or partner fields is not provided.
with self.assertRaisesRegex(UserError, ".*Missing.*"):
self.env["base.ubl"]._ubl_add_supplier_party(
False, False, "AccountingSupplierParty", self.xml_root, self.ns
)
def test_ubl_add_party(self):
self.env["base.ubl"]._ubl_add_party(
self.invoice.partner_id,
False,
"AccountingCustomerParty",
self.xml_root,
self.ns,
)
def test_ubl_add_language(self):
self.env["base.ubl"]._ubl_add_language(
self.invoice.partner_id.lang, self.xml_root, self.ns
)
def test_ubl_add_tax_scheme(self):
tax_scheme_dict = self.env["base.ubl"]._ubl_get_tax_scheme_dict_from_partner(
self.invoice.partner_id
)
tax_category = etree.SubElement(self.xml_root, self.ns["cac"] + "TaxCategory")
self.env["base.ubl"]._ubl_add_tax_scheme(tax_scheme_dict, tax_category, self.ns)
def test_get_xml_files_from_pdf(self):
self.disable_other_embeddings(self.company_data["company"])
content, doc_type = (
self.env.ref("account.account_invoices")
.with_context(no_embedded_ubl_xml=True, force_report_rendering=True)
.env.ref("account.account_invoices")
._render_qweb_pdf(self.invoice.ids)
)
self.env["base.ubl"].get_xml_files_from_pdf(content)
def test_embed_xml_in_pdf(self):
"""
Checking two methods:
_ubl_check_xml_schema
embed_xml_in_pdf
"""
self.disable_other_embeddings(self.company_data["company"])
content, doc_type = (
self.env.ref("account.account_invoices")
.with_context(no_embedded_ubl_xml=True, force_report_rendering=True)
.env.ref("account.account_invoices")
._render_qweb_pdf(self.invoice.ids)
)
fd = BytesIO(content)
pdf = PdfFileReader(fd)
pdf_root = pdf.trailer["/Root"]
embeddedfiles = pdf_root["/Names"]["/EmbeddedFiles"]["/Names"]
i = 0
xmlfiles = {} # key = filename, value = PDF obj
for embeddedfile in embeddedfiles[:-1]:
mime_res = mimetypes.guess_type(embeddedfile)
if mime_res and mime_res[0] in ["application/xml", "text/xml"]:
xmlfiles[embeddedfile] = embeddedfiles[i + 1]
i += 1
for _filename, xml_file_dict_obj in xmlfiles.items():
xml_file_dict = xml_file_dict_obj.getObject()
xml_string = xml_file_dict["/EF"]["/F"].getData()
self.env["base.ubl"].new().embed_xml_in_pdf(
xml_string, "factur-x.xml", pdf_content=content
)
xsd_file = "base_ubl/data/xsd-{}/common/UBL-{}-{}.xsd".format(
"2.1", "CommonAggregateComponents", "2.1"
)
xsd_etree_obj = etree.parse(file_open(xsd_file))
self.env["base.ubl"].new().ubl_parse_address(xsd_etree_obj, self.ns)
self.env["base.ubl"].new().ubl_parse_delivery_details(
xsd_etree_obj, self.ns
)
self.env["base.ubl"].new().ubl_parse_incoterm(xsd_etree_obj, self.ns)
self.env["base.ubl"].new().ubl_parse_product(xsd_etree_obj, self.ns)
self.env["base.ubl"].new().ubl_parse_party(xsd_etree_obj, self.ns)
with self.assertRaisesRegex(IndexError, ".*out of range.*"):
self.env["base.ubl"].new().ubl_parse_customer_party(
xsd_etree_obj, self.ns
)
with self.assertRaisesRegex(IndexError, ".*out of range.*"):
self.env["base.ubl"].new().ubl_parse_supplier_party(
xsd_etree_obj, self.ns
)
with self.assertRaisesRegex(
UserError, ".*The UBL XML file is not valid against the official.*"
):
self.env["base.ubl"].new()._ubl_check_xml_schema(
xml_string, "Statement"
)
def test_ubl_add_line_item(self):
product = self.env.ref("product.product_product_4")
self.env["base.ubl"]._ubl_add_line_item(
1,
"test",
product,
"purchase",
2,
product.uom_id,
self.xml_root,
self.ns,
currency=self.currency_data["currency"],
price_subtotal=100,
)
product.uom_id.unece_code = False
with self.assertRaisesRegex(UserError, ".*Missing UNECE.*"):
self.env["base.ubl"]._ubl_add_line_item(
1,
"test",
product,
"purchase",
2,
product.uom_id,
self.xml_root,
self.ns,
currency=self.currency_data["currency"],
price_subtotal=100,
)
def test_ubl_add_tax_subtotal(self):
self.env["base.ubl"]._ubl_add_tax_subtotal(
100,
100,
self.invoice_tax,
self.currency_data["currency"].name,
self.xml_root,
self.ns,
)
def test_ubl_get_version(self):
with self.assertRaisesRegex(UserError, ".*The UBL XML file does not contain.*"):
self.env["base.ubl"]._ubl_get_version(self.xml_root, "Invoice", self.ns)
def test_ubl_add_party_tax_scheme(self):
self.env["base.ubl"]._ubl_add_party_tax_scheme(
self.invoice.partner_id, self.xml_root, self.ns
)
def test_ubl_add_delivery(self):
self.env["base.ubl"]._ubl_add_delivery(
self.invoice.partner_id, self.xml_root, self.ns
)
def test_ubl_add_delivery_terms(self):
self.env["base.ubl"]._ubl_add_delivery_terms(
self.invoice.invoice_incoterm_id, self.xml_root, self.ns
)
def test_ubl_add_payment_terms(self):
self.env["base.ubl"]._ubl_add_payment_terms(
self.invoice.invoice_payment_term_id, self.xml_root, self.ns
)
def create_test_invoice(
self, product=False, qty=1, price=12.42, discount=0, validate=True
):
aio = self.env["account.move"]
aao = self.env["account.account"]
company = self.company_data["company"]
account_revenue = aao.search(
[("code", "=", "707100"), ("company_id", "=", company.id)], limit=1
)
if not account_revenue:
account_revenue = aao.with_user(self.internal_user).create(
{
"code": "707100",
"name": "Product Sales - (test)",
"company_id": company.id,
"user_type_id": self.env.ref(
"account.data_account_type_revenue"
).id,
}
)
# validate invoice
if not product:
product = self.env.ref("product.product_product_4")
incoterm_id = self.env["account.incoterms"].search(
[("code", "!=", False)], limit=1
)
product.barcode = "1234567890"
invoice = aio.with_user(self.internal_user).create(
{
"partner_id": self.env.ref("base.res_partner_2").id,
"currency_id": self.currency_data["currency"].id,
"move_type": "out_invoice",
"company_id": company.id,
"name": "SO1242",
"invoice_incoterm_id": incoterm_id.id or False,
"invoice_payment_term_id": self.env.ref(
"account.account_payment_term_end_following_month"
).id,
"invoice_line_ids": [
(
0,
0,
{
"product_id": product.id,
"product_uom_id": product.uom_id.id,
"quantity": qty,
"price_unit": price,
"discount": discount,
"name": product.name,
"account_id": account_revenue.id,
"tax_ids": [(6, 0, [self.invoice_tax.id])],
},
)
],
}
)
if validate:
invoice.action_post()
return invoice
| 38.631579 | 13,212 |
35,082 |
py
|
PYTHON
|
15.0
|
# © 2016-2017 Akretion (Alexis de Lattre <[email protected]>)
# Copyright 2019 Onestein (<https://www.onestein.eu>)
# Copyright 2020 Jacques-Etienne Baudoux (BCIM) <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
import mimetypes
from io import BytesIO
from lxml import etree
from odoo import _, api, models
from odoo.exceptions import UserError
from odoo.tools import file_open, float_is_zero, float_round
logger = logging.getLogger(__name__)
try:
from PyPDF2 import PdfFileReader, PdfFileWriter
from PyPDF2.generic import NameObject
except ImportError:
logger.debug("Cannot import PyPDF2")
class BaseUbl(models.AbstractModel):
_name = "base.ubl"
_description = "Common methods to generate and parse UBL XML files"
# ==================== METHODS TO GENERATE UBL files
@api.model
def _ubl_add_country(self, country, parent_node, ns, version="2.1"):
country_root = etree.SubElement(parent_node, ns["cac"] + "Country")
country_code = etree.SubElement(country_root, ns["cbc"] + "IdentificationCode")
country_code.text = country.code
country_name = etree.SubElement(country_root, ns["cbc"] + "Name")
country_name.text = country.name
@api.model
def _ubl_add_address(self, partner, node_name, parent_node, ns, version="2.1"):
address = etree.SubElement(parent_node, ns["cac"] + node_name)
if partner.street:
streetname = etree.SubElement(address, ns["cbc"] + "StreetName")
streetname.text = partner.street
if partner.street2:
addstreetname = etree.SubElement(
address, ns["cbc"] + "AdditionalStreetName"
)
addstreetname.text = partner.street2
if hasattr(partner, "street3") and partner.street3:
blockname = etree.SubElement(address, ns["cbc"] + "BlockName")
blockname.text = partner.street3
if partner.city:
city = etree.SubElement(address, ns["cbc"] + "CityName")
city.text = partner.city
if partner.zip:
zip_code = etree.SubElement(address, ns["cbc"] + "PostalZone")
zip_code.text = partner.zip
if partner.state_id:
state = etree.SubElement(address, ns["cbc"] + "CountrySubentity")
state.text = partner.state_id.name
state_code = etree.SubElement(address, ns["cbc"] + "CountrySubentityCode")
state_code.text = partner.state_id.code
if partner.country_id:
self._ubl_add_country(partner.country_id, address, ns, version=version)
else:
logger.warning("UBL: missing country on partner %s", partner.name)
@api.model
def _ubl_get_contact_id(self, partner):
return False
@api.model
def _ubl_add_contact(
self, partner, parent_node, ns, node_name="Contact", version="2.1"
):
contact = etree.SubElement(parent_node, ns["cac"] + node_name)
contact_id_text = self._ubl_get_contact_id(partner)
if contact_id_text:
contact_id = etree.SubElement(contact, ns["cbc"] + "ID")
contact_id.text = contact_id_text
if partner.parent_id:
contact_name = etree.SubElement(contact, ns["cbc"] + "Name")
contact_name.text = partner.name or partner.parent_id.name
phone = partner.phone or partner.commercial_partner_id.phone
if phone:
telephone = etree.SubElement(contact, ns["cbc"] + "Telephone")
telephone.text = phone
email = partner.email or partner.commercial_partner_id.email
if email:
electronicmail = etree.SubElement(contact, ns["cbc"] + "ElectronicMail")
electronicmail.text = email
@api.model
def _ubl_add_language(self, lang_code, parent_node, ns, version="2.1"):
langs = self.env["res.lang"].search([("code", "=", lang_code)])
if not langs:
return
lang = langs[0]
lang_root = etree.SubElement(parent_node, ns["cac"] + "Language")
lang_name = etree.SubElement(lang_root, ns["cbc"] + "Name")
lang_name.text = lang.name
lang_code = etree.SubElement(lang_root, ns["cbc"] + "LocaleCode")
lang_code.text = lang.code
@api.model
def _ubl_get_party_identification(self, commercial_partner):
"""This method is designed to be inherited in localisation modules
Should return a dict with key=SchemeName, value=Identifier"""
return {}
@api.model
def _ubl_add_party_identification(
self, commercial_partner, parent_node, ns, version="2.1"
):
id_dict = self._ubl_get_party_identification(commercial_partner)
if id_dict:
party_identification = etree.SubElement(
parent_node, ns["cac"] + "PartyIdentification"
)
for scheme_name, party_id_text in id_dict.items():
party_identification_id = etree.SubElement(
party_identification, ns["cbc"] + "ID", schemeName=scheme_name
)
party_identification_id.text = party_id_text
return
@api.model
def _ubl_get_tax_scheme_dict_from_partner(self, commercial_partner):
tax_scheme_dict = {"id": "VAT", "name": False, "type_code": False}
return tax_scheme_dict
@api.model
def _ubl_add_party_tax_scheme(
self, commercial_partner, parent_node, ns, version="2.1"
):
if commercial_partner.vat:
party_tax_scheme = etree.SubElement(
parent_node, ns["cac"] + "PartyTaxScheme"
)
registration_name = etree.SubElement(
party_tax_scheme, ns["cbc"] + "RegistrationName"
)
registration_name.text = commercial_partner.name
company_id = etree.SubElement(party_tax_scheme, ns["cbc"] + "CompanyID")
company_id.text = commercial_partner.vat
tax_scheme_dict = self._ubl_get_tax_scheme_dict_from_partner(
commercial_partner
)
self._ubl_add_tax_scheme(
tax_scheme_dict, party_tax_scheme, ns, version=version
)
@api.model
def _ubl_add_party_legal_entity(
self, commercial_partner, parent_node, ns, version="2.1"
):
party_legal_entity = etree.SubElement(
parent_node, ns["cac"] + "PartyLegalEntity"
)
registration_name = etree.SubElement(
party_legal_entity, ns["cbc"] + "RegistrationName"
)
registration_name.text = commercial_partner.name
self._ubl_add_address(
commercial_partner,
"RegistrationAddress",
party_legal_entity,
ns,
version=version,
)
@api.model
def _ubl_add_party(
self, partner, company, node_name, parent_node, ns, version="2.1"
):
commercial_partner = partner.commercial_partner_id
party = etree.SubElement(parent_node, ns["cac"] + node_name)
if commercial_partner.website:
website = etree.SubElement(party, ns["cbc"] + "WebsiteURI")
website.text = commercial_partner.website
self._ubl_add_party_identification(
commercial_partner, party, ns, version=version
)
party_name = etree.SubElement(party, ns["cac"] + "PartyName")
name = etree.SubElement(party_name, ns["cbc"] + "Name")
name.text = commercial_partner.name
if partner.lang:
self._ubl_add_language(partner.lang, party, ns, version=version)
self._ubl_add_address(
commercial_partner, "PostalAddress", party, ns, version=version
)
self._ubl_add_party_tax_scheme(commercial_partner, party, ns, version=version)
if company:
self._ubl_add_party_legal_entity(
commercial_partner, party, ns, version="2.1"
)
self._ubl_add_contact(partner, party, ns, version=version)
def _ubl_get_customer_assigned_id(self, partner):
return partner.commercial_partner_id.ref
@api.model
def _ubl_add_customer_party(
self, partner, company, node_name, parent_node, ns, version="2.1"
):
"""Please read the docstring of the method _ubl_add_supplier_party"""
if company:
if partner:
assert (
partner.commercial_partner_id == company.partner_id
), "partner is wrong"
else:
partner = company.partner_id
customer_party_root = etree.SubElement(parent_node, ns["cac"] + node_name)
partner_ref = self._ubl_get_customer_assigned_id(partner)
if partner_ref:
customer_ref = etree.SubElement(
customer_party_root, ns["cbc"] + "SupplierAssignedAccountID"
)
customer_ref.text = partner_ref
self._ubl_add_party(
partner, company, "Party", customer_party_root, ns, version=version
)
# TODO: rewrite support for AccountingContact + add DeliveryContact
# Additional optional args
if partner and not company and partner.parent_id:
self._ubl_add_contact(
partner,
customer_party_root,
ns,
node_name="AccountingContact",
version=version,
)
return customer_party_root
@api.model
def _ubl_add_supplier_party(
self, partner, company, node_name, parent_node, ns, version="2.1"
):
"""The company argument has been added to properly handle the
'ref' field.
In Odoo, we only have one ref field, in which we are supposed
to enter the reference that our company gives to its
customers/suppliers. We unfortunately don't have a native field to
enter the reference that our suppliers/customers give to us.
So, to set the fields CustomerAssignedAccountID and
SupplierAssignedAccountID, I need to know if the partner for
which we want to build the party block is our company or a
regular partner:
1) if it is a regular partner, call the method that way:
self._ubl_add_supplier_party(partner, False, ...)
2) if it is our company, call the method that way:
self._ubl_add_supplier_party(False, company, ...)
"""
if company:
if partner:
assert (
partner.commercial_partner_id == company.partner_id
), "partner is wrong"
else:
partner = company.partner_id
else:
raise UserError(_("Missing company!"))
supplier_party_root = etree.SubElement(parent_node, ns["cac"] + node_name)
partner_ref = self._ubl_get_customer_assigned_id(partner)
if partner_ref:
supplier_ref = etree.SubElement(
supplier_party_root, ns["cbc"] + "CustomerAssignedAccountID"
)
supplier_ref.text = partner_ref
self._ubl_add_party(
partner, company, "Party", supplier_party_root, ns, version=version
)
return supplier_party_root
@api.model
def _ubl_add_delivery(self, delivery_partner, parent_node, ns, version="2.1"):
delivery = etree.SubElement(parent_node, ns["cac"] + "Delivery")
delivery_location = etree.SubElement(delivery, ns["cac"] + "DeliveryLocation")
self._ubl_add_address(
delivery_partner, "Address", delivery_location, ns, version=version
)
self._ubl_add_party(
delivery_partner, False, "DeliveryParty", delivery, ns, version=version
)
@api.model
def _ubl_add_delivery_terms(self, incoterm, parent_node, ns, version="2.1"):
delivery_term = etree.SubElement(parent_node, ns["cac"] + "DeliveryTerms")
delivery_term_id = etree.SubElement(
delivery_term, ns["cbc"] + "ID", schemeAgencyID="6", schemeID="INCOTERM"
)
delivery_term_id.text = incoterm.code
@api.model
def _ubl_add_payment_terms(self, payment_term, parent_node, ns, version="2.1"):
pay_term_root = etree.SubElement(parent_node, ns["cac"] + "PaymentTerms")
pay_term_note = etree.SubElement(pay_term_root, ns["cbc"] + "Note")
pay_term_note.text = payment_term.name
@api.model
def _ubl_add_line_item(
self,
line_number,
name,
product,
type_,
quantity,
uom,
parent_node,
ns,
seller=False,
currency=False,
price_subtotal=False,
qty_precision=3,
price_precision=2,
version="2.1",
):
line_item = etree.SubElement(parent_node, ns["cac"] + "LineItem")
line_item_id = etree.SubElement(line_item, ns["cbc"] + "ID")
line_item_id.text = str(line_number)
if not uom.unece_code:
raise UserError(_("Missing UNECE code on unit of measure '%s'") % uom.name)
quantity_node = etree.SubElement(
line_item, ns["cbc"] + "Quantity", unitCode=uom.unece_code
)
quantity_node.text = str(quantity)
if currency and price_subtotal:
line_amount = etree.SubElement(
line_item, ns["cbc"] + "LineExtensionAmount", currencyID=currency.name
)
line_amount.text = str(price_subtotal)
price_unit = 0.0
# Use price_subtotal/qty to compute price_unit to be sure
# to get a *tax_excluded* price unit
if not float_is_zero(quantity, precision_digits=qty_precision):
price_unit = float_round(
price_subtotal / float(quantity), precision_digits=price_precision
)
price = etree.SubElement(line_item, ns["cac"] + "Price")
price_amount = etree.SubElement(
price, ns["cbc"] + "PriceAmount", currencyID=currency.name
)
price_amount.text = str(price_unit)
base_qty = etree.SubElement(
price, ns["cbc"] + "BaseQuantity", unitCode=uom.unece_code
)
base_qty.text = "1" # What else could it be ?
self._ubl_add_item(
name, product, line_item, ns, type_=type_, seller=seller, version=version
)
def _ubl_get_seller_code_from_product(self, product):
"""Inherit and overwrite if another custom product code is required"""
return product.default_code
def _ubl_get_customer_product_code(self, product, customer):
"""Inherit and overwrite to return the customer product sku either from
product, invoice_line or customer (product.customer_sku,
invoice_line.customer_sku, customer.product_sku)"""
return ""
@api.model
def _ubl_add_item(
self,
name,
product,
parent_node,
ns,
type_="purchase",
seller=False,
customer=False,
version="2.1",
):
"""Beware that product may be False (in particular on invoices)"""
assert type_ in ("sale", "purchase"), "Wrong type param"
assert name, "name is a required arg"
item = etree.SubElement(parent_node, ns["cac"] + "Item")
product_name = False
seller_code = False
if product:
if type_ == "purchase":
if seller:
sellers = product._select_seller(
partner_id=seller, quantity=0.0, date=None, uom_id=False
)
if sellers:
product_name = sellers[0].product_name
seller_code = sellers[0].product_code
if not seller_code:
seller_code = self._ubl_get_seller_code_from_product(product)
if not product_name:
variant = ", ".join(product.attribute_line_ids.mapped("value_ids.name"))
product_name = (
variant and "{} ({})".format(product.name, variant) or product.name
)
description = etree.SubElement(item, ns["cbc"] + "Description")
description.text = name
name_node = etree.SubElement(item, ns["cbc"] + "Name")
name_node.text = product_name or name.split("\n")[0]
customer_code = self._ubl_get_customer_product_code(product, customer)
if customer_code:
buyer_identification = etree.SubElement(
item, ns["cac"] + "BuyersItemIdentification"
)
buyer_identification_id = etree.SubElement(
buyer_identification, ns["cbc"] + "ID"
)
buyer_identification_id.text = customer_code
if seller_code:
seller_identification = etree.SubElement(
item, ns["cac"] + "SellersItemIdentification"
)
seller_identification_id = etree.SubElement(
seller_identification, ns["cbc"] + "ID"
)
seller_identification_id.text = seller_code
if product:
if product.barcode:
std_identification = etree.SubElement(
item, ns["cac"] + "StandardItemIdentification"
)
std_identification_id = etree.SubElement(
std_identification,
ns["cbc"] + "ID",
schemeAgencyID="6",
schemeID="GTIN",
)
std_identification_id.text = product.barcode
# I'm not 100% sure, but it seems that ClassifiedTaxCategory
# contains the taxes of the product without taking into
# account the fiscal position
if type_ == "sale":
taxes = product.taxes_id
else:
taxes = product.supplier_taxes_id
if taxes:
for tax in taxes:
self._ubl_add_tax_category(
tax,
item,
ns,
node_name="ClassifiedTaxCategory",
version=version,
)
for attribute_value in product.attribute_line_ids.mapped("value_ids"):
item_property = etree.SubElement(
item, ns["cac"] + "AdditionalItemProperty"
)
property_name = etree.SubElement(item_property, ns["cbc"] + "Name")
property_name.text = attribute_value.attribute_id.name
property_value = etree.SubElement(item_property, ns["cbc"] + "Value")
property_value.text = attribute_value.name
return item
@api.model
def _ubl_add_tax_subtotal(
self,
taxable_amount,
tax_amount,
tax,
currency_code,
parent_node,
ns,
version="2.1",
):
prec = self.env["decimal.precision"].precision_get("Account")
tax_subtotal = etree.SubElement(parent_node, ns["cac"] + "TaxSubtotal")
if not float_is_zero(taxable_amount, precision_digits=prec):
taxable_amount_node = etree.SubElement(
tax_subtotal, ns["cbc"] + "TaxableAmount", currencyID=currency_code
)
taxable_amount_node.text = "%0.*f" % (prec, taxable_amount)
tax_amount_node = etree.SubElement(
tax_subtotal, ns["cbc"] + "TaxAmount", currencyID=currency_code
)
tax_amount_node.text = "%0.*f" % (prec, tax_amount)
if tax.amount_type == "percent" and not float_is_zero(
tax.amount, precision_digits=prec + 3
):
percent = etree.SubElement(tax_subtotal, ns["cbc"] + "Percent")
percent.text = str(float_round(tax.amount, precision_digits=2))
self._ubl_add_tax_category(tax, tax_subtotal, ns, version=version)
@api.model
def _ubl_add_tax_category(
self, tax, parent_node, ns, node_name="TaxCategory", version="2.1"
):
tax_category = etree.SubElement(parent_node, ns["cac"] + node_name)
if not tax.unece_categ_id:
raise UserError(_("Missing UNECE Tax Category on tax '%s'") % tax.name)
tax_category_id = etree.SubElement(
tax_category, ns["cbc"] + "ID", schemeID="UN/ECE 5305", schemeAgencyID="6"
)
tax_category_id.text = tax.unece_categ_code
tax_name = etree.SubElement(tax_category, ns["cbc"] + "Name")
tax_name.text = tax.name
if tax.amount_type == "percent":
tax_percent = etree.SubElement(tax_category, ns["cbc"] + "Percent")
tax_percent.text = str(tax.amount)
tax_scheme_dict = self._ubl_get_tax_scheme_dict_from_tax(tax)
self._ubl_add_tax_scheme(tax_scheme_dict, tax_category, ns, version=version)
@api.model
def _ubl_get_tax_scheme_dict_from_tax(self, tax):
if not tax.unece_type_id:
raise UserError(_("Missing UNECE Tax Type on tax '%s'") % tax.name)
tax_scheme_dict = {"id": tax.unece_type_code, "name": False, "type_code": False}
return tax_scheme_dict
@api.model
def _ubl_add_tax_scheme(self, tax_scheme_dict, parent_node, ns, version="2.1"):
tax_scheme = etree.SubElement(parent_node, ns["cac"] + "TaxScheme")
if tax_scheme_dict.get("id"):
tax_scheme_id = etree.SubElement(
tax_scheme, ns["cbc"] + "ID", schemeID="UN/ECE 5153", schemeAgencyID="6"
)
tax_scheme_id.text = tax_scheme_dict["id"]
if tax_scheme_dict.get("name"):
tax_scheme_name = etree.SubElement(tax_scheme, ns["cbc"] + "Name")
tax_scheme_name.text = tax_scheme_dict["name"]
if tax_scheme_dict.get("type_code"):
tax_scheme_type_code = etree.SubElement(
tax_scheme, ns["cbc"] + "TaxTypeCode"
)
tax_scheme_type_code.text = tax_scheme_dict["type_code"]
@api.model
def _ubl_get_nsmap_namespace(self, doc_name, version="2.1"):
nsmap = {
None: "urn:oasis:names:specification:ubl:schema:xsd:" + doc_name,
"cac": "urn:oasis:names:specification:ubl:"
"schema:xsd:CommonAggregateComponents-2",
"cbc": "urn:oasis:names:specification:ubl:schema:xsd:"
"CommonBasicComponents-2",
}
ns = {
"cac": "{urn:oasis:names:specification:ubl:schema:xsd:"
"CommonAggregateComponents-2}",
"cbc": "{urn:oasis:names:specification:ubl:schema:xsd:"
"CommonBasicComponents-2}",
}
return nsmap, ns
@api.model
def _ubl_get_version(self, xml_root, root_name, ns):
version_xpath = xml_root.xpath(
"/%s/cbc:UBLVersionID" % root_name, namespaces=ns
)
if not version_xpath:
raise UserError(
_(
"The UBL XML file does not contain the version "
"for validating the content according to the schema."
)
)
return version_xpath[0].text.strip()
@api.model
def _ubl_check_xml_schema(self, xml_string, document, version="2.1"):
"""Validate the XML file against the XSD"""
xsd_file = "base_ubl/data/xsd-{}/maindoc/UBL-{}-{}.xsd".format(
version, document, version
)
xsd_etree_obj = etree.parse(file_open(xsd_file))
official_schema = etree.XMLSchema(xsd_etree_obj)
try:
t = etree.parse(BytesIO(xml_string))
official_schema.assertValid(t)
except Exception as e:
# if the validation of the XSD fails, we arrive here
logger = logging.getLogger(__name__)
logger.warning("The XML file is invalid against the XML Schema Definition")
logger.warning(xml_string)
logger.warning(e)
raise UserError(
_(
"The UBL XML file is not valid against the official "
"XML Schema Definition. The XML file and the "
"full error have been written in the server logs. "
"Here is the error, which may give you an idea on the "
"cause of the problem : %s."
)
% str(e)
) from e
return True
@api.model
def _ubl_add_xml_in_pdf_buffer(self, xml_string, xml_filename, buffer):
# Add attachment to PDF content.
reader = PdfFileReader(buffer)
writer = PdfFileWriter()
writer.appendPagesFromReader(reader)
writer.addAttachment(xml_filename, xml_string)
# show attachments when opening PDF
writer._root_object.update(
{NameObject("/PageMode"): NameObject("/UseAttachments")}
)
new_buffer = BytesIO()
writer.write(new_buffer)
return new_buffer
@api.model
def _embed_ubl_xml_in_pdf_content(self, xml_string, xml_filename, pdf_content):
"""Add the attachments to the PDF content.
Use the pdf_content argument, which has the binary of the PDF
-> it will return the new PDF binary with the embedded XML
(used for qweb-pdf reports)
"""
self.ensure_one()
logger.debug("Starting to embed %s in PDF", xml_filename)
with BytesIO(pdf_content) as reader_buffer:
buffer = self._ubl_add_xml_in_pdf_buffer(
xml_string, xml_filename, reader_buffer
)
pdf_content = buffer.getvalue()
buffer.close()
logger.info("%s file added to PDF content", xml_filename)
return pdf_content
@api.model
def embed_xml_in_pdf(
self, xml_string, xml_filename, pdf_content=None, pdf_file=None
):
"""
2 possible uses:
a) use the pdf_content argument, which has the binary of the PDF
-> it will return the new PDF binary with the embedded XML
(used for qweb-pdf reports)
b) OR use the pdf_file argument, which has the full path to the
original PDF file
-> it will re-write this file with the new PDF
(used for py3o reports, *_ubl_py3o modules in this repo)
"""
assert pdf_content or pdf_file, "Missing pdf_file or pdf_content"
if pdf_file:
with open(pdf_file, "rb") as f:
pdf_content = f.read()
updated_pdf_content = self._embed_ubl_xml_in_pdf_content(
xml_string, xml_filename, pdf_content
)
if pdf_file:
with open(pdf_file, "wb") as f:
f.write(updated_pdf_content)
return updated_pdf_content
# ==================== METHODS TO PARSE UBL files
@api.model
def ubl_parse_customer_party(self, party_node, ns):
ref_xpath = party_node.xpath("cbc:SupplierAssignedAccountID", namespaces=ns)
party_node = party_node.xpath("cac:Party", namespaces=ns)[0]
partner_dict = self.ubl_parse_party(party_node, ns)
partner_dict["ref"] = ref_xpath and ref_xpath[0].text or False
return partner_dict
@api.model
def ubl_parse_supplier_party(self, party_node, ns):
ref_xpath = party_node.xpath("cbc:CustomerAssignedAccountID", namespaces=ns)
party_node = party_node.xpath("cac:Party", namespaces=ns)[0]
partner_dict = self.ubl_parse_party(party_node, ns)
partner_dict["ref"] = ref_xpath and ref_xpath[0].text or False
return partner_dict
@api.model
def ubl_parse_party(self, party_node, ns):
partner_name_xpath = party_node.xpath("cac:PartyName/cbc:Name", namespaces=ns)
vat_xpath = party_node.xpath("cac:PartyTaxScheme/cbc:CompanyID", namespaces=ns)
website_xpath = party_node.xpath("cbc:WebsiteURI", namespaces=ns)
contact_name_xpath = party_node.xpath("cac:Contact/cbc:Name", namespaces=ns)
contact_email_xpath = party_node.xpath(
"cac:Contact/cbc:ElectronicMail", namespaces=ns
)
contact_phone_xpath = party_node.xpath(
"cac:Contact/cbc:Telephone", namespaces=ns
)
partner_dict = {
"vat": vat_xpath and vat_xpath[0].text or False,
"name": partner_name_xpath and partner_name_xpath[0].text or False,
"website": website_xpath and website_xpath[0].text or False,
"contact": contact_name_xpath and contact_name_xpath[0].text or False,
"email": contact_email_xpath and contact_email_xpath[0].text or False,
"phone": contact_phone_xpath and contact_phone_xpath[0].text or False,
}
id_nodes = party_node.xpath("cac:PartyIdentification/cbc:ID", namespaces=ns)
id_numbers = []
for id_node in id_nodes:
id_numbers.append(
{"value": id_node.text, "schemeID": id_node.attrib.get("schemeID")}
)
partner_dict["id_number"] = id_numbers
address_xpath = party_node.xpath("cac:PostalAddress", namespaces=ns)
if address_xpath:
address_dict = self.ubl_parse_address(address_xpath[0], ns)
partner_dict.update(address_dict)
return partner_dict
@api.model
def ubl_parse_address(self, address_node, ns):
country_code_xpath = address_node.xpath(
"cac:Country/cbc:IdentificationCode", namespaces=ns
)
country_code = country_code_xpath and country_code_xpath[0].text or False
state_code_xpath = address_node.xpath("cbc:CountrySubentityCode", namespaces=ns)
state_code = state_code_xpath and state_code_xpath[0].text or False
street_xpath = address_node.xpath("cbc:StreetName", namespaces=ns)
street2_xpath = address_node.xpath("cbc:AdditionalStreetName", namespaces=ns)
street_number_xpath = address_node.xpath("cbc:BuildingNumber", namespaces=ns)
city_xpath = address_node.xpath("cbc:CityName", namespaces=ns)
zip_xpath = address_node.xpath("cbc:PostalZone", namespaces=ns)
zip_code = (
zip_xpath
and zip_xpath[0].text
and zip_xpath[0].text.replace(" ", "")
or False
)
address_dict = {
"street": street_xpath and street_xpath[0].text or False,
"street_number": street_number_xpath
and street_number_xpath[0].text
or False,
"street2": street2_xpath and street2_xpath[0].text or False,
"city": city_xpath and city_xpath[0].text or False,
"zip": zip_code,
"state_code": state_code,
"country_code": country_code,
}
return address_dict
@api.model
def ubl_parse_delivery(self, delivery_node, ns):
party_xpath = delivery_node.xpath("cac:DeliveryParty", namespaces=ns)
if party_xpath:
partner_dict = self.ubl_parse_party(party_xpath[0], ns)
else:
partner_dict = {}
postal_xpath = delivery_node.xpath(
"cac:DeliveryParty/cac:PostalAddress", namespaces=ns
)
if not postal_xpath:
delivery_address_xpath = delivery_node.xpath(
"cac:DeliveryLocation/cac:Address", namespaces=ns
)
if not delivery_address_xpath:
delivery_address_xpath = delivery_node.xpath(
"cac:DeliveryAddress", namespaces=ns
)
if delivery_address_xpath:
partner_dict.update(
self.ubl_parse_address(delivery_address_xpath[0], ns)
)
return partner_dict
@api.model
def ubl_parse_delivery_details(self, delivery_node, ns):
delivery_dict = {}
latest_date = delivery_node.xpath("cbc:LatestDeliveryDate", namespaces=ns)
latest_time = delivery_node.xpath("cbc:LatestDeliveryTime", namespaces=ns)
if latest_date:
latest_delivery = latest_date[0].text
if latest_time:
latest_delivery += " " + latest_time[0].text[:-3]
delivery_dict["commitment_date"] = latest_delivery
return delivery_dict
def ubl_parse_incoterm(self, delivery_term_node, ns):
incoterm_xpath = delivery_term_node.xpath("cbc:ID", namespaces=ns)
if incoterm_xpath:
incoterm_dict = {"code": incoterm_xpath[0].text}
return incoterm_dict
return {}
def ubl_parse_product(self, line_node, ns):
barcode_xpath = line_node.xpath(
"cac:Item/cac:StandardItemIdentification/cbc:ID[@schemeID='GTIN']",
namespaces=ns,
)
code_xpath = line_node.xpath(
"cac:Item/cac:SellersItemIdentification/cbc:ID", namespaces=ns
)
product_dict = {
"barcode": barcode_xpath and barcode_xpath[0].text or False,
"code": code_xpath and code_xpath[0].text or False,
}
return product_dict
# ======================= METHODS only needed for testing
# Method copy-pasted from edi/base_business_document_import/
# models/business_document_import.py
# Because we don't depend on this module
def get_xml_files_from_pdf(self, pdf_file):
"""Returns a dict with key = filename, value = XML file obj"""
logger.info("Trying to find an embedded XML file inside PDF")
res = {}
try:
fd = BytesIO(pdf_file)
pdf = PdfFileReader(fd)
logger.debug("pdf.trailer=%s", pdf.trailer)
pdf_root = pdf.trailer["/Root"]
logger.debug("pdf_root=%s", pdf_root)
embeddedfiles = pdf_root["/Names"]["/EmbeddedFiles"]["/Names"]
i = 0
xmlfiles = {} # key = filename, value = PDF obj
for embeddedfile in embeddedfiles[:-1]:
mime_res = mimetypes.guess_type(embeddedfile)
if mime_res and mime_res[0] in ["application/xml", "text/xml"]:
xmlfiles[embeddedfile] = embeddedfiles[i + 1]
i += 1
logger.debug("xmlfiles=%s", xmlfiles)
for filename, xml_file_dict_obj in xmlfiles.items():
try:
xml_file_dict = xml_file_dict_obj.getObject()
logger.debug("xml_file_dict=%s", xml_file_dict)
xml_string = xml_file_dict["/EF"]["/F"].getData()
xml_root = etree.fromstring(xml_string)
logger.debug(
"A valid XML file %s has been found in the PDF file", filename
)
res[filename] = xml_root
except Exception:
continue
except Exception as exc:
logger.debug("Passing any uncaught exception. \n %s" % exc)
logger.info("Valid XML files found in PDF: %s", list(res.keys()))
return res
| 42.266265 | 35,081 |
619 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Voxel stock picking secondary unit",
"summary": "Export Secondary UoMs Voxel Code in picking Voxel documents",
"version": "15.0.1.0.0",
"category": "Warehouse Management",
"website": "https://github.com/OCA/edi",
"author": "Tecnativa, Odoo Community Association (OCA)",
"maintainers": ["ernestotejeda"],
"license": "AGPL-3",
"depends": [
"sale_stock_secondary_unit",
"edi_voxel_secondary_unit_oca",
"edi_voxel_stock_picking_oca",
],
}
| 36.411765 | 619 |
2,385 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests import Form
from odoo.addons.edi_voxel_stock_picking_oca.tests.test_voxel_stock_picking import (
TestVoxelStockPickingCommon,
)
class TestVoxelStockPickingSecondaryUnit(TestVoxelStockPickingCommon):
@classmethod
def _create_sale_order(cls):
sale_order = super()._create_sale_order()
secondary_uom = cls.env["product.secondary.unit"].create(
{
"product_tmpl_id": cls.product.product_tmpl_id.id,
"code": "boxes",
"name": "Boxes",
"voxel_code": "Cajas",
"uom_id": cls.env.ref("uom.product_uom_unit").id,
"factor": 20,
}
)
cls.env.user.groups_id += cls.env.ref("uom.group_uom")
with Form(sale_order) as so_form:
with so_form.order_line.edit(0) as so_line_form:
so_line_form.secondary_uom_id = secondary_uom
so_line_form.secondary_uom_qty = 2
return sale_order
def test_get_report_values(self):
# Get report data
report_edi_obj = self.env[
"report.edi_voxel_stock_picking_oca.template_voxel_picking"
]
report_data = report_edi_obj._get_report_values(self.picking.ids)
# Check product data
self.assertListEqual(report_data["products"], self._get_products_data())
def _get_products_data(self):
return [
{
"product": {
"SupplierSKU": "DC_001",
"CustomerSKU": "1234567891234",
"Item": "Product 1 (test)",
"Qty": "2.0",
"MU": "Cajas",
},
},
{
"product": {
"SupplierSKU": "DC_002",
"CustomerSKU": False,
"Item": "Product 2 (test)",
"Qty": "1.0",
"MU": "Unidades",
"TraceabilityList": [
{
"BatchNumber": "LOT01",
"ExpirationDate": "2020-01-01",
"Quantity": 1.0,
}
],
},
},
]
| 35.073529 | 2,385 |
574 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import models
class ReportVoxelPicking(models.AbstractModel):
_inherit = "report.edi_voxel_stock_picking_oca.template_voxel_picking"
def _get_product_data(self, line):
res = super()._get_product_data(line)
if line.secondary_uom_id and line.secondary_uom_id.voxel_code:
res.update(
Qty=str(line.secondary_uom_qty),
MU=line.secondary_uom_id.voxel_code,
)
return res
| 33.764706 | 574 |
524 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Edi WebService",
"summary": """
Defines webservice integration from EDI Exchange records""",
"version": "15.0.1.1.0",
"license": "AGPL-3",
"development_status": "Beta",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/edi",
"depends": ["edi_oca", "webservice"],
"data": ["views/edi_backend.xml", "security/ir.model.access.csv"],
}
| 34.933333 | 524 |
1,275 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# @author: Enric Tobella
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.addons.edi_oca.tests.common import EDIBackendCommonTestCase
class TestEdiWebService(EDIBackendCommonTestCase):
@classmethod
def _setup_records(cls):
result = super()._setup_records()
cls.webservice = cls.env["webservice.backend"].create(
{
"name": "WebService",
"protocol": "http",
"url": "http://localhost.demo.odoo/",
"content_type": "application/xml",
"tech_name": "demo_ws",
}
)
vals = {
"model": cls.partner._name,
"res_id": cls.partner.id,
}
cls.record = cls.backend.create_record("test_csv_input", vals)
return result
def test_components_with_ws(self):
self.backend.webservice_backend_id = self.webservice
components = self.backend._get_component_usage_candidates(self.record, "send")
self.assertIn("webservice.send", components)
def test_components_without_ws(self):
components = self.backend._get_component_usage_candidates(self.record, "send")
self.assertNotIn("webservice.send", components)
| 36.428571 | 1,275 |
1,389 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class EdiBackend(models.Model):
_inherit = "edi.backend"
webservice_backend_id = fields.Many2one("webservice.backend")
_webservice_actions = ("send", "receive")
def _get_component_usage_candidates(self, exchange_record, key):
candidates = super()._get_component_usage_candidates(exchange_record, key)
if not self.webservice_backend_id or key not in self._webservice_actions:
return candidates
return ["webservice.{}".format(key)] + candidates
def _component_match_attrs(self, exchange_record, key):
# Override to inject `webservice_protocol` as match attribute
res = super()._component_match_attrs(exchange_record, key)
if not self.webservice_backend_id or key not in self._webservice_actions:
return res
res["webservice_protocol"] = self.webservice_backend_id.protocol
return res
def _component_sort_key(self, component_class):
res = super()._component_sort_key(component_class)
# Override to give precedence by `webservice_protocol` when needed.
if not self.webservice_backend_id:
return res
return (
1 if getattr(component_class, "_webservice_protocol", False) else 0,
) + res
| 39.685714 | 1,389 |
1,164 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptcamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import api, fields, models
class EDIBackend(models.Model):
_inherit = "edi.backend"
endpoint_ids = fields.One2many(
string="Endpoints",
comodel_name="edi.endpoint",
inverse_name="backend_id",
)
endpoints_count = fields.Integer(compute="_compute_endpoints_count")
@api.depends("endpoint_ids")
def _compute_endpoints_count(self):
for record in self:
record.endpoints_count = len(record.endpoint_ids)
def action_manage_endpoints(self):
xmlid = "edi_endpoint_oca.edi_endpoint_act_window"
action = self.env["ir.actions.act_window"]._for_xml_id(xmlid)
action["domain"] = [
("backend_type_id", "=", self.backend_type_id),
"|",
("backend_id", "=", False),
("backend_id", "=", self.id),
]
action["context"] = {
"default_backend_id": self.id,
"default_backend_type_id": self.backend_type_id.id,
}
return action
| 31.459459 | 1,164 |
521 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Odoo Community Association
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Edi Stock Oca",
"summary": """
Define EDI Configuration for Stock""",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Odoo Community Association,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/edi",
"depends": ["stock", "edi_oca", "component_event"],
"data": ["views/stock_picking.xml", "views/res_partner.xml"],
"demo": [],
}
| 34.733333 | 521 |
2,024 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.tests.common import tagged
from odoo.addons.component.core import Component
from odoo.addons.component.tests.common import TransactionComponentRegistryCase
from odoo.addons.stock.tests.common import TestStockCommon
@tagged("-at_install", "post_install")
class EDIBackendTestCase(TestStockCommon, TransactionComponentRegistryCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._setup_registry(cls)
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
class StockPickingEventListenerDemo(Component):
_name = "stock.picking.event.listener.demo"
_inherit = "base.event.listener"
def on_validate(self, picking):
picking.name = "picking_done"
StockPickingEventListenerDemo._build_component(cls.comp_registry)
cls.comp_registry._cache.clear()
cls.picking_in = cls.PickingObj.with_context(
components_registry=cls.comp_registry
).create(
{
"picking_type_id": cls.picking_type_in,
"location_id": cls.supplier_location,
"location_dest_id": cls.stock_location,
}
)
move_a = cls.MoveObj.create(
{
"name": cls.productA.name,
"product_id": cls.productA.id,
"product_uom_qty": 1,
"product_uom": cls.productA.uom_id.id,
"picking_id": cls.picking_in.id,
"location_id": cls.supplier_location,
"location_dest_id": cls.stock_location,
}
)
cls.picking_in.refresh()
cls.picking_in.action_confirm()
cls.picking_in.action_assign()
move_a.move_line_ids.qty_done = 4
def test_validate_picking(self):
self.picking_in._action_done()
self.assertEqual(self.picking_in.name, "picking_done")
| 36.8 | 2,024 |
639 |
py
|
PYTHON
|
15.0
|
# Copyright 2022 OCA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class StockPicking(models.Model):
_name = "stock.picking"
_inherit = ["stock.picking", "edi.exchange.consumer.mixin"]
edi_auto_disabled = fields.Boolean(
states={
"draft": [("readonly", False)],
"waiting": [("readonly", False)],
"confirmed": [("readonly", False)],
"assigned": [("readonly", False)],
},
)
def _action_done(self):
res = super()._action_done()
self._event("on_validate").notify(self)
return res
| 27.782609 | 639 |
443 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2021 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 odoo import SUPERUSER_ID, api
def set_xml_format_in_pdf_invoice_to_facturx(cr, registry):
env = api.Environment(cr, SUPERUSER_ID, {})
companies = env["res.company"].search([])
companies.write({"xml_format_in_pdf_invoice": "factur-x"})
| 40.272727 | 443 |
945 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2021 Akretion France (http://www.akretion.com/)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Account Invoice Factur-X",
"version": "15.0.1.0.0",
"category": "Invoicing Management",
"license": "AGPL-3",
"summary": "Generate Factur-X/ZUGFeRD customer invoices",
"author": "Akretion,Odoo Community Association (OCA)",
"maintainers": ["alexis-via"],
"website": "https://github.com/OCA/edi",
"depends": [
"account_einvoice_generate",
"account_payment_partner",
"base_facturx",
"base_vat",
],
"external_dependencies": {"python": ["factur-x"]},
"data": [
"views/res_partner.xml",
"views/res_config_settings.xml",
"views/report_invoice.xml",
],
"post_init_hook": "set_xml_format_in_pdf_invoice_to_facturx",
"installable": True,
}
| 33.75 | 945 |
3,356 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2020 Akretion France
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
from facturx import get_facturx_level
from lxml import etree
from odoo.tests.common import TransactionCase
logger = logging.getLogger(__name__)
class TestFacturXInvoice(TransactionCase):
def setUp(self):
super().setUp()
self.company = self.env.ref("base.main_company")
self.product1 = self.env.ref("product.product_product_4")
self.product2 = self.env.ref("product.product_product_1")
self.invoice = self.env["account.move"].create(
{
"company_id": self.company.id,
"move_type": "out_invoice",
"partner_id": self.env.ref("base.res_partner_2").id,
"currency_id": self.company.currency_id.id,
"invoice_line_ids": [
(
0,
0,
{
"product_id": self.product1.id,
"product_uom_id": self.product1.uom_id.id,
"quantity": 12,
"price_unit": 42.42,
},
),
(
0,
0,
{
"product_id": self.product2.id,
"product_uom_id": self.product2.uom_id.id,
"quantity": 2,
"price_unit": 12.34,
},
),
],
}
)
self.invoice.action_post()
def test_deep_customer_invoice(self):
# Bug in Basic XSD: missing CountrySubDivisionName
# I reported it to FNFE-MPE on 24/10/2021
# In the meantime, we want to avoid the bug:
self.company.partner_id.state_id = False
self.invoice.partner_id.state_id = False
if self.company.xml_format_in_pdf_invoice != "factur-x":
self.company.write({"xml_format_in_pdf_invoice": "factur-x"})
# inv_report = self.env.ref("account.account_invoices").with_context(
# force_report_rendering=True
# )
for level in ["minimum", "basicwl", "basic", "en16931", "extended"]:
self.company.write({"facturx_level": level})
# Travis tests get stalled on this line
# Maybe it's not possible to render a PDF on Travis... I don't know
# pdf_content, pdf_ext = inv_report._render_qweb_pdf(
# res_ids=[self.invoice.id]
# )
# xml_filename, xml_string = get_facturx_xml_from_pdf(
# pdf_content, check_xsd=True
# )
# self.assertTrue(xml_filename, "factur-x.xml")
# xml_root = etree.fromstring(xml_string)
# facturx_level = get_facturx_level(xml_root)
# self.assertEqual(facturx_level, level)
xml_bytes, fx_level = self.invoice.generate_facturx_xml()
self.assertEqual(fx_level, level)
xml_root = etree.fromstring(xml_bytes)
facturx_level = get_facturx_level(xml_root)
self.assertEqual(facturx_level, level)
| 40.926829 | 3,356 |
41,723 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2021 Akretion France (http://www.akretion.com)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
from lxml import etree
from odoo import _, api, fields, models
from odoo.exceptions import UserError
from odoo.tools import (
float_compare,
float_is_zero,
float_round,
html2plaintext,
is_html_empty,
)
from odoo.tools.misc import format_date
logger = logging.getLogger(__name__)
try:
from facturx import generate_from_binary, xml_check_xsd
except ImportError:
logger.debug("Cannot import facturx")
FACTURX_FILENAME = "factur-x.xml"
DIRECT_DEBIT_CODES = ("49", "59")
CREDIT_TRF_CODES = ("30", "31", "42")
PROFILES_EN_UP = ["en16931", "extended"]
class AccountMove(models.Model):
_name = "account.move"
_inherit = ["account.move", "base.facturx"]
@api.model
def _cii_add_address_block(self, partner, parent_node, ns):
address = etree.SubElement(parent_node, ns["ram"] + "PostalTradeAddress")
if ns["level"] != "minimum":
if partner.zip:
address_zip = etree.SubElement(address, ns["ram"] + "PostcodeCode")
address_zip.text = partner.zip
if partner.street:
address_street = etree.SubElement(address, ns["ram"] + "LineOne")
address_street.text = partner.street
if partner.street2:
address_street2 = etree.SubElement(address, ns["ram"] + "LineTwo")
address_street2.text = partner.street2
if hasattr(partner, "street3") and partner.street3:
address_street3 = etree.SubElement(address, ns["ram"] + "LineThree")
address_street3.text = partner.street3
if partner.city:
address_city = etree.SubElement(address, ns["ram"] + "CityName")
address_city.text = partner.city
if not partner.country_id:
raise UserError(
_(
"Country is not set on partner '%s'. In the Factur-X "
"standard, the country is required for buyer and seller."
)
% partner.display_name
)
address_country = etree.SubElement(address, ns["ram"] + "CountryID")
address_country.text = partner.country_id.code
if ns["level"] != "minimum" and partner.state_id:
address_state = etree.SubElement(
address, ns["ram"] + "CountrySubDivisionName"
)
address_state.text = partner.state_id.name
@api.model
def _cii_trade_contact_department_name(self, partner):
return None
@api.model
def _cii_add_trade_contact_block(self, partner, parent_node, ns):
trade_contact = etree.SubElement(parent_node, ns["ram"] + "DefinedTradeContact")
contact_name = etree.SubElement(trade_contact, ns["ram"] + "PersonName")
contact_name.text = partner.name
department = self._cii_trade_contact_department_name(partner)
if department:
department_name = etree.SubElement(
trade_contact, ns["ram"] + "DepartmentName"
)
department_name.text = department
phone = partner.phone or partner.mobile
if phone:
phone_node = etree.SubElement(
trade_contact, ns["ram"] + "TelephoneUniversalCommunication"
)
phone_number = etree.SubElement(phone_node, ns["ram"] + "CompleteNumber")
phone_number.text = phone
if partner.email:
email_node = etree.SubElement(
trade_contact, ns["ram"] + "EmailURIUniversalCommunication"
)
email_uriid = etree.SubElement(
email_node, ns["ram"] + "URIID", schemeID="SMTP"
)
email_uriid.text = partner.email
@api.model
def _cii_add_date(
self, node_name, date_datetime, parent_node, ns, date_ns_type="udt"
):
date_node = etree.SubElement(parent_node, ns["ram"] + node_name)
date_node_str = etree.SubElement(
date_node, ns[date_ns_type] + "DateTimeString", format="102"
)
# 102 = format YYYYMMDD
date_node_str.text = date_datetime.strftime("%Y%m%d")
def _cii_add_document_context_block(self, root, ns):
self.ensure_one()
doc_ctx = etree.SubElement(root, ns["rsm"] + "ExchangedDocumentContext")
ctx_param = etree.SubElement(
doc_ctx, ns["ram"] + "GuidelineSpecifiedDocumentContextParameter"
)
ctx_param_id = etree.SubElement(ctx_param, ns["ram"] + "ID")
if ns["level"] == "en16931":
urn = "urn:cen.eu:en16931:2017"
elif ns["level"] == "basic":
urn = "urn:cen.eu:en16931:2017#compliant#urn:factur-x.eu:1p0:basic"
elif ns["level"] == "extended":
urn = "urn:cen.eu:en16931:2017#conformant#" "urn:factur-x.eu:1p0:extended"
else:
urn = "urn:factur-x.eu:1p0:%s" % ns["level"]
ctx_param_id.text = urn
def _cii_add_header_block(self, root, ns):
self.ensure_one()
header_doc = etree.SubElement(root, ns["rsm"] + "ExchangedDocument")
header_doc_id = etree.SubElement(header_doc, ns["ram"] + "ID")
if self.state == "posted":
header_doc_id.text = self.name
else:
header_doc_id.text = self._fields["state"].convert_to_export(
self.state, self
)
header_doc_typecode = etree.SubElement(header_doc, ns["ram"] + "TypeCode")
if self.move_type == "out_invoice":
header_doc_typecode.text = "380"
elif self.move_type == "out_refund":
header_doc_typecode.text = ns["refund_type"]
# 2 options allowed in Factur-X :
# a) invoice and refunds -> 380 ; negative amounts if refunds
# b) invoice -> 380 refunds -> 381, with positive amounts
# In ZUGFeRD samples, they use option a)
# For Chorus, they impose option b)
# Until August 2017, I was using option a), now I use option b)
# Starting from November 2017, it's a config option !
invoice_date_dt = self.invoice_date or fields.Date.context_today(self)
self._cii_add_date("IssueDateTime", invoice_date_dt, header_doc, ns)
if not is_html_empty(self.narration) and ns["level"] != "minimum":
note = etree.SubElement(header_doc, ns["ram"] + "IncludedNote")
content_note = etree.SubElement(note, ns["ram"] + "Content")
content_note.text = html2plaintext(self.narration)
@api.model
def _cii_get_party_identification(self, commercial_partner):
"""This method is designed to be inherited in localisation modules
Should return a dict with key=SchemeName, value=Identifier"""
return {}
@api.model
def _cii_add_party_identification(self, commercial_partner, parent_node, ns):
id_dict = self._cii_get_party_identification(commercial_partner)
if id_dict:
party_identification = etree.SubElement(
parent_node, ns["ram"] + "SpecifiedLegalOrganization"
)
for scheme_name, party_id_text in id_dict.items():
party_identification_id = etree.SubElement(
party_identification, ns["ram"] + "ID", schemeID=scheme_name
)
party_identification_id.text = party_id_text
return
@api.model
def _cii_trade_agreement_buyer_ref(self, partner):
return None
def _cii_add_trade_agreement_block(self, trade_transaction, ns):
self.ensure_one()
company = self.company_id
trade_agreement = etree.SubElement(
trade_transaction, ns["ram"] + "ApplicableHeaderTradeAgreement"
)
buyer_ref = self._cii_trade_agreement_buyer_ref(self.partner_id)
if buyer_ref:
buyer_reference = etree.SubElement(
trade_agreement, ns["ram"] + "BuyerReference"
)
buyer_reference.text = buyer_ref
seller = etree.SubElement(trade_agreement, ns["ram"] + "SellerTradeParty")
seller_name = etree.SubElement(seller, ns["ram"] + "Name")
seller_name.text = company.name
self._cii_add_party_identification(company.partner_id, seller, ns)
if ns["level"] in PROFILES_EN_UP:
self._cii_add_trade_contact_block(
self.invoice_user_id.partner_id or company.partner_id, seller, ns
)
self._cii_add_address_block(company.partner_id, seller, ns)
if company.vat:
seller_tax_reg = etree.SubElement(
seller, ns["ram"] + "SpecifiedTaxRegistration"
)
seller_tax_reg_id = etree.SubElement(
seller_tax_reg, ns["ram"] + "ID", schemeID="VA"
)
seller_tax_reg_id.text = company.vat
buyer = etree.SubElement(trade_agreement, ns["ram"] + "BuyerTradeParty")
if ns["level"] != "minimum" and self.commercial_partner_id.ref:
buyer_id = etree.SubElement(buyer, ns["ram"] + "ID")
buyer_id.text = self.commercial_partner_id.ref
buyer_name = etree.SubElement(buyer, ns["ram"] + "Name")
buyer_name.text = self.commercial_partner_id.name
self._cii_add_party_identification(self.commercial_partner_id, buyer, ns)
if (
ns["level"] in PROFILES_EN_UP
and self.commercial_partner_id != self.partner_id
and self.partner_id.name
):
self._cii_add_trade_contact_block(self.partner_id, buyer, ns)
self._cii_add_address_block(self.partner_id, buyer, ns)
if self.commercial_partner_id.vat:
buyer_tax_reg = etree.SubElement(
buyer, ns["ram"] + "SpecifiedTaxRegistration"
)
buyer_tax_reg_id = etree.SubElement(
buyer_tax_reg, ns["ram"] + "ID", schemeID="VA"
)
buyer_tax_reg_id.text = self.commercial_partner_id.vat
if ns["level"] == "extended" and self.invoice_incoterm_id:
delivery_terms = etree.SubElement(
trade_agreement, ns["ram"] + "ApplicableTradeDeliveryTerms"
)
delivery_code = etree.SubElement(
delivery_terms, ns["ram"] + "DeliveryTypeCode"
)
delivery_code.text = self.invoice_incoterm_id.code
self._cii_add_buyer_order_reference(trade_agreement, ns)
self._cii_add_contract_reference(trade_agreement, ns)
def _cii_add_buyer_order_reference(self, trade_agreement, ns):
self.ensure_one()
if self.ref:
buyer_order_ref = etree.SubElement(
trade_agreement, ns["ram"] + "BuyerOrderReferencedDocument"
)
buyer_order_id = etree.SubElement(
buyer_order_ref, ns["ram"] + "IssuerAssignedID"
)
buyer_order_id.text = self.ref
def _cii_add_contract_reference(self, trade_agreement, ns):
self.ensure_one()
contract_code = self._get_contract_code()
if ns["level"] != "minimum" and contract_code:
contract_ref = etree.SubElement(
trade_agreement, ns["ram"] + "ContractReferencedDocument"
)
contract_id = etree.SubElement(contract_ref, ns["ram"] + "IssuerAssignedID")
contract_id.text = contract_code
def _get_contract_code(self):
"""This method is designed to be inherited
There are so many different ways to handle a contract in Odoo!
So it's difficult to have a common datamodel for it"""
return False
def _cii_add_trade_delivery_block(self, trade_transaction, ns):
self.ensure_one()
trade_agreement = etree.SubElement(
trade_transaction, ns["ram"] + "ApplicableHeaderTradeDelivery"
)
# partner_shipping_id is provided by the sale module
if (
ns["level"] in PROFILES_EN_UP
and hasattr(self, "partner_shipping_id")
and self.partner_shipping_id
):
shipto_trade_party = etree.SubElement(
trade_agreement, ns["ram"] + "ShipToTradeParty"
)
self._cii_add_address_block(
self.partner_shipping_id, shipto_trade_party, ns
)
return trade_agreement
def _cii_add_trade_settlement_payment_means_block(self, trade_settlement, ns):
payment_means = etree.SubElement(
trade_settlement, ns["ram"] + "SpecifiedTradeSettlementPaymentMeans"
)
payment_means_code = etree.SubElement(payment_means, ns["ram"] + "TypeCode")
if ns["level"] in PROFILES_EN_UP:
payment_means_info = etree.SubElement(
payment_means, ns["ram"] + "Information"
)
if self.payment_mode_id:
payment_means_code.text = self.payment_mode_id.payment_method_id.unece_code
if ns["level"] in PROFILES_EN_UP:
payment_means_info.text = (
self.payment_mode_id.note or self.payment_mode_id.name
)
else:
payment_means_code.text = "30" # use 30 and not 31,
# for wire transfer, according to Factur-X CIUS
if ns["level"] in PROFILES_EN_UP:
payment_means_info.text = _("Wire transfer")
logger.warning(
"Missing payment mode on invoice ID %d. "
"Using 30 (wire transfer) as UNECE code as fallback "
"for payment mean",
self.id,
)
if payment_means_code.text in CREDIT_TRF_CODES:
partner_bank = self.partner_bank_id
if (
not partner_bank
and self.payment_mode_id
and self.payment_mode_id.bank_account_link == "fixed"
and self.payment_mode_id.fixed_journal_id
):
partner_bank = self.payment_mode_id.fixed_journal_id.bank_account_id
if partner_bank and partner_bank.acc_type == "iban":
payment_means_bank_account = etree.SubElement(
payment_means, ns["ram"] + "PayeePartyCreditorFinancialAccount"
)
iban = etree.SubElement(
payment_means_bank_account, ns["ram"] + "IBANID"
)
iban.text = partner_bank.sanitized_acc_number
if ns["level"] in PROFILES_EN_UP and partner_bank.bank_bic:
payment_means_bank = etree.SubElement(
payment_means,
ns["ram"] + "PayeeSpecifiedCreditorFinancialInstitution",
)
payment_means_bic = etree.SubElement(
payment_means_bank, ns["ram"] + "BICID"
)
payment_means_bic.text = partner_bank.bank_bic
# Field mandate_id provided by the OCA module account_banking_mandate
elif (
payment_means_code.text in DIRECT_DEBIT_CODES
and hasattr(self, "mandate_id")
and self.mandate_id.partner_bank_id
and self.mandate_id.partner_bank_id.acc_type == "iban"
and self.mandate_id.partner_bank_id.sanitized_acc_number
):
debtor_acc = etree.SubElement(
payment_means, ns["ram"] + "PayerPartyDebtorFinancialAccount"
)
debtor_acc_iban = etree.SubElement(debtor_acc, ns["ram"] + "IBANID")
debtor_acc_iban.text = self.mandate_id.partner_bank_id.sanitized_acc_number
def _cii_trade_payment_terms_block(self, trade_settlement, ns):
trade_payment_term = etree.SubElement(
trade_settlement, ns["ram"] + "SpecifiedTradePaymentTerms"
)
if ns["level"] in PROFILES_EN_UP:
trade_payment_term_desc = etree.SubElement(
trade_payment_term, ns["ram"] + "Description"
)
# The 'Description' field of SpecifiedTradePaymentTerms
# is a required field, so we must always give a value
if self.invoice_payment_term_id:
trade_payment_term_desc.text = self.invoice_payment_term_id.name
else:
trade_payment_term_desc.text = _("No specific payment term selected")
if self.invoice_date_due:
self._cii_add_date(
"DueDateDateTime", self.invoice_date_due, trade_payment_term, ns
)
# Direct debit Mandate
if (
self.payment_mode_id.payment_method_id.unece_code in DIRECT_DEBIT_CODES
and hasattr(self, "mandate_id")
and self.mandate_id.unique_mandate_reference
):
mandate = etree.SubElement(
trade_payment_term, ns["ram"] + "DirectDebitMandateID"
)
mandate.text = self.mandate_id.unique_mandate_reference
def _cii_check_tax_required_info(self, tax_dict):
if not tax_dict:
# Hack when there is NO tax at all
# ApplicableTradeTax is a required field, both on line and total
tax_dict.update(
{
"unece_type_code": "VAT",
"unece_categ_code": "E",
"amount": 0,
"display_name": "Empty virtual tax",
}
)
if not tax_dict["unece_type_code"]:
raise UserError(
_("Missing UNECE Tax Type on tax '%s'") % tax_dict["display_name"]
)
if not tax_dict["unece_categ_code"]:
raise UserError(
_("Missing UNECE Tax Category on tax '%s'") % tax_dict["display_name"]
)
def _cii_line_applicable_trade_tax_block(self, tax_recordset, parent_node, ns):
tax = {}
if tax_recordset:
tax = ns["tax_speeddict"][tax_recordset.id]
self._cii_check_tax_required_info(tax)
trade_tax = etree.SubElement(parent_node, ns["ram"] + "ApplicableTradeTax")
trade_tax_typecode = etree.SubElement(trade_tax, ns["ram"] + "TypeCode")
trade_tax_typecode.text = tax["unece_type_code"]
trade_tax_categcode = etree.SubElement(trade_tax, ns["ram"] + "CategoryCode")
trade_tax_categcode.text = tax["unece_categ_code"]
# No 'DueDateTypeCode' on lines
if tax.get("amount_type") == "percent":
trade_tax_percent = etree.SubElement(
trade_tax, ns["ram"] + "RateApplicablePercent"
)
trade_tax_percent.text = "%0.*f" % (2, tax["amount"])
def _cii_total_applicable_trade_tax_block(
self, tax_recordset, tax_amount, base_amount, parent_node, ns
):
if ns["level"] == "minimum":
return
tax = {}
if tax_recordset:
tax = ns["tax_speeddict"][tax_recordset.id]
self._cii_check_tax_required_info(tax)
trade_tax = etree.SubElement(parent_node, ns["ram"] + "ApplicableTradeTax")
amount = etree.SubElement(trade_tax, ns["ram"] + "CalculatedAmount")
amount.text = "%0.*f" % (ns["cur_prec"], tax_amount * ns["sign"])
tax_type = etree.SubElement(trade_tax, ns["ram"] + "TypeCode")
tax_type.text = tax["unece_type_code"]
if (
tax["unece_categ_code"] != "S"
and float_is_zero(tax_amount, precision_digits=ns["cur_prec"])
and self.fiscal_position_id
and ns["fp_speeddict"][self.fiscal_position_id.id]["note"]
):
exemption_reason = etree.SubElement(
trade_tax, ns["ram"] + "ExemptionReason"
)
exemption_reason.text = ns["fp_speeddict"][self.fiscal_position_id.id][
"note"
]
base = etree.SubElement(trade_tax, ns["ram"] + "BasisAmount")
base.text = "%0.*f" % (ns["cur_prec"], base_amount * ns["sign"])
tax_categ_code = etree.SubElement(trade_tax, ns["ram"] + "CategoryCode")
tax_categ_code.text = tax["unece_categ_code"]
if tax.get("unece_due_date_code"):
trade_tax_due_date = etree.SubElement(
trade_tax, ns["ram"] + "DueDateTypeCode"
)
trade_tax_due_date.text = tax["unece_due_date_code"]
# Field tax_exigibility is not required, so no error if missing
if tax.get("amount_type") == "percent":
percent = etree.SubElement(trade_tax, ns["ram"] + "RateApplicablePercent")
percent.text = "%0.*f" % (2, tax["amount"])
def _cii_add_trade_settlement_block(self, trade_transaction, ns):
self.ensure_one()
trade_settlement = etree.SubElement(
trade_transaction, ns["ram"] + "ApplicableHeaderTradeSettlement"
)
# ICS, provided by the OCA module account_banking_sepa_direct_debit
if (
ns["level"] != "minimum"
and self.payment_mode_id.payment_method_id.unece_code in DIRECT_DEBIT_CODES
and hasattr(self.company_id, "sepa_creditor_identifier")
and self.company_id.sepa_creditor_identifier
):
ics = etree.SubElement(trade_settlement, ns["ram"] + "CreditorReferenceID")
ics.text = self.company_id.sepa_creditor_identifier
if ns["level"] != "minimum":
payment_ref = etree.SubElement(
trade_settlement, ns["ram"] + "PaymentReference"
)
payment_ref.text = self.name or self.state
invoice_currency = etree.SubElement(
trade_settlement, ns["ram"] + "InvoiceCurrencyCode"
)
invoice_currency.text = ns["currency"]
if (
self.payment_mode_id
and not self.payment_mode_id.payment_method_id.unece_code
):
raise UserError(
_("Missing UNECE code on payment method '%s'")
% self.payment_mode_id.payment_method_id.display_name
)
if ns["level"] != "minimum" and not (
self.move_type == "out_refund"
and self.payment_mode_id
and self.payment_mode_id.payment_method_id.unece_code in CREDIT_TRF_CODES
):
self._cii_add_trade_settlement_payment_means_block(trade_settlement, ns)
at_least_one_tax = False
tax_basis_total = 0.0
for tline in self.line_ids.filtered(lambda x: x.tax_line_id):
tax_base_amount = tline.tax_base_amount
self._cii_total_applicable_trade_tax_block(
tline.tax_line_id,
tline.price_subtotal,
tax_base_amount,
trade_settlement,
ns,
)
tax_basis_total += tax_base_amount
at_least_one_tax = True
tax_zero_amount = {} # key = tax recordset, value = base
for line in self.line_ids:
for tax in line.tax_ids.filtered(
lambda t: float_is_zero(t.amount, precision_digits=ns["cur_prec"])
):
tax_zero_amount.setdefault(tax, 0.0)
tax_zero_amount[tax] += line.price_subtotal
for tax, tax_base_amount in tax_zero_amount.items():
self._cii_total_applicable_trade_tax_block(
tax, 0, tax_base_amount, trade_settlement, ns
)
tax_basis_total += tax_base_amount
at_least_one_tax = True
if not at_least_one_tax:
self._cii_total_applicable_trade_tax_block(None, 0, 0, trade_settlement, ns)
if ns["level"] != "minimum":
self._cii_trade_payment_terms_block(trade_settlement, ns)
self._cii_monetary_summation_block(trade_settlement, tax_basis_total, ns)
# When you create a full refund from an invoice, Odoo will
# set the field reversed_entry_id
if self.reversed_entry_id and self.reversed_entry_id.state == "posted":
inv_ref_doc = etree.SubElement(
trade_settlement, ns["ram"] + "InvoiceReferencedDocument"
)
inv_ref_doc_num = etree.SubElement(
inv_ref_doc, ns["ram"] + "IssuerAssignedID"
)
inv_ref_doc_num.text = self.reversed_entry_id.name
self._cii_add_date(
"FormattedIssueDateTime",
self.reversed_entry_id.invoice_date,
inv_ref_doc,
ns,
date_ns_type="qdt",
)
def _cii_monetary_summation_block(self, trade_settlement, tax_basis_total, ns):
sums = etree.SubElement(
trade_settlement,
ns["ram"] + "SpecifiedTradeSettlementHeaderMonetarySummation",
)
if ns["level"] != "minimum":
line_total = etree.SubElement(sums, ns["ram"] + "LineTotalAmount")
line_total.text = "%0.*f" % (
ns["cur_prec"],
self.amount_untaxed * ns["sign"],
)
# In Factur-X, charge total amount and allowance total are not required
# charge_total = etree.SubElement(
# sums, ns['ram'] + 'ChargeTotalAmount')
# charge_total.text = '0.00'
# allowance_total = etree.SubElement(
# sums, ns['ram'] + 'AllowanceTotalAmount')
# allowance_total.text = '0.00'
tax_basis_total_amt = etree.SubElement(sums, ns["ram"] + "TaxBasisTotalAmount")
tax_basis_total_amt.text = "%0.*f" % (
ns["cur_prec"],
tax_basis_total * ns["sign"],
)
tax_total = etree.SubElement(
sums, ns["ram"] + "TaxTotalAmount", currencyID=ns["currency"]
)
tax_total.text = "%0.*f" % (ns["cur_prec"], self.amount_tax * ns["sign"])
total = etree.SubElement(sums, ns["ram"] + "GrandTotalAmount")
total.text = "%0.*f" % (ns["cur_prec"], self.amount_total * ns["sign"])
if ns["level"] != "minimum":
prepaid = etree.SubElement(sums, ns["ram"] + "TotalPrepaidAmount")
prepaid.text = "%0.*f" % (
ns["cur_prec"],
(self.amount_total - self.amount_residual) * ns["sign"],
)
residual = etree.SubElement(sums, ns["ram"] + "DuePayableAmount")
residual.text = "%0.*f" % (ns["cur_prec"], self.amount_residual * ns["sign"])
def _set_iline_product_information(self, iline, trade_product, ns):
if iline.product_id:
if iline.product_id.barcode:
barcode = etree.SubElement(
trade_product, ns["ram"] + "GlobalID", schemeID="0160"
)
# 0160 = GS1 Global Trade Item Number (GTIN, EAN)
barcode.text = iline.product_id.barcode
if ns["level"] in PROFILES_EN_UP and iline.product_id.default_code:
product_code = etree.SubElement(
trade_product, ns["ram"] + "SellerAssignedID"
)
product_code.text = iline.product_id.default_code
product_name = etree.SubElement(trade_product, ns["ram"] + "Name")
product_name.text = iline.name
if (
ns["level"] in PROFILES_EN_UP
and iline.product_id
and iline.product_id.description_sale
):
product_desc = etree.SubElement(trade_product, ns["ram"] + "Description")
product_desc.text = iline.product_id.description_sale
def _set_iline_product_attributes(self, iline, trade_product, ns):
if iline.product_id and ns["level"] in PROFILES_EN_UP:
product = iline.product_id
for attrib_val in product.product_template_attribute_value_ids:
attrib_value_rec = attrib_val.product_attribute_value_id
attrib_value = attrib_value_rec.name
attribute_name = attrib_value_rec.attribute_id.name
product_charact = etree.SubElement(
trade_product, ns["ram"] + "ApplicableProductCharacteristic"
)
product_charact_desc = etree.SubElement(
product_charact, ns["ram"] + "Description"
)
product_charact_desc.text = attribute_name
product_charact_value = etree.SubElement(
product_charact, ns["ram"] + "Value"
)
product_charact_value.text = attrib_value
if (
hasattr(product, "hs_code_id")
and product.type in ("product", "consu")
and product.get_hs_code_recursively()
):
product_classification = etree.SubElement(
trade_product, ns["ram"] + "DesignatedProductClassification"
)
product_classification_code = etree.SubElement(
product_classification, ns["ram"] + "ClassCode", listID="HS"
)
product_classification_code.text = product.hs_code_id.local_code
# origin_country_id and hs_code_id are provided
# by the OCA module product_harmonized_system
if (
hasattr(product, "origin_country_id")
and product.type in ("product", "consu")
and product.origin_country_id
):
origin_trade_country = etree.SubElement(
trade_product, ns["ram"] + "OriginTradeCountry"
)
origin_trade_country_code = etree.SubElement(
origin_trade_country, ns["ram"] + "ID"
)
origin_trade_country_code.text = product.origin_country_id.code
def _cii_add_invoice_line_block(self, trade_transaction, iline, line_number, ns):
self.ensure_one()
line_item = etree.SubElement(
trade_transaction, ns["ram"] + "IncludedSupplyChainTradeLineItem"
)
line_doc = etree.SubElement(
line_item, ns["ram"] + "AssociatedDocumentLineDocument"
)
etree.SubElement(line_doc, ns["ram"] + "LineID").text = str(line_number)
trade_product = etree.SubElement(line_item, ns["ram"] + "SpecifiedTradeProduct")
self._set_iline_product_information(iline, trade_product, ns)
self._set_iline_product_attributes(iline, trade_product, ns)
line_trade_agreement = etree.SubElement(
line_item, ns["ram"] + "SpecifiedLineTradeAgreement"
)
if float_compare(iline.price_unit, 0, precision_digits=ns["price_prec"]) < 0:
raise UserError(
_(
"The Factur-X standard specify that unit prices can't be "
"negative. The unit price of line '%s' is negative. You "
"should generate a customer refund for that line."
)
% iline.name
)
# convert gross price_unit to tax_excluded value
taxres = iline.tax_ids.compute_all(iline.price_unit)
gross_price_val = float_round(
taxres["total_excluded"], precision_digits=ns["price_prec"]
)
# Use oline.price_subtotal/qty to compute net unit price to be sure
# to get a *tax_excluded* net unit price
if float_is_zero(iline.quantity, precision_digits=ns["qty_prec"]):
net_price_val = 0.0
else:
net_price_val = float_round(
iline.price_subtotal / float(iline.quantity),
precision_digits=ns["price_prec"],
)
if ns["level"] in PROFILES_EN_UP:
gross_price = etree.SubElement(
line_trade_agreement, ns["ram"] + "GrossPriceProductTradePrice"
)
gross_price_amount = etree.SubElement(
gross_price, ns["ram"] + "ChargeAmount"
)
gross_price_amount.text = "%0.*f" % (ns["price_prec"], gross_price_val)
fc_discount = float_compare(
iline.discount, 0.0, precision_digits=ns["disc_prec"]
)
if fc_discount in [-1, 1]:
trade_allowance = etree.SubElement(
gross_price, ns["ram"] + "AppliedTradeAllowanceCharge"
)
charge_indic = etree.SubElement(
trade_allowance, ns["ram"] + "ChargeIndicator"
)
indicator = etree.SubElement(charge_indic, ns["udt"] + "Indicator")
if fc_discount == 1:
indicator.text = "false"
else:
indicator.text = "true"
actual_amount = etree.SubElement(
trade_allowance, ns["ram"] + "ActualAmount"
)
actual_amount_val = float_round(
gross_price_val - net_price_val, precision_digits=ns["price_prec"]
)
actual_amount.text = "%0.*f" % (
ns["price_prec"],
actual_amount_val * ns["sign"],
)
net_price = etree.SubElement(
line_trade_agreement, ns["ram"] + "NetPriceProductTradePrice"
)
net_price_amount = etree.SubElement(net_price, ns["ram"] + "ChargeAmount")
net_price_amount.text = "%0.*f" % (ns["price_prec"], net_price_val)
line_trade_delivery = etree.SubElement(
line_item, ns["ram"] + "SpecifiedLineTradeDelivery"
)
if iline.product_uom_id and iline.product_uom_id.unece_code:
unitCode = iline.product_uom_id.unece_code
else:
unitCode = "C62"
if not iline.product_uom_id:
logger.warning(
"No unit of measure on invoice line '%s', "
"using C62 (piece) as fallback",
iline.name,
)
else:
logger.warning(
"Missing UNECE Code on unit of measure %s, "
"using C62 (piece) as fallback",
iline.product_uom_id.name,
)
billed_qty = etree.SubElement(
line_trade_delivery, ns["ram"] + "BilledQuantity", unitCode=unitCode
)
billed_qty.text = "%0.*f" % (ns["qty_prec"], iline.quantity * ns["sign"])
line_trade_settlement = etree.SubElement(
line_item, ns["ram"] + "SpecifiedLineTradeSettlement"
)
if iline.tax_ids:
for tax in iline.tax_ids:
self._cii_line_applicable_trade_tax_block(
tax, line_trade_settlement, ns
)
else:
self._cii_line_applicable_trade_tax_block(None, line_trade_settlement, ns)
# Fields start_date and end_date are provided by the OCA
# module account_invoice_start_end_dates
if (
ns["level"] in PROFILES_EN_UP
and hasattr(iline, "start_date")
and hasattr(iline, "end_date")
and iline.start_date
and iline.end_date
):
bill_period = etree.SubElement(
line_trade_settlement, ns["ram"] + "BillingSpecifiedPeriod"
)
self._cii_add_date("StartDateTime", iline.start_date, bill_period, ns)
self._cii_add_date("EndDateTime", iline.end_date, bill_period, ns)
subtotal = etree.SubElement(
line_trade_settlement,
ns["ram"] + "SpecifiedTradeSettlementLineMonetarySummation",
)
subtotal_amount = etree.SubElement(subtotal, ns["ram"] + "LineTotalAmount")
subtotal_amount.text = "%0.*f" % (
ns["cur_prec"],
iline.price_subtotal * ns["sign"],
)
def generate_facturx_xml(self):
self.ensure_one()
assert self.move_type in (
"out_invoice",
"out_refund",
), "only works for customer invoice and refunds"
dpo = self.env["decimal.precision"]
level = self.company_id.facturx_level or "en16931"
refund_type = self.company_id.facturx_refund_type or "381"
sign = 1
if self.move_type == "out_refund" and refund_type == "380":
sign = -1
lang = self.partner_id.lang or self.env.user.lang or "en_US"
tax_speeddict = self.company_id._get_tax_unece_speeddict()
fp_speeddict = self.company_id._get_fiscal_position_speeddict(lang=lang)
self = self.with_context(lang=lang)
nsmap = {
"xsi": "http://www.w3.org/2001/XMLSchema-instance",
"rsm": "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100",
"ram": "urn:un:unece:uncefact:data:standard:"
"ReusableAggregateBusinessInformationEntity:100",
"qdt": "urn:un:unece:uncefact:data:standard:QualifiedDataType:100",
"udt": "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100",
}
ns = {
"rsm": "{urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100}",
"ram": "{urn:un:unece:uncefact:data:standard:"
"ReusableAggregateBusinessInformationEntity:100}",
"qdt": "{urn:un:unece:uncefact:data:standard:QualifiedDataType:100}",
"udt": "{urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100}",
"level": level,
"refund_type": refund_type,
"sign": sign,
"currency": self.currency_id.name,
"cur_prec": self.currency_id.decimal_places,
"price_prec": dpo.precision_get("Product Price"),
"disc_prec": dpo.precision_get("Discount"),
"qty_prec": dpo.precision_get("Product Unit of Measure"),
"lang": lang,
"tax_speeddict": tax_speeddict,
"fp_speeddict": fp_speeddict,
}
root = etree.Element(ns["rsm"] + "CrossIndustryInvoice", nsmap=nsmap)
self._cii_add_document_context_block(root, ns)
self._cii_add_header_block(root, ns)
trade_transaction = etree.SubElement(
root, ns["rsm"] + "SupplyChainTradeTransaction"
)
if ns["level"] in ("extended", "en16931", "basic"):
line_number = 0
for iline in self.invoice_line_ids.filtered(lambda x: not x.display_type):
line_number += 1
self._cii_add_invoice_line_block(
trade_transaction, iline, line_number, ns
)
self._cii_add_trade_agreement_block(trade_transaction, ns)
self._cii_add_trade_delivery_block(trade_transaction, ns)
self._cii_add_trade_settlement_block(trade_transaction, ns)
xml_byte = etree.tostring(
root, pretty_print=True, encoding="UTF-8", xml_declaration=True
)
logger.debug("Factur-X XML file generated for invoice ID %d", self.id)
logger.debug(xml_byte.decode("utf-8"))
try:
xml_check_xsd(xml_byte, flavor="factur-x", level=ns["level"])
except Exception as e:
raise UserError(str(e)) from e
return (xml_byte, level)
def _prepare_pdf_metadata(self):
self.ensure_one()
inv_type = self.move_type == "out_refund" and _("Refund") or _("Invoice")
if self.invoice_date:
invoice_date = format_date(
self.env, self.invoice_date, lang_code=self.partner_id.lang
)
else:
invoice_date = _("(no date)")
if self.state == "posted":
invoice_number = self.name
else:
invoice_number = self._fields["state"].convert_to_export(self.state, self)
format_vals = {
"company_name": self.company_id.name,
"invoice_type": inv_type,
"invoice_number": invoice_number,
"invoice_date": invoice_date,
}
pdf_metadata = {
"author": format_vals["company_name"],
"keywords": ", ".join([inv_type, _("Factur-X")]),
"title": _(
"{company_name}: {invoice_type} {invoice_number} dated {invoice_date}"
).format(**format_vals),
"subject": _(
"Factur-X {invoice_type} {invoice_number} dated {invoice_date} "
"issued by {company_name}"
).format(**format_vals),
}
return pdf_metadata
def _prepare_facturx_attachments(self):
# This method is designed to be inherited in other modules
self.ensure_one()
return {}
def regular_pdf_invoice_to_facturx_invoice(self, pdf_content):
self.ensure_one()
assert pdf_content, "Missing pdf_content"
if self.move_type in ("out_invoice", "out_refund"):
facturx_xml_bytes, level = self.generate_facturx_xml()
pdf_metadata = self._prepare_pdf_metadata()
lang = (
self.partner_id.lang and self.partner_id.lang.replace("_", "-") or None
)
# Generate a new PDF with XML file as attachment
attachments = self._prepare_facturx_attachments()
pdf_content = generate_from_binary(
pdf_content,
facturx_xml_bytes,
flavor="factur-x",
level=level,
check_xsd=False,
pdf_metadata=pdf_metadata,
lang=lang,
attachments=attachments,
)
logger.info("%s file added to PDF invoice", FACTURX_FILENAME)
return pdf_content
| 44.528282 | 41,723 |
1,274 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2021 Akretion France (http://www.akretion.com)
# @author: Alexis de Lattre <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
class IrActionsReport(models.Model):
_inherit = "ir.actions.report"
def _post_pdf(self, save_in_attachment, pdf_content=None, res_ids=None):
"""We go through that method when the PDF is generated for the
1st time (res_id has a value) and also
when it is read from the attachment (res_ids=None).
This method is specific to QWeb"""
amo = self.env["account.move"]
invoice_reports = amo._get_invoice_report_names()
if (
len(self) == 1
and self.report_name in invoice_reports
and res_ids
and len(res_ids) == 1
and not self.env.context.get("no_embedded_factur-x_xml")
):
inv = amo.browse(res_ids[0])
if inv._xml_format_in_pdf_invoice() == "factur-x":
pdf_content = inv.regular_pdf_invoice_to_facturx_invoice(
pdf_content=pdf_content
)
return super()._post_pdf(
save_in_attachment, pdf_content=pdf_content, res_ids=res_ids
)
| 39.8125 | 1,274 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.