# Conectar Odoo
> Rellenar las facturas de proveedor en borrador de Odoo desde Ocost: un pequeño módulo de Odoo que envía PDF, consulta, convierte el documento en una factura y busca.
>
> Antes: [Inicio rápido](https://ocost.io/docs/es/quickstart.md)

Haz que Odoo envíe a Ocost los PDF de sus facturas de proveedor y rellene sus borradores con lo que Ocost leyó. Odoo lleva la contabilidad. Ocost nunca escribe en Odoo: tu Odoo pregunta a Ocost y rellena sus propias facturas.

## El addon de Ocost

Llega un addon de Ocost para Odoo, primero para 19.0 y después para 18.0 y 20.0, Community y Enterprise. Hará esto:

| Parte | Qué hace |
| --- | --- |
| Ajustes › Ocost | Por compañía: la clave de API y cuándo enviar (al subir, con un botón o nunca). |
| Envío | Los PDF de una factura de proveedor en borrador, enviados por correo a un diario de compras o soltados en Facturas de proveedor. Odoo sigue leyendo él mismo las facturas electrónicas. |
| Relleno | Proveedor, número, fechas, líneas con impuestos, vencimiento y condiciones de pago con Skonto. Solo los campos vacíos, y nunca contabilizada. La factura lista las dudas y las comprobaciones fallidas. |
| Búsqueda | Contabilidad › Ocost › Buscar, por lo que dicen los PDF. |

Hasta entonces, el módulo de abajo hace lo esencial en código Odoo sencillo.

## Qué rellena qué

| Odoo | De [`ocost.document.v1`](https://ocost.io/docs/es/document.md) |
| --- | --- |
| `partner_id` | `seller`, encontrado por su NIF-IVA y su nombre, o creado |
| `ref` | `number` |
| `invoice_date` | `issue_date` |
| `invoice_date_due` | `due_date` |
| `invoice_origin` | `order_reference` |
| `invoice_line_ids` | `lines`, cada una con `quantity`, `price` y el impuesto de compra de su `vat_rate` |

Sin líneas leídas, el módulo crea una línea por tipo de IVA. Rellena borradores y nunca contabiliza una factura. Anota los problemas en la factura: sumas que no cuadran, las dudas de Ocost y un posible duplicado. También anota el Skonto.

## Crea un módulo pequeño

Las acciones de servidor no pueden importar `requests`. Por eso las llamadas viven en un módulo, al que llama una acción de servidor o un botón.

```text
ocost_connect/
  __init__.py              from . import models
  __manifest__.py
  models/__init__.py       from . import account_move
  models/account_move.py
  data/cron.xml
```

Guarda la clave en el parámetro del sistema `ocost.api_key`, en Ajustes › Técnico › Parámetros del sistema. Solo los administradores pueden leerla. Una compañía de Odoo es una empresa de Ocost. Con varias compañías, usa una clave para cada una, como `ocost.api_key.<company id>`.

`__manifest__.py`:

```python
{
    "name": "Ocost Connect",
    "version": "19.0.1.0.0",
    "depends": ["account"],
    "data": ["data/cron.xml"],
    "license": "LGPL-3",
}
```

`models/account_move.py`:

```python
import base64
import logging
from decimal import Decimal

import requests

from odoo import _, api, fields, models
from odoo.fields import Command

API = "https://api.ocost.io/public/v1"
log = logging.getLogger(__name__)


def _dec(*values):
    """The first of Ocost's numbers given, exact: through str, never as a float."""
    return next((Decimal(str(v)) for v in values if v is not None), Decimal(0))


class AccountMove(models.Model):
    _inherit = "account.move"

    ocost_file_id = fields.Char(copy=False, readonly=True)
    ocost_state = fields.Selection(
        [("sent", "Sent"), ("read", "Read"), ("not_read", "Not read"), ("failed", "Failed")],
        copy=False,
        readonly=True,
    )

    def _ocost(self):
        key = self.env["ir.config_parameter"].sudo().get_param("ocost.api_key")
        session = requests.Session()
        session.headers["Authorization"] = f"Bearer {key}"
        return session

    def action_ocost_send(self):
        """Sends each draft vendor bill's PDF to Ocost (a button, a server
        action or the cron). The same PDF twice is the same file: safe."""
        session = self._ocost()
        bills = self.filtered(
            lambda m: m.move_type in ("in_invoice", "in_refund")
            and m.state == "draft"
            and not m.ocost_file_id
        )
        for move in bills:
            attachment = move.message_main_attachment_id or move.attachment_ids[:1]
            if not attachment:
                continue
            answer = session.post(
                f"{API}/files",
                files={
                    "file": (
                        attachment.name,
                        base64.b64decode(attachment.datas),
                        attachment.mimetype,
                    )
                },
                data={"external_ref": f"account.move,{move.id}"},
                timeout=30,
            )
            if answer.status_code == 429 or answer.status_code >= 500:
                continue  # the next run tries again
            if answer.status_code == 401:
                log.warning("Ocost refused the API key: replace it")
                return
            if answer.status_code in (413, 415):
                move.ocost_state = "failed"
                move.message_post(body=answer.json().get("detail"))
                continue
            answer.raise_for_status()
            file = answer.json()
            move.write({"ocost_file_id": file["id"], "ocost_state": "sent"})
            if file["status"] == "read":
                move._ocost_fill(session)

    @api.model
    def _cron_ocost(self):
        """Every few minutes: send what waits, then fill what Ocost read."""
        self.search(
            [("move_type", "in", ("in_invoice", "in_refund")), ("state", "=", "draft"),
             ("ocost_file_id", "=", False), ("message_main_attachment_id", "!=", False)],
            limit=20,
        ).action_ocost_send()
        session = self._ocost()
        for move in self.search([("ocost_state", "=", "sent")], limit=50):
            file = session.get(f"{API}/files/{move.ocost_file_id}", timeout=15).json()
            if file["status"] in ("received", "reading"):
                continue
            if file["status"] == "read":
                move._ocost_fill(session)
            else:
                move.ocost_state = file["status"]
                move.message_post(body=_("Ocost didn't read it: %s", file["reason"]))

    def _ocost_fill(self, session):
        """Fills the draft bill's empty fields from Ocost's reading."""
        self.ensure_one()
        doc = session.get(f"{API}/files/{self.ocost_file_id}/document", timeout=15).json()
        notes = []
        if doc["direction"] == "outgoing" or doc["kind"] not in ("invoice", "credit_note"):
            self.ocost_state = "read"
            self.message_post(body=_("Ocost read a %s, not a bill to fill.", doc["kind_detail"]))
            return
        vals = {}
        seller = doc["seller"] or {}
        contact = seller.get("contact") or {}
        vat_sure = doc["sources"].get("seller.vat_id", {}).get("confidence") != "doubt"
        if not self.partner_id and seller.get("name"):
            partner = self.env["res.partner"]._retrieve_partner(
                name=seller["name"],
                vat=seller.get("vat_id") if vat_sure else None,
                email=contact.get("email"),
                company=self.company_id,
            )
            if not partner:
                address = seller.get("address") or {}
                country = self.env["res.country"].search(
                    [("code", "=", address.get("country"))], limit=1
                )
                partner = self.env["res.partner"].create({
                    "name": seller["name"],
                    "is_company": True,
                    "vat": seller.get("vat_id") if vat_sure else False,
                    "street": address.get("street"),
                    "zip": address.get("postal_code"),
                    "city": address.get("city"),
                    "country_id": country.id or False,
                    "email": contact.get("email"),
                    "phone": contact.get("phone"),
                    "supplier_rank": 1,
                })
            vals["partner_id"] = partner.id
        if not self.ref and doc["number"]:
            vals["ref"] = doc["number"]
        if not self.invoice_date and doc["issue_date"]:
            vals["invoice_date"] = doc["issue_date"]
        if doc["due_date"]:
            vals["invoice_date_due"] = doc["due_date"]
        if doc["order_reference"] and not self.invoice_origin:
            vals["invoice_origin"] = doc["order_reference"]
        currency = self.env["res.currency"].search([("name", "=", doc["currency"])], limit=1)
        if currency:
            vals["currency_id"] = currency.id
        if doc["kind"] == "credit_note" and self.move_type == "in_invoice" and not self.invoice_line_ids:
            vals["move_type"] = "in_refund"
        if not self.invoice_line_ids:
            vals["invoice_line_ids"] = [
                Command.create(self._ocost_line(line, doc["totals"]["prices_include_vat"], notes))
                for line in doc["lines"]
            ] or [
                # No lines read: one line per VAT rate.
                Command.create(self._ocost_line(
                    {"name": doc["number"] or _("Invoice"), "quantity": 1,
                     "price": group["taxable_amount"], "vat_rate": group["rate"]},
                    False, notes,
                ))
                for group in doc["vat_breakdown"]
            ]
        self.write(vals)
        self.ocost_state = "read"
        if not all(c["passed"] for c in doc["checks"] if c["sums"]):
            notes.append(_("The sums don't add up as read: check the amounts."))
        doubts = [path for path, s in doc["sources"].items() if s["confidence"] == "doubt"]
        if doubts:
            notes.append(_("Ocost isn't sure of: %s", ", ".join(doubts)))
        if doc["possible_duplicate_of"]:
            notes.append(_("Ocost read a bill of this number from this seller before."))
        if doc["early_payment_discounts"]:
            skonto = doc["early_payment_discounts"][0]
            notes.append(_("Skonto: %s %% until %s", skonto["percent"], skonto["due_date"]))
        self.message_post(body="\n".join([_("Filled from Ocost's reading. Check before posting."), *notes]))

    def _ocost_line(self, line, included, notes):
        price = _dec(line.get("price"), line.get("net_amount"))
        per = _dec(line.get("base_quantity"), 1)
        values = {
            "name": " ".join(filter(None, [
                line.get("seller_item_id") and f"[{line['seller_item_id']}]", line["name"],
            ])),
            "quantity": float(_dec(line.get("quantity"), 1)),
            "price_unit": float(price / per),
            "discount": float(_dec(line.get("discount_percent"))),
        }
        if line.get("vat_rate") is not None:
            tax = self.env["account.tax"].search([
                ("company_id", "=", self.company_id.id),
                ("type_tax_use", "=", "purchase"),
                ("amount_type", "=", "percent"),
                ("amount", "=", float(line["vat_rate"])),
                ("price_include", "=", included),
            ], limit=1)
            if tax:
                values["tax_ids"] = [Command.set(tax.ids)]
            else:
                notes.append(_("No purchase tax of %s %%: set the line's tax.", line["vat_rate"]))
        return values
```

`data/cron.xml`:

```xml
<odoo>
  <record id="cron_ocost" model="ir.cron">
    <field name="name">Ocost: send and fill</field>
    <field name="model_id" ref="account.model_account_move"/>
    <field name="state">code</field>
    <field name="code">model._cron_ocost()</field>
    <field name="interval_number">5</field>
    <field name="interval_type">minutes</field>
  </record>
</odoo>
```

Añade una acción de servidor en las facturas de proveedor, Acción › Enviar a Ocost, que ejecute `records.action_ocost_send()`. El cron envía entonces lo que espera y rellena lo que Ocost leyó, cada cinco minutos.

Prueba el módulo primero en una copia de tu base de datos. El `tax_ids` de una línea puede necesitar `fiscal_position_id.map_tax`. Toma los impuestos de inversión del sujeto pasivo (`AE`) e intracomunitarios (`K`) de la tabla de tu asesor contable.

## Busca desde Odoo

Añade este método al mismo modelo. Encuentra facturas por lo que dicen sus PDF.

```python
    @api.model
    def ocost_search(self, query, kind=None):
        """Bills by what their PDFs say: a list of (bill, page, text)."""
        params = {"q": query, "limit": 20}
        if kind:
            params["kind"] = kind
        found = self._ocost().get(f"{API}/search", params=params, timeout=15).json()
        out = []
        for r in found["results"]:
            bill = self.search([("ocost_file_id", "=", r["file_id"])], limit=1)
            passage = r["passages"][0] if r["passages"] else {}
            out.append((bill, passage.get("page"), passage.get("text")))
        return out
```

Un resultado puede ser una factura que llegó a Ocost por otra vía. Para obtener su PDF, llama a `GET /public/v1/files/{file_id}/content` en el servidor de Odoo, para que la clave nunca llegue a un navegador.

## Véase también

- [El documento](https://ocost.io/docs/es/document.md): El esquema ocost.document.v1 en términos de EN 16931 (se corresponde con UBL y CII): un ejemplo, tipo y dirección, fuentes, comprobaciones, versiones, y cada campo y valor.
- [Mantenerse sincronizado](https://ocost.io/docs/es/sync.md): Recoger cada archivo cambiado con una sola llamada: GET /public/v1/files con updated_since, un cursor y un filtro de estado.
- [Búsqueda](https://ocost.io/docs/es/search.md): Buscar en todos los documentos por palabras y por significado: parámetros, filtros, resultados, ejemplos.
- [Claves y permisos](https://ocost.io/docs/es/authentication.md): Claves de API: cómo las lleva una solicitud, cómo rotarlas, sus permisos y los rechazos.
- En ocost.io: [Invoice processing](https://ocost.io/en/product/invoice-processing)
