[MM-133] Added a feature of restricting bot messages to private channels and DM/GMs

plugin.json

@@ -89,6 +89,15 @@
                 "regenerate_help_text": "",
                 "placeholder": "",
                 "default": null
+            },
+            {
+                "key": "RestrictMeetingCreation",
+                "display_name": "Restrict Meeting Creation:",
+                "type": "bool",
+                "help_text": "Restrict user from creating meetings in public channels.",
+                "regenerate_help_text": "",
+                "placeholder": "",
+                "default": false
             }
         ]
     }

server/command.go

@@ -17,21 +17,29 @@ const (
 	helpText      = `* |/zoom start| - Start a zoom meeting`
 	oAuthHelpText = `* |/zoom connect| - Connect to Zoom
 * |/zoom disconnect| - Disconnect from Zoom`
-	settingHelpText        = `* |/zoom settings| - Update your preferences`
-	alreadyConnectedText   = "Already connected"
-	zoomPreferenceCategory = "plugin:zoom"
-	zoomPMISettingName     = "use-pmi"
-	zoomPMISettingValueAsk = "ask"
+	settingHelpText               = `* |/zoom settings| - Update your preferences`
+	channelPreferenceHelpText     = `* |/zoom channel-settings| - Update your current channel preference`
+	listChannelPreferenceHelpText = `* |/zoom channel-settings list| - List all channel preferences`
+	alreadyConnectedText          = "Already connected"
+	zoomPreferenceCategory        = "plugin:zoom"
+	zoomPMISettingName            = "use-pmi"
+	zoomPMISettingValueAsk        = "ask"
 )
 
 const (
-	actionConnect    = "connect"
-	actionStart      = "start"
-	actionDisconnect = "disconnect"
-	actionHelp       = "help"
-	settings         = "settings"
+	actionConnect             = "connect"
+	actionStart               = "start"
+	actionDisconnect          = "disconnect"
+	actionHelp                = "help"
+	settings                  = "settings"
+	actionChannelSettings     = "channel-settings"
+	channelSettingsActionList = "list"
+
+	actionUnkown = "Unknown Action"
 )
 
