Using idiomatic error handling in channel store (#9130)

store/sqlstore/channel_store.go

@@ -305,19 +305,24 @@ func (s SqlChannelStore) Save(channel *model.Channel, maxChannelsPerTeam int64)
 	return store.Do(func(result *store.StoreResult) {
 		if channel.Type == model.CHANNEL_DIRECT {
 			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.direct_channel.app_error", nil, "", http.StatusBadRequest)
-		} else {
+			return
-			if transaction, err := s.GetMaster().Begin(); err != nil {
+		}
+
+		transaction, err := s.GetMaster().Begin()
+		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			} else {
+			return
+		}
+
 		*result = s.saveChannelT(transaction, channel, maxChannelsPerTeam)
 		if result.Err != nil {
 			transaction.Rollback()
-				} else {
+			return
+		}
+
 		if err := transaction.Commit(); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.Save", "store.sql_channel.save.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-					}
+			return
-				}
-			}
 		}
 	})
 }
@@ -349,10 +354,15 @@ func (s SqlChannelStore) SaveDirectChannel(directchannel *model.Channel, member1
 	return store.Do(func(result *store.StoreResult) {
 		if directchannel.Type != model.CHANNEL_DIRECT {
 			result.Err = model.NewAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.not_direct.app_error", nil, "", http.StatusBadRequest)
-		} else {
+			return
-			if transaction, err := s.GetMaster().Begin(); err != nil {
+		}
+
+		transaction, err := s.GetMaster().Begin()
+		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			} else {
+			return
+		}
+
 		directchannel.TeamId = ""
 		channelResult := s.saveChannelT(transaction, directchannel, 0)
 
@@ -360,7 +370,9 @@ func (s SqlChannelStore) SaveDirectChannel(directchannel *model.Channel, member1
 			transaction.Rollback()
 			result.Err = channelResult.Err
 			result.Data = channelResult.Data
-				} else {
+			return
+		}
+
 		newChannel := channelResult.Data.(*model.Channel)
 		// Members need new channel ID
 		member1.ChannelId = newChannel.Id
@@ -382,16 +394,15 @@ func (s SqlChannelStore) SaveDirectChannel(directchannel *model.Channel, member1
 				details += "Member2Err: " + member2Result.Err.Message
 			}
 			result.Err = model.NewAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.add_members.app_error", nil, details, http.StatusInternalServerError)
-					} else {
+			return
+		}
+
 		if err := transaction.Commit(); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.SaveDirectChannel", "store.sql_channel.save_direct_channel.commit.app_error", nil, err.Error(), http.StatusInternalServerError)
-						} else {
+			return
+		}
+
 		*result = channelResult
-						}
-					}
-				}
-			}
-		}
 	})
 }
 
@@ -446,23 +457,28 @@ func (s SqlChannelStore) Update(channel *model.Channel) store.StoreChannel {
 			return
 		}
 
-		if count, err := s.GetMaster().Update(channel); err != nil {
+		count, err := s.GetMaster().Update(channel)
+		if err != nil {
 			if IsUniqueConstraintError(err, []string{"Name", "channels_name_teamid_key"}) {
 				dupChannel := model.Channel{}
 				s.GetReplica().SelectOne(&dupChannel, "SELECT * FROM Channels WHERE TeamId = :TeamId AND Name= :Name AND DeleteAt > 0", map[string]interface{}{"TeamId": channel.TeamId, "Name": channel.Name})
 				if dupChannel.DeleteAt > 0 {
 					result.Err = model.NewAppError("SqlChannelStore.Update", "store.sql_channel.update.previously.app_error", nil, "id="+channel.Id+", "+err.Error(), http.StatusBadRequest)
-				} else {
+					return
+				}
 				result.Err = model.NewAppError("SqlChannelStore.Update", "store.sql_channel.update.exists.app_error", nil, "id="+channel.Id+", "+err.Error(), http.StatusBadRequest)
+				return
 			}
-			} else {
 			result.Err = model.NewAppError("SqlChannelStore.Update", "store.sql_channel.update.updating.app_error", nil, "id="+channel.Id+", "+err.Error(), http.StatusInternalServerError)
+			return
 		}
-		} else if count != 1 {
+
+		if count != 1 {
 			result.Err = model.NewAppError("SqlChannelStore.Update", "store.sql_channel.update.app_error", nil, "id="+channel.Id, http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = channel
 		}
+
+		result.Data = channel
 	})
 }
 
