Base Rest

Si se produce un error al llamar a un método de un servicio (es decir, falta un parámetro, etc.), el sistema devuelve solo una descripción general del problema sin detalles. Esto se hace a propósito para garantizar la máxima opacidad sobre los detalles de implementación y, por lo tanto, reducir los problemas de seguridad.

Esta restricción puede ser problemática cuando un sistema externo en desarrollo accede a los servicios. Para conocer los detalles de un error es necesario tener acceso al log del servidor. No siempre es posible proporcionar este tipo de acceso. Por eso se puede configurar el servidor para ejecutar estos servicios en modo desarrollo.

Para ejecutar la REST API en modo desarrollo debe añadir una nueva sección '[base_rest]' con la opción 'dev_mode=True' en el archivo de configuración del servidor.

[base_rest]
dev_mode=True

Cuando la REST API se ejecuta en modo desarrollo, se devuelve la descripción original y un stack trace en caso de error. Tenga cuidado de no utilizar este modo en producción.

Para añadir tu propio servicio REST debes proporcionar al menos 2 clases.

• Un Component que proporcione la lógica de negocio de tu servicio,
• Un Controller para registrar tu servicio.

La lógica de negocio de tu servicio debe implementarse en un component (odoo.addons.component.core.Component) que herede de 'base.rest.service'

Inicialmente, base_rest expone por defecto todos los métodos públicos definidos en un servicio. Las convenciones para acceder a los métodos vía HTTP eran las siguientes:

• El método def get(self, _id) si está definido, es accesible vía las rutas HTTP GET <string:_service_name>/<int:_id> y <string:_service_name>/<int:_id>/get.
• El método def search(self, **params) si está definido, es accesible vía las rutas HTTP GET <string:_service_name>/ y <string:_service_name>/search.
• El método def delete(self, _id) si está definido, es accesible vía la ruta HTTP DELETE <string:_service_name>/<int:_id>.
• El método def update(self, _id, **params), si está definido, es accesible vía la ruta HTTP PUT <string:_service_name>/<int:_id>.
• Otros métodos solo son accesibles vía las rutas HTTP POST <string:_service_name> o <string:_service_name>/<string:method_name> o <string:_service_name>/<int:_id> o <string:_service_name>/<int:_id>/<string:method_name>

from odoo.addons.component.core import Component


class PingService(Component):
    _inherit = 'base.rest.service'
    _name = 'ping.service'
    _usage = 'ping'
    _collection = 'my_module.services'


    # The following method are 'public' and can be called from the controller.
    def get(self, _id, message):
        return {
            'response': 'Get called with message ' + message}

    def search(self, message):
        return {
            'response': 'Search called search with message ' + message}

    def update(self, _id, message):
        return {'response': 'PUT called with message ' + message}

    # pylint:disable=method-required-super
    def create(self, **params):
        return {'response': 'POST called with message ' + params['message']}

    def delete(self, _id):
        return {'response': 'DELETE called with id %s ' % _id}

    # Validator
    def _validator_search(self):
        return {'message': {'type': 'string'}}

    # Validator
    def _validator_get(self):
        # no parameters by default
        return {}

    def _validator_update(self):
        return {'message': {'type': 'string'}}

    def _validator_create(self):
        return {'message': {'type': 'string'}}

Una vez que hayas implementado tus servicios (ping, ...), debes indicar a Odoo cómo acceder a estos servicios. Este proceso se realiza implementando un controller que herede de odoo.addons.base_rest.controllers.main.RestController

from odoo.addons.base_rest.controllers import main

class MyRestController(main.RestController):
    _root_path = '/my_services_api/'
    _collection_name = my_module.services

En tu controller, _'root_path' se usa para especificar la raíz de la ruta para acceder a tus servicios y '_collection_name' es el nombre de la colección que proporciona la lógica de negocio para el servicio solicitado/

Al heredar de RestController se registrarán las siguientes rutas para acceder a tus servicios

@route([
    ROOT_PATH + '<string:_service_name>',
    ROOT_PATH + '<string:_service_name>/search',
    ROOT_PATH + '<string:_service_name>/<int:_id>',
    ROOT_PATH + '<string:_service_name>/<int:_id>/get'
], methods=['GET'], auth="user", csrf=False)
def get(self, _service_name, _id=None, **params):
    method_name = 'get' if _id else 'search'
    return self._process_method(_service_name, method_name, _id, params)

@route([
    ROOT_PATH + '<string:_service_name>',
    ROOT_PATH + '<string:_service_name>/<string:method_name>',
    ROOT_PATH + '<string:_service_name>/<int:_id>',
    ROOT_PATH + '<string:_service_name>/<int:_id>/<string:method_name>'
], methods=['POST'], auth="user", csrf=False)
def modify(self, _service_name, _id=None, method_name=None, **params):
    if not method_name:
        method_name = 'update' if _id else 'create'
    if method_name == 'get':
        _logger.error("HTTP POST with method name 'get' is not allowed. "
                      "(service name: %s)", _service_name)
        raise BadRequest()
    return self._process_method(_service_name, method_name, _id, params)

