Add Login() method for native authentication. (#22)

* add Native auth support, move req into new file

* Make Login work

* minor updates, gomock

Author: davidnewhall

go.mod

@@ -2,4 +2,7 @@ module golift.io/starr
 
 go 1.17
 
-require github.com/golang/mock v1.6.0
+require (
+	github.com/golang/mock v1.6.0
+	golang.org/x/net v0.0.0-20211216030914-fe4d6282115f // publicsuffix, cookiejar.
+)

go.sum

@@ -7,6 +7,8 @@ golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20211216030914-fe4d6282115f h1:hEYJvxw1lSnWIl8X9ofsYMklzaDs90JI2az5YMd4fPM=
+golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

http.go

@@ -72,7 +72,12 @@ func (c *Config) setHeaders(req *http.Request) {
 		req.Header.Set("Content-Type", "application/json")
 	}
 
-	req.Header.Set("Accept", "application/json")
+	if req.Method == http.MethodPost && strings.HasSuffix(req.URL.RequestURI(), "/login") {
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	} else {
+		req.Header.Set("Accept", "application/json")
+	}
+
 	req.Header.Set("User-Agent", "go-starr: https://"+reflect.TypeOf(Config{}).PkgPath()) //nolint:exhaustivestruct
 	req.Header.Set("X-API-Key", c.APIKey)
 }
