MM-31064: Simplify indentation (#16565)

* MM-31064: Simplify indentation

Reduce indentation where possible.

```release-note
NONE
```

Command ran to verify:
golangci-lint run --disable-all --enable golint --max-issues-per-linter=10000 --max-same-issues=100000 ./... | grep "block ends with a return state"

https://mattermost.atlassian.net/browse/MM-31064

* incorporate review comments

* enable golint for outdent rule

* fix remaining issues

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>

app/emoji.go

@@ -281,16 +281,16 @@ func (a *App) GetEmojiStaticUrl(emojiName string) (string, *model.AppError) {
 		return path.Join(subPath, "/static/emoji", id+".png"), nil
 	}
 
-	if emoji, err := a.Srv().Store.Emoji().GetByName(emojiName, true); err == nil {
+	emoji, err := a.Srv().Store.Emoji().GetByName(emojiName, true)
+	if err == nil {
 		return path.Join(subPath, "/api/v4/emoji", emoji.Id, "image"), nil
-	} else {
-		var nfErr *store.ErrNotFound
-		switch {
-		case errors.As(err, &nfErr):
-			return "", model.NewAppError("GetEmojiStaticUrl", "app.emoji.get_by_name.no_result", nil, err.Error(), http.StatusNotFound)
-		default:
-			return "", model.NewAppError("GetEmojiStaticUrl", "app.emoji.get_by_name.app_error", nil, err.Error(), http.StatusInternalServerError)
-		}
+	}
+	var nfErr *store.ErrNotFound
+	switch {
+	case errors.As(err, &nfErr):
+		return "", model.NewAppError("GetEmojiStaticUrl", "app.emoji.get_by_name.no_result", nil, err.Error(), http.StatusNotFound)
+	default:
+		return "", model.NewAppError("GetEmojiStaticUrl", "app.emoji.get_by_name.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 }
 

app/helper_test.go

@@ -629,31 +629,27 @@ func (th *TestHelper) CheckChannelsCount(t *testing.T, expected int64) {
 }
 
 func (th *TestHelper) SetupTeamScheme() *model.Scheme {
-	scheme := model.Scheme{
+	scheme, err := th.App.CreateScheme(&model.Scheme{
 		Name:        model.NewId(),
 		DisplayName: model.NewId(),
 		Scope:       model.SCHEME_SCOPE_TEAM,
-	}
-
-	if scheme, err := th.App.CreateScheme(&scheme); err == nil {
-		return scheme
-	} else {
+	})
+	if err != nil {
 		panic(err)
 	}
+	return scheme
 }
 
 func (th *TestHelper) SetupChannelScheme() *model.Scheme {
-	scheme := model.Scheme{
+	scheme, err := th.App.CreateScheme(&model.Scheme{
 		Name:        model.NewId(),
 		DisplayName: model.NewId(),
 		Scope:       model.SCHEME_SCOPE_CHANNEL,
-	}
-
-	if scheme, err := th.App.CreateScheme(&scheme); err == nil {
-		return scheme
-	} else {
+	})
+	if err != nil {
 		panic(err)
 	}
+	return scheme
 }
 
 func (th *TestHelper) SetupPluginAPI() *PluginAPI {

app/integration_action.go

@@ -238,13 +238,12 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
 			return "", appErr
 		}
 		return "", nil
-	} else {
-		resp, appErr = a.DoActionRequest(upstreamURL, upstreamRequest.ToJson())
-		if appErr != nil {
-			return "", appErr
-		}
-		defer resp.Body.Close()
 	}
+	resp, appErr = a.DoActionRequest(upstreamURL, upstreamRequest.ToJson())
+	if appErr != nil {
+		return "", appErr
+	}
+	defer resp.Body.Close()
 
 	var response model.PostActionIntegrationResponse
 	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {

app/plugin_api.go

@@ -50,16 +50,16 @@ func (api *PluginAPI) LoadPluginConfiguration(dest interface{}) error {
 		finalConfig[strings.ToLower(setting)] = value
 	}
 
-	if pluginSettingsJsonBytes, err := json.Marshal(finalConfig); err != nil {
+	pluginSettingsJsonBytes, err := json.Marshal(finalConfig)
+	if err != nil {
 		api.logger.Error("Error marshaling config for plugin", mlog.Err(err))
 		return nil
-	} else {
-		err := json.Unmarshal(pluginSettingsJsonBytes, dest)
-		if err != nil {
-			api.logger.Error("Error unmarshaling config for plugin", mlog.Err(err))
-		}
-		return nil
 	}
+	err = json.Unmarshal(pluginSettingsJsonBytes, dest)
+	if err != nil {
+		api.logger.Error("Error unmarshaling config for plugin", mlog.Err(err))
+	}
+	return nil
 }
 
 func (api *PluginAPI) RegisterCommand(command *model.Command) error {

app/post_metadata.go

@@ -534,9 +534,8 @@ func (a *App) parseLinkMetadata(requestURL string, body io.Reader, contentType s
 		// one of these required fields exists before returning the OpenGraph data
 		if og.Title != "" || og.Type != "" || og.URL != "" {
 			return og, nil, nil
-		} else {
-			return nil, nil, nil
 		}
+		return nil, nil, nil
 	} else {
 		// Not an image or web page with OpenGraph information
 		return nil, nil, nil

app/slashcommands/command_invite.go

@@ -113,14 +113,13 @@ func (*InviteProvider) DoCommand(a *app.App, args *model.CommandArgs, message st
 					}),
 					ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL,
 				}
-			} else {
-				// User doing the inviting is *not* a member of the channel.
-				return &model.CommandResponse{
-					Text: args.T("api.command_invite.private_channel.app_error", map[string]interface{}{
-						"Channel": channelToJoin.Name,
-					}),
-					ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL,
-				}
+			}
+			// User doing the inviting is *not* a member of the channel.
+			return &model.CommandResponse{
+				Text: args.T("api.command_invite.private_channel.app_error", map[string]interface{}{
+					"Channel": channelToJoin.Name,
+				}),
+				ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL,
 			}
 		}
 	default:

app/slashcommands/command_msg.go

@@ -85,9 +85,8 @@ func (*msgProvider) DoCommand(a *app.App, args *model.CommandArgs, message strin
 			if directChannel, err = a.GetOrCreateDirectChannel(args.UserId, userProfile.Id); err != nil {
 				mlog.Error(err.Error())
 				return &model.CommandResponse{Text: args.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-			} else {
-				targetChannelId = directChannel.Id
 			}
+			targetChannelId = directChannel.Id
 		} else {
 			mlog.Error(channelErr.Error())
 			return &model.CommandResponse{Text: args.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}

app/slashcommands/command_mute.go

@@ -70,14 +70,12 @@ func (*MuteProvider) DoCommand(a *app.App, args *model.CommandArgs, message stri
 	if channel.Type == model.CHANNEL_DIRECT || channel.Type == model.CHANNEL_GROUP {
 		if channelMember.NotifyProps[model.MARK_UNREAD_NOTIFY_PROP] == model.CHANNEL_NOTIFY_MENTION {
 			return &model.CommandResponse{Text: args.T("api.command_mute.success_mute_direct_msg"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-		} else {
-			return &model.CommandResponse{Text: args.T("api.command_mute.success_unmute_direct_msg"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 		}
+		return &model.CommandResponse{Text: args.T("api.command_mute.success_unmute_direct_msg"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	}
 
 	if channelMember.NotifyProps[model.MARK_UNREAD_NOTIFY_PROP] == model.CHANNEL_NOTIFY_MENTION {
 		return &model.CommandResponse{Text: args.T("api.command_mute.success_mute", map[string]interface{}{"Channel": channel.DisplayName}), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-	} else {
-		return &model.CommandResponse{Text: args.T("api.command_mute.success_unmute", map[string]interface{}{"Channel": channel.DisplayName}), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	}
+	return &model.CommandResponse{Text: args.T("api.command_mute.success_unmute", map[string]interface{}{"Channel": channel.DisplayName}), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }

app/webhook.go

@@ -468,17 +468,16 @@ func (a *App) CreateOutgoingWebhook(hook *model.OutgoingWebhook) (*model.Outgoin
 		return nil, model.NewAppError("CreateOutgoingWebhook", "api.webhook.create_outgoing.triggers.app_error", nil, "", http.StatusBadRequest)
 	}
 
-	if allHooks, err := a.Srv().Store.Webhook().GetOutgoingByTeam(hook.TeamId, -1, -1); err != nil {
+	allHooks, err := a.Srv().Store.Webhook().GetOutgoingByTeam(hook.TeamId, -1, -1)
+	if err != nil {
 		return nil, model.NewAppError("CreateOutgoingWebhook", "app.webhooks.get_outgoing_by_team.app_error", nil, err.Error(), http.StatusInternalServerError)
-	} else {
+	}
+	for _, existingOutHook := range allHooks {
+		urlIntersect := utils.StringArrayIntersection(existingOutHook.CallbackURLs, hook.CallbackURLs)
+		triggerIntersect := utils.StringArrayIntersection(existingOutHook.TriggerWords, hook.TriggerWords)
 
-		for _, existingOutHook := range allHooks {
-			urlIntersect := utils.StringArrayIntersection(existingOutHook.CallbackURLs, hook.CallbackURLs)
-			triggerIntersect := utils.StringArrayIntersection(existingOutHook.TriggerWords, hook.TriggerWords)
-
-			if existingOutHook.ChannelId == hook.ChannelId && len(urlIntersect) != 0 && len(triggerIntersect) != 0 {
-				return nil, model.NewAppError("CreateOutgoingWebhook", "api.webhook.create_outgoing.intersect.app_error", nil, "", http.StatusInternalServerError)
-			}
+		if existingOutHook.ChannelId == hook.ChannelId && len(urlIntersect) != 0 && len(triggerIntersect) != 0 {
+			return nil, model.NewAppError("CreateOutgoingWebhook", "api.webhook.create_outgoing.intersect.app_error", nil, "", http.StatusInternalServerError)
 		}
 	}
 
@@ -667,11 +666,11 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
 	webhookType := req.Type
 
 	var hook *model.IncomingWebhook
-	if result := <-hchan; result.NErr != nil {
+	result := <-hchan
+	if result.NErr != nil {
 		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.invalid.app_error", nil, result.NErr.Error(), http.StatusBadRequest)
-	} else {
-		hook = result.Data.(*model.IncomingWebhook)
 	}
+	hook = result.Data.(*model.IncomingWebhook)
 
 	uchan := make(chan store.StoreResult, 1)
 	go func() {
@@ -699,15 +698,15 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
 
 	if len(channelName) != 0 {
 		if channelName[0] == '@' {
-			if result, err := a.Srv().Store.User().GetByUsername(channelName[1:]); err != nil {
-				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.user.app_error", nil, err.Error(), http.StatusBadRequest)
-			} else {
-				if ch, err := a.GetOrCreateDirectChannel(hook.UserId, result.Id); err != nil {
-					return err
-				} else {
-					channel = ch
-				}
+			result, nErr := a.Srv().Store.User().GetByUsername(channelName[1:])
+			if nErr != nil {
+				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.user.app_error", nil, nErr.Error(), http.StatusBadRequest)
 			}
+			ch, err := a.GetOrCreateDirectChannel(hook.UserId, result.Id)
+			if err != nil {
+				return err
+			}
+			channel = ch
 		} else if channelName[0] == '#' {
 			cchan = make(chan store.StoreResult, 1)
 			go func() {
@@ -738,18 +737,17 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
 	}
 
 	if channel == nil {
-		result := <-cchan
-		if result.NErr != nil {
+		result2 := <-cchan
+		if result2.NErr != nil {
 			var nfErr *store.ErrNotFound
 			switch {
-			case errors.As(result.NErr, &nfErr):
+			case errors.As(result2.NErr, &nfErr):
 				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.channel.app_error", nil, nfErr.Error(), http.StatusNotFound)
 			default:
-				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.channel.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+				return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.channel.app_error", nil, result2.NErr.Error(), http.StatusInternalServerError)
 			}
-		} else {
-			channel = result.Data.(*model.Channel)
 		}
+		channel = result2.Data.(*model.Channel)
 	}
 
 	if hook.ChannelLocked && hook.ChannelId != channel.Id {
@@ -757,11 +755,11 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
 	}
 
 	var user *model.User
-	if result := <-uchan; result.NErr != nil {
+	result = <-uchan
+	if result.NErr != nil {
 		return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.user.app_error", nil, result.NErr.Error(), http.StatusForbidden)
-	} else {
-		user = result.Data.(*model.User)
 	}
+	user = result.Data.(*model.User)
 
 	if a.Srv().License() != nil && *a.Config().TeamSettings.ExperimentalTownSquareIsReadOnly &&
 		channel.Name == model.DEFAULT_CHANNEL && !a.RolesGrantPermission(user.GetRoles(), model.PERMISSION_MANAGE_SYSTEM.Id) {