1  use crate::{
  2      item::{
  3          attr::{AttrIndexesResponse, AttrKeys, Stock},
  4          ItemId, ItemName,
  5      },
  6      market::{MarketId, MarketName},
  7      media::MediaData,
  8      store::{StoreId, StoreName},
  9      unit::Price,
 10  };
 11  use candid::CandidType;
 12  use serde::{Deserialize, Serialize};
 13  
 14  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
 15  pub struct UserBasketPageResponse {
 16      pub physical_items: Vec<PhysicalItemGroupOfSender>,
 17      pub digital_items:
 18          Vec<Result<DigitalItemInBasket, (BasketItemError, Option<DigitalItemInBasket>)>>,
 19  }
 20  
 21  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
 22  pub struct PhysicalItemGroupOfSender {
 23      pub store_id: StoreId,
 24      pub store_name: StoreName,
 25      pub items: Vec<Result<PhysicalItemInBasket, (BasketItemError, Option<PhysicalItemInBasket>)>>,
 26  }
 27  
 28  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
 29  pub struct PhysicalItemInBasket {
 30      pub market_id: MarketId,
 31      pub market_name: MarketName,
 32      pub item_id: ItemId,
 33      pub item_name: ItemName,
 34      pub image: MediaData,
 35      pub attr_keys: AttrKeys,
 36      pub attrs: AttrIndexesResponse,
 37      pub price: Price,
 38      pub count: u32,
 39      pub stock: Stock,
 40  }
 41  
 42  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
 43  pub struct DigitalItemInBasket {
 44      pub market_id: MarketId,
 45      pub market_name: MarketName,
 46      pub store_id: StoreId,
 47      pub store_name: StoreName,
 48      pub item_id: ItemId,
 49      pub item_name: ItemName,
 50      pub image: MediaData,
 51      pub attr_keys: AttrKeys,
 52      pub attrs: AttrIndexesResponse,
 53      pub price: Price,
 54      pub count: u32,
 55      pub stock: Stock,
 56  }
 57  
 58  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
 59  pub struct ItemInBasket {
 60      pub market_id: MarketId,
 61      pub market_name: MarketName,
 62      pub store_id: StoreId,
 63      pub store_name: StoreName,
 64      pub item_id: ItemId,
 65      pub item_name: ItemName,
 66      pub image: MediaData,
 67      pub attr_keys: AttrKeys,
 68      pub attrs: AttrIndexesResponse,
 69      pub price: Price,
 70      pub count: u32,
 71      pub stock: Stock,
 72  }
 73  
 74  impl From<((StoreId, StoreName), PhysicalItemInBasket)> for ItemInBasket {
 75      fn from(item: ((StoreId, StoreName), PhysicalItemInBasket)) -> Self {
 76          ItemInBasket {
 77              market_id: item.1.market_id,
 78              market_name: item.1.market_name,
 79              store_id: item.0 .0,
 80              store_name: item.0 .1,
 81              item_id: item.1.item_id,
 82              item_name: item.1.item_name,
 83              image: item.1.image,
 84              attr_keys: item.1.attr_keys,
 85              attrs: item.1.attrs,
 86              price: item.1.price,
 87              count: item.1.count,
 88              stock: item.1.stock,
 89          }
 90      }
 91  }
 92  
 93  impl From<DigitalItemInBasket> for ItemInBasket {
 94      fn from(item: DigitalItemInBasket) -> Self {
 95          ItemInBasket {
 96              market_id: item.market_id,
 97              market_name: item.market_name,
 98              store_id: item.store_id,
 99              store_name: item.store_name,
100              item_id: item.item_id,
101              item_name: item.item_name,
102              image: item.image,
103              attr_keys: item.attr_keys,
104              attrs: item.attrs,
105              price: item.price,
106              count: item.count,
107              stock: item.stock,
108          }
109      }
110  }
111  
112  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
113  pub enum BasketItemError {
114      ItemNotFound,
115      ItemOutOfStock,
116      QuantityNotEnough,
117      MarketNotFound,
118      StoreNotFound,
119  }
120  
121  #[derive(CandidType, Serialize, Deserialize, Debug, Clone, PartialEq)]
122  pub enum UserBasketPageError {
123      ActorNotFound,
124      ActorIsNotUser,
125  }