NOISSUE - Add Domains to the SDK (#45)

* add: domains sdk Signed-off-by: Arvindh <arvindh91@gmail.com> * fix: error Signed-off-by: Arvindh <arvindh91@gmail.com> * fix: cli users token and refresh Signed-off-by: Arvindh <arvindh91@gmail.com> * fix: cli provision Signed-off-by: Arvindh <arvindh91@gmail.com> * add domains cli Signed-off-by: Arvindh <arvindh91@gmail.com> * remove test program Signed-off-by: Arvindh <arvindh91@gmail.com> * update cli command for list domains Signed-off-by: Arvindh <arvindh91@gmail.com> * add list user domain cli cmd Signed-off-by: Arvindh <arvindh91@gmail.com> * fix varaible naming Signed-off-by: Arvindh <arvindh91@gmail.com> * fix: comments grammar & varabile; add package headers Signed-off-by: Arvindh <arvindh91@gmail.com> --------- Signed-off-by: Arvindh <arvindh91@gmail.com>
2026-06-23 04:10:28 +00:00 · 2023-11-17 16:12:53 +05:30
parent 7acf21a3e1
commit 48dddc4bba
13 changed files with 632 additions and 66 deletions
@@ -0,0 +1,236 @@
+// Copyright (c) Magistrala
+// SPDX-License-Identifier: Apache-2.0
+
+package cli
+
+import (
+	"encoding/json"
+
+	mgxsdk "github.com/absmach/magistrala/pkg/sdk/go"
+	"github.com/spf13/cobra"
+)
+
+var cmdDomains = []cobra.Command{
+	{
+		Use:   "create <name> <alias> <token>",
+		Short: "Create Domain",
+		Long: "Create Domain with provided name and alias. \n" +
+			"For example:\n" +
+			"\tmagistrala-cli domains create domain_1 domain_1_alias $TOKEN\n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 3 {
+				logUsage(cmd.Use)
+				return
+			}
+
+			user := mgxsdk.Domain{
+				Name:  args[0],
+				Alias: args[1],
+			}
+			user, err := sdk.CreateDomain(user, args[2])
+			if err != nil {
+				logError(err)
+				return
+			}
+			logJSON(user)
+		},
+	},
+	{
+		Use:   "get [all | <domain_id> ] <token>",
+		Short: "Get Domains",
+		Long:  "Get all domains. Users can be filtered by name or metadata or status",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Use)
+				return
+			}
+			metadata, err := convertMetadata(Metadata)
+			if err != nil {
+				logError(err)
+				return
+			}
+			pageMetadata := mgxsdk.PageMetadata{
+				Name:     Name,
+				Offset:   Offset,
+				Limit:    Limit,
+				Metadata: metadata,
+				Status:   Status,
+			}
+			if args[0] == all {
+				l, err := sdk.Domains(pageMetadata, args[1])
+				if err != nil {
+					logError(err)
+					return
+				}
+				logJSON(l)
+				return
+			}
+			d, err := sdk.Domain(args[0], args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(d)
+		},
+	},
+
+	{
+		Use:   "users <domain_id>  <token>",
+		Short: "List Domain users",
+		Long:  "List Domain users",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Use)
+				return
+			}
+			metadata, err := convertMetadata(Metadata)
+			if err != nil {
+				logError(err)
+				return
+			}
+			pageMetadata := mgxsdk.PageMetadata{
+				Offset:   Offset,
+				Limit:    Limit,
+				Metadata: metadata,
+				Status:   Status,
+			}
+
+			l, err := sdk.ListDomainUsers(args[0], pageMetadata, args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+			logJSON(l)
+		},
+	},
+
+	{
+		Use:   "update <domain_id> <JSON_string> <user_auth_token>",
+		Short: "Update domains",
+		Long: "Updates domains name, alias and metadata \n" +
+			"Usage:\n" +
+			"\tmagistrala-cli domains update <domain_id> '{\"name\":\"new name\", \"alias\":\"new_alias\", \"metadata\":{\"key\": \"value\"}}' $TOKEN \n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 4 && len(args) != 3 {
+				logUsage(cmd.Use)
+				return
+			}
+
+			var d mgxsdk.Domain
+
+			if err := json.Unmarshal([]byte(args[1]), &d); err != nil {
+				logError(err)
+				return
+			}
+			d.ID = args[0]
+			d, err := sdk.UpdateDomain(d, args[2])
+			if err != nil {
+				logError(err)
+				return
+			}
+			logJSON(d)
+		},
+	},
+
+	{
+		Use:   "enable <domain_id> <token>",
+		Short: "Change domain status to enabled",
+		Long: "Change domain status to enabled\n" +
+			"Usage:\n" +
+			"\tmagistrala-cli domains enable <domain_id> <token>\n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Use)
+				return
+			}
+
+			if err := sdk.EnableDomain(args[0], args[1]); err != nil {
+				logError(err)
+				return
+			}
+			logOK()
+		},
+	},
+	{
+		Use:   "disable <domain_id> <token>",
+		Short: "Change domain status to disabled",
+		Long: "Change domain status to disabled\n" +
+			"Usage:\n" +
+			"\tmagistrala-cli domains disable <domain_id> <token>\n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Use)
+				return
+			}
+
+			if err := sdk.DisableDomain(args[0], args[1]); err != nil {
+				logError(err)
+				return
+			}
+			logOK()
+		},
+	},
+
+	{
+		Use:   "assign user <relation> <user_ids> <domain_id> <token>",
+		Short: "Assign user",
+		Long: "Assign user to a domain\n" +
+			"Usage:\n" +
+			"\tmagistrala-cli groups assign user <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <domain_id> $TOKEN\n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 5 {
+				logUsage(cmd.Use)
+				return
+			}
+			var userIDs []string
+			if err := json.Unmarshal([]byte(args[2]), &userIDs); err != nil {
+				logError(err)
+				return
+			}
+			if err := sdk.AddUserToDomain(args[3], mgxsdk.UsersRelationRequest{Relation: args[1], UserIDs: userIDs}, args[4]); err != nil {
+				logError(err)
+				return
+			}
+			logOK()
+		},
+	},
+	{
+		Use:   "unassign user <relation> <user_ids> <domain_id> <token>",
+		Short: "Unassign user",
+		Long: "Unassign user from a domain\n" +
+			"Usage:\n" +
+			"\tmagistrala-cli groups unassign user <relation> '[\"<user_id_1>\", \"<user_id_2>\"]' <domain_id> $TOKEN\n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 5 {
+				logUsage(cmd.Use)
+				return
+			}
+			var userIDs []string
+			if err := json.Unmarshal([]byte(args[2]), &userIDs); err != nil {
+				logError(err)
+				return
+			}
+			if err := sdk.RemoveUserFromDomain(args[3], mgxsdk.UsersRelationRequest{Relation: args[1], UserIDs: userIDs}, args[4]); err != nil {
+				logError(err)
+				return
+			}
+			logOK()
+		},
+	},
+}
+
+// NewDomainsCmd returns domains command.
+func NewDomainsCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "domains [create | get | update | enable | disable | enable | users | assign | unassign]",
+		Short: "Domains management",
+		Long:  `Domains management: create, update, retrieve domains , assign/unassign users to domains and list users of domain"`,
+	}
+
+	for i := range cmdDomains {
+		cmd.AddCommand(&cmdDomains[i])
+	}
+
+	return &cmd
+}
@@ -140,7 +140,7 @@ var cmdProvision = []cobra.Command{
 			}

 			user.Credentials.Secret = "12345678"
