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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
use sqlx::{Sqlite, SqliteConnection, Transaction};
use web_push::SubscriptionInfo;
use crate::{login::Login, token::Token};
pub trait Provider {
fn push(&mut self) -> Push<'_>;
}
impl Provider for Transaction<'_, Sqlite> {
fn push(&mut self) -> Push<'_> {
Push(self)
}
}
pub struct Push<'t>(&'t mut SqliteConnection);
impl Push<'_> {
pub async fn create(
&mut self,
token: &Token,
subscription: &SubscriptionInfo,
) -> Result<(), sqlx::Error> {
sqlx::query!(
r#"
insert into push_subscription (token, endpoint, p256dh, auth)
values ($1, $2, $3, $4)
"#,
token.id,
subscription.endpoint,
subscription.keys.p256dh,
subscription.keys.auth,
)
.execute(&mut *self.0)
.await?;
Ok(())
}
pub async fn by_login(&mut self, login: &Login) -> Result<Vec<SubscriptionInfo>, sqlx::Error> {
sqlx::query!(
r#"
select
subscription.endpoint,
subscription.p256dh,
subscription.auth
from push_subscription as subscription
join token on subscription.token = token.id
where token.login = $1
"#,
login.id,
)
.map(|row| SubscriptionInfo::new(row.endpoint, row.p256dh, row.auth))
.fetch_all(&mut *self.0)
.await
}
pub async fn by_endpoint(
&mut self,
subscriber: &Login,
endpoint: &str,
) -> Result<SubscriptionInfo, sqlx::Error> {
let row = sqlx::query!(
r#"
select
subscription.endpoint,
subscription.p256dh,
subscription.auth
from push_subscription as subscription
join token on subscription.token = token.id
join login as subscriber on token.login = subscriber.id
where subscriber.id = $1
and subscription.endpoint = $2
"#,
subscriber.id,
endpoint,
)
.fetch_one(&mut *self.0)
.await?;
let info = SubscriptionInfo::new(row.endpoint, row.p256dh, row.auth);
Ok(info)
}
pub async fn broadcast_from(
&mut self,
originator: &Login,
) -> Result<Vec<SubscriptionInfo>, sqlx::Error> {
sqlx::query!(
r#"
select
sub.endpoint,
sub.p256dh,
sub.auth
from push_subscription as sub
join token on sub.token = token.id
where token.login <> $1
"#,
originator.id,
)
.map(|row| SubscriptionInfo::new(row.endpoint, row.p256dh, row.auth))
.fetch_all(&mut *self.0)
.await
}
pub async fn unsubscribe(
&mut self,
subscription: &SubscriptionInfo,
) -> Result<(), sqlx::Error> {
sqlx::query!(
r#"
delete from push_subscription
where endpoint = $1
"#,
subscription.endpoint,
)
.execute(&mut *self.0)
.await?;
Ok(())
}
pub async fn unsubscribe_token(&mut self, token: &Token) -> Result<(), sqlx::Error> {
sqlx::query!(
r#"
delete from push_subscription
where token = $1
"#,
token.id,
)
.execute(&mut *self.0)
.await?;
Ok(())
}
pub async fn unsubscribe_login(&mut self, login: &Login) -> Result<(), sqlx::Error> {
sqlx::query!(
r#"
with tokens as (
select id from token
where login = $1
)
delete from push_subscription
where token in tokens
"#,
login.id,
)
.execute(&mut *self.0)
.await?;
Ok(())
}
// Unsubscribe logic for token expiry lives in the `tokens` repository, for maintenance reasons.
pub async fn clear(&mut self) -> Result<(), sqlx::Error> {
// We assume that _all_ stored subscriptions are for a VAPID key we're about to delete.
sqlx::query!(
r#"
delete from push_subscription
"#,
)
.execute(&mut *self.0)
.await?;
Ok(())
}
}
|