@@ -548,25 +564,26 @@ func (s SqlChannelStore) get(id string, master bool, allowFromCache bool) store.
 				}
 				result.Data = (cacheItem.(*model.Channel)).DeepCopy()
 				return
-			} else {
-				if s.metrics != nil {
-					s.metrics.IncrementMemCacheMissCounter("Channel")
-				}
-			}
-		} else {
-			if s.metrics != nil {
-				s.metrics.IncrementMemCacheMissCounter("Channel")
 			}
 		}
 
-		if obj, err := db.Get(model.Channel{}, id); err != nil {
+		if s.metrics != nil {
+			s.metrics.IncrementMemCacheMissCounter("Channel")
+		}
+
+		obj, err := db.Get(model.Channel{}, id)
+		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.Get", "store.sql_channel.get.find.app_error", nil, "id="+id+", "+err.Error(), http.StatusInternalServerError)
-		} else if obj == nil {
+			return
+		}
+
+		if obj == nil {
 			result.Err = model.NewAppError("SqlChannelStore.Get", "store.sql_channel.get.existing.app_error", nil, "id="+id, http.StatusNotFound)
-		} else {
+			return
+		}
+
 		result.Data = obj.(*model.Channel)
 		channelCache.AddWithExpiresInSecs(id, obj.(*model.Channel), CHANNEL_CACHE_SEC)
-		}
 	})
 }
 
@@ -619,13 +636,15 @@ func (s SqlChannelStore) GetChannels(teamId string, userId string) store.StoreCh
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetChannels", "store.sql_channel.get_channels.get.app_error", nil, "teamId="+teamId+", userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
+		}
+
 		if len(*data) == 0 {
 			result.Err = model.NewAppError("SqlChannelStore.GetChannels", "store.sql_channel.get_channels.not_found.app_error", nil, "teamId="+teamId+", userId="+userId, http.StatusBadRequest)
-			} else {
+			return
+		}
+
 		result.Data = data
-			}
-		}
 	})
 }
 
@@ -658,9 +677,10 @@ func (s SqlChannelStore) GetMoreChannels(teamId string, userId string, offset in
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetMoreChannels", "store.sql_channel.get_more_channels.get.app_error", nil, "teamId="+teamId+", userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = data
 		}
+
+		result.Data = data
 	})
 }
 
@@ -683,9 +703,10 @@ func (s SqlChannelStore) GetPublicChannelsForTeam(teamId string, offset int, lim
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetPublicChannelsForTeam", "store.sql_channel.get_public_channels.get.app_error", nil, "teamId="+teamId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = data
 		}
+
+		result.Data = data
 	})
 }
 
@@ -744,7 +765,9 @@ func (s SqlChannelStore) GetChannelCounts(teamId string, userId string) store.St
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetChannelCounts", "store.sql_channel.get_channel_counts.get.app_error", nil, "teamId="+teamId+", userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
+		}
+
 		counts := &model.ChannelCounts{Counts: make(map[string]int64), UpdateTimes: make(map[string]int64)}
 		for i := range data {
 			v := data[i]
@@ -753,7 +776,6 @@ func (s SqlChannelStore) GetChannelCounts(teamId string, userId string) store.St
 		}
 
 		result.Data = counts
-		}
 	})
 }
 
@@ -764,13 +786,15 @@ func (s SqlChannelStore) GetTeamChannels(teamId string) store.StoreChannel {
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetChannels", "store.sql_channel.get_channels.get.app_error", nil, "teamId="+teamId+",  err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
+		}
+
 		if len(*data) == 0 {
 			result.Err = model.NewAppError("SqlChannelStore.GetChannels", "store.sql_channel.get_channels.not_found.app_error", nil, "teamId="+teamId, http.StatusNotFound)
-			} else {
+			return
+		}
+
 		result.Data = data
-			}
-		}
 	})
 }
 
@@ -858,22 +882,23 @@ func (s SqlChannelStore) getByName(teamId string, name string, includeDeleted bo
 				}
 				result.Data = cacheItem.(*model.Channel)
 				return