-			ut, err := sdk.CreateToken(user)
+			ut, err := sdk.CreateToken(mgxsdk.Login{Identity: user.Credentials.Identity, Secret: user.Credentials.Secret})
 			if err != nil {
 				logError(err)
 				return
@@ -88,24 +88,26 @@ var cmdUsers = []cobra.Command{
 		},
 	},
 	{
-		Use:   "token <username> <password>",
+		Use:   "token <username> <password> [<domainID>]",
 		Short: "Get token",
 		Long: "Generate new token from username and password\n" +
 			"For example:\n" +
 			"\tmagistrala-cli users token user@example.com 12345678\n",
 		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) != 2 {
+			if len(args) != 3 && len(args) != 2 {
 				logUsage(cmd.Use)
 				return
 			}

-			user := mgxsdk.User{
-				Credentials: mgxsdk.Credentials{
-					Identity: args[0],
-					Secret:   args[1],
-				},
+			lg := mgxsdk.Login{
+				Identity: args[0],
+				Secret:   args[1],
 			}
-			token, err := sdk.CreateToken(user)
+			if len(args) == 3 {
+				lg.DomainID = args[2]
+			}
+
+			token, err := sdk.CreateToken(lg)
 			if err != nil {
 				logError(err)
 				return
@@ -115,18 +117,22 @@ var cmdUsers = []cobra.Command{
 		},
 	},
 	{
-		Use:   "refreshtoken <token>",
+		Use:   "refreshtoken <token> [<domainID>]",
 		Short: "Get token",
 		Long: "Generate new token from refresh token\n" +
 			"For example:\n" +
 			"\tmagistrala-cli users refreshtoken <refresh_token>\n",
 		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) != 1 {
+			if len(args) != 2 && len(args) != 1 {
 				logUsage(cmd.Use)
 				return
 			}

-			token, err := sdk.RefreshToken(args[0])
+			lg := mgxsdk.Login{}
+			if len(args) == 2 {
+				lg.DomainID = args[1]
+			}
+			token, err := sdk.RefreshToken(lg, args[0])
 			if err != nil {
 				logError(err)
 				return
@@ -351,13 +357,13 @@ var cmdUsers = []cobra.Command{
 				Limit:  Limit,
 			}

-			users, err := sdk.ListUserChannels(args[0], pm, args[1])
+			cp, err := sdk.ListUserChannels(args[0], pm, args[1])
 			if err != nil {
 				logError(err)
 				return
 			}

-			logJSON(users)
+			logJSON(cp)
 		},
 	},

@@ -378,15 +384,43 @@ var cmdUsers = []cobra.Command{
 				Limit:  Limit,
 			}

-			users, err := sdk.ListUserThings(args[0], pm, args[1])
+			tp, err := sdk.ListUserThings(args[0], pm, args[1])
 			if err != nil {
 				logError(err)
 				return
 			}

-			logJSON(users)
+			logJSON(tp)
 		},
 	},
