diff --git a/cli/domains.go b/cli/domains.go new file mode 100644 index 000000000..641f33bb3 --- /dev/null +++ b/cli/domains.go @@ -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 ", + 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 | ] ", + 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 ", + 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 ", + Short: "Update domains", + Long: "Updates domains name, alias and metadata \n" + + "Usage:\n" + + "\tmagistrala-cli domains update '{\"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 ", + Short: "Change domain status to enabled", + Long: "Change domain status to enabled\n" + + "Usage:\n" + + "\tmagistrala-cli domains enable \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 ", + Short: "Change domain status to disabled", + Long: "Change domain status to disabled\n" + + "Usage:\n" + + "\tmagistrala-cli domains disable \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 ", + Short: "Assign user", + Long: "Assign user to a domain\n" + + "Usage:\n" + + "\tmagistrala-cli groups assign user '[\"\", \"\"]' $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 ", + Short: "Unassign user", + Long: "Unassign user from a domain\n" + + "Usage:\n" + + "\tmagistrala-cli groups unassign user '[\"\", \"\"]' $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 +} diff --git a/cli/provision.go b/cli/provision.go index 00c9d492e..8aff4016d 100644 --- a/cli/provision.go +++ b/cli/provision.go @@ -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 diff --git a/cli/users.go b/cli/users.go index eac2dbe21..bbf095b57 100644 --- a/cli/users.go +++ b/cli/users.go @@ -88,24 +88,26 @@ var cmdUsers = []cobra.Command{ }, }, { - Use: "token ", + Use: "token []", 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 ", + Use: "refreshtoken []", Short: "Get token", Long: "Generate new token from refresh token\n" + "For example:\n" + "\tmagistrala-cli users refreshtoken \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 ", + Short: "List domains", + Long: "List user's domains\n" + + "Usage:\n" + + "\tmagistrala-cli users domains \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 ", Short: "List groups", diff --git a/cmd/cli/main.go b/cmd/cli/main.go index 348ca6d4c..8cdd93647 100644 --- a/cmd/cli/main.go +++ b/cmd/cli/main.go @@ -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", diff --git a/pkg/sdk/go/domains.go b/pkg/sdk/go/domains.go new file mode 100644 index 000000000..fe941a175 --- /dev/null +++ b/pkg/sdk/go/domains.go @@ -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 +} diff --git a/pkg/sdk/go/requests.go b/pkg/sdk/go/requests.go index 6cd714b84..9092b5a90 100644 --- a/pkg/sdk/go/requests.go +++ b/pkg/sdk/go/requests.go @@ -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"` diff --git a/pkg/sdk/go/responses.go b/pkg/sdk/go/responses.go index 63d2f095c..614ec084a 100644 --- a/pkg/sdk/go/responses.go +++ b/pkg/sdk/go/responses.go @@ -86,3 +86,8 @@ type SubscriptionPage struct { type identifyThingResp struct { ID string `json:"id,omitempty"` } + +type DomainsPage struct { + Domains []Domain `json:"domains"` + pageRes +} diff --git a/pkg/sdk/go/sdk.go b/pkg/sdk/go/sdk.go index cbcc64188..5747bab36 100644 --- a/pkg/sdk/go/sdk.go +++ b/pkg/sdk/go/sdk.go @@ -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, diff --git a/pkg/sdk/go/tokens.go b/pkg/sdk/go/tokens.go index 634f71794..5bf045d42 100644 --- a/pkg/sdk/go/tokens.go +++ b/pkg/sdk/go/tokens.go @@ -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 } diff --git a/pkg/sdk/go/tokens_test.go b/pkg/sdk/go/tokens_test.go index c1a104a6c..4dd2874c2 100644 --- a/pkg/sdk/go/tokens_test.go +++ b/pkg/sdk/go/tokens_test.go @@ -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)) diff --git a/provision/service.go b/provision/service.go index be810551a..faadc5569 100644 --- a/provision/service.go +++ b/provision/service.go @@ -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 { diff --git a/tools/e2e/e2e.go b/tools/e2e/e2e.go index d94293b3d..dc816e689 100644 --- a/tools/e2e/e2e.go +++ b/tools/e2e/e2e.go @@ -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) } diff --git a/tools/provision/provision.go b/tools/provision/provision.go index b1220db05..c05e743c2 100644 --- a/tools/provision/provision.go +++ b/tools/provision/provision.go @@ -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()) }