package statuscake
import (
"encoding/json"
"fmt"
"net/url"
"strings"
"github.com/google/go-querystring/query"
)
//ContactGroup represent the data received by the API with GET
type ContactGroup struct {
GroupName string `json:"GroupName" url:"GroupName,omitempty"`
Emails []string `json:"Emails"`
EmailsPut string `url:"Email,omitempty"`
Mobiles string `json:"Mobiles" url:"Mobile,omitempty"`
Boxcar string `json:"Boxcar" url:"Boxcar,omitempty"`
Pushover string `json:"Pushover" url:"Pushover,omitempty"`
ContactID int `json:"ContactID" url:"ContactID,omitempty"`
DesktopAlert string `json:"DesktopAlert" url:"DesktopAlert,omitempty"`
PingURL string `json:"PingURL" url:"PingURL,omitempty"`
}
type Response struct {
Success bool `json:"Success"`
Message string `json:"Message"`
InsertID int `json:"InsertID"`
}
//ContactGroups represent the actions done wit the API
type ContactGroups interface {
All() ([]*ContactGroup, error)
Detail(int) (*ContactGroup, error)
Update(*ContactGroup) (*ContactGroup, error)
Delete(int) error
Create(*ContactGroup) (*ContactGroup, error)
}
func findContactGroup(responses []*ContactGroup, id int) (*ContactGroup, error) {
var response *ContactGroup
for _, elem := range responses {
if (*elem).ContactID == id {
return elem, nil
}
}
return response, fmt.Errorf("%d Not found", id)
}
type contactGroups struct{
client apiClient
}
//NewContactGroups return a new ssls
func NewContactGroups(c apiClient) ContactGroups {
return &contactGroups{
client: c,
}
}
//All return a list of all the ContactGroup from the API
func (tt *contactGroups) All() ([]*ContactGroup, error) {
rawResponse, err := tt.client.get("/ContactGroups", nil)
if err != nil {
return nil, fmt.Errorf("Error getting StatusCake contactGroups: %s", err.Error())
}
var getResponse []*ContactGroup
err = json.NewDecoder(rawResponse.Body).Decode(&getResponse)
if err != nil {
return nil, err
}
return getResponse, err
}
//Detail return the ContactGroup corresponding to the id
func (tt *contactGroups) Detail(id int) (*ContactGroup, error) {
responses, err := tt.All()
if err != nil {
return nil, err
}
myContactGroup, errF := findContactGroup(responses, id)
if errF != nil {
return nil, errF
}
return myContactGroup, nil
}
//Update update the API with cg and create one if cg.ContactID=0 then return the corresponding ContactGroup
func (tt *contactGroups) Update(cg *ContactGroup) (*ContactGroup, error) {
if(cg.ContactID == 0){
return tt.Create(cg)
}
cg.EmailsPut=strings.Join(cg.Emails,",")
var v url.Values
v, _ = query.Values(*cg)
rawResponse, err := tt.client.put("/ContactGroups/Update", v)
if err != nil {
return nil, fmt.Errorf("Error creating StatusCake ContactGroup: %s", err.Error())
}
var response Response
err = json.NewDecoder(rawResponse.Body).Decode(&response)
if err != nil {
return nil, err
}
if !response.Success {
return nil, fmt.Errorf("%s", response.Message)
}
return cg, nil
}
//Delete delete the ContactGroup which ID is id
func (tt *contactGroups) Delete(id int) error {
_, err := tt.client.delete("/ContactGroups/Update", url.Values{"ContactID": {fmt.Sprint(id)}})
return err
}
//CreatePartial create the ContactGroup whith the data in cg and return the ContactGroup created
func (tt *contactGroups) Create(cg *ContactGroup) (*ContactGroup, error) {
cg.ContactID=0
cg.EmailsPut=strings.Join(cg.Emails,",")
var v url.Values
v, _ = query.Values(*cg)
rawResponse, err := tt.client.put("/ContactGroups/Update", v)
if err != nil {
return nil, fmt.Errorf("Error creating StatusCake ContactGroup: %s", err.Error())
}
var response Response
err = json.NewDecoder(rawResponse.Body).Decode(&response)
if err != nil {
return nil, err
}
if !response.Success {
return nil, fmt.Errorf("%s", response.Message)
}
cg.ContactID = response.InsertID
return cg,nil
}