lib

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

encode.rs (2787B)

      1 #[cfg(not(feature = "std"))]
      2 use alloc::{
      3     string::{String, ToString},
      4     vec::Vec,
      5 };
      6 
      7 use radroots_events::{
      8     farm::{RadrootsFarm, RadrootsFarmRef},
      9     kinds::KIND_FARM,
     10     tags::TAG_D,
     11 };
     12 
     13 use crate::d_tag::validate_d_tag;
     14 use crate::error::EventEncodeError;
     15 
     16 #[cfg(feature = "serde_json")]
     17 use crate::wire::WireEventParts;
     18 
     19 const TAG_T: &str = "t";
     20 const TAG_G: &str = "g";
     21 
     22 fn push_tag(tags: &mut Vec<Vec<String>>, key: &str, value: &str) {
     23     tags.push(vec![key.to_string(), value.to_string()]);
     24 }
     25 
     26 pub fn farm_build_tags(farm: &RadrootsFarm) -> Result<Vec<Vec<String>>, EventEncodeError> {
     27     if farm.d_tag.trim().is_empty() {
     28         return Err(EventEncodeError::EmptyRequiredField("d_tag"));
     29     }
     30     validate_d_tag(&farm.d_tag, "d_tag")?;
     31     if farm.name.trim().is_empty() {
     32         return Err(EventEncodeError::EmptyRequiredField("name"));
     33     }
     34     let mut tags = Vec::new();
     35     push_tag(&mut tags, TAG_D, &farm.d_tag);
     36     if let Some(items) = farm.tags.as_ref() {
     37         for item in items.iter().filter(|v| !v.trim().is_empty()) {
     38             push_tag(&mut tags, TAG_T, item);
     39         }
     40     }
     41     if let Some(geohash) = farm
     42         .location
     43         .as_ref()
     44         .and_then(|location| location.gcs.as_ref())
     45         .map(|gcs| gcs.geohash.trim())
     46     {
     47         if geohash.is_empty() {
     48             return Err(EventEncodeError::EmptyRequiredField("location.gcs.geohash"));
     49         }
     50         push_tag(&mut tags, TAG_G, geohash);
     51     }
     52     Ok(tags)
     53 }
     54 
     55 pub fn farm_ref_tags(farm: &RadrootsFarmRef) -> Result<Vec<Vec<String>>, EventEncodeError> {
     56     if farm.pubkey.trim().is_empty() {
     57         return Err(EventEncodeError::EmptyRequiredField("farm.pubkey"));
     58     }
     59     if farm.d_tag.trim().is_empty() {
     60         return Err(EventEncodeError::EmptyRequiredField("farm.d_tag"));
     61     }
     62     validate_d_tag(&farm.d_tag, "farm.d_tag")?;
     63     let mut addr = String::new();
     64     addr.push_str(&KIND_FARM.to_string());
     65     addr.push(':');
     66     addr.push_str(&farm.pubkey);
     67     addr.push(':');
     68     addr.push_str(&farm.d_tag);
     69     let mut tags = Vec::with_capacity(2);
     70     push_tag(&mut tags, "p", &farm.pubkey);
     71     push_tag(&mut tags, "a", &addr);
     72     Ok(tags)
     73 }
     74 
     75 #[cfg(feature = "serde_json")]
     76 pub fn to_wire_parts(farm: &RadrootsFarm) -> Result<WireEventParts, EventEncodeError> {
     77     to_wire_parts_with_kind(farm, KIND_FARM)
     78 }
     79 
     80 #[cfg(feature = "serde_json")]
     81 pub fn to_wire_parts_with_kind(
     82     farm: &RadrootsFarm,
     83     kind: u32,
     84 ) -> Result<WireEventParts, EventEncodeError> {
     85     if kind != KIND_FARM {
     86         return Err(EventEncodeError::InvalidKind(kind));
     87     }
     88     let tags = farm_build_tags(farm)?;
     89     let content = serde_json::to_string(farm).map_err(|_| EventEncodeError::Json)?;
     90     Ok(WireEventParts {
     91         kind,
     92         content,
     93         tags,
     94     })
     95 }