lib

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

post.rs (2870B)

      1 use crate::error::{NetError, Result};
      2 use radroots_events::post::RadrootsPost;
      3 use radroots_events_codec::parsed::RadrootsParsedData;
      4 use radroots_nostr::prelude::{
      5     radroots_nostr_build_post_event, radroots_nostr_build_post_reply_event,
      6     radroots_nostr_fetch_post_events, radroots_nostr_send_event,
      7 };
      8 
      9 use crate::nostr_client::manager::NostrClientManager;
     10 
     11 impl NostrClientManager {
     12     pub async fn publish_post_event(&self, content: String) -> Result<String> {
     13         let builder = radroots_nostr_build_post_event(content);
     14         let out = radroots_nostr_send_event(&self.inner.client, builder)
     15             .await
     16             .map_err(|e| NetError::Msg(e.to_string()))?;
     17         Ok(out.val.to_string())
     18     }
     19 
     20     pub fn publish_post_event_blocking(&self, content: String) -> Result<String> {
     21         let rt = self.inner.rt.clone();
     22         let this = self.clone();
     23         rt.block_on(async move { this.publish_post_event(content).await })
     24     }
     25 
     26     pub async fn publish_post_reply_event(
     27         &self,
     28         parent_event_id_hex: String,
     29         parent_author_hex: String,
     30         content: String,
     31         root_event_id_hex: Option<String>,
     32     ) -> Result<String> {
     33         let builder = radroots_nostr_build_post_reply_event(
     34             &parent_event_id_hex,
     35             &parent_author_hex,
     36             content,
     37             root_event_id_hex.as_deref(),
     38         )
     39         .map_err(|e| NetError::Msg(e.to_string()))?;
     40 
     41         let out = radroots_nostr_send_event(&self.inner.client, builder)
     42             .await
     43             .map_err(|e| NetError::Msg(e.to_string()))?;
     44 
     45         Ok(out.val.to_string())
     46     }
     47 
     48     pub fn publish_post_reply_event_blocking(
     49         &self,
     50         parent_event_id_hex: String,
     51         parent_author_hex: String,
     52         content: String,
     53         root_event_id_hex: Option<String>,
     54     ) -> Result<String> {
     55         let rt = self.inner.rt.clone();
     56         let this = self.clone();
     57         rt.block_on(async move {
     58             this.publish_post_reply_event(
     59                 parent_event_id_hex,
     60                 parent_author_hex,
     61                 content,
     62                 root_event_id_hex,
     63             )
     64             .await
     65         })
     66     }
     67 
     68     pub async fn fetch_post_events(
     69         &self,
     70         limit: u16,
     71         since_unix: Option<u64>,
     72     ) -> Result<Vec<RadrootsParsedData<RadrootsPost>>> {
     73         let items = radroots_nostr_fetch_post_events(&self.inner.client, limit, since_unix)
     74             .await
     75             .map_err(|e| NetError::Msg(e.to_string()))?;
     76         Ok(items)
     77     }
     78 
     79     pub fn fetch_post_events_blocking(
     80         &self,
     81         limit: u16,
     82         since_unix: Option<u64>,
     83     ) -> Result<Vec<RadrootsParsedData<RadrootsPost>>> {
     84         let rt = self.inner.rt.clone();
     85         let this = self.clone();
     86         rt.block_on(async move { this.fetch_post_events(limit, since_unix).await })
     87     }
     88 }