-			} else {
+			}
 			if s.metrics != nil {
 				s.metrics.IncrementMemCacheMissCounter("Channel By Name")
 			}
 		}
-		}
+
 		if err := s.GetReplica().SelectOne(&channel, query, map[string]interface{}{"TeamId": teamId, "Name": name}); err != nil {
 			if err == sql.ErrNoRows {
 				result.Err = model.NewAppError("SqlChannelStore.GetByName", store.MISSING_CHANNEL_ERROR, nil, "teamId="+teamId+", "+"name="+name+", "+err.Error(), http.StatusNotFound)
-			} else {
+				return
-				result.Err = model.NewAppError("SqlChannelStore.GetByName", "store.sql_channel.get_by_name.existing.app_error", nil, "teamId="+teamId+", "+"name="+name+", "+err.Error(), http.StatusInternalServerError)
 			}
-		} else {
+			result.Err = model.NewAppError("SqlChannelStore.GetByName", "store.sql_channel.get_by_name.existing.app_error", nil, "teamId="+teamId+", "+"name="+name+", "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+
 		result.Data = &channel
 		channelByNameCache.AddWithExpiresInSecs(teamId+name, &channel, CHANNEL_CACHE_SEC)
-		}
 	})
 }
 
@@ -884,12 +909,13 @@ func (s SqlChannelStore) GetDeletedByName(teamId string, name string) store.Stor
 		if err := s.GetReplica().SelectOne(&channel, "SELECT * FROM Channels WHERE (TeamId = :TeamId OR TeamId = '') AND Name = :Name AND DeleteAt != 0", map[string]interface{}{"TeamId": teamId, "Name": name}); err != nil {
 			if err == sql.ErrNoRows {
 				result.Err = model.NewAppError("SqlChannelStore.GetDeletedByName", "store.sql_channel.get_deleted_by_name.missing.app_error", nil, "teamId="+teamId+", "+"name="+name+", "+err.Error(), http.StatusNotFound)
-			} else {
+				return
+			}
 			result.Err = model.NewAppError("SqlChannelStore.GetDeletedByName", "store.sql_channel.get_deleted_by_name.existing.app_error", nil, "teamId="+teamId+", "+"name="+name+", "+err.Error(), http.StatusInternalServerError)
+			return
 		}
-		} else {
+
 		result.Data = &channel
-		}
 	})
 }
 
@@ -900,12 +926,13 @@ func (s SqlChannelStore) GetDeleted(teamId string, offset int, limit int) store.
 		if _, err := s.GetReplica().Select(channels, "SELECT * FROM Channels WHERE (TeamId = :TeamId OR TeamId = '') AND DeleteAt != 0 ORDER BY DisplayName LIMIT :Limit OFFSET :Offset", map[string]interface{}{"TeamId": teamId, "Limit": limit, "Offset": offset}); err != nil {
 			if err == sql.ErrNoRows {
 				result.Err = model.NewAppError("SqlChannelStore.GetDeleted", "store.sql_channel.get_deleted.missing.app_error", nil, "teamId="+teamId+", "+err.Error(), http.StatusNotFound)
-			} else {
+				return
+			}
 			result.Err = model.NewAppError("SqlChannelStore.GetDeleted", "store.sql_channel.get_deleted.existing.app_error", nil, "teamId="+teamId+", "+err.Error(), http.StatusInternalServerError)
+			return
 		}
-		} else {
+
 		result.Data = channels
-		}
 	})
 }
 