@route([
    ROOT_PATH + '<string:_service_name>/<int:_id>',
], methods=['PUT'], auth="user", csrf=False)
def update(self, _service_name, _id, **params):
    return self._process_method(_service_name, 'update', _id, params)

@route([
    ROOT_PATH + '<string:_service_name>/<int:_id>',
], methods=['DELETE'], auth="user", csrf=False)
def delete(self, _service_name, _id):
    return self._process_method(_service_name, 'delete', _id)

Como resultado, una llamada HTTP GET a 'http://my_odoo/my_services_api/ping' se despachará al método PingService.search

Además de exponer fácilmente tus métodos, el módulo te permite definir esquemas de datos a los que deben ajustarse los datos intercambiados. Estos esquemas se definen sobre la base de esquemas de Cerberus y se asocian a los métodos usando la siguiente convención de nomenclatura. Para un método my_method:

• Se llamará a def _validator_my_method(self): para obtener el esquema requerido para validar los parámetros de entrada.
• Se llamará a def _validator_return_my_method(self): si está definido, para obtener el esquema usado para validar la respuesta.

Con el fin de ofrecer aún más flexibilidad, se ha desarrollado una nueva API.

Esta nueva API reemplaza el enfoque implícito usado para exponer un servicio por el uso de un decorador de python para marcar explícitamente un método como disponible vía la REST API: odoo.addons.base_rest.restapi.method.

class PartnerNewApiService(Component):
    _inherit = "base.rest.service"
    _name = "partner.new_api.service"
    _usage = "partner"
    _collection = "base.rest.demo.new_api.services"
    _description = """
        Partner New API Services
        Services developed with the new api provided by base_rest
    """

    @restapi.method(
        [(["/<int:id>/get", "/<int:id>"], "GET")],
        output_param=restapi.CerberusValidator("_get_partner_schema"),
        auth="public",
    )
    def get(self, _id):
        return {"name": self.env["res.partner"].browse(_id).name}

    def _get_partner_schema(self):
        return {
            "name": {"type": "string", "required": True}
        }

    @restapi.method(
        [(["/list", "/"], "GET")],
        output_param=restapi.CerberusListValidator("_get_partner_schema"),
        auth="public",
    )
    def list(self):
        partners = self.env["res.partner"].search([])
        return [{"name": p.name} for p in partners]

Gracias a esta nueva api, ahora eres libre de especificar tus propias rutas pero también de usar otros tipos de objetos como parámetro o respuesta de tus métodos. Por ejemplo, base_rest_datamodel te permite usar una instancia de objeto Datamodel en tus servicios.

from marshmallow import fields

from odoo.addons.base_rest import restapi
from odoo.addons.component.core import Component
from odoo.addons.datamodel.core import Datamodel


class PartnerSearchParam(Datamodel):
    _name = "partner.search.param"

    id = fields.Integer(required=False, allow_none=False)
    name = fields.String(required=False, allow_none=False)


class PartnerShortInfo(Datamodel):
    _name = "partner.short.info"

    id = fields.Integer(required=True, allow_none=False)
    name = fields.String(required=True, allow_none=False)


class PartnerNewApiService(Component):
    _inherit = "base.rest.service"
    _name = "partner.new_api.service"
    _usage = "partner"
    _collection = "base.rest.demo.new_api.services"
    _description = """
        Partner New API Services
        Services developed with the new api provided by base_rest
    """

    @restapi.method(
        [(["/", "/search"], "GET")],
        input_param=restapi.Datamodel("partner.search.param"),
        output_param=restapi.Datamodel("partner.short.info", is_list=True),
        auth="public",
    )
    def search(self, partner_search_param):
        """
        Search for partners
        :param partner_search_param: An instance of partner.search.param
        :return: List of partner.short.info
        """
        domain = []
        if partner_search_param.name:
            domain.append(("name", "like", partner_search_param.name))
        if partner_search_param.id:
            domain.append(("id", "=", partner_search_param.id))
        res = []
        PartnerShortInfo = self.env.datamodels["partner.short.info"]
        for p in self.env["res.partner"].search(domain):
            res.append(PartnerShortInfo(id=p.id, name=p.name))
        return res

The BaseRestServiceContextProvider proporciona contexto para tus servicios, incluyendo authenticated_partner_id. Eres libre de redefinir el método get_authenticated_partner_id() para pasar el authenticated_partner_id basado en el mecanismo de autenticación de tu elección. Consulta base_rest_auth_jwt para ver un ejemplo.

Además, authenticated_partner_id está disponible en el contexto de evaluación de record rule.