WebService Core

Vaya a Ajustes > Técnico > WebService Backend (requiere el grupo Administración / Ajustes) y cree un nuevo backend:

• Nombre / Nombre técnico: una etiqueta y una clave técnica única que usará para buscar el backend desde el código (p. ej., env.ref no se usa aquí; busque por tech_name en su lugar).
• Protocolo: solo HTTP Request está disponible en este módulo.
• URL: la URL base a la que es relativa cada llamada, p. ej. https://api.example.com. Puede contener tokens {placeholder} (consulte Uso), p. ej. https://api.example.com/{endpoint}.
• Content-Type: cabecera Content-Type predeterminada opcional para cada llamada.
• Timeout: tiempo de espera opcional en segundos para toda la solicitud (conexión + lectura). Si se deja vacío, una llamada espera indefinidamente.

En las pestañas Headers y Querystring Params puede configurar valores predeterminados estáticos, que se combinan en cada llamada (consulte Uso).

A continuación, configure la autenticación mediante Tipo de autenticación:

• Público: no se necesitan credenciales.
• Nombre de usuario y contraseña: se envían como HTTP Basic Auth. Requiere Nombre de usuario y Contraseña.
• Clave API: se envía como una cabecera personalizada. Requiere Clave API y cabecera de Clave API (el nombre de la cabecera bajo la que se envía, p. ej. X-Api-Key).

Los campos obligatorios dependen del tipo de autenticación seleccionado; el formulario solo muestra y exige los que corresponden, y el guardado lo aplica.

Cada webservice.endpoint (consulte Descripción) tiene su propio Content-Type, Timeout, Headers y Querystring Params, que anulan los del backend para ese endpoint concreto: configure solo lo que deba diferir.

Busca el backend (por ejemplo, por su nombre técnico) y llámalo:

backend = env["webservice.backend"].search([("tech_name", "=", "my_api")])
result = backend.call("get")  # -> the full requests.Response object

call(method, *args, **kwargs) acepta cualquiera de los verbos HTTP estándar (get, post, put, delete) y reenvía todo lo demás a requests, por lo que también funcionan cualquiera de sus argumentos de palabra clave (data, json, params, files, ...):

backend.call("post", data=b"<xml>...</xml>")
backend.call("post", json={"foo": "bar"})

URL: por defecto se usa el propio url del backend. Pasa url para acceder a una ruta diferente: las rutas relativas se añaden a la URL del backend, una URL completa http(s):// se usa tal cual:

backend.call("get", url="orders")  # -> <backend url>/orders
backend.call("get", url="https://other.example.com/orders")

Si la URL del backend (o el url pasado arriba) contiene tokens {placeholder}, rellénalos con url_params:

# backend.url == "https://api.example.com/{endpoint}"
backend.call("get", url_params={"endpoint": "orders"})

Cabeceras: pasa headers para añadir o sobrescribir cabeceras en esa llamada; se combinan sobre las cabeceras estáticas propias del backend (configuradas en la pestaña "Headers"), Content-Type y las cabeceras derivadas de la autenticación (por ejemplo, la cabecera de la clave API): el kwarg headers prevalece en las claves coincidentes:

backend.call("get", headers={"X-Request-Id": "42"})

Parámetros de querystring: se envían mediante requests' params=, que no deben confundirse con url_params de arriba, que rellena los tokens {placeholder} en la propia ruta de la URL. Configura los valores estáticos predeterminados en la pestaña "Querystring Params": un valor allí puede contener a su vez un {placeholder}, resuelto con el mismo url_params usado para la URL. Un kwarg params explícito pasado a call() prevalece sobre la configuración estática en las claves coincidentes:

backend.call("get", params={"verbose": "1"})

Anulación de autenticación: pasa auth para omitir el tipo de autenticación configurado en el backend en una sola llamada (el mismo formato que acepta requests, por ejemplo, una tupla (user, password)):

backend.call("get", auth=("other_user", "other_password"))

Tiempo de espera: pasa timeout para anular el tiempo de espera configurado en el propio backend (en segundos) en una sola llamada:

backend.call("get", timeout=5)

Respuesta: call() siempre devuelve el objeto requests.Response completo (código de estado, cabeceras, contenido, ...):

response = backend.call("get")
response.status_code
response.content