lib

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

encode.rs (2686B)

      1 use crate::profile::error::ProfileEncodeError;
      2 #[cfg(feature = "serde_json")]
      3 use radroots_events::kinds::KIND_PROFILE;
      4 use radroots_events::profile::{
      5     RADROOTS_PROFILE_TYPE_TAG_KEY, RadrootsProfile, RadrootsProfileType,
      6     radroots_profile_type_tag_value,
      7 };
      8 
      9 use nostr::Metadata;
     10 use nostr::prelude::Url;
     11 
     12 #[cfg(not(feature = "std"))]
     13 use alloc::{string::String, vec::Vec};
     14 
     15 #[cfg(feature = "serde_json")]
     16 use crate::wire::WireEventParts;
     17 
     18 fn push_tag(tags: &mut Vec<Vec<String>>, key: &str, value: &str) {
     19     tags.push(vec![key.to_string(), value.to_string()]);
     20 }
     21 
     22 pub fn profile_type_tags(profile_type: RadrootsProfileType) -> Vec<Vec<String>> {
     23     let mut tags = Vec::with_capacity(1);
     24     push_tag(
     25         &mut tags,
     26         RADROOTS_PROFILE_TYPE_TAG_KEY,
     27         radroots_profile_type_tag_value(profile_type),
     28     );
     29     tags
     30 }
     31 
     32 pub fn profile_build_tags(profile_type: Option<RadrootsProfileType>) -> Vec<Vec<String>> {
     33     match profile_type {
     34         Some(value) => profile_type_tags(value),
     35         None => Vec::new(),
     36     }
     37 }
     38 
     39 pub fn to_metadata(p: &RadrootsProfile) -> Result<Metadata, ProfileEncodeError> {
     40     let mut md = Metadata::new().name(p.name.clone());
     41 
     42     if let Some(s) = &p.display_name {
     43         md = md.display_name(s.clone());
     44     }
     45     if let Some(s) = &p.about {
     46         md = md.about(s.clone());
     47     }
     48     if let Some(s) = &p.website {
     49         let u = Url::parse(s).map_err(|_| ProfileEncodeError::InvalidUrl("website", s.clone()))?;
     50         md = md.website(u);
     51     }
     52     if let Some(s) = &p.picture {
     53         let u = Url::parse(s).map_err(|_| ProfileEncodeError::InvalidUrl("picture", s.clone()))?;
     54         md = md.picture(u);
     55     }
     56     if let Some(s) = &p.banner {
     57         let u = Url::parse(s).map_err(|_| ProfileEncodeError::InvalidUrl("banner", s.clone()))?;
     58         md = md.banner(u);
     59     }
     60     if let Some(s) = &p.nip05 {
     61         md = md.nip05(s.clone());
     62     }
     63     if let Some(s) = &p.lud06 {
     64         md = md.lud06(s.clone());
     65     }
     66     if let Some(s) = &p.lud16 {
     67         md = md.lud16(s.clone());
     68     }
     69 
     70     Ok(md)
     71 }
     72 
     73 #[cfg(feature = "serde_json")]
     74 pub fn to_wire_parts(p: &RadrootsProfile) -> Result<WireEventParts, ProfileEncodeError> {
     75     to_wire_parts_with_profile_type(p, None)
     76 }
     77 
     78 #[cfg(feature = "serde_json")]
     79 pub fn to_wire_parts_with_profile_type(
     80     p: &RadrootsProfile,
     81     profile_type: Option<RadrootsProfileType>,
     82 ) -> Result<WireEventParts, ProfileEncodeError> {
     83     let md = to_metadata(p)?;
     84     let content = serde_json::to_string(&md).map_err(|_| ProfileEncodeError::Json)?;
     85     let tags = profile_build_tags(profile_type);
     86     Ok(WireEventParts {
     87         kind: KIND_PROFILE,
     88         content,
     89         tags,
     90     })
     91 }