lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

trade_validation.rs (4714B)

      1 #![forbid(unsafe_code)]
      2 
      3 #[cfg(not(feature = "std"))]
      4 use alloc::string::String;
      5 
      6 use crate::listing::operational::OperationalListingParseError;
      7 
      8 #[cfg_attr(
      9     any(feature = "serde", test),
     10     derive(serde::Serialize, serde::Deserialize)
     11 )]
     12 #[cfg_attr(all(test, feature = "std"), derive(dto_bindgen::Dto))]
     13 #[cfg_attr(all(test, feature = "std"), dto(export))]
     14 #[cfg_attr(
     15     feature = "serde",
     16     serde(rename_all = "snake_case", tag = "kind", content = "amount")
     17 )]
     18 #[derive(Clone, Debug, PartialEq, Eq)]
     19 pub enum OperationalListingValidationError {
     20     InvalidKind { kind: u32 },
     21     InvalidProfile,
     22     MissingListingId,
     23     ListingEventNotFound { listing_addr: String },
     24     ListingEventFetchFailed { listing_addr: String },
     25     ParseError { error: OperationalListingParseError },
     26     InvalidSeller,
     27     MissingFarmProfile,
     28     MissingFarmRecord,
     29     MissingTitle,
     30     MissingDescription,
     31     MissingProductType,
     32     MissingBins,
     33     MissingPrimaryBin,
     34     InvalidBin,
     35     MissingPrice,
     36     InvalidPrice,
     37     MissingInventory,
     38     InvalidInventory,
     39     MissingAvailability,
     40     MissingLocation,
     41     MissingLocationLocality,
     42     MissingLocationGeohash,
     43     InvalidLocationGeohash,
     44     MissingDeliveryMethod,
     45 }
     46 
     47 impl core::fmt::Display for OperationalListingValidationError {
     48     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
     49         match self {
     50             Self::InvalidKind { kind } => write!(f, "invalid listing kind: {kind}"),
     51             Self::InvalidProfile => {
     52                 write!(
     53                     f,
     54                     "classified listing is not an Operational Listing profile"
     55                 )
     56             }
     57             Self::MissingListingId => write!(f, "missing listing id"),
     58             Self::ListingEventNotFound { listing_addr } => {
     59                 write!(f, "listing event not found: {listing_addr}")
     60             }
     61             Self::ListingEventFetchFailed { listing_addr } => {
     62                 write!(f, "listing event fetch failed: {listing_addr}")
     63             }
     64             Self::ParseError { error } => write!(f, "invalid listing data: {error}"),
     65             Self::InvalidSeller => write!(f, "listing author does not match farm pubkey"),
     66             Self::MissingFarmProfile => write!(f, "missing farm profile"),
     67             Self::MissingFarmRecord => write!(f, "missing farm record"),
     68             Self::MissingTitle => write!(f, "missing listing title"),
     69             Self::MissingDescription => write!(f, "missing listing description"),
     70             Self::MissingProductType => write!(f, "missing listing product type"),
     71             Self::MissingBins => write!(f, "missing listing bins"),
     72             Self::MissingPrimaryBin => write!(f, "missing primary listing bin"),
     73             Self::InvalidBin => write!(f, "invalid listing bin"),
     74             Self::MissingPrice => write!(f, "missing listing price"),
     75             Self::InvalidPrice => write!(f, "invalid listing price"),
     76             Self::MissingInventory => write!(f, "missing listing inventory"),
     77             Self::InvalidInventory => write!(f, "invalid listing inventory"),
     78             Self::MissingAvailability => write!(f, "missing listing availability"),
     79             Self::MissingLocation => write!(f, "missing listing location"),
     80             Self::MissingLocationLocality => write!(f, "missing listing location locality"),
     81             Self::MissingLocationGeohash => write!(f, "missing listing location geohash"),
     82             Self::InvalidLocationGeohash => write!(f, "invalid listing location geohash"),
     83             Self::MissingDeliveryMethod => write!(f, "missing listing delivery method"),
     84         }
     85     }
     86 }
     87 
     88 #[cfg(feature = "std")]
     89 impl std::error::Error for OperationalListingValidationError {}
     90 
     91 #[cfg(test)]
     92 #[cfg_attr(coverage_nightly, coverage(off))]
     93 mod tests {
     94     use super::*;
     95 
     96     #[test]
     97     fn listing_validation_error_display_covers_location_variants() {
     98         assert_eq!(
     99             OperationalListingValidationError::InvalidProfile.to_string(),
    100             "classified listing is not an Operational Listing profile"
    101         );
    102         assert_eq!(
    103             OperationalListingValidationError::MissingLocation.to_string(),
    104             "missing listing location"
    105         );
    106         assert_eq!(
    107             OperationalListingValidationError::MissingLocationLocality.to_string(),
    108             "missing listing location locality"
    109         );
    110         assert_eq!(
    111             OperationalListingValidationError::MissingLocationGeohash.to_string(),
    112             "missing listing location geohash"
    113         );
    114         assert_eq!(
    115             OperationalListingValidationError::InvalidLocationGeohash.to_string(),
    116             "invalid listing location geohash"
    117         );
    118     }
    119 }