@@ -92,7 +97,7 @@ func (c *Config) getBody(req *http.Request) (int, []byte, http.Header, error) {
 
 	// #############################################
 	// DEBUG: useful for viewing payloads from apps.
-	// fmt.Println(resp.StatusCode, string(body))
+	// log.Println(resp.StatusCode, resp.Header.Get("location"), string(body))
 	// #############################################
 
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {

interface.go

@@ -10,12 +10,17 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/http/cookiejar"
 	"net/url"
+	"strings"
+
+	"golang.org/x/net/publicsuffix"
 )
 
 // APIer is used by the sub packages to allow mocking the http methods in tests.
 // This also allows consuming packages to override methods.
 type APIer interface {
+	Login() error // Only needed for non-API paths, like backup downloads. Requires Username and Password being set.
 	Get(path string, params url.Values) (respBody []byte, err error)
 	Post(path string, params url.Values, postBody []byte) (respBody []byte, err error)
 	Put(path string, params url.Values, putBody []byte) (respBody []byte, err error)
@@ -63,6 +68,39 @@ func (c *Config) log(code int, data, body []byte, header http.Header, path, meth
 	}
 }
 
+// Login POSTs to the login form in a Starr app and saves the authentication cookie for future use.
+func (c *Config) Login() error {
+	if c.Client.Jar == nil {
+		jar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+		if err != nil {
+			return fmt.Errorf("cookiejar.New(publicsuffix): %w", err)
+		}
+
+		c.Client.Jar = jar
+	}
+
+	post := []byte("username=" + c.Username + "&password=" + c.Password)
+
+	code, resp, header, err := c.body(context.Background(), "/login", http.MethodPost, nil, bytes.NewBuffer(post))
+	c.log(code, nil, post, header, c.URL+"/login", http.MethodPost, err)
+
+	if err != nil {
+		return fmt.Errorf("authenticating as user '%s' failed: %w", c.Username, err)
+	}
+	defer resp.Close()
+
+	_, _ = io.Copy(io.Discard, resp)
+
+	if u, _ := url.Parse(c.URL); strings.Contains(header.Get("location"), "loginFailed") ||
+		len(c.Client.Jar.Cookies(u)) == 0 {
+		return fmt.Errorf("%w: authenticating as user '%s' failed", ErrRequestError, c.Username)
+	}
+
+	c.cookie = true
+
+	return nil
+}
+
 // Get makes a GET http request and returns the body.
 func (c *Config) Get(path string, params url.Values) ([]byte, error) {
 	code, data, header, err := c.req(path, http.MethodGet, params, nil)
@@ -74,7 +112,7 @@ func (c *Config) Get(path string, params url.Values) ([]byte, error) {
 // Post makes a POST http request and returns the body.
 func (c *Config) Post(path string, params url.Values, postBody []byte) ([]byte, error) {
 	code, data, header, err := c.req(path, http.MethodPost, params, bytes.NewBuffer(postBody))
-	c.log(code, data, postBody, header, c.setPathParams(path, params), http.MethodPut, err)
+	c.log(code, data, postBody, header, c.setPathParams(path, params), http.MethodPost, err)
 
 	return data, err
 }
@@ -130,7 +168,7 @@ func (c *Config) DeleteInto(path string, params url.Values, v interface{}) error
 // If it's not 200, it's possible the request had an error or was not authenticated.
 func (c *Config) GetBody(ctx context.Context, path string, params url.Values) (io.ReadCloser, int, error) {
 	code, data, header, err := c.body(ctx, path, http.MethodGet, params, nil)
-	c.log(code, nil, nil, header, c.setPathParams(path, params), http.MethodGet, err)
+	c.log(code, nil, nil, header, c.URL+path, http.MethodGet, err)
 
 	return data, code, err
 }
@@ -142,7 +180,7 @@ func (c *Config) GetBody(ctx context.Context, path string, params url.Values) (i
 func (c *Config) PostBody(ctx context.Context, path string, params url.Values,
 	postBody []byte) (io.ReadCloser, int, error) {
 	code, data, header, err := c.body(ctx, path, http.MethodPost, params, bytes.NewBuffer(postBody))
-	c.log(code, nil, postBody, header, c.setPathParams(path, params), http.MethodPut, err)
+	c.log(code, nil, postBody, header, c.URL+path, http.MethodPost, err)
 
 	return data, code, err
 }
@@ -153,7 +191,7 @@ func (c *Config) PostBody(ctx context.Context, path string, params url.Values,
 func (c *Config) PutBody(ctx context.Context, path string, params url.Values,
 	putBody []byte) (io.ReadCloser, int, error) {
 	code, data, header, err := c.body(ctx, path, http.MethodPut, params, bytes.NewBuffer(putBody))
-	c.log(code, nil, putBody, header, c.setPathParams(path, params), http.MethodPut, err)
+	c.log(code, nil, putBody, header, c.URL+path, http.MethodPut, err)
 
 	return data, code, err
 }
@@ -164,7 +202,7 @@ func (c *Config) PutBody(ctx context.Context, path string, params url.Values,
 // If it's not 200, it's possible the request had an error or was not authenticated.
 func (c *Config) DeleteBody(ctx context.Context, path string, params url.Values) (io.ReadCloser, int, error) {
 	code, data, header, err := c.body(ctx, path, http.MethodDelete, params, nil)
-	c.log(code, nil, nil, header, c.setPathParams(path, params), http.MethodDelete, err)
+	c.log(code, nil, nil, header, c.URL+path, http.MethodDelete, err)
 
 	return data, code, err
 }

mocks/apier.go

@@ -0,0 +1,147 @@
+package starr
+
+import (
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+/* This file containers helper methods and types for page-able API calls.
+ * Like GetHistory() and GetQueue().
+ */
+
+// Req is the input to search requests that have page-able responses.
+// These are turned into HTTP parameters.
+type Req struct {
+	PageSize   int    // 10 is default if not provided.
+	Page       int    // 1 or higher
+	SortKey    string // date, timeleft, others?
+	SortDir    string // asc, desc
+	url.Values        // Additional values that may be set.
+}
+
+// Params returns a brand new url.Values with all request parameters combined.
+func (r *Req) Params() url.Values {
+	params := make(url.Values)
+
+	if r.Page > 0 {
+		params.Set("page", strconv.Itoa(r.Page))
+	} else {
+		params.Set("page", "1")
+	}
+
+	if r.PageSize > 0 {
+		params.Set("pageSize", strconv.Itoa(r.PageSize))
+	} else {
+		params.Set("pageSize", "10")
+	}
+
+	if r.SortKey != "" {
+		params.Set("sortKey", r.SortKey)
+	} else {
+		params.Set("sortKey", "date") // timeleft, title, id
+	}
+
+	if r.SortDir != "" {
+		params.Set("sortDirection", r.SortDir)
+	} else {
+		params.Set("sortDirection", "ascending") // descending
+	}
+
+	for k, v := range r.Values {
+		for _, val := range v {
+			params.Set(k, val)
+		}
+	}
+
+	return params
+}
+
+// Encode turns our request parameters into a URI string.
+func (r *Req) Encode() string {
+	return r.Params().Encode()
+}
+
+// CheckSet sets a request parameter if it's not already set.
+func (r *Req) CheckSet(key, value string) { //nolint:cyclop
+	switch strings.ToLower(key) {
+	case "page":
+		if r.Page == 0 {
+			r.Page, _ = strconv.Atoi(value)
+		}
+	case "pagesize":
+		if r.PageSize == 0 {
+			r.PageSize, _ = strconv.Atoi(value)
+		}
+	case "sortkey":
+		if r.SortKey == "" {
+			r.SortKey = value
+		}
+	case "sortdirection":
+		if r.SortDir == "" {
+			r.SortDir = value
+		}
+	default:
+		if r.Values == nil || r.Values.Get(key) == "" {
+			r.Values.Set(key, value)
+		}
+	}
+}
+
+// Set sets a request parameter.
+func (r *Req) Set(key, value string) {
+	switch strings.ToLower(key) {
+	case "page":
+		r.Page, _ = strconv.Atoi(value)
+	case "pagesize":
+		r.PageSize, _ = strconv.Atoi(value)
+	case "sortkey":
+		r.SortKey = value
+	case "sortdirection":
+		r.SortDir = value
+	default:
+		if r.Values == nil {
+			r.Values = make(url.Values)
+		}
+
+		r.Values.Set(key, value)
+	}
+}
+
+// SetPerPage returns a proper perPage value that is not equal to zero,
+// and not larger than the record count desired. If the count is zero, then
+// perPage can be anything other than zero.
+// This is used by paginated methods in the starr modules.
+func SetPerPage(records, perPage int) int {
+	const perPageDefault = 500
+
+	if perPage <= 1 {
+		if records > perPageDefault || records == 0 {
+			perPage = perPageDefault
+		} else {
+			perPage = records
+		}
+	} else if perPage > records && records != 0 {
+		perPage = records
+	}
+
+	return perPage
+}
+
+// AdjustPerPage to make sure we don't go over, or ask for more records than exist.
+// This is used by paginated methods in the starr modules.
+// 'records' is the number requested, 'total' is the number in the app,
+// 'collected' is how many we have so far, and 'perPage' is the current perPage setting.
+func AdjustPerPage(records, total, collected, perPage int) int {
+	// Do not ask for more than was requested.
+	if d := records - collected; perPage > d && d > 0 {
+		perPage = d
+	}
+
+	// Ask for only the known total.
+	if d := total - collected; perPage > d {
+		perPage = d
+	}
+
+	return perPage
+}