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
}
