Add team_user resource

docs/resources/team_user.md

@@ -0,0 +1,23 @@
+# Resource: konnect_team_user
+Represents a member of a team
+## Example usage
+```hcl
+resource "konnect_team" "Team" {
+  name = "Test"
+  description = "testing"
+}
+data "konnect_user" "User" {
+  search_full_name = "Joe"
+}
+resource "konnect_team_user" "example" {
+  team_id = konnect_team.Team.id
+  user_id = data.konnect_user.User.id
+}
+```
+## Argument Reference
+* `team_id` - **(Required, ForceNew, String)** The id of the team.
+* `user_id` - **(Required, ForceNew, String)** The id of the user.
+## Attribute Reference
+* `id` - **(String)** Same as `team_id`:`user_id`
+## Import
+Team users can be imported using a proper value of `id` as described above

konnect/client/client.go

@@ -16,6 +16,7 @@ const (
 	Bearer                 = "Bearer"
 	KonnectDomain          = "api.konghq.com"
 	GlobalRegion           = "global"
+	IdSeparator            = ":"
 	FilterName             = "filter[name]"
 	FilterNameContains     = "filter[name][contains]"
 	FilterFullName         = "filter[full_name]"

konnect/client/team_user.go

@@ -0,0 +1,23 @@
+package client
+
+import "strings"
+
+const (
+	TeamUserPath       = "teams/%s/users"
+	TeamUserPathCreate = TeamUserPath
+	TeamUserPathDelete = TeamUserPath + "/%s"
+)
+
+type TeamUser struct {
+	TeamId string `json:"-"`
+	UserId string `json:"id"`
+}
+
+func (tm *TeamUser) TeamUserEncodeId() string {
+	return tm.TeamId + IdSeparator + tm.UserId
+}
+
+func TeamUserDecodeId(s string) (string, string) {
+	tokens := strings.Split(s, IdSeparator)
+	return tokens[0], tokens[1]
+}

konnect/provider.go

@@ -27,6 +27,7 @@ func Provider() *schema.Provider {
 			"konnect_identity_provider":      resourceIdentityProvider(),
 			"konnect_user":                   resourceUser(),
 			"konnect_team":                   resourceTeam(),
+			"konnect_team_user":              resourceTeamUser(),
 		},
 		DataSourcesMap: map[string]*schema.Resource{
 			"konnect_runtime_group": dataSourceRuntimeGroup(),

konnect/resource_team_user.go

@@ -0,0 +1,120 @@
+package konnect
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/go-http-utils/headers"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/scastria/terraform-provider-konnect/konnect/client"
+	"net/http"
+)
+
+func resourceTeamUser() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceTeamUserCreate,
+		ReadContext:   resourceTeamUserRead,
+		DeleteContext: resourceTeamUserDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		Schema: map[string]*schema.Schema{
+			"team_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"user_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func fillTeamUser(c *client.TeamUser, d *schema.ResourceData) {
+	c.TeamId = d.Get("team_id").(string)
+	c.UserId = d.Get("user_id").(string)
+}
+
+func fillResourceDataFromTeamUser(c *client.TeamUser, d *schema.ResourceData) {
+	d.Set("team_id", c.TeamId)
+	d.Set("user_id", c.UserId)
+}
+
+func resourceTeamUserCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	var diags diag.Diagnostics
+	c := m.(*client.Client)
+	buf := bytes.Buffer{}
+	newTeamUser := client.TeamUser{}
+	fillTeamUser(&newTeamUser, d)
+	err := json.NewEncoder(&buf).Encode(newTeamUser)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	requestPath := fmt.Sprintf(client.TeamUserPathCreate, newTeamUser.TeamId)
+	requestHeaders := http.Header{
+		headers.ContentType: []string{client.ApplicationJson},
+	}
+	_, err = c.HttpRequest(ctx, false, http.MethodPost, requestPath, nil, requestHeaders, &buf)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	d.SetId(newTeamUser.TeamUserEncodeId())
+	return diags
+}
+
+func resourceTeamUserRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	var diags diag.Diagnostics
+	teamId, userId := client.TeamUserDecodeId(d.Id())
+	c := m.(*client.Client)
+	requestPath := fmt.Sprintf(client.TeamUserPath, teamId)
+	body, err := c.HttpRequest(ctx, false, http.MethodGet, requestPath, nil, nil, &bytes.Buffer{})
+	if err != nil {
+		d.SetId("")
+		re := err.(*client.RequestError)
+		if re.StatusCode == http.StatusNotFound {
+			return diags
+		}
+		return diag.FromErr(err)
+	}
+	retVal := &client.UserCollection{}
+	err = json.NewDecoder(body).Decode(retVal)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	//Search users looking for userId
+	foundUser := false
+	for _, u := range retVal.Users {
+		if u.Id == userId {
+			foundUser = true
+			break
+		}
+	}
+	if !foundUser {
+		d.SetId("")
+		return diags
+	}
+	d.Set("team_id", teamId)
+	d.Set("user_id", userId)
+	return diags
+}
+
+func resourceTeamUserDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	var diags diag.Diagnostics
+	teamId, userId := client.TeamUserDecodeId(d.Id())
+	c := m.(*client.Client)
+	requestPath := fmt.Sprintf(client.TeamUserPathDelete, teamId, userId)
+	_, err := c.HttpRequest(ctx, false, http.MethodDelete, requestPath, nil, nil, &bytes.Buffer{})
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	d.SetId("")
+	return diags
+}

test/main.tf

@@ -9,10 +9,10 @@ terraform {
 provider "konnect" {
 }
 
-#resource "konnect_team" "T" {
-#  name = "ShawnTest"
-#  description = "testing"
-#}
+resource "konnect_team" "T" {
+  name = "ShawnTest"
+  description = "testing"
+}
 
 #data "konnect_team" "T" {
 #  search_name = "eve"
@@ -24,9 +24,14 @@ provider "konnect" {
 #  preferred_name = "Joe"
 #}
 
-#data "konnect_user" "U" {
-#  full_name = "Joe Blow"
-#}
+data "konnect_user" "U" {
+  search_full_name = "Julia"
+}
+
+resource "konnect_team_user" "TU" {
+  team_id = konnect_team.T.id
+  user_id = data.konnect_user.U.id
+}
 
 #resource "konnect_identity_provider" "IP" {
 #  issuer = "https://greenst.okta.com/oauth2/default"