55 |
66 | ))}
67 | {repoPath}
56 |-
57 | {data.PullRequests[repoPath].map((pr) => (
58 |
- 59 | 60 | #{pr.Number} {pr.Title} 61 | 62 | 63 | ))} 64 |
55 | 58 | 61 | # 62 | 2 63 | 64 | 65 | Release 2017-10-11 20:18:22 +0900 66 | 67 |
68 |
72 |
293 | -
73 |
-
74 | 77 | 83 |84 |87 | 90 | # 91 | 1 92 | 93 |94 | 95 |99 | feature-1 100 |101 | 102 |105 | @ 106 | motemen 107 |108 | 109 |112 | 115 |121 |
119 | 120 |
122 | -
123 | 126 | 132 |133 |136 | 139 | # 140 | 3 141 | 142 |143 | 144 |148 | foo bar baz foo foo foo foo foo foo foof foohof ofhfof 149 |150 | 151 |154 | @ 155 | motemen 156 |157 | 158 | 161 |
162 |
-
163 | 166 | 172 |173 |176 | 179 | # 180 | 4 181 | 182 |183 | 184 |188 | 1403357307 189 |190 | 191 |194 | @ 195 | motemen 196 |197 | 198 |201 | 204 |210 |
211 |
-
212 | 215 | 221 |222 |225 | 228 | # 229 | 7 230 | 231 |232 | 233 |237 | feature-y 238 |239 | 240 |243 | @ 244 | werckerbot 245 |246 | 247 | 250 |
251 |
-
252 | 255 | 261 |262 |265 | 268 | # 269 | 33 270 | 271 |272 | 273 |277 | mk-feature 278 |279 | 280 |283 | @ 284 | motemen 285 |286 | 287 | 290 |
291 |
294 | Blah blah blah 295 | - [ ] #1 feature-1 @motemen 296 | - [ ] #3 foo bar baz foo foo foo foo foo foo foof foohof ofhfof @motemen 297 | - [ ] #33 mk-feature @motemen 298 | - [ ] #4 1403357307 @motemen 299 | - [ ] #7 feature-y @motemen 300 |301 |
{this.state.error}
58 | 98 | 99 | #{checklist.Number} {checklist.Title} 100 | 101 |
102 |
103 |
141 | -
104 | {checklist.Items.map((item) => {
105 | return (
106 |
-
107 | 108 | 116 |117 |118 | #{item.Number} 119 |{" "} 120 |121 | {item.Title} 122 |{" "} 123 |@{item.User.Login}{" "} 124 |125 | {item.CheckedBy.map((user) => { 126 | return ( 127 | 131 |136 |
132 | 133 | ); 134 | })} 135 |
137 | );
138 | })}
139 |
{checklist.Body}
142 |
53 |
54 |
55 |
56 |
57 |
58 |
59 | `
60 |
61 | func init() {
62 | flag.StringVar(&sessionSecret, "session-secret", sessionSecret, "session secret (PRCHECKLIST_SESSION_SECRET)")
63 | flag.BoolVar(&behindProxy, "behind-proxy", behindProxy, "prchecklist is behind a reverse proxy (PRCHECKLIST_BEHIND_PROXY)")
64 |
65 | gob.Register(&prchecklist.GitHubUser{})
66 | }
67 |
68 | // GitHubGateway is an interface that makes API calls to GitHub (Enterprise).
69 | // Used for OAuth interaction.
70 | type GitHubGateway interface {
71 | AuthCodeURL(state string, redirectURI *url.URL) string
72 | AuthenticateUser(ctx context.Context, code string) (*prchecklist.GitHubUser, error)
73 | GetUserFromToken(ctx context.Context, token *oauth2.Token) (*prchecklist.GitHubUser, error)
74 | }
75 |
76 | // Web is a web server implementation.
77 | type Web struct {
78 | app *usecase.Usecase
79 | github GitHubGateway
80 | sessionStore sessions.Store
81 | oauthForwarder oauthforwarder.Forwarder
82 | }
83 |
84 | // New creates a new Web.
85 | func New(app *usecase.Usecase, github GitHubGateway) *Web {
86 | cookieStore := sessions.NewCookieStore([]byte(sessionSecret))
87 | cookieStore.Options = &sessions.Options{
88 | Path: "/",
89 | MaxAge: int(30 * 24 * time.Hour / time.Second),
90 | HttpOnly: true,
91 | }
92 |
93 | // TODO: write doc about it
94 | // TODO be a flag variable
95 | oauthCallbackOrigin := os.Getenv("PRCHECKLIST_OAUTH_CALLBACK_ORIGIN")
96 | if oauthCallbackOrigin == "" {
97 | // deprecated
98 | oauthCallbackOrigin = "https://" + os.Getenv("PRCHECKLIST_OAUTH_CALLBACK_HOST")
99 | }
100 | u, _ := url.Parse(oauthCallbackOrigin + "/auth/callback/forward")
101 | forwarder := oauthforwarder.Forwarder{
102 | CallbackURL: u,
103 | Secret: []byte(sessionSecret),
104 | }
105 |
106 | return &Web{
107 | app: app,
108 | github: github,
109 | sessionStore: cookieStore,
110 | oauthForwarder: forwarder,
111 | }
112 | }
113 |
114 | // Handler is the main logic of Web.
115 | func (web *Web) Handler() http.Handler {
116 | router := mux.NewRouter()
117 | router.Handle("/", httpHandler(web.handleIndex))
118 | router.Handle("/auth", httpHandler(web.handleAuth))
119 | router.Handle("/auth/callback", httpHandler(web.handleAuthCallback))
120 | router.Handle("/auth/clear", httpHandler(web.handleAuthClear))
121 | router.Handle("/api/me", httpHandler(web.handleAPIMe))
122 | router.Handle("/api/checklist", httpHandler(web.handleAPIChecklist))
123 | router.Handle("/api/check", httpHandler(web.handleAPICheck)).Methods("PUT", "DELETE")
124 | router.Handle("/{owner}/{repo}/pull/{number}", httpHandler(web.handleChecklist))
125 | router.Handle("/{owner}/{repo}/pull/{number}/{stage}", httpHandler(web.handleChecklist))
126 | router.PathPrefix("/js/").Handler(http.FileServer(&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, AssetInfo: AssetInfo}))
127 |
128 | if testToken := os.Getenv("PRCHECKLIST_TEST_GITHUB_TOKEN"); testToken != "" {
129 | router.Handle("/debug/auth-for-testing", web.mkHandlerDebugAuthTesting(testToken))
130 | }
131 |
132 | handler := http.Handler(router)
133 |
134 | if behindProxy {
135 | handler = handlers.ProxyHeaders(handler)
136 | }
137 |
138 | return web.oauthForwarder.Wrap(handler)
139 | }
140 |
141 | type httpError int
142 |
143 | func (he httpError) Error() string {
144 | return http.StatusText(int(he))
145 | }
146 |
147 | type httpHandler func(w http.ResponseWriter, req *http.Request) error
148 |
149 | func (h httpHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
150 | err := h(w, req)
151 | if err != nil {
152 | log.Printf("ServeHTTP: %s (%+v)", err, err)
153 |
154 | status := http.StatusInternalServerError
155 | if he, ok := err.(httpError); ok {
156 | status = int(he)
157 | }
158 |
159 | http.Error(w, fmt.Sprintf("%+v", err), status)
160 | }
161 | }
162 |
163 | func renderJSON(w http.ResponseWriter, v interface{}) error {
164 | b, err := json.Marshal(v)
165 | if err != nil {
166 | return err
167 | }
168 |
169 | w.Header().Add("Content-Type", "application/json")
170 | w.Write(b)
171 | return nil
172 | }
173 |
174 | func (web *Web) handleAuth(w http.ResponseWriter, req *http.Request) error {
175 | sess, _ := web.sessionStore.Get(req, sessionName)
176 |
177 | state, err := makeRandomString()
178 | if err != nil {
179 | return err
180 | }
181 |
182 | sess.Values[sessionKeyOAuthState] = state
183 | err = web.sessionStore.Save(req, w, sess)
184 | if err != nil {
185 | return err
186 | }
187 |
188 | ctx := prchecklist.RequestContext(req)
189 |
190 | callback := prchecklist.BuildURL(ctx, "/auth/callback")
191 |
192 | if returnTo := req.URL.Query().Get("return_to"); returnTo != "" {
193 | callback.RawQuery = url.Values{"return_to": {returnTo}}.Encode()
194 | }
195 |
196 | // XXX Special and ad-hoc implementation for review apps
197 | if web.oauthForwarder.CallbackURL.Host != "" && web.oauthForwarder.CallbackURL.Host != callback.Host {
198 | callback = web.oauthForwarder.CreateURL(callback.String())
199 | }
200 |
201 | authURL := web.github.AuthCodeURL(state, callback)
202 |
203 | http.Redirect(w, req, authURL, http.StatusFound)
204 |
205 | return nil
206 | }
207 |
208 | func makeRandomString() (string, error) {
209 | buf := make([]byte, 16)
210 | _, err := rand.Read(buf)
211 | if err != nil {
212 | return "", err
213 | }
214 | return base64.RawURLEncoding.EncodeToString(buf), nil
215 | }
216 |
217 | func (web *Web) handleIndex(w http.ResponseWriter, req *http.Request) error {
218 | fmt.Fprint(w, htmlContent)
219 | return nil
220 | }
221 |
222 | func (web *Web) mkHandlerDebugAuthTesting(testToken string) httpHandler {
223 | return func(w http.ResponseWriter, req *http.Request) error {
224 | ctx := prchecklist.RequestContext(req)
225 | user, err := web.github.GetUserFromToken(ctx, &oauth2.Token{
226 | AccessToken: testToken,
227 | })
228 | if err != nil {
229 | return err
230 | }
231 |
232 | sess, err := web.sessionStore.Get(req, sessionName)
233 | if err != nil {
234 | return errors.Wrapf(err, "sessionStore.Get")
235 | }
236 |
237 | sess.Values[sessionKeyGitHubUser] = *user
238 |
239 | err = web.app.AddUser(ctx, *user)
240 | if err != nil {
241 | return err
242 | }
243 |
244 | err = sess.Save(req, w)
245 | if err != nil {
246 | return err
247 | }
248 |
249 | fmt.Fprintln(w, "OK")
250 | return nil
251 | }
252 | }
253 |
254 | func (web *Web) handleAuthCallback(w http.ResponseWriter, req *http.Request) error {
255 | sess, err := web.sessionStore.Get(req, sessionName)
256 | if err != nil {
257 | return errors.Wrapf(err, "sessionStore.Get")
258 | }
259 |
260 | state := req.URL.Query().Get("state")
261 | log.Printf("%#v", sess.Values)
262 | if state != sess.Values[sessionKeyOAuthState] {
263 | log.Printf("%v != %v", state, sess.Values[sessionKeyOAuthState])
264 | return httpError(http.StatusBadRequest)
265 | }
266 |
267 | delete(sess.Values, sessionKeyOAuthState)
268 |
269 | ctx := prchecklist.RequestContext(req)
270 |
271 | code := req.URL.Query().Get("code")
272 | user, err := web.github.AuthenticateUser(ctx, code)
273 | if err != nil {
274 | return err
275 | }
276 |
277 | sess.Values[sessionKeyGitHubUser] = *user
278 |
279 | err = web.app.AddUser(ctx, *user)
280 | if err != nil {
281 | return err
282 | }
283 |
284 | err = sess.Save(req, w)
285 | if err != nil {
286 | return err
287 | }
288 |
289 | returnTo := req.URL.Query().Get("return_to")
290 | if !strings.HasPrefix(returnTo, "/") {
291 | returnTo = "/"
292 | }
293 |
294 | http.Redirect(w, req, returnTo, http.StatusFound)
295 |
296 | return nil
297 | }
298 |
299 | func (web *Web) handleAuthClear(w http.ResponseWriter, req *http.Request) error {
300 | http.SetCookie(w, &http.Cookie{
301 | Name: sessionName,
302 | Path: "/",
303 | Expires: time.Now().Add(-1 * time.Hour),
304 | })
305 |
306 | http.Redirect(w, req, "/", http.StatusFound)
307 |
308 | return nil
309 | }
310 |
311 | func (web *Web) getAuthInfo(w http.ResponseWriter, req *http.Request) (*prchecklist.GitHubUser, error) {
312 | sess, err := web.sessionStore.Get(req, sessionName)
313 | if err != nil {
314 | // FIXME
315 | // return nil, err
316 | return nil, nil
317 | }
318 |
319 | v, ok := sess.Values[sessionKeyGitHubUser]
320 | if !ok {
321 | return nil, nil
322 | }
323 |
324 | user, ok := v.(*prchecklist.GitHubUser)
325 | if !ok || user.Token == nil {
326 | delete(sess.Values, sessionKeyGitHubUser)
327 | return nil, sess.Save(req, w)
328 | }
329 |
330 | return user, nil
331 | }
332 |
333 | func (web *Web) handleAPIMe(w http.ResponseWriter, req *http.Request) error {
334 | u, _ := web.getAuthInfo(w, req)
335 | result := prchecklist.MeResponse{Me: u}
336 | if u != nil {
337 | ctx := prchecklist.RequestContext(req)
338 | ctx = context.WithValue(ctx, prchecklist.ContextKeyHTTPClient, u.HTTPClient(ctx))
339 | var err error
340 | result.PullRequests, err = web.app.GetRecentPullRequests(ctx)
341 | if err != nil {
342 | return err
343 | }
344 | }
345 |
346 | return renderJSON(w, &result)
347 | }
348 |
349 | func (web *Web) handleAPIChecklist(w http.ResponseWriter, req *http.Request) error {
350 | u, err := web.getAuthInfo(w, req)
351 | if err != nil {
352 | return err
353 | }
354 | if u == nil {
355 | w.WriteHeader(http.StatusForbidden)
356 | return renderJSON(w, &prchecklist.ErrorResponse{
357 | Type: prchecklist.ErrorTypeNotAuthed,
358 | })
359 | }
360 |
361 | type inQuery struct {
362 | Owner string
363 | Repo string
364 | Number int
365 | Stage string
366 | }
367 |
368 | var in inQuery
369 | err = schema.NewDecoder().Decode(&in, req.URL.Query())
370 | if err != nil {
371 | return err
372 | }
373 | if in.Stage == "" {
374 | in.Stage = "default"
375 | }
376 |
377 | ctx := prchecklist.RequestContext(req)
378 | ctx = context.WithValue(ctx, prchecklist.ContextKeyHTTPClient, u.HTTPClient(ctx))
379 |
380 | cl, err := web.app.GetChecklist(ctx, prchecklist.ChecklistRef{
381 | Owner: in.Owner,
382 | Repo: in.Repo,
383 | Number: in.Number,
384 | Stage: in.Stage,
385 | })
386 | if err != nil {
387 | return err
388 | }
389 |
390 | return renderJSON(w, &prchecklist.ChecklistResponse{
391 | Checklist: cl,
392 | Me: u,
393 | })
394 | }
395 |
396 | func (web *Web) handleAPICheck(w http.ResponseWriter, req *http.Request) error {
397 | u, err := web.getAuthInfo(w, req)
398 | if err != nil {
399 | return err
400 | }
401 | if u == nil {
402 | return httpError(http.StatusForbidden)
403 | }
404 |
405 | type inQuery struct {
406 | Owner string
407 | Repo string
408 | Number int
409 | Stage string
410 | FeatureNumber int
411 | }
412 |
413 | if err := req.ParseForm(); err != nil {
414 | return err
415 | }
416 |
417 | var in inQuery
418 | err = schema.NewDecoder().Decode(&in, req.Form)
419 | if err != nil {
420 | return err
421 | }
422 | if in.Stage == "" {
423 | in.Stage = "default"
424 | }
425 |
426 | clRef := prchecklist.ChecklistRef{
427 | Owner: in.Owner,
428 | Repo: in.Repo,
429 | Number: in.Number,
430 | Stage: in.Stage,
431 | }
432 | ctx := prchecklist.RequestContext(req)
433 | ctx = context.WithValue(ctx, prchecklist.ContextKeyHTTPClient, u.HTTPClient(ctx))
434 |
435 | log.Printf("handleAPICheck: %s %+v", req.Method, in)
436 |
437 | switch req.Method {
438 | case "PUT":
439 | checklist, err := web.app.AddCheck(ctx, clRef, in.FeatureNumber, *u)
440 | if err != nil {
441 | return err
442 | }
443 | return renderJSON(w, &prchecklist.ChecklistResponse{
444 | Checklist: checklist,
445 | Me: u,
446 | })
447 |
448 | case "DELETE":
449 | checklist, err := web.app.RemoveCheck(ctx, clRef, in.FeatureNumber, *u)
450 | if err != nil {
451 | return err
452 | }
453 | return renderJSON(w, &prchecklist.ChecklistResponse{
454 | Checklist: checklist,
455 | Me: u,
456 | })
457 |
458 | default:
459 | return httpError(http.StatusMethodNotAllowed)
460 | }
461 | }
462 |
463 | func (web *Web) handleChecklist(w http.ResponseWriter, req *http.Request) error {
464 | // handle logged-out state earlier than APIs called
465 | u, _ := web.getAuthInfo(w, req)
466 | if u == nil {
467 | http.Redirect(w, req, "/auth?"+url.Values{"return_to": {req.URL.Path}}.Encode(), http.StatusFound)
468 | return nil
469 | }
470 |
471 | fmt.Fprint(w, htmlContent)
472 | return nil
473 | }
474 |
--------------------------------------------------------------------------------
/lib/gateway/github.go:
--------------------------------------------------------------------------------
1 | package gateway
2 |
3 | import (
4 | "bytes"
5 | "context"
6 | "encoding/base64"
7 | "encoding/json"
8 | "flag"
9 | "fmt"
10 | "net/http"
11 | "net/url"
12 | "os"
13 | "time"
14 |
15 | "github.com/google/go-github/v31/github"
16 | graphqlquery "github.com/motemen/go-graphql-query"
17 | "github.com/patrickmn/go-cache"
18 | "github.com/pkg/errors"
19 | "golang.org/x/oauth2"
20 |
21 | "github.com/motemen/prchecklist/v2"
22 | )
23 |
24 | const (
25 | cacheDurationPullReqBase = 30 * time.Second
26 | cacheDurationPullReqFeat = 5 * time.Minute
27 | cacheDurationBlob = cache.NoExpiration
28 | )
29 |
30 | var (
31 | githubClientID string
32 | githubClientSecret string
33 | githubDomain string
34 | )
35 |
36 | func getenv(key, def string) string {
37 | v := os.Getenv(key)
38 | if v == "" {
39 | return def
40 | }
41 | return v
42 | }
43 |
44 | func init() {
45 | flag.StringVar(&githubClientID, "github-client-id", os.Getenv("GITHUB_CLIENT_ID"), "GitHub client ID (GITHUB_CLIENT_ID)")
46 | flag.StringVar(&githubClientSecret, "github-client-secret", os.Getenv("GITHUB_CLIENT_SECRET"), "GitHub client secret (GITHUB_CLIENT_SECRET)")
47 | flag.StringVar(&githubDomain, "github-domain", getenv("GITHUB_DOMAIN", "github.com"), "GitHub domain (GITHUB_DOMAIN)")
48 | }
49 |
50 | // NewGitHub creates a new GitHub gateway.
51 | func NewGitHub() (*githubGateway, error) {
52 | if (githubClientID == "" || githubClientSecret == "") && os.Getenv("PRCHECKLIST_TEST_GITHUB_TOKEN") == "" {
53 | return nil, errors.New("gateway/github: both GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET must be set")
54 | }
55 |
56 | var githubEndpoint = oauth2.Endpoint{
57 | AuthURL: "https://" + githubDomain + "/login/oauth/authorize",
58 | TokenURL: "https://" + githubDomain + "/login/oauth/access_token",
59 | }
60 |
61 | return &githubGateway{
62 | cache: cache.New(30*time.Second, 10*time.Minute),
63 | oauth2Config: &oauth2.Config{
64 | ClientID: githubClientID,
65 | ClientSecret: githubClientSecret,
66 | Endpoint: githubEndpoint,
67 | Scopes: []string{"repo"},
68 | },
69 | domain: githubDomain,
70 | }, nil
71 | }
72 |
73 | type githubGateway struct {
74 | cache *cache.Cache
75 | oauth2Config *oauth2.Config
76 | domain string
77 | }
78 |
79 | type githubPullRequest struct {
80 | GraphQLArguments struct {
81 | IsBase bool `graphql:"$isBase,notnull"`
82 | }
83 | Repository *struct {
84 | GraphQLArguments struct {
85 | Owner string `graphql:"$owner,notnull"`
86 | Name string `graphql:"$repo,notnull"`
87 | }
88 | IsPrivate bool
89 | PullRequest struct {
90 | GraphQLArguments struct {
91 | Number int `graphql:"$number,notnull"`
92 | }
93 | Title string
94 | Number int
95 | Body string
96 | URL string
97 | Author struct {
98 | Login string
99 | }
100 | Assignees struct {
101 | Edges []struct {
102 | Node struct {
103 | Login string
104 | }
105 | }
106 | } `graphql:"(first: 1)"`
107 | BaseRef struct {
108 | Name string
109 | }
110 | HeadRef struct {
111 | Target struct {
112 | Tree struct {
113 | Entries []struct {
114 | Name string
115 | Oid string
116 | Type string
117 | }
118 | } `graphql:"... on Commit"`
119 | }
120 | } `graphql:"@include(if: $isBase)"`
121 | Commits struct {
122 | GraphQLArguments struct {
123 | First int `graphql:"100"`
124 | After string `graphql:"$commitsAfter"`
125 | }
126 | Edges []struct {
127 | Node struct {
128 | Commit struct {
129 | Message string
130 | Oid string
131 | }
132 | }
133 | }
134 | PageInfo struct {
135 | HasNextPage bool
136 | EndCursor string
137 | }
138 | TotalCount int
139 | } `graphql:"@include(if: $isBase)"`
140 | }
141 | }
142 | }
143 |
144 | type githubRecentPullRequests struct {
145 | Viewer struct {
146 | Repositories struct {
147 | Edges []struct {
148 | Node struct {
149 | NameWithOwner string
150 | PullRequests struct {
151 | Edges []struct {
152 | Node struct {
153 | Title string
154 | Number int
155 | URL string
156 | }
157 | }
158 | } `graphql:"(first: 5, orderBy: {field: UPDATED_AT, direction: DESC}, baseRefName: \"master\")"`
159 | }
160 | }
161 | } `graphql:"(first: 10, orderBy: {field: PUSHED_AT, direction: DESC}, affiliations: [OWNER, ORGANIZATION_MEMBER, COLLABORATOR])"`
162 | }
163 | }
164 |
165 | type githubPullRequsetVars struct {
166 | Owner string `json:"owner"`
167 | Repo string `json:"repo"`
168 | Number int `json:"number"`
169 | IsBase bool `json:"isBase"`
170 | CommitsAfter string `json:"commitsAfter,omitempty"`
171 | }
172 |
173 | type graphQLResult struct {
174 | Data interface{}
175 | Errors []struct {
176 | Message string
177 | }
178 | }
179 |
180 | var (
181 | pullRequestQuery string
182 | recentPullRequestsQuery string
183 | )
184 |
185 | func mustBuildGraphQLQuery(q interface{}) []byte {
186 | b, err := graphqlquery.Build(q)
187 | if err != nil {
188 | panic(err)
189 | }
190 |
191 | return b
192 | }
193 |
194 | func init() {
195 | pullRequestQuery = string(mustBuildGraphQLQuery(&githubPullRequest{}))
196 | recentPullRequestsQuery = string(mustBuildGraphQLQuery(&githubRecentPullRequests{}))
197 | }
198 |
199 | func (g githubGateway) GetBlob(ctx context.Context, ref prchecklist.ChecklistRef, sha string) ([]byte, error) {
200 | cacheKey := fmt.Sprintf("blob\000%s\000%s", ref.String(), sha)
201 |
202 | if data, ok := g.cache.Get(cacheKey); ok {
203 | if blob, ok := data.([]byte); ok {
204 | return blob, nil
205 | }
206 | }
207 |
208 | blob, err := g.getBlob(ctx, ref, sha)
209 | if err != nil {
210 | return nil, err
211 | }
212 |
213 | g.cache.Set(cacheKey, blob, cacheDurationBlob)
214 |
215 | return blob, nil
216 | }
217 |
218 | func (g githubGateway) getBlob(ctx context.Context, ref prchecklist.ChecklistRef, sha string) ([]byte, error) {
219 | gh, err := g.newGitHubClient(prchecklist.ContextClient(ctx))
220 | if err != nil {
221 | return nil, err
222 | }
223 |
224 | blob, _, err := gh.Git.GetBlob(ctx, ref.Owner, ref.Repo, sha)
225 | if err != nil {
226 | return nil, err
227 | }
228 |
229 | content := blob.GetContent()
230 | if enc := blob.GetEncoding(); enc != "base64" {
231 | return nil, errors.Errorf("unknown encoding: %q", enc)
232 | }
233 |
234 | buf, err := base64.StdEncoding.DecodeString(content)
235 | return buf, errors.Wrap(err, "base64")
236 | }
237 |
238 | var contextKeyRepoAccessRight = &struct{ key string }{"repoRight"}
239 |
240 | type repoRight struct {
241 | owner string
242 | repo string
243 | }
244 |
245 | func contextHasRepoAccessRight(ctx context.Context, ref prchecklist.ChecklistRef) bool {
246 | if g, ok := ctx.Value(contextKeyRepoAccessRight).(repoRight); ok {
247 | return g.owner == ref.Owner && g.repo == ref.Repo
248 | }
249 | return false
250 | }
251 |
252 | func contextWithRepoAccessRight(ctx context.Context, ref prchecklist.ChecklistRef) context.Context {
253 | return context.WithValue(ctx, contextKeyRepoAccessRight, repoRight{owner: ref.Owner, repo: ref.Repo})
254 | }
255 |
256 | func (g githubGateway) GetPullRequest(ctx context.Context, ref prchecklist.ChecklistRef, isBase bool) (*prchecklist.PullRequest, context.Context, error) {
257 | cacheKey := fmt.Sprintf("pullRequest\000%s\000%v", ref.String(), isBase)
258 |
259 | if data, ok := g.cache.Get(cacheKey); ok {
260 | if pullReq, ok := data.(*prchecklist.PullRequest); ok {
261 | if pullReq.IsPrivate && !contextHasRepoAccessRight(ctx, ref) {
262 | // something's wrong!
263 | } else {
264 | return pullReq, ctx, nil
265 | }
266 | }
267 | }
268 |
269 | pullReq, err := g.getPullRequest(ctx, ref, isBase)
270 | if err != nil {
271 | return nil, ctx, err
272 | }
273 | if isBase && pullReq.IsPrivate {
274 | // Do not cache result if the pull request is private
275 | // and isBase is true to check if the visitor has rights to
276 | // read the repo.
277 | // If isBase is false, we don't need to check vititor's rights
278 | // because GetPullRequest() with truthy isBase must be called before falsy one.
279 | return pullReq, contextWithRepoAccessRight(ctx, ref), nil
280 | }
281 |
282 | var cacheDuration time.Duration
283 | if isBase {
284 | cacheDuration = cacheDurationPullReqBase
285 | } else {
286 | cacheDuration = cacheDurationPullReqFeat
287 | }
288 |
289 | g.cache.Set(cacheKey, pullReq, cacheDuration)
290 |
291 | return pullReq, contextWithRepoAccessRight(ctx, ref), nil
292 | }
293 |
294 | func (g githubGateway) GetRecentPullRequests(ctx context.Context) (map[string][]*prchecklist.PullRequest, error) {
295 | var result githubRecentPullRequests
296 | err := g.queryGraphQL(ctx, recentPullRequestsQuery, nil, &result)
297 | if err != nil {
298 | return nil, err
299 | }
300 |
301 | pullRequests := map[string][]*prchecklist.PullRequest{}
302 | for _, edge := range result.Viewer.Repositories.Edges {
303 | repo := edge.Node
304 | if len(repo.PullRequests.Edges) == 0 {
305 | continue
306 | }
307 | pullRequests[repo.NameWithOwner] = make([]*prchecklist.PullRequest, len(repo.PullRequests.Edges))
308 | for i, edge := range repo.PullRequests.Edges {
309 | pullReq := edge.Node
310 | pullRequests[repo.NameWithOwner][i] = &prchecklist.PullRequest{
311 | Title: pullReq.Title,
312 | URL: pullReq.URL,
313 | Number: pullReq.Number,
314 | }
315 | }
316 | }
317 |
318 | return pullRequests, nil
319 | }
320 |
321 | func (g githubGateway) getPullRequest(ctx context.Context, ref prchecklist.ChecklistRef, isBase bool) (*prchecklist.PullRequest, error) {
322 | var qr githubPullRequest
323 | err := g.queryGraphQL(ctx, pullRequestQuery, githubPullRequsetVars{
324 | Owner: ref.Owner,
325 | Repo: ref.Repo,
326 | Number: ref.Number,
327 | IsBase: isBase,
328 | }, &qr)
329 | if err != nil {
330 | return nil, err
331 | }
332 | if qr.Repository == nil {
333 | return nil, errors.Errorf("could not retrieve repo/pullreq")
334 | }
335 |
336 | graphqlResultToCommits := func(qr githubPullRequest) []prchecklist.Commit {
337 | commits := make([]prchecklist.Commit, len(qr.Repository.PullRequest.Commits.Edges))
338 | for i, e := range qr.Repository.PullRequest.Commits.Edges {
339 | commits[i] = prchecklist.Commit{Message: e.Node.Commit.Message, Oid: e.Node.Commit.Oid}
340 | }
341 | return commits
342 | }
343 |
344 | pullReq := &prchecklist.PullRequest{
345 | URL: qr.Repository.PullRequest.URL,
346 | Title: qr.Repository.PullRequest.Title,
347 | Body: qr.Repository.PullRequest.Body,
348 | IsPrivate: qr.Repository.IsPrivate,
349 | Owner: ref.Owner,
350 | Repo: ref.Repo,
351 | Number: ref.Number,
352 | Commits: graphqlResultToCommits(qr),
353 | User: prchecklist.GitHubUserSimple{
354 | Login: qr.Repository.PullRequest.Author.Login,
355 | },
356 | }
357 |
358 | // prefer assignee
359 | if len(qr.Repository.PullRequest.Assignees.Edges) > 0 {
360 | pullReq.User.Login = qr.Repository.PullRequest.Assignees.Edges[0].Node.Login
361 | }
362 |
363 | for _, e := range qr.Repository.PullRequest.HeadRef.Target.Tree.Entries {
364 | if e.Name == "prchecklist.yml" && e.Type == "blob" {
365 | pullReq.ConfigBlobID = e.Oid
366 | break
367 | }
368 | }
369 |
370 | for {
371 | pageInfo := qr.Repository.PullRequest.Commits.PageInfo
372 | if !pageInfo.HasNextPage {
373 | break
374 | }
375 |
376 | err := g.queryGraphQL(ctx, pullRequestQuery, githubPullRequsetVars{
377 | Owner: ref.Owner,
378 | Repo: ref.Repo,
379 | Number: ref.Number,
380 | IsBase: isBase,
381 | CommitsAfter: pageInfo.EndCursor,
382 | }, &qr)
383 | if err != nil {
384 | return nil, err
385 | }
386 |
387 | pullReq.Commits = append(pullReq.Commits, graphqlResultToCommits(qr)...)
388 | }
389 |
390 | return pullReq, nil
391 | }
392 |
393 | func (g githubGateway) graphqlEndpoint() string {
394 | if g.domain == "github.com" {
395 | return "https://api.github.com/graphql"
396 | }
397 |
398 | return "https://" + g.domain + "/api/graphql"
399 | }
400 |
401 | func (g githubGateway) queryGraphQL(ctx context.Context, query string, variables interface{}, value interface{}) error {
402 | client := prchecklist.ContextClient(ctx)
403 |
404 | varBytes, err := json.Marshal(variables)
405 |
406 | var buf bytes.Buffer
407 | err = json.NewEncoder(&buf).Encode(map[string]string{"query": query, "variables": string(varBytes)})
408 | if err != nil {
409 | return err
410 | }
411 |
412 | req, err := http.NewRequest("POST", g.graphqlEndpoint(), &buf)
413 | if err != nil {
414 | return err
415 | }
416 |
417 | resp, err := client.Do(req)
418 | if err != nil {
419 | return err
420 | }
421 |
422 | result := graphQLResult{
423 | Data: value,
424 | }
425 |
426 | defer resp.Body.Close()
427 | err = json.NewDecoder(resp.Body).Decode(&result)
428 | if err != nil {
429 | return err
430 | }
431 |
432 | if len(result.Errors) > 0 {
433 | return fmt.Errorf("GraphQL error: %v", result.Errors)
434 | }
435 |
436 | return nil
437 | }
438 |
439 | func (g githubGateway) AuthCodeURL(state string, redirectURI *url.URL) string {
440 | opts := []oauth2.AuthCodeOption{}
441 | if redirectURI != nil {
442 | opts = append(opts, oauth2.SetAuthURLParam("redirect_uri", redirectURI.String()))
443 | }
444 | return g.oauth2Config.AuthCodeURL(state, opts...)
445 | }
446 |
447 | func (g githubGateway) newGitHubClient(base *http.Client) (*github.Client, error) {
448 | client := github.NewClient(base)
449 | if g.domain != "github.com" {
450 | var err error
451 | // TODO(motemen): parsing url can be done earlier
452 | client.BaseURL, err = url.Parse("https://" + g.domain + "/api/v3/")
453 | if err != nil {
454 | return nil, err
455 | }
456 | }
457 | return client, nil
458 | }
459 |
460 | func (g githubGateway) AuthenticateUser(ctx context.Context, code string) (*prchecklist.GitHubUser, error) {
461 | token, err := g.oauth2Config.Exchange(ctx, code)
462 | if err != nil {
463 | return nil, err
464 | }
465 |
466 | return g.GetUserFromToken(ctx, token)
467 | }
468 |
469 | func (g githubGateway) GetUserFromToken(ctx context.Context, token *oauth2.Token) (*prchecklist.GitHubUser, error) {
470 | client, err := g.newGitHubClient(
471 | oauth2.NewClient(ctx, oauth2.StaticTokenSource(token)),
472 | )
473 | if err != nil {
474 | return nil, err
475 | }
476 |
477 | u, _, err := client.Users.Get(ctx, "")
478 | if err != nil {
479 | return nil, err
480 | }
481 |
482 | return &prchecklist.GitHubUser{
483 | ID: int(u.GetID()),
484 | Login: u.GetLogin(),
485 | AvatarURL: u.GetAvatarURL(),
486 | Token: token,
487 | }, nil
488 | }
489 |
490 | func (g githubGateway) SetRepositoryStatusAs(ctx context.Context, owner, repo, ref, contextName, state, targetURL string) error {
491 | gh, err := g.newGitHubClient(prchecklist.ContextClient(ctx))
492 | if err != nil {
493 | return err
494 | }
495 |
496 | status := &github.RepoStatus{
497 | State: &state,
498 | Context: &contextName,
499 | TargetURL: &targetURL,
500 | }
501 | if _, _, err = gh.Repositories.CreateStatus(ctx, owner, repo, ref, status); err != nil {
502 | return err
503 | }
504 |
505 | return nil
506 | }
507 |
--------------------------------------------------------------------------------