[monorail go api] add IssuesList rpc

go/src/infra/monorail/endpoints.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package monorail
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "io"
         "io/ioutil"
         "net/http"
+        "net/url"
         "strings"
 
         "golang.org/x/net/context"
         "golang.org/x/net/context/ctxhttp"
         "google.golang.org/grpc"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
 )
@@ skipping 15 matching lines @@
 //
 // Methods do not implement retries.
 // Use "github.com/luci/luci-go/common/errors".IsTransient to check
 // if an error is transient.
 //
 // Client methods return an error on any grpc.CallOption.
 func NewEndpointsClient(client *http.Client, url string) MonorailClient {
         return &epClient{HTTP: client, url: strings.TrimSuffix(url, "/")}
 }
 
-func (c *epClient) call(ctx context.Context, urlSuffix string, request, response interface{}) error {
+func (c *epClient) call(ctx context.Context, method, urlSuffix string, request, response interface{}) error {
         client := c.HTTP
         if client == nil {
                 client = http.DefaultClient
         }
 
         // Limit ctx deadline to timeout set in client.
         if client.Timeout > 0 {
                 clientDeadline := clock.Now(ctx).Add(client.Timeout)
                 if deadline, ok := ctx.Deadline(); !ok || deadline.After(clientDeadline) {
                         ctx, _ = context.WithDeadline(ctx, clientDeadline)
                 }
         }
 
         // Convert request object to JSON.
         reqBuf := &bytes.Buffer{}
         if request != nil {
                 if err := json.NewEncoder(reqBuf).Encode(request); err != nil {
                         return err
                 }
         }
 
         // Make an HTTP request.
-        req, err := http.NewRequest("POST", c.url + urlSuffix, reqBuf)
+        req, err := http.NewRequest(method, c.url+urlSuffix, reqBuf)
         if err != nil {
                 return fmt.Errorf("could not make a request to %s: %s", req.URL, err)
         }
         req.Header.Set("Content-Type", "application/json")
         req.Header.Set("Accept", "application/json")
 
         // Send the request.
-        logging.Debugf(ctx, "POST %s %s", req.URL, reqBuf.Bytes())
+        logging.Debugf(ctx, "%s %s %s", method, req.URL, reqBuf.Bytes())
         res, err := ctxhttp.Do(ctx, client, req)
         if err != nil {
                 return errors.WrapTransient(err)
         }
         defer res.Body.Close()
 
         // Check HTTP status code.
         if res.StatusCode != http.StatusOK {
                 text, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1024))
                 err := fmt.Errorf("unexpected status %q. Response: %s", res.Status, text)
@@ skipping 13 matching lines @@
 
 func (c *epClient) InsertIssue(ctx context.Context, req *InsertIssueRequest, options ...grpc.CallOption) (*InsertIssueResponse, error) {
         if err := checkOptions(options); err != nil {
                 return nil, err
         }
         if err := req.Validate(); err != nil {
                 return nil, err
         }
         url := fmt.Sprintf("/projects/%s/issues?sendEmail=%v", req.ProjectId, req.SendEmail)
         res := &InsertIssueResponse{&Issue{}}
-        return res, c.call(ctx, url, &req.Issue, res.Issue)
+        return res, c.call(ctx, "POST", url, &req.Issue, res.Issue)
 }
 
 func (c *epClient) InsertComment(ctx context.Context, req *InsertCommentRequest, options ...grpc.CallOption) (*InsertCommentResponse, error) {
         if err := checkOptions(options); err != nil {
                 return nil, err
         }
         url := fmt.Sprintf("/projects/%s/issues/%d/comments", req.Issue.ProjectId, req.Issue.IssueId)
-        return &InsertCommentResponse{}, c.call(ctx, url, req.Comment, nil)
+        return &InsertCommentResponse{}, c.call(ctx, "POST", url, req.Comment, nil)
+}
+
+func (c *epClient) IssuesList(ctx context.Context, req *IssuesListRequest, options ...grpc.CallOption) (*IssuesListResponse, error) {
+        if err := checkOptions(options); err != nil {
+                return nil, err
+        }
+
+        args := url.Values{}
+        args.Set("can", strings.ToLower(req.Can.String()))
+        args.Set("q", req.Q)
+        args.Set("label", req.Label)
+        args.Set("maxResults", fmt.Sprintf("%d", req.MaxResults))
+        args.Set("owner", req.Owner)
+        args.Set("publishedMax", fmt.Sprintf("%d", req.PublishedMax))
+        args.Set("publishedMin", fmt.Sprintf("%d", req.PublishedMin))
+        args.Set("sort", req.Sort)
+        args.Set("startIndex", fmt.Sprintf("%d", req.StartIndex))
+        args.Set("status", req.Status)
+        args.Set("updatedMax", fmt.Sprintf("%d", req.UpdatedMax))
+        args.Set("updatedMin", fmt.Sprintf("%d", req.UpdatedMin))
+
+        url := fmt.Sprintf("/projects/%s/issues?%s", req.ProjectId, args.Encode())
+        res := &IssuesListResponse{}
+        err := c.call(ctx, "GET", url, nil, res)
+        if err != nil {
+                return nil, err
+        }
+        return res, nil
 }
 
 func checkOptions(options []grpc.CallOption) error {
         if len(options) > 0 {
                 return errGrpcOptions
         }
         return nil
 }