research 0.1.22

Manage your reading lists and generate a static site with your saved articles.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use super::{Insertable, OnlineProvider, Provider, ResearchItem};
use crate::db::{Secrets, Tags};
use api::{add, favorite, get, login, PocketItem};
use chrono::Utc;

pub mod api;

#[derive(Debug, Default)]
pub struct ProviderPocket {
    pub consumer_key: String,
    pub access_token: Option<String>,
    pub client: reqwest::Client,
}

impl Provider for ProviderPocket {
    type Item = PocketItem;
}

impl OnlineProvider for ProviderPocket {
    async fn authenticate(&self) -> Result<Secrets, Box<dyn std::error::Error>> {
        let access_token = login(&self.client, &self.consumer_key).await?;
        Ok(Secrets {
            pocket_consumer_key: Some(self.consumer_key.clone()),
            pocket_access_token: Some(access_token),
            ..Default::default()
        })
    }

    async fn fetch_items(
        &self,
        limit: Option<usize>,
    ) -> Result<Vec<PocketItem>, Box<dyn std::error::Error>> {
        let access_token = self.access_token.as_ref().ok_or("Access token not found")?;
        get(access_token, &self.consumer_key, &self.client, limit).await
    }

    async fn add_item(
        &self,
        uri: &str,
        tags: Vec<&str>,
    ) -> Result<Option<i64>, Box<dyn std::error::Error>> {
        let access_token = self.access_token.as_ref().ok_or("Access token not found")?;
        let add_request = api::PocketAddRequest {
            url: uri,
            title: None,
            tags: Some(&tags),
        };
        let item_id = add(&self.client, access_token, &self.consumer_key, add_request).await?;
        Ok(Some(item_id))
    }

    async fn mark_as_favorite(
        &self,
        item_id: i64,
        mark: bool,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let access_token = self.access_token.as_ref().ok_or("Access token not found")?;
        favorite(
            &self.client,
            access_token,
            &self.consumer_key,
            item_id,
            mark,
        )
        .await?;
        Ok(())
    }
}

impl Insertable for PocketItem {
    fn to_research_item(&self) -> ResearchItem {
        let title = self
            .given_title
            .as_ref()
            .filter(|title| !title.is_empty())
            .or_else(|| {
                self.resolved_title
                    .as_ref()
                    .filter(|title| !title.is_empty())
            })
            .cloned()
            .unwrap_or_else(|| "Untitled".to_string());

        let uri = self
            .given_url
            .as_ref()
            .or(self.resolved_url.as_ref())
            .map_or("#".into(), |url| url.to_string());

        ResearchItem {
            id: Some(self.item_id as i64),
            uri,
            title,
            excerpt: self.excerpt.as_ref().map_or("".to_string(), |s| s.clone()),
            time_added: self.time_added.unwrap_or(Utc::now()).timestamp(),
            favorite: self.favorite.unwrap_or(false),
            lang: self.lang.clone(),
        }
    }

    fn to_tags(&self) -> Vec<Tags> {
        self.tags.as_ref().map_or(vec![], |tags| {
            tags.iter()
                .map(|tag| Tags {
                    tag_name: tag.tag.clone(),
                })
                .collect()
        })
    }
}