+const channelPreferenceListErr = "Unable to list channel preferences"
+
 func (p *Plugin) getCommand() (*model.Command, error) {
 	iconData, err := command.GetIconData(p.API, "assets/profile.svg")
 	if err != nil {
@@ -40,9 +48,9 @@ func (p *Plugin) getCommand() (*model.Command, error) {
 
 	canConnect := !p.configuration.AccountLevelApp
 
-	autoCompleteDesc := "Available commands: start, help, settings"
+	autoCompleteDesc := "Available commands: start, help, settings, channel-settings"
 	if canConnect {
-		autoCompleteDesc = "Available commands: start, connect, disconnect, help, settings"
+		autoCompleteDesc = "Available commands: start, connect, disconnect, help, settings, channel-settings"
 	}
 
 	return &model.Command{
@@ -104,8 +112,10 @@ func (p *Plugin) executeCommand(c *plugin.Context, args *model.CommandArgs) (str
 		return p.runHelpCommand(user)
 	case settings:
 		return p.runSettingCommand(args, strings.Fields(args.Command)[2:], user)
+	case actionChannelSettings:
+		return p.runChannelSettingsCommand(args, strings.Fields(args.Command)[2:], user)
 	default:
-		return fmt.Sprintf("Unknown action %v", action), nil
+		return fmt.Sprintf("%s %v", actionUnkown, action), nil
 	}
 }
 
@@ -126,6 +136,16 @@ func (p *Plugin) ExecuteCommand(c *plugin.Context, args *model.CommandArgs) (*mo
 
 // runStartCommand runs command to start a Zoom meeting.
 func (p *Plugin) runStartCommand(args *model.CommandArgs, user *model.User, topic string) (string, error) {
+	restrict, err := p.isChannelRestrictedForMeetings(args.ChannelId)
+	if err != nil {
+		p.client.Log.Error("Unable to check channel preference", "ChannelID", args.ChannelId, "Error", err.Error())
+		return "Error occurred while starting meeting", nil
+	}
+
+	if restrict {
+		return "Creating zoom meeting is disabled for this channel.", nil
+	}
+
 	if _, appErr := p.API.GetChannelMember(args.ChannelId, user.Id); appErr != nil {
 		return fmt.Sprintf("We could not get the channel members (channelId: %v)", args.ChannelId), nil
 	}
@@ -167,14 +187,14 @@ func (p *Plugin) runStartCommand(args *model.CommandArgs, user *model.User, topi
 		meetingID = zoomUser.Pmi
 
 		if meetingID <= 0 {
-			meetingID, createMeetingErr = p.createMeetingWithoutPMI(user, zoomUser, args.ChannelId, topic)
+			meetingID, createMeetingErr = p.createMeetingWithoutPMI(user, zoomUser, topic)
 			if createMeetingErr != nil {
 				return "", errors.Wrap(createMeetingErr, "failed to create the meeting")
 			}
 			p.sendEnableZoomPMISettingMessage(user.Id, args.ChannelId, args.RootId)
 		}
 	default:
-		meetingID, createMeetingErr = p.createMeetingWithoutPMI(user, zoomUser, args.ChannelId, topic)
+		meetingID, createMeetingErr = p.createMeetingWithoutPMI(user, zoomUser, topic)
 		if createMeetingErr != nil {
 			return "", errors.Wrap(createMeetingErr, "failed to create the meeting")
 		}
@@ -191,7 +211,7 @@ func (p *Plugin) runStartCommand(args *model.CommandArgs, user *model.User, topi
 
 func (p *Plugin) runConnectCommand(user *model.User, extra *model.CommandArgs) (string, error) {
 	if !p.canConnect(user) {
-		return "Unknown action `connect`", nil
+		return fmt.Sprintf("%s `%s`", actionUnkown, actionConnect), nil
 	}
 
 	oauthMsg := fmt.Sprintf(
@@ -228,7 +248,7 @@ func (p *Plugin) runConnectCommand(user *model.User, extra *model.CommandArgs) (
 // runDisconnectCommand runs command to disconnect from Zoom. Will fail if user cannot connect.
 func (p *Plugin) runDisconnectCommand(user *model.User) (string, error) {
 	if !p.canConnect(user) {
-		return "Unknown action `disconnect`", nil
+		return fmt.Sprintf("%s `%s`", actionUnkown, actionDisconnect), nil
 	}
 
 	if p.configuration.AccountLevelApp {
@@ -253,6 +273,10 @@ func (p *Plugin) runDisconnectCommand(user *model.User) (string, error) {
 // runHelpCommand runs command to display help text.
 func (p *Plugin) runHelpCommand(user *model.User) (string, error) {
 	text := starterText + strings.ReplaceAll(helpText+"\n"+settingHelpText, "|", "`")
+	if p.API.HasPermissionTo(user.Id, model.PermissionManageSystem) {
+		text += "\n" + strings.ReplaceAll(channelPreferenceHelpText+"\n"+listChannelPreferenceHelpText, "|", "`")
+	}
+
 	if p.canConnect(user) {
 		text += "\n" + strings.ReplaceAll(oAuthHelpText, "|", "`")
 	}
@@ -275,7 +299,125 @@ func (p *Plugin) runSettingCommand(args *model.CommandArgs, params []string, use
 		}
 		return "", nil
 	}
-	return fmt.Sprintf("Unknown Action %v", ""), nil
+	return actionUnkown, nil
+}
+
+func (p *Plugin) runChannelSettingsCommand(args *model.CommandArgs, params []string, user *model.User) (string, error) {
+	if len(params) == 0 {
+		return p.runEditChannelSettingsCommand(args, user)
+	} else if params[0] == channelSettingsActionList {
+		return p.runChannelSettingsListCommand(args)
+	}
+
+	return actionUnkown, nil
+}
+
+func (p *Plugin) runEditChannelSettingsCommand(args *model.CommandArgs, user *model.User) (string, error) {
+	if !p.client.User.HasPermissionTo(args.UserId, model.PermissionManageChannelRoles) {
+		return "Unable to execute the command, only channel admins have access to execute this command.", nil
+	}
+
+	channel, appErr := p.client.Channel.Get(args.ChannelId)
+	if appErr != nil {
+		p.client.Log.Error("Unable to get channel", "ChannelID", args.ChannelId, "Error", appErr.Error())
+		return "Error occurred while fetching channel information", nil
+	}
+
+	if channel.Type == model.ChannelTypeDirect || channel.Type == model.ChannelTypeGroup {
+		return "Preference not allowed to set for DM/GM.", nil
+	}
+
+	requestBody := model.OpenDialogRequest{
+		TriggerId: args.TriggerId,
+		URL:       fmt.Sprintf("%s/plugins/%s%s", p.siteURL, manifest.Id, pathChannelPreference),
+		Dialog: model.Dialog{
+			Title:       "Set Channel Preference",
+			SubmitLabel: "Submit",
+			CallbackId:  channel.DisplayName,
+			Elements: []model.DialogElement{
+				{
+					DisplayName: fmt.Sprintf("Select your channel preference for ~%s", channel.DisplayName),
+					HelpText:    "Disable to restrict creating meetings in this channel.",
+					Name:        "preference",
+					Type:        "radio",
+					Options: []*model.PostActionOptions{
+						{
+							Text:  "Enable Zoom Meetings in this channel",
+							Value: "allow",
+						},
+						{
+							Text:  "Disable Zoom Meetings in this channel",
+							Value: "restrict",
+						},
+						{
+							Text:  fmt.Sprintf("Default to plugin-wide settings (%t)", p.getConfiguration().RestrictMeetingCreation),
+							Value: "default",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	client, _, err := p.getActiveClient(user)
+	if err != nil {
+		p.client.Log.Error("Unable to get the client", "Error", err.Error())
+		return "Unable to send request to open preference dialog", nil
+	}
+
+	if err := client.OpenDialogRequest(&requestBody); err != nil {
+		p.client.Log.Error("Failed to fulfill the request to open preference dialog", "Error", err.Error())
+		return "Unable to open the dialog for setting preference", nil
+	}
+
+	return "", nil
+}
+
+func (p *Plugin) runChannelSettingsListCommand(args *model.CommandArgs) (string, error) {
+	if !p.client.User.HasPermissionTo(args.UserId, model.PermissionManageSystem) {
+		return "Unable to execute the command, only system admins have access to execute this command.", nil
+	}
+
+	zoomChannelSettingsMap, err := p.listZoomChannelSettings()
+	if err != nil {
+		p.client.Log.Error(channelPreferenceListErr, "Error", err.Error())
+		return channelPreferenceListErr, nil
+	}
+
+	if len(zoomChannelSettingsMap) == 0 {
+		return "No channel preference present", nil
+	}
+
+	var sb strings.Builder
+	sb.WriteString("#### Channel preferences\n")
+	config := p.getConfiguration()
+	if config.RestrictMeetingCreation {
+		sb.WriteString("Default: Allow meetings only in private channels and DMs/GMs\n\n")
+	} else {
+		sb.WriteString("Default: Allow meetings in public channels, private channels, and DMs/GMs\n\n")
+	}
+
+	listChannelHeading := true
+	for key, value := range zoomChannelSettingsMap {
+		preference := value.Preference
+		channel, err := p.client.Channel.Get(key)
+		if err != nil {
+			p.client.Log.Error(channelPreferenceListErr, "Error", err.Error())
+			return channelPreferenceListErr, nil
+		}
+		if value.Preference == ZoomChannelPreferences[DefaultChannelRestrictionPreference] {
+			continue
+		}
+
+		if listChannelHeading {
+			sb.WriteString("| Channel ID | Channel Name | Preference |\n| :---- | :-------- | :-------- |")
+			listChannelHeading = false
+		}
+
+		sb.WriteString(fmt.Sprintf("\n|%s|%s|%s|", key, channel.DisplayName, preference))
+	}
+
+	return sb.String(), nil
 }
 
 func (p *Plugin) updateUserPersonalSettings(usePMIValue, userID string) *model.AppError {
@@ -293,9 +435,9 @@ func (p *Plugin) updateUserPersonalSettings(usePMIValue, userID string) *model.A
 func (p *Plugin) getAutocompleteData() *model.AutocompleteData {
 	canConnect := !p.configuration.AccountLevelApp
 
-	available := "start, help, settings"
+	available := "start, help, settings, channel-settings"
 	if canConnect {
-		available = "start, connect, disconnect, help, settings"
+		available = "start, connect, disconnect, help, settings, channel-settings"
 	}
 
 	zoom := model.NewAutocompleteData("zoom", "[command]", fmt.Sprintf("Available commands: %s", available))
@@ -314,6 +456,13 @@ func (p *Plugin) getAutocompleteData() *model.AutocompleteData {
 	setting := model.NewAutocompleteData("settings", "", "Update your meeting ID preferences")
 	zoom.AddCommand(setting)
 
+	// channel-settings to update channel preferences
+	channelSettings := model.NewAutocompleteData("channel-settings", "", "Update current channel preference")
+	channelSettingsList := model.NewAutocompleteData("list", "", "List all the channel preferences")
+	channelSettings.AddCommand(channelSettingsList)
+	channelSettings.RoleID = model.SystemAdminRoleId
+	zoom.AddCommand(channelSettings)
+
 	help := model.NewAutocompleteData("help", "", "Display usage")
 	zoom.AddCommand(help)
 

server/configuration.go

@@ -41,6 +41,10 @@ type configuration struct {
 
 	// ZoomWebhookSecret is the `Secret Token` taken from Zoom's webhook configuration page
 	ZoomWebhookSecret string
+
+	// RestrictMeetingCreation allows the admin to by default restrict zoom meetings to only private channels.
+	// The admin can also edit each channel's behavior with the `/zoom channel-settings` command
+	RestrictMeetingCreation bool
 }
 
 // Clone shallow copies the configuration. Your implementation may require a deep copy if