Avoid search call for empty query
[bloat] / service / auth.go
1 package service
2
3 import (
4         "errors"
5         "mime/multipart"
6
7         "bloat/mastodon"
8         "bloat/model"
9 )
10
11 var (
12         errInvalidSession   = errors.New("invalid session")
13         errInvalidAccessToken = errors.New("invalid access token")
14         errInvalidCSRFToken = errors.New("invalid csrf token")
15 )
16
17 type as struct {
18         sessionRepo model.SessionRepo
19         appRepo     model.AppRepo
20         Service
21 }
22
23 func NewAuthService(sessionRepo model.SessionRepo, appRepo model.AppRepo, s Service) Service {
24         return &as{sessionRepo, appRepo, s}
25 }
26
27 func (s *as) initClient(c *model.Client) (err error) {
28         if len(c.Ctx.SessionID) < 1 {
29                 return errInvalidSession
30         }
31         session, err := s.sessionRepo.Get(c.Ctx.SessionID)
32         if err != nil {
33                 return errInvalidSession
34         }
35         app, err := s.appRepo.Get(session.InstanceDomain)
36         if err != nil {
37                 return
38         }
39         mc := mastodon.NewClient(&mastodon.Config{
40                 Server:       app.InstanceURL,
41                 ClientID:     app.ClientID,
42                 ClientSecret: app.ClientSecret,
43                 AccessToken:  session.AccessToken,
44         })
45         c.Client = mc
46         c.Session = session
47         return nil
48 }
49
50 func (s *as) authenticateClient(c *model.Client) (err error) {
51         err = s.initClient(c)
52         if err != nil {
53                 return
54         }
55         if len(c.Session.AccessToken) < 1 {
56                 return errInvalidAccessToken
57         }
58         return nil
59 }
60
61 func checkCSRF(c *model.Client) (err error) {
62         if c.Ctx.CSRFToken != c.Session.CSRFToken {
63                 return errInvalidCSRFToken
64         }
65         return nil
66 }
67
68 func (s *as) ServeErrorPage(c *model.Client, err error) {
69         s.authenticateClient(c)
70         s.Service.ServeErrorPage(c, err)
71 }
72
73 func (s *as) ServeSigninPage(c *model.Client) (err error) {
74         return s.Service.ServeSigninPage(c)
75 }
76
77 func (s *as) ServeRootPage(c *model.Client) (err error) {
78         err = s.authenticateClient(c)
79         if err != nil {
80                 return
81         }
82         return s.Service.ServeRootPage(c)
83 }
84
85 func (s *as) ServeNavPage(c *model.Client) (err error) {
86         err = s.authenticateClient(c)
87         if err != nil {
88                 return
89         }
90         return s.Service.ServeNavPage(c)
91 }
92
93 func (s *as) ServeTimelinePage(c *model.Client, tType string,
94         maxID string, minID string) (err error) {
95         err = s.authenticateClient(c)
96         if err != nil {
97                 return
98         }
99         return s.Service.ServeTimelinePage(c, tType, maxID, minID)
100 }
101
102 func (s *as) ServeThreadPage(c *model.Client, id string, reply bool) (err error) {
103         err = s.authenticateClient(c)
104         if err != nil {
105                 return
106         }
107         return s.Service.ServeThreadPage(c, id, reply)
108 }
109
110 func (s *as) ServeLikedByPage(c *model.Client, id string) (err error) {
111         err = s.authenticateClient(c)
112         if err != nil {
113                 return
114         }
115         return s.Service.ServeLikedByPage(c, id)
116 }
117
118 func (s *as) ServeRetweetedByPage(c *model.Client, id string) (err error) {
119         err = s.authenticateClient(c)
120         if err != nil {
121                 return
122         }
123         return s.Service.ServeRetweetedByPage(c, id)
124 }
125
126 func (s *as) ServeNotificationPage(c *model.Client,
127         maxID string, minID string) (err error) {
128         err = s.authenticateClient(c)
129         if err != nil {
130                 return
131         }
132         return s.Service.ServeNotificationPage(c, maxID, minID)
133 }
134
135 func (s *as) ServeUserPage(c *model.Client, id string,
136         pageType string, maxID string, minID string) (err error) {
137         err = s.authenticateClient(c)
138         if err != nil {
139                 return
140         }
141         return s.Service.ServeUserPage(c, id, pageType, maxID, minID)
142 }
143
144 func (s *as) ServeAboutPage(c *model.Client) (err error) {
145         err = s.authenticateClient(c)
146         if err != nil {
147                 return
148         }
149         return s.Service.ServeAboutPage(c)
150 }
151
152 func (s *as) ServeEmojiPage(c *model.Client) (err error) {
153         err = s.authenticateClient(c)
154         if err != nil {
155                 return
156         }
157         return s.Service.ServeEmojiPage(c)
158 }
159
160 func (s *as) ServeSearchPage(c *model.Client, q string,
161         qType string, offset int) (err error) {
162         err = s.authenticateClient(c)
163         if err != nil {
164                 return
165         }
166         return s.Service.ServeSearchPage(c, q, qType, offset)
167 }
168
169 func (s *as) ServeUserSearchPage(c *model.Client,
170         id string, q string, offset int) (err error) {
171         err = s.authenticateClient(c)
172         if err != nil {
173                 return
174         }
175         return s.Service.ServeUserSearchPage(c, id, q, offset)
176 }
177
178 func (s *as) ServeSettingsPage(c *model.Client) (err error) {
179         err = s.authenticateClient(c)
180         if err != nil {
181                 return
182         }
183         return s.Service.ServeSettingsPage(c)
184 }
185
186 func (s *as) NewSession(instance string) (redirectUrl string,
187         sessionID string, err error) {
188         return s.Service.NewSession(instance)
189 }
190
191 func (s *as) Signin(c *model.Client, sessionID string,
192         code string) (token string, userID string, err error) {
193         err = s.authenticateClient(c)
194         if err != nil && err != errInvalidAccessToken {
195                 return
196         }
197
198         token, userID, err = s.Service.Signin(c, c.Session.ID, code)
199         if err != nil {
200                 return
201         }
202
203         c.Session.AccessToken = token
204         c.Session.UserID = userID
205
206         err = s.sessionRepo.Add(c.Session)
207         if err != nil {
208                 return
209         }
210
211         return
212 }
213
214 func (s *as) Signout(c *model.Client) (err error) {
215         err = s.authenticateClient(c)
216         if err != nil {
217                 return
218         }
219         err = checkCSRF(c)
220         if err != nil {
221                 return
222         }
223         s.Service.Signout(c)
224         return
225 }
226
227 func (s *as) Post(c *model.Client, content string,
228         replyToID string, format string, visibility string, isNSFW bool,
229         files []*multipart.FileHeader) (id string, err error) {
230         err = s.authenticateClient(c)
231         if err != nil {
232                 return
233         }
234         err = checkCSRF(c)
235         if err != nil {
236                 return
237         }
238         return s.Service.Post(c, content, replyToID, format, visibility, isNSFW, files)
239 }
240
241 func (s *as) Like(c *model.Client, id string) (count int64, err error) {
242         err = s.authenticateClient(c)
243         if err != nil {
244                 return
245         }
246         err = checkCSRF(c)
247         if err != nil {
248                 return
249         }
250         return s.Service.Like(c, id)
251 }
252
253 func (s *as) UnLike(c *model.Client, id string) (count int64, err error) {
254         err = s.authenticateClient(c)
255         if err != nil {
256                 return
257         }
258         err = checkCSRF(c)
259         if err != nil {
260                 return
261         }
262         return s.Service.UnLike(c, id)
263 }
264
265 func (s *as) Retweet(c *model.Client, id string) (count int64, err error) {
266         err = s.authenticateClient(c)
267         if err != nil {
268                 return
269         }
270         err = checkCSRF(c)
271         if err != nil {
272                 return
273         }
274         return s.Service.Retweet(c, id)
275 }
276
277 func (s *as) UnRetweet(c *model.Client, id string) (count int64, err error) {
278         err = s.authenticateClient(c)
279         if err != nil {
280                 return
281         }
282         err = checkCSRF(c)
283         if err != nil {
284                 return
285         }
286         return s.Service.UnRetweet(c, id)
287 }
288
289 func (s *as) Vote(c *model.Client, id string,
290         choices []string) (err error) {
291         err = s.authenticateClient(c)
292         if err != nil {
293                 return
294         }
295         err = checkCSRF(c)
296         if err != nil {
297                 return
298         }
299         return s.Service.Vote(c, id, choices)
300 }
301
302 func (s *as) Follow(c *model.Client, id string, reblogs *bool) (err error) {
303         err = s.authenticateClient(c)
304         if err != nil {
305                 return
306         }
307         err = checkCSRF(c)
308         if err != nil {
309                 return
310         }
311         return s.Service.Follow(c, id, reblogs)
312 }
313
314 func (s *as) UnFollow(c *model.Client, id string) (err error) {
315         err = s.authenticateClient(c)
316         if err != nil {
317                 return
318         }
319         err = checkCSRF(c)
320         if err != nil {
321                 return
322         }
323         return s.Service.UnFollow(c, id)
324 }
325
326 func (s *as) Mute(c *model.Client, id string) (err error) {
327         err = s.authenticateClient(c)
328         if err != nil {
329                 return
330         }
331         err = checkCSRF(c)
332         if err != nil {
333                 return
334         }
335         return s.Service.Mute(c, id)
336 }
337
338 func (s *as) UnMute(c *model.Client, id string) (err error) {
339         err = s.authenticateClient(c)
340         if err != nil {
341                 return
342         }
343         err = checkCSRF(c)
344         if err != nil {
345                 return
346         }
347         return s.Service.UnMute(c, id)
348 }
349
350 func (s *as) Block(c *model.Client, id string) (err error) {
351         err = s.authenticateClient(c)
352         if err != nil {
353                 return
354         }
355         err = checkCSRF(c)
356         if err != nil {
357                 return
358         }
359         return s.Service.Block(c, id)
360 }
361
362 func (s *as) UnBlock(c *model.Client, id string) (err error) {
363         err = s.authenticateClient(c)
364         if err != nil {
365                 return
366         }
367         err = checkCSRF(c)
368         if err != nil {
369                 return
370         }
371         return s.Service.UnBlock(c, id)
372 }
373
374 func (s *as) Subscribe(c *model.Client, id string) (err error) {
375         err = s.authenticateClient(c)
376         if err != nil {
377                 return
378         }
379         err = checkCSRF(c)
380         if err != nil {
381                 return
382         }
383         return s.Service.Subscribe(c, id)
384 }
385
386 func (s *as) UnSubscribe(c *model.Client, id string) (err error) {
387         err = s.authenticateClient(c)
388         if err != nil {
389                 return
390         }
391         err = checkCSRF(c)
392         if err != nil {
393                 return
394         }
395         return s.Service.UnSubscribe(c, id)
396 }
397
398 func (s *as) SaveSettings(c *model.Client, settings *model.Settings) (err error) {
399         err = s.authenticateClient(c)
400         if err != nil {
401                 return
402         }
403         err = checkCSRF(c)
404         if err != nil {
405                 return
406         }
407         return s.Service.SaveSettings(c, settings)
408 }
409
410 func (s *as) MuteConversation(c *model.Client, id string) (err error) {
411         err = s.authenticateClient(c)
412         if err != nil {
413                 return
414         }
415         err = checkCSRF(c)
416         if err != nil {
417                 return
418         }
419         return s.Service.MuteConversation(c, id)
420 }
421
422 func (s *as) UnMuteConversation(c *model.Client, id string) (err error) {
423         err = s.authenticateClient(c)
424         if err != nil {
425                 return
426         }
427         err = checkCSRF(c)
428         if err != nil {
429                 return
430         }
431         return s.Service.UnMuteConversation(c, id)
432 }
433
434 func (s *as) Delete(c *model.Client, id string) (err error) {
435         err = s.authenticateClient(c)
436         if err != nil {
437                 return
438         }
439         err = checkCSRF(c)
440         if err != nil {
441                 return
442         }
443         return s.Service.Delete(c, id)
444 }
445
446 func (s *as) ReadNotifications(c *model.Client, maxID string) (err error) {
447         err = s.authenticateClient(c)
448         if err != nil {
449                 return
450         }
451         err = checkCSRF(c)
452         if err != nil {
453                 return
454         }
455         return s.Service.ReadNotifications(c, maxID)
456 }
457
458 func (s *as) Bookmark(c *model.Client, id string) (err error) {
459         err = s.authenticateClient(c)
460         if err != nil {
461                 return
462         }
463         err = checkCSRF(c)
464         if err != nil {
465                 return
466         }
467         return s.Service.Bookmark(c, id)
468 }
469
470 func (s *as) UnBookmark(c *model.Client, id string) (err error) {
471         err = s.authenticateClient(c)
472         if err != nil {
473                 return
474         }
475         err = checkCSRF(c)
476         if err != nil {
477                 return
478         }
479         return s.Service.UnBookmark(c, id)
480 }