859 lines
33 KiB
Python
859 lines
33 KiB
Python
# -*- coding: utf-8 -*-
|
|
# The COPYRIGHT file at the top level of this repository contains the full
|
|
# copyright notices and license terms.
|
|
import logging
|
|
import os
|
|
import re
|
|
import base64
|
|
import random
|
|
import xmlsig
|
|
import hashlib
|
|
import datetime
|
|
import math
|
|
from decimal import Decimal
|
|
from jinja2 import Environment, FileSystemLoader
|
|
from lxml import etree
|
|
from operator import attrgetter
|
|
from trytond.model import ModelView, fields
|
|
from trytond.pool import Pool, PoolMeta
|
|
from trytond.pyson import Bool, Eval
|
|
from trytond.transaction import Transaction
|
|
from trytond.wizard import Wizard, StateView, StateTransition, Button
|
|
from trytond import backend
|
|
from trytond.i18n import gettext
|
|
from trytond.exceptions import UserError
|
|
from trytond.modules.certificate_manager.certificate_manager import (
|
|
ENCODING_DER)
|
|
|
|
FACTURAE_SCHEMA_VERSION = '3.2.2'
|
|
|
|
# Get from XSD scheme of Facturae 3.2.2
|
|
# http://www.facturae.gob.es/formato/Versiones/Facturaev3_2_2.xml
|
|
RECTIFICATIVE_REASON_CODES = [
|
|
("01", "Invoice number", "Número de la factura"),
|
|
("02", "Invoice serial number", "Serie de la factura"),
|
|
("03", "Issue date", "Fecha expedición"),
|
|
("04", "Name and surnames/Corporate name-Issuer (Sender)",
|
|
"Nombre y apellidos/Razón Social-Emisor"),
|
|
("05", "Name and surnames/Corporate name-Receiver",
|
|
"Nombre y apellidos/Razón Social-Receptor"),
|
|
("06", "Issuer's Tax Identification Number",
|
|
"Identificación fiscal Emisor/obligado"),
|
|
("07", "Receiver's Tax Identification Number",
|
|
"Identificación fiscal Receptor"),
|
|
("08", "Issuer's address", "Domicilio Emisor/Obligado"),
|
|
("09", "Receiver's address", "Domicilio Receptor"),
|
|
("10", "Item line", "Detalle Operación"),
|
|
("11", "Applicable Tax Rate", "Porcentaje impositivo a aplicar"),
|
|
("12", "Applicable Tax Amount", "Cuota tributaria a aplicar"),
|
|
("13", "Applicable Date/Period", "Fecha/Periodo a aplicar"),
|
|
("14", "Invoice Class", "Clase de factura"),
|
|
("15", "Legal literals", "Literales legales"),
|
|
("16", "Taxable Base", "Base imponible"),
|
|
("80", "Calculation of tax outputs", "Cálculo de cuotas repercutidas"),
|
|
("81", "Calculation of tax inputs", "Cálculo de cuotas retenidas"),
|
|
("82",
|
|
"Taxable Base modified due to return of packages and packaging "
|
|
"materials",
|
|
"Base imponible modificada por devolución de envases / embalajes"),
|
|
("83", "Taxable Base modified due to discounts and rebates",
|
|
"Base imponible modificada por descuentos y bonificaciones"),
|
|
("84",
|
|
"Taxable Base modified due to firm court ruling or administrative "
|
|
"decision",
|
|
"Base imponible modificada por resolución firme, judicial o "
|
|
"administrativa"),
|
|
("85",
|
|
"Taxable Base modified due to unpaid outputs where there is a "
|
|
"judgement opening insolvency proceedings",
|
|
"Base imponible modificada cuotas repercutidas no satisfechas. Auto "
|
|
"de declaración de concurso"),
|
|
]
|
|
# UoM Type from UN/CEFACT
|
|
UOM_CODE2TYPE = {
|
|
'u': '01',
|
|
'h': '02',
|
|
'kg': '03',
|
|
'g': '21',
|
|
's': '34',
|
|
'm': '25',
|
|
'km': '22',
|
|
'cm': '16',
|
|
'mm': '26',
|
|
'm³': '33',
|
|
'l': '04',
|
|
}
|
|
# Missing types in product/uom.xml
|
|
# "06", Boxes-BX
|
|
# "07", Trays, one layer no cover, plastic-DS
|
|
# "08", Barrels-BA
|
|
# "09", Jerricans, cylindrical-JY
|
|
# "10", Bags-BG
|
|
# "11", Carboys, non-protected-CO
|
|
# "12", Bottles, non-protected, cylindrical-BO
|
|
# "13", Canisters-CI
|
|
# "14", Tetra Briks
|
|
# "15", Centiliters-CLT
|
|
# "17", Bins-BI
|
|
# "18", Dozens
|
|
# "19", Cases-CS
|
|
# "20", Demijohns, non-protected-DJ
|
|
# "23", Cans, rectangular-CA
|
|
# "24", Bunches-BH
|
|
# "27", 6-Packs
|
|
# "28", Packages-PK
|
|
# "29", Portions
|
|
# "30", Rolls-RO
|
|
# "31", Envelopes-EN
|
|
# "32", Tubs-TB
|
|
# "35", Watt-WTT
|
|
FACe_REQUIRED_FIELDS = ['facturae_person_type', 'facturae_residence_type']
|
|
|
|
_slugify_strip_re = re.compile(r'[^\w\s-]')
|
|
_slugify_hyphenate_re = re.compile(r'[-\s]+')
|
|
|
|
DEFAULT_FACTURAE_TEMPLATE = 'template_facturae_3.2.2.xml'
|
|
DEFAULT_FACTURAE_SCHEMA = 'Facturaev3_2_2-offline.xml'
|
|
|
|
|
|
def slugify(value):
|
|
if not isinstance(value, str):
|
|
value = str(value)
|
|
value = str(_slugify_strip_re.sub('', value).strip().lower())
|
|
return _slugify_hyphenate_re.sub('-', value)
|
|
|
|
|
|
def module_path():
|
|
return os.path.dirname(os.path.abspath(__file__))
|
|
|
|
|
|
class Invoice(metaclass=PoolMeta):
|
|
__name__ = 'account.invoice'
|
|
credited_invoices = fields.Function(fields.One2Many('account.invoice',
|
|
None, 'Credited Invoices'),
|
|
'get_credited_invoices', searcher='search_credited_invoices')
|
|
rectificative_reason_code = fields.Selection(
|
|
[(None, "")] + [(x[0], x[1]) for x in RECTIFICATIVE_REASON_CODES],
|
|
'Rectificative Reason Code', sort=False,
|
|
states={
|
|
'invisible': ~Bool(Eval('credited_invoices')),
|
|
'required': (Bool(Eval('credited_invoices'))
|
|
& (Eval('state').in_(['posted', 'paid']))),
|
|
}, depends=['credited_invoices'])
|
|
invoice_facturae = fields.Binary('Factura-e',
|
|
filename='invoice_facturae_filename')
|
|
invoice_facturae_filename = fields.Function(fields.Char(
|
|
'Factura-e filename'), 'get_invoice_facturae_filename')
|
|
invoice_facturae_sent = fields.Boolean('Factura-e Sent')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(Invoice, cls).__setup__()
|
|
cls._check_modify_exclude |= {'invoice_facturae', 'invoice_facturae_sent'}
|
|
cls._buttons.update({
|
|
'generate_facturae_wizard': {
|
|
'invisible': ((Eval('type') != 'out')
|
|
| ~Eval('state').in_(['posted', 'paid'])),
|
|
'readonly': Bool(Eval('invoice_facturae_sent')),
|
|
}
|
|
})
|
|
|
|
@classmethod
|
|
def copy(cls, invoices, default=None):
|
|
if default is None:
|
|
default = {}
|
|
else:
|
|
default = default.copy()
|
|
default.setdefault('invoice_facturae', None)
|
|
default.setdefault('rectificative_reason_code', None)
|
|
default.setdefault('invoice_facturae_sent', None)
|
|
return super(Invoice, cls).copy(invoices, default=default)
|
|
|
|
def get_credited_invoices(self, name):
|
|
pool = Pool()
|
|
InvoiceLine = pool.get('account.invoice.line')
|
|
invoices = set()
|
|
for line in self.lines:
|
|
if isinstance(line.origin, InvoiceLine) and line.origin.invoice:
|
|
invoices.add(line.origin.invoice.id)
|
|
return list(invoices)
|
|
|
|
@classmethod
|
|
def search_credited_invoices(cls, name, clause):
|
|
return [('lines.origin.invoice',) + tuple(clause[1:3])
|
|
+ ('account.invoice.line',) + tuple(clause[3:])]
|
|
|
|
def get_invoice_facturae_filename(self, name):
|
|
return 'facturae-%s.xsig' % slugify(self.number)
|
|
|
|
@property
|
|
def rectificative_reason_spanish_description(self):
|
|
if self.rectificative_reason_code:
|
|
for code, _, spanish_description in RECTIFICATIVE_REASON_CODES:
|
|
if code == self.rectificative_reason_code:
|
|
return spanish_description
|
|
|
|
@property
|
|
def taxes_outputs(self):
|
|
"""Return list of 'impuestos repecutidos'"""
|
|
return [inv_tax for inv_tax in self.taxes
|
|
if inv_tax.tax and inv_tax.tax.rate >= Decimal(0)]
|
|
|
|
@property
|
|
def taxes_withheld(self):
|
|
"""Return list of 'impuestos retenidos'"""
|
|
return [inv_tax for inv_tax in self.taxes
|
|
if inv_tax.tax and inv_tax.tax.rate < Decimal(0)]
|
|
|
|
@property
|
|
def payment_details(self):
|
|
return sorted([ml for ml in self.move.lines
|
|
if ml.account.type.receivable],
|
|
key=attrgetter('maturity_date'))
|
|
|
|
@classmethod
|
|
def draft(cls, invoices):
|
|
invoice_facturae_sends = [invoice for invoice in invoices if invoice.invoice_facturae_sent]
|
|
if invoice_facturae_sends:
|
|
names = ', '.join(m.rec_name for m in invoice_facturae_sends[:5])
|
|
if len(invoice_facturae_sends) > 5:
|
|
names += '...'
|
|
raise UserError(gettext('account_invoice_facturae.msg_draft_invoice_facturae_sent',
|
|
invoices=names))
|
|
|
|
cls.write(invoices, {
|
|
'invoice_facturae': None,
|
|
})
|
|
super(Invoice, cls).draft(invoices)
|
|
|
|
@classmethod
|
|
def post(cls, invoices):
|
|
super(Invoice, cls).post(invoices)
|
|
|
|
for invoice in invoices:
|
|
cls.__queue__.generate_facturae(invoice)
|
|
|
|
def _credit(self, **values):
|
|
credit = super(Invoice, self)._credit(**values)
|
|
rectificative_reason_code = Transaction().context.get(
|
|
'rectificative_reason_code')
|
|
if rectificative_reason_code:
|
|
credit.rectificative_reason_code = rectificative_reason_code
|
|
return credit
|
|
|
|
@classmethod
|
|
@ModelView.button_action(
|
|
'account_invoice_facturae.wizard_generate_signed_facturae')
|
|
def generate_facturae_wizard(cls, invoices):
|
|
pass
|
|
|
|
def generate_facturae(self, certificate=None, service=None):
|
|
pool = Pool()
|
|
Configuration = pool.get('account.configuration')
|
|
Invoice = pool.get('account.invoice')
|
|
|
|
config = Configuration(1)
|
|
transaction = Transaction()
|
|
|
|
if self.type != 'out' or self.state not in ('posted', 'paid'):
|
|
return
|
|
# send facturae to service
|
|
if not service and config.facturae_service:
|
|
service = config.facturae_service
|
|
if service:
|
|
if not self.invoice_facturae:
|
|
facturae_content = self.get_facturae()
|
|
self._validate_facturae(facturae_content)
|
|
if backend.name != 'sqlite':
|
|
invoice_facturae = self._sign_facturae(facturae_content,
|
|
'default', certificate)
|
|
else:
|
|
invoice_facturae = facturae_content
|
|
self.invoice_facturae = invoice_facturae
|
|
self.save()
|
|
|
|
if self.invoice_facturae and service != 'only_file':
|
|
with transaction.set_context(
|
|
queue_scheduled_at=config.invoice_facturae_after):
|
|
Invoice.__queue__.send_facturae(self, service)
|
|
|
|
def send_facturae(self, service):
|
|
Invoice = Pool().get('account.invoice')
|
|
|
|
method = 'send_facturae_%s' % service
|
|
getattr(Invoice, method)(self)
|
|
|
|
def get_facturae(self):
|
|
jinja_env = Environment(
|
|
loader=FileSystemLoader(module_path()),
|
|
trim_blocks=True,
|
|
lstrip_blocks=True,
|
|
)
|
|
template = DEFAULT_FACTURAE_TEMPLATE
|
|
return self._get_jinja_template(jinja_env, template).render(
|
|
self._get_content_to_render(), ).encode('utf-8')
|
|
|
|
def _get_jinja_template(self, jinja_env, template):
|
|
return jinja_env.get_template(template)
|
|
|
|
def _get_content_to_render(self):
|
|
"""Return the content to render in factura-e XML file"""
|
|
pool = Pool()
|
|
Currency = pool.get('currency.currency')
|
|
Invoice = pool.get('account.invoice')
|
|
Date = pool.get('ir.date')
|
|
Rate = pool.get('currency.currency.rate')
|
|
|
|
# These are an assert because it shouldn't happen
|
|
assert self.invoice_date <= Date.today(), (
|
|
"Invoice date of invoice %s is in the future" % self.id)
|
|
assert len(self.credited_invoices) < 2, (
|
|
"Too much credited invoices for invoice %s" % self.id)
|
|
assert not self.credited_invoices or self.rectificative_reason_code, (
|
|
"Missing rectificative_reason_code for invoice %s with credited "
|
|
"invoices" % self.id)
|
|
assert len(self.taxes_outputs) > 0, (
|
|
"Missing some tax in invoice %s" % self.id)
|
|
|
|
for field in FACe_REQUIRED_FIELDS:
|
|
if (not getattr(self.invoice_address, field)
|
|
or not getattr(self.company, field)):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.party_facturae_fields',
|
|
party=self.party.rec_name,
|
|
invoice=self.rec_name,
|
|
field=field))
|
|
if (not self.company.party.tax_identifier
|
|
or len(self.company.party.tax_identifier.code) < 3
|
|
or len(self.company.party.tax_identifier.code) > 30):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.company_vat_identifier',
|
|
party=self.company.party.rec_name))
|
|
|
|
company_address = self.company.party.address_get(type='invoice')
|
|
if (not company_address
|
|
or not company_address.street
|
|
or not company_address.postal_code
|
|
or not company_address.city
|
|
or not company_address.subdivision
|
|
or not company_address.country):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.company_address_fields',
|
|
party=self.company.party.rec_name))
|
|
|
|
if (not self.party.tax_identifier
|
|
or len(self.party.tax_identifier.code) < 3
|
|
or len(self.party.tax_identifier.code) > 30):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.party_vat_identifier',
|
|
party=self.party.rec_name,
|
|
invoice=self.rec_name))
|
|
if (self.invoice_address.facturae_person_type == 'F'
|
|
and len(self.party.name.split(' ', 2)) < 2):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.party_name_surname',
|
|
party=self.party.rec_name,
|
|
invoice=self.rec_name))
|
|
if (not self.invoice_address.street
|
|
or not self.invoice_address.postal_code
|
|
or not self.invoice_address.city
|
|
or not self.invoice_address.subdivision
|
|
or not self.invoice_address.country):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.invoice_address_fields',
|
|
invoice=self.rec_name))
|
|
|
|
euro, = Currency.search([('code', '=', 'EUR')], limit=1)
|
|
if self.currency != euro:
|
|
assert (euro.rate == Decimal(1)
|
|
or self.currency.rate == Decimal(1)), (
|
|
"Euro currency or the currency of invoice %s must to be the "
|
|
"base currency" % self.id)
|
|
if euro.rate == Decimal(1):
|
|
rates = Rate.search([
|
|
('currency', '=', self.currency),
|
|
('date', '<=', self.invoice_date),
|
|
], limit=1, order=[('date', 'DESC')])
|
|
if not rates:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.no_rate',
|
|
currency=self.currenc.name,
|
|
date=self.invoice_date.strftime('%d/%m/%Y')))
|
|
exchange_rate = rates[0].rate
|
|
exchange_rate_date = rates[0].date
|
|
else:
|
|
rates = Rate.search([
|
|
('currency', '=', euro),
|
|
('date', '<=', self.invoice_date),
|
|
], limit=1, order=[('date', 'DESC')])
|
|
if not rates:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.no_rate',
|
|
currency=euro.name,
|
|
date=self.invoice_date.strftime('%d/%m/%Y')))
|
|
exchange_rate = Decimal(1) / rates[0].rate
|
|
exchange_rate_date = rates[0].date
|
|
else:
|
|
exchange_rate = exchange_rate_date = None
|
|
|
|
for invoice_tax in self.taxes:
|
|
assert invoice_tax.tax, 'Empty tax in invoice %s' % self.id
|
|
assert (invoice_tax.tax.type == 'percentage'), (
|
|
'Unsupported non percentage tax %s of invoice %s'
|
|
% (invoice_tax.tax.id, self.id))
|
|
|
|
for move_line in self.payment_details:
|
|
if not move_line.payment_type:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.missing_payment_type',
|
|
invoice=self.rec_name))
|
|
if not move_line.payment_type.facturae_type:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.'
|
|
'missing_payment_type_facturae_type',
|
|
payment_type=move_line.payment_type.rec_name,
|
|
invoice=self.rec_name))
|
|
if move_line.payment_type.facturae_type in ('02', '04'):
|
|
if not hasattr(move_line, 'account_bank'):
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.'
|
|
'missing_account_bank_module',
|
|
payment_type=move_line.payment_type.rec_name,
|
|
invoice=self.rec_name))
|
|
if not move_line.bank_account:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.missing_bank_account',
|
|
invoice=self.rec_name))
|
|
if not [n for n in move_line.bank_account.numbers
|
|
if n.type == 'iban']:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.missing_iban',
|
|
bank_account=move_line.bank_account.rec_name,
|
|
invoice=self.rec_name))
|
|
|
|
return {
|
|
'invoice': self,
|
|
'Decimal': Decimal,
|
|
'Currency': Currency,
|
|
'Invoice': Invoice,
|
|
'euro': euro,
|
|
'exchange_rate': exchange_rate,
|
|
'exchange_rate_date': exchange_rate_date,
|
|
'UOM_CODE2TYPE': UOM_CODE2TYPE,
|
|
}
|
|
|
|
def _validate_facturae(self, xml_string, schema_file_path=None):
|
|
"""
|
|
Inspired by https://github.com/pedrobaeza/l10n-spain/blob/d01d049934db55130471e284012be7c860d987eb/l10n_es_facturae/wizard/create_facturae.py
|
|
"""
|
|
logger = logging.getLogger('account_invoice_facturae')
|
|
|
|
if not schema_file_path:
|
|
schema_file_path = os.path.join(
|
|
module_path(),
|
|
DEFAULT_FACTURAE_SCHEMA)
|
|
with open(schema_file_path, encoding='utf-8') as schema_file:
|
|
facturae_schema = etree.XMLSchema(file=schema_file)
|
|
logger.debug("%s loaded" % schema_file_path)
|
|
try:
|
|
facturae_schema.assertValid(etree.fromstring(xml_string))
|
|
logger.debug("Factura-e XML of invoice %s validated",
|
|
self.rec_name)
|
|
except Exception as e:
|
|
logger.warning("Error validating generated Factura-e file",
|
|
exc_info=True)
|
|
logger.debug(xml_string)
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.invalid_factura_xml_file',
|
|
invoice=self.rec_name, message=e))
|
|
return True
|
|
|
|
def _sign_facturae(self, xml_string, service='default', certificate=None):
|
|
"""
|
|
Inspired by https://github.com/pedrobaeza/l10n-spain/blob/d01d049934db55130471e284012be7c860d987eb/l10n_es_facturae/wizard/create_facturae.py
|
|
"""
|
|
pool = Pool()
|
|
Configuration = pool.get('account.configuration')
|
|
|
|
if not certificate:
|
|
certificate = Configuration(1).facturae_certificate
|
|
if not certificate:
|
|
raise UserError(gettext(
|
|
'account_invoice_facturae.msg_missing_certificate'))
|
|
|
|
logger = logging.getLogger('account_invoice_facturae')
|
|
|
|
def _sign_file(cert, request):
|
|
key = cert.load_pem_key()
|
|
pem = cert.load_pem_certificate()
|
|
|
|
# DER is an ASN.1 encoding type
|
|
crt = pem.public_bytes(ENCODING_DER)
|
|
|
|
# Set variables values
|
|
rand_min = 1
|
|
rand_max = 99999
|
|
signature_id = "Signature%05d" % random.randint(rand_min, rand_max)
|
|
signed_properties_id = (
|
|
signature_id
|
|
+ "-SignedProperties%05d" % random.randint(rand_min, rand_max)
|
|
)
|
|
key_info_id = "KeyInfo%05d" % random.randint(rand_min, rand_max)
|
|
reference_id = "Reference%05d" % random.randint(rand_min, rand_max)
|
|
object_id = "Object%05d" % random.randint(rand_min, rand_max)
|
|
etsi = "http://uri.etsi.org/01903/v1.3.2#"
|
|
sig_policy_identifier = (
|
|
"http://www.facturae.es/"
|
|
"politica_de_firma_formato_facturae/"
|
|
"politica_de_firma_formato_facturae_v3_1"
|
|
".pdf"
|
|
)
|
|
sig_policy_hash_value = "Ohixl6upD6av8N7pEvDABhEL6hM="
|
|
|
|
# Get XML file to edit
|
|
root = etree.fromstring(request)
|
|
|
|
# Create a signature template for RSA-SHA1 enveloped signature.
|
|
sign = xmlsig.template.create(
|
|
c14n_method=xmlsig.constants.TransformInclC14N,
|
|
sign_method=xmlsig.constants.TransformRsaSha1,
|
|
name=signature_id,
|
|
ns="ds",
|
|
)
|
|
assert sign is not None
|
|
|
|
# Add the <ds:Signature/> node to the document.
|
|
root.append(sign)
|
|
|
|
# Add the <ds:Reference/> node to the signature template.
|
|
ref = xmlsig.template.add_reference(
|
|
sign, xmlsig.constants.TransformSha1, name=reference_id, uri=""
|
|
)
|
|
|
|
# Add the enveloped transform descriptor.
|
|
xmlsig.template.add_transform(ref,
|
|
xmlsig.constants.TransformEnveloped)
|
|
|
|
# Add 2 new <ds:Reference/> node to the signature template.
|
|
xmlsig.template.add_reference(
|
|
sign,
|
|
xmlsig.constants.TransformSha1,
|
|
uri="#" + signed_properties_id,
|
|
uri_type="http://uri.etsi.org/01903#SignedProperties",
|
|
)
|
|
xmlsig.template.add_reference(
|
|
sign, xmlsig.constants.TransformSha1, uri="#" + key_info_id
|
|
)
|
|
|
|
# Add the <ds:KeyInfo/> and <ds:KeyName/> nodes.
|
|
key_info = xmlsig.template.ensure_key_info(sign, name=key_info_id)
|
|
x509_data = xmlsig.template.add_x509_data(key_info)
|
|
xmlsig.template.x509_data_add_certificate(x509_data)
|
|
|
|
# Set the certificate values
|
|
ctx = xmlsig.SignatureContext()
|
|
ctx.private_key = key
|
|
ctx.x509 = pem
|
|
ctx.public_key = pem.public_key()
|
|
|
|
# Set the footer validation
|
|
object_node = etree.SubElement(
|
|
sign,
|
|
etree.QName(xmlsig.constants.DSigNs, "Object"),
|
|
nsmap={"etsi": etsi},
|
|
attrib={xmlsig.constants.ID_ATTR: object_id},
|
|
)
|
|
qualifying_properties = etree.SubElement(
|
|
object_node,
|
|
etree.QName(etsi, "QualifyingProperties"),
|
|
attrib={"Target": "#" + signature_id},
|
|
)
|
|
signed_properties = etree.SubElement(
|
|
qualifying_properties,
|
|
etree.QName(etsi, "SignedProperties"),
|
|
attrib={xmlsig.constants.ID_ATTR: signed_properties_id},
|
|
)
|
|
signed_signature_properties = etree.SubElement(
|
|
signed_properties, etree.QName(etsi,
|
|
"SignedSignatureProperties")
|
|
)
|
|
now = datetime.datetime.now()
|
|
etree.SubElement(
|
|
signed_signature_properties, etree.QName(etsi, "SigningTime")
|
|
).text = now.isoformat()
|
|
signing_certificate = etree.SubElement(
|
|
signed_signature_properties, etree.QName(etsi,
|
|
"SigningCertificate")
|
|
)
|
|
signing_certificate_cert = etree.SubElement(
|
|
signing_certificate, etree.QName(etsi, "Cert")
|
|
)
|
|
cert_digest = etree.SubElement(
|
|
signing_certificate_cert, etree.QName(etsi, "CertDigest")
|
|
)
|
|
etree.SubElement(
|
|
cert_digest,
|
|
etree.QName(xmlsig.constants.DSigNs, "DigestMethod"),
|
|
attrib={"Algorithm": "http://www.w3.org/2000/09/xmldsig#sha1"},
|
|
)
|
|
|
|
hash_cert = hashlib.sha1(crt)
|
|
etree.SubElement(
|
|
cert_digest, etree.QName(xmlsig.constants.DSigNs,
|
|
"DigestValue")
|
|
).text = base64.b64encode(hash_cert.digest())
|
|
|
|
issuer_serial = etree.SubElement(
|
|
signing_certificate_cert, etree.QName(etsi, "IssuerSerial")
|
|
)
|
|
etree.SubElement(
|
|
issuer_serial, etree.QName(xmlsig.constants.DSigNs,
|
|
"X509IssuerName")
|
|
).text = xmlsig.utils.get_rdns_name(pem.issuer.rdns)
|
|
etree.SubElement(
|
|
issuer_serial, etree.QName(xmlsig.constants.DSigNs,
|
|
"X509SerialNumber")
|
|
).text = str(pem.serial_number)
|
|
|
|
signature_policy_identifier = etree.SubElement(
|
|
signed_signature_properties,
|
|
etree.QName(etsi, "SignaturePolicyIdentifier"),
|
|
)
|
|
signature_policy_id = etree.SubElement(
|
|
signature_policy_identifier, etree.QName(etsi,
|
|
"SignaturePolicyId")
|
|
)
|
|
sig_policy_id = etree.SubElement(
|
|
signature_policy_id, etree.QName(etsi, "SigPolicyId")
|
|
)
|
|
etree.SubElement(
|
|
sig_policy_id, etree.QName(etsi, "Identifier")
|
|
).text = sig_policy_identifier
|
|
etree.SubElement(
|
|
sig_policy_id, etree.QName(etsi, "Description")
|
|
).text = "Política de Firma FacturaE v3.1"
|
|
sig_policy_hash = etree.SubElement(
|
|
signature_policy_id, etree.QName(etsi, "SigPolicyHash")
|
|
)
|
|
etree.SubElement(
|
|
sig_policy_hash,
|
|
etree.QName(xmlsig.constants.DSigNs, "DigestMethod"),
|
|
attrib={"Algorithm": "http://www.w3.org/2000/09/xmldsig#sha1"},
|
|
)
|
|
hash_value = sig_policy_hash_value
|
|
etree.SubElement(
|
|
sig_policy_hash, etree.QName(xmlsig.constants.DSigNs,
|
|
"DigestValue")
|
|
).text = hash_value
|
|
signer_role = etree.SubElement(
|
|
signed_signature_properties, etree.QName(etsi, "SignerRole")
|
|
)
|
|
claimed_roles = etree.SubElement(
|
|
signer_role, etree.QName(etsi, "ClaimedRoles")
|
|
)
|
|
etree.SubElement(
|
|
claimed_roles, etree.QName(etsi, "ClaimedRole")
|
|
).text = "supplier"
|
|
signed_data_object_properties = etree.SubElement(
|
|
signed_properties, etree.QName(etsi,
|
|
"SignedDataObjectProperties")
|
|
)
|
|
data_object_format = etree.SubElement(
|
|
signed_data_object_properties,
|
|
etree.QName(etsi, "DataObjectFormat"),
|
|
attrib={"ObjectReference": "#" + reference_id},
|
|
)
|
|
etree.SubElement(
|
|
data_object_format, etree.QName(etsi, "Description")
|
|
).text = "Factura"
|
|
data_object_format_identifier = etree.SubElement(
|
|
data_object_format, etree.QName(etsi, "ObjectIdentifier")
|
|
)
|
|
etree.SubElement(
|
|
data_object_format_identifier,
|
|
etree.QName(etsi, "Identifier"),
|
|
attrib={"Qualifier": "OIDAsURN"}
|
|
).text = "urn:oid:1.2.840.10003.5.109.10"
|
|
etree.SubElement(
|
|
data_object_format_identifier, etree.QName(etsi, "Description")
|
|
)
|
|
etree.SubElement(
|
|
data_object_format, etree.QName(etsi, "MimeType")
|
|
).text = "text/xml"
|
|
|
|
# Sign the file and verify the sign.
|
|
ctx.sign(sign)
|
|
ctx.verify(sign)
|
|
|
|
return etree.tostring(root, xml_declaration=True, encoding="UTF-8")
|
|
|
|
signed_file_content = _sign_file(certificate, xml_string)
|
|
|
|
logger.info("Factura-e for invoice %s (%s) generated and signed",
|
|
self.rec_name, self.id)
|
|
|
|
return signed_file_content
|
|
|
|
@classmethod
|
|
def double_up_to_eight(cls, value):
|
|
# return max 8 digits in DoubleUpToEightDecimalType
|
|
_TOTAL_DIGITS = 8
|
|
def digits_decimal(value):
|
|
num_str = str(value)
|
|
if '.' in num_str:
|
|
num_digits = num_str[::-1].find('.')
|
|
else:
|
|
num_digits = 0
|
|
|
|
return num_digits
|
|
|
|
if digits_decimal(value) > _TOTAL_DIGITS:
|
|
precision = 10 ** -_TOTAL_DIGITS
|
|
return math.floor(float(value) / precision) * precision
|
|
return value
|
|
|
|
|
|
class InvoiceLine(metaclass=PoolMeta):
|
|
__name__ = 'account.invoice.line'
|
|
|
|
@property
|
|
def facturae_article_code(self):
|
|
return self.product and self.product.code or ''
|
|
|
|
@property
|
|
def facturae_item_description(self):
|
|
return (
|
|
(self.description and self.description)
|
|
or (self.product and self.product.rec_name)
|
|
or '#'+str(self.id)
|
|
)
|
|
|
|
@property
|
|
def facturae_receiver_transaction_reference(self):
|
|
# TODO Issuer/ReceiverTransactionDate (sale, contract...)
|
|
return ''
|
|
|
|
@property
|
|
def facturae_start_date(self):
|
|
try:
|
|
pool = Pool()
|
|
Consumption = pool.get('contract.consumption')
|
|
except:
|
|
Consumption = None
|
|
|
|
if (self.origin and Consumption
|
|
and isinstance(self.origin, Consumption)):
|
|
return self.origin.start_date
|
|
return None
|
|
|
|
@property
|
|
def facturae_end_date(self):
|
|
try:
|
|
pool = Pool()
|
|
Consumption = pool.get('contract.consumption')
|
|
except:
|
|
Consumption = None
|
|
|
|
if (self.origin and Consumption
|
|
and isinstance(self.origin, Consumption)):
|
|
return self.origin.end_date
|
|
elif self.facturae_start_date:
|
|
return self.facturae_start_date
|
|
return None
|
|
|
|
@property
|
|
def taxes_outputs(self):
|
|
"""Return list of 'impuestos repecutidos'"""
|
|
return [inv_tax for inv_tax in self.invoice_taxes
|
|
if inv_tax.tax and inv_tax.tax.rate >= Decimal(0)]
|
|
|
|
@property
|
|
def taxes_withheld(self):
|
|
"""Return list of 'impuestos retenidos'"""
|
|
return [inv_tax for inv_tax in self.invoice_taxes
|
|
if inv_tax.tax and inv_tax.tax.rate < Decimal(0)]
|
|
|
|
@property
|
|
def taxes_additional_line_item_information(self):
|
|
res = {}
|
|
for inv_tax in self.invoice_taxes:
|
|
if inv_tax.tax and (not inv_tax.tax.report_type
|
|
or inv_tax.tax.report_type == '05'):
|
|
key = (inv_tax.tax.rate * 100, inv_tax.base, inv_tax.amount)
|
|
res.setdefault('05', []).append((key, inv_tax.description))
|
|
elif inv_tax.tax and inv_tax.tax.report_description:
|
|
res[inv_tax.tax.report_type] = inv_tax.tax.report_description
|
|
if '05' in res:
|
|
if len(res['05']) == 1:
|
|
res['05'] = res['05'][0]
|
|
else:
|
|
for key, tax_description in res['05']:
|
|
res['05 %s %s %s' % key] = tax_description
|
|
del res['05']
|
|
return res
|
|
|
|
|
|
class CreditInvoiceStart(metaclass=PoolMeta):
|
|
__name__ = 'account.invoice.credit.start'
|
|
rectificative_reason_code = fields.Selection(
|
|
[(x[0], x[1]) for x in RECTIFICATIVE_REASON_CODES],
|
|
'Rectificative Reason Code', required=True, sort=False)
|
|
|
|
|
|
class CreditInvoice(metaclass=PoolMeta):
|
|
__name__ = 'account.invoice.credit'
|
|
|
|
def do_credit(self, action):
|
|
with Transaction().set_context(
|
|
rectificative_reason_code=self.start.rectificative_reason_code
|
|
):
|
|
return super(CreditInvoice, self).do_credit(action)
|
|
|
|
|
|
class GenerateFacturaeStart(ModelView):
|
|
'Generate Factura-e file - Start'
|
|
__name__ = 'account.invoice.generate_facturae.start'
|
|
service = fields.Selection([
|
|
(None, 'None'),
|
|
('only_file', 'Only Generate Facturae'),
|
|
], 'Factura-e Service')
|
|
certificate = fields.Many2One('certificate',
|
|
'Factura-e Certificate', depends=['service'])
|
|
|
|
|
|
class GenerateFacturae(Wizard):
|
|
'Generate Factura-e file'
|
|
__name__ = 'account.invoice.generate_facturae'
|
|
start = StateView('account.invoice.generate_facturae.start',
|
|
'account_invoice_facturae.generate_facturae_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Generate', 'generate', 'tryton-launch', default=True),
|
|
])
|
|
generate = StateTransition()
|
|
|
|
def default_start(self, fields):
|
|
pool = Pool()
|
|
Configuration = pool.get('account.configuration')
|
|
|
|
default = {
|
|
'service': None,
|
|
'certificate': None,
|
|
}
|
|
|
|
config = Configuration(1)
|
|
if config.facturae_service:
|
|
default['service'] = config.facturae_service
|
|
if config.facturae_certificate:
|
|
default['certificate'] = config.facturae_certificate.id
|
|
|
|
return default
|
|
|
|
def transition_generate(self):
|
|
Invoice = Pool().get('account.invoice')
|
|
|
|
invoices = Invoice.browse(Transaction().context['active_ids'])
|
|
for invoice in invoices:
|
|
invoice.generate_facturae(certificate=self.start.certificate,
|
|
service=self.start.service)
|
|
return 'end'
|