jmap_client/push_subscription/
helpers.rs

1/*
2 * Copyright Stalwart Labs LLC See the COPYING
3 * file at the top-level directory of this distribution.
4 *
5 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 * https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 * <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
8 * option. This file may not be copied, modified, or distributed
9 * except according to those terms.
10 */
11
12use crate::{
13    client::Client,
14    core::{
15        get::GetRequest,
16        request::{Arguments, Request},
17        response::{PushSubscriptionGetResponse, PushSubscriptionSetResponse},
18        set::{SetObject, SetRequest},
19    },
20    Method, Set, DataType,
21};
22
23use super::{Keys, PushSubscription};
24
25impl Client {
26    #[maybe_async::maybe_async]
27    pub async fn push_subscription_create(
28        &self,
29        device_client_id: impl Into<String>,
30        url: impl Into<String>,
31        keys: Option<Keys>,
32    ) -> crate::Result<PushSubscription> {
33        let mut request = self.build();
34        let create_req = request
35            .set_push_subscription()
36            .create()
37            .device_client_id(device_client_id)
38            .url(url);
39
40        if let Some(keys) = keys {
41            create_req.keys(keys);
42        }
43
44        let id = create_req.create_id().unwrap();
45        request
46            .send_single::<PushSubscriptionSetResponse>()
47            .await?
48            .created(&id)
49    }
50
51    #[maybe_async::maybe_async]
52    pub async fn push_subscription_verify(
53        &self,
54        id: &str,
55        verification_code: impl Into<String>,
56    ) -> crate::Result<Option<PushSubscription>> {
57        let mut request = self.build();
58        request
59            .set_push_subscription()
60            .update(id)
61            .verification_code(verification_code);
62        request
63            .send_single::<PushSubscriptionSetResponse>()
64            .await?
65            .updated(id)
66    }
67
68    #[maybe_async::maybe_async]
69    pub async fn push_subscription_update_types(
70        &self,
71        id: &str,
72        types: Option<impl IntoIterator<Item = DataType>>,
73    ) -> crate::Result<Option<PushSubscription>> {
74        let mut request = self.build();
75        request.set_push_subscription().update(id).types(types);
76        request
77            .send_single::<PushSubscriptionSetResponse>()
78            .await?
79            .updated(id)
80    }
81
82    #[maybe_async::maybe_async]
83    pub async fn push_subscription_destroy(&self, id: &str) -> crate::Result<()> {
84        let mut request = self.build();
85        request.set_push_subscription().destroy([id]);
86        request
87            .send_single::<PushSubscriptionSetResponse>()
88            .await?
89            .destroyed(id)
90    }
91}
92
93impl Request<'_> {
94    pub fn get_push_subscription(&mut self) -> &mut GetRequest<PushSubscription<Set>> {
95        self.add_method_call(
96            Method::GetPushSubscription,
97            Arguments::push_get(self.params(Method::GetPushSubscription)),
98        )
99        .push_get_mut()
100    }
101
102    #[maybe_async::maybe_async]
103    pub async fn send_get_push_subscription(self) -> crate::Result<PushSubscriptionGetResponse> {
104        self.send_single().await
105    }
106
107    pub fn set_push_subscription(&mut self) -> &mut SetRequest<PushSubscription<Set>> {
108        self.add_method_call(
109            Method::SetPushSubscription,
110            Arguments::push_set(self.params(Method::SetPushSubscription)),
111        )
112        .push_set_mut()
113    }
114
115    #[maybe_async::maybe_async]
116    pub async fn send_set_push_subscription(self) -> crate::Result<PushSubscriptionSetResponse> {
117        self.send_single().await
118    }
119}