Added NewsAPI

Author: djthorpe

pkg/client/transport.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"mime"
 	"net/http"
 	"time"
 	// Packages
@@ -90,8 +91,8 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 
 	// If verbose is switched on, read the body
 	if transport.v && resp.Body != nil {
-		contentType := resp.Header.Get("Content-Type")
-		if contentType == ContentTypeJson || contentType == ContentTypeTextPlain {
+		contentType, _, _ := mime.ParseMediaType(resp.Header.Get("Content-Type"))
+		if contentType == ContentTypeTextPlain || contentType == ContentTypeJson {
 			defer resp.Body.Close()
 			body, err := io.ReadAll(resp.Body)
 			if err == nil {

pkg/multipart/multipart.go

@@ -16,10 +16,12 @@ import (
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
+// Encoder is a multipart encoder object
 type Encoder struct {
 	w *multipart.Writer
 }
 
+// File is a file object, which is used to encode a file in a multipart request
 type File struct {
 	Path string
 	Body io.Reader
@@ -35,6 +37,7 @@ const (
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
+// NewEncoder creates a new encoder object, which writes to the io.Writer
 func NewEncoder(w io.Writer) *Encoder {
 	return &Encoder{
 		multipart.NewWriter(w),
@@ -44,6 +47,8 @@ func NewEncoder(w io.Writer) *Encoder {
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
+// Encode writes the struct to the multipart writer, including any File objects
+// which are added as form data and excluding any fields with a tag of json:"-"
 func (enc *Encoder) Encode(v any) error {
 	rv := reflect.ValueOf(v)
 	if rv.Kind() == reflect.Ptr {
@@ -82,7 +87,6 @@ func (enc *Encoder) Encode(v any) error {
 		// If this is a file, then add it to the form data
 		if field.Type == reflect.TypeOf(File{}) {
 			path := value.(File).Path
-			fmt.Println("path=", path)
 			if part, err := enc.w.CreateFormFile(name, filepath.Base(path)); err != nil {
 				result = errors.Join(result, err)
 			} else if _, err := io.Copy(part, value.(File).Body); err != nil {
@@ -97,10 +101,12 @@ func (enc *Encoder) Encode(v any) error {
 	return result
 }
 
+// Return the MIME content type of the multipart writer
 func (enc *Encoder) ContentType() string {
 	return enc.w.FormDataContentType()
 }
 
+// Close the multipart writer after writing all the data
 func (enc *Encoder) Close() error {
 	return enc.w.Close()
 }

pkg/newsapi/articles.go

@@ -0,0 +1,81 @@
+package newsapi
+
+import (
+	"time"
+
+	"github.com/mutablelogic/go-client/pkg/client"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Article struct {
+	Source      Source    `json:"source"`
+	Title       string    `json:"title"`
+	Author      string    `json:"author,omitempty"`
+	Description string    `json:"description,omitempty"`
+	Url         string    `json:"url,omitempty"`
+	ImageUrl    string    `json:"urlToImage,omitempty"`
+	PublishedAt time.Time `json:"publishedAt,omitempty"`
+	Content     string    `json:"content,omitempty"`
+}
+
+type respArticles struct {
+	Status       string    `json:"status"`
+	Code         string    `json:"code,omitempty"`
+	Message      string    `json:"message,omitempty"`
+	TotalResults int       `json:"totalResults"`
+	Articles     []Article `json:"articles"`
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Returns headlines
+func (c *Client) Headlines(opt ...Opt) ([]Article, error) {
+	var response respArticles
+	var query opts
+
+	// Add options
+	for _, opt := range opt {
+		if err := opt(&query); err != nil {
+			return nil, err
+		}
+	}
+
+	// Request -> Response
+	if err := c.Do(nil, &response, client.OptPath("top-headlines"), client.OptQuery(query.Values())); err != nil {
+		return nil, err
+	} else if response.Status != "ok" {
+		return nil, ErrBadParameter.Withf("%s: %s", response.Code, response.Message)
+	}
+
+	// Return success
+	return response.Articles, nil
+}
+
+// Returns articles
+func (c *Client) Articles(opt ...Opt) ([]Article, error) {
+	var response respArticles
+	var query opts
+
+	// Add options
+	for _, opt := range opt {
+		if err := opt(&query); err != nil {
+			return nil, err
+		}
+	}
+
+	// Request -> Response
+	if err := c.Do(nil, &response, client.OptPath("everything"), client.OptQuery(query.Values())); err != nil {
+		return nil, err
+	} else if response.Status != "ok" {
+		return nil, ErrBadParameter.Withf("%s: %s", response.Code, response.Message)
+	}
+
+	// Return success
+	return response.Articles, nil
+}

pkg/newsapi/articles_test.go

@@ -0,0 +1,38 @@
+package newsapi_test
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	// Packages
+	opts "github.com/mutablelogic/go-client/pkg/client"
+	newsapi "github.com/mutablelogic/go-client/pkg/newsapi"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_articles_001(t *testing.T) {
+	assert := assert.New(t)
+	client, err := newsapi.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+
+	articles, err := client.Headlines(newsapi.OptQuery("google"))
+	assert.NoError(err)
+	assert.NotNil(articles)
+
+	body, _ := json.MarshalIndent(articles, "", "  ")
+	t.Log(string(body))
+}
+
+func Test_articles_002(t *testing.T) {
+	assert := assert.New(t)
+	client, err := newsapi.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+
+	articles, err := client.Articles(newsapi.OptQuery("google"), newsapi.OptLimit(1))
+	assert.NoError(err)
+	assert.NotNil(articles)
+
+	body, _ := json.MarshalIndent(articles, "", "  ")
+	t.Log(string(body))
+}

pkg/newsapi/client.go

@@ -0,0 +1,37 @@
+/*
+newsapi implements an API client for NewsAPI (https://newsapi.org/docs)
+*/
+package newsapi
+
+import (
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Client struct {
+	*client.Client
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	endPoint = "https://newsapi.org/v2"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func New(ApiKey string, opts ...client.ClientOpt) (*Client, error) {
+	// Create client
+	client, err := client.New(append(opts, client.OptEndpoint(endPoint), client.OptHeader("X-Api-Key", ApiKey))...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return the client
+	return &Client{client}, nil
+}

pkg/newsapi/client_test.go

@@ -0,0 +1,31 @@
+package newsapi_test
+
+import (
+	"os"
+	"testing"
+
+	// Packages
+	opts "github.com/mutablelogic/go-client/pkg/client"
+	newsapi "github.com/mutablelogic/go-client/pkg/newsapi"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_client_001(t *testing.T) {
+	assert := assert.New(t)
+	client, err := newsapi.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+	assert.NotNil(client)
+	t.Log(client)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ENVIRONMENT
+
+func GetApiKey(t *testing.T) string {
+	key := os.Getenv("NEWSAPI_KEY")
+	if key == "" {
+		t.Skip("NEWSAPI_KEY not set")
+		t.SkipNow()
+	}
+	return key
+}

pkg/newsapi/opts.go

@@ -0,0 +1,114 @@
+package newsapi
+
+import (
+	"fmt"
+	"net/url"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type opts struct {
+	Category string `json:"category,omitempty"`
+	Language string `json:"language,omitempty"`
+	Country  string `json:"country,omitempty"`
+	Query    string `json:"q,omitempty"`
+	Limit    int    `json:"pageSize,omitempty"`
+	Sort     string `json:"sortBy,omitempty"`
+}
+
+// Opt is a function which can be used to set options on a request
+type Opt func(*opts) error
+
+///////////////////////////////////////////////////////////////////////////////
+// METHODS
+
+func (o *opts) Values() url.Values {
+	result := url.Values{}
+	if o.Category != "" {
+		result.Set("category", o.Category)
+	}
+	if o.Language != "" {
+		result.Set("language", o.Language)
+	}
+	if o.Country != "" {
+		result.Set("country", o.Country)
+	}
+	if o.Query != "" {
+		result.Set("q", o.Query)
+	}
+	if o.Limit > 0 {
+		result.Set("pageSize", fmt.Sprint(o.Limit))
+	}
+	if o.Sort != "" {
+		result.Set("sortBy", o.Sort)
+	}
+	return result
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// OPTIONS
+
+// Set the category
+func OptCategory(v string) Opt {
+	return func(o *opts) error {
+		o.Category = v
+		return nil
+	}
+}
+
+// Set the language
+func OptLanguage(v string) Opt {
+	return func(o *opts) error {
+		o.Language = v
+		return nil
+	}
+}
+
+// Set the country
+func OptCountry(v string) Opt {
+	return func(o *opts) error {
+		o.Country = v
+		return nil
+	}
+}
+
+// Set the query
+func OptQuery(v string) Opt {
+	return func(o *opts) error {
+		o.Query = v
+		return nil
+	}
+}
+
+// Set the number of results
+func OptLimit(v int) Opt {
+	return func(o *opts) error {
+		o.Limit = v
+		return nil
+	}
+}
+
+// Sort for articles by relevancy
+func OptSortByRelevancy() Opt {
+	return func(o *opts) error {
+		o.Sort = "relevancy"
+		return nil
+	}
+}
+
+// Sort for articles by popularity
+func OptSortByPopularity() Opt {
+	return func(o *opts) error {
+		o.Sort = "popularity"
+		return nil
+	}
+}
+
+// Sort for articles by date
+func OptSortByDate() Opt {
+	return func(o *opts) error {
+		o.Sort = "publishedAt"
+		return nil
+	}
+}