Add list notes

Author: kentakozuka

errors.go

@@ -0,0 +1,22 @@
+package habitify
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type ErrPreconditionFailed struct {
+	msg string
+}
+
+func (e *ErrPreconditionFailed) Error() string {
+	return e.msg
+}
+
+func newError(statusCode int, msg string) error {
+	switch statusCode {
+	case http.StatusPreconditionFailed:
+		return &ErrPreconditionFailed{msg: msg}
+	}
+	return fmt.Errorf("unknown error: %s", msg)
+}

habitify.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -16,8 +15,16 @@ const DefaultEndpoint = "https://api.habitify.me"
 
 const (
 	urlHabits = "/habits"
+	urlNotes  = "/notes"
 )
 
+type apiResponse struct {
+	Message string          `json:"message"`
+	Version string          `json:"version"`
+	Status  bool            `json:"status"`
+	Data    json.RawMessage `json:"data"`
+}
+
 // Client is a client for Habitify API.
 type Client struct {
 	httpClient *http.Client
@@ -75,53 +82,48 @@ func (resp *httpResponse) Close() {
 	_ = resp.Body.Close()
 }
 
-func (c *Client) do(ctx context.Context, method, path string, body io.Reader) (*httpResponse, error) {
+func (c *Client) do(ctx context.Context, method, path string, body io.Reader, data interface{}) error {
 	req, err := http.NewRequestWithContext(ctx, method, c.endpoint+path, body)
 
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	req.Header.Add("Authorization", c.apiKey)
 	req.Header.Add("Content-Type", "application/json; charset=utf8")
 
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
-		return nil, err
+		return err
 	}
+	defer resp.Body.Close()
 
-	switch resp.StatusCode {
-	case http.StatusBadRequest:
-		return nil, errors.New("client has issues an invalid request")
-	case http.StatusUnauthorized:
-		return nil, errors.New("authorization for the API is required but the request has not been authenticated")
-	case http.StatusForbidden:
-		return nil, errors.New("the request has been authenticated but does not have permission or the resource is not found")
-	case http.StatusNotAcceptable:
-		return nil, errors.New("the client has requestd a MIM typ via the Accept header for a value not supported by the server")
-	case http.StatusUnsupportedMediaType:
-		return nil, errors.New("the client has defined a Content-Type header that is not supported by the server")
-	case http.StatusUnprocessableEntity:
-		return nil, errors.New("the client has made a valid request but the server cannot process it")
-	case http.StatusTooManyRequests:
-		return nil, errors.New("the client has exceeded the number of requests allowed for a givn time window")
-	case http.StatusInternalServerError:
-		return nil, errors.New("an unexpected error on the server has occurred")
+	httpResp := &httpResponse{Response: resp}
+	var apiResp apiResponse
+	if err := httpResp.DecodeJSON(&apiResp); err != nil {
+		return err
+	}
+	if !apiResp.Status {
+		return newError(resp.StatusCode, apiResp.Message)
 	}
 
-	return &httpResponse{Response: resp}, nil
+	if err := json.Unmarshal(apiResp.Data, data); err != nil {
+		return fmt.Errorf("decoding JSON data: %w", err)
+	}
+
+	return nil
 }
 
-func (c *Client) get(ctx context.Context, path string) (*httpResponse, error) {
-	return c.do(ctx, http.MethodGet, path, nil)
+func (c *Client) get(ctx context.Context, path string, data interface{}) error {
+	return c.do(ctx, http.MethodGet, path, nil, data)
 }
 
-func (c *Client) post(ctx context.Context, path string, body interface{}) (*httpResponse, error) {
+func (c *Client) post(ctx context.Context, path string, body interface{}) error {
 	var buf bytes.Buffer
 
 	if err := json.NewEncoder(&buf).Encode(body); err != nil {
-		return nil, err
+		return err
 	}
 
-	return c.do(ctx, http.MethodPost, path, &buf)
+	return c.do(ctx, http.MethodPost, path, &buf, nil)
 }

habits.go

@@ -6,20 +6,6 @@ import (
 	"time"
 )
 
-type getHabitResp struct {
-	Message string `json:"message"`
-	Habit   *Habit `json:"data"`
-	Version string `json:"version"`
-	Status  bool   `json:"status"`
-}
-
-type listHabitsResp struct {
-	Message string   `json:"message"`
-	Habits  []*Habit `json:"data"`
-	Version string   `json:"version"`
-	Status  bool     `json:"status"`
-}
-
 type Habit struct {
 	ID         string    `json:"id"`
 	Name       string    `json:"name"`
@@ -49,31 +35,21 @@ type Habit struct {
 }
 
 func (c *Client) GetHabit(ctx context.Context, id string) (*Habit, error) {
-	resp, err := c.get(ctx, fmt.Sprintf("%s/%s", urlHabits, id))
+	var habit Habit
+	err := c.get(ctx, fmt.Sprintf("%s/%s", urlHabits, id), &habit)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Close()
-
-	var response getHabitResp
-	if err := resp.DecodeJSON(&response); err != nil {
-		return nil, err
-	}
 
-	return response.Habit, nil
+	return &habit, nil
 }
 
 func (c *Client) ListHabits(ctx context.Context) ([]*Habit, error) {
-	resp, err := c.get(ctx, urlHabits)
+	var habits []*Habit
+	err := c.get(ctx, urlHabits, &habits)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Close()
-
-	var response listHabitsResp
-	if err := resp.DecodeJSON(&response); err != nil {
-		return nil, err
-	}
 
-	return response.Habits, nil
+	return habits, nil
 }

notes.go

@@ -0,0 +1,33 @@
+package habitify
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+const dateFormat = "2006-01-02T15:04:05-07:00"
+
+type Note struct {
+	ID          string      `json:"id"`
+	Content     string      `json:"content"`
+	CreatedDate string      `json:"created_date"`
+	ImageURL    interface{} `json:"image_url"`
+	NoteType    int         `json:"note_type"`
+	HabitID     string      `json:"habit_id"`
+}
+
+func (c *Client) ListNotes(ctx context.Context, habitID string, from, to time.Time) ([]*Note, error) {
+	var notes []*Note
+	err := c.get(ctx, fmt.Sprintf("%s/%s?from=%s&to=%s", urlNotes, habitID, formatTime(from), formatTime(to)), &notes)
+	if err != nil {
+		return nil, err
+	}
+
+	return notes, nil
+}
+
+func formatTime(t time.Time) string {
+	return url.QueryEscape(t.Format(dateFormat))
+}