feat: add support for opsgenie

docs/services/opsgenie.md

@@ -0,0 +1,59 @@
+# OpsGenie
+
+## URL Format
+
+## Creating a REST API endpoint in OpsGenie
+
+1. Open up the Integration List page by clicking on *Settings => Integration List* within the menu
+![Screenshot 1](opsgenie/1.png)
+
+2. Click *API => Add*
+
+3. Make sure *Create and Update Access* and *Enabled* are checked and click *Save Integration*
+![Screenshot 2](opsgenie/2.png)
+
+4. Copy the *API Key*
+
+5. Format the service URL
+
+The host can be either api.opsgenie.com or api.eu.opsgenie.com depending on the location of your instance. See
+the [OpsGenie documentation](https://docs.opsgenie.com/docs/alert-api) for details.
+
+```
+opsgenie://api.opsgenie.com/eb243592-faa2-4ba2-a551q-1afdf565c889
+                            └───────────────────────────────────┘
+                                           token
+```
+
+## Passing parameters via code
+
+If you want to, you can pass additional parameters to the `send` function.
+<br/>
+The following example contains all parameters that are currently supported.
+
+```gotemplate
+service.Send("An example alert message", &types.Params{
+    "alias":       "Life is too short for no alias",
+    "description": "Every alert needs a description",
+    "responders":  `[{"id":"4513b7ea-3b91-438f-b7e4-e3e54af9147c","type":"team"},{"name":"NOC","type":"team"}]`,
+    "visibleTo":   `[{"id":"4513b7ea-3b91-438f-b7e4-e3e54af9147c","type":"team"},{"name":"rocket_team","type":"team"}]`,
+    "actions":     "An action",
+    "tags":        "tag1 tag2",
+    "details":     `{"key1": "value1", "key2": "value2"}`,
+    "entity":      "An example entity",
+    "source":      "The source",
+    "priority":    "P1",
+    "user":        "Dracula",
+    "note":        "Here is a note",
+})
+```
+
+# Optional parameters
+
+You can optionally specify the parameters in the URL:
+opsgenie://api.opsgenie.com/eb243592-faa2-4ba2-a551q-1afdf565c889?alias=Life+is+too+short+for+no+alias&description=Every+alert+needs+a+description&actions=An+action&tags=["tag1","tag2"]&entity=An+example+entity&source=The+source&priority=P1&user=Dracula&note=Here+is+a+note
+
+Example using the command line:
+
+	shoutrrr send -u 'opsgenie://api.eu.opsgenie.com/token?tags=["tag1","tag2"]&description=testing&responders=[{"username":"superuser", "type": "user"}]&entity=Example Entity&source=Example Source&actions=["asdf", "bcde"]' -m "Hello World6"
+

pkg/format/format_query.go

@@ -19,7 +19,7 @@ func BuildQuery(cqr types.ConfigQueryResolver) string {
 		}
 		value, err := cqr.Get(key)
 
-		if err == nil {
+		if err == nil && value != "" {
 			query.Set(key, value)
 		}
 	}

pkg/format/formatter.go

@@ -346,7 +346,7 @@ func SetConfigField(config reflect.Value, field FieldInfo, inputValue string) (v
 
 		configField.SetBool(value)
 		return true, nil
-	} else if fieldKind >= reflect.Slice || fieldKind == reflect.Array {
+	} else if fieldKind == reflect.Slice || fieldKind == reflect.Array {
 		elemType := field.Type.Elem()
 		elemKind := elemType.Kind()
 		if elemKind != reflect.String {
@@ -367,7 +367,29 @@ func SetConfigField(config reflect.Value, field FieldInfo, inputValue string) (v
 
 		configField.Set(value)
 		return true, nil
+	} else if fieldKind == reflect.Map {
+		keyKind := field.Type.Key().Kind()
+		elemKind := field.Type.Elem().Kind()
+		if elemKind != reflect.String || keyKind != reflect.String {
+			return false, errors.New("field format is not supported")
+		}
+
+		newMap := make(map[string]string)
+
+		pairs := strings.Split(inputValue, ",")
+		for _, pair := range pairs {
+			elems := strings.Split(pair, ":")
+			if len(elems) != 2 {
+				return false, errors.New("field format is not supported")
+			}
+			key := elems[0]
+			value := elems[1]
+
+			newMap[key] = value
+		}
 
+		configField.Set(reflect.ValueOf(newMap))
+		return true, nil
 	} else {
 		err = fmt.Errorf("invalid field kind %v", fieldKind)
 	}
@@ -395,14 +417,28 @@ func GetConfigFieldString(config reflect.Value, field FieldInfo) (value string,
 		return strconv.FormatInt(configField.Int(), field.Base), nil
 	} else if fieldKind == reflect.Bool {
 		return PrintBool(configField.Bool()), nil
-	} else if fieldKind >= reflect.Slice {
+	} else if fieldKind == reflect.Slice {
 		sliceLen := configField.Len()
 		sliceValue := configField.Slice(0, sliceLen)
 		if field.Type.Elem().Kind() != reflect.String {
 			return "", errors.New("field format is not supported")
 		}
 		slice := sliceValue.Interface().([]string)
 		return strings.Join(slice, ","), nil
+	} else if fieldKind == reflect.Map {
+		keyKind := field.Type.Key().Kind()
+		elemKind := field.Type.Elem().Kind()
+		if elemKind != reflect.String || keyKind != reflect.String {
+			return "", errors.New("field format is not supported")
+		}
+
+		kvPairs := []string{}
+		for _, key := range configField.MapKeys() {
+			value := configField.MapIndex(key).Interface()
+
+			kvPairs = append(kvPairs, fmt.Sprintf("%s:%s", key, value))
+		}
+		return strings.Join(kvPairs, ","), nil
 	}
 	return "", fmt.Errorf("field kind %x is not supported", fieldKind)
 

pkg/router/servicemap.go

@@ -8,6 +8,7 @@ import (
 	"github.com/containrrr/shoutrrr/pkg/services/join"
 	"github.com/containrrr/shoutrrr/pkg/services/logger"
 	"github.com/containrrr/shoutrrr/pkg/services/mattermost"
+	"github.com/containrrr/shoutrrr/pkg/services/opsgenie"
 	"github.com/containrrr/shoutrrr/pkg/services/pushbullet"
 	"github.com/containrrr/shoutrrr/pkg/services/pushover"
 	"github.com/containrrr/shoutrrr/pkg/services/rocketchat"
@@ -37,4 +38,5 @@ var serviceMap = map[string]func() t.Service{
 	"zulip":      func() t.Service { return &zulip.Service{} },
 	"join":       func() t.Service { return &join.Service{} },
 	"rocketchat": func() t.Service { return &rocketchat.Service{} },
+	"opsgenie":   func() t.Service { return &opsgenie.Service{} },
 }

pkg/services/opsgenie/opsgenie.go

@@ -0,0 +1,74 @@
+package opsgenie
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+
+	"github.com/containrrr/shoutrrr/pkg/services/standard"
+	"github.com/containrrr/shoutrrr/pkg/types"
+)
+
+const (
+	alertEndpointTemplate = "https://%s:%d/v2/alerts"
+)
+
+// Service providing OpsGenie as a notification service
+type Service struct {
+	standard.Standard
+	config *Config
+}
+
+func (service *Service) sendAlert(url string, apiKey string, payload AlertPayload) error {
+	jsonBody, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	jsonBuffer := bytes.NewBuffer(jsonBody)
+
+	req, err := http.NewRequest("POST", url, jsonBuffer)
+	if err != nil {
+		return err
+	}
+	req.Header.Add("Authorization", "GenieKey "+apiKey)
+	req.Header.Add("Content-Type", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send notification to OpsGenie: %s", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		body, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return fmt.Errorf("OpsGenie notification returned %d HTTP status code. Cannot read body: %s", resp.StatusCode, err)
+		}
+		return fmt.Errorf("OpsGenie notification returned %d HTTP status code: %s", resp.StatusCode, body)
+	}
+
+	return nil
+}
+
+// Initialize loads ServiceConfig from configURL and sets logger for this Service
+func (service *Service) Initialize(configURL *url.URL, logger *log.Logger) error {
+	service.Logger.SetLogger(logger)
+	service.config = &Config{}
+	return service.config.SetURL(configURL)
+}
+
+// Send a notification message to OpsGenie
+// See: https://docs.opsgenie.com/docs/alert-api#create-alert
+func (service *Service) Send(message string, params *types.Params) error {
+	config := service.config
+	url := fmt.Sprintf(alertEndpointTemplate, config.Host, config.Port)
+	payload, err := NewAlertPayload(message, config, params)
+	if err != nil {
+		return err
+	}
+	return service.sendAlert(url, config.ApiKey, payload)
+}

pkg/services/opsgenie/opsgenie_config.go

@@ -0,0 +1,121 @@
+package opsgenie
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"github.com/containrrr/shoutrrr/pkg/format"
+	"github.com/containrrr/shoutrrr/pkg/types"
+)
+
+// Config for use within the opsgenie service
+type Config struct {
+	ApiKey      string            `desc:"The OpsGenie API key"`
+	Host        string            `desc:"The OpsGenie API host. Use 'api.eu.opsgenie.com' for EU instances" default:"api.opsgenie.com"`
+	Port        uint16            `desc:"The OpsGenie API port." default:"443"`
+	Alias       string            `key:"alias" desc:"Client-defined identifier of the alert" optional:"true"`
+	Description string            `key:"description" desc:"Description field of the alert" optional:"true"`
+	Responders  []Entity          `key:"responders" desc:"Teams, users, escalations and schedules that the alert will be routed to send notifications" optional:"true"`
+	VisibleTo   []Entity          `key:"visibleTo" desc:"Teams and users that the alert will become visible to without sending any notification" optional:"true"`
+	Actions     []string          `key:"actions" desc:"Custom actions that will be available for the alert" optional:"true"`
+	Tags        []string          `key:"tags" desc:"Tags of the alert" optional:"true"`
+	Details     map[string]string `key:"details" desc:"Map of key-value pairs to use as custom properties of the alert" optional:"true"`
+	Entity      string            `key:"entity" desc:"Entity field of the alert that is generally used to specify which domain the Source field of the alert" optional:"true"`
+	Source      string            `key:"source" desc:"Source field of the alert" optional:"true"`
+	Priority    string            `key:"priority" desc:"Priority level of the alert. Possible values are P1, P2, P3, P4 and P5" optional:"true"`
+	Note        string            `key:"note" desc:"Additional note that will be added while creating the alert" optional:"true"`
+	User        string            `key:"user" desc:"Display name of the request owner" optional:"true"`
+}
+
+func (config Config) Enums() map[string]types.EnumFormatter {
+	return map[string]types.EnumFormatter{}
+}
+
+// Public version of GetURL that creates a new PropKeyResolver when accessed from outside the package
+func (config *Config) GetURL() *url.URL {
+	resolver := format.NewPropKeyResolver(config)
+	return config.getURL(&resolver)
+}
+
+// Private version of GetURL that can use an instance of PropKeyResolver instead of rebuilding it's model from reflection
+func (config *Config) getURL(resolver types.ConfigQueryResolver) *url.URL {
+	host := ""
+	if config.Port > 0 {
+		host = fmt.Sprintf("%s:%d", config.Host, config.Port)
+	} else {
+		host = config.Host
+	}
+
+	// Serialize Shoutrrr standard data types
+	rawQuery := format.BuildQuery(resolver)
+
+	// Serialize OpsGenie specific data types
+	separator := "&"
+	if rawQuery == "" {
+		separator = ""
+	}
+
+	if len(config.Responders) > 0 {
+		responders, _ := serializeEntities(config.Responders)
+		rawQuery = rawQuery + separator + "responders=" + responders
+		separator = "&"
+	}
+	if len(config.VisibleTo) > 0 {
+		visibleTo, _ := serializeEntities(config.VisibleTo)
+		rawQuery = rawQuery + separator + "visibleTo=" + visibleTo
+	}
+
+	result := &url.URL{
+		Host:     host,
+		Path:     fmt.Sprintf("/%s", config.ApiKey),
+		Scheme:   Scheme,
+		RawQuery: rawQuery,
+	}
+
+	return result
+}
+
+// SetURL updates a ServiceConfig from a URL representation of it's field values
+func (config *Config) SetURL(url *url.URL) error {
+	resolver := format.NewPropKeyResolver(config)
+	return config.setURL(&resolver, url)
+}
+
+// Private version of SetURL that can use an instance of PropKeyResolver instead of rebuilding it's model from reflection
+func (config *Config) setURL(resolver types.ConfigQueryResolver, url *url.URL) error {
+	config.Host = url.Hostname()
+	config.ApiKey = url.Path[1:]
+
+	if url.Port() != "" {
+		port, err := strconv.ParseUint(url.Port(), 10, 16)
+		if err != nil {
+			return err
+		}
+		config.Port = uint16(port)
+	}
+
+	for key, vals := range url.Query() {
+		var err error
+
+		switch key {
+		case "responders":
+			config.Responders, err = deserializeEntities(vals[0])
+		case "visibleTo":
+			config.VisibleTo, err = deserializeEntities(vals[0])
+		default:
+			err = resolver.Set(key, vals[0])
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+const (
+	// Scheme is the identifying part of this service's configuration URL
+	Scheme = "opsgenie"
+)