Use a custom client for settings
[bloat] / service / auth.go
1 package service
2
3 import (
4         "context"
5         "errors"
6         "io"
7         "mastodon"
8         "mime/multipart"
9         "web/model"
10 )
11
12 var (
13         ErrInvalidSession = errors.New("invalid session")
14 )
15
16 type authService struct {
17         sessionRepo model.SessionRepository
18         appRepo     model.AppRepository
19         Service
20 }
21
22 func NewAuthService(sessionRepo model.SessionRepository, appRepo model.AppRepository, s Service) Service {
23         return &authService{sessionRepo, appRepo, s}
24 }
25
26 func getSessionID(ctx context.Context) (sessionID string, err error) {
27         sessionID, ok := ctx.Value("session_id").(string)
28         if !ok || len(sessionID) < 1 {
29                 return "", ErrInvalidSession
30         }
31         return sessionID, nil
32 }
33
34 func (s *authService) getClient(ctx context.Context) (c *model.Client, err error) {
35         sessionID, err := getSessionID(ctx)
36         if err != nil {
37                 return nil, ErrInvalidSession
38         }
39         session, err := s.sessionRepo.Get(sessionID)
40         if err != nil {
41                 return nil, ErrInvalidSession
42         }
43         client, err := s.appRepo.Get(session.InstanceDomain)
44         if err != nil {
45                 return
46         }
47         mc := mastodon.NewClient(&mastodon.Config{
48                 Server:       client.InstanceURL,
49                 ClientID:     client.ClientID,
50                 ClientSecret: client.ClientSecret,
51                 AccessToken:  session.AccessToken,
52         })
53         c = &model.Client{Client: mc}
54         return c, nil
55 }
56
57 func (s *authService) GetAuthUrl(ctx context.Context, instance string) (
58         redirectUrl string, sessionID string, err error) {
59         return s.Service.GetAuthUrl(ctx, instance)
60 }
61
62 func (s *authService) GetUserToken(ctx context.Context, sessionID string, c *model.Client,
63         code string) (token string, err error) {
64         sessionID, err = getSessionID(ctx)
65         if err != nil {
66                 return
67         }
68         c, err = s.getClient(ctx)
69         if err != nil {
70                 return
71         }
72
73         token, err = s.Service.GetUserToken(ctx, sessionID, c, code)
74         if err != nil {
75                 return
76         }
77
78         err = s.sessionRepo.Update(sessionID, token)
79         if err != nil {
80                 return
81         }
82
83         return
84 }
85
86 func (s *authService) ServeHomePage(ctx context.Context, client io.Writer) (err error) {
87         return s.Service.ServeHomePage(ctx, client)
88 }
89
90 func (s *authService) ServeErrorPage(ctx context.Context, client io.Writer, err error) {
91         s.Service.ServeErrorPage(ctx, client, err)
92 }
93
94 func (s *authService) ServeSigninPage(ctx context.Context, client io.Writer) (err error) {
95         return s.Service.ServeSigninPage(ctx, client)
96 }
97
98 func (s *authService) ServeTimelinePage(ctx context.Context, client io.Writer,
99         c *model.Client, maxID string, sinceID string, minID string) (err error) {
100         c, err = s.getClient(ctx)
101         if err != nil {
102                 return
103         }
104         return s.Service.ServeTimelinePage(ctx, client, c, maxID, sinceID, minID)
105 }
106
107 func (s *authService) ServeThreadPage(ctx context.Context, client io.Writer, c *model.Client, id string, reply bool) (err error) {
108         c, err = s.getClient(ctx)
109         if err != nil {
110                 return
111         }
112         return s.Service.ServeThreadPage(ctx, client, c, id, reply)
113 }
114
115 func (s *authService) ServeNotificationPage(ctx context.Context, client io.Writer, c *model.Client, maxID string, minID string) (err error) {
116         c, err = s.getClient(ctx)
117         if err != nil {
118                 return
119         }
120         return s.Service.ServeNotificationPage(ctx, client, c, maxID, minID)
121 }
122
123 func (s *authService) ServeUserPage(ctx context.Context, client io.Writer, c *model.Client, id string, maxID string, minID string) (err error) {
124         c, err = s.getClient(ctx)
125         if err != nil {
126                 return
127         }
128         return s.Service.ServeUserPage(ctx, client, c, id, maxID, minID)
129 }
130
131 func (s *authService) ServeAboutPage(ctx context.Context, client io.Writer, c *model.Client) (err error) {
132         c, err = s.getClient(ctx)
133         if err != nil {
134                 return
135         }
136         return s.Service.ServeAboutPage(ctx, client, c)
137 }
138
139 func (s *authService) Like(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
140         c, err = s.getClient(ctx)
141         if err != nil {
142                 return
143         }
144         return s.Service.Like(ctx, client, c, id)
145 }
146
147 func (s *authService) UnLike(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
148         c, err = s.getClient(ctx)
149         if err != nil {
150                 return
151         }
152         return s.Service.UnLike(ctx, client, c, id)
153 }
154
155 func (s *authService) Retweet(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
156         c, err = s.getClient(ctx)
157         if err != nil {
158                 return
159         }
160         return s.Service.Retweet(ctx, client, c, id)
161 }
162
163 func (s *authService) UnRetweet(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
164         c, err = s.getClient(ctx)
165         if err != nil {
166                 return
167         }
168         return s.Service.UnRetweet(ctx, client, c, id)
169 }
170
171 func (s *authService) PostTweet(ctx context.Context, client io.Writer, c *model.Client, content string, replyToID string, files []*multipart.FileHeader) (id string, err error) {
172         c, err = s.getClient(ctx)
173         if err != nil {
174                 return
175         }
176         return s.Service.PostTweet(ctx, client, c, content, replyToID, files)
177 }
178
179 func (s *authService) Follow(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
180         c, err = s.getClient(ctx)
181         if err != nil {
182                 return
183         }
184         return s.Service.Follow(ctx, client, c, id)
185 }
186
187 func (s *authService) UnFollow(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
188         c, err = s.getClient(ctx)
189         if err != nil {
190                 return
191         }
192         return s.Service.UnFollow(ctx, client, c, id)
193 }