@@ -930,27 +957,33 @@ var CHANNEL_MEMBERS_WITH_SCHEME_SELECT_QUERY = `
 
 func (s SqlChannelStore) SaveMember(member *model.ChannelMember) store.StoreChannel {
 	return store.Do(func(result *store.StoreResult) {
+		defer s.InvalidateAllChannelMembersForUser(member.UserId)
+
 		// Grab the channel we are saving this member to
-		if cr := <-s.GetFromMaster(member.ChannelId); cr.Err != nil {
+		cr := <-s.GetFromMaster(member.ChannelId)
+		if cr.Err != nil {
 			result.Err = cr.Err
-		} else {
+			return
+		}
+
 		channel := cr.Data.(*model.Channel)
 
-			if transaction, err := s.GetMaster().Begin(); err != nil {
+		transaction, err := s.GetMaster().Begin()
+		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.SaveMember", "store.sql_channel.save_member.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			} else {
+			return
+		}
+
 		*result = s.saveMemberT(transaction, member, channel)
 		if result.Err != nil {
 			transaction.Rollback()
-				} else {
+			return
-					if err := transaction.Commit(); err != nil {
-						result.Err = model.NewAppError("SqlChannelStore.SaveMember", "store.sql_channel.save_member.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-					}
-				}
-			}
 		}
 
-		s.InvalidateAllChannelMembersForUser(member.UserId)
+		if err := transaction.Commit(); err != nil {
+			result.Err = model.NewAppError("SqlChannelStore.SaveMember", "store.sql_channel.save_member.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return
+		}
 	})
 }
 
@@ -967,22 +1000,23 @@ func (s SqlChannelStore) saveMemberT(transaction *gorp.Transaction, member *mode
 	if err := transaction.Insert(dbMember); err != nil {
 		if IsUniqueConstraintError(err, []string{"ChannelId", "channelmembers_pkey"}) {
 			result.Err = model.NewAppError("SqlChannelStore.SaveMember", "store.sql_channel.save_member.exists.app_error", nil, "channel_id="+member.ChannelId+", user_id="+member.UserId+", "+err.Error(), http.StatusBadRequest)
-		} else {
+			return result
-			result.Err = model.NewAppError("SqlChannelStore.SaveMember", "store.sql_channel.save_member.save.app_error", nil, "channel_id="+member.ChannelId+", user_id="+member.UserId+", "+err.Error(), http.StatusInternalServerError)
 		}
-	} else {
+		result.Err = model.NewAppError("SqlChannelStore.SaveMember", "store.sql_channel.save_member.save.app_error", nil, "channel_id="+member.ChannelId+", user_id="+member.UserId+", "+err.Error(), http.StatusInternalServerError)
+		return result
+	}
+
 	var retrievedMember channelMemberWithSchemeRoles
 	if err := transaction.SelectOne(&retrievedMember, CHANNEL_MEMBERS_WITH_SCHEME_SELECT_QUERY+"WHERE ChannelMembers.ChannelId = :ChannelId AND ChannelMembers.UserId = :UserId", map[string]interface{}{"ChannelId": dbMember.ChannelId, "UserId": dbMember.UserId}); err != nil {
 		if err == sql.ErrNoRows {
 			result.Err = model.NewAppError("SqlChannelStore.GetMember", store.MISSING_CHANNEL_MEMBER_ERROR, nil, "channel_id="+dbMember.ChannelId+"user_id="+dbMember.UserId+","+err.Error(), http.StatusNotFound)
-			} else {
+			return result
+		}
 		result.Err = model.NewAppError("SqlChannelStore.GetMember", "store.sql_channel.get_member.app_error", nil, "channel_id="+dbMember.ChannelId+"user_id="+dbMember.UserId+","+err.Error(), http.StatusInternalServerError)
-			}
+		return result
-		} else {
-			result.Data = retrievedMember.ToModel()
-		}
 	}
 
+	result.Data = retrievedMember.ToModel()
 	return result
 }
 
@@ -996,19 +1030,20 @@ func (s SqlChannelStore) UpdateMember(member *model.ChannelMember) store.StoreCh
 
 		if _, err := s.GetMaster().Update(NewChannelMemberFromModel(member)); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.UpdateMember", "store.sql_channel.update_member.app_error", nil, "channel_id="+member.ChannelId+", "+"user_id="+member.UserId+", "+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
+		}
+
 		var dbMember channelMemberWithSchemeRoles
 
 		if err := s.GetReplica().SelectOne(&dbMember, CHANNEL_MEMBERS_WITH_SCHEME_SELECT_QUERY+"WHERE ChannelMembers.ChannelId = :ChannelId AND ChannelMembers.UserId = :UserId", map[string]interface{}{"ChannelId": member.ChannelId, "UserId": member.UserId}); err != nil {
 			if err == sql.ErrNoRows {
 				result.Err = model.NewAppError("SqlChannelStore.GetMember", store.MISSING_CHANNEL_MEMBER_ERROR, nil, "channel_id="+member.ChannelId+"user_id="+member.UserId+","+err.Error(), http.StatusNotFound)
-				} else {
+				return
+			}
 			result.Err = model.NewAppError("SqlChannelStore.GetMember", "store.sql_channel.get_member.app_error", nil, "channel_id="+member.ChannelId+"user_id="+member.UserId+","+err.Error(), http.StatusInternalServerError)
+			return
 		}
-			} else {
 		result.Data = dbMember.ToModel()
-			}
-		}
 	})
 }
 
@@ -1018,9 +1053,10 @@ func (s SqlChannelStore) GetMembers(channelId string, offset, limit int) store.S
 		_, err := s.GetReplica().Select(&dbMembers, CHANNEL_MEMBERS_WITH_SCHEME_SELECT_QUERY+"WHERE ChannelId = :ChannelId LIMIT :Limit OFFSET :Offset", map[string]interface{}{"ChannelId": channelId, "Limit": limit, "Offset": offset})
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetMembers", "store.sql_channel.get_members.app_error", nil, "channel_id="+channelId+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = dbMembers.ToModel()
 		}
+
+		result.Data = dbMembers.ToModel()
 	})
 }
 
@@ -1031,12 +1067,13 @@ func (s SqlChannelStore) GetMember(channelId string, userId string) store.StoreC
 		if err := s.GetReplica().SelectOne(&dbMember, CHANNEL_MEMBERS_WITH_SCHEME_SELECT_QUERY+"WHERE ChannelMembers.ChannelId = :ChannelId AND ChannelMembers.UserId = :UserId", map[string]interface{}{"ChannelId": channelId, "UserId": userId}); err != nil {
 			if err == sql.ErrNoRows {
 				result.Err = model.NewAppError("SqlChannelStore.GetMember", store.MISSING_CHANNEL_MEMBER_ERROR, nil, "channel_id="+channelId+"user_id="+userId+","+err.Error(), http.StatusNotFound)
-			} else {
+				return
+			}
 			result.Err = model.NewAppError("SqlChannelStore.GetMember", "store.sql_channel.get_member.app_error", nil, "channel_id="+channelId+"user_id="+userId+","+err.Error(), http.StatusInternalServerError)
+			return
 		}
-		} else {
+
 		result.Data = dbMember.ToModel()
-		}
 	})
 }
 
@@ -1055,27 +1092,27 @@ func (s SqlChannelStore) IsUserInChannelUseCache(userId string, channelId string
 		ids := cacheItem.(map[string]string)
 		if _, ok := ids[channelId]; ok {
 			return true
-		} else {
+		}
 		return false
 	}
-	} else {
+
 	if s.metrics != nil {
 		s.metrics.IncrementMemCacheMissCounter("All Channel Members for User")
 	}
-	}
 
-	if result := <-s.GetAllChannelMembersForUser(userId, true); result.Err != nil {
+	result := <-s.GetAllChannelMembersForUser(userId, true)
+	if result.Err != nil {
 		mlog.Error("SqlChannelStore.IsUserInChannelUseCache: " + result.Err.Error())
 		return false
-	} else {
+	}
+
 	ids := result.Data.(map[string]string)
 	if _, ok := ids[channelId]; ok {
 		return true
-		} else {
+	}
+
 	return false
 }
-	}
-}
 
 func (s SqlChannelStore) GetMemberForPost(postId string, userId string) store.StoreChannel {
 	return store.Do(func(result *store.StoreResult) {
@@ -1104,9 +1141,9 @@ func (s SqlChannelStore) GetMemberForPost(postId string, userId string) store.St
 				ChannelMembers.UserId = :UserId
 				AND Posts.Id = :PostId`, map[string]interface{}{"UserId": userId, "PostId": postId}); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetMemberForPost", "store.sql_channel.get_member_for_post.app_error", nil, "postId="+postId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = dbMember.ToModel()
 		}
