Merge pull request #14 from bugout-dev/brood-resources

find user and main endpoints for Brood resources

Author: kompotkot

cmd/bugout/brood/command.go

@@ -10,11 +10,12 @@ import (
 
 func PopulateBroodCommands(cmd *cobra.Command) {
 	groupsCmd := CreateGroupsCommand()
+	resourcesCmd := GenerateResourcesCommand()
 	pingCmd := CreatePingCommand()
 	userCmd := CreateUserCommand()
 	versionCmd := CreateVersionCommand()
 
-	cmd.AddCommand(groupsCmd, pingCmd, userCmd, versionCmd)
+	cmd.AddCommand(groupsCmd, resourcesCmd, pingCmd, userCmd, versionCmd)
 }
 
 func CreatePingCommand() *cobra.Command {

cmd/bugout/brood/resources.go

@@ -0,0 +1,121 @@
+package broodcmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bugout-dev/bugout-go/cmd/bugout/cmdutils"
+	bugout "github.com/bugout-dev/bugout-go/pkg"
+)
+
+func GenerateResourcesCommand() *cobra.Command {
+	resourcesCmd := &cobra.Command{
+		Use:   "resources",
+		Short: "Bugout resources operations",
+	}
+
+	resourcesCreateCmd := GenerateResourceCreateCommand()
+	resourcesDeleteCmd := GenerateResourceDeleteCommand()
+	resourcesGetCmd := GenerateResourcesGetCommand()
+
+	resourcesCmd.AddCommand(resourcesCreateCmd, resourcesDeleteCmd, resourcesGetCmd)
+
+	return resourcesCmd
+}
+
+func GenerateResourceCreateCommand() *cobra.Command {
+	var token, applicationId string
+	resourceCreateCmd := &cobra.Command{
+		Use:     "create [resource]",
+		Short:   "Create new resource",
+		PreRunE: cmdutils.TokenArgPopulator,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if len(args) != 1 {
+				return fmt.Errorf("One resource argument as json string must be specified")
+			}
+			var resourceRaw interface{}
+			err := json.Unmarshal([]byte(args[0]), &resourceRaw)
+			if err != nil {
+				return err
+			}
+
+			client, clientErr := bugout.ClientFromEnv()
+			if clientErr != nil {
+				return clientErr
+			}
+
+			resource, err := client.Brood.CreateResource(token, applicationId, resourceRaw)
+			if err != nil {
+				return err
+			}
+
+			encodeErr := json.NewEncoder(cmd.OutOrStdout()).Encode(&resource)
+			return encodeErr
+		},
+	}
+
+	resourceCreateCmd.Flags().StringVarP(&token, "token", "t", "", "Bugout access token to use for the request")
+	resourceCreateCmd.Flags().StringVarP(&applicationId, "application_id", "a", "", "Application ID resource belongs to")
+
+	return resourceCreateCmd
+}
+
+func GenerateResourceDeleteCommand() *cobra.Command {
+	var token, resourceId string
+	resourceDeleteCmd := &cobra.Command{
+		Use:     "delete",
+		Short:   "Delete resource",
+		PreRunE: cmdutils.TokenArgPopulator,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			client, clientErr := bugout.ClientFromEnv()
+			if clientErr != nil {
+				return clientErr
+			}
+
+			resource, err := client.Brood.DeleteResource(token, resourceId)
+			if err != nil {
+				return nil
+			}
+
+			encodeErr := json.NewEncoder(cmd.OutOrStdout()).Encode(&resource)
+			return encodeErr
+		},
+	}
+
+	resourceDeleteCmd.Flags().StringVarP(&token, "token", "t", "", "Bugout access token to use for the request")
+	resourceDeleteCmd.Flags().StringVarP(&resourceId, "resource_id", "r", "", "Resource ID")
+
+	return resourceDeleteCmd
+}
+
+func GenerateResourcesGetCommand() *cobra.Command {
+	var token, applicationId string
+	var queryParams map[string]string
+	resourcesGetCmd := &cobra.Command{
+		Use:     "get",
+		Short:   "Get resources of application",
+		PreRunE: cmdutils.TokenArgPopulator,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			client, clientErr := bugout.ClientFromEnv()
+			if clientErr != nil {
+				return clientErr
+			}
+
+			resources, err := client.Brood.GetResources(token, applicationId, queryParams)
+			if err != nil {
+				return nil
+			}
+
+			encodeErr := json.NewEncoder(cmd.OutOrStdout()).Encode(&resources)
+			return encodeErr
+		},
+	}
+
+	resourcesGetCmd.Flags().StringVarP(&token, "token", "t", "", "Bugout access token to use for the request")
+	resourcesGetCmd.Flags().StringVarP(&applicationId, "application_id", "a", "", "Application ID resource belongs to")
+	resourcesGetCmd.Flags().StringToStringVarP(&queryParams, "params", "p", nil, "Optional query parameters to filter resources")
+
+	return resourcesGetCmd
+}

cmd/bugout/brood/user.go

@@ -2,6 +2,7 @@ package broodcmd
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -20,10 +21,11 @@ func CreateUserCommand() *cobra.Command {
 	userLoginCmd := CreateUserLoginCommand()
 	userTokensCmd := CreateUserTokensCommand()
 	userGetCmd := CreateUserGetCommand()
+	userFindCmd := CreateUserFindCommand()
 	userVerifyCmd := CreateUserVerifyCommand()
 	userChangePasswordCmd := CreateUserChangePasswordCommand()
 
-	userCmd.AddCommand(userCreateCmd, userLoginCmd, userTokensCmd, userGetCmd, userVerifyCmd, userChangePasswordCmd)
+	userCmd.AddCommand(userCreateCmd, userLoginCmd, userTokensCmd, userGetCmd, userFindCmd, userVerifyCmd, userChangePasswordCmd)
 
 	return userCmd
 }
@@ -155,6 +157,58 @@ func CreateUserGetCommand() *cobra.Command {
 	return userGetCmd
 }
 
+func CreateUserFindCommand() *cobra.Command {
+	var token, user_id, username, email, application_id string
+	userFindCmd := &cobra.Command{
+		Use:   "find",
+		Short: "Find user if exists",
+		Args: func(cmd *cobra.Command, args []string) error {
+			if user_id == "" && username == "" && email == "" && application_id == "" {
+				return errors.New("Exactly one of --user_id or --username or --email or application_id must be specified")
+			}
+
+			return nil
+		},
+		PreRunE: cmdutils.TokenArgPopulator,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			client, err := bugout.ClientFromEnv()
+			if err != nil {
+				return err
+			}
+
+			queryParams := make(map[string]string)
+			if user_id != "" {
+				queryParams["user_id"] = user_id
+			}
+			if username != "" {
+				queryParams["username"] = username
+			}
+			if email != "" {
+				queryParams["email"] = email
+			}
+			if application_id != "" {
+				queryParams["application_id"] = application_id
+			}
+
+			user, err := client.Brood.FindUser(token, queryParams)
+			if err != nil {
+				return err
+			}
+
+			encodeErr := json.NewEncoder(cmd.OutOrStdout()).Encode(&user)
+			return encodeErr
+		},
+	}
+
+	userFindCmd.Flags().StringVarP(&token, "token", "t", "", "Bugout access token to use for the request")
+	userFindCmd.Flags().StringVarP(&user_id, "user_id", "i", "", "Bugout user ID")
+	userFindCmd.Flags().StringVarP(&username, "username", "u", "", "User name")
+	userFindCmd.Flags().StringVarP(&email, "email", "e", "", "User email address")
+	userFindCmd.Flags().StringVarP(&application_id, "application_id", "a", "", "Application user belongs to")
+
+	return userFindCmd
+}
+
 func CreateUserVerifyCommand() *cobra.Command {
 	var token, code string
 	userVerifyCmd := &cobra.Command{

pkg/brood/client.go

@@ -22,6 +22,7 @@ type BroodCaller interface {
 	GenerateToken(string, string) (string, error)
 	AnnotateToken(token, tokenType, note string) (string, error)
 	ListTokens(token string) (UserTokensList, error)
+	FindUser(token string, queryParameters map[string]string) (User, error)
 	GetUser(token string) (User, error)
 	VerifyUser(token, code string) (User, error)
 	ChangePassword(token, currentPassword, newPassword string) (User, error)
@@ -31,12 +32,16 @@ type BroodCaller interface {
 	RenameGroup(token, groupID, name string) (Group, error)
 	AddUserToGroup(token, groupID, username, role string) (UserGroup, error)
 	RemoveUserFromGroup(token, groupID, username string) (UserGroup, error)
+	CreateResource(token, applicationId string, resourceData interface{}) (Resource, error)
+	GetResources(token, applicationId string, queryParameters map[string]string) (Resources, error)
+	DeleteResource(token, resourceId string) (Resource, error)
 }
 
 type BroodRoutes struct {
 	Ping                string
 	Version             string
 	User                string
+	FindUser            string
 	Groups              string
 	Token               string
 	RevokeToken         string
@@ -45,6 +50,7 @@ type BroodRoutes struct {
 	ChangePassword      string
 	RequestReset        string
 	ConfirmReset        string
+	Resources           string
 }
 
 func RoutesFromURL(broodURL string) BroodRoutes {
@@ -54,13 +60,15 @@ func RoutesFromURL(broodURL string) BroodRoutes {
 		Ping:                fmt.Sprintf("%s/ping", cleanURL),
 		Version:             fmt.Sprintf("%s/version", cleanURL),
 		User:                fmt.Sprintf("%s/user", cleanURL),
+		FindUser:            fmt.Sprintf("%s/user/find", cleanURL),
 		Groups:              fmt.Sprintf("%s/groups", cleanURL),
 		Token:               fmt.Sprintf("%s/token", cleanURL),
 		ListTokens:          fmt.Sprintf("%s/tokens", cleanURL),
 		ConfirmRegistration: fmt.Sprintf("%s/confirm", cleanURL),
 		ChangePassword:      fmt.Sprintf("%s/profile/password", cleanURL),
 		RequestReset:        fmt.Sprintf("%s/reset", cleanURL),
 		ConfirmReset:        fmt.Sprintf("%s/reset_password", cleanURL),
+		Resources:           fmt.Sprintf("%s/resources", cleanURL),
 	}
 }
 

pkg/brood/data.go

@@ -47,3 +47,19 @@ type UserGroup struct {
 type UserGroupsList struct {
 	Groups []UserGroup `json:"groups"`
 }
+
+// Resources
+type Resource struct {
+	Id            string      `json:"id"`
+	ApplicationId string      `json:"application_id"`
+	ResourceData  interface{} `json:"resource_data"`
+}
+
+type Resources struct {
+	Resources []Resource `json:"resources"`
+}
+
+type resourceCreateRequest struct {
+	ApplicationId string      `json:"application_id"`
+	ResourceData  interface{} `json:"resource_data"`
+}

pkg/brood/resources.go

@@ -0,0 +1,103 @@
+package brood
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/bugout-dev/bugout-go/pkg/utils"
+)
+
+func (client BroodClient) CreateResource(token, applicationId string, resourceData interface{}) (Resource, error) {
+	resourcesRoute := client.Routes.Resources
+	requestBody := resourceCreateRequest{
+		ApplicationId: applicationId,
+		ResourceData:  resourceData,
+	}
+	requestBuffer := new(bytes.Buffer)
+	encodeErr := json.NewEncoder(requestBuffer).Encode(requestBody)
+	if encodeErr != nil {
+		return Resource{}, encodeErr
+	}
+	request, requestErr := http.NewRequest("POST", resourcesRoute, requestBuffer)
+	if requestErr != nil {
+		return Resource{}, requestErr
+	}
+	request.Header.Add("Content-Type", "application/json")
+	request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", token))
+	request.Header.Add("Accept", "application/json")
+
+	response, responseErr := client.HTTPClient.Do(request)
+	if responseErr != nil {
+		return Resource{}, responseErr
+	}
+	defer response.Body.Close()
+
+	statusErr := utils.HTTPStatusCheck(response)
+	if statusErr != nil {
+		return Resource{}, statusErr
+	}
+
+	var resource Resource
+	decodeErr := json.NewDecoder(response.Body).Decode(&resource)
+	return resource, decodeErr
+}
+
+func (client BroodClient) GetResources(token, applicationId string, queryParameters map[string]string) (Resources, error) {
+	resourcesRoute := client.Routes.Resources
+	request, requestErr := http.NewRequest("GET", resourcesRoute, nil)
+	if requestErr != nil {
+		return Resources{}, requestErr
+	}
+	request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", token))
+	request.Header.Add("Accept", "application/json")
+
+	query := request.URL.Query()
+	query.Add("application_id", applicationId)
+	for k, v := range queryParameters {
+		query.Add(k, v)
+	}
+	request.URL.RawQuery = query.Encode()
+
+	response, responseErr := client.HTTPClient.Do(request)
+	if responseErr != nil {
+		return Resources{}, responseErr
+	}
+	defer response.Body.Close()
+
+	statusErr := utils.HTTPStatusCheck(response)
+	if statusErr != nil {
+		return Resources{}, statusErr
+	}
+
+	var resources Resources
+	decodeErr := json.NewDecoder(response.Body).Decode(&resources)
+	return resources, decodeErr
+}
+
+func (client BroodClient) DeleteResource(token, resourceId string) (Resource, error) {
+	resourcesRoute := fmt.Sprintf("%s/%s", client.Routes.Resources, resourceId)
+	request, requestErr := http.NewRequest("DELETE", resourcesRoute, nil)
+	if requestErr != nil {
+		return Resource{}, requestErr
+	}
+	request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", token))
+	request.Header.Add("Accept", "application/json")
+
+	response, responseErr := client.HTTPClient.Do(request)
+	if responseErr != nil {
+		return Resource{}, responseErr
+	}
+	defer response.Body.Close()
+
+	statusErr := utils.HTTPStatusCheck(response)
+	if statusErr != nil {
+		return Resource{}, statusErr
+	}
+
+	var resource Resource
+	decodeErr := json.NewDecoder(response.Body).Decode(&resource)
+
+	return resource, decodeErr
+}