+
+	{
+		Use:   "domains <user_id> <user_auth_token>",
+		Short: "List domains",
+		Long: "List user's domains\n" +
+			"Usage:\n" +
+			"\tmagistrala-cli users domains <user_id> <user_auth_token>\n",
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) != 2 {
+				logUsage(cmd.Use)
+				return
+			}
+
+			pm := mgxsdk.PageMetadata{
+				Offset: Offset,
+				Limit:  Limit,
+			}
+
+			dp, err := sdk.ListUserDomains(args[0], pm, args[1])
+			if err != nil {
+				logError(err)
+				return
+			}
+
+			logJSON(dp)
+		},
+	},
+
 	{
 		Use:   "groups <user_id> <user_auth_token>",
 		Short: "List groups",
@@ -18,6 +18,7 @@ const (
 	defUsersURL     string = defURL + ":9002"
 	defThingsURL    string = defURL + ":9000"
 	defBootstrapURL string = defURL + ":9013"
+	defDomainsURL   string = defURL + ":8189"
 	defCertsURL     string = defURL + ":9019"
 )

@@ -30,6 +31,7 @@ func main() {
 		HTTPAdapterURL:  fmt.Sprintf("%s/http", defURL),
 		BootstrapURL:    defBootstrapURL,
 		CertsURL:        defCertsURL,
+		DomainsURL:      defDomainsURL,
 		MsgContentType:  sdk.ContentType(msgContentType),
 		TLSVerification: false,
 		HostURL:         defURL,
@@ -53,6 +55,7 @@ func main() {
 	// API commands
 	healthCmd := cli.NewHealthCmd()
 	usersCmd := cli.NewUsersCmd()
+	domainsCmd := cli.NewDomainsCmd()
 	thingsCmd := cli.NewThingsCmd()
 	groupsCmd := cli.NewGroupsCmd()
 	channelsCmd := cli.NewChannelsCmd()
@@ -66,6 +69,7 @@ func main() {
 	// Root Commands
 	rootCmd.AddCommand(healthCmd)
 	rootCmd.AddCommand(usersCmd)
+	rootCmd.AddCommand(domainsCmd)
 	rootCmd.AddCommand(groupsCmd)
 	rootCmd.AddCommand(thingsCmd)
 	rootCmd.AddCommand(channelsCmd)
@@ -109,6 +113,14 @@ func main() {
 		"Users service URL",
 	)

+	rootCmd.PersistentFlags().StringVarP(
+		&sdkConf.DomainsURL,
+		"domains-url",
+		"d",
+		sdkConf.DomainsURL,
+		"Domains service URL",
+	)
+
 	rootCmd.PersistentFlags().StringVarP(
 		&sdkConf.HTTPAdapterURL,
 		"http-url",
@@ -0,0 +1,177 @@
+// Copyright (c) Magistrala
+// SPDX-License-Identifier: Apache-2.0
+
+package sdk
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/absmach/magistrala/pkg/errors"
+)
+
+const domainsEndpoint = "domains"
+
+// Domain represents magistrala domain.
+type Domain struct {
+	ID         string    `json:"id,omitempty"`
+	Name       string    `json:"name,omitempty"`
+	Metadata   Metadata  `json:"metadata,omitempty"`
+	Tags       []string  `json:"tags,omitempty"`
+	Alias      string    `json:"alias,omitempty"`
+	Status     string    `json:"status,omitempty"`
+	Permission string    `json:"permission,omitempty"`
+	CreatedBy  string    `json:"created_by,omitempty"`
+	CreatedAt  time.Time `json:"created_at,omitempty"`
+	UpdatedBy  string    `json:"updated_by,omitempty"`
+	UpdatedAt  time.Time `json:"updated_at,omitempty"`
+}
+
+func (sdk mgSDK) CreateDomain(domain Domain, token string) (Domain, errors.SDKError) {
+	data, err := json.Marshal(domain)
+	if err != nil {
+		return Domain{}, errors.NewSDKError(err)
+	}
+
+	url := fmt.Sprintf("%s/%s", sdk.domainsURL, domainsEndpoint)
+
+	_, body, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusOK)
+	if sdkerr != nil {
+		return Domain{}, sdkerr
+	}
+
+	var d Domain
+	if err := json.Unmarshal(body, &d); err != nil {
+		return Domain{}, errors.NewSDKError(err)
+	}
+	return d, nil
+}
+
+func (sdk mgSDK) UpdateDomain(domain Domain, token string) (Domain, errors.SDKError) {
+	data, err := json.Marshal(domain)
+	if err != nil {
+		return Domain{}, errors.NewSDKError(err)
+	}
+
+	url := fmt.Sprintf("%s/%s/%s", sdk.domainsURL, domainsEndpoint, domain.ID)
+
+	_, body, sdkerr := sdk.processRequest(http.MethodPatch, url, token, data, nil, http.StatusOK)
+	if sdkerr != nil {
+		return Domain{}, sdkerr
+	}
+
+	var d Domain
+	if err := json.Unmarshal(body, &d); err != nil {
+		return Domain{}, errors.NewSDKError(err)
+	}
+	return d, nil
+}
+
+func (sdk mgSDK) Domain(domainID, token string) (Domain, errors.SDKError) {
+	url := fmt.Sprintf("%s/%s/%s", sdk.domainsURL, domainsEndpoint, domainID)
+
+	_, body, sdkerr := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkerr != nil {
+		return Domain{}, sdkerr
+	}
+
+	var domain Domain
+	if err := json.Unmarshal(body, &domain); err != nil {
+		return Domain{}, errors.NewSDKError(err)
+	}
+
+	return domain, nil
+}
+
+func (sdk mgSDK) Domains(pm PageMetadata, token string) (DomainsPage, errors.SDKError) {
+	url, err := sdk.withQueryParams(sdk.domainsURL, domainsEndpoint, pm)
+	if err != nil {
+		return DomainsPage{}, errors.NewSDKError(err)
+	}
+
+	_, body, sdkerr := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkerr != nil {
+		return DomainsPage{}, sdkerr
+	}
+
+	var dp DomainsPage
+	if err := json.Unmarshal(body, &dp); err != nil {
+		return DomainsPage{}, errors.NewSDKError(err)
+	}
+
+	return dp, nil
+}
+
+func (sdk mgSDK) ListDomainUsers(domainID string, pm PageMetadata, token string) (UsersPage, errors.SDKError) {
+	url, err := sdk.withQueryParams(sdk.usersURL, fmt.Sprintf("%s/%s/%s", domainsEndpoint, domainID, usersEndpoint), pm)
+	if err != nil {
+		return UsersPage{}, errors.NewSDKError(err)
+	}
+	_, body, sdkerr := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkerr != nil {
+		return UsersPage{}, sdkerr
+	}
+	var up UsersPage
+	if err := json.Unmarshal(body, &up); err != nil {
+		return UsersPage{}, errors.NewSDKError(err)
+	}
+
+	return up, nil
+}
+
+func (sdk mgSDK) ListUserDomains(userID string, pm PageMetadata, token string) (DomainsPage, errors.SDKError) {
+	url, err := sdk.withQueryParams(sdk.domainsURL, fmt.Sprintf("%s/%s/%s", usersEndpoint, userID, domainsEndpoint), pm)
+	if err != nil {
+		return DomainsPage{}, errors.NewSDKError(err)
+	}
+	_, body, sdkerr := sdk.processRequest(http.MethodGet, url, token, nil, nil, http.StatusOK)
+	if sdkerr != nil {
+		return DomainsPage{}, sdkerr
+	}
+	var dp DomainsPage
+	if err := json.Unmarshal(body, &dp); err != nil {
+		return DomainsPage{}, errors.NewSDKError(err)
+	}
+
+	return dp, nil
+}
+
+func (sdk mgSDK) EnableDomain(domainID, token string) errors.SDKError {
+	return sdk.changeDomainStatus(token, domainID, enableEndpoint)
+}
+
+func (sdk mgSDK) DisableDomain(domainID, token string) errors.SDKError {
+	return sdk.changeDomainStatus(token, domainID, disableEndpoint)
+}
+
+func (sdk mgSDK) changeDomainStatus(token, id, status string) errors.SDKError {
+	url := fmt.Sprintf("%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, id, status)
+	_, _, sdkerr := sdk.processRequest(http.MethodPost, url, token, nil, nil, http.StatusOK)
+	return sdkerr
+}
+
+func (sdk mgSDK) AddUserToDomain(domainID string, req UsersRelationRequest, token string) errors.SDKError {
+	data, err := json.Marshal(req)
+	if err != nil {
+		return errors.NewSDKError(err)
+	}
+
+	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, domainID, usersEndpoint, assignEndpoint)
+
+	_, _, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusCreated)
+	return sdkerr
+}
+
+func (sdk mgSDK) RemoveUserFromDomain(domainID string, req UsersRelationRequest, token string) errors.SDKError {
+	data, err := json.Marshal(req)
+	if err != nil {
+		return errors.NewSDKError(err)
+	}
+
+	url := fmt.Sprintf("%s/%s/%s/%s/%s", sdk.domainsURL, domainsEndpoint, domainID, usersEndpoint, unassignEndpoint)
+
+	_, _, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusNoContent)
+	return sdkerr
+}
@@ -43,11 +43,6 @@ type Connection struct {
 	ChannelID string `json:"channel_id,omitempty"`
 }

-type tokenReq struct {
-	Identity string `json:"identity"`
-	Secret   string `json:"secret"`
-}
-
 type UsersRelationRequest struct {
 	Relation string   `json:"relation"`
 	UserIDs  []string `json:"user_ids"`
@@ -86,3 +86,8 @@ type SubscriptionPage struct {
 type identifyThingResp struct {
 	ID string `json:"id,omitempty"`
 }
+
+type DomainsPage struct {
+	Domains []Domain `json:"domains"`
+	pageRes
+}
@@ -230,22 +230,24 @@ type SDK interface {
 	// CreateToken receives credentials and returns user token.
 	//
 	// example:
-	//  user := sdk.User{
-	//    Credentials: sdk.Credentials{
+	//  lt := sdk.Login{
 	//      Identity: "john.doe@example",
 	//      Secret:   "12345678",
-	//    },
 	//  }
-	//  token, _ := sdk.CreateToken(user)
+	//  token, _ := sdk.CreateToken(lt)
 	//  fmt.Println(token)
-	CreateToken(user User) (Token, errors.SDKError)
+	CreateToken(lt Login) (Token, errors.SDKError)

 	// RefreshToken receives credentials and returns user token.
 	//
 	// example:
-	//  token, _ := sdk.RefreshToken("refresh_token")
+	//  lt := sdk.Login{
+	//      DomainID:   "domain_id",
+	//  }
+	// example:
+	//  token, _ := sdk.RefreshToken(lt,"refresh_token")
 	//  fmt.Println(token)
-	RefreshToken(token string) (Token, errors.SDKError)
+	RefreshToken(lt Login, token string) (Token, errors.SDKError)

 	// ListUserChannels list all channels belongs a particular user id.
 	//
@@ -537,8 +539,8 @@ type SDK interface {
 	//		Relation: "viewer", // available options: "owner", "admin", "editor", "viewer"
 	//  	UserIDs: ["user_id_1", "user_id_2", "user_id_3"]
 	// }
-	// group, _ := sdk.AddUserToGroup("groupID",req, "token")
-	// fmt.Println(group)
+	// err := sdk.AddUserToGroup("groupID",req, "token")
+	// fmt.Println(err)
 	AddUserToGroup(groupID string, req UsersRelationRequest, token string) errors.SDKError

 	// RemoveUserFromGroup remove user from a group.
@@ -548,8 +550,8 @@ type SDK interface {
 	//		Relation: "viewer", // available options: "owner", "admin", "editor", "viewer"
 	//  	UserIDs: ["user_id_1", "user_id_2", "user_id_3"]
 	// }
-	// group, _ := sdk.RemoveUserFromGroup("groupID",req, "token")
-	// fmt.Println(group)
+	// err := sdk.RemoveUserFromGroup("groupID",req, "token")
+	// fmt.Println(err)
 	RemoveUserFromGroup(groupID string, req UsersRelationRequest, token string) errors.SDKError

 	// ListGroupUsers list all users in the group id .
@@ -958,6 +960,113 @@ type SDK interface {
 	//  err := sdk.DeleteSubscription("id", "token")
 	//  fmt.Println(err)
 	DeleteSubscription(id, token string) errors.SDKError
+
+	// CreateDomain creates new domain and returns its details.
+	//
+	// example:
+	//  domain := sdk.Domain{
+	//    Name: "My Domain",
+	//    Metadata: sdk.Metadata{
+	//      "key": "value",
+	//    },
+	//  }
+	//  domain, _ := sdk.CreateDomain(group, "token")
+	//  fmt.Println(domain)
+	CreateDomain(d Domain, token string) (Domain, errors.SDKError)
+
+	// RetrieveDomain retrieve domain information of given domain ID .
+	//
+	// example:
+	//  domain, _ := sdk.Domain("domainID", "token")
+	//  fmt.Println(domain)
+	Domain(domainID, token string) (Domain, errors.SDKError)
+
+	// UpdateDomain updates details of the given domain ID.
+	//
+	// example:
+	//  domain := sdk.Domain{
+	//    ID : "domainID"
+	//    Name: "New Domain Name",
+	//    Metadata: sdk.Metadata{
+	//      "key": "value",
+	//    },
+	//  }
+	//  domain, _ := sdk.UpdateDomain(domain, "token")
+	//  fmt.Println(domain)
+	UpdateDomain(d Domain, token string) (Domain, errors.SDKError)
+
+	// Domains returns list of domain for the given filters.
+	//
+	// example:
+	//  pm := sdk.PageMetadata{
+	//    Offset: 0,
+	//    Limit:  10,
+	//    Name:   "My Domain",
+	//    Permission : "view"
+	//  }
+	//  domains, _ := sdk.Domains(pm, "token")
+	//  fmt.Println(domains)
+	Domains(pm PageMetadata, token string) (DomainsPage, errors.SDKError)
+
+	// ListDomainUsers returns list of users for the given domain ID and filters.
+	//
+	// example:
+	//  pm := sdk.PageMetadata{
+	//    Offset: 0,
+	//    Limit:  10,
+	//    Permission : "view"
+	//  }
+	//  users, _ := sdk.ListDomainUsers("domainID", pm, "token")
+	//  fmt.Println(users)
+	ListDomainUsers(domainID string, pm PageMetadata, token string) (UsersPage, errors.SDKError)
+
+	// ListUserDomains returns list of domains for the given user ID and filters.
+	//
+	// example:
+	//  pm := sdk.PageMetadata{
+	//    Offset: 0,
+	//    Limit:  10,
+	//    Permission : "view"
+	//  }
+	//  domains, _ := sdk.ListUserDomains("userID", pm, "token")
+	//  fmt.Println(domains)
+	ListUserDomains(userID string, pm PageMetadata, token string) (DomainsPage, errors.SDKError)
+
+	// EnableDomain changes the status of the domain to enabled.
+	//
+	// example:
+	//  err := sdk.EnableDomain("domainID", "token")
+	//  fmt.Println(err)
+	EnableDomain(domainID, token string) errors.SDKError
+
+	// DisableDomain changes the status of the domain to disabled.
+	//
+	// example:
+	//  err := sdk.DisableDomain("domainID", "token")
+	//  fmt.Println(err)
+	DisableDomain(domainID, token string) errors.SDKError
+
+	// AddUserToDomain adds a user to a domain.
+	//
+	// example:
+	// req := sdk.UsersRelationRequest{
+	//		Relation: "viewer", // available options: "owner", "admin", "editor", "viewer",  "member"
+	//  	UserIDs: ["user_id_1", "user_id_2", "user_id_3"]
+	// }
+	// err := sdk.AddUserToDomain("domainID", req, "token")
+	// fmt.Println(err)
+	AddUserToDomain(domainID string, req UsersRelationRequest, token string) errors.SDKError
+
+	// RemoveUserFromDomain removes a user from a domain.
+	//
+	// example:
+	// req := sdk.UsersRelationRequest{
+	//		Relation: "viewer", // available options: "owner", "admin", "editor", "viewer" , "member"
+	//  	UserIDs: ["user_id_1", "user_id_2", "user_id_3"]
+	// }
+	// err := sdk.RemoveUserFromDomain("domainID", req, "token")
+	// fmt.Println(err)
+	RemoveUserFromDomain(domainID string, req UsersRelationRequest, token string) errors.SDKError
 }

 type mgSDK struct {
@@ -967,6 +1076,7 @@ type mgSDK struct {
 	readerURL      string
 	thingsURL      string
 	usersURL       string
+	domainsURL     string
 	HostURL        string

 	msgContentType ContentType
@@ -981,6 +1091,7 @@ type Config struct {
 	ReaderURL      string
 	ThingsURL      string
 	UsersURL       string
+	DomainsURL     string
 	HostURL        string

 	MsgContentType  ContentType
@@ -996,6 +1107,7 @@ func NewSDK(conf Config) SDK {
 		readerURL:      conf.ReaderURL,
 		thingsURL:      conf.ThingsURL,
 		usersURL:       conf.UsersURL,
+		domainsURL:     conf.DomainsURL,
 		HostURL:        conf.HostURL,

 		msgContentType: conf.MsgContentType,
@@ -19,12 +19,14 @@ type Token struct {
 	AccessType   string `json:"access_type,omitempty"`
 }

-func (sdk mgSDK) CreateToken(user User) (Token, errors.SDKError) {
-	treq := tokenReq{
-		Identity: user.Credentials.Identity,
-		Secret:   user.Credentials.Secret,
-	}
-	data, err := json.Marshal(treq)
+type Login struct {
+	Identity string `json:"identity"`
+	Secret   string `json:"secret"`
+	DomainID string `json:"domain_id,omitempty"`
+}
+
+func (sdk mgSDK) CreateToken(lt Login) (Token, errors.SDKError) {
+	data, err := json.Marshal(lt)
 	if err != nil {
 		return Token{}, errors.NewSDKError(err)
 	}
@@ -43,10 +45,14 @@ func (sdk mgSDK) CreateToken(user User) (Token, errors.SDKError) {
 	return token, nil
 }

-func (sdk mgSDK) RefreshToken(token string) (Token, errors.SDKError) {
+func (sdk mgSDK) RefreshToken(lt Login, token string) (Token, errors.SDKError) {
+	data, err := json.Marshal(lt)
+	if err != nil {
+		return Token{}, errors.NewSDKError(err)
+	}
 	url := fmt.Sprintf("%s/%s/%s", sdk.usersURL, usersEndpoint, refreshTokenEndpoint)

-	_, body, sdkerr := sdk.processRequest(http.MethodPost, url, token, []byte{}, nil, http.StatusCreated)
+	_, body, sdkerr := sdk.processRequest(http.MethodPost, url, token, data, nil, http.StatusCreated)
 	if sdkerr != nil {
 		return Token{}, sdkerr
 	}
@@ -40,36 +40,31 @@ func TestIssueToken(t *testing.T) {

 	cases := []struct {
 		desc     string
-		client   sdk.User
+		login    sdk.Login
 		dbClient sdk.User
 		err      errors.SDKError
 	}{
 		{
 			desc:     "issue token for a new user",
-			client:   client,
+			login:    sdk.Login{Identity: client.Credentials.Identity, Secret: client.Credentials.Secret},
 			dbClient: rClient,
 			err:      nil,
 		},
 		{
-			desc:   "issue token for an empty user",
-			client: sdk.User{},
-			err:    errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingIdentity), http.StatusInternalServerError),
+			desc:  "issue token for an empty user",
+			login: sdk.Login{},
+			err:   errors.NewSDKErrorWithStatus(errors.Wrap(apiutil.ErrValidation, apiutil.ErrMissingIdentity), http.StatusInternalServerError),
 		},
 		{
-			desc: "issue token for invalid identity",
-			client: sdk.User{
-				Credentials: sdk.Credentials{
-					Identity: "invalid",
-					Secret:   "secret",
-				},
-			},
+			desc:     "issue token for invalid identity",
+			login:    sdk.Login{Identity: "invalid", Secret: "secret"},
 			dbClient: wrongClient,
 			err:      errors.NewSDKErrorWithStatus(errors.ErrAuthentication, http.StatusUnauthorized),
 		},
 	}
 	for _, tc := range cases {
 		repoCall := cRepo.On("RetrieveByIdentity", mock.Anything, mock.Anything).Return(convertClient(tc.dbClient), tc.err)
-		token, err := mgsdk.CreateToken(tc.client)
+		token, err := mgsdk.CreateToken(tc.login)
 		switch tc.err {
 		case nil:
 			assert.NotEmpty(t, token, fmt.Sprintf("%s: expected token, got empty", tc.desc))
@@ -126,7 +121,7 @@ func TestRefreshToken(t *testing.T) {
 	}
 	for _, tc := range cases {
 		repoCall := cRepo.On("RetrieveByID", mock.Anything, mock.Anything).Return(convertClient(user), tc.err)
-		_, err := mgsdk.RefreshToken(tc.token)
+		_, err := mgsdk.RefreshToken(sdk.Login{}, tc.token)
 		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected error %s, got %s", tc.desc, tc.err, err))
 		if tc.err == nil {
 			assert.NotEmpty(t, token, fmt.Sprintf("%s: expected token, got empty", tc.desc))
@@ -284,11 +284,9 @@ func (ps *provisionService) createTokenIfEmpty(token string) (string, error) {
 		return token, ErrMissingCredentials
 	}

-	u := sdk.User{
-		Credentials: sdk.Credentials{
-			Identity: ps.conf.Server.MgUser,
-			Secret:   ps.conf.Server.MgPass,
-		},
+	u := sdk.Login{
+		Identity: ps.conf.Server.MgUser,
+		Secret:   ps.conf.Server.MgPass,
 	}
 	tkn, err := ps.sdk.CreateToken(u)
 	if err != nil {
@@ -142,15 +142,11 @@ func createUser(s sdk.SDK, conf Config) (string, error) {
 		Status: sdk.EnabledStatus,
 	}

-	pass := user.Credentials.Secret
-
-	user, err := s.CreateUser(user, "")
-	if err != nil {
+	if _, err := s.CreateUser(user, ""); err != nil {
 		return "", fmt.Errorf("unable to create user: %w", err)
 	}

-	user.Credentials.Secret = pass
-	token, err := s.CreateToken(user)
+	token, err := s.CreateToken(sdk.Login{Identity: user.Credentials.Identity, Secret: user.Credentials.Secret})
 	if err != nil {
 		return "", fmt.Errorf("unable to login user: %w", err)
 	}
@@ -90,7 +90,7 @@ func Provision(conf Config) error {
 	var err error

 	// Login user
-	token, err := s.CreateToken(user)
+	token, err := s.CreateToken(sdk.Login{Identity: user.Credentials.Identity, Secret: user.Credentials.Secret})
 	if err != nil {
 		return fmt.Errorf("unable to login user: %s", err.Error())
 	}