+		result.Data = dbMember.ToModel()
 	})
 }
 
@@ -1119,16 +1156,12 @@ func (s SqlChannelStore) GetAllChannelMembersForUser(userId string, allowFromCac
 				}
 				result.Data = cacheItem.(map[string]string)
 				return
-			} else {
+			}
+		}
+
 		if s.metrics != nil {
 			s.metrics.IncrementMemCacheMissCounter("All Channel Members for User")
 		}
-			}
-		} else {
-			if s.metrics != nil {
-				s.metrics.IncrementMemCacheMissCounter("All Channel Members for User")
-			}
-		}
 
 		var data allChannelMembers
 		_, err := s.GetReplica().Select(&data, `
@@ -1154,15 +1187,15 @@ func (s SqlChannelStore) GetAllChannelMembersForUser(userId string, allowFromCac
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetAllChannelMembersForUser", "store.sql_channel.get_channels.get.app_error", nil, "userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			ids := data.ToMapStringString()
+		}
 
+		ids := data.ToMapStringString()
 		result.Data = ids
 
 		if allowFromCache {
 			allChannelMembersForUserCache.AddWithExpiresInSecs(userId, ids, ALL_CHANNEL_MEMBERS_FOR_USER_CACHE_SEC)
 		}
-		}
 	})
 }
 
@@ -1187,16 +1220,12 @@ func (s SqlChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelId str
 				}
 				result.Data = cacheItem.(map[string]model.StringMap)
 				return
-			} else {
+			}
+		}
+
 		if s.metrics != nil {
 			s.metrics.IncrementMemCacheMissCounter("All Channel Members Notify Props for Channel")
 		}
-			}
-		} else {
-			if s.metrics != nil {
-				s.metrics.IncrementMemCacheMissCounter("All Channel Members Notify Props for Channel")
-			}
-		}
 
 		var data []allChannelMemberNotifyProps
 		_, err := s.GetReplica().Select(&data, `
@@ -1206,7 +1235,8 @@ func (s SqlChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelId str
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetAllChannelMembersPropsForChannel", "store.sql_channel.get_members.app_error", nil, "channelId="+channelId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
+		}
 
 		props := make(map[string]model.StringMap)
 		for i := range data {
@@ -1216,7 +1246,6 @@ func (s SqlChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelId str
 		result.Data = props
 
 		allChannelMembersNotifyPropsForChannelCache.AddWithExpiresInSecs(channelId, props, ALL_CHANNEL_MEMBERS_NOTIFY_PROPS_FOR_CHANNEL_CACHE_SEC)
-		}
 	})
 }
 
