Struct Restore

pub struct Restore {
    pub passwd: String,
    pub b64_data: String,
    pub restore_type: RestoreType,
}

Upload and restore an Odoo dump to a new database

Note that this request may take some time to complete, and it’s likely worth only firing this from an async-type client

Note also that the uploaded “file” must:

• Be a zip file
• Contain a folder named filestore, whose direct descendents are the databases filestore content (e.g. filestore/a0, filestore/a1, etc)
• Contain a file name dump.sql, which is a pg_dump “plain” format dump (e.g. a text file of SQL statements)

Typically Odoo backups also include a manifest.json, but this file isn’t checked by the Restore endpoint.

Example

use odoo_api::service::db::RestoreType;
use std::fs;

// load the file data
let data = fs::read("/my/database/backup.zip")?;

// convert raw bytes to base64
// e.g., with the `base64` crate: https://crates.io/crates/base64
let data_b64 = base64::encode(&data)?;

// convert base64's `Vec<u8>` to a `&str`
let data_b64 = std::str::from_utf8(&data_b64)?;

// read `id` and `login` from users id=1,2,3
client.db_restore(
    "master-password",
    data_b64,
    RestoreType::Copy
).send()?;

Reference: odoo/service/db.py
See also: odoo/service/db.py

Fields

passwd: String

The Odoo master password

b64_data: String

The backup data, as a base64-encoded string

restore_type: RestoreType

The restore type (see RestoreType)

Trait Implementations

impl Debug for Restore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl JsonRpcParams for Restore

type Container<T> = OdooApiContainer<Restore>

type Response = RestoreResponse

fn build(self, id: JsonRpcId) -> JsonRpcRequest<Self>

impl OdooApiMethod for Restore

fn describe(&self) -> (&'static str, &'static str)

Describe the JSON-RPC service and method for this type

fn endpoint(&self) -> &'static str

Describe method endpoint (e.g., “/web/session/authenticate”)

fn _build(self, id: JsonRpcId) -> JsonRpcRequest<Self>

Build self into a full JsonRpcRequest

impl Serialize for Restore

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.