Merge branch 'master' into update-service-tags

incident/incident.go

@@ -178,3 +178,12 @@ func (c *Client) ListNotes(context context.Context, request *ListNotesRequest) (
 	}
 	return result, nil
 }
+
+func (c *Client) GetResponderAlerts(context context.Context, request *GetResponderAlertsRequest) (*GetResponderAlertsResult, error) {
+	result := &GetResponderAlertsResult{}
+	err := c.client.Exec(context, request, result)
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}

incident/incident_test.go

@@ -475,13 +475,12 @@ func TestResponders_Validate(t *testing.T) {
 		{Type: User},
 	}
 	err = validateResponders(Responders)
-	assert.Equal(t, err.Error(), errors.New("For responder either name"+
-		" or id must be provided.").Error())
+	assert.Equal(t, err.Error(), errors.New("For responder type user either username or id must be provided.").Error())
 
 	Responders = []Responder{
 		{
-			Type: User,
-			Name: "cem",
+			Type:     User,
+			Username: "cem@example.com",
 		},
 	}
 	err = validateResponders(Responders)
@@ -492,8 +491,7 @@ func TestResponders_Validate(t *testing.T) {
 			Type: Team},
 	}
 	err = validateResponders(Responders)
-	assert.Equal(t, err.Error(), errors.New("For responder either name"+
-		" or id must be provided.").Error())
+	assert.Equal(t, err.Error(), errors.New("For responder type team either team name or id must be provided.").Error())
 
 	Responders = []Responder{
 		{
@@ -504,3 +502,37 @@ func TestResponders_Validate(t *testing.T) {
 	err = validateResponders(Responders)
 	assert.Nil(t, err)
 }
+
+func TestGetResponderAlertsRequest_Endpoint(t *testing.T) {
+	request := &GetResponderAlertsRequest{
+		Id:         "adea9e79-5527-4e49-b345-e55ae180ae59",
+		Identifier: Id,
+	}
+	endpoint := request.ResourcePath()
+	params := request.RequestParams()
+	assert.Equal(t, "/v1/incidents/adea9e79-5527-4e49-b345-e55ae180ae59/responder-alert-ids", endpoint)
+	assert.Equal(t, "id", params["identifierType"])
+}
+
+func TestGetResponderAlertsRequest_GetParams(t *testing.T) {
+	request := &GetResponderAlertsRequest{
+		Limit:     10,
+		Offset:    30,
+		Order:     "desc",
+		Direction: "next",
+	}
+	params := request.RequestParams()
+	assert.Equal(t, "10", params["limit"])
+	assert.Equal(t, "30", params["offset"])
+	assert.Equal(t, "next", params["direction"])
+	assert.Equal(t, "desc", params["order"])
+}
+
+func TestGetResponderAlertsRequest_Validate(t *testing.T) {
+	request := &GetResponderAlertsRequest{}
+	err := request.Validate()
+	assert.Equal(t, err.Error(), errors.New("Incident ID cannot be blank.").Error())
+	request.Id = "adea9e79-5527-4e49-b345-e55ae180ae59"
+	err = request.Validate()
+	assert.Nil(t, err)
+}

incident/request.go

@@ -772,6 +772,61 @@ func (r *ListNotesRequest) RequestParams() map[string]string {
 	return params
 }
 
+type GetResponderAlertsRequest struct {
+	client.BaseRequest
+	Identifier IdentifierType
+	Id         string
+	Limit      int
+	Offset     int
+	Order      Order
+	Direction  string
+}
+
+func (r *GetResponderAlertsRequest) Validate() error {
+	if r.Id == "" {
+		return errors.New("Incident ID cannot be blank.")
+	}
+	if r.Identifier != "" && r.Identifier != Id && r.Identifier != Tiny {
+		return errors.New("Identifier type should be one of these: 'Id', 'Tiny' or empty.")
+	}
+	return nil
+}
+
+func (r *GetResponderAlertsRequest) ResourcePath() string {
+	return "/v1/incidents/" + r.Id + "/responder-alert-ids"
+}
+
+func (r *GetResponderAlertsRequest) Method() string {
+	return http.MethodGet
+}
+
+func (r *GetResponderAlertsRequest) RequestParams() map[string]string {
+
+	params := make(map[string]string)
+
+	if r.Identifier == Tiny {
+		params["identifierType"] = "tiny"
+	} else {
+		params["identifierType"] = "id"
+	}
+
+	if r.Limit != 0 {
+		params["limit"] = strconv.Itoa(r.Limit)
+	}
+	if r.Offset != 0 {
+		params["offset"] = strconv.Itoa(r.Offset)
+	}
+	if r.Direction != "" {
+		params["direction"] = r.Direction
+
+	}
+	if r.Order != "" {
+		params["order"] = string(r.Order)
+	}
+
+	return params
+}
+
 type IdentifierType string
 type ResponderType string
 type Priority string
@@ -806,6 +861,7 @@ type Responder struct {
 	Type ResponderType `json:"type,omitempty"`
 	Name string        `json:"name,omitempty"`
 	Id   string        `json:"id,omitempty"`
+	Username string    `json:"username,omitempty"`
 }
 
 func validateResponders(responders []Responder) error {
@@ -816,8 +872,11 @@ func validateResponders(responders []Responder) error {
 		if !(responder.Type == User || responder.Type == Team) {
 			return errors.New("Responder type should be one of these: 'User', 'Team'.")
 		}
-		if responder.Name == "" && responder.Id == "" {
-			return errors.New("For responder either name or id must be provided.")
+		if responder.Type == User && responder.Username == "" && responder.Id == "" {
+			return errors.New("For responder type user either username or id must be provided.")
+		}
+		if responder.Type == Team && responder.Name == "" && responder.Id == "" {
+			return errors.New("For responder type team either team name or id must be provided.")
 		}
 	}
 	return nil

incident/result.go

@@ -80,3 +80,8 @@ type Paging struct {
 	First string `json:"first"`
 	Last  string `json:"last"`
 }
+
+type GetResponderAlertsResult struct {
+	client.ResultMetadata
+	AlertIds []string `json:"data"`
+}

integration/integration.go

@@ -75,11 +75,15 @@ func (c *Client) ForceUpdateAllFields(context context.Context, request *UpdateIn
 	request.OtherFields["ignoreRespondersFromPayload"] = request.IgnoreRespondersFromPayload
 	request.OtherFields["suppressNotifications"] = request.SuppressNotifications
 	request.OtherFields["responders"] = request.Responders
+	request.OtherFields["recipients"] = request.Responders
 	request.OtherFields["emailUsername"] = request.EmailUsername
 	request.OtherFields["url"] = request.WebhookUrl
 	request.OtherFields["addAlertDescription"] = request.AddAlertDescription
 	request.OtherFields["addAlertDetails"] = request.AddAlertDetails
 	request.OtherFields["headers"] = request.Headers
+	request.OtherFields["assignedTeam"] = request.OwnerTeam
+	request.OtherFields["ownerTeam"] = request.OwnerTeam
+
 	err := c.client.Exec(context, request.OtherFields, result)
 	if err != nil {
 		return nil, err

integration/request.go

@@ -153,6 +153,7 @@ type UpdateIntegrationRequest struct {
 	Responders                  []Responder
 	AddAlertDescription         *bool
 	AddAlertDetails             *bool
+	OwnerTeam                   *og.OwnerTeam `json:"ownerTeam,omitempty"`
 	Headers                     map[string]string
 	OtherFields
 }
@@ -396,6 +397,7 @@ type IntegrationAction struct {
 	Responders                       []Responder       `json:"responders,omitempty"`
 	Tags                             []string          `json:"tags,omitempty"`
 	ExtraProperties                  map[string]string `json:"extraProperties,omitempty"`
+	Recipients                       []Responder       `json:"recipients,omitempty"`
 }
 
 func (r *UpdateAllIntegrationActionsRequest) Validate() error {

policy/policy_test.go

@@ -126,14 +126,14 @@ func TestCreateAlertPolicy_Validate(t *testing.T) {
 
 	req.Responders = &[]alert.Responder{
 		{
-			Type:     alert.ScheduleResponder,
+			Type:     "",
 			Name:     "",
 			Id:       "",
 			Username: "",
 		},
 	}
 	err = req.Validate()
-	assert.Equal(t, err.Error(), errors.New("responder type for alert policy should be one of team or user").Error())
+	assert.Equal(t, err.Error(), errors.New("responder type for alert policy should be one of team, user, escalation or schedule").Error())
 
 	req.Responders = &[]alert.Responder{
 		{
@@ -179,6 +179,50 @@ func TestCreateAlertPolicy_Validate(t *testing.T) {
 	err = req.Validate()
 	assert.Nil(t, err)
 
+	req.Responders = &[]alert.Responder{
+		{
+			Type:     alert.EscalationResponder,
+			Name:     "",
+			Id:       "",
+			Username: "user1",
+		},
+	}
+	err = req.Validate()
+	assert.Equal(t, err.Error(), errors.New("responder id should be provided").Error())
+
+	req.Responders = &[]alert.Responder{
+		{
+			Type:     alert.EscalationResponder,
+			Name:     "",
+			Id:       "teamId",
+			Username: "",
+		},
+	}
+	err = req.Validate()
+	assert.Nil(t, err)
+
+	req.Responders = &[]alert.Responder{
+		{
+			Type:     alert.ScheduleResponder,
+			Name:     "",
+			Id:       "",
+			Username: "user1",
+		},
+	}
+	err = req.Validate()
+	assert.Equal(t, err.Error(), errors.New("responder id should be provided").Error())
+
+	req.Responders = &[]alert.Responder{
+		{
+			Type:     alert.ScheduleResponder,
+			Name:     "",
+			Id:       "teamId",
+			Username: "",
+		},
+	}
+	err = req.Validate()
+	assert.Nil(t, err)
+
 	req.Priority = "asd"
 	err = req.Validate()
 	assert.Equal(t, err.Error(), errors.New("Priority should be one of these: 'P1', 'P2', 'P3', 'P4' and 'P5'").Error())

policy/request.go

@@ -210,7 +210,7 @@ type UpdateAlertPolicyRequest struct {
 	Message                  string                 `json:"message,omitempty"`
 	Continue                 *bool                  `json:"continue,omitempty"`
 	Alias                    string                 `json:"alias,omitempty"`
-	AlertDescription         string                 `json:"alertDescription,omitempty"`
+	AlertDescription         string                 `json:"description,omitempty"`
 	Entity                   string                 `json:"entity,omitempty"`
 	Source                   string                 `json:"source,omitempty"`
 	IgnoreOriginalDetails    *bool                  `json:"ignoreOriginalDetails,omitempty"`
@@ -681,8 +681,8 @@ func ValidateDelayAction(action DelayAction) error {
 
 func ValidateResponders(responders *[]alert.Responder) error {
 	for _, responder := range *responders {
-		if responder.Type != alert.UserResponder && responder.Type != alert.TeamResponder {
-			return errors.New("responder type for alert policy should be one of team or user")
+		if responder.Type != alert.UserResponder && responder.Type != alert.TeamResponder && responder.Type != alert.EscalationResponder && responder.Type != alert.ScheduleResponder {
+			return errors.New("responder type for alert policy should be one of team, user, escalation or schedule")
 		}
 		if responder.Id == "" {
 			return errors.New("responder id should be provided")