commerce-theory 0.1.0

Runtime Rust mirror of the CommerceTheory Lean package
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::foundation::*;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ProductStatus {
    Draft,
    Active,
    Archived,
    Discontinued,
}

domain_struct! {
    pub struct Brand {
        id: Id,
        name: String,
    }
}

domain_struct! {
    pub struct Category {
        id: Id,
        name: String,
    }
}

domain_struct! {
    pub struct Product {
        id: ProductId,
        brand: Brand,
        category: Category,
        status: ProductStatus,
    }
}

domain_struct! {
    pub struct ProductVariant {
        id: VariantId,
        product_id: ProductId,
        sku: Sku,
        active: bool,
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ProductCatalogEntry {
    pub(crate) product: Product,
    pub(crate) variant: ProductVariant,
}

impl ProductCatalogEntry {
    pub fn try_new(product: Product, variant: ProductVariant) -> DomainResult<Self> {
        if variant.product_id != product.id {
            return Err(ValidationError::Invariant("variant must belong to product"));
        }
        Ok(Self { product, variant })
    }

    pub fn product(&self) -> &Product {
        &self.product
    }

    pub fn variant(&self) -> &ProductVariant {
        &self.variant
    }
}

domain_struct! {
    pub struct ImageAsset {
        id: Id,
        width: Nat,
        height: Nat,
    }
}

domain_struct! {
    pub struct ListingContent {
        title_length: Nat,
        image_count: Nat,
        required_attributes_filled: bool,
    }
}

domain_struct! {
    pub struct MarketplaceContentPolicy {
        max_title_length: Nat,
        min_image_count: Nat,
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ValidListingContent {
    pub(crate) content: ListingContent,
    pub(crate) policy: MarketplaceContentPolicy,
}

impl ValidListingContent {
    pub fn try_new(
        content: ListingContent,
        policy: MarketplaceContentPolicy,
    ) -> DomainResult<Self> {
        if content.title_length > policy.max_title_length {
            return Err(ValidationError::Invariant("listing title exceeds policy"));
        }
        if content.image_count < policy.min_image_count {
            return Err(ValidationError::Invariant("listing has too few images"));
        }
        if !content.required_attributes_filled {
            return Err(ValidationError::Invariant(
                "listing attributes must be filled",
            ));
        }
        Ok(Self { content, policy })
    }

    pub fn content(&self) -> &ListingContent {
        &self.content
    }

    pub fn policy(&self) -> &MarketplaceContentPolicy {
        &self.policy
    }
}