@@ -1233,18 +1262,19 @@ func (s SqlChannelStore) GetMemberCountFromCache(channelId string) int64 {
 			s.metrics.IncrementMemCacheHitCounter("Channel Member Counts")
 		}
 		return cacheItem.(int64)
-	} else {
+	}
+
 	if s.metrics != nil {
 		s.metrics.IncrementMemCacheMissCounter("Channel Member Counts")
 	}
+
+	result := <-s.GetMemberCount(channelId, true)
+	if result.Err != nil {
+		return 0
 	}
 
-	if result := <-s.GetMemberCount(channelId, true); result.Err != nil {
-		return 0
-	} else {
 	return result.Data.(int64)
 }
-}
 
 func (s SqlChannelStore) GetMemberCount(channelId string, allowFromCache bool) store.StoreChannel {
 	return store.Do(func(result *store.StoreResult) {
@@ -1255,16 +1285,12 @@ func (s SqlChannelStore) GetMemberCount(channelId string, allowFromCache bool) s
 				}
 				result.Data = cacheItem.(int64)
 				return
-			} else {
+			}
+		}
+
 		if s.metrics != nil {
 			s.metrics.IncrementMemCacheMissCounter("Channel Member Counts")
 		}
-			}
-		} else {
-			if s.metrics != nil {
-				s.metrics.IncrementMemCacheMissCounter("Channel Member Counts")
-			}
-		}
 
 		count, err := s.GetReplica().SelectInt(`
 			SELECT
@@ -1278,13 +1304,13 @@ func (s SqlChannelStore) GetMemberCount(channelId string, allowFromCache bool) s
 				AND Users.DeleteAt = 0`, map[string]interface{}{"ChannelId": channelId})
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetMemberCount", "store.sql_channel.get_member_count.app_error", nil, "channel_id="+channelId+", "+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
+		}
 		result.Data = count
 
 		if allowFromCache {
 			channelMemberCountsCache.AddWithExpiresInSecs(channelId, count, CHANNEL_MEMBERS_COUNTS_CACHE_SEC)
 		}
-		}
 	})
 }
 
@@ -1379,9 +1405,10 @@ func (s SqlChannelStore) UpdateLastViewedAt(channelIds []string, userId string)
 
 		if _, err := s.GetMaster().Exec(updateQuery, props); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.UpdateLastViewedAt", "store.sql_channel.update_last_viewed_at.app_error", nil, "channel_ids="+strings.Join(channelIds, ",")+", user_id="+userId+", "+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = times
 		}
+
+		result.Data = times
 	})
 }
 
@@ -1410,9 +1437,10 @@ func (s SqlChannelStore) GetAll(teamId string) store.StoreChannel {
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetAll", "store.sql_channel.get_all.app_error", nil, "teamId="+teamId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = data
 		}
+
+		result.Data = data
 	})
 }
 
@@ -1430,9 +1458,10 @@ func (s SqlChannelStore) GetForPost(postId string) store.StoreChannel {
 				Channels.Id = Posts.ChannelId
 				AND Posts.Id = :PostId`, map[string]interface{}{"PostId": postId}); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetForPost", "store.sql_channel.get_for_post.app_error", nil, "postId="+postId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = channel
 		}
+
+		result.Data = channel
 	})
 }
 
@@ -1447,9 +1476,10 @@ func (s SqlChannelStore) AnalyticsTypeCount(teamId string, channelType string) s
 		v, err := s.GetReplica().SelectInt(query, map[string]interface{}{"TeamId": teamId, "ChannelType": channelType})
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.AnalyticsTypeCount", "store.sql_channel.analytics_type_count.app_error", nil, err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = v
 		}
+
+		result.Data = v
 	})
 }
 
@@ -1464,9 +1494,10 @@ func (s SqlChannelStore) AnalyticsDeletedTypeCount(teamId string, channelType st
 		v, err := s.GetReplica().SelectInt(query, map[string]interface{}{"TeamId": teamId, "ChannelType": channelType})
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.AnalyticsDeletedTypeCount", "store.sql_channel.analytics_deleted_type_count.app_error", nil, err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = v
 		}
+
+		result.Data = v
 	})
 }
 
@@ -1477,9 +1508,10 @@ func (s SqlChannelStore) GetMembersForUser(teamId string, userId string) store.S
 
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetMembersForUser", "store.sql_channel.get_members.app_error", nil, "teamId="+teamId+", userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = dbMembers.ToModel()
 		}
+
+		result.Data = dbMembers.ToModel()
 	})
 }
 
@@ -1663,10 +1695,10 @@ func (s SqlChannelStore) performSearch(searchQuery string, term string, paramete
 
 	if _, err := s.GetReplica().Select(&channels, searchQuery, parameters); err != nil {
 		result.Err = model.NewAppError("SqlChannelStore.Search", "store.sql_channel.search.app_error", nil, "term="+term+", "+", "+err.Error(), http.StatusInternalServerError)
-	} else {
+		return result
-		result.Data = &channels
 	}
 
+	result.Data = &channels
 	return result
 }
 
@@ -1689,9 +1721,10 @@ func (s SqlChannelStore) GetMembersByIds(channelId string, userIds []string) sto
 
 		if _, err := s.GetReplica().Select(&dbMembers, CHANNEL_MEMBERS_WITH_SCHEME_SELECT_QUERY+"WHERE ChannelMembers.ChannelId = :ChannelId AND ChannelMembers.UserId IN ("+idQuery+")", props); err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetMembersByIds", "store.sql_channel.get_members_by_ids.app_error", nil, "channelId="+channelId+" "+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = dbMembers.ToModel()
 		}
+
+		result.Data = dbMembers.ToModel()
 	})
 }
 
@@ -1701,9 +1734,9 @@ func (s SqlChannelStore) GetChannelsByScheme(schemeId string, offset int, limit
 		_, err := s.GetReplica().Select(&channels, "SELECT * FROM Channels WHERE SchemeId = :SchemeId ORDER BY DisplayName LIMIT :Limit OFFSET :Offset", map[string]interface{}{"SchemeId": schemeId, "Offset": offset, "Limit": limit})
 		if err != nil {
 			result.Err = model.NewAppError("SqlChannelStore.GetChannelsByScheme", "store.sql_channel.get_by_scheme.app_error", nil, "schemeId="+schemeId+" "+err.Error(), http.StatusInternalServerError)
-		} else {
+			return
-			result.Data = channels
 		}
+		result.Data = channels
 	})
 }