Add basic email template resource

examples/okta_template_email/README.md

@@ -0,0 +1,6 @@
+# okta_template_email
+
+
+Represents an Okta Email Template. [See Okta documentation for more details](https://developer.okta.com/docs/api/resources/templates).
+
+* Example of an email template with translations [can be found here](./basic.tf)

examples/okta_template_email/basic.tf

@@ -0,0 +1,15 @@
+resource okta_template_email test {
+  type = "email.forgotPassword"
+
+  translations {
+    language = "en"
+    subject  = "Stuff"
+    template = "Hi $${user.firstName}"
+  }
+
+  translations {
+    language = "es"
+    subject  = "Cosas"
+    template = "Hola $${user.firstName}"
+  }
+}

okta/provider.go

@@ -42,6 +42,7 @@ const (
 	policyRulePassword     = "okta_policy_rule_password"
 	policyRuleSignOn       = "okta_policy_rule_signon"
 	policySignOn           = "okta_policy_signon"
+	templateEmail          = "okta_template_email"
 	trustedOrigin          = "okta_trusted_origin"
 	userBaseSchema         = "okta_user_base_schema"
 	userSchema             = "okta_user_schema"
@@ -136,6 +137,7 @@ func Provider() terraform.ResourceProvider {
 			policyRulePassword:     resourcePolicyPasswordRule(),
 			policyRuleSignOn:       resourcePolicySignonRule(),
 			policySignOn:           resourcePolicySignon(),
+			templateEmail:          resourceTemplateEmail(),
 			trustedOrigin:          resourceTrustedOrigin(),
 			userSchema:             resourceUserSchema(),
 

okta/resource_template_email.go

@@ -0,0 +1,123 @@
+package okta
+
+import (
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+var translationResource = &schema.Resource{
+	Schema: map[string]*schema.Schema{
+		"language": &schema.Schema{
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"subject": &schema.Schema{
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"template": &schema.Schema{
+			Type:     schema.TypeString,
+			Required: true,
+		},
+	},
+}
+
+func resourceTemplateEmail() *schema.Resource {
+	return &schema.Resource{
+		// No point in having an exist function since templates always exist
+		Create: resourceTemplateEmailCreate,
+		Read:   resourceTemplateEmailRead,
+		Update: resourceTemplateEmailUpdate,
+		Delete: resourceTemplateEmailDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+		Schema: map[string]*schema.Schema{
+			"type": &schema.Schema{
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "Email template type",
+			},
+			"translations": &schema.Schema{
+				Type:     schema.TypeSet,
+				Required: true,
+				Elem:     translationResource,
+			},
+		},
+	}
+}
+
+func buildEmailTemplate(d *schema.ResourceData) *EmailTemplate {
+	trans := map[string]*EmailTranslation{}
+	rawTransList := d.Get("translations").(*schema.Set)
+
+	for _, val := range rawTransList.List() {
+		rawTrans := val.(map[string]interface{})
+		trans[rawTrans["language"].(string)] = &EmailTranslation{
+			Subject:  rawTrans["subject"].(string),
+			Template: rawTrans["template"].(string),
+		}
+	}
+
+	return &EmailTemplate{
+		Name:         "Custom",
+		Type:         d.Get("type").(string),
+		Translations: trans,
+	}
+}
+
+func flattenEmailTranlations(temp map[string]*EmailTranslation) *schema.Set {
+	rawSet := []interface{}{}
+
+	for key, val := range temp {
+		rawSet = append(rawSet, map[string]interface{}{
+			"language": key,
+			"subject":  val.Subject,
+			"template": val.Template,
+		})
+	}
+
+	return schema.NewSet(schema.HashResource(translationResource), rawSet)
+}
+
+func resourceTemplateEmailCreate(d *schema.ResourceData, m interface{}) error {
+	temp := buildEmailTemplate(d)
+	id := d.Get("type").(string)
+	_, _, err := getSupplementFromMetadata(m).UpdateEmailTemplate(id, *temp, nil)
+	if err != nil {
+		return err
+	}
+
+	d.SetId(id)
+
+	return resourceTemplateEmailRead(d, m)
+}
+
+func resourceTemplateEmailRead(d *schema.ResourceData, m interface{}) error {
+	temp, _, err := getSupplementFromMetadata(m).GetEmailTemplate(d.Id())
+	if err != nil {
+		return err
+	}
+	d.Set("translations", flattenEmailTranlations(temp.Translations))
+
+	return nil
+}
+
+func resourceTemplateEmailUpdate(d *schema.ResourceData, m interface{}) error {
+	temp := buildEmailTemplate(d)
+	_, _, err := getSupplementFromMetadata(m).UpdateEmailTemplate(d.Id(), *temp, nil)
+	if err != nil {
+		return err
+	}
+
+	return resourceTemplateEmailRead(d, m)
+}
+
+func resourceTemplateEmailDelete(d *schema.ResourceData, m interface{}) error {
+	temp := &EmailTemplate{
+		Name: "Default",
+		Type: d.Get("type").(string),
+	}
+	_, _, err := getSupplementFromMetadata(m).UpdateEmailTemplate(d.Id(), *temp, nil)
+
+	return err
+}

okta/resource_template_email_test.go

@@ -0,0 +1,29 @@
+package okta
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccEmailTemplate(t *testing.T) {
+	ri := acctest.RandInt()
+	resourceName := fmt.Sprintf("%s.test", templateEmail)
+	mgr := newFixtureManager(templateEmail)
+	config := mgr.GetFixtures("basic.tf", ri, t)
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: config,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(resourceName, "type", "email.forgotPassword"),
+				),
+			},
+		},
+	})
+}

okta/templates.go

@@ -0,0 +1,63 @@
+package okta
+
+import (
+	"fmt"
+
+	"github.com/okta/okta-sdk-golang/okta"
+	"github.com/okta/okta-sdk-golang/okta/query"
+)
+
+type (
+	EmailTemplate struct {
+		Id              string                       `json:"id,omitempty"`
+		Name            string                       `json:"name,omitempty"`
+		Type            string                       `json:"type,omitempty"`
+		DefaultLanguage string                       `json:"defaultLanguage,omitempty"`
+		Subject         string                       `json:"subject,omitempty"`
+		Template        string                       `json:"template,omitempty"`
+		Translations    map[string]*EmailTranslation `json:"translations,omitempty"`
+	}
+
+	EmailTranslation struct {
+		Subject  string `json:"subject,omitempty"`
+		Template string `json:"template,omitempty"`
+	}
+)
+
+func (m *ApiSupplement) ListEmailTemplates() ([]*EmailTemplate, *okta.Response, error) {
+	url := fmt.Sprintf("/api/v1/templates/emails")
+	req, err := m.requestExecutor.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var auth []*EmailTemplate
+	resp, err := m.requestExecutor.Do(req, &auth)
+	return auth, resp, err
+}
+
+func (m *ApiSupplement) UpdateEmailTemplate(id string, body EmailTemplate, qp *query.Params) (*EmailTemplate, *okta.Response, error) {
+	url := fmt.Sprintf("/api/v1/templates/emails/%s", id)
+	if qp != nil {
+		url += qp.String()
+	}
+	req, err := m.requestExecutor.NewRequest("PUT", url, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	temp := &EmailTemplate{}
+	resp, err := m.requestExecutor.Do(req, temp)
+	return temp, resp, err
+}
+
+func (m *ApiSupplement) GetEmailTemplate(id string) (*EmailTemplate, *okta.Response, error) {
+	url := fmt.Sprintf("/api/v1/templates/emails/%s", id)
+	req, err := m.requestExecutor.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	temp := &EmailTemplate{}
+	resp, err := m.requestExecutor.Do(req, temp)
+	return temp, resp, err
+}