first commit

Author: maiku1008

.gitignore

@@ -0,0 +1,23 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+
+main.go

README.md

@@ -0,0 +1,124 @@
+
+# OpenApi IT Go Client 
+
+This client is used to interact with the API found at [openapi.it](https://openapi.it/)
+
+## Pre-requisites
+
+Before using the OpenApi IT Go Client, you will need an account at [openapi.it](https://openapi.it/) and an API key to the sandbox and/or production environment
+
+## Installation
+
+You can install the OpenApi IT Go Client with the following command using go get:
+
+```bash
+go get github.com/openapi-it/openapi-cli-go
+```
+    
+## Usage
+
+```go
+// main.go
+package main
+
+import (
+	client "github.com/openapi-it/openapi-cli-go/pkg/client"
+)
+
+func main() {
+	// Initialize the oauth client on the sandbox environment
+	ctx := context.Background()
+	oauthClient := client.NewOauthClient("<your_username>", "<your_apikey>", true)
+
+	// Create a token for a list of scopes
+	scopes := []string{
+		"GET:test.cap.openapi.it/cerca_comuni",
+		"POST:test.postontarget.com/fields/country",
+	}
+	ttl := 2592000
+	resp, err := oauthClient.CreateToken(ctx, scopes, ttl) // returns the json as string
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// The string response can be parsed into a custom object
+	tokenResponse := struct {
+		Scopes []string `json:"scopes"`
+		Token  string   `json:"token"`
+	}{}
+	_ = json.Unmarshal([]byte(resp), &tokenResponse)
+
+	// Initialize the client
+	client := client.NewClient(tokenResponse.Token)
+
+	// Make a request with params
+	params := map[string]string{
+		"denominazione": "altravia",
+		"provincia":     "RM",
+		"codice_ateco":  "6201",
+	}
+	_, err = client.Request(
+		ctx,
+		"GET",
+		"https://test.imprese.openapi.it",
+		"/advance",
+		nil, params,
+	)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Make a request with a payload
+	payload := struct {
+		Limit int `json:"limit"`
+		Query struct {
+			CountryCode string `json:"country_code"`
+		} `json:"query"`
+	}{
+		Limit: 0,
+		Query: struct {
+			CountryCode string `json:"country_code"`
+		}{CountryCode: "IT"},
+	}
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(payload); err != nil {
+		log.Fatal(err)
+	}
+	_, err = client.Request(
+		ctx,
+		"POST",
+		"https://test.postontarget.com",
+		"/fields/country",
+		&buf,
+		nil,
+	)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Delete the token
+	_, err = oauthClient.DeleteToken(ctx, tokenResponse.Token)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+## Contributing
+
+Contributions are always welcome!
+
+See `contributing.md` for ways to get started.
+
+Please adhere to this project's `code of conduct`.
+
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)
+
+
+## Authors
+
+- [@maiku1008](https://www.github.com/maiku1008)
+- [@openapi-it](https://github.com/openapi-it)

go.mod

@@ -0,0 +1,3 @@
+module github.com/openapi-it/openapi-cli-go
+
+go 1.19

pkg/client/client.go

@@ -0,0 +1,55 @@
+package client
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// NewClient creates a new Client instance with the given authentication token.
+// The returned client can be used to make API requests.
+func NewClient(token string) *Client {
+	return &Client{
+		authHeader: "Bearer " + token,
+		httpClient: &http.Client{},
+	}
+}
+
+// Client is a simple HTTP client used to make API requests.
+type Client struct {
+	authHeader string
+	httpClient *http.Client
+}
+
+// Request sends an HTTP request to the specified endpoint.
+// ctx: the context.Context to be used for the request.
+// baseURL: the base URL of the API.
+// method: the HTTP method to use (e.g. GET, POST, etc.).
+// endpoint: the endpoint to send the request to.
+// body: the body of the request.
+// params: the query parameters to include in the request.
+//
+// Returns a string containing the formatted JSON response and an error if any.
+func (c *Client) Request(
+	ctx context.Context,
+	method string,
+	baseURL string,
+	endpoint string,
+	body io.Reader,
+	params map[string]string) (string, error) {
+
+	queryParams := url.Values{}
+	for key, value := range params {
+		queryParams.Set(key, value)
+	}
+	opts := &requestOptions{
+		method:      method,
+		baseURL:     baseURL,
+		endpoint:    endpoint,
+		authString:  c.authHeader,
+		payload:     body,
+		queryParams: queryParams,
+	}
+	return request(ctx, c.httpClient, opts)
+}

pkg/client/common.go

@@ -0,0 +1,62 @@
+package client
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// httpClient is an interface that defines the Do method for making HTTP requests.
+type httpClient interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+// requestOptions contains the options for an HTTP request.
+type requestOptions struct {
+	method      string     // HTTP request method (e.g., "GET", "POST", etc.)
+	baseURL     string     // Base URL for the HTTP request.
+	endpoint    string     // Endpoint for the HTTP request.
+	authString  string     // Authentication string for the HTTP request.
+	payload     io.Reader  // Payload for the HTTP request (if any).
+	queryParams url.Values // Query parameters for the HTTP request (if any).
+}
+
+// request makes an HTTP request with the specified options.
+func request(
+	ctx context.Context,
+	client httpClient,
+	opts *requestOptions) (string, error) {
+
+	req, err := http.NewRequestWithContext(ctx, opts.method, opts.baseURL, opts.payload)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Add("Authorization", opts.authString)
+	req.Header.Add("Content-Type", `application/json`)
+	req.URL.Path += opts.endpoint
+
+	if opts.queryParams != nil {
+		req.URL.RawQuery = opts.queryParams.Encode()
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var formattedJSON bytes.Buffer
+	err = json.Indent(&formattedJSON, body, "", "\t")
+	if err != nil {
+		return "", err
+	}
+	return formattedJSON.String(), nil
+}