lib

decode.rs (33230B)

---

 #[cfg(not(feature = "std"))]
 use alloc::{
     string::{String, ToString},
     vec::Vec,
 };
 
 use radroots_core::pricing::Discount;
 use radroots_core::{Currency, Decimal, Money, Quantity, QuantityPrice, Unit};
 use radroots_event::{
     envelope::EventEnvelope,
     envelope::kind::{KIND_FARM, KIND_PLOT, KIND_RESOURCE_AREA, is_classified_listing_kind},
     farm::FarmRef,
     farm::location::is_public_geohash5,
     farm::plot::PlotRef,
     farm::resource_area::ResourceAreaRef,
     id::{DTag, InventoryBinId},
     listing::operational::OperationalListingParseError,
     listing::operational::{
         OperationalListing, OperationalListingAvailability, OperationalListingBin,
         OperationalListingDeliveryMethod, OperationalListingImage, OperationalListingImageSize,
         OperationalListingProduct, OperationalListingPublicLocation, OperationalListingStatus,
     },
     tag::name::{TAG_D, TAG_PUBLISHED_AT},
 };
 
 use crate::d_tag::validate_d_tag_tag;
 use crate::error::EventParseError;
 use crate::parsed::{RadrootsParsedData, RadrootsParsedEvent};
 
 const EXPECTED_CLASSIFIED_LISTING_KINDS: &str = "30402";
 const TAG_A: &str = "a";
 const TAG_P: &str = "p";
 const TAG_PRICE: &str = "price";
 const TAG_RADROOTS_BIN: &str = "radroots:bin";
 const TAG_RADROOTS_PRICE: &str = "radroots:price";
 const TAG_RADROOTS_DISCOUNT: &str = "radroots:discount";
 const TAG_RADROOTS_PRIMARY_BIN: &str = "radroots:primary_bin";
 const TAG_RADROOTS_RESOURCE_AREA: &str = "radroots:resource_area";
 const TAG_RADROOTS_PLOT: &str = "radroots:plot";
 const TAG_LOCATION: &str = "location";
 const TAG_IMAGE: &str = "image";
 const TAG_GEOHASH: &str = "g";
 const TAG_LABEL: &str = "l";
 const TAG_LABEL_NS: &str = "L";
 const TAG_DD: &str = "dd";
 const TAG_DD_LAT: &str = "dd.lat";
 const TAG_DD_LON: &str = "dd.lon";
 const TAG_INVENTORY: &str = "inventory";
 const TAG_DELIVERY: &str = "delivery";
 const TAG_RADROOTS_AVAILABILITY_START: &str = "radroots:availability_start";
 const TAG_STATUS: &str = "status";
 const TAG_EXPIRES_AT: &str = "expires_at";
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 enum OperationalListingDecodeError {
     MissingTag(&'static str),
     InvalidTag(&'static str),
     InvalidNumber(&'static str),
     InvalidUnit(&'static str),
     InvalidCurrency(&'static str),
     InvalidJson(&'static str),
     #[cfg(feature = "json")]
     InvalidDiscount(&'static str),
 }
 
 impl OperationalListingDecodeError {
     fn into_listing_parse_error(self) -> OperationalListingParseError {
         match self {
             Self::MissingTag(field) => OperationalListingParseError::MissingTag(field.to_string()),
             Self::InvalidTag(field) => OperationalListingParseError::InvalidTag(field.to_string()),
             Self::InvalidNumber(field) => {
                 OperationalListingParseError::InvalidNumber(field.to_string())
             }
             Self::InvalidUnit(_) => OperationalListingParseError::InvalidUnit,
             Self::InvalidCurrency(_) => OperationalListingParseError::InvalidCurrency,
             Self::InvalidJson(field) => {
                 OperationalListingParseError::InvalidJson(field.to_string())
             }
             #[cfg(feature = "json")]
             Self::InvalidDiscount(field) => {
                 OperationalListingParseError::InvalidDiscount(field.to_string())
             }
         }
     }
 
     fn into_event_parse_error(self) -> EventParseError {
         match self {
             Self::MissingTag(field) => EventParseError::MissingTag(field),
             Self::InvalidTag(field)
             | Self::InvalidNumber(field)
             | Self::InvalidUnit(field)
             | Self::InvalidCurrency(field) => EventParseError::InvalidTag(field),
             #[cfg(feature = "json")]
             Self::InvalidDiscount(field) => EventParseError::InvalidTag(field),
             Self::InvalidJson(_) => EventParseError::InvalidJson("content"),
         }
     }
 }
 
 struct OperationalListingLocationDraft {
     primary: String,
     city: Option<String>,
     region: Option<String>,
     country: Option<String>,
 }
 
 fn parse_decimal(
     value: &str,
     field: &'static str,
 ) -> Result<Decimal, OperationalListingDecodeError> {
     value
         .parse::<Decimal>()
         .map_err(|_| OperationalListingDecodeError::InvalidNumber(field))
 }
 
 fn reject_private_listing_location_content(
     content: &str,
 ) -> Result<(), OperationalListingDecodeError> {
     let trimmed = content.trim();
     if !trimmed.starts_with('{') {
         return Ok(());
     }
     #[cfg(feature = "json")]
     {
         let Ok(value) = serde_json::from_str::<serde_json::Value>(trimmed) else {
             return Ok(());
         };
         let Some(location) = value.get("location").and_then(|value| value.as_object()) else {
             return Ok(());
         };
         for key in [
             "lat",
             "lng",
             "lon",
             "point",
             "polygon",
             "coordinates",
             "accuracy",
             "altitude",
             "label",
             "tag_0",
             "gcs",
         ] {
             if location.contains_key(key) {
                 return Err(OperationalListingDecodeError::InvalidJson("location"));
             }
         }
     }
     Ok(())
 }
 
 fn parse_currency(
     value: &str,
     field: &'static str,
 ) -> Result<Currency, OperationalListingDecodeError> {
     let upper = value.trim().to_ascii_uppercase();
     Currency::from_str_upper(&upper)
         .map_err(|_| OperationalListingDecodeError::InvalidCurrency(field))
 }
 
 fn parse_unit(value: &str, field: &'static str) -> Result<Unit, OperationalListingDecodeError> {
     value
         .parse::<Unit>()
         .map_err(|_| OperationalListingDecodeError::InvalidUnit(field))
 }
 
 fn parse_u64_tag_value(
     value: Option<&String>,
     field: &'static str,
 ) -> Result<u64, OperationalListingDecodeError> {
     value
         .ok_or(OperationalListingDecodeError::InvalidTag(field))?
         .parse::<u64>()
         .map_err(|_| OperationalListingDecodeError::InvalidNumber(field))
 }
 
 fn parse_d_tag(tags: &[Vec<String>]) -> Result<String, OperationalListingDecodeError> {
     let tag = tags
         .iter()
         .find(|tag| tag.first().map(|value| value.as_str()) == Some(TAG_D))
         .ok_or(OperationalListingDecodeError::MissingTag(TAG_D))?;
     let value = tag
         .get(1)
         .map(|value| value.to_string())
         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_D))?;
     if value.trim().is_empty() {
         return Err(OperationalListingDecodeError::InvalidTag(TAG_D));
     }
     validate_d_tag_tag(&value, TAG_D)
         .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_D))?;
     Ok(value)
 }
 
 fn parse_farm_ref(tags: &[Vec<String>]) -> Result<FarmRef, OperationalListingDecodeError> {
     for tag in tags
         .iter()
         .filter(|tag| tag.first().map(|value| value.as_str()) == Some(TAG_A))
     {
         let value = tag
             .get(1)
             .map(|value| value.to_string())
             .ok_or(OperationalListingDecodeError::InvalidTag(TAG_A))?;
         let mut parts = value.splitn(3, ':');
         let kind = parts
             .next()
             .and_then(|raw| raw.parse::<u32>().ok())
             .ok_or(OperationalListingDecodeError::InvalidTag(TAG_A))?;
         if kind != KIND_FARM {
             continue;
         }
         let pubkey = parts
             .next()
             .ok_or(OperationalListingDecodeError::InvalidTag(TAG_A))?
             .to_string();
         let d_tag = parts
             .next()
             .ok_or(OperationalListingDecodeError::InvalidTag(TAG_A))?
             .to_string();
         if pubkey.trim().is_empty() || d_tag.trim().is_empty() {
             return Err(OperationalListingDecodeError::InvalidTag(TAG_A));
         }
         validate_d_tag_tag(&d_tag, TAG_A)
             .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_A))?;
         return Ok(FarmRef { pubkey, d_tag });
     }
     Err(OperationalListingDecodeError::MissingTag(TAG_A))
 }
 
 fn parse_farm_pubkey(tags: &[Vec<String>]) -> Result<String, OperationalListingDecodeError> {
     let tag = tags
         .iter()
         .find(|tag| tag.first().map(|value| value.as_str()) == Some(TAG_P))
         .ok_or(OperationalListingDecodeError::MissingTag(TAG_P))?;
     let value = tag
         .get(1)
         .map(|value| value.to_string())
         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_P))?;
     if value.trim().is_empty() {
         return Err(OperationalListingDecodeError::InvalidTag(TAG_P));
     }
     Ok(value)
 }
 
 fn parse_resource_area(
     tags: &[Vec<String>],
 ) -> Result<Option<ResourceAreaRef>, OperationalListingDecodeError> {
     let tag = tags
         .iter()
         .find(|tag| tag.first().map(|value| value.as_str()) == Some(TAG_RADROOTS_RESOURCE_AREA));
     let Some(tag) = tag else {
         return Ok(None);
     };
     let value = tag.get(1).map(|value| value.to_string()).ok_or(
         OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_RESOURCE_AREA),
     )?;
     let mut parts = value.splitn(3, ':');
     let kind = parts.next().and_then(|raw| raw.parse::<u32>().ok()).ok_or(
         OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_RESOURCE_AREA),
     )?;
     if kind != KIND_RESOURCE_AREA {
         return Err(OperationalListingDecodeError::InvalidTag(
             TAG_RADROOTS_RESOURCE_AREA,
         ));
     }
     let pubkey = parts
         .next()
         .ok_or(OperationalListingDecodeError::InvalidTag(
             TAG_RADROOTS_RESOURCE_AREA,
         ))?
         .to_string();
     let d_tag = parts
         .next()
         .ok_or(OperationalListingDecodeError::InvalidTag(
             TAG_RADROOTS_RESOURCE_AREA,
         ))?
         .to_string();
     if pubkey.trim().is_empty() || d_tag.trim().is_empty() {
         return Err(OperationalListingDecodeError::InvalidTag(
             TAG_RADROOTS_RESOURCE_AREA,
         ));
     }
     validate_d_tag_tag(&d_tag, TAG_RADROOTS_RESOURCE_AREA)
         .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_RESOURCE_AREA))?;
     Ok(Some(ResourceAreaRef { pubkey, d_tag }))
 }
 
 fn parse_plot_ref(tags: &[Vec<String>]) -> Result<Option<PlotRef>, OperationalListingDecodeError> {
     let tag = tags
         .iter()
         .find(|tag| tag.first().map(|value| value.as_str()) == Some(TAG_RADROOTS_PLOT));
     let Some(tag) = tag else {
         return Ok(None);
     };
     let value = tag
         .get(1)
         .map(|value| value.to_string())
         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT))?;
     let mut parts = value.splitn(3, ':');
     let kind = parts
         .next()
         .and_then(|raw| raw.parse::<u32>().ok())
         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT))?;
     if kind != KIND_PLOT {
         return Err(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT));
     }
     let pubkey = parts
         .next()
         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT))?
         .to_string();
     let d_tag = parts
         .next()
         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT))?
         .to_string();
     if pubkey.trim().is_empty() || d_tag.trim().is_empty() {
         return Err(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT));
     }
     validate_d_tag_tag(&d_tag, TAG_RADROOTS_PLOT)
         .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PLOT))?;
     Ok(Some(PlotRef { pubkey, d_tag }))
 }
 
 pub fn operational_listing_from_event(
     kind: u32,
     tags: &[Vec<String>],
     content: &str,
 ) -> Result<OperationalListing, EventParseError> {
     if !is_classified_listing_kind(kind) {
         return Err(EventParseError::InvalidKind {
             expected: EXPECTED_CLASSIFIED_LISTING_KINDS,
             got: kind,
         });
     }
     decode_operational_listing_from_event_parts(tags, content)
         .map_err(OperationalListingDecodeError::into_event_parse_error)
 }
 
 pub fn operational_listing_from_event_parts(
     tags: &[Vec<String>],
     content: &str,
 ) -> Result<OperationalListing, OperationalListingParseError> {
     decode_operational_listing_from_event_parts(tags, content)
         .map_err(OperationalListingDecodeError::into_listing_parse_error)
 }
 
 pub fn operational_listing_from_nostr_event(
     event: &EventEnvelope,
 ) -> Result<OperationalListing, OperationalListingParseError> {
     if !is_classified_listing_kind(event.kind_u32()) {
         return Err(OperationalListingParseError::InvalidKind(event.kind_u32()));
     }
     operational_listing_from_event_parts(&event.tags_as_vec(), event.content())
 }
 
 fn decode_operational_listing_from_event_parts(
     tags: &[Vec<String>],
     content: &str,
 ) -> Result<OperationalListing, OperationalListingDecodeError> {
     reject_private_listing_location_content(content)?;
     let d_tag = parse_d_tag(tags)?;
     let farm_ref = parse_farm_ref(tags)?;
     let farm_pubkey = parse_farm_pubkey(tags)?;
     let resource_area = parse_resource_area(tags)?;
     let plot = parse_plot_ref(tags)?;
 
     let mut product = OperationalListingProduct {
         key: String::new(),
         title: String::new(),
         category: String::new(),
         summary: None,
         process: None,
         lot: None,
         location: None,
         profile: None,
         year: None,
     };
     let mut primary_bin_id: Option<String> = None;
     let mut bin_drafts: Vec<BinDraft> = Vec::new();
     let mut bin_order = 0usize;
     let mut discounts: Vec<Discount> = Vec::new();
     let mut location: Option<OperationalListingLocationDraft> = None;
     let mut inventory_available: Option<Decimal> = None;
     let mut availability_status: Option<OperationalListingStatus> = None;
     let mut availability_start: Option<u64> = None;
     let mut availability_end: Option<u64> = None;
     let mut delivery_method: Option<OperationalListingDeliveryMethod> = None;
     let mut images: Vec<OperationalListingImage> = Vec::new();
     let mut geohash: Option<String> = None;
     let mut published_at: Option<u64> = None;
 
     for tag in tags {
         if tag.is_empty() {
             continue;
         }
         match tag[0].as_str() {
             "key" => set_if_empty(&mut product.key, tag.get(1)),
             "title" => set_if_empty(&mut product.title, tag.get(1)),
             "category" => set_if_empty(&mut product.category, tag.get(1)),
             "summary" => set_optional(&mut product.summary, tag.get(1)),
             TAG_PUBLISHED_AT => {
                 published_at = Some(parse_u64_tag_value(tag.get(1), TAG_PUBLISHED_AT)?);
             }
             "process" => set_optional(&mut product.process, tag.get(1)),
             "lot" => set_optional(&mut product.lot, tag.get(1)),
             "location" => {
                 let parse_structured_location = !matches!(tag.len(), 0..=2);
                 if parse_structured_location {
                     let primary = tag
                         .get(1)
                         .and_then(|value| clean_value(value))
                         .ok_or(OperationalListingDecodeError::InvalidTag(TAG_LOCATION))?;
                     let mut parsed = OperationalListingLocationDraft {
                         primary,
                         city: None,
                         region: None,
                         country: None,
                     };
                     if let Some(city) = tag.get(2).and_then(|value| clean_value(value)) {
                         parsed.city = Some(city);
                     }
                     if let Some(region) = tag.get(3).and_then(|value| clean_value(value)) {
                         parsed.region = Some(region);
                     }
                     if let Some(country) = tag.get(4).and_then(|value| clean_value(value)) {
                         parsed.country = Some(country);
                     }
                     location = Some(parsed);
                 } else {
                     set_optional(&mut product.location, tag.get(1));
                 }
             }
             "profile" => set_optional(&mut product.profile, tag.get(1)),
             "year" => set_optional(&mut product.year, tag.get(1)),
             TAG_PRICE => {}
             TAG_RADROOTS_PRIMARY_BIN => {
                 let value = tag.get(1).and_then(|value| clean_value(value)).ok_or(
                     OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRIMARY_BIN),
                 )?;
                 if let Some(existing) = primary_bin_id.as_ref() {
                     if existing != &value {
                         return Err(OperationalListingDecodeError::InvalidTag(
                             TAG_RADROOTS_PRIMARY_BIN,
                         ));
                     }
                 } else {
                     primary_bin_id = Some(value);
                 }
             }
             TAG_RADROOTS_BIN => {
                 if tag.len() < 4 || tag.len() > 7 {
                     return Err(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN));
                 }
                 let bin_id = tag
                     .get(1)
                     .and_then(|value| clean_value(value))
                     .ok_or(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN))?;
                 let amount = parse_decimal(&tag[2], TAG_RADROOTS_BIN)?;
                 let unit = parse_unit(&tag[3], TAG_RADROOTS_BIN)?;
                 if unit != unit.canonical_unit() {
                     return Err(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN));
                 }
                 let bin = upsert_bin(&mut bin_drafts, &bin_id, &mut bin_order);
                 if bin.quantity.is_some() {
                     return Err(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN));
                 }
                 bin.quantity =
                     Some(Quantity::try_new(amount, unit).map_err(|_| {
                         OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN)
                     })?);
 
                 match tag.as_slice() {
                     [_, _, _, _, display_amount_raw, display_unit_raw]
                     | [_, _, _, _, display_amount_raw, display_unit_raw, _] => {
                         let display_amount = parse_decimal(display_amount_raw, TAG_RADROOTS_BIN)?;
                         let display_unit = parse_unit(display_unit_raw, TAG_RADROOTS_BIN)?;
                         bin.display_amount = Some(display_amount);
                         bin.display_unit = Some(display_unit);
                         if let [_, _, _, _, _, _, label] = tag.as_slice() {
                             bin.display_label = clean_value(label);
                         }
                     }
                     [_, _, _, _, _] => {
                         return Err(OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN));
                     }
                     _ => {}
                 }
             }
             TAG_RADROOTS_PRICE => {
                 if tag.len() < 6 || tag.len() > 8 {
                     return Err(OperationalListingDecodeError::InvalidTag(
                         TAG_RADROOTS_PRICE,
                     ));
                 }
                 let bin_id = tag.get(1).and_then(|value| clean_value(value)).ok_or(
                     OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRICE),
                 )?;
                 let amount = parse_decimal(&tag[2], TAG_RADROOTS_PRICE)?;
                 let currency = parse_currency(&tag[3], TAG_RADROOTS_PRICE)?;
                 let per_amount = parse_decimal(&tag[4], TAG_RADROOTS_PRICE)?;
                 let per_unit = parse_unit(&tag[5], TAG_RADROOTS_PRICE)?;
                 let money = Money::try_new(amount, currency)
                     .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRICE))?;
                 let quantity = Quantity::try_new(per_amount, per_unit)
                     .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRICE))?;
                 let price_per_canonical_unit = QuantityPrice::try_new(money, quantity)
                     .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRICE))?;
                 if !price_per_canonical_unit.is_price_per_canonical_unit() {
                     return Err(OperationalListingDecodeError::InvalidTag(
                         TAG_RADROOTS_PRICE,
                     ));
                 }
                 let bin = upsert_bin(&mut bin_drafts, &bin_id, &mut bin_order);
                 if bin.price_per_canonical_unit.is_some() {
                     return Err(OperationalListingDecodeError::InvalidTag(
                         TAG_RADROOTS_PRICE,
                     ));
                 }
                 bin.price_per_canonical_unit = Some(price_per_canonical_unit);
 
                 match tag.as_slice() {
                     [_, _, _, _, _, _, _] => {
                         return Err(OperationalListingDecodeError::InvalidTag(
                             TAG_RADROOTS_PRICE,
                         ));
                     }
                     [_, _, _, _, _, _, display_price_raw, display_unit_raw] => {
                         let display_price = parse_decimal(display_price_raw, TAG_RADROOTS_PRICE)?;
                         let display_unit = parse_unit(display_unit_raw, TAG_RADROOTS_PRICE)?;
                         bin.display_price =
                             Some(Money::try_new(display_price, currency).map_err(|_| {
                                 OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRICE)
                             })?);
                         bin.display_price_unit = Some(display_unit);
                     }
                     _ => {}
                 }
             }
             TAG_RADROOTS_DISCOUNT => {
                 let payload = tag.get(1).ok_or(OperationalListingDecodeError::InvalidTag(
                     TAG_RADROOTS_DISCOUNT,
                 ))?;
                 discounts.push(parse_discount(payload)?);
             }
             TAG_GEOHASH => {
                 let value = tag
                     .get(1)
                     .and_then(|value| clean_value(value))
                     .ok_or(OperationalListingDecodeError::InvalidTag(TAG_GEOHASH))?;
                 if !is_public_geohash5(&value) {
                     return Err(OperationalListingDecodeError::InvalidTag(TAG_GEOHASH));
                 }
                 let value = value.to_ascii_lowercase();
                 if geohash.as_ref().is_some_and(|existing| existing != &value) {
                     return Err(OperationalListingDecodeError::InvalidTag(TAG_GEOHASH));
                 }
                 geohash = Some(value);
             }
             TAG_DD => return Err(OperationalListingDecodeError::InvalidTag(TAG_DD)),
             TAG_DD_LAT => return Err(OperationalListingDecodeError::InvalidTag(TAG_DD_LAT)),
             TAG_DD_LON => return Err(OperationalListingDecodeError::InvalidTag(TAG_DD_LON)),
             TAG_LABEL => return Err(OperationalListingDecodeError::InvalidTag(TAG_LABEL)),
             TAG_LABEL_NS => return Err(OperationalListingDecodeError::InvalidTag(TAG_LABEL_NS)),
             TAG_INVENTORY => {
                 let value = tag
                     .get(1)
                     .ok_or(OperationalListingDecodeError::InvalidTag(TAG_INVENTORY))?;
                 inventory_available = Some(parse_decimal(value, TAG_INVENTORY)?);
             }
             TAG_RADROOTS_AVAILABILITY_START => {
                 availability_start = Some(parse_u64_tag_value(
                     tag.get(1),
                     TAG_RADROOTS_AVAILABILITY_START,
                 )?);
             }
             TAG_EXPIRES_AT => {
                 availability_end = Some(parse_u64_tag_value(tag.get(1), TAG_EXPIRES_AT)?);
             }
             TAG_STATUS => {
                 let status = tag
                     .get(1)
                     .and_then(|value| clean_value(value))
                     .unwrap_or_default();
                 availability_status = Some(parse_status(&status));
             }
             TAG_DELIVERY => {
                 let method = tag
                     .get(1)
                     .and_then(|value| clean_value(value))
                     .unwrap_or_default();
                 delivery_method = Some(match method.as_str() {
                     "pickup" => OperationalListingDeliveryMethod::Pickup,
                     "local_delivery" => OperationalListingDeliveryMethod::LocalDelivery,
                     "shipping" => OperationalListingDeliveryMethod::Shipping,
                     "other" => OperationalListingDeliveryMethod::Other {
                         method: tag
                             .get(2)
                             .and_then(|value| clean_value(value))
                             .unwrap_or_default(),
                     },
                     other => OperationalListingDeliveryMethod::Other {
                         method: other.to_string(),
                     },
                 });
             }
             TAG_IMAGE => {
                 let url = tag
                     .get(1)
                     .ok_or(OperationalListingDecodeError::InvalidTag(TAG_IMAGE))?;
                 if url.trim().is_empty() {
                     continue;
                 }
                 images.push(OperationalListingImage {
                     url: url.to_string(),
                     size: tag.get(2).and_then(|value| parse_image_size(value)),
                 });
             }
             _ => {}
         }
     }
 
     let availability = match availability_status {
         Some(status) => Some(OperationalListingAvailability::Status { status }),
         None => match (availability_start, availability_end) {
             (None, None) => None,
             (start, end) => Some(OperationalListingAvailability::Window { start, end }),
         },
     };
 
     let location = location
         .map(|location| {
             let geohash = geohash.ok_or(OperationalListingDecodeError::InvalidTag(TAG_GEOHASH))?;
             Ok::<OperationalListingPublicLocation, OperationalListingDecodeError>(
                 OperationalListingPublicLocation {
                     primary: location.primary,
                     city: location.city,
                     region: location.region,
                     country: location.country,
                     geohash,
                 },
             )
         })
         .transpose()?;
 
     if farm_pubkey != farm_ref.pubkey {
         return Err(OperationalListingDecodeError::InvalidTag(TAG_P));
     }
 
     let primary_bin_id = primary_bin_id.ok_or(OperationalListingDecodeError::MissingTag(
         TAG_RADROOTS_PRIMARY_BIN,
     ))?;
     let bins = build_bins(bin_drafts)?;
     if !bins.iter().any(|bin| bin.bin_id.as_str() == primary_bin_id) {
         return Err(OperationalListingDecodeError::InvalidTag(
             TAG_RADROOTS_PRIMARY_BIN,
         ));
     }
 
     let d_tag =
         DTag::parse(&d_tag).map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_D))?;
     let primary_bin_id = InventoryBinId::parse(&primary_bin_id)
         .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_PRIMARY_BIN))?;
 
     Ok(OperationalListing {
         d_tag,
         published_at,
         farm: farm_ref,
         product,
         primary_bin_id,
         bins,
         resource_area,
         plot,
         discounts: if discounts.is_empty() {
             None
         } else {
             Some(discounts)
         },
         inventory_available,
         availability,
         delivery_method,
         location,
         images: if images.is_empty() {
             None
         } else {
             Some(images)
         },
     })
 }
 
 pub fn data_from_event(
     id: String,
     author: String,
     published_at: u64,
     kind: u32,
     content: String,
     tags: Vec<Vec<String>>,
 ) -> Result<RadrootsParsedData<OperationalListing>, EventParseError> {
     let listing = operational_listing_from_event(kind, &tags, &content)?;
     Ok(RadrootsParsedData::new(
         id,
         author,
         published_at,
         kind,
         listing,
     ))
 }
 
 pub fn parsed_from_event(
     id: String,
     author: String,
     published_at: u64,
     kind: u32,
     content: String,
     tags: Vec<Vec<String>>,
     sig: String,
 ) -> Result<RadrootsParsedEvent<OperationalListing>, EventParseError> {
     let data = data_from_event(
         id.clone(),
         author.clone(),
         published_at,
         kind,
         content.clone(),
         tags.clone(),
     )?;
     RadrootsParsedEvent::from_parts(
         id,
         author,
         published_at,
         kind,
         content,
         tags,
         sig,
         data.data,
     )
 }
 
 pub fn data_from_nostr_event(
     event: &EventEnvelope,
 ) -> Result<RadrootsParsedData<OperationalListing>, EventParseError> {
     data_from_event(
         event.id_hex(),
         event.author().to_hex().to_string(),
         event.created_at_u64(),
         event.kind_u32(),
         event.content().to_string(),
         event.tags_as_vec(),
     )
 }
 
 pub fn parsed_from_nostr_event(
     event: &EventEnvelope,
 ) -> Result<RadrootsParsedEvent<OperationalListing>, EventParseError> {
     parsed_from_event(
         event.id_hex(),
         event.author().to_hex().to_string(),
         event.created_at_u64(),
         event.kind_u32(),
         event.content().to_string(),
         event.tags_as_vec(),
         event.signature_hex(),
     )
 }
 
 fn clean_value(value: &str) -> Option<String> {
     let trimmed = value.trim();
     if trimmed.is_empty() || trimmed.eq_ignore_ascii_case("null") {
         None
     } else {
         Some(trimmed.to_string())
     }
 }
 
 fn set_if_empty(target: &mut String, value: Option<&String>) {
     if target.trim().is_empty()
         && let Some(value) = value.and_then(|value| clean_value(value))
     {
         *target = value;
     }
 }
 
 fn set_optional(target: &mut Option<String>, value: Option<&String>) {
     if target.is_none()
         && let Some(value) = value.and_then(|value| clean_value(value))
     {
         *target = Some(value);
     }
 }
 
 fn parse_status(value: &str) -> OperationalListingStatus {
     match value.trim().to_ascii_lowercase().as_str() {
         "active" => OperationalListingStatus::Active,
         "sold" => OperationalListingStatus::Sold,
         other => OperationalListingStatus::Other {
             value: other.to_string(),
         },
     }
 }
 
 fn parse_image_size(value: &str) -> Option<OperationalListingImageSize> {
     let (w_raw, h_raw) = value.split_once('x')?;
     let w = w_raw.parse::<u32>().ok()?;
     let h = h_raw.parse::<u32>().ok()?;
     Some(OperationalListingImageSize { w, h })
 }
 
 fn parse_discount(payload: &str) -> Result<Discount, OperationalListingDecodeError> {
     #[cfg(feature = "json")]
     {
         serde_json::from_str(payload)
             .map_err(|_| OperationalListingDecodeError::InvalidDiscount(TAG_RADROOTS_DISCOUNT))
     }
     #[cfg(not(feature = "json"))]
     {
         let _ = payload;
         Err(OperationalListingDecodeError::InvalidJson("discount"))
     }
 }
 
 #[derive(Clone, Debug)]
 struct BinDraft {
     bin_id: String,
     order_index: usize,
     quantity: Option<Quantity>,
     display_amount: Option<Decimal>,
     display_unit: Option<Unit>,
     display_label: Option<String>,
     price_per_canonical_unit: Option<QuantityPrice>,
     display_price: Option<Money>,
     display_price_unit: Option<Unit>,
 }
 
 fn upsert_bin<'a>(
     bins: &'a mut Vec<BinDraft>,
     bin_id: &str,
     order_index: &mut usize,
 ) -> &'a mut BinDraft {
     if let Some(position) = bins.iter().position(|bin| bin.bin_id == bin_id) {
         return &mut bins[position];
     }
     bins.push(BinDraft {
         bin_id: bin_id.to_string(),
         order_index: *order_index,
         quantity: None,
         display_amount: None,
         display_unit: None,
         display_label: None,
         price_per_canonical_unit: None,
         display_price: None,
         display_price_unit: None,
     });
     *order_index += 1;
     let index = bins.len() - 1;
     &mut bins[index]
 }
 
 fn build_bins(
     mut drafts: Vec<BinDraft>,
 ) -> Result<Vec<OperationalListingBin>, OperationalListingDecodeError> {
     drafts.sort_by_key(|draft| draft.order_index);
     let mut bins = Vec::with_capacity(drafts.len());
     for draft in drafts {
         let quantity = draft
             .quantity
             .ok_or(OperationalListingDecodeError::MissingTag(TAG_RADROOTS_BIN))?;
         let price =
             draft
                 .price_per_canonical_unit
                 .ok_or(OperationalListingDecodeError::MissingTag(
                     TAG_RADROOTS_PRICE,
                 ))?;
         if quantity.unit() != price.quantity().unit() {
             return Err(OperationalListingDecodeError::InvalidTag(
                 TAG_RADROOTS_PRICE,
             ));
         }
         bins.push(OperationalListingBin {
             bin_id: InventoryBinId::parse(&draft.bin_id)
                 .map_err(|_| OperationalListingDecodeError::InvalidTag(TAG_RADROOTS_BIN))?,
             quantity,
             price_per_canonical_unit: price,
             display_amount: draft.display_amount,
             display_unit: draft.display_unit,
             display_label: draft.display_label,
             display_price: draft.display_price,
             display_price_unit: draft.display_price_unit,
         });
     }
     Ok(bins)
 }