Struct carbone_sdk_rust::carbone::Carbone

pub struct Carbone<'a> { /* private fields */ }

Implementations

impl<'a> Carbone<'a>

pub fn new(config: &'a Config, api_token: &'a ApiJsonToken) -> Result<Self>

pub async fn delete_template(&self, template_id: TemplateId) -> Result<bool>

Example

use std::env;

use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::types::ApiJsonToken;
use carbone_sdk_rs::template::TemplateId;
use carbone_sdk_rs::errors::CarboneError;

#[tokio::main]
async fn main() -> Result<(), CarboneError> {
    
    let token =  match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();

    let api_token = ApiJsonToken::new(token)?;

    let template_id = TemplateId::new("0545253258577a632a99065f0572720225f5165cc43db9515e9cef0e17b40114".to_string())?;

    let carbone = Carbone::new(&config, &api_token)?;
    let is_deleted = carbone.delete_template(template_id).await.unwrap();

    assert_eq!(is_deleted, true);

    Ok(())
}

pub async fn download_template(&self, template_id: &TemplateId) -> Result<Bytes>

Example

use std::env;

use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::types::ApiJsonToken;
use carbone_sdk_rs::template::TemplateId;
use carbone_sdk_rs::errors::CarboneError;

#[tokio::main]
async fn main() -> Result<(), CarboneError> {
    
    let token = match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();

    let api_token = ApiJsonToken::new(token)?;

    let template_file = String::from("template.odt");

    let template_id = TemplateId::new("0545253258577a632a99065f0572720225f5165cc43db9515e9cef0e17b40114".to_string())?;
    let carbone = Carbone::new(&config, &api_token)?;
     
    let template_content = carbone.download_template(&template_id).await.unwrap();

    assert_eq!(template_content.is_empty(), false);

    Ok(())
}

pub async fn generate_report( &self, template_name: String, template_data: Vec<u8>, json_data: JsonData, payload: Option<&str>, salt: Option<&str> ) -> Result<Bytes>

Generate a report.

Example

use std::env;

use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::render::*;
use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::types::{ApiJsonToken, JsonData};
use carbone_sdk_rs::template::{TemplateFile,TemplateId};

use carbone_sdk_rs::errors::CarboneError;

#[tokio::main]
async fn main() -> Result<(), CarboneError> {
    
    let token =  match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();

    let api_token = &ApiJsonToken::new(token)?;

    let carbone = Carbone::new(&config, api_token)?;

    let json_data_value = String::from(r#"
        "data" : {
            "firstname" : "John",
            "lastname" : "Wick"
        },
        "convertTo" : "odt"
    "#);

    let json_data = JsonData::new(json_data_value)?;

    let template_data: Vec<u8> = Vec::new(); // content of the template
    let report_content = carbone.generate_report("template.odt".to_string(), template_data, json_data, None, None).await.unwrap();

    assert_eq!(report_content.is_empty(), false);

    Ok(())
}

pub async fn get_report(&self, render_id: &RenderId) -> Result<Bytes>

Get a new report.

Example

use std::env;

use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::render::RenderId;
use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::types::ApiJsonToken;
use carbone_sdk_rs::errors::CarboneError;

#[tokio::main]
async fn main() -> Result<(), CarboneError> {
    
    let token =  match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();

    let api_token = ApiJsonToken::new(token)?;

    let carbone = Carbone::new(&config, &api_token)?;

    let render_id = &RenderId::new("MTAuMjAuMjEuMTAgICAg01E98H4R7PMC2H6XSE5Z6J8XYQ.pdf".to_string())?;
    let report_content = carbone.get_report(render_id).await.unwrap();

    assert_eq!(report_content.is_empty(), false);

    Ok(())
}

pub async fn generate_report_with_template_id( &self, template_id: TemplateId, json_data: JsonData ) -> Result<Bytes>

Generate a report with a template_id given.

Example

use std::env;

use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::render::*;
use carbone_sdk_rs::types::JsonData;
use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::types::ApiJsonToken;
use carbone_sdk_rs::template::TemplateId;

use carbone_sdk_rs::errors::CarboneError;

#[tokio::main]
async fn main() -> Result<(), CarboneError> {
    
    let token =  match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();

    let api_token = &ApiJsonToken::new(token)?;

    let template_id = TemplateId::new("0545253258577a632a99065f0572720225f5165cc43db9515e9cef0e17b40114".to_string())?;
    let carbone = Carbone::new(&config, &api_token)?;

    let json_data_value = String::from(r#"
        "data" : {
            "firstname" : "John",
            "lastname" : "Wick"
        },
        "convertTo" : "odt"
    "#);

    let json_data = JsonData::new(json_data_value)?;
    let report_content = carbone.generate_report_with_template_id(template_id, json_data).await.unwrap();

    assert_eq!(report_content.is_empty(), false);

    Ok(())
}

pub async fn render_data( &self, template_id: TemplateId, json_data: JsonData ) -> Result<RenderId>

Render data with a given template_id.

Example

use std::env;

use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::template::TemplateId;
use carbone_sdk_rs::errors::CarboneError;
use carbone_sdk_rs::types::{ApiJsonToken, JsonData};

#[tokio::main]
async fn main() -> Result<(), CarboneError> {

    let token =  match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();
    let api_token = ApiJsonToken::new(token)?;

    let template_id = TemplateId::new("foiejwoi21e093ru3209jf2093j".to_string())?;

    let carbone = Carbone::new(&config, &api_token)?;
    
    let json_data_value = String::from(r#"
        "data" : {
            "firstname" : "John",
            "lastname" : "Wick"
        },
        "convertTo" : "odt"
    "#);

    let json_data = JsonData::new(json_data_value)?;

    let render_id = carbone.render_data(template_id, json_data).await.unwrap();

    assert_eq!(render_id.as_str().is_empty(), false);

    Ok(())
}

pub async fn upload_template( &self, file_name: &str, file_content: Vec<u8>, salt: Option<&str> ) -> Result<TemplateId>

Upload a template to the Carbone Service.

Example

use std::env;
use std::fs;

use carbone_sdk_rs::config::Config;
use carbone_sdk_rs::carbone::Carbone;
use carbone_sdk_rs::types::ApiJsonToken;
use carbone_sdk_rs::template::TemplateFile;
use carbone_sdk_rs::errors::CarboneError;

#[tokio::main]
async fn main() -> Result<(), CarboneError> {
    
    let token =  match env::var("CARBONE_TOKEN") {
            Ok(v) => v,
            Err(e) => panic!("{}", e.to_string())
    };

    let config: Config = Default::default();

    let api_token = ApiJsonToken::new(token)?;

    let file_name = "template.odt";
    let file_path = format!("tests/data/{}", file_name);
    let filte_content = fs::read(file_path)?;

    let carbone = Carbone::new(&config, &api_token)?;
    let template_id = carbone.upload_template(file_name, filte_content, None).await.unwrap();

    assert_eq!(template_id.as_str().is_empty(), false);

    Ok(())
}

Trait Implementations

impl<'a> Clone for Carbone<'a>

fn clone(&self) -> Carbone<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Carbone<'a>

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

Formats the value using the given formatter.