1  use crate::{item::get_item_core_data_vec, MARKETS};
  2  use candid::{CandidType, Decode, Deserialize, Encode};
  3  use ic_stable_structures::{storable::Bound, Storable};
  4  use interface::{
  5      item::{ItemCoreDataArgs, ItemCoreKeys},
  6      market::{
  7          MarketDataForHomeFirstLoadArgs, MarketDataForHomeFirstLoadResult, MarketDataResult,
  8          MarketId, MarketName,
  9      },
 10  };
 11  use std::{borrow::Cow, collections::BTreeMap};
 12  
 13  #[derive(CandidType, Deserialize, Debug, Clone)]
 14  pub struct Market {
 15      pub name: MarketName,
 16      pub contained_items: BTreeMap<u16, ItemCoreKeys>,
 17  }
 18  
 19  impl Storable for Market {
 20      fn to_bytes(&self) -> std::borrow::Cow<[u8]> {
 21          Cow::Owned(Encode!(self).unwrap())
 22      }
 23  
 24      fn from_bytes(bytes: std::borrow::Cow<[u8]>) -> Self {
 25          Decode!(bytes.as_ref(), Self).unwrap()
 26      }
 27  
 28      const BOUND: Bound = Bound::Bounded {
 29          max_size: 1024,
 30          is_fixed_size: false,
 31      };
 32  }
 33  
 34  impl Market {
 35      pub fn new(name: String, items: Option<Vec<ItemCoreKeys>>) -> Self {
 36          let mut contained_items = BTreeMap::new();
 37          if let Some(items) = items {
 38              for i in 0..items.len() {
 39                  contained_items.insert(i as u16, items[i].clone());
 40              }
 41          }
 42  
 43          Self {
 44              name,
 45              contained_items,
 46          }
 47      }
 48  }
 49  
 50  pub fn get_markets(market_ids: Vec<MarketId>) -> Vec<MarketDataResult> {
 51      let mut markets = Vec::new();
 52  
 53      for market_id in market_ids {
 54          let market = MARKETS.with(|p| p.borrow().get(&market_id));
 55  
 56          let market = match market {
 57              Some(market) => market,
 58              None => continue, // TODO: error handling
 59          };
 60  
 61          let items = market
 62              .contained_items
 63              .iter()
 64              .map(|(_, item)| item.clone())
 65              .collect();
 66  
 67          markets.push(MarketDataResult {
 68              name: market.name.clone(),
 69              items,
 70          });
 71      }
 72  
 73      markets
 74  }
 75  
 76  pub fn get_markets_for_home_first_load(
 77      arg: MarketDataForHomeFirstLoadArgs,
 78  ) -> Vec<MarketDataForHomeFirstLoadResult> {
 79      let mut markets = Vec::new();
 80  
 81      let len = arg.market_ids.len().min(5);
 82      let first_5_market_ids: Vec<MarketId> = arg.market_ids[..len].to_vec();
 83  
 84      for market_id in first_5_market_ids {
 85          let market = MARKETS.with(|p| p.borrow().get(&market_id));
 86  
 87          let market = match market {
 88              Some(market) => market,
 89              None => continue, // TODO: error handling
 90          };
 91  
 92          let first_ten_items: Vec<ItemCoreKeys> = market
 93              .contained_items
 94              .iter()
 95              .take(10)
 96              .map(|(_, item)| *item)
 97              .collect();
 98  
 99          let first_ten_item_core_data_args: Vec<ItemCoreDataArgs> = first_ten_items
100              .iter()
101              .map(|item| ItemCoreDataArgs {
102                  item: *item,
103                  currency: arg.currency,
104              })
105              .collect();
106  
107          let items = get_item_core_data_vec(first_ten_item_core_data_args);
108  
109          markets.push(MarketDataForHomeFirstLoadResult {
110              name: market.name.clone(),
111              items,
112          });
113      }
114  
115      markets
116  }