Struct Batch

pub struct Batch { /* private fields */ }

Represents a batch of Microsoft Dataverse Requests

Some restrictions apply for creating batches:

• the batch size may not exceed 1000 calls
• the batch execution time may not exceed 2 minutes

the second restriction is especially tricky to handle because the execution time depends on the complexity of the entity in dataverse. So it is possible to create 300 records of an entity with low complexity but only 50 records of an entity with high complexity in that timeframe.

Based on experience a batch size of 50 should be safe for all entities though

Examples

use uuid::Uuid;
use serde::Serialize;
use powerplatform_dataverse_service_client::{
    batch::Batch,
    client::Client,
    entity::WriteEntity,
    reference::{Reference, ReferenceStruct},
    result::{Result, IntoDataverseResult}
};

async fn test() -> Result<()> {
    let testy_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789012").into_dataverse_result()?,
        firstname: String::from("Testy"),
        lastname: String::from("McTestface"),
    };

    let marianne_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789abc").into_dataverse_result()?,
        firstname: String::from("Marianne"),
        lastname: String::from("McTestface"),
    };

    // this batch creates both contacts in one call
    let mut batch = Batch::new("https://instance.crm.dynamics.com/");
    batch.create(&testy_contact)?;
    batch.create(&marianne_contact)?;

    let client = Client::new_dummy(); // Please replace this with your preferred authentication method
    client.execute(&batch).await?;
    Ok(())
}

#[derive(Serialize)]
struct Contact {
    contactid: Uuid,
    firstname: String,
    lastname: String,
}

impl WriteEntity for Contact {}

impl Reference for Contact {
    fn get_reference(&self) -> ReferenceStruct {
        ReferenceStruct::new(
            "contacts",
            self.contactid,
        )
    }
}

Implementations

impl Batch

pub fn new(url: &'static str) -> Self

Creates a new empty batch with its own batch id and dataset id

pub fn reset(&mut self)

Clears the batch of its contents and generates a new batch id and a new dataset id

Note that this can be used to prevent frequent allocations by reusing the Batch instance and its buffer

pub fn get_batch_id(&self) -> Uuid

returns the current batch id (This will change after a call to reset())

pub fn get_dataset_id(&self) -> Uuid

returns the current dataset id (This will change after a call to reset())

pub fn get_count(&self) -> u16

returns the current count of requests in this batch

pub fn create(&mut self, entity: &impl WriteEntity) -> Result<()>

Adds a Create Request for the given entity to this batch

Please note that this function can fail if a serde serialization error occurs

Examples

use uuid::Uuid;
use serde::Serialize;
use powerplatform_dataverse_service_client::{
    batch::Batch,
    client::Client,
    entity::WriteEntity,
    reference::{Reference, ReferenceStruct},
    result::{Result, IntoDataverseResult}
};

async fn test() -> Result<()> {
    let testy_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789012").into_dataverse_result()?,
        firstname: String::from("Testy"),
        lastname: String::from("McTestface"),
    };

    let marianne_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789abc").into_dataverse_result()?,
        firstname: String::from("Marianne"),
        lastname: String::from("McTestface"),
    };

    // this batch creates both contacts in one call
    let mut batch = Batch::new("https://instance.crm.dynamics.com/");
    batch.create(&testy_contact)?;
    batch.create(&marianne_contact)?;

    let client = Client::new_dummy(); // Please replace this with your preferred authentication method
    client.execute(&batch).await?;
    Ok(())
}

#[derive(Serialize)]
struct Contact {
    contactid: Uuid,
    firstname: String,
    lastname: String,
}

impl WriteEntity for Contact {}

impl Reference for Contact {
    fn get_reference(&self) -> ReferenceStruct {
        ReferenceStruct::new(
            "contacts",
            self.contactid,
        )
    }
}

pub fn update(&mut self, entity: &impl WriteEntity) -> Result<()>

Adds an Update Request for the given entity to this batch

Please note that this function can fail if a serde serialization error occurs

Examples

use uuid::Uuid;
use serde::Serialize;
use powerplatform_dataverse_service_client::{
    batch::Batch,
    client::Client,
    entity::WriteEntity,
    reference::{Reference, ReferenceStruct},
    result::{Result, IntoDataverseResult}
};

async fn test() -> Result<()> {
    let testy_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789012").into_dataverse_result()?,
        firstname: String::from("Testy"),
        lastname: String::from("McTestface"),
    };

    let marianne_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789abc").into_dataverse_result()?,
        firstname: String::from("Marianne"),
        lastname: String::from("McTestface"),
    };

    // this batch creates both contacts in one call
    let mut batch = Batch::new("https://instance.crm.dynamics.com/");
    batch.update(&testy_contact)?;
    batch.update(&marianne_contact)?;

    let client = Client::new_dummy(); // Please replace this with your preferred authentication method
    client.execute(&batch).await?;
    Ok(())
}

#[derive(Serialize)]
struct Contact {
    contactid: Uuid,
    firstname: String,
    lastname: String,
}

impl WriteEntity for Contact {}

impl Reference for Contact {
    fn get_reference(&self) -> ReferenceStruct {
        ReferenceStruct::new(
            "contacts",
            self.contactid,
        )
    }
}

pub fn upsert(&mut self, entity: &impl WriteEntity) -> Result<()>

Adds an Upsert Request for the given entity to this batch

Please note that this function can fail if a serde serialization error occurs

Examples

use uuid::Uuid;
use serde::Serialize;
use powerplatform_dataverse_service_client::{
    batch::Batch,
    client::Client,
    entity::WriteEntity,
    reference::{Reference, ReferenceStruct},
    result::{Result, IntoDataverseResult}
};

async fn test() -> Result<()> {
    let testy_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789012").into_dataverse_result()?,
        firstname: String::from("Testy"),
        lastname: String::from("McTestface"),
    };

    let marianne_contact = Contact {
        contactid: Uuid::parse_str("12345678-1234-1234-1234-123456789abc").into_dataverse_result()?,
        firstname: String::from("Marianne"),
        lastname: String::from("McTestface"),
    };

    // this batch creates both contacts in one call
    let mut batch = Batch::new("https://instance.crm.dynamics.com/");
    batch.upsert(&testy_contact)?;
    batch.upsert(&marianne_contact)?;

    let client = Client::new_dummy(); // Please replace this with your preferred authentication method
    client.execute(&batch).await?;
    Ok(())
}

#[derive(Serialize)]
struct Contact {
    contactid: Uuid,
    firstname: String,
    lastname: String,
}

impl WriteEntity for Contact {}

impl Reference for Contact {
    fn get_reference(&self) -> ReferenceStruct {
        ReferenceStruct::new(
            "contacts",
            self.contactid,
        )
    }
}

pub fn delete(&mut self, entity: &impl Reference) -> Result<()>

Adds a Delete Request for the given entity reference to this batch

Please note that this function can fail if a serde serialization error occurs

Examples

use uuid::Uuid;
use serde::Serialize;
use powerplatform_dataverse_service_client::{
    batch::Batch,
    client::Client,
    entity::WriteEntity,
    reference::{Reference, ReferenceStruct},
    result::{Result, IntoDataverseResult}
};

async fn test() -> Result<()> {
    let testy_contact = ReferenceStruct::new(
        "contacts",
        Uuid::parse_str("12345678-1234-1234-1234-123456789012").into_dataverse_result()?
    );

    let marianne_contact = ReferenceStruct::new(
        "contacts",
        Uuid::parse_str("12345678-1234-1234-1234-123456789abc").into_dataverse_result()?
    );

    // this batch creates both contacts in one call
    let mut batch = Batch::new("https://instance.crm.dynamics.com/");
    batch.delete(&testy_contact)?;
    batch.delete(&marianne_contact)?;

    let client = Client::new_dummy(); // Please replace this with your preferred authentication method
    client.execute(&batch).await?;
    Ok(())
}

Trait Implementations

impl Display for Batch

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

Formats the value using the given formatter.