Struct Variant 

pub struct Variant {

    pub account_id: Uuid,
    pub archived: bool,
    pub barcodes: Option<Vec<Barcode>>,
    pub buy_price: Option<BuyPrice>,
    pub characteristics: Vec<Characteristic>,
    pub code: Option<String>,
    pub description: Option<String>,
    pub discount_prohibited: bool,
    pub external_code: String,
    pub id: Uuid,
    pub images: Option<MetaWrapper>,
    pub meta: Meta,
    pub min_price: Option<MinPrice>,
    pub name: String,
    pub packs: Option<Vec<Pack>>,
    pub product: MetaWrapper,
    pub sale_prices: Vec<SalePrice>,
    pub things: Option<Vec<String>>,
    pub updated: Option<NaiveDateTime>,
}

Модификация

Example

use anyhow::Result;
use rust_moysklad::{Characteristic, Currency, MoySkladApiClient, Product, Variant};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "rust-moysklad=debug".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    let client = MoySkladApiClient::from_env().expect("MS_TOKEN env var not set!");
    let variants = client.get_all::<Variant>().await?;
    dbg!(variants.len());
    let search_string = "carolus";
    let search_result = client.search::<Variant>(search_string).await?;
    dbg!(&search_result);
    let filtered = client
        .filter::<Variant>(
            "name",
            rust_moysklad::FilterOperator::PartialMatch,
            search_string,
        )
        .await?;
    dbg!(&filtered);
    let chars = client.get_variants_characteristics().await?;
    dbg!(&chars);
    let price_types = client.get_price_types().await?;
    let products = client.search::<Product>("Краска для разметки").await?;
    let currencies = client.get_all::<Currency>().await?;
    if let Some(char) = chars.iter().find(|c| c.name == "Ширина рулона, м") {
        if let Some(product) = products.first() {
            let characteristic = Characteristic::from_variant_char(char.clone(), 4);
            let mut variant_to_create = Variant::create(product.meta.clone(), vec![characteristic]);
            if let Some(sale_price) = price_types.iter().find(|p| p.name == "Цена продажи")
            {
                if let Some(rub) = currencies.iter().find(|c| c.iso_code == "RUB") {
                    variant_to_create.sale_price(500000.0, &rub.meta, &sale_price.meta);
                }
            }
            let vtc = variant_to_create.build();
            let created: Variant = client.create(vtc).await?;
            dbg!(&created);
            let update = Variant::update().description("Test description").build();
            let updated: Variant = client.update(created.id, update).await?;
            dbg!(&updated);
            client.delete::<Variant>(updated.id).await?;
        }
    }
    Ok(())
}

Fields

account_id: Uuid

archived: bool

barcodes: Option<Vec<Barcode>>

buy_price: Option<BuyPrice>

characteristics: Vec<Characteristic>

code: Option<String>

description: Option<String>

discount_prohibited: bool

external_code: String

id: Uuid

images: Option<MetaWrapper>

meta: Meta

min_price: Option<MinPrice>

name: String

packs: Option<Vec<Pack>>

product: MetaWrapper

sale_prices: Vec<SalePrice>

things: Option<Vec<String>>

updated: Option<NaiveDateTime>

Implementations

impl Variant

pub fn create( product: Meta, characteristics: Vec<Characteristic>, ) -> CreateVariantBuilder

pub fn update() -> UpdateVariantBuilder

Trait Implementations

impl Clone for Variant

fn clone(&self) -> Variant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variant

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

Formats the value using the given formatter.

impl Default for Variant

fn default() -> Variant

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Variant

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Variant

fn eq(&self, other: &Variant) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Variant

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Variant