[mm-507] Add support for DM subscriptions based on "watching" an issue in Jira (#507)

server/client.go

@@ -69,6 +69,7 @@ type SearchService interface {
 type IssueService interface {
 	GetIssue(key string, options *jira.GetQueryOptions) (*jira.Issue, error)
 	CreateIssue(issue *jira.Issue) (*jira.Issue, error)
+	GetWatchers(issueKey string) (*[]jira.User, error)
 
 	AddAttachment(api plugin.API, issueKey, fileID string, maxSize utils.ByteSize) (mattermostName, jiraName, mime string, err error)
 	AddComment(issueKey string, comment *jira.Comment) (*jira.Comment, error)
@@ -199,6 +200,15 @@ func (client JiraClient) GetIssue(key string, options *jira.GetQueryOptions) (*j
 	return issue, nil
 }
 
+// GetWatchers returns an array of Jira users watching for a given issue.
+func (client JiraClient) GetWatchers(issueKey string) (*[]jira.User, error) {
+	watchers, resp, err := client.Jira.Issue.GetWatchers(issueKey)
+	if err != nil {
+		return nil, userFriendlyJiraError(resp, err)
+	}
+	return watchers, nil
+}
+
 // GetTransitions returns transitions for an issue with issueKey.
 func (client JiraClient) GetTransitions(issueKey string) ([]jira.Transition, error) {
 	transitions, resp, err := client.Jira.Issue.GetTransitions(issueKey)

server/command.go

@@ -595,6 +595,8 @@ func executeSettings(p *Plugin, c *plugin.Context, header *model.CommandArgs, ar
 		return p.responsef(header, "Current settings:\n%s", conn.Settings.String())
 	case "notifications":
 		return p.settingsNotifications(header, instance.GetID(), user.MattermostUserID, conn, args)
+	case "watching":
+		return p.settingsWatching(header, instance.GetID(), user.MattermostUserID, conn, args)
 	default:
 		return p.responsef(header, "Unknown setting.")
 	}

server/command_test.go

@@ -165,12 +165,12 @@ func TestPlugin_ExecuteCommand_Settings(t *testing.T) {
 		"no params, with notifications": {
 			commandArgs:  &model.CommandArgs{Command: "/jira settings", UserId: mockUserIDWithNotifications},
 			numInstances: 1,
-			expectedMsg:  "Current settings:\n\tNotifications: on",
+			expectedMsg:  "Current settings:\n- Notifications: on\n\t- Watching: on",
 		},
 		"no params, without notifications": {
 			commandArgs:  &model.CommandArgs{Command: "/jira settings", UserId: mockUserIDWithoutNotifications},
 			numInstances: 1,
-			expectedMsg:  "Current settings:\n\tNotifications: off",
+			expectedMsg:  "Current settings:\n- Notifications: off\n\t- Watching: off",
 		},
 		"unknown setting": {
 			commandArgs:  &model.CommandArgs{Command: "/jira settings" + " test", UserId: mockUserIDWithoutNotifications},

server/kv.go

@@ -474,10 +474,17 @@ func (store *store) LoadInstance(instanceID types.ID) (Instance, error) {
 	if instanceID == "" {
 		return nil, errors.Wrap(kvstore.ErrNotFound, "no instance specified")
 	}
-	instance, err := store.LoadInstanceFullKey(hashkey(prefixInstance, instanceID.String()))
+	hashedKey := hashkey(prefixInstance, instanceID.String())
+	instance, err := store.LoadInstanceFullKey(hashedKey)
 	if err != nil {
+		if errors.Is(errors.Wrap(kvstore.ErrNotFound, hashedKey), err) {
+			return nil, nil
+		}
 		return nil, errors.Wrap(err, instanceID.String())
 	}
+	if instance == nil {
+		return nil, nil
+	}
 	return instance, nil
 }
 

server/plugin.go

@@ -28,6 +28,7 @@ import (
 	"github.com/mattermost/mattermost-plugin-jira/server/tracker"
 	"github.com/mattermost/mattermost-plugin-jira/server/utils"
 	"github.com/mattermost/mattermost-plugin-jira/server/utils/telemetry"
+	"github.com/mattermost/mattermost-plugin-jira/server/utils/types"
 )
 
 const (
@@ -425,3 +426,66 @@ func (p *Plugin) CheckSiteURL() error {
 	}
 	return nil
 }
+
+func (p *Plugin) GetWebhookURL(jiraURL string, teamID, channelID string) (subURL, legacyURL string, err error) {
+	cf := p.getConfig()
+
+	instanceID, err := p.ResolveWebhookInstanceURL(jiraURL)
+	if err != nil {
+		p.API.LogError("error while getting instance ID", err)
+		return "", "", err
+	}
+
+	team, appErr := p.API.GetTeam(teamID)
+	if appErr != nil {
+		return "", "", appErr
+	}
+
+	channel, appErr := p.API.GetChannel(channelID)
+	if appErr != nil {
+		return "", "", appErr
+	}
+
+	v := url.Values{}
+	secret, _ := url.QueryUnescape(cf.Secret)
+	v.Add("secret", secret)
+	subURL = p.GetPluginURL() + instancePath(routeAPISubscribeWebhook, instanceID) + "?" + v.Encode()
+
+	// For the legacy URL, add team and channel. Secret is already in the map.
+	v.Add("team", team.Name)
+	v.Add("channel", channel.Name)
+	legacyURL = p.GetPluginURL() + instancePath(routeIncomingWebhook, instanceID) + "?" + v.Encode()
+
+	return subURL, legacyURL, nil
+}
+func newWebhook(jwh *JiraWebhook, eventType string, format string, args ...interface{}) *webhook {
+	return &webhook{
+		JiraWebhook: jwh,
+		eventTypes:  NewStringSet(eventType),
+		headline:    jwh.mdUser() + " " + fmt.Sprintf(format, args...) + " " + jwh.mdKeySummaryLink(),
+	}
+}
+
+func (p *Plugin) getConnection(instance Instance, notification webhookUserNotification) (con *Connection, err error) {
+	var mattermostUserID types.ID
+
+	// prefer accountId to username when looking up UserIds
+	if notification.jiraAccountID != "" {
+		mattermostUserID, err = p.userStore.LoadMattermostUserID(instance.GetID(), notification.jiraAccountID)
+	} else {
+		mattermostUserID, err = p.userStore.LoadMattermostUserID(instance.GetID(), notification.jiraUsername)
+	}
+	if err != nil {
+		return
+	}
+
+	// Check if the user has permissions.
+	con, err = p.userStore.LoadConnection(instance.GetID(), mattermostUserID)
+	if err != nil {
+		p.API.LogError("error while load connection", err)
+		// Not connected to Jira, so can't check permissions
+		return
+	}
+
+	return
+}

server/settings.go

@@ -9,6 +9,9 @@ import (
 const (
 	settingOn  = "on"
 	settingOff = "off"
+
+	errStoreNewSettings = "Could not store new settings. Please contact your system administrator. error: %v"
+	errConnectToJira    = "Your username is not connected to Jira. Please type `/jira connect`. %v"
 )
 
 func (p *Plugin) settingsNotifications(header *model.CommandArgs, instanceID, mattermostUserID types.ID, connection *Connection, args []string) *model.CommandResponse {
@@ -34,13 +37,13 @@ func (p *Plugin) settingsNotifications(header *model.CommandArgs, instanceID, ma
 	connection.Settings.Notifications = value
 	if err := p.userStore.StoreConnection(instanceID, mattermostUserID, connection); err != nil {
 		p.errorf("settingsNotifications, err: %v", err)
-		p.responsef(header, "Could not store new settings. Please contact your system administrator. error: %v", err)
+		p.responsef(header, errStoreNewSettings, err)
 	}
 
 	// send back the actual value
 	updatedConnection, err := p.userStore.LoadConnection(instanceID, mattermostUserID)
 	if err != nil {
-		return p.responsef(header, "Your username is not connected to Jira. Please type `jira connect`. %v", err)
+		return p.responsef(header, errConnectToJira, err)
 	}
 	notifications := settingOff
 	if updatedConnection.Settings.Notifications {
@@ -49,3 +52,35 @@ func (p *Plugin) settingsNotifications(header *model.CommandArgs, instanceID, ma
 
 	return p.responsef(header, "Settings updated. Notifications %s.", notifications)
 }
+
+func (p *Plugin) settingsWatching(header *model.CommandArgs, instanceID, mattermostUserID types.ID, connection *Connection, args []string) *model.CommandResponse {
+	const helpText = "`/jira settings watching [value]`\\n* Invalid value. Accepted values are: `on` or `off`."
+
+	if len(args) != 2 {
+		return p.responsef(header, helpText)
+	}
+
+	wathing := false
+	wathingOnOff := settingOff
+
+	switch args[1] {
+	case settingOn:
+		wathing = true
+		wathingOnOff = settingOn
+	case settingOff:
+		wathing = false
+	default:
+		return p.responsef(header, helpText)
+	}
+
+	if connection.Settings == nil {
+		connection.Settings = &ConnectionSettings{}
+	}
+	connection.Settings.Watching = &wathing
+	if err := p.userStore.StoreConnection(instanceID, mattermostUserID, connection); err != nil {
+		p.errorf("settingsWatching, err: %v", err)
+		return p.responsef(header, errStoreNewSettings, err)
+	}
+
+	return p.responsef(header, "Settings updated. Watching %s.", wathingOnOff)
+}

server/user.go

@@ -43,15 +43,30 @@ func (c *Connection) JiraAccountID() types.ID {
 }
 
 type ConnectionSettings struct {
-	Notifications bool `json:"notifications"`
+	Notifications bool  `json:"notifications"`
+	Watching      *bool `json:"watching"`
 }
 
 func (s *ConnectionSettings) String() string {
-	notifications := "off"
-	if s != nil && s.Notifications {
-		notifications = "on"
+	notifications, watching := settingOff, settingOff
+	if s != nil {
+		if s.Notifications {
+			notifications = "on"
+		}
+		if s.ShouldReceiveWatcherNotifications() {
+			watching = "on"
+		}
+	}
+	return fmt.Sprintf("- Notifications: %s\n\t- Watching: %s", notifications, watching)
+}
+
+func (s *ConnectionSettings) ShouldReceiveWatcherNotifications() bool {
+	if s.Watching != nil {
+		return *s.Watching
 	}
-	return fmt.Sprintf("\tNotifications: %s", notifications)
+
+	// Check old setting for backwards compatibility
+	return s.Notifications
 }
 
 func NewUser(mattermostUserID types.ID) *User {

server/user_test.go

@@ -17,11 +17,11 @@ func TestUserSettings_String(t *testing.T) {
 	}{
 		"notifications on": {
 			settings:       ConnectionSettings{Notifications: false},
-			expectedOutput: "\tNotifications: off",
+			expectedOutput: "- Notifications: off\n\t- Watching: off",
 		},
 		"notifications off": {
 			settings:       ConnectionSettings{Notifications: true},
-			expectedOutput: "\tNotifications: on",
+			expectedOutput: "- Notifications: on\n\t- Watching: on",
 		},
 	}
 	for name, tt := range tests {

server/webhook.go

@@ -6,7 +6,6 @@ package main
 import (
 	"fmt"
 	"net/http"
-	"net/url"
 
 	"github.com/pkg/errors"
 
@@ -26,6 +25,7 @@ type Webhook interface {
 	Events() StringSet
 	PostToChannel(p *Plugin, instanceID types.ID, channelID, fromUserID, subscriptionName string) (*model.Post, int, error)
 	PostNotifications(p *Plugin, instanceID types.ID) ([]*model.Post, int, error)
+	CheckIssueWatchers(p *Plugin, instanceID types.ID)
 }
 
 type webhookField struct {
@@ -161,41 +161,59 @@ func (wh *webhook) PostNotifications(p *Plugin, instanceID types.ID) ([]*model.P
 	return posts, http.StatusOK, nil
 }
 
-func newWebhook(jwh *JiraWebhook, eventType string, format string, args ...interface{}) *webhook {
-	return &webhook{
-		JiraWebhook: jwh,
-		eventTypes:  NewStringSet(eventType),
-		headline:    jwh.mdUser() + " " + fmt.Sprintf(format, args...) + " " + jwh.mdKeySummaryLink(),
+func (wh *webhook) CheckIssueWatchers(p *Plugin, instanceID types.ID) {
+	instance, err := p.instanceStore.LoadInstance(instanceID)
+	if err != nil && instance == nil {
+		// This isn't an internal server error. There's just no instance installed.
+		return
 	}
-}
 
-func (p *Plugin) GetWebhookURL(jiraURL string, teamID, channelID string) (subURL, legacyURL string, err error) {
-	cf := p.getConfig()
-
-	instanceID, err := p.ResolveWebhookInstanceURL(jiraURL)
+	c, err := p.getConnection(instance, webhookUserNotification{
+		jiraAccountID: wh.JiraWebhook.User.AccountID,
+		jiraUsername:  wh.JiraWebhook.User.Name,
+	})
 	if err != nil {
-		return "", "", err
+		return
 	}
-
-	team, appErr := p.API.GetTeam(teamID)
-	if appErr != nil {
-		return "", "", appErr
+	client, err := instance.GetClient(c)
+	if err != nil {
+		return
 	}
-
-	channel, appErr := p.API.GetChannel(channelID)
-	if appErr != nil {
-		return "", "", appErr
+	watcherUsers, err := client.GetWatchers(wh.Issue.ID)
+	if err != nil {
+		return
 	}
 
-	v := url.Values{}
-	secret, _ := url.QueryUnescape(cf.Secret)
-	v.Add("secret", secret)
-	subURL = p.GetPluginURL() + instancePath(routeAPISubscribeWebhook, instanceID) + "?" + v.Encode()
+	for _, watcherUser := range *watcherUsers {
+		postType := ""
+		message := ""
+		var shouldNotReceiveNotification bool
+		for _, notification := range wh.notifications {
+			if notification.jiraAccountID == watcherUser.AccountID || (notification.jiraUsername != "" && notification.jiraUsername == watcherUser.Name) {
+				shouldNotReceiveNotification = true
+				break
+			}
+			postType = notification.postType
+			message = notification.message
+		}
+		if shouldNotReceiveNotification {
+			continue
+		}
+		whUserNotification := webhookUserNotification{
+			jiraUsername:  watcherUser.Name,
+			jiraAccountID: watcherUser.AccountID,
+			message:       message,
+			postType:      postType,
+			commentSelf:   wh.JiraWebhook.Comment.Self,
+		}
 
-	// For the legacy URL, add team and channel. Secret is already in the map.
-	v.Add("team", team.Name)
-	v.Add("channel", channel.Name)
-	legacyURL = p.GetPluginURL() + instancePath(routeIncomingWebhook, instanceID) + "?" + v.Encode()
+		c, err = p.getConnection(instance, whUserNotification)
 
-	return subURL, legacyURL, nil
+		// if setting watching value is false don't put into webhookUserNotification
+		if err != nil || c.Settings == nil || !c.Settings.ShouldReceiveWatcherNotifications() {
+			continue
+		}
+
+		wh.notifications = append(wh.notifications, whUserNotification)
+	}
 }

server/webhook_worker.go

@@ -57,6 +57,8 @@ func (ww webhookWorker) process(msg *webhookMessage) (err error) {
 		return err
 	}
 
+	wh.CheckIssueWatchers(ww.p, msg.InstanceID)
+
 	if _, _, err = wh.PostNotifications(ww.p, msg.InstanceID); err != nil {
 		ww.p.errorf("WebhookWorker id: %d, error posting notifications, err: %v", ww.id, err)
 	}