Add thing create command

The parameters to create a new thing are:
- thing name - mandatory
- device (id) to bind the thing to - optional
- thing template - mandatory if no thing to clone is passed
- thing to clone (id) - mandatory if no template

note that:
- iot client is really ugly and should be refactored -> the problem is that iot-client-go doesn't accept the 'properties' field when creating a new thing. For this reason a standard http request has been performed.

todos and questions:
- improve naming of create flags and create params (maybe it's not clear that IDs should be used)
- is template or thing to be cloned a real requirement? An empty thing could also make sense
- refactor iot client AddThing -> prerequisite: add the properties parameter in iot-client-go
- thing Create function stores the thing parameters into an empty interface -> this will be replaced into a proper structure as soon as iot-client-go can handle properties

Author: polldo

cli/root.go

@@ -7,6 +7,7 @@ import (
 	"github.com/arduino/iot-cloud-cli/cli/config"
 	"github.com/arduino/iot-cloud-cli/cli/device"
 	"github.com/arduino/iot-cloud-cli/cli/ping"
+	"github.com/arduino/iot-cloud-cli/cli/thing"
 	"github.com/spf13/cobra"
 )
 
@@ -15,6 +16,7 @@ func Execute() {
 	rootCmd.AddCommand(ping.NewCommand())
 	rootCmd.AddCommand(config.NewCommand())
 	rootCmd.AddCommand(device.NewCommand())
+	rootCmd.AddCommand(thing.NewCommand())
 
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Fprintln(os.Stderr, err)

cli/thing/create.go

@@ -0,0 +1,49 @@
+package thing
+
+import (
+	"fmt"
+
+	"github.com/arduino/iot-cloud-cli/command/thing"
+	"github.com/spf13/cobra"
+)
+
+var createFlags struct {
+	name     string
+	device   string
+	template string
+	clone    string
+}
+
+func initCreateCommand() *cobra.Command {
+	createCommand := &cobra.Command{
+		Use:   "create",
+		Short: "Create a thing",
+		Long:  "Create a thing for Arduino IoT Cloud",
+		RunE:  runCreateCommand,
+	}
+	createCommand.Flags().StringVarP(&createFlags.name, "name", "n", "", "Thing name")
+	createCommand.Flags().StringVarP(&createFlags.device, "device", "d", "", "ID of Device to bind to the new thing")
+	createCommand.Flags().StringVarP(&createFlags.clone, "clone", "c", "", "ID of Thing to be cloned")
+	createCommand.Flags().StringVarP(&createFlags.template, "template", "t", "", "File containing a thing template")
+	createCommand.MarkFlagRequired("name")
+	return createCommand
+}
+
+func runCreateCommand(cmd *cobra.Command, args []string) error {
+	fmt.Printf("Creating thing with name %s\n", createFlags.name)
+
+	params := &thing.CreateParams{
+		Name:     createFlags.name,
+		Device:   createFlags.device,
+		Template: createFlags.template,
+		Clone:    createFlags.clone,
+	}
+
+	thingID, err := thing.Create(params)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("IoT Cloud thing created with ID: %s\n", thingID)
+	return nil
+}

cli/thing/thing.go

@@ -0,0 +1,17 @@
+package thing
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func NewCommand() *cobra.Command {
+	thingCommand := &cobra.Command{
+		Use:   "thing",
+		Short: "Thing commands.",
+		Long:  "Thing commands.",
+	}
+
+	thingCommand.AddCommand(initCreateCommand())
+
+	return thingCommand
+}

command/thing/create.go

@@ -0,0 +1,100 @@
+package thing
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/arduino/iot-cloud-cli/internal/config"
+	"github.com/arduino/iot-cloud-cli/internal/iot"
+)
+
+// CreateParams contains the parameters needed to create a new thing.
+type CreateParams struct {
+	// Mandatory - contains the name of the thing
+	Name string
+	// Optional - contains the ID of the device to be bound to the thing
+	Device string
+	// Mandatory if device is empty - contains the path of the template file
+	Template string
+	// Mandatory if template is empty- name of things to be cloned
+	Clone string
+}
+
+// Create allows to create a new thing
+func Create(params *CreateParams) (string, error) {
+	if params.Template == "" && params.Clone == "" {
+		return "", fmt.Errorf("%s", "provide either a thing(ID) to clone (--clone) or a thing template file (--template)\n")
+	}
+
+	conf, err := config.Retrieve()
+	if err != nil {
+		return "", err
+	}
+	iotClient, err := iot.NewClient(conf.Client, conf.Secret)
+	if err != nil {
+		return "", err
+	}
+
+	var thing map[string]interface{}
+
+	if params.Clone != "" {
+		thing, err = cloneThing(iotClient, params.Clone)
+		if err != nil {
+			return "", err
+		}
+
+	} else if params.Template != "" {
+		thing, err = loadTemplate(params.Template)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	thing["name"] = params.Name
+	force := true
+	if params.Device != "" {
+		thing["device_id"] = params.Device
+	}
+	thingID, err := iotClient.AddThing(thing, force)
+	if err != nil {
+		return "", err
+	}
+
+	return thingID, nil
+}
+
+func cloneThing(client iot.Client, thingID string) (map[string]interface{}, error) {
+	clone, err := client.GetThing(thingID)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", "retrieving the thing to be cloned", err)
+	}
+
+	thing := make(map[string]interface{})
+	thing["device_id"] = clone.DeviceId
+	thing["properties"] = clone.Properties
+
+	return thing, nil
+}
+
+func loadTemplate(file string) (map[string]interface{}, error) {
+	templateFile, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	defer templateFile.Close()
+
+	templateBytes, err := ioutil.ReadAll(templateFile)
+	if err != nil {
+		return nil, err
+	}
+
+	var template map[string]interface{}
+	err = json.Unmarshal([]byte(templateBytes), &template)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", "reading template file: template not valid: ", err)
+	}
+
+	return template, nil
+}

internal/iot/client.go

@@ -1,8 +1,13 @@
 package iot
 
 import (
+	"bytes"
 	"context"
+	"encoding/json"
+	"errors"
 	"fmt"
+	"net/http"
+	"strconv"
 
 	iotclient "github.com/arduino/iot-client-go"
 )
@@ -11,6 +16,8 @@ import (
 type Client interface {
 	AddDevice(fqbn, name, serial, devType string) (string, error)
 	AddCertificate(id, csr string) (*iotclient.ArduinoCompressedv2, error)
+	AddThing(thing interface{}, force bool) (string, error)
+	GetThing(id string) (*iotclient.ArduinoThing, error)
 }
 
 type client struct {
@@ -65,6 +72,77 @@ func (cl *client) AddCertificate(id, csr string) (*iotclient.ArduinoCompressedv2
 	return &newCert.Compressed, nil
 }
 
+func (cl *client) AddThing(thing interface{}, force bool) (string, error) {
+	// Request
+	url := "https://api2.arduino.cc/iot/v2/things"
+	bodyBuf := &bytes.Buffer{}
+	err := json.NewEncoder(bodyBuf).Encode(thing)
+	if err != nil {
+		return "", err
+	}
+	if bodyBuf.Len() == 0 {
+		err = errors.New("invalid body type")
+		return "", err
+	}
+
+	req, err := http.NewRequest(http.MethodPut, url, bodyBuf)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	var bearer = "Bearer " + cl.ctx.Value(iotclient.ContextAccessToken).(string)
+	req.Header.Add("Authorization", bearer)
+
+	q := req.URL.Query()
+	q.Add("force", strconv.FormatBool(force))
+	req.URL.RawQuery = q.Encode()
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		err = fmt.Errorf("%s: %w", "adding new thing", err)
+		return "", err
+	}
+
+	// Response
+	if resp.StatusCode != 201 {
+		// Get response error detail
+		var respObj map[string]interface{}
+		err = json.NewDecoder(resp.Body).Decode(&respObj)
+		if err != nil {
+			return "", fmt.Errorf("%s: %s: %s", "cannot get response body", err, resp.Status)
+		}
+		return "", fmt.Errorf("%s: %s", "adding new thing", respObj["detail"].(string))
+	}
+
+	if resp.Body == nil {
+		return "", errors.New("response body is empty")
+	}
+	defer resp.Body.Close()
+
+	var newThing map[string]interface{}
+	err = json.NewDecoder(resp.Body).Decode(&newThing)
+	if err != nil {
+		err = fmt.Errorf("%s: %w", "cannot parse body response", err)
+		return "", err
+	}
+	newID, ok := newThing["id"].(string)
+	if !ok {
+		return "", errors.New("adding new thing: new thing created: returned id is not available")
+	}
+	return newID, nil
+}
+
+func (cl *client) GetThing(id string) (*iotclient.ArduinoThing, error) {
+	thing, _, err := cl.api.ThingsV2Api.ThingsV2Show(cl.ctx, id, nil)
+	if err != nil {
+		err = fmt.Errorf("retrieving thing, %w", err)
+		return nil, err
+	}
+	return &thing, nil
+}
+
 func (cl *client) setup(client, secret string) error {
 	// Get the access token in exchange of client_id and client_secret
 	tok, err := token(client, secret)