1 files changed, 290 insertions, 0 deletions

diff --git a/statuscake/resource_statuscakessl.go b/statuscake/resource_statuscakessl.go
new file mode 100644
index 0000000..2ee50e6
--- /dev/null
+++ b/statuscake/resource_statuscakessl.go
@@ -0,0 +1,290 @@
+package statuscake
+
+import (
+        "fmt"
+        "strconv"
+
+        "github.com/DreamItGetIT/statuscake"
+        "github.com/hashicorp/terraform/helper/schema"
+        "log"
+        "strings"
+)
+
+func resourceStatusCakeSsl() *schema.Resource {
+        return &schema.Resource{
+                Create: CreateSsl,
+                Update: UpdateSsl,
+                Delete: DeleteSsl,
+                Read:   ReadSsl,
+                Importer: &schema.ResourceImporter{
+                        State: schema.ImportStatePassthrough,
+                },
+
+                Schema: map[string]*schema.Schema{
+                        "ssl_id": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "domain": {
+                                Type:     schema.TypeString,
+                                Required: true,
+                        },
+
+                        "contact_groups": {
+                                Type:          schema.TypeSet,
+                                Elem:          &schema.Schema{Type: schema.TypeString},
+                                Optional:      true,
+                                Computed:      true,
+                                ConflictsWith: []string{"contact_groups_c"},
+                        },
+
+                        "contact_groups_c": {
+                                Type:          schema.TypeString,
+                                Optional:      true,
+                                Computed:      true,
+                                ConflictsWith: []string{"contact_groups"},
+                        },
+
+                        "checkrate": {
+                                Type:     schema.TypeInt,
+                                Required: true,
+                        },
+
+                        "alert_at": {
+                                Type:     schema.TypeString,
+                                Required: true,
+                        },
+
+                        "alert_reminder": {
+                                Type:     schema.TypeBool,
+                                Required: true,
+                        },
+
+                        "alert_expiry": {
+                                Type:     schema.TypeBool,
+                                Required: true,
+                        },
+
+                        "alert_broken": {
+                                Type:     schema.TypeBool,
+                                Required: true,
+                        },
+
+                        "alert_mixed": {
+                                Type:     schema.TypeBool,
+                                Required: true,
+                        },
+
+                        "paused": {
+                                Type:     schema.TypeBool,
+                                Computed: true,
+                        },
+
+                        "issuer_cn": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "cert_score": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "cipher_score": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "cert_status": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "cipher": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "valid_from_utc": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "valid_until_utc": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+
+                        "mixed_content": {
+                                Type: schema.TypeList,
+                                Elem: &schema.Schema{
+                                        Type: schema.TypeMap,
+                                        Elem: &schema.Schema{Type: schema.TypeString},
+                                },
+                                Computed: true,
+                        },
+
+                        "flags": {
+                                Type:     schema.TypeMap,
+                                Elem:     &schema.Schema{Type: schema.TypeBool},
+                                Computed: true,
+                        },
+
+                        "last_reminder": {
+                                Type:     schema.TypeInt,
+                                Computed: true,
+                        },
+
+                        "last_updated_utc": {
+                                Type:     schema.TypeString,
+                                Computed: true,
+                        },
+                },
+        }
+}
+
+func CreateSsl(d *schema.ResourceData, meta interface{}) error {
+        client := meta.(*statuscake.Client)
+
+        if v, ok := d.GetOk("contact_groups"); ok {
+                d.Set("contact_groups_c", strings.Join(castSetToSliceStrings(v.(*schema.Set).List()), ","))
+        }
+
+        newSsl := &statuscake.PartialSsl{
+                Domain:         d.Get("domain").(string),
+                Checkrate:      strconv.Itoa(d.Get("checkrate").(int)),
+                ContactGroupsC: d.Get("contact_groups_c").(string),
+                AlertReminder:  d.Get("alert_reminder").(bool),
+                AlertExpiry:    d.Get("alert_expiry").(bool),
+                AlertBroken:    d.Get("alert_broken").(bool),
+                AlertMixed:     d.Get("alert_mixed").(bool),
+                AlertAt:        d.Get("alert_at").(string),
+        }
+
+        log.Printf("[DEBUG] Creating new StatusCake Ssl: %s", d.Get("domain").(string))
+
+        response, err := statuscake.NewSsls(client).Create(newSsl)
+        if err != nil {
+                return fmt.Errorf("Error creating StatusCake Ssl: %s", err.Error())
+        }
+
+        d.Set("ssl_id", response.ID)
+        d.Set("paused", response.Paused)
+        d.Set("issuer_cn", response.IssuerCn)
+        d.Set("cert_score", response.CertScore)
+        d.Set("cipher_score", response.CipherScore)
+        d.Set("cert_status", response.CertStatus)
+        d.Set("cipher", response.Cipher)
+        d.Set("valid_from_utc", response.ValidFromUtc)
+        d.Set("valid_until_utc", response.ValidUntilUtc)
+        d.Set("mixed_content", response.MixedContent)
+        d.Set("flags", response.Flags)
+        d.Set("last_reminder", response.LastReminder)
+        d.Set("last_updated_utc", response.LastUpdatedUtc)
+        d.SetId(response.ID)
+
+        return ReadSsl(d, meta)
+}
+
+func UpdateSsl(d *schema.ResourceData, meta interface{}) error {
+        client := meta.(*statuscake.Client)
+
+        params := getStatusCakeSslInput(d)
+
+        log.Printf("[DEBUG] StatusCake Ssl Update for %s", d.Id())
+        _, err := statuscake.NewSsls(client).Update(params)
+        if err != nil {
+                return fmt.Errorf("Error Updating StatusCake Ssl: %s", err.Error())
+        }
+        return nil
+}
+
+func DeleteSsl(d *schema.ResourceData, meta interface{}) error {
+        client := meta.(*statuscake.Client)
+
+        log.Printf("[DEBUG] Deleting StatusCake Ssl: %s", d.Id())
+        err := statuscake.NewSsls(client).Delete(d.Id())
+
+        return err
+}
+
+func ReadSsl(d *schema.ResourceData, meta interface{}) error {
+        client := meta.(*statuscake.Client)
+
+        response, err := statuscake.NewSsls(client).Detail(d.Id())
+        if err != nil {
+                return fmt.Errorf("Error Getting StatusCake Ssl Details for %s: Error: %s", d.Id(), err)
+        }
+        d.Set("domain", response.Domain)
+        d.Set("checkrate", response.Checkrate)
+        d.Set("contact_groups_c", response.ContactGroupsC)
+        d.Set("alert_reminder", response.AlertReminder)
+        d.Set("alert_expiry", response.AlertExpiry)
+        d.Set("alert_broken", response.AlertBroken)
+        d.Set("alert_mixed", response.AlertMixed)
+        d.Set("alert_at", response.AlertAt)
+        d.Set("ssl_id", response.ID)
+        d.Set("contact_groups", response.ContactGroups)
+        d.Set("paused", response.Paused)
+        d.Set("issuer_cn", response.IssuerCn)
+        d.Set("cert_score", response.CertScore)
+        d.Set("cipher_score", response.CipherScore)
+        d.Set("cert_status", response.CertStatus)
+        d.Set("cipher", response.Cipher)
+        d.Set("valid_from_utc", response.ValidFromUtc)
+        d.Set("valid_until_utc", response.ValidUntilUtc)
+        d.Set("mixed_content", response.MixedContent)
+        d.Set("flags", response.Flags)
+        d.Set("last_reminder", response.LastReminder)
+        d.Set("last_updated_utc", response.LastUpdatedUtc)
+        d.SetId(response.ID)
+
+        return nil
+}
+
+func getStatusCakeSslInput(d *schema.ResourceData) *statuscake.PartialSsl {
+        sslId, parseErr := strconv.Atoi(d.Id())
+        if parseErr != nil {
+                log.Printf("[DEBUG] Error Parsing StatusCake Id: %s", d.Id())
+        }
+        ssl := &statuscake.PartialSsl{
+                ID: sslId,
+        }
+
+        if v, ok := d.GetOk("domain"); ok {
+                ssl.Domain = v.(string)
+        }
+
+        if v, ok := d.GetOk("checkrate"); ok {
+                ssl.Checkrate = strconv.Itoa(v.(int))
+        }
+
+        if v, ok := d.GetOk("contact_groups"); ok {
+                ssl.ContactGroupsC = strings.Join(castSetToSliceStrings(v.(*schema.Set).List()), ",")
+        } else if v, ok := d.GetOk("contact_groups_c"); ok {
+                ssl.ContactGroupsC = v.(string)
+        }
+
+        if v, ok := d.GetOk("alert_reminder"); ok {
+                ssl.AlertReminder = v.(bool)
+        }
+
+        if v, ok := d.GetOk("alert_expiry"); ok {
+                ssl.AlertExpiry = v.(bool)
+        }
+
+        if v, ok := d.GetOk("alert_broken"); ok {
+                ssl.AlertBroken = v.(bool)
+        }
+
+        if v, ok := d.GetOk("alert_mixed"); ok {
+                ssl.AlertMixed = v.(bool)
+        }
+
+        if v, ok := d.GetOk("alert_at"); ok {
+                ssl.AlertAt = v.(string)
+        }
+
+        return ssl
+}