Struct rust_woocommerce::order_notes::OrderNotes

pub struct OrderNotes {
    pub id: i32,
    pub author: String,
    pub date_created: NaiveDateTime,
    pub date_created_gmt: NaiveDateTime,
    pub note: String,
    pub customer_note: bool,
    pub added_by_user: Option<bool>,
}

#[cfg(test)]
mod tests {
    use crate::{
        controllers::orders::ORDER_ID, order_notes::OrderNotes, ApiClient, Entity, SubEntity,
    };

    #[tokio::test]
    async fn test_list_all_order_notes() {
        let client = ApiClient::from_env().unwrap();
        let order_notes: Vec<OrderNotes> = client
            .list_all_subentities(Entity::Order, ORDER_ID, SubEntity::OrderNote)
            .await
            .unwrap();
        assert!(!order_notes.is_empty());
    }
    #[tokio::test]
    async fn test_retrieve_order_note() {
        let client = ApiClient::from_env().unwrap();
        let order_notes: Vec<OrderNotes> = client
            .list_all_subentities(Entity::Order, ORDER_ID, SubEntity::OrderNote)
            .await
            .unwrap();
        let id = order_notes.last().unwrap().id;
        let order_note: OrderNotes = client
            .retrieve_subentity(Entity::Order, ORDER_ID, SubEntity::OrderNote, id)
            .await
            .unwrap();
        assert_eq!(id, order_note.id);
    }
    #[tokio::test]
    async fn test_create_order_note() {
        let client = ApiClient::from_env().unwrap();
        let note = OrderNotes::create()
            .note("Testing note")
            .customer_note()
            .added_by_user()
            .build();
        let created_note: OrderNotes = client
            .create_subentity(Entity::Order, ORDER_ID, SubEntity::OrderNote, note)
            .await
            .unwrap();
        assert_eq!(created_note.customer_note, true);
        let _deleted: OrderNotes = client
            .delete_subentity(
                Entity::Order,
                ORDER_ID,
                SubEntity::OrderNote,
                created_note.id,
            )
            .await
            .unwrap();
    }
    #[tokio::test]
    async fn test_update_order_note() {
        let client = ApiClient::from_env().unwrap();
        let order_notes: Vec<OrderNotes> = client
            .list_all_subentities(Entity::Order, ORDER_ID, SubEntity::OrderNote)
            .await
            .unwrap();
        let id = order_notes.first().unwrap().id;
        let update = OrderNotes::update().id(id).note("some test note").build();
        let updated_note: Result<OrderNotes, _> = client
            .update_subentity(Entity::Order, ORDER_ID, SubEntity::OrderNote, id, update)
            .await;
        assert!(updated_note.is_err())
    }
}

Fields

id: i32

Unique identifier for the resource.

author: String

Order note author

date_created: NaiveDateTime

The date the order note was created, in the site’s timezone.

date_created_gmt: NaiveDateTime

The date the order note was created, as GMT.

note: String

Order note content.

customer_note: bool

If true, the note will be shown to customers and they will be notified. If false, the note will be for admin reference only. Default is false.

added_by_user: Option<bool>

If true, this note will be attributed to the current user. If false, the note will be attributed to the system. Default is false.

Implementations

impl OrderNotes

pub fn create() -> OrderNotesCreateBuilder<NoNote>

pub fn update() -> OrderNotesUpdateBuilder<NoId>

Trait Implementations

impl Clone for OrderNotes

fn clone(&self) -> OrderNotes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OrderNotes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OrderNotes

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for OrderNotes

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.