hanzoai/team
2
0
Fork 0
mirror of https://github.com/hanzoai/team.git synced 2026-09-30 01:57:35 +00:00
Code Issues Releases Activity
Files
release-10.9
team/server/channels/store/storetest/mocks/ChannelStore.go
T
Agniva De SarkerGitHubMattermost Build
 9b8739ca08 MM-56906: Remove redundant calls on team switch (#30771) 
On page load, we load ALL channels and channel members from all teams.
But then, on team_switch, we would again load channels and channel
members from that team. This was redundant and mainly kept
because previously the websocket events were considered unreliable.

Now with reliable websockets, and client-side pings, we can detect
broken connections faster and recover without loss.

Additionally, the getAllChannelMembers call would page through
all responses on the client side. This was inefficient and incur
extra latency. To optimize for this, we introduce server-side
streaming of the full response if page is set to -1.

This optimizes the intial response as well.

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

```release-note
Optimize team switch operation by removing calls to get channels
and channel members.
```


Co-authored-by: Mattermost Build <[email protected]>
2025-05-12 20:05:46 +05:30

3227 lines
89 KiB
Go
Raw Permalink Blame History

// Code generated by mockery v2.42.2. DO NOT EDIT.
// Regenerate this file using `make store-mocks`.
package mocks
import (
context "context"
model "github.com/mattermost/mattermost/server/public/model"
mock "github.com/stretchr/testify/mock"
request "github.com/mattermost/mattermost/server/public/shared/request"
store "github.com/mattermost/mattermost/server/v8/channels/store"
)
// ChannelStore is an autogenerated mock type for the ChannelStore type
type ChannelStore struct {
mock.Mock
}
// AnalyticsCountAll provides a mock function with given fields: teamID
func (_m *ChannelStore) AnalyticsCountAll(teamID string) (map[model.ChannelType]int64, error) {
ret := _m.Called(teamID)
if len(ret) == 0 {
panic("no return value specified for AnalyticsCountAll")
}
var r0 map[model.ChannelType]int64
var r1 error
if rf, ok := ret.Get(0).(func(string) (map[model.ChannelType]int64, error)); ok {
return rf(teamID)
}
if rf, ok := ret.Get(0).(func(string) map[model.ChannelType]int64); ok {
r0 = rf(teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[model.ChannelType]int64)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// AnalyticsDeletedTypeCount provides a mock function with given fields: teamID, channelType
func (_m *ChannelStore) AnalyticsDeletedTypeCount(teamID string, channelType model.ChannelType) (int64, error) {
ret := _m.Called(teamID, channelType)
if len(ret) == 0 {
panic("no return value specified for AnalyticsDeletedTypeCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(string, model.ChannelType) (int64, error)); ok {
return rf(teamID, channelType)
}
if rf, ok := ret.Get(0).(func(string, model.ChannelType) int64); ok {
r0 = rf(teamID, channelType)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(string, model.ChannelType) error); ok {
r1 = rf(teamID, channelType)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// AnalyticsTypeCount provides a mock function with given fields: teamID, channelType
func (_m *ChannelStore) AnalyticsTypeCount(teamID string, channelType model.ChannelType) (int64, error) {
ret := _m.Called(teamID, channelType)
if len(ret) == 0 {
panic("no return value specified for AnalyticsTypeCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(string, model.ChannelType) (int64, error)); ok {
return rf(teamID, channelType)
}
if rf, ok := ret.Get(0).(func(string, model.ChannelType) int64); ok {
r0 = rf(teamID, channelType)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(string, model.ChannelType) error); ok {
r1 = rf(teamID, channelType)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// Autocomplete provides a mock function with given fields: rctx, userID, term, includeDeleted, isGuest
func (_m *ChannelStore) Autocomplete(rctx request.CTX, userID string, term string, includeDeleted bool, isGuest bool) (model.ChannelListWithTeamData, error) {
ret := _m.Called(rctx, userID, term, includeDeleted, isGuest)
if len(ret) == 0 {
panic("no return value specified for Autocomplete")
}
var r0 model.ChannelListWithTeamData
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, string, string, bool, bool) (model.ChannelListWithTeamData, error)); ok {
return rf(rctx, userID, term, includeDeleted, isGuest)
}
if rf, ok := ret.Get(0).(func(request.CTX, string, string, bool, bool) model.ChannelListWithTeamData); ok {
r0 = rf(rctx, userID, term, includeDeleted, isGuest)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelListWithTeamData)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, string, string, bool, bool) error); ok {
r1 = rf(rctx, userID, term, includeDeleted, isGuest)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// AutocompleteInTeam provides a mock function with given fields: rctx, teamID, userID, term, includeDeleted, isGuest
func (_m *ChannelStore) AutocompleteInTeam(rctx request.CTX, teamID string, userID string, term string, includeDeleted bool, isGuest bool) (model.ChannelList, error) {
ret := _m.Called(rctx, teamID, userID, term, includeDeleted, isGuest)
if len(ret) == 0 {
panic("no return value specified for AutocompleteInTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, string, string, string, bool, bool) (model.ChannelList, error)); ok {
return rf(rctx, teamID, userID, term, includeDeleted, isGuest)
}
if rf, ok := ret.Get(0).(func(request.CTX, string, string, string, bool, bool) model.ChannelList); ok {
r0 = rf(rctx, teamID, userID, term, includeDeleted, isGuest)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, string, string, string, bool, bool) error); ok {
r1 = rf(rctx, teamID, userID, term, includeDeleted, isGuest)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// AutocompleteInTeamForSearch provides a mock function with given fields: teamID, userID, term, includeDeleted
func (_m *ChannelStore) AutocompleteInTeamForSearch(teamID string, userID string, term string, includeDeleted bool) (model.ChannelList, error) {
ret := _m.Called(teamID, userID, term, includeDeleted)
if len(ret) == 0 {
panic("no return value specified for AutocompleteInTeamForSearch")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, string, bool) (model.ChannelList, error)); ok {
return rf(teamID, userID, term, includeDeleted)
}
if rf, ok := ret.Get(0).(func(string, string, string, bool) model.ChannelList); ok {
r0 = rf(teamID, userID, term, includeDeleted)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, string, bool) error); ok {
r1 = rf(teamID, userID, term, includeDeleted)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// ClearAllCustomRoleAssignments provides a mock function with given fields:
func (_m *ChannelStore) ClearAllCustomRoleAssignments() error {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for ClearAllCustomRoleAssignments")
}
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
} else {
r0 = ret.Error(0)
}
return r0
}
// ClearCaches provides a mock function with given fields:
func (_m *ChannelStore) ClearCaches() {
_m.Called()
}
// ClearMembersForUserCache provides a mock function with given fields:
func (_m *ChannelStore) ClearMembersForUserCache() {
_m.Called()
}
// ClearSidebarOnTeamLeave provides a mock function with given fields: userID, teamID
func (_m *ChannelStore) ClearSidebarOnTeamLeave(userID string, teamID string) error {
ret := _m.Called(userID, teamID)
if len(ret) == 0 {
panic("no return value specified for ClearSidebarOnTeamLeave")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, string) error); ok {
r0 = rf(userID, teamID)
} else {
r0 = ret.Error(0)
}
return r0
}
// CountPostsAfter provides a mock function with given fields: channelID, timestamp, excludedUserID
func (_m *ChannelStore) CountPostsAfter(channelID string, timestamp int64, excludedUserID string) (int, int, error) {
ret := _m.Called(channelID, timestamp, excludedUserID)
if len(ret) == 0 {
panic("no return value specified for CountPostsAfter")
}
var r0 int
var r1 int
var r2 error
if rf, ok := ret.Get(0).(func(string, int64, string) (int, int, error)); ok {
return rf(channelID, timestamp, excludedUserID)
}
if rf, ok := ret.Get(0).(func(string, int64, string) int); ok {
r0 = rf(channelID, timestamp, excludedUserID)
} else {
r0 = ret.Get(0).(int)
}
if rf, ok := ret.Get(1).(func(string, int64, string) int); ok {
r1 = rf(channelID, timestamp, excludedUserID)
} else {
r1 = ret.Get(1).(int)
}
if rf, ok := ret.Get(2).(func(string, int64, string) error); ok {
r2 = rf(channelID, timestamp, excludedUserID)
} else {
r2 = ret.Error(2)
}
return r0, r1, r2
}
// CountUrgentPostsAfter provides a mock function with given fields: channelID, timestamp, excludedUserID
func (_m *ChannelStore) CountUrgentPostsAfter(channelID string, timestamp int64, excludedUserID string) (int, error) {
ret := _m.Called(channelID, timestamp, excludedUserID)
if len(ret) == 0 {
panic("no return value specified for CountUrgentPostsAfter")
}
var r0 int
var r1 error
if rf, ok := ret.Get(0).(func(string, int64, string) (int, error)); ok {
return rf(channelID, timestamp, excludedUserID)
}
if rf, ok := ret.Get(0).(func(string, int64, string) int); ok {
r0 = rf(channelID, timestamp, excludedUserID)
} else {
r0 = ret.Get(0).(int)
}
if rf, ok := ret.Get(1).(func(string, int64, string) error); ok {
r1 = rf(channelID, timestamp, excludedUserID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// CreateDirectChannel provides a mock function with given fields: ctx, userID, otherUserID, channelOptions
func (_m *ChannelStore) CreateDirectChannel(ctx request.CTX, userID *model.User, otherUserID *model.User, channelOptions ...model.ChannelOption) (*model.Channel, error) {
_va := make([]interface{}, len(channelOptions))
for _i := range channelOptions {
_va[_i] = channelOptions[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, userID, otherUserID)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for CreateDirectChannel")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, *model.User, *model.User, ...model.ChannelOption) (*model.Channel, error)); ok {
return rf(ctx, userID, otherUserID, channelOptions...)
}
if rf, ok := ret.Get(0).(func(request.CTX, *model.User, *model.User, ...model.ChannelOption) *model.Channel); ok {
r0 = rf(ctx, userID, otherUserID, channelOptions...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, *model.User, *model.User, ...model.ChannelOption) error); ok {
r1 = rf(ctx, userID, otherUserID, channelOptions...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// CreateInitialSidebarCategories provides a mock function with given fields: c, userID, opts
func (_m *ChannelStore) CreateInitialSidebarCategories(c request.CTX, userID string, opts *store.SidebarCategorySearchOpts) (*model.OrderedSidebarCategories, error) {
ret := _m.Called(c, userID, opts)
if len(ret) == 0 {
panic("no return value specified for CreateInitialSidebarCategories")
}
var r0 *model.OrderedSidebarCategories
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, string, *store.SidebarCategorySearchOpts) (*model.OrderedSidebarCategories, error)); ok {
return rf(c, userID, opts)
}
if rf, ok := ret.Get(0).(func(request.CTX, string, *store.SidebarCategorySearchOpts) *model.OrderedSidebarCategories); ok {
r0 = rf(c, userID, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.OrderedSidebarCategories)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, string, *store.SidebarCategorySearchOpts) error); ok {
r1 = rf(c, userID, opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// CreateSidebarCategory provides a mock function with given fields: userID, teamID, newCategory
func (_m *ChannelStore) CreateSidebarCategory(userID string, teamID string, newCategory *model.SidebarCategoryWithChannels) (*model.SidebarCategoryWithChannels, error) {
ret := _m.Called(userID, teamID, newCategory)
if len(ret) == 0 {
panic("no return value specified for CreateSidebarCategory")
}
var r0 *model.SidebarCategoryWithChannels
var r1 error
if rf, ok := ret.Get(0).(func(string, string, *model.SidebarCategoryWithChannels) (*model.SidebarCategoryWithChannels, error)); ok {
return rf(userID, teamID, newCategory)
}
if rf, ok := ret.Get(0).(func(string, string, *model.SidebarCategoryWithChannels) *model.SidebarCategoryWithChannels); ok {
r0 = rf(userID, teamID, newCategory)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.SidebarCategoryWithChannels)
}
}
if rf, ok := ret.Get(1).(func(string, string, *model.SidebarCategoryWithChannels) error); ok {
r1 = rf(userID, teamID, newCategory)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// Delete provides a mock function with given fields: channelID, timestamp
func (_m *ChannelStore) Delete(channelID string, timestamp int64) error {
ret := _m.Called(channelID, timestamp)
if len(ret) == 0 {
panic("no return value specified for Delete")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, int64) error); ok {
r0 = rf(channelID, timestamp)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeleteAllSidebarChannelForChannel provides a mock function with given fields: channelID
func (_m *ChannelStore) DeleteAllSidebarChannelForChannel(channelID string) error {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for DeleteAllSidebarChannelForChannel")
}
var r0 error
if rf, ok := ret.Get(0).(func(string) error); ok {
r0 = rf(channelID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeleteSidebarCategory provides a mock function with given fields: categoryID
func (_m *ChannelStore) DeleteSidebarCategory(categoryID string) error {
ret := _m.Called(categoryID)
if len(ret) == 0 {
panic("no return value specified for DeleteSidebarCategory")
}
var r0 error
if rf, ok := ret.Get(0).(func(string) error); ok {
r0 = rf(categoryID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeleteSidebarChannelsByPreferences provides a mock function with given fields: preferences
func (_m *ChannelStore) DeleteSidebarChannelsByPreferences(preferences model.Preferences) error {
ret := _m.Called(preferences)
if len(ret) == 0 {
panic("no return value specified for DeleteSidebarChannelsByPreferences")
}
var r0 error
if rf, ok := ret.Get(0).(func(model.Preferences) error); ok {
r0 = rf(preferences)
} else {
r0 = ret.Error(0)
}
return r0
}
// Get provides a mock function with given fields: id, allowFromCache
func (_m *ChannelStore) Get(id string, allowFromCache bool) (*model.Channel, error) {
ret := _m.Called(id, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for Get")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string, bool) (*model.Channel, error)); ok {
return rf(id, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, bool) *model.Channel); ok {
r0 = rf(id, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(id, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAll provides a mock function with given fields: teamID
func (_m *ChannelStore) GetAll(teamID string) ([]*model.Channel, error) {
ret := _m.Called(teamID)
if len(ret) == 0 {
panic("no return value specified for GetAll")
}
var r0 []*model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string) ([]*model.Channel, error)); ok {
return rf(teamID)
}
if rf, ok := ret.Get(0).(func(string) []*model.Channel); ok {
r0 = rf(teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllChannelMemberIdsByChannelId provides a mock function with given fields: id
func (_m *ChannelStore) GetAllChannelMemberIdsByChannelId(id string) ([]string, error) {
ret := _m.Called(id)
if len(ret) == 0 {
panic("no return value specified for GetAllChannelMemberIdsByChannelId")
}
var r0 []string
var r1 error
if rf, ok := ret.Get(0).(func(string) ([]string, error)); ok {
return rf(id)
}
if rf, ok := ret.Get(0).(func(string) []string); ok {
r0 = rf(id)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]string)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(id)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllChannelMembersForUser provides a mock function with given fields: ctx, userID, allowFromCache, includeDeleted
func (_m *ChannelStore) GetAllChannelMembersForUser(ctx request.CTX, userID string, allowFromCache bool, includeDeleted bool) (map[string]string, error) {
ret := _m.Called(ctx, userID, allowFromCache, includeDeleted)
if len(ret) == 0 {
panic("no return value specified for GetAllChannelMembersForUser")
}
var r0 map[string]string
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, string, bool, bool) (map[string]string, error)); ok {
return rf(ctx, userID, allowFromCache, includeDeleted)
}
if rf, ok := ret.Get(0).(func(request.CTX, string, bool, bool) map[string]string); ok {
r0 = rf(ctx, userID, allowFromCache, includeDeleted)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]string)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, string, bool, bool) error); ok {
r1 = rf(ctx, userID, allowFromCache, includeDeleted)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllChannelMembersNotifyPropsForChannel provides a mock function with given fields: channelID, allowFromCache
func (_m *ChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelID string, allowFromCache bool) (map[string]model.StringMap, error) {
ret := _m.Called(channelID, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetAllChannelMembersNotifyPropsForChannel")
}
var r0 map[string]model.StringMap
var r1 error
if rf, ok := ret.Get(0).(func(string, bool) (map[string]model.StringMap, error)); ok {
return rf(channelID, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, bool) map[string]model.StringMap); ok {
r0 = rf(channelID, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]model.StringMap)
}
}
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(channelID, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllChannels provides a mock function with given fields: page, perPage, opts
func (_m *ChannelStore) GetAllChannels(page int, perPage int, opts store.ChannelSearchOpts) (model.ChannelListWithTeamData, error) {
ret := _m.Called(page, perPage, opts)
if len(ret) == 0 {
panic("no return value specified for GetAllChannels")
}
var r0 model.ChannelListWithTeamData
var r1 error
if rf, ok := ret.Get(0).(func(int, int, store.ChannelSearchOpts) (model.ChannelListWithTeamData, error)); ok {
return rf(page, perPage, opts)
}
if rf, ok := ret.Get(0).(func(int, int, store.ChannelSearchOpts) model.ChannelListWithTeamData); ok {
r0 = rf(page, perPage, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelListWithTeamData)
}
}
if rf, ok := ret.Get(1).(func(int, int, store.ChannelSearchOpts) error); ok {
r1 = rf(page, perPage, opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllChannelsCount provides a mock function with given fields: opts
func (_m *ChannelStore) GetAllChannelsCount(opts store.ChannelSearchOpts) (int64, error) {
ret := _m.Called(opts)
if len(ret) == 0 {
panic("no return value specified for GetAllChannelsCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(store.ChannelSearchOpts) (int64, error)); ok {
return rf(opts)
}
if rf, ok := ret.Get(0).(func(store.ChannelSearchOpts) int64); ok {
r0 = rf(opts)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(store.ChannelSearchOpts) error); ok {
r1 = rf(opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllChannelsForExportAfter provides a mock function with given fields: limit, afterID
func (_m *ChannelStore) GetAllChannelsForExportAfter(limit int, afterID string) ([]*model.ChannelForExport, error) {
ret := _m.Called(limit, afterID)
if len(ret) == 0 {
panic("no return value specified for GetAllChannelsForExportAfter")
}
var r0 []*model.ChannelForExport
var r1 error
if rf, ok := ret.Get(0).(func(int, string) ([]*model.ChannelForExport, error)); ok {
return rf(limit, afterID)
}
if rf, ok := ret.Get(0).(func(int, string) []*model.ChannelForExport); ok {
r0 = rf(limit, afterID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelForExport)
}
}
if rf, ok := ret.Get(1).(func(int, string) error); ok {
r1 = rf(limit, afterID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetAllDirectChannelsForExportAfter provides a mock function with given fields: limit, afterID, includeArchivedChannels
func (_m *ChannelStore) GetAllDirectChannelsForExportAfter(limit int, afterID string, includeArchivedChannels bool) ([]*model.DirectChannelForExport, error) {
ret := _m.Called(limit, afterID, includeArchivedChannels)
if len(ret) == 0 {
panic("no return value specified for GetAllDirectChannelsForExportAfter")
}
var r0 []*model.DirectChannelForExport
var r1 error
if rf, ok := ret.Get(0).(func(int, string, bool) ([]*model.DirectChannelForExport, error)); ok {
return rf(limit, afterID, includeArchivedChannels)
}
if rf, ok := ret.Get(0).(func(int, string, bool) []*model.DirectChannelForExport); ok {
r0 = rf(limit, afterID, includeArchivedChannels)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.DirectChannelForExport)
}
}
if rf, ok := ret.Get(1).(func(int, string, bool) error); ok {
r1 = rf(limit, afterID, includeArchivedChannels)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetByName provides a mock function with given fields: teamID, name, allowFromCache
func (_m *ChannelStore) GetByName(teamID string, name string, allowFromCache bool) (*model.Channel, error) {
ret := _m.Called(teamID, name, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetByName")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string, string, bool) (*model.Channel, error)); ok {
return rf(teamID, name, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, string, bool) *model.Channel); ok {
r0 = rf(teamID, name, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
r1 = rf(teamID, name, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetByNameIncludeDeleted provides a mock function with given fields: teamID, name, allowFromCache
func (_m *ChannelStore) GetByNameIncludeDeleted(teamID string, name string, allowFromCache bool) (*model.Channel, error) {
ret := _m.Called(teamID, name, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetByNameIncludeDeleted")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string, string, bool) (*model.Channel, error)); ok {
return rf(teamID, name, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, string, bool) *model.Channel); ok {
r0 = rf(teamID, name, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
r1 = rf(teamID, name, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetByNames provides a mock function with given fields: teamID, names, allowFromCache
func (_m *ChannelStore) GetByNames(teamID string, names []string, allowFromCache bool) ([]*model.Channel, error) {
ret := _m.Called(teamID, names, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetByNames")
}
var r0 []*model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string, []string, bool) ([]*model.Channel, error)); ok {
return rf(teamID, names, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, []string, bool) []*model.Channel); ok {
r0 = rf(teamID, names, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string, []string, bool) error); ok {
r1 = rf(teamID, names, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetByNamesIncludeDeleted provides a mock function with given fields: teamID, names, allowFromCache
func (_m *ChannelStore) GetByNamesIncludeDeleted(teamID string, names []string, allowFromCache bool) ([]*model.Channel, error) {
ret := _m.Called(teamID, names, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetByNamesIncludeDeleted")
}
var r0 []*model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string, []string, bool) ([]*model.Channel, error)); ok {
return rf(teamID, names, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, []string, bool) []*model.Channel); ok {
r0 = rf(teamID, names, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string, []string, bool) error); ok {
r1 = rf(teamID, names, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelCounts provides a mock function with given fields: teamID, userID
func (_m *ChannelStore) GetChannelCounts(teamID string, userID string) (*model.ChannelCounts, error) {
ret := _m.Called(teamID, userID)
if len(ret) == 0 {
panic("no return value specified for GetChannelCounts")
}
var r0 *model.ChannelCounts
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*model.ChannelCounts, error)); ok {
return rf(teamID, userID)
}
if rf, ok := ret.Get(0).(func(string, string) *model.ChannelCounts); ok {
r0 = rf(teamID, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelCounts)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(teamID, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelMembersForExport provides a mock function with given fields: userID, teamID, includeArchivedChannel
func (_m *ChannelStore) GetChannelMembersForExport(userID string, teamID string, includeArchivedChannel bool) ([]*model.ChannelMemberForExport, error) {
ret := _m.Called(userID, teamID, includeArchivedChannel)
if len(ret) == 0 {
panic("no return value specified for GetChannelMembersForExport")
}
var r0 []*model.ChannelMemberForExport
var r1 error
if rf, ok := ret.Get(0).(func(string, string, bool) ([]*model.ChannelMemberForExport, error)); ok {
return rf(userID, teamID, includeArchivedChannel)
}
if rf, ok := ret.Get(0).(func(string, string, bool) []*model.ChannelMemberForExport); ok {
r0 = rf(userID, teamID, includeArchivedChannel)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelMemberForExport)
}
}
if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
r1 = rf(userID, teamID, includeArchivedChannel)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelMembersTimezones provides a mock function with given fields: channelID
func (_m *ChannelStore) GetChannelMembersTimezones(channelID string) ([]model.StringMap, error) {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for GetChannelMembersTimezones")
}
var r0 []model.StringMap
var r1 error
if rf, ok := ret.Get(0).(func(string) ([]model.StringMap, error)); ok {
return rf(channelID)
}
if rf, ok := ret.Get(0).(func(string) []model.StringMap); ok {
r0 = rf(channelID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]model.StringMap)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(channelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelUnread provides a mock function with given fields: channelID, userID
func (_m *ChannelStore) GetChannelUnread(channelID string, userID string) (*model.ChannelUnread, error) {
ret := _m.Called(channelID, userID)
if len(ret) == 0 {
panic("no return value specified for GetChannelUnread")
}
var r0 *model.ChannelUnread
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*model.ChannelUnread, error)); ok {
return rf(channelID, userID)
}
if rf, ok := ret.Get(0).(func(string, string) *model.ChannelUnread); ok {
r0 = rf(channelID, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelUnread)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(channelID, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannels provides a mock function with given fields: teamID, userID, opts
func (_m *ChannelStore) GetChannels(teamID string, userID string, opts *model.ChannelSearchOpts) (model.ChannelList, error) {
ret := _m.Called(teamID, userID, opts)
if len(ret) == 0 {
panic("no return value specified for GetChannels")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, *model.ChannelSearchOpts) (model.ChannelList, error)); ok {
return rf(teamID, userID, opts)
}
if rf, ok := ret.Get(0).(func(string, string, *model.ChannelSearchOpts) model.ChannelList); ok {
r0 = rf(teamID, userID, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, *model.ChannelSearchOpts) error); ok {
r1 = rf(teamID, userID, opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsBatchForIndexing provides a mock function with given fields: startTime, startChannelID, limit
func (_m *ChannelStore) GetChannelsBatchForIndexing(startTime int64, startChannelID string, limit int) ([]*model.Channel, error) {
ret := _m.Called(startTime, startChannelID, limit)
if len(ret) == 0 {
panic("no return value specified for GetChannelsBatchForIndexing")
}
var r0 []*model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(int64, string, int) ([]*model.Channel, error)); ok {
return rf(startTime, startChannelID, limit)
}
if rf, ok := ret.Get(0).(func(int64, string, int) []*model.Channel); ok {
r0 = rf(startTime, startChannelID, limit)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(int64, string, int) error); ok {
r1 = rf(startTime, startChannelID, limit)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsByIds provides a mock function with given fields: channelIds, includeDeleted
func (_m *ChannelStore) GetChannelsByIds(channelIds []string, includeDeleted bool) ([]*model.Channel, error) {
ret := _m.Called(channelIds, includeDeleted)
if len(ret) == 0 {
panic("no return value specified for GetChannelsByIds")
}
var r0 []*model.Channel
var r1 error
if rf, ok := ret.Get(0).(func([]string, bool) ([]*model.Channel, error)); ok {
return rf(channelIds, includeDeleted)
}
if rf, ok := ret.Get(0).(func([]string, bool) []*model.Channel); ok {
r0 = rf(channelIds, includeDeleted)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Channel)
}
}
if rf, ok := ret.Get(1).(func([]string, bool) error); ok {
r1 = rf(channelIds, includeDeleted)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsByScheme provides a mock function with given fields: schemeID, offset, limit
func (_m *ChannelStore) GetChannelsByScheme(schemeID string, offset int, limit int) (model.ChannelList, error) {
ret := _m.Called(schemeID, offset, limit)
if len(ret) == 0 {
panic("no return value specified for GetChannelsByScheme")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, int, int) (model.ChannelList, error)); ok {
return rf(schemeID, offset, limit)
}
if rf, ok := ret.Get(0).(func(string, int, int) model.ChannelList); ok {
r0 = rf(schemeID, offset, limit)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
r1 = rf(schemeID, offset, limit)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsByUser provides a mock function with given fields: userID, includeDeleted, lastDeleteAt, pageSize, fromChannelID
func (_m *ChannelStore) GetChannelsByUser(userID string, includeDeleted bool, lastDeleteAt int, pageSize int, fromChannelID string) (model.ChannelList, error) {
ret := _m.Called(userID, includeDeleted, lastDeleteAt, pageSize, fromChannelID)
if len(ret) == 0 {
panic("no return value specified for GetChannelsByUser")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, bool, int, int, string) (model.ChannelList, error)); ok {
return rf(userID, includeDeleted, lastDeleteAt, pageSize, fromChannelID)
}
if rf, ok := ret.Get(0).(func(string, bool, int, int, string) model.ChannelList); ok {
r0 = rf(userID, includeDeleted, lastDeleteAt, pageSize, fromChannelID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, bool, int, int, string) error); ok {
r1 = rf(userID, includeDeleted, lastDeleteAt, pageSize, fromChannelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsMemberCount provides a mock function with given fields: channelIDs
func (_m *ChannelStore) GetChannelsMemberCount(channelIDs []string) (map[string]int64, error) {
ret := _m.Called(channelIDs)
if len(ret) == 0 {
panic("no return value specified for GetChannelsMemberCount")
}
var r0 map[string]int64
var r1 error
if rf, ok := ret.Get(0).(func([]string) (map[string]int64, error)); ok {
return rf(channelIDs)
}
if rf, ok := ret.Get(0).(func([]string) map[string]int64); ok {
r0 = rf(channelIDs)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]int64)
}
}
if rf, ok := ret.Get(1).(func([]string) error); ok {
r1 = rf(channelIDs)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsWithTeamDataByIds provides a mock function with given fields: channelIds, includeDeleted
func (_m *ChannelStore) GetChannelsWithTeamDataByIds(channelIds []string, includeDeleted bool) ([]*model.ChannelWithTeamData, error) {
ret := _m.Called(channelIds, includeDeleted)
if len(ret) == 0 {
panic("no return value specified for GetChannelsWithTeamDataByIds")
}
var r0 []*model.ChannelWithTeamData
var r1 error
if rf, ok := ret.Get(0).(func([]string, bool) ([]*model.ChannelWithTeamData, error)); ok {
return rf(channelIds, includeDeleted)
}
if rf, ok := ret.Get(0).(func([]string, bool) []*model.ChannelWithTeamData); ok {
r0 = rf(channelIds, includeDeleted)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelWithTeamData)
}
}
if rf, ok := ret.Get(1).(func([]string, bool) error); ok {
r1 = rf(channelIds, includeDeleted)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetChannelsWithUnreadsAndWithMentions provides a mock function with given fields: ctx, channelIDs, userID, userNotifyProps
func (_m *ChannelStore) GetChannelsWithUnreadsAndWithMentions(ctx context.Context, channelIDs []string, userID string, userNotifyProps model.StringMap) ([]string, []string, map[string]int64, error) {
ret := _m.Called(ctx, channelIDs, userID, userNotifyProps)
if len(ret) == 0 {
panic("no return value specified for GetChannelsWithUnreadsAndWithMentions")
}
var r0 []string
var r1 []string
var r2 map[string]int64
var r3 error
if rf, ok := ret.Get(0).(func(context.Context, []string, string, model.StringMap) ([]string, []string, map[string]int64, error)); ok {
return rf(ctx, channelIDs, userID, userNotifyProps)
}
if rf, ok := ret.Get(0).(func(context.Context, []string, string, model.StringMap) []string); ok {
r0 = rf(ctx, channelIDs, userID, userNotifyProps)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]string)
}
}
if rf, ok := ret.Get(1).(func(context.Context, []string, string, model.StringMap) []string); ok {
r1 = rf(ctx, channelIDs, userID, userNotifyProps)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).([]string)
}
}
if rf, ok := ret.Get(2).(func(context.Context, []string, string, model.StringMap) map[string]int64); ok {
r2 = rf(ctx, channelIDs, userID, userNotifyProps)
} else {
if ret.Get(2) != nil {
r2 = ret.Get(2).(map[string]int64)
}
}
if rf, ok := ret.Get(3).(func(context.Context, []string, string, model.StringMap) error); ok {
r3 = rf(ctx, channelIDs, userID, userNotifyProps)
} else {
r3 = ret.Error(3)
}
return r0, r1, r2, r3
}
// GetDeleted provides a mock function with given fields: teamID, offset, limit, userID, skipTeamMembershipCheck
func (_m *ChannelStore) GetDeleted(teamID string, offset int, limit int, userID string, skipTeamMembershipCheck bool) (model.ChannelList, error) {
ret := _m.Called(teamID, offset, limit, userID, skipTeamMembershipCheck)
if len(ret) == 0 {
panic("no return value specified for GetDeleted")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, int, int, string, bool) (model.ChannelList, error)); ok {
return rf(teamID, offset, limit, userID, skipTeamMembershipCheck)
}
if rf, ok := ret.Get(0).(func(string, int, int, string, bool) model.ChannelList); ok {
r0 = rf(teamID, offset, limit, userID, skipTeamMembershipCheck)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, int, int, string, bool) error); ok {
r1 = rf(teamID, offset, limit, userID, skipTeamMembershipCheck)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetDeletedByName provides a mock function with given fields: teamID, name
func (_m *ChannelStore) GetDeletedByName(teamID string, name string) (*model.Channel, error) {
ret := _m.Called(teamID, name)
if len(ret) == 0 {
panic("no return value specified for GetDeletedByName")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*model.Channel, error)); ok {
return rf(teamID, name)
}
if rf, ok := ret.Get(0).(func(string, string) *model.Channel); ok {
r0 = rf(teamID, name)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(teamID, name)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetFileCount provides a mock function with given fields: channelID
func (_m *ChannelStore) GetFileCount(channelID string) (int64, error) {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for GetFileCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(string) (int64, error)); ok {
return rf(channelID)
}
if rf, ok := ret.Get(0).(func(string) int64); ok {
r0 = rf(channelID)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(channelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetForPost provides a mock function with given fields: postID
func (_m *ChannelStore) GetForPost(postID string) (*model.Channel, error) {
ret := _m.Called(postID)
if len(ret) == 0 {
panic("no return value specified for GetForPost")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.Channel, error)); ok {
return rf(postID)
}
if rf, ok := ret.Get(0).(func(string) *model.Channel); ok {
r0 = rf(postID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(postID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetGuestCount provides a mock function with given fields: channelID, allowFromCache
func (_m *ChannelStore) GetGuestCount(channelID string, allowFromCache bool) (int64, error) {
ret := _m.Called(channelID, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetGuestCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(string, bool) (int64, error)); ok {
return rf(channelID, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, bool) int64); ok {
r0 = rf(channelID, allowFromCache)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(channelID, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMany provides a mock function with given fields: ids, allowFromCache
func (_m *ChannelStore) GetMany(ids []string, allowFromCache bool) (model.ChannelList, error) {
ret := _m.Called(ids, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetMany")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func([]string, bool) (model.ChannelList, error)); ok {
return rf(ids, allowFromCache)
}
if rf, ok := ret.Get(0).(func([]string, bool) model.ChannelList); ok {
r0 = rf(ids, allowFromCache)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func([]string, bool) error); ok {
r1 = rf(ids, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMember provides a mock function with given fields: ctx, channelID, userID
func (_m *ChannelStore) GetMember(ctx context.Context, channelID string, userID string) (*model.ChannelMember, error) {
ret := _m.Called(ctx, channelID, userID)
if len(ret) == 0 {
panic("no return value specified for GetMember")
}
var r0 *model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, string) (*model.ChannelMember, error)); ok {
return rf(ctx, channelID, userID)
}
if rf, ok := ret.Get(0).(func(context.Context, string, string) *model.ChannelMember); ok {
r0 = rf(ctx, channelID, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
r1 = rf(ctx, channelID, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMemberCount provides a mock function with given fields: channelID, allowFromCache
func (_m *ChannelStore) GetMemberCount(channelID string, allowFromCache bool) (int64, error) {
ret := _m.Called(channelID, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetMemberCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(string, bool) (int64, error)); ok {
return rf(channelID, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, bool) int64); ok {
r0 = rf(channelID, allowFromCache)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(channelID, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMemberCountFromCache provides a mock function with given fields: channelID
func (_m *ChannelStore) GetMemberCountFromCache(channelID string) int64 {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for GetMemberCountFromCache")
}
var r0 int64
if rf, ok := ret.Get(0).(func(string) int64); ok {
r0 = rf(channelID)
} else {
r0 = ret.Get(0).(int64)
}
return r0
}
// GetMemberCountsByGroup provides a mock function with given fields: ctx, channelID, includeTimezones
func (_m *ChannelStore) GetMemberCountsByGroup(ctx context.Context, channelID string, includeTimezones bool) ([]*model.ChannelMemberCountByGroup, error) {
ret := _m.Called(ctx, channelID, includeTimezones)
if len(ret) == 0 {
panic("no return value specified for GetMemberCountsByGroup")
}
var r0 []*model.ChannelMemberCountByGroup
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, bool) ([]*model.ChannelMemberCountByGroup, error)); ok {
return rf(ctx, channelID, includeTimezones)
}
if rf, ok := ret.Get(0).(func(context.Context, string, bool) []*model.ChannelMemberCountByGroup); ok {
r0 = rf(ctx, channelID, includeTimezones)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelMemberCountByGroup)
}
}
if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
r1 = rf(ctx, channelID, includeTimezones)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMemberForPost provides a mock function with given fields: postID, userID, includeArchivedChannels
func (_m *ChannelStore) GetMemberForPost(postID string, userID string, includeArchivedChannels bool) (*model.ChannelMember, error) {
ret := _m.Called(postID, userID, includeArchivedChannels)
if len(ret) == 0 {
panic("no return value specified for GetMemberForPost")
}
var r0 *model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func(string, string, bool) (*model.ChannelMember, error)); ok {
return rf(postID, userID, includeArchivedChannels)
}
if rf, ok := ret.Get(0).(func(string, string, bool) *model.ChannelMember); ok {
r0 = rf(postID, userID, includeArchivedChannels)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
r1 = rf(postID, userID, includeArchivedChannels)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMemberLastViewedAt provides a mock function with given fields: ctx, channelID, userID
func (_m *ChannelStore) GetMemberLastViewedAt(ctx context.Context, channelID string, userID string) (int64, error) {
ret := _m.Called(ctx, channelID, userID)
if len(ret) == 0 {
panic("no return value specified for GetMemberLastViewedAt")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, string) (int64, error)); ok {
return rf(ctx, channelID, userID)
}
if rf, ok := ret.Get(0).(func(context.Context, string, string) int64); ok {
r0 = rf(ctx, channelID, userID)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
r1 = rf(ctx, channelID, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembers provides a mock function with given fields: channelID, offset, limit
func (_m *ChannelStore) GetMembers(channelID string, offset int, limit int) (model.ChannelMembers, error) {
ret := _m.Called(channelID, offset, limit)
if len(ret) == 0 {
panic("no return value specified for GetMembers")
}
var r0 model.ChannelMembers
var r1 error
if rf, ok := ret.Get(0).(func(string, int, int) (model.ChannelMembers, error)); ok {
return rf(channelID, offset, limit)
}
if rf, ok := ret.Get(0).(func(string, int, int) model.ChannelMembers); ok {
r0 = rf(channelID, offset, limit)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelMembers)
}
}
if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
r1 = rf(channelID, offset, limit)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembersByChannelIds provides a mock function with given fields: channelIds, userID
func (_m *ChannelStore) GetMembersByChannelIds(channelIds []string, userID string) (model.ChannelMembers, error) {
ret := _m.Called(channelIds, userID)
if len(ret) == 0 {
panic("no return value specified for GetMembersByChannelIds")
}
var r0 model.ChannelMembers
var r1 error
if rf, ok := ret.Get(0).(func([]string, string) (model.ChannelMembers, error)); ok {
return rf(channelIds, userID)
}
if rf, ok := ret.Get(0).(func([]string, string) model.ChannelMembers); ok {
r0 = rf(channelIds, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelMembers)
}
}
if rf, ok := ret.Get(1).(func([]string, string) error); ok {
r1 = rf(channelIds, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembersByIds provides a mock function with given fields: channelID, userIds
func (_m *ChannelStore) GetMembersByIds(channelID string, userIds []string) (model.ChannelMembers, error) {
ret := _m.Called(channelID, userIds)
if len(ret) == 0 {
panic("no return value specified for GetMembersByIds")
}
var r0 model.ChannelMembers
var r1 error
if rf, ok := ret.Get(0).(func(string, []string) (model.ChannelMembers, error)); ok {
return rf(channelID, userIds)
}
if rf, ok := ret.Get(0).(func(string, []string) model.ChannelMembers); ok {
r0 = rf(channelID, userIds)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelMembers)
}
}
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(channelID, userIds)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembersForUser provides a mock function with given fields: teamID, userID
func (_m *ChannelStore) GetMembersForUser(teamID string, userID string) (model.ChannelMembers, error) {
ret := _m.Called(teamID, userID)
if len(ret) == 0 {
panic("no return value specified for GetMembersForUser")
}
var r0 model.ChannelMembers
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (model.ChannelMembers, error)); ok {
return rf(teamID, userID)
}
if rf, ok := ret.Get(0).(func(string, string) model.ChannelMembers); ok {
r0 = rf(teamID, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelMembers)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(teamID, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembersForUserWithCursorPagination provides a mock function with given fields: userId, perPage, fromChanneID
func (_m *ChannelStore) GetMembersForUserWithCursorPagination(userId string, perPage int, fromChanneID string) (model.ChannelMembersWithTeamData, error) {
ret := _m.Called(userId, perPage, fromChanneID)
if len(ret) == 0 {
panic("no return value specified for GetMembersForUserWithCursorPagination")
}
var r0 model.ChannelMembersWithTeamData
var r1 error
if rf, ok := ret.Get(0).(func(string, int, string) (model.ChannelMembersWithTeamData, error)); ok {
return rf(userId, perPage, fromChanneID)
}
if rf, ok := ret.Get(0).(func(string, int, string) model.ChannelMembersWithTeamData); ok {
r0 = rf(userId, perPage, fromChanneID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelMembersWithTeamData)
}
}
if rf, ok := ret.Get(1).(func(string, int, string) error); ok {
r1 = rf(userId, perPage, fromChanneID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembersForUserWithPagination provides a mock function with given fields: userID, page, perPage
func (_m *ChannelStore) GetMembersForUserWithPagination(userID string, page int, perPage int) (model.ChannelMembersWithTeamData, error) {
ret := _m.Called(userID, page, perPage)
if len(ret) == 0 {
panic("no return value specified for GetMembersForUserWithPagination")
}
var r0 model.ChannelMembersWithTeamData
var r1 error
if rf, ok := ret.Get(0).(func(string, int, int) (model.ChannelMembersWithTeamData, error)); ok {
return rf(userID, page, perPage)
}
if rf, ok := ret.Get(0).(func(string, int, int) model.ChannelMembersWithTeamData); ok {
r0 = rf(userID, page, perPage)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelMembersWithTeamData)
}
}
if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
r1 = rf(userID, page, perPage)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMembersInfoByChannelIds provides a mock function with given fields: channelIDs
func (_m *ChannelStore) GetMembersInfoByChannelIds(channelIDs []string) (map[string][]*model.User, error) {
ret := _m.Called(channelIDs)
if len(ret) == 0 {
panic("no return value specified for GetMembersInfoByChannelIds")
}
var r0 map[string][]*model.User
var r1 error
if rf, ok := ret.Get(0).(func([]string) (map[string][]*model.User, error)); ok {
return rf(channelIDs)
}
if rf, ok := ret.Get(0).(func([]string) map[string][]*model.User); ok {
r0 = rf(channelIDs)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string][]*model.User)
}
}
if rf, ok := ret.Get(1).(func([]string) error); ok {
r1 = rf(channelIDs)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetMoreChannels provides a mock function with given fields: teamID, userID, offset, limit
func (_m *ChannelStore) GetMoreChannels(teamID string, userID string, offset int, limit int) (model.ChannelList, error) {
ret := _m.Called(teamID, userID, offset, limit)
if len(ret) == 0 {
panic("no return value specified for GetMoreChannels")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, int, int) (model.ChannelList, error)); ok {
return rf(teamID, userID, offset, limit)
}
if rf, ok := ret.Get(0).(func(string, string, int, int) model.ChannelList); ok {
r0 = rf(teamID, userID, offset, limit)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, int, int) error); ok {
r1 = rf(teamID, userID, offset, limit)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPinnedPostCount provides a mock function with given fields: channelID, allowFromCache
func (_m *ChannelStore) GetPinnedPostCount(channelID string, allowFromCache bool) (int64, error) {
ret := _m.Called(channelID, allowFromCache)
if len(ret) == 0 {
panic("no return value specified for GetPinnedPostCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(string, bool) (int64, error)); ok {
return rf(channelID, allowFromCache)
}
if rf, ok := ret.Get(0).(func(string, bool) int64); ok {
r0 = rf(channelID, allowFromCache)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(channelID, allowFromCache)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPinnedPosts provides a mock function with given fields: channelID
func (_m *ChannelStore) GetPinnedPosts(channelID string) (*model.PostList, error) {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for GetPinnedPosts")
}
var r0 *model.PostList
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.PostList, error)); ok {
return rf(channelID)
}
if rf, ok := ret.Get(0).(func(string) *model.PostList); ok {
r0 = rf(channelID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PostList)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(channelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPrivateChannelsForTeam provides a mock function with given fields: teamID, offset, limit
func (_m *ChannelStore) GetPrivateChannelsForTeam(teamID string, offset int, limit int) (model.ChannelList, error) {
ret := _m.Called(teamID, offset, limit)
if len(ret) == 0 {
panic("no return value specified for GetPrivateChannelsForTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, int, int) (model.ChannelList, error)); ok {
return rf(teamID, offset, limit)
}
if rf, ok := ret.Get(0).(func(string, int, int) model.ChannelList); ok {
r0 = rf(teamID, offset, limit)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
r1 = rf(teamID, offset, limit)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPublicChannelsByIdsForTeam provides a mock function with given fields: teamID, channelIds
func (_m *ChannelStore) GetPublicChannelsByIdsForTeam(teamID string, channelIds []string) (model.ChannelList, error) {
ret := _m.Called(teamID, channelIds)
if len(ret) == 0 {
panic("no return value specified for GetPublicChannelsByIdsForTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, []string) (model.ChannelList, error)); ok {
return rf(teamID, channelIds)
}
if rf, ok := ret.Get(0).(func(string, []string) model.ChannelList); ok {
r0 = rf(teamID, channelIds)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(teamID, channelIds)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPublicChannelsForTeam provides a mock function with given fields: teamID, offset, limit
func (_m *ChannelStore) GetPublicChannelsForTeam(teamID string, offset int, limit int) (model.ChannelList, error) {
ret := _m.Called(teamID, offset, limit)
if len(ret) == 0 {
panic("no return value specified for GetPublicChannelsForTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, int, int) (model.ChannelList, error)); ok {
return rf(teamID, offset, limit)
}
if rf, ok := ret.Get(0).(func(string, int, int) model.ChannelList); ok {
r0 = rf(teamID, offset, limit)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
r1 = rf(teamID, offset, limit)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetSidebarCategories provides a mock function with given fields: userID, opts
func (_m *ChannelStore) GetSidebarCategories(userID string, opts *store.SidebarCategorySearchOpts) (*model.OrderedSidebarCategories, error) {
ret := _m.Called(userID, opts)
if len(ret) == 0 {
panic("no return value specified for GetSidebarCategories")
}
var r0 *model.OrderedSidebarCategories
var r1 error
if rf, ok := ret.Get(0).(func(string, *store.SidebarCategorySearchOpts) (*model.OrderedSidebarCategories, error)); ok {
return rf(userID, opts)
}
if rf, ok := ret.Get(0).(func(string, *store.SidebarCategorySearchOpts) *model.OrderedSidebarCategories); ok {
r0 = rf(userID, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.OrderedSidebarCategories)
}
}
if rf, ok := ret.Get(1).(func(string, *store.SidebarCategorySearchOpts) error); ok {
r1 = rf(userID, opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetSidebarCategoriesForTeamForUser provides a mock function with given fields: userID, teamID
func (_m *ChannelStore) GetSidebarCategoriesForTeamForUser(userID string, teamID string) (*model.OrderedSidebarCategories, error) {
ret := _m.Called(userID, teamID)
if len(ret) == 0 {
panic("no return value specified for GetSidebarCategoriesForTeamForUser")
}
var r0 *model.OrderedSidebarCategories
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*model.OrderedSidebarCategories, error)); ok {
return rf(userID, teamID)
}
if rf, ok := ret.Get(0).(func(string, string) *model.OrderedSidebarCategories); ok {
r0 = rf(userID, teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.OrderedSidebarCategories)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(userID, teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetSidebarCategory provides a mock function with given fields: categoryID
func (_m *ChannelStore) GetSidebarCategory(categoryID string) (*model.SidebarCategoryWithChannels, error) {
ret := _m.Called(categoryID)
if len(ret) == 0 {
panic("no return value specified for GetSidebarCategory")
}
var r0 *model.SidebarCategoryWithChannels
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.SidebarCategoryWithChannels, error)); ok {
return rf(categoryID)
}
if rf, ok := ret.Get(0).(func(string) *model.SidebarCategoryWithChannels); ok {
r0 = rf(categoryID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.SidebarCategoryWithChannels)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(categoryID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetSidebarCategoryOrder provides a mock function with given fields: userID, teamID
func (_m *ChannelStore) GetSidebarCategoryOrder(userID string, teamID string) ([]string, error) {
ret := _m.Called(userID, teamID)
if len(ret) == 0 {
panic("no return value specified for GetSidebarCategoryOrder")
}
var r0 []string
var r1 error
if rf, ok := ret.Get(0).(func(string, string) ([]string, error)); ok {
return rf(userID, teamID)
}
if rf, ok := ret.Get(0).(func(string, string) []string); ok {
r0 = rf(userID, teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]string)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(userID, teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetTeamChannels provides a mock function with given fields: teamID
func (_m *ChannelStore) GetTeamChannels(teamID string) (model.ChannelList, error) {
ret := _m.Called(teamID)
if len(ret) == 0 {
panic("no return value specified for GetTeamChannels")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string) (model.ChannelList, error)); ok {
return rf(teamID)
}
if rf, ok := ret.Get(0).(func(string) model.ChannelList); ok {
r0 = rf(teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetTeamForChannel provides a mock function with given fields: channelID
func (_m *ChannelStore) GetTeamForChannel(channelID string) (*model.Team, error) {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for GetTeamForChannel")
}
var r0 *model.Team
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.Team, error)); ok {
return rf(channelID)
}
if rf, ok := ret.Get(0).(func(string) *model.Team); ok {
r0 = rf(channelID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Team)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(channelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetTeamMembersForChannel provides a mock function with given fields: channelID
func (_m *ChannelStore) GetTeamMembersForChannel(channelID string) ([]string, error) {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for GetTeamMembersForChannel")
}
var r0 []string
var r1 error
if rf, ok := ret.Get(0).(func(string) ([]string, error)); ok {
return rf(channelID)
}
if rf, ok := ret.Get(0).(func(string) []string); ok {
r0 = rf(channelID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]string)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(channelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GroupSyncedChannelCount provides a mock function with given fields:
func (_m *ChannelStore) GroupSyncedChannelCount() (int64, error) {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for GroupSyncedChannelCount")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func() (int64, error)); ok {
return rf()
}
if rf, ok := ret.Get(0).(func() int64); ok {
r0 = rf()
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// IncrementMentionCount provides a mock function with given fields: channelID, userIDs, isRoot, isUrgent
func (_m *ChannelStore) IncrementMentionCount(channelID string, userIDs []string, isRoot bool, isUrgent bool) error {
ret := _m.Called(channelID, userIDs, isRoot, isUrgent)
if len(ret) == 0 {
panic("no return value specified for IncrementMentionCount")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, []string, bool, bool) error); ok {
r0 = rf(channelID, userIDs, isRoot, isUrgent)
} else {
r0 = ret.Error(0)
}
return r0
}
// InvalidateAllChannelMembersForUser provides a mock function with given fields: userID
func (_m *ChannelStore) InvalidateAllChannelMembersForUser(userID string) {
_m.Called(userID)
}
// InvalidateCacheForChannelMembersNotifyProps provides a mock function with given fields: channelID
func (_m *ChannelStore) InvalidateCacheForChannelMembersNotifyProps(channelID string) {
_m.Called(channelID)
}
// InvalidateChannel provides a mock function with given fields: id
func (_m *ChannelStore) InvalidateChannel(id string) {
_m.Called(id)
}
// InvalidateChannelByName provides a mock function with given fields: teamID, name
func (_m *ChannelStore) InvalidateChannelByName(teamID string, name string) {
_m.Called(teamID, name)
}
// InvalidateGuestCount provides a mock function with given fields: channelID
func (_m *ChannelStore) InvalidateGuestCount(channelID string) {
_m.Called(channelID)
}
// InvalidateMemberCount provides a mock function with given fields: channelID
func (_m *ChannelStore) InvalidateMemberCount(channelID string) {
_m.Called(channelID)
}
// InvalidatePinnedPostCount provides a mock function with given fields: channelID
func (_m *ChannelStore) InvalidatePinnedPostCount(channelID string) {
_m.Called(channelID)
}
// IsChannelReadOnlyScheme provides a mock function with given fields: schemeID
func (_m *ChannelStore) IsChannelReadOnlyScheme(schemeID string) (bool, error) {
ret := _m.Called(schemeID)
if len(ret) == 0 {
panic("no return value specified for IsChannelReadOnlyScheme")
}
var r0 bool
var r1 error
if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
return rf(schemeID)
}
if rf, ok := ret.Get(0).(func(string) bool); ok {
r0 = rf(schemeID)
} else {
r0 = ret.Get(0).(bool)
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(schemeID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// IsReadOnlyChannel provides a mock function with given fields: channelID
func (_m *ChannelStore) IsReadOnlyChannel(channelID string) (bool, error) {
ret := _m.Called(channelID)
if len(ret) == 0 {
panic("no return value specified for IsReadOnlyChannel")
}
var r0 bool
var r1 error
if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
return rf(channelID)
}
if rf, ok := ret.Get(0).(func(string) bool); ok {
r0 = rf(channelID)
} else {
r0 = ret.Get(0).(bool)
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(channelID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MigrateChannelMembers provides a mock function with given fields: fromChannelID, fromUserID
func (_m *ChannelStore) MigrateChannelMembers(fromChannelID string, fromUserID string) (map[string]string, error) {
ret := _m.Called(fromChannelID, fromUserID)
if len(ret) == 0 {
panic("no return value specified for MigrateChannelMembers")
}
var r0 map[string]string
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (map[string]string, error)); ok {
return rf(fromChannelID, fromUserID)
}
if rf, ok := ret.Get(0).(func(string, string) map[string]string); ok {
r0 = rf(fromChannelID, fromUserID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]string)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(fromChannelID, fromUserID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// PatchMultipleMembersNotifyProps provides a mock function with given fields: members, notifyProps
func (_m *ChannelStore) PatchMultipleMembersNotifyProps(members []*model.ChannelMemberIdentifier, notifyProps map[string]string) ([]*model.ChannelMember, error) {
ret := _m.Called(members, notifyProps)
if len(ret) == 0 {
panic("no return value specified for PatchMultipleMembersNotifyProps")
}
var r0 []*model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func([]*model.ChannelMemberIdentifier, map[string]string) ([]*model.ChannelMember, error)); ok {
return rf(members, notifyProps)
}
if rf, ok := ret.Get(0).(func([]*model.ChannelMemberIdentifier, map[string]string) []*model.ChannelMember); ok {
r0 = rf(members, notifyProps)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func([]*model.ChannelMemberIdentifier, map[string]string) error); ok {
r1 = rf(members, notifyProps)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// PermanentDelete provides a mock function with given fields: ctx, channelID
func (_m *ChannelStore) PermanentDelete(ctx request.CTX, channelID string) error {
ret := _m.Called(ctx, channelID)
if len(ret) == 0 {
panic("no return value specified for PermanentDelete")
}
var r0 error
if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
r0 = rf(ctx, channelID)
} else {
r0 = ret.Error(0)
}
return r0
}
// PermanentDeleteByTeam provides a mock function with given fields: teamID
func (_m *ChannelStore) PermanentDeleteByTeam(teamID string) error {
ret := _m.Called(teamID)
if len(ret) == 0 {
panic("no return value specified for PermanentDeleteByTeam")
}
var r0 error
if rf, ok := ret.Get(0).(func(string) error); ok {
r0 = rf(teamID)
} else {
r0 = ret.Error(0)
}
return r0
}
// PermanentDeleteMembersByChannel provides a mock function with given fields: ctx, channelID
func (_m *ChannelStore) PermanentDeleteMembersByChannel(ctx request.CTX, channelID string) error {
ret := _m.Called(ctx, channelID)
if len(ret) == 0 {
panic("no return value specified for PermanentDeleteMembersByChannel")
}
var r0 error
if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
r0 = rf(ctx, channelID)
} else {
r0 = ret.Error(0)
}
return r0
}
// PermanentDeleteMembersByUser provides a mock function with given fields: ctx, userID
func (_m *ChannelStore) PermanentDeleteMembersByUser(ctx request.CTX, userID string) error {
ret := _m.Called(ctx, userID)
if len(ret) == 0 {
panic("no return value specified for PermanentDeleteMembersByUser")
}
var r0 error
if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
r0 = rf(ctx, userID)
} else {
r0 = ret.Error(0)
}
return r0
}
// RemoveAllDeactivatedMembers provides a mock function with given fields: ctx, channelID
func (_m *ChannelStore) RemoveAllDeactivatedMembers(ctx request.CTX, channelID string) error {
ret := _m.Called(ctx, channelID)
if len(ret) == 0 {
panic("no return value specified for RemoveAllDeactivatedMembers")
}
var r0 error
if rf, ok := ret.Get(0).(func(request.CTX, string) error); ok {
r0 = rf(ctx, channelID)
} else {
r0 = ret.Error(0)
}
return r0
}
// RemoveMember provides a mock function with given fields: ctx, channelID, userID
func (_m *ChannelStore) RemoveMember(ctx request.CTX, channelID string, userID string) error {
ret := _m.Called(ctx, channelID, userID)
if len(ret) == 0 {
panic("no return value specified for RemoveMember")
}
var r0 error
if rf, ok := ret.Get(0).(func(request.CTX, string, string) error); ok {
r0 = rf(ctx, channelID, userID)
} else {
r0 = ret.Error(0)
}
return r0
}
// RemoveMembers provides a mock function with given fields: ctx, channelID, userIds
func (_m *ChannelStore) RemoveMembers(ctx request.CTX, channelID string, userIds []string) error {
ret := _m.Called(ctx, channelID, userIds)
if len(ret) == 0 {
panic("no return value specified for RemoveMembers")
}
var r0 error
if rf, ok := ret.Get(0).(func(request.CTX, string, []string) error); ok {
r0 = rf(ctx, channelID, userIds)
} else {
r0 = ret.Error(0)
}
return r0
}
// ResetAllChannelSchemes provides a mock function with given fields:
func (_m *ChannelStore) ResetAllChannelSchemes() error {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for ResetAllChannelSchemes")
}
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
} else {
r0 = ret.Error(0)
}
return r0
}
// Restore provides a mock function with given fields: channelID, timestamp
func (_m *ChannelStore) Restore(channelID string, timestamp int64) error {
ret := _m.Called(channelID, timestamp)
if len(ret) == 0 {
panic("no return value specified for Restore")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, int64) error); ok {
r0 = rf(channelID, timestamp)
} else {
r0 = ret.Error(0)
}
return r0
}
// Save provides a mock function with given fields: rctx, channel, maxChannelsPerTeam
func (_m *ChannelStore) Save(rctx request.CTX, channel *model.Channel, maxChannelsPerTeam int64) (*model.Channel, error) {
ret := _m.Called(rctx, channel, maxChannelsPerTeam)
if len(ret) == 0 {
panic("no return value specified for Save")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, *model.Channel, int64) (*model.Channel, error)); ok {
return rf(rctx, channel, maxChannelsPerTeam)
}
if rf, ok := ret.Get(0).(func(request.CTX, *model.Channel, int64) *model.Channel); ok {
r0 = rf(rctx, channel, maxChannelsPerTeam)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, *model.Channel, int64) error); ok {
r1 = rf(rctx, channel, maxChannelsPerTeam)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SaveDirectChannel provides a mock function with given fields: ctx, channel, member1, member2
func (_m *ChannelStore) SaveDirectChannel(ctx request.CTX, channel *model.Channel, member1 *model.ChannelMember, member2 *model.ChannelMember) (*model.Channel, error) {
ret := _m.Called(ctx, channel, member1, member2)
if len(ret) == 0 {
panic("no return value specified for SaveDirectChannel")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, *model.Channel, *model.ChannelMember, *model.ChannelMember) (*model.Channel, error)); ok {
return rf(ctx, channel, member1, member2)
}
if rf, ok := ret.Get(0).(func(request.CTX, *model.Channel, *model.ChannelMember, *model.ChannelMember) *model.Channel); ok {
r0 = rf(ctx, channel, member1, member2)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, *model.Channel, *model.ChannelMember, *model.ChannelMember) error); ok {
r1 = rf(ctx, channel, member1, member2)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SaveMember provides a mock function with given fields: rctx, member
func (_m *ChannelStore) SaveMember(rctx request.CTX, member *model.ChannelMember) (*model.ChannelMember, error) {
ret := _m.Called(rctx, member)
if len(ret) == 0 {
panic("no return value specified for SaveMember")
}
var r0 *model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, *model.ChannelMember) (*model.ChannelMember, error)); ok {
return rf(rctx, member)
}
if rf, ok := ret.Get(0).(func(request.CTX, *model.ChannelMember) *model.ChannelMember); ok {
r0 = rf(rctx, member)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, *model.ChannelMember) error); ok {
r1 = rf(rctx, member)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SaveMultipleMembers provides a mock function with given fields: members
func (_m *ChannelStore) SaveMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
ret := _m.Called(members)
if len(ret) == 0 {
panic("no return value specified for SaveMultipleMembers")
}
var r0 []*model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func([]*model.ChannelMember) ([]*model.ChannelMember, error)); ok {
return rf(members)
}
if rf, ok := ret.Get(0).(func([]*model.ChannelMember) []*model.ChannelMember); ok {
r0 = rf(members)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func([]*model.ChannelMember) error); ok {
r1 = rf(members)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchAllChannels provides a mock function with given fields: term, opts
func (_m *ChannelStore) SearchAllChannels(term string, opts store.ChannelSearchOpts) (model.ChannelListWithTeamData, int64, error) {
ret := _m.Called(term, opts)
if len(ret) == 0 {
panic("no return value specified for SearchAllChannels")
}
var r0 model.ChannelListWithTeamData
var r1 int64
var r2 error
if rf, ok := ret.Get(0).(func(string, store.ChannelSearchOpts) (model.ChannelListWithTeamData, int64, error)); ok {
return rf(term, opts)
}
if rf, ok := ret.Get(0).(func(string, store.ChannelSearchOpts) model.ChannelListWithTeamData); ok {
r0 = rf(term, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelListWithTeamData)
}
}
if rf, ok := ret.Get(1).(func(string, store.ChannelSearchOpts) int64); ok {
r1 = rf(term, opts)
} else {
r1 = ret.Get(1).(int64)
}
if rf, ok := ret.Get(2).(func(string, store.ChannelSearchOpts) error); ok {
r2 = rf(term, opts)
} else {
r2 = ret.Error(2)
}
return r0, r1, r2
}
// SearchArchivedInTeam provides a mock function with given fields: teamID, term, userID
func (_m *ChannelStore) SearchArchivedInTeam(teamID string, term string, userID string) (model.ChannelList, error) {
ret := _m.Called(teamID, term, userID)
if len(ret) == 0 {
panic("no return value specified for SearchArchivedInTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, string) (model.ChannelList, error)); ok {
return rf(teamID, term, userID)
}
if rf, ok := ret.Get(0).(func(string, string, string) model.ChannelList); ok {
r0 = rf(teamID, term, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
r1 = rf(teamID, term, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchForUserInTeam provides a mock function with given fields: userID, teamID, term, includeDeleted
func (_m *ChannelStore) SearchForUserInTeam(userID string, teamID string, term string, includeDeleted bool) (model.ChannelList, error) {
ret := _m.Called(userID, teamID, term, includeDeleted)
if len(ret) == 0 {
panic("no return value specified for SearchForUserInTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, string, bool) (model.ChannelList, error)); ok {
return rf(userID, teamID, term, includeDeleted)
}
if rf, ok := ret.Get(0).(func(string, string, string, bool) model.ChannelList); ok {
r0 = rf(userID, teamID, term, includeDeleted)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, string, bool) error); ok {
r1 = rf(userID, teamID, term, includeDeleted)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchGroupChannels provides a mock function with given fields: userID, term
func (_m *ChannelStore) SearchGroupChannels(userID string, term string) (model.ChannelList, error) {
ret := _m.Called(userID, term)
if len(ret) == 0 {
panic("no return value specified for SearchGroupChannels")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (model.ChannelList, error)); ok {
return rf(userID, term)
}
if rf, ok := ret.Get(0).(func(string, string) model.ChannelList); ok {
r0 = rf(userID, term)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(userID, term)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchInTeam provides a mock function with given fields: teamID, term, includeDeleted
func (_m *ChannelStore) SearchInTeam(teamID string, term string, includeDeleted bool) (model.ChannelList, error) {
ret := _m.Called(teamID, term, includeDeleted)
if len(ret) == 0 {
panic("no return value specified for SearchInTeam")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, bool) (model.ChannelList, error)); ok {
return rf(teamID, term, includeDeleted)
}
if rf, ok := ret.Get(0).(func(string, string, bool) model.ChannelList); ok {
r0 = rf(teamID, term, includeDeleted)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, bool) error); ok {
r1 = rf(teamID, term, includeDeleted)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchMore provides a mock function with given fields: userID, teamID, term
func (_m *ChannelStore) SearchMore(userID string, teamID string, term string) (model.ChannelList, error) {
ret := _m.Called(userID, teamID, term)
if len(ret) == 0 {
panic("no return value specified for SearchMore")
}
var r0 model.ChannelList
var r1 error
if rf, ok := ret.Get(0).(func(string, string, string) (model.ChannelList, error)); ok {
return rf(userID, teamID, term)
}
if rf, ok := ret.Get(0).(func(string, string, string) model.ChannelList); ok {
r0 = rf(userID, teamID, term)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(model.ChannelList)
}
}
if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
r1 = rf(userID, teamID, term)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SetDeleteAt provides a mock function with given fields: channelID, deleteAt, updateAt
func (_m *ChannelStore) SetDeleteAt(channelID string, deleteAt int64, updateAt int64) error {
ret := _m.Called(channelID, deleteAt, updateAt)
if len(ret) == 0 {
panic("no return value specified for SetDeleteAt")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, int64, int64) error); ok {
r0 = rf(channelID, deleteAt, updateAt)
} else {
r0 = ret.Error(0)
}
return r0
}
// SetShared provides a mock function with given fields: channelID, shared
func (_m *ChannelStore) SetShared(channelID string, shared bool) error {
ret := _m.Called(channelID, shared)
if len(ret) == 0 {
panic("no return value specified for SetShared")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, bool) error); ok {
r0 = rf(channelID, shared)
} else {
r0 = ret.Error(0)
}
return r0
}
// Update provides a mock function with given fields: ctx, channel
func (_m *ChannelStore) Update(ctx request.CTX, channel *model.Channel) (*model.Channel, error) {
ret := _m.Called(ctx, channel)
if len(ret) == 0 {
panic("no return value specified for Update")
}
var r0 *model.Channel
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, *model.Channel) (*model.Channel, error)); ok {
return rf(ctx, channel)
}
if rf, ok := ret.Get(0).(func(request.CTX, *model.Channel) *model.Channel); ok {
r0 = rf(ctx, channel)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Channel)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, *model.Channel) error); ok {
r1 = rf(ctx, channel)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateLastViewedAt provides a mock function with given fields: channelIds, userID
func (_m *ChannelStore) UpdateLastViewedAt(channelIds []string, userID string) (map[string]int64, error) {
ret := _m.Called(channelIds, userID)
if len(ret) == 0 {
panic("no return value specified for UpdateLastViewedAt")
}
var r0 map[string]int64
var r1 error
if rf, ok := ret.Get(0).(func([]string, string) (map[string]int64, error)); ok {
return rf(channelIds, userID)
}
if rf, ok := ret.Get(0).(func([]string, string) map[string]int64); ok {
r0 = rf(channelIds, userID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]int64)
}
}
if rf, ok := ret.Get(1).(func([]string, string) error); ok {
r1 = rf(channelIds, userID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateLastViewedAtPost provides a mock function with given fields: unreadPost, userID, mentionCount, mentionCountRoot, urgentMentionCount, setUnreadCountRoot
func (_m *ChannelStore) UpdateLastViewedAtPost(unreadPost *model.Post, userID string, mentionCount int, mentionCountRoot int, urgentMentionCount int, setUnreadCountRoot bool) (*model.ChannelUnreadAt, error) {
ret := _m.Called(unreadPost, userID, mentionCount, mentionCountRoot, urgentMentionCount, setUnreadCountRoot)
if len(ret) == 0 {
panic("no return value specified for UpdateLastViewedAtPost")
}
var r0 *model.ChannelUnreadAt
var r1 error
if rf, ok := ret.Get(0).(func(*model.Post, string, int, int, int, bool) (*model.ChannelUnreadAt, error)); ok {
return rf(unreadPost, userID, mentionCount, mentionCountRoot, urgentMentionCount, setUnreadCountRoot)
}
if rf, ok := ret.Get(0).(func(*model.Post, string, int, int, int, bool) *model.ChannelUnreadAt); ok {
r0 = rf(unreadPost, userID, mentionCount, mentionCountRoot, urgentMentionCount, setUnreadCountRoot)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelUnreadAt)
}
}
if rf, ok := ret.Get(1).(func(*model.Post, string, int, int, int, bool) error); ok {
r1 = rf(unreadPost, userID, mentionCount, mentionCountRoot, urgentMentionCount, setUnreadCountRoot)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateMember provides a mock function with given fields: ctx, member
func (_m *ChannelStore) UpdateMember(ctx request.CTX, member *model.ChannelMember) (*model.ChannelMember, error) {
ret := _m.Called(ctx, member)
if len(ret) == 0 {
panic("no return value specified for UpdateMember")
}
var r0 *model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func(request.CTX, *model.ChannelMember) (*model.ChannelMember, error)); ok {
return rf(ctx, member)
}
if rf, ok := ret.Get(0).(func(request.CTX, *model.ChannelMember) *model.ChannelMember); ok {
r0 = rf(ctx, member)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func(request.CTX, *model.ChannelMember) error); ok {
r1 = rf(ctx, member)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateMemberNotifyProps provides a mock function with given fields: channelID, userID, props
func (_m *ChannelStore) UpdateMemberNotifyProps(channelID string, userID string, props map[string]string) (*model.ChannelMember, error) {
ret := _m.Called(channelID, userID, props)
if len(ret) == 0 {
panic("no return value specified for UpdateMemberNotifyProps")
}
var r0 *model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func(string, string, map[string]string) (*model.ChannelMember, error)); ok {
return rf(channelID, userID, props)
}
if rf, ok := ret.Get(0).(func(string, string, map[string]string) *model.ChannelMember); ok {
r0 = rf(channelID, userID, props)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func(string, string, map[string]string) error); ok {
r1 = rf(channelID, userID, props)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateMembersRole provides a mock function with given fields: channelID, userIDs
func (_m *ChannelStore) UpdateMembersRole(channelID string, userIDs []string) ([]*model.ChannelMember, error) {
ret := _m.Called(channelID, userIDs)
if len(ret) == 0 {
panic("no return value specified for UpdateMembersRole")
}
var r0 []*model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func(string, []string) ([]*model.ChannelMember, error)); ok {
return rf(channelID, userIDs)
}
if rf, ok := ret.Get(0).(func(string, []string) []*model.ChannelMember); ok {
r0 = rf(channelID, userIDs)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(channelID, userIDs)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateMultipleMembers provides a mock function with given fields: members
func (_m *ChannelStore) UpdateMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
ret := _m.Called(members)
if len(ret) == 0 {
panic("no return value specified for UpdateMultipleMembers")
}
var r0 []*model.ChannelMember
var r1 error
if rf, ok := ret.Get(0).(func([]*model.ChannelMember) ([]*model.ChannelMember, error)); ok {
return rf(members)
}
if rf, ok := ret.Get(0).(func([]*model.ChannelMember) []*model.ChannelMember); ok {
r0 = rf(members)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.ChannelMember)
}
}
if rf, ok := ret.Get(1).(func([]*model.ChannelMember) error); ok {
r1 = rf(members)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateSidebarCategories provides a mock function with given fields: userID, teamID, categories
func (_m *ChannelStore) UpdateSidebarCategories(userID string, teamID string, categories []*model.SidebarCategoryWithChannels) ([]*model.SidebarCategoryWithChannels, []*model.SidebarCategoryWithChannels, error) {
ret := _m.Called(userID, teamID, categories)
if len(ret) == 0 {
panic("no return value specified for UpdateSidebarCategories")
}
var r0 []*model.SidebarCategoryWithChannels
var r1 []*model.SidebarCategoryWithChannels
var r2 error
if rf, ok := ret.Get(0).(func(string, string, []*model.SidebarCategoryWithChannels) ([]*model.SidebarCategoryWithChannels, []*model.SidebarCategoryWithChannels, error)); ok {
return rf(userID, teamID, categories)
}
if rf, ok := ret.Get(0).(func(string, string, []*model.SidebarCategoryWithChannels) []*model.SidebarCategoryWithChannels); ok {
r0 = rf(userID, teamID, categories)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.SidebarCategoryWithChannels)
}
}
if rf, ok := ret.Get(1).(func(string, string, []*model.SidebarCategoryWithChannels) []*model.SidebarCategoryWithChannels); ok {
r1 = rf(userID, teamID, categories)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).([]*model.SidebarCategoryWithChannels)
}
}
if rf, ok := ret.Get(2).(func(string, string, []*model.SidebarCategoryWithChannels) error); ok {
r2 = rf(userID, teamID, categories)
} else {
r2 = ret.Error(2)
}
return r0, r1, r2
}
// UpdateSidebarCategoryOrder provides a mock function with given fields: userID, teamID, categoryOrder
func (_m *ChannelStore) UpdateSidebarCategoryOrder(userID string, teamID string, categoryOrder []string) error {
ret := _m.Called(userID, teamID, categoryOrder)
if len(ret) == 0 {
panic("no return value specified for UpdateSidebarCategoryOrder")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, string, []string) error); ok {
r0 = rf(userID, teamID, categoryOrder)
} else {
r0 = ret.Error(0)
}
return r0
}
// UpdateSidebarChannelCategoryOnMove provides a mock function with given fields: channel, newTeamID
func (_m *ChannelStore) UpdateSidebarChannelCategoryOnMove(channel *model.Channel, newTeamID string) error {
ret := _m.Called(channel, newTeamID)
if len(ret) == 0 {
panic("no return value specified for UpdateSidebarChannelCategoryOnMove")
}
var r0 error
if rf, ok := ret.Get(0).(func(*model.Channel, string) error); ok {
r0 = rf(channel, newTeamID)
} else {
r0 = ret.Error(0)
}
return r0
}
// UpdateSidebarChannelsByPreferences provides a mock function with given fields: preferences
func (_m *ChannelStore) UpdateSidebarChannelsByPreferences(preferences model.Preferences) error {
ret := _m.Called(preferences)
if len(ret) == 0 {
panic("no return value specified for UpdateSidebarChannelsByPreferences")
}
var r0 error
if rf, ok := ret.Get(0).(func(model.Preferences) error); ok {
r0 = rf(preferences)
} else {
r0 = ret.Error(0)
}
return r0
}
// UserBelongsToChannels provides a mock function with given fields: userID, channelIds
func (_m *ChannelStore) UserBelongsToChannels(userID string, channelIds []string) (bool, error) {
ret := _m.Called(userID, channelIds)
if len(ret) == 0 {
panic("no return value specified for UserBelongsToChannels")
}
var r0 bool
var r1 error
if rf, ok := ret.Get(0).(func(string, []string) (bool, error)); ok {
return rf(userID, channelIds)
}
if rf, ok := ret.Get(0).(func(string, []string) bool); ok {
r0 = rf(userID, channelIds)
} else {
r0 = ret.Get(0).(bool)
}
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(userID, channelIds)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// NewChannelStore creates a new instance of ChannelStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewChannelStore(t interface {
mock.TestingT
Cleanup(func())
}) *ChannelStore {
mock := &ChannelStore{}
mock.Mock.Test(t)
t.Cleanup(func() { mock.AssertExpectations(t) })
return mock
}
Reference in New Issue View Git Blame Copy Permalink