lib

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

profile.rs (2478B)

      1 use crate::error::{NetError, Result};
      2 use radroots_events_codec::parsed::RadrootsParsedData;
      3 use radroots_events_codec::profile::RadrootsProfileData;
      4 use radroots_nostr::prelude::{
      5     RadrootsNostrMetadata, RadrootsNostrPublicKey, radroots_nostr_fetch_metadata_for_author,
      6     radroots_nostr_post_metadata_event,
      7 };
      8 
      9 use crate::nostr_client::manager::NostrClientManager;
     10 
     11 impl NostrClientManager {
     12     pub async fn fetch_profile_event(
     13         &self,
     14         author: RadrootsNostrPublicKey,
     15     ) -> Result<Option<RadrootsParsedData<RadrootsProfileData>>> {
     16         let ev = radroots_nostr_fetch_metadata_for_author(
     17             &self.inner.client,
     18             author,
     19             core::time::Duration::from_secs(5),
     20         )
     21         .await
     22         .map_err(|e| NetError::Msg(e.to_string()))?;
     23         if let Some(e) = ev {
     24             if let Some(meta) = radroots_nostr::event_adapters::to_profile_event_metadata(&e) {
     25                 return Ok(Some(meta));
     26             }
     27             return Err(NetError::Msg(
     28                 "failed to parse kind:0 metadata content".to_string(),
     29             ));
     30         }
     31         Ok(None)
     32     }
     33 
     34     pub fn fetch_profile_event_blocking(
     35         &self,
     36         author: RadrootsNostrPublicKey,
     37     ) -> Result<Option<RadrootsParsedData<RadrootsProfileData>>> {
     38         let rt = self.inner.rt.clone();
     39         let this = self.clone();
     40         rt.block_on(async move { this.fetch_profile_event(author).await })
     41     }
     42 
     43     pub fn publish_profile_event_blocking(
     44         &self,
     45         name: Option<String>,
     46         display_name: Option<String>,
     47         nip05: Option<String>,
     48         about: Option<String>,
     49     ) -> Result<String> {
     50         let rt = self.inner.rt.clone();
     51         let inner_for_task = self.inner.clone();
     52         let event_id = rt.block_on(async move {
     53             let mut md = RadrootsNostrMetadata::new();
     54             if let Some(v) = name {
     55                 md = md.name(v);
     56             }
     57             if let Some(v) = display_name {
     58                 md = md.display_name(v);
     59             }
     60             if let Some(v) = nip05 {
     61                 md = md.nip05(v);
     62             }
     63             if let Some(v) = about {
     64                 md = md.about(v);
     65             }
     66             let out = radroots_nostr_post_metadata_event(&inner_for_task.client, &md)
     67                 .await
     68                 .map_err(|e| NetError::Msg(e.to_string()))?;
     69             Ok::<String, NetError>(out.val.to_string())
     70         })?;
     71         Ok(event_id)
     72     }
     73 }