github.com/cloudfoundry-community/cloudfoundry-cli@v6.44.1-0.20240130060226-cda5ed8e89a5+incompatible/api/cloudcontroller/ccv2/user.go (about)

     1  package ccv2
     2  
     3  import (
     4  	"bytes"
     5  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccerror"
     6  	"encoding/json"
     7  
     8  	"code.cloudfoundry.org/cli/api/cloudcontroller"
     9  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv2/internal"
    10  )
    11  
    12  // User represents a Cloud Controller User.
    13  type User struct {
    14  	// GUID is the unique user identifier.
    15  	GUID string
    16  
    17  	// Username of the user
    18  	Username string
    19  }
    20  
    21  // UnmarshalJSON helps unmarshal a Cloud Controller User response.
    22  func (user *User) UnmarshalJSON(data []byte) error {
    23  	var ccUser struct {
    24  		Metadata internal.Metadata `json:"metadata"`
    25  		Entity   struct {
    26  			Username string `json:"username"`
    27  		} `json:"entity"`
    28  	}
    29  	err := cloudcontroller.DecodeJSON(data, &ccUser)
    30  	if err != nil {
    31  		return err
    32  	}
    33  
    34  	user.GUID = ccUser.Metadata.GUID
    35  	user.Username = ccUser.Entity.Username
    36  	return nil
    37  }
    38  
    39  // CreateUser creates a new Cloud Controller User from the provided UAA user
    40  // ID.
    41  func (client *Client) CreateUser(uaaUserID string) (User, Warnings, error) {
    42  	type userRequestBody struct {
    43  		GUID string `json:"guid"`
    44  	}
    45  
    46  	bodyBytes, err := json.Marshal(userRequestBody{
    47  		GUID: uaaUserID,
    48  	})
    49  	if err != nil {
    50  		return User{}, nil, err
    51  	}
    52  
    53  	request, err := client.newHTTPRequest(requestOptions{
    54  		RequestName: internal.PostUserRequest,
    55  		Body:        bytes.NewReader(bodyBytes),
    56  	})
    57  	if err != nil {
    58  		return User{}, nil, err
    59  	}
    60  
    61  	var user User
    62  	response := cloudcontroller.Response{
    63  		DecodeJSONResponseInto: &user,
    64  	}
    65  
    66  	err = client.connection.Make(request, &response)
    67  	if err != nil {
    68  		return User{}, response.Warnings, err
    69  	}
    70  
    71  	return user, response.Warnings, nil
    72  }
    73  
    74  // GetUserOrganizations get all organizations available to user
    75  func (client *Client) GetUserOrganizations(uaaUserID string, filters ...Filter) ([]Organization, Warnings, error) {
    76  	allQueries := ConvertFilterParameters(filters)
    77  	allQueries.Add("order-by", "name")
    78  	request, err := client.newHTTPRequest(requestOptions{
    79  		RequestName: internal.GetUserOrganizationsRequest,
    80  		URIParams:   Params{"user_guid": uaaUserID},
    81  		Query:       allQueries,
    82  	})
    83  	if err != nil {
    84  		return []Organization{}, nil, err
    85  	}
    86  
    87  	var fullOrgsList []Organization
    88  	warnings, err := client.paginate(request, Organization{}, func(item interface{}) error {
    89  		if org, ok := item.(Organization); ok {
    90  			fullOrgsList = append(fullOrgsList, org)
    91  		} else {
    92  			return ccerror.UnknownObjectInListError{
    93  				Expected:   Organization{},
    94  				Unexpected: item,
    95  			}
    96  		}
    97  		return nil
    98  	})
    99  
   100  	return fullOrgsList, warnings, err
   101  }
   102  
   103  // GetUserSpaces get all spaces available to user
   104  func (client *Client) GetUserSpaces(uaaUserID string, filters ...Filter) ([]Space, Warnings, error) {
   105  	allQueries := ConvertFilterParameters(filters)
   106  	allQueries.Add("order-by", "name")
   107  	request, err := client.newHTTPRequest(requestOptions{
   108  		RequestName: internal.GetUserSpacesRequest,
   109  		URIParams:   Params{"user_guid": uaaUserID},
   110  		Query:       allQueries,
   111  	})
   112  	if err != nil {
   113  		return []Space{}, nil, err
   114  	}
   115  
   116  	var fullSpacesList []Space
   117  	warnings, err := client.paginate(request, Space{}, func(item interface{}) error {
   118  		if org, ok := item.(Space); ok {
   119  			fullSpacesList = append(fullSpacesList, org)
   120  		} else {
   121  			return ccerror.UnknownObjectInListError{
   122  				Expected:   Space{},
   123  				Unexpected: item,
   124  			}
   125  		}
   126  		return nil
   127  	})
   128  
   129  	return fullSpacesList, warnings, err
   130  }
   131  
   132  // GetUsers returns back a list of User based off of the
   133  // provided filters.
   134  func (client *Client) GetUsers(filters ...Filter) ([]User, Warnings, error) {
   135  	allQueries := ConvertFilterParameters(filters)
   136  	request, err := client.newHTTPRequest(requestOptions{
   137  		RequestName: internal.GetUsersRequest,
   138  		Query:       allQueries,
   139  	})
   140  
   141  	if err != nil {
   142  		return nil, nil, err
   143  	}
   144  
   145  	var fullUsersList []User
   146  	warnings, err := client.paginate(request, User{}, func(item interface{}) error {
   147  		if user, ok := item.(User); ok {
   148  			fullUsersList = append(fullUsersList, user)
   149  		} else {
   150  			return ccerror.UnknownObjectInListError{
   151  				Expected:   User{},
   152  				Unexpected: item,
   153  			}
   154  		}
   155  		return nil
   156  	})
   157  
   158  	return fullUsersList, warnings, err
   159  }