entertainarr-adapter-http 0.1.1

HTTP adapter for entertainarr
Documentation 
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use axum::routing::{delete, get, post};
use entertainarr_domain::podcast::entity::PodcastWithSubscription;

use crate::entity::podcast::{
    PodcastAttributes, PodcastDocument, PodcastRelation, PodcastRelationships,
};
use crate::entity::podcast_subscription::{PodcastSubscriptionEntity, PodcastSubscriptionMeta};
use crate::entity::{ApiResource, Couple, Relation};

pub mod find;
pub mod subscription;
pub mod task;
pub mod user_list;

pub fn create<S>() -> axum::Router<S>
where
    S: crate::server::prelude::ServerState + Clone,
{
    axum::Router::new()
        .route("/podcasts/{podcast_id}", get(find::handle::<S>))
        .route(
            "/users/me/podcasts",
            get(user_list::handle::<S>).post(subscription::create::handle::<S>),
        )
        .route(
            "/users/me/podcasts/{podcast_id}",
            delete(subscription::delete::handle::<S>).put(subscription::update::handle::<S>),
        )
        .route("/podcast-tasks", post(task::create::handle::<S>))
}

impl From<entertainarr_domain::podcast::entity::Podcast> for PodcastDocument {
    fn from(value: entertainarr_domain::podcast::entity::Podcast) -> Self {
        Self {
            id: value.id,
            kind: Default::default(),
            attributes: PodcastAttributes {
                title: value.title,
                description: value.description,
                image_url: value.image_url,
                language: value.language,
                feed_url: value.feed_url,
                website: value.website,
                created_at: value.created_at,
                updated_at: value.updated_at,
            },
            relationships: PodcastRelationships {
                subscription: Relation {
                    data: Some(PodcastSubscriptionEntity {
                        id: Couple(value.id, 0),
                        kind: Default::default(),
                    }),
                    meta: None,
                },
                synchronization: Relation {
                    data: None,
                    meta: (),
                },
            },
        }
    }
}

impl From<entertainarr_domain::podcast::entity::Podcast> for PodcastAttributes {
    fn from(value: entertainarr_domain::podcast::entity::Podcast) -> Self {
        PodcastAttributes {
            title: value.title,
            description: value.description,
            image_url: value.image_url,
            language: value.language,
            feed_url: value.feed_url,
            website: value.website,
            created_at: value.created_at,
            updated_at: value.updated_at,
        }
    }
}

impl From<entertainarr_domain::podcast::entity::PodcastWithSubscription> for PodcastDocument {
    fn from(value: entertainarr_domain::podcast::entity::PodcastWithSubscription) -> Self {
        let entertainarr_domain::podcast::entity::PodcastWithSubscription {
            podcast,
            queue_size,
        } = value;
        Self {
            id: podcast.id,
            kind: Default::default(),
            attributes: PodcastAttributes {
                title: podcast.title,
                description: podcast.description,
                image_url: podcast.image_url,
                language: podcast.language,
                feed_url: podcast.feed_url,
                website: podcast.website,
                created_at: podcast.created_at,
                updated_at: podcast.updated_at,
            },
            relationships: PodcastRelationships {
                subscription: Relation {
                    data: Some(PodcastSubscriptionEntity {
                        id: Couple(podcast.id, 0),
                        kind: Default::default(),
                    }),
                    meta: Some(PodcastSubscriptionMeta { queue_size }),
                },
                synchronization: Relation {
                    data: None,
                    meta: (),
                },
            },
        }
    }
}

impl ApiResource<Vec<PodcastDocument>, PodcastRelation> {
    pub fn from_subscription_list(list: Vec<PodcastWithSubscription>) -> Self {
        let mut data = Vec::with_capacity(list.len());
        list.into_iter().for_each(|item| {
            data.push(PodcastDocument::from(item));
        });
        Self {
            data,
            includes: Vec::new(),
        }
    }
}