mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

[MM-44573] Sanitize options (#20380)

Просмотр исходного кода 
Automatic Merge
Этот коммит содержится в:
Guillermo Vayá
2022-06-08 23:36:28 +02:00
коммит произвёл GitHub
родитель a251510717
Коммит c6f80dfe0a
18 изменённых файлов: 235 добавлений и 234 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
app/channel_test.go
Просмотреть файл

@@ -644,7 +644,7 @@ func TestAddChannelMemberNoUserRequestor(t *testing.T) {
} }
assert.Equal(t, groupUserIds, channelMemberHistoryUserIds) assert.Equal(t, groupUserIds, channelMemberHistoryUserIds)
postList, nErr := th.App.Srv().Store.Post().GetPosts(model.GetPostsOptions{ChannelId: channel.Id, Page: 0, PerPage: 1}, false) postList, nErr := th.App.Srv().Store.Post().GetPosts(model.GetPostsOptions{ChannelId: channel.Id, Page: 0, PerPage: 1}, false, map[string]bool{})
require.NoError(t, nErr) require.NoError(t, nErr)
if assert.Len(t, postList.Order, 1) { if assert.Len(t, postList.Order, 1) {

2
app/file.go
Просмотреть файл

@@ -367,7 +367,7 @@ func (a *App) MigrateFilenamesToFileInfos(post *model.Post) []*model.FileInfo {
fileMigrationLock.Lock() fileMigrationLock.Lock()
defer fileMigrationLock.Unlock() defer fileMigrationLock.Unlock()
result, nErr := a.Srv().Store.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") result, nErr := a.Srv().Store.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", a.Config().GetSanitizeOptions())
if nErr != nil { if nErr != nil {
mlog.Error("Unable to get post when migrating post to use FileInfos", mlog.Err(nErr), mlog.String("post_id", post.Id)) mlog.Error("Unable to get post when migrating post to use FileInfos", mlog.Err(nErr), mlog.String("post_id", post.Id))
return []*model.FileInfo{} return []*model.FileInfo{}

23
app/post.go
Просмотреть файл

@@ -176,7 +176,7 @@ func (a *App) CreatePost(c *request.Context, post *model.Post, channel *model.Ch
if post.RootId != "" { if post.RootId != "" {
pchan = make(chan store.StoreResult, 1) pchan = make(chan store.StoreResult, 1)
go func() { go func() {
r, pErr := a.Srv().Store.Post().Get(sqlstore.WithMaster(context.Background()), post.RootId, model.GetPostsOptions{}, "") r, pErr := a.Srv().Store.Post().Get(sqlstore.WithMaster(context.Background()), post.RootId, model.GetPostsOptions{}, "", a.Config().GetSanitizeOptions())
pchan <- store.StoreResult{Data: r, NErr: pErr} pchan <- store.StoreResult{Data: r, NErr: pErr}
close(pchan) close(pchan)
}() }()
@@ -567,7 +567,7 @@ func (a *App) DeleteEphemeralPost(userID, postID string) {
func (a *App) UpdatePost(c *request.Context, post *model.Post, safeUpdate bool) (*model.Post, *model.AppError) { func (a *App) UpdatePost(c *request.Context, post *model.Post, safeUpdate bool) (*model.Post, *model.AppError) {
post.SanitizeProps() post.SanitizeProps()
postLists, nErr := a.Srv().Store.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") postLists, nErr := a.Srv().Store.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", a.Config().GetSanitizeOptions())
if nErr != nil { if nErr != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
@@ -798,7 +798,7 @@ func (a *App) PatchPost(c *request.Context, postID string, patch *model.PostPatc
} }
func (a *App) GetPostsPage(options model.GetPostsOptions) (*model.PostList, *model.AppError) { func (a *App) GetPostsPage(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
postList, err := a.Srv().Store.Post().GetPosts(options, false) postList, err := a.Srv().Store.Post().GetPosts(options, false, a.Config().GetSanitizeOptions())
if err != nil { if err != nil {
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
switch { switch {
@@ -813,7 +813,7 @@ func (a *App) GetPostsPage(options model.GetPostsOptions) (*model.PostList, *mod
} }
func (a *App) GetPosts(channelID string, offset int, limit int) (*model.PostList, *model.AppError) { func (a *App) GetPosts(channelID string, offset int, limit int) (*model.PostList, *model.AppError) {
postList, err := a.Srv().Store.Post().GetPosts(model.GetPostsOptions{ChannelId: channelID, Page: offset, PerPage: limit}, true) postList, err := a.Srv().Store.Post().GetPosts(model.GetPostsOptions{ChannelId: channelID, Page: offset, PerPage: limit}, true, a.Config().GetSanitizeOptions())
if err != nil { if err != nil {
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
switch { switch {
@@ -832,7 +832,7 @@ func (a *App) GetPostsEtag(channelID string, collapsedThreads bool) string {
} }
func (a *App) GetPostsSince(options model.GetPostsSinceOptions) (*model.PostList, *model.AppError) { func (a *App) GetPostsSince(options model.GetPostsSinceOptions) (*model.PostList, *model.AppError) {
postList, err := a.Srv().Store.Post().GetPostsSince(options, true) postList, err := a.Srv().Store.Post().GetPostsSince(options, true, a.Config().GetSanitizeOptions())
if err != nil { if err != nil {
return nil, model.NewAppError("GetPostsSince", "app.post.get_posts_since.app_error", nil, err.Error(), http.StatusInternalServerError) return nil, model.NewAppError("GetPostsSince", "app.post.get_posts_since.app_error", nil, err.Error(), http.StatusInternalServerError)
} }
@@ -856,7 +856,7 @@ func (a *App) GetSinglePost(postID string, includeDeleted bool) (*model.Post, *m
} }
func (a *App) GetPostThread(postID string, opts model.GetPostsOptions, userID string) (*model.PostList, *model.AppError) { func (a *App) GetPostThread(postID string, opts model.GetPostsOptions, userID string) (*model.PostList, *model.AppError) {
posts, err := a.Srv().Store.Post().Get(context.Background(), postID, opts, userID) posts, err := a.Srv().Store.Post().Get(context.Background(), postID, opts, userID, a.Config().GetSanitizeOptions())
if err != nil { if err != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
@@ -901,7 +901,7 @@ func (a *App) GetFlaggedPostsForChannel(userID, channelID string, offset int, li
} }
func (a *App) GetPermalinkPost(c *request.Context, postID string, userID string) (*model.PostList, *model.AppError) { func (a *App) GetPermalinkPost(c *request.Context, postID string, userID string) (*model.PostList, *model.AppError) {
list, nErr := a.Srv().Store.Post().Get(context.Background(), postID, model.GetPostsOptions{}, userID) list, nErr := a.Srv().Store.Post().Get(context.Background(), postID, model.GetPostsOptions{}, userID, a.Config().GetSanitizeOptions())
if nErr != nil { if nErr != nil {
var nfErr *store.ErrNotFound var nfErr *store.ErrNotFound
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
@@ -933,7 +933,7 @@ func (a *App) GetPermalinkPost(c *request.Context, postID string, userID string)
} }
func (a *App) GetPostsBeforePost(options model.GetPostsOptions) (*model.PostList, *model.AppError) { func (a *App) GetPostsBeforePost(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
postList, err := a.Srv().Store.Post().GetPostsBefore(options) postList, err := a.Srv().Store.Post().GetPostsBefore(options, a.Config().GetSanitizeOptions())
if err != nil { if err != nil {
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
switch { switch {
@@ -948,7 +948,7 @@ func (a *App) GetPostsBeforePost(options model.GetPostsOptions) (*model.PostList
} }
func (a *App) GetPostsAfterPost(options model.GetPostsOptions) (*model.PostList, *model.AppError) { func (a *App) GetPostsAfterPost(options model.GetPostsOptions) (*model.PostList, *model.AppError) {
postList, err := a.Srv().Store.Post().GetPostsAfter(options) postList, err := a.Srv().Store.Post().GetPostsAfter(options, a.Config().GetSanitizeOptions())
if err != nil { if err != nil {
var invErr *store.ErrInvalidInput var invErr *store.ErrInvalidInput
switch { switch {
@@ -965,10 +965,11 @@ func (a *App) GetPostsAfterPost(options model.GetPostsOptions) (*model.PostList,
func (a *App) GetPostsAroundPost(before bool, options model.GetPostsOptions) (*model.PostList, *model.AppError) { func (a *App) GetPostsAroundPost(before bool, options model.GetPostsOptions) (*model.PostList, *model.AppError) {
var postList *model.PostList var postList *model.PostList
var err error var err error
sanitize := a.Config().GetSanitizeOptions()
if before { if before {
postList, err = a.Srv().Store.Post().GetPostsBefore(options) postList, err = a.Srv().Store.Post().GetPostsBefore(options, sanitize)
} else { } else {
postList, err = a.Srv().Store.Post().GetPostsAfter(options) postList, err = a.Srv().Store.Post().GetPostsAfter(options, sanitize)
} }
if err != nil { if err != nil {

2
services/sharedchannel/permalink.go
Просмотреть файл

@@ -34,7 +34,7 @@ func (scs *Service) processPermalinkToRemote(p *model.Post) string {
opts := model.GetPostsOptions{ opts := model.GetPostsOptions{
SkipFetchThreads: true, SkipFetchThreads: true,
} }
postList, err := scs.server.GetStore().Post().Get(context.Background(), postID, opts, "") postList, err := scs.server.GetStore().Post().Get(context.Background(), postID, opts, "", map[string]bool{})
if err != nil { if err != nil {
scs.server.GetLogger().Log(mlog.LvlSharedChannelServiceWarn, "Unable to get post during replacing permalinks", mlog.Err(err)) scs.server.GetLogger().Log(mlog.LvlSharedChannelServiceWarn, "Unable to get post during replacing permalinks", mlog.Err(err))
return msg return msg

2
services/sharedchannel/permalink_test.go
Просмотреть файл

@@ -27,7 +27,7 @@ func TestProcessPermalinkToRemote(t *testing.T) {
utils.TranslationsPreInit() utils.TranslationsPreInit()
pl := &model.PostList{} pl := &model.PostList{}
mockPostStore.On("Get", context.Background(), "postID", model.GetPostsOptions{SkipFetchThreads: true}, "").Return(pl, nil) mockPostStore.On("Get", context.Background(), "postID", model.GetPostsOptions{SkipFetchThreads: true}, "", map[string]bool{}).Return(pl, nil)
mockStore.On("Post").Return(&mockPostStore) mockStore.On("Post").Return(&mockPostStore)

8
store/localcachelayer/main_test.go
Просмотреть файл

@@ -104,8 +104,8 @@ func getMockStore() *mocks.Store {
fakePosts := &model.PostList{} fakePosts := &model.PostList{}
fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30} fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30}
mockPostStore := mocks.PostStore{} mockPostStore := mocks.PostStore{}
mockPostStore.On("GetPosts", fakeOptions, true).Return(fakePosts, nil) mockPostStore.On("GetPosts", fakeOptions, true, map[string]bool{}).Return(fakePosts, nil)
mockPostStore.On("GetPosts", fakeOptions, false).Return(fakePosts, nil) mockPostStore.On("GetPosts", fakeOptions, false, map[string]bool{}).Return(fakePosts, nil)
mockPostStore.On("InvalidateLastPostTimeCache", "12360") mockPostStore.On("InvalidateLastPostTimeCache", "12360")
mockPostStoreOptions := model.GetPostsSinceOptions{ mockPostStoreOptions := model.GetPostsSinceOptions{
@@ -119,8 +119,8 @@ func getMockStore() *mocks.Store {
mockPostStore.On("InvalidateLastPostTimeCache", "channelId") mockPostStore.On("InvalidateLastPostTimeCache", "channelId")
mockPostStore.On("GetEtag", "channelId", true, false).Return(mockPostStoreEtagResult) mockPostStore.On("GetEtag", "channelId", true, false).Return(mockPostStoreEtagResult)
mockPostStore.On("GetEtag", "channelId", false, false).Return(mockPostStoreEtagResult) mockPostStore.On("GetEtag", "channelId", false, false).Return(mockPostStoreEtagResult)
mockPostStore.On("GetPostsSince", mockPostStoreOptions, true).Return(model.NewPostList(), nil) mockPostStore.On("GetPostsSince", mockPostStoreOptions, true, map[string]bool{}).Return(model.NewPostList(), nil)
mockPostStore.On("GetPostsSince", mockPostStoreOptions, false).Return(model.NewPostList(), nil) mockPostStore.On("GetPostsSince", mockPostStoreOptions, false, map[string]bool{}).Return(model.NewPostList(), nil)
mockStore.On("Post").Return(&mockPostStore) mockStore.On("Post").Return(&mockPostStore)
fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"} fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"}

10
store/localcachelayer/post_layer.go
Просмотреть файл

@@ -89,7 +89,7 @@ func (s LocalCachePostStore) GetEtag(channelId string, allowFromCache, collapsed
return result return result
} }
func (s LocalCachePostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) { func (s LocalCachePostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
if allowFromCache { if allowFromCache {
// If the last post in the channel's time is less than or equal to the time we are getting posts since, // If the last post in the channel's time is less than or equal to the time we are getting posts since,
// we can safely return no posts. // we can safely return no posts.
@@ -100,7 +100,7 @@ func (s LocalCachePostStore) GetPostsSince(options model.GetPostsSinceOptions, a
} }
} }
list, err := s.PostStore.GetPostsSince(options, allowFromCache) list, err := s.PostStore.GetPostsSince(options, allowFromCache, sanitizeOptions)
latestUpdate := options.Time latestUpdate := options.Time
if err == nil { if err == nil {
@@ -115,9 +115,9 @@ func (s LocalCachePostStore) GetPostsSince(options model.GetPostsSinceOptions, a
return list, err return list, err
} }
func (s LocalCachePostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) { func (s LocalCachePostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
if !allowFromCache { if !allowFromCache {
return s.PostStore.GetPosts(options, allowFromCache) return s.PostStore.GetPosts(options, allowFromCache, sanitizeOptions)
} }
offset := options.PerPage * options.Page offset := options.PerPage * options.Page
@@ -129,7 +129,7 @@ func (s LocalCachePostStore) GetPosts(options model.GetPostsOptions, allowFromCa
} }
} }
list, err := s.PostStore.GetPosts(options, false) list, err := s.PostStore.GetPosts(options, false, sanitizeOptions)
if err != nil { if err != nil {
return nil, err return nil, err
} }

28
store/localcachelayer/post_layer_test.go
Просмотреть файл

@@ -91,12 +91,12 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
expectedResult := model.NewPostList() expectedResult := model.NewPostList()
list, err := cachedStore.Post().GetPostsSince(fakeOptions, true) list, err := cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, list, expectedResult) assert.Equal(t, list, expectedResult)
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
list, err = cachedStore.Post().GetPostsSince(fakeOptions, true) list, err = cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, list, expectedResult) assert.Equal(t, list, expectedResult)
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
@@ -108,9 +108,9 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Post().GetPostsSince(fakeOptions, true) cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
cachedStore.Post().GetPostsSince(fakeOptions, false) cachedStore.Post().GetPostsSince(fakeOptions, false, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2)
}) })
@@ -120,10 +120,10 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Post().GetPostsSince(fakeOptions, true) cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
cachedStore.Post().InvalidateLastPostTimeCache(channelId) cachedStore.Post().InvalidateLastPostTimeCache(channelId)
cachedStore.Post().GetPostsSince(fakeOptions, true) cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2)
}) })
@@ -133,10 +133,10 @@ func TestPostStoreLastPostTimeCache(t *testing.T) {
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
cachedStore.Post().GetPostsSince(fakeOptions, true) cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
cachedStore.Post().ClearCaches() cachedStore.Post().ClearCaches()
cachedStore.Post().GetPostsSince(fakeOptions, true) cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2)
}) })
} }
@@ -151,12 +151,12 @@ func TestPostStoreCache(t *testing.T) {
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true) gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, fakePosts, gotPosts) assert.Equal(t, fakePosts, gotPosts)
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
_, _ = cachedStore.Post().GetPosts(fakeOptions, true) _, _ = cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
}) })
@@ -166,12 +166,12 @@ func TestPostStoreCache(t *testing.T) {
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true) gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, fakePosts, gotPosts) assert.Equal(t, fakePosts, gotPosts)
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
_, _ = cachedStore.Post().GetPosts(fakeOptions, false) _, _ = cachedStore.Post().GetPosts(fakeOptions, false, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 2) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 2)
}) })
@@ -181,14 +181,14 @@ func TestPostStoreCache(t *testing.T) {
cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
require.NoError(t, err) require.NoError(t, err)
gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true) gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, fakePosts, gotPosts) assert.Equal(t, fakePosts, gotPosts)
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
cachedStore.Post().InvalidateLastPostTimeCache("12360") cachedStore.Post().InvalidateLastPostTimeCache("12360")
_, _ = cachedStore.Post().GetPosts(fakeOptions, true) _, _ = cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1) mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
}) })

20
store/opentracinglayer/opentracinglayer.go
Просмотреть файл

@@ -5486,7 +5486,7 @@ func (s *OpenTracingLayerPostStore) DeleteOrphanedRows(limit int) (int64, error)
return result, err return result, err
} }
func (s *OpenTracingLayerPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string) (*model.PostList, error) { func (s *OpenTracingLayerPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string, sanitizeOptions map[string]bool) (*model.PostList, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.Get") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.Get")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@@ -5495,7 +5495,7 @@ func (s *OpenTracingLayerPostStore) Get(ctx context.Context, id string, opts mod
}() }()
defer span.Finish() defer span.Finish()
result, err := s.PostStore.Get(ctx, id, opts, userID) result, err := s.PostStore.Get(ctx, id, opts, userID, sanitizeOptions)
if err != nil { if err != nil {
span.LogFields(spanlog.Error(err)) span.LogFields(spanlog.Error(err))
ext.Error.Set(span, true) ext.Error.Set(span, true)
@@ -5736,7 +5736,7 @@ func (s *OpenTracingLayerPostStore) GetPostIdBeforeTime(channelID string, time i
return result, err return result, err
} }
func (s *OpenTracingLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) { func (s *OpenTracingLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPosts") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPosts")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@@ -5745,7 +5745,7 @@ func (s *OpenTracingLayerPostStore) GetPosts(options model.GetPostsOptions, allo
}() }()
defer span.Finish() defer span.Finish()
result, err := s.PostStore.GetPosts(options, allowFromCache) result, err := s.PostStore.GetPosts(options, allowFromCache, sanitizeOptions)
if err != nil { if err != nil {
span.LogFields(spanlog.Error(err)) span.LogFields(spanlog.Error(err))
ext.Error.Set(span, true) ext.Error.Set(span, true)
@@ -5754,7 +5754,7 @@ func (s *OpenTracingLayerPostStore) GetPosts(options model.GetPostsOptions, allo
return result, err return result, err
} }
func (s *OpenTracingLayerPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) { func (s *OpenTracingLayerPostStore) GetPostsAfter(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPostsAfter") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPostsAfter")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@@ -5763,7 +5763,7 @@ func (s *OpenTracingLayerPostStore) GetPostsAfter(options model.GetPostsOptions)
}() }()
defer span.Finish() defer span.Finish()
result, err := s.PostStore.GetPostsAfter(options) result, err := s.PostStore.GetPostsAfter(options, sanitizeOptions)
if err != nil { if err != nil {
span.LogFields(spanlog.Error(err)) span.LogFields(spanlog.Error(err))
ext.Error.Set(span, true) ext.Error.Set(span, true)
@@ -5790,7 +5790,7 @@ func (s *OpenTracingLayerPostStore) GetPostsBatchForIndexing(startTime int64, st
return result, err return result, err
} }
func (s *OpenTracingLayerPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) { func (s *OpenTracingLayerPostStore) GetPostsBefore(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPostsBefore") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPostsBefore")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@@ -5799,7 +5799,7 @@ func (s *OpenTracingLayerPostStore) GetPostsBefore(options model.GetPostsOptions
}() }()
defer span.Finish() defer span.Finish()
result, err := s.PostStore.GetPostsBefore(options) result, err := s.PostStore.GetPostsBefore(options, sanitizeOptions)
if err != nil { if err != nil {
span.LogFields(spanlog.Error(err)) span.LogFields(spanlog.Error(err))
ext.Error.Set(span, true) ext.Error.Set(span, true)
@@ -5844,7 +5844,7 @@ func (s *OpenTracingLayerPostStore) GetPostsCreatedAt(channelID string, time int
return result, err return result, err
} }
func (s *OpenTracingLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) { func (s *OpenTracingLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
origCtx := s.Root.Store.Context() origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPostsSince") span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetPostsSince")
s.Root.Store.SetContext(newCtx) s.Root.Store.SetContext(newCtx)
@@ -5853,7 +5853,7 @@ func (s *OpenTracingLayerPostStore) GetPostsSince(options model.GetPostsSinceOpt
}() }()
defer span.Finish() defer span.Finish()
result, err := s.PostStore.GetPostsSince(options, allowFromCache) result, err := s.PostStore.GetPostsSince(options, allowFromCache, sanitizeOptions)
if err != nil { if err != nil {
span.LogFields(spanlog.Error(err)) span.LogFields(spanlog.Error(err))
ext.Error.Set(span, true) ext.Error.Set(span, true)

20
store/retrylayer/retrylayer.go
Просмотреть файл

@@ -6226,11 +6226,11 @@ func (s *RetryLayerPostStore) DeleteOrphanedRows(limit int) (int64, error) {
} }
func (s *RetryLayerPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string) (*model.PostList, error) { func (s *RetryLayerPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string, sanitizeOptions map[string]bool) (*model.PostList, error) {
tries := 0 tries := 0
for { for {
result, err := s.PostStore.Get(ctx, id, opts, userID) result, err := s.PostStore.Get(ctx, id, opts, userID, sanitizeOptions)
if err == nil { if err == nil {
return result, nil return result, nil
} }
@@ -6490,11 +6490,11 @@ func (s *RetryLayerPostStore) GetPostIdBeforeTime(channelID string, time int64,
} }
func (s *RetryLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) { func (s *RetryLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
tries := 0 tries := 0
for { for {
result, err := s.PostStore.GetPosts(options, allowFromCache) result, err := s.PostStore.GetPosts(options, allowFromCache, sanitizeOptions)
if err == nil { if err == nil {
return result, nil return result, nil
} }
@@ -6511,11 +6511,11 @@ func (s *RetryLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromC
} }
func (s *RetryLayerPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) { func (s *RetryLayerPostStore) GetPostsAfter(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
tries := 0 tries := 0
for { for {
result, err := s.PostStore.GetPostsAfter(options) result, err := s.PostStore.GetPostsAfter(options, sanitizeOptions)
if err == nil { if err == nil {
return result, nil return result, nil
} }
@@ -6553,11 +6553,11 @@ func (s *RetryLayerPostStore) GetPostsBatchForIndexing(startTime int64, startPos
} }
func (s *RetryLayerPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) { func (s *RetryLayerPostStore) GetPostsBefore(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
tries := 0 tries := 0
for { for {
result, err := s.PostStore.GetPostsBefore(options) result, err := s.PostStore.GetPostsBefore(options, sanitizeOptions)
if err == nil { if err == nil {
return result, nil return result, nil
} }
@@ -6616,11 +6616,11 @@ func (s *RetryLayerPostStore) GetPostsCreatedAt(channelID string, time int64) ([
} }
func (s *RetryLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) { func (s *RetryLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
tries := 0 tries := 0
for { for {
result, err := s.PostStore.GetPostsSince(options, allowFromCache) result, err := s.PostStore.GetPostsSince(options, allowFromCache, sanitizeOptions)
if err == nil { if err == nil {
return result, nil return result, nil
} }

2
store/searchlayer/post_layer.go
Просмотреть файл

@@ -111,7 +111,7 @@ func (s SearchPostStore) Delete(postId string, date int64, deletedByID string) e
opts := model.GetPostsOptions{ opts := model.GetPostsOptions{
SkipFetchThreads: true, SkipFetchThreads: true,
} }
postList, err2 := s.PostStore.Get(context.Background(), postId, opts, "") postList, err2 := s.PostStore.Get(context.Background(), postId, opts, "", map[string]bool{})
if postList != nil && len(postList.Order) > 0 { if postList != nil && len(postList.Order) > 0 {
if err2 != nil { if err2 != nil {
s.deletePostIndex(postList.Posts[postList.Order[0]]) s.deletePostIndex(postList.Posts[postList.Order[0]])

40
store/sqlstore/post_store.go
Просмотреть файл

@@ -549,7 +549,7 @@ func (s *SqlPostStore) buildFlaggedPostChannelFilterClause(channelId string, que
return "AND ChannelId = ?", append(queryParams, channelId) return "AND ChannelId = ?", append(queryParams, channelId)
} }
func (s *SqlPostStore) getPostWithCollapsedThreads(id, userID string, opts model.GetPostsOptions) (*model.PostList, error) { func (s *SqlPostStore) getPostWithCollapsedThreads(id, userID string, opts model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
if id == "" { if id == "" {
return nil, store.NewErrInvalidInput("Post", "id", id) return nil, store.NewErrInvalidInput("Post", "id", id)
} }
@@ -659,7 +659,7 @@ func (s *SqlPostStore) getPostWithCollapsedThreads(id, userID string, opts model
posts = posts[:len(posts)-1] posts = posts[:len(posts)-1]
} }
list, err := s.prepareThreadedResponse([]*postWithExtra{&post}, opts.CollapsedThreadsExtended, false) list, err := s.prepareThreadedResponse([]*postWithExtra{&post}, opts.CollapsedThreadsExtended, false, sanitizeOptions)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -672,9 +672,9 @@ func (s *SqlPostStore) getPostWithCollapsedThreads(id, userID string, opts model
return list, nil return list, nil
} }
func (s *SqlPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string) (*model.PostList, error) { func (s *SqlPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string, sanitizeOptions map[string]bool) (*model.PostList, error) {
if opts.CollapsedThreads { if opts.CollapsedThreads {
return s.getPostWithCollapsedThreads(id, userID, opts) return s.getPostWithCollapsedThreads(id, userID, opts, sanitizeOptions)
} }
pl := model.NewPostList() pl := model.NewPostList()
@@ -1051,7 +1051,7 @@ func (s *SqlPostStore) PermanentDeleteByChannel(channelId string) error {
return nil return nil
} }
func (s *SqlPostStore) prepareThreadedResponse(posts []*postWithExtra, extended, reversed bool) (*model.PostList, error) { func (s *SqlPostStore) prepareThreadedResponse(posts []*postWithExtra, extended, reversed bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
list := model.NewPostList() list := model.NewPostList()
var userIds []string var userIds []string
userIdMap := map[string]bool{} userIdMap := map[string]bool{}
@@ -1071,7 +1071,7 @@ func (s *SqlPostStore) prepareThreadedResponse(posts []*postWithExtra, extended,
return nil, err return nil, err
} }
for _, user := range users { for _, user := range users {
user.SanitizeProfile(map[string]bool{}) user.SanitizeProfile(sanitizeOptions)
usersMap[user.Id] = user usersMap[user.Id] = user
} }
} else { } else {
@@ -1114,7 +1114,7 @@ func (s *SqlPostStore) prepareThreadedResponse(posts []*postWithExtra, extended,
return list, nil return list, nil
} }
func (s *SqlPostStore) getPostsCollapsedThreads(options model.GetPostsOptions) (*model.PostList, error) { func (s *SqlPostStore) getPostsCollapsedThreads(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
var columns []string var columns []string
for _, c := range postSliceColumns() { for _, c := range postSliceColumns() {
columns = append(columns, "Posts."+c) columns = append(columns, "Posts."+c)
@@ -1145,15 +1145,15 @@ func (s *SqlPostStore) getPostsCollapsedThreads(options model.GetPostsOptions) (
return nil, errors.Wrapf(err, "failed to find Posts with channelId=%s", options.ChannelId) return nil, errors.Wrapf(err, "failed to find Posts with channelId=%s", options.ChannelId)
} }
return s.prepareThreadedResponse(posts, options.CollapsedThreadsExtended, false) return s.prepareThreadedResponse(posts, options.CollapsedThreadsExtended, false, sanitizeOptions)
} }
func (s *SqlPostStore) GetPosts(options model.GetPostsOptions, _ bool) (*model.PostList, error) { func (s *SqlPostStore) GetPosts(options model.GetPostsOptions, _ bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
if options.PerPage > 1000 { if options.PerPage > 1000 {
return nil, store.NewErrInvalidInput("Post", "<options.PerPage>", options.PerPage) return nil, store.NewErrInvalidInput("Post", "<options.PerPage>", options.PerPage)
} }
if options.CollapsedThreads { if options.CollapsedThreads {
return s.getPostsCollapsedThreads(options) return s.getPostsCollapsedThreads(options, sanitizeOptions)
} }
offset := options.PerPage * options.Page offset := options.PerPage * options.Page
@@ -1199,7 +1199,7 @@ func (s *SqlPostStore) GetPosts(options model.GetPostsOptions, _ bool) (*model.P
return list, nil return list, nil
} }
func (s *SqlPostStore) getPostsSinceCollapsedThreads(options model.GetPostsSinceOptions) (*model.PostList, error) { func (s *SqlPostStore) getPostsSinceCollapsedThreads(options model.GetPostsSinceOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
var columns []string var columns []string
for _, c := range postSliceColumns() { for _, c := range postSliceColumns() {
columns = append(columns, "Posts."+c) columns = append(columns, "Posts."+c)
@@ -1227,13 +1227,13 @@ func (s *SqlPostStore) getPostsSinceCollapsedThreads(options model.GetPostsSince
if err != nil { if err != nil {
return nil, errors.Wrapf(err, "failed to find Posts with channelId=%s", options.ChannelId) return nil, errors.Wrapf(err, "failed to find Posts with channelId=%s", options.ChannelId)
} }
return s.prepareThreadedResponse(posts, options.CollapsedThreadsExtended, false) return s.prepareThreadedResponse(posts, options.CollapsedThreadsExtended, false, sanitizeOptions)
} }
//nolint:unparam //nolint:unparam
func (s *SqlPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) { func (s *SqlPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
if options.CollapsedThreads { if options.CollapsedThreads {
return s.getPostsSinceCollapsedThreads(options) return s.getPostsSinceCollapsedThreads(options, sanitizeOptions)
} }
posts := []*model.Post{} posts := []*model.Post{}
@@ -1378,15 +1378,15 @@ func (s *SqlPostStore) GetPostsSinceForSync(options model.GetPostsSinceForSyncOp
return posts, cursor, nil return posts, cursor, nil
} }
func (s *SqlPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) { func (s *SqlPostStore) GetPostsBefore(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
return s.getPostsAround(true, options) return s.getPostsAround(true, options, sanitizeOptions)
} }
func (s *SqlPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) { func (s *SqlPostStore) GetPostsAfter(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
return s.getPostsAround(false, options) return s.getPostsAround(false, options, sanitizeOptions)
} }
func (s *SqlPostStore) getPostsAround(before bool, options model.GetPostsOptions) (*model.PostList, error) { func (s *SqlPostStore) getPostsAround(before bool, options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
if options.Page < 0 { if options.Page < 0 {
return nil, store.NewErrInvalidInput("Post", "<options.Page>", options.Page) return nil, store.NewErrInvalidInput("Post", "<options.Page>", options.Page)
} }
@@ -1492,7 +1492,7 @@ func (s *SqlPostStore) getPostsAround(before bool, options model.GetPostsOptions
} }
} }
list, err := s.prepareThreadedResponse(posts, options.CollapsedThreadsExtended, !before) list, err := s.prepareThreadedResponse(posts, options.CollapsedThreadsExtended, !before, sanitizeOptions)
if err != nil { if err != nil {
return nil, err return nil, err
} }

10
store/store.go
Просмотреть файл

@@ -336,19 +336,19 @@ type PostStore interface {
SaveMultiple(posts []*model.Post) ([]*model.Post, int, error) SaveMultiple(posts []*model.Post) ([]*model.Post, int, error)
Save(post *model.Post) (*model.Post, error) Save(post *model.Post) (*model.Post, error)
Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error)
Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string) (*model.PostList, error) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string, sanitizeOptions map[string]bool) (*model.PostList, error)
GetSingle(id string, inclDeleted bool) (*model.Post, error) GetSingle(id string, inclDeleted bool) (*model.Post, error)
Delete(postID string, time int64, deleteByID string) error Delete(postID string, time int64, deleteByID string) error
PermanentDeleteByUser(userID string) error PermanentDeleteByUser(userID string) error
PermanentDeleteByChannel(channelID string) error PermanentDeleteByChannel(channelID string) error
GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error)
GetFlaggedPosts(userID string, offset int, limit int) (*model.PostList, error) GetFlaggedPosts(userID string, offset int, limit int) (*model.PostList, error)
// @openTracingParams userID, teamID, offset, limit // @openTracingParams userID, teamID, offset, limit
GetFlaggedPostsForTeam(userID, teamID string, offset int, limit int) (*model.PostList, error) GetFlaggedPostsForTeam(userID, teamID string, offset int, limit int) (*model.PostList, error)
GetFlaggedPostsForChannel(userID, channelID string, offset int, limit int) (*model.PostList, error) GetFlaggedPostsForChannel(userID, channelID string, offset int, limit int) (*model.PostList, error)
GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) GetPostsBefore(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error)
GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) GetPostsAfter(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error)
GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error)
GetPostAfterTime(channelID string, time int64, collapsedThreads bool) (*model.Post, error) GetPostAfterTime(channelID string, time int64, collapsedThreads bool) (*model.Post, error)
GetPostIdAfterTime(channelID string, time int64, collapsedThreads bool) (string, error) GetPostIdAfterTime(channelID string, time int64, collapsedThreads bool) (string, error)
GetPostIdBeforeTime(channelID string, time int64, collapsedThreads bool) (string, error) GetPostIdBeforeTime(channelID string, time int64, collapsedThreads bool) (string, error)

70
store/storetest/mocks/PostStore.go
Просмотреть файл

@@ -123,13 +123,13 @@ func (_m *PostStore) DeleteOrphanedRows(limit int) (int64, error) {
return r0, r1 return r0, r1
} }
// Get provides a mock function with given fields: ctx, id, opts, userID // Get provides a mock function with given fields: ctx, id, opts, userID, sanitizeOptions
func (_m *PostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string) (*model.PostList, error) { func (_m *PostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string, sanitizeOptions map[string]bool) (*model.PostList, error) {
ret := _m.Called(ctx, id, opts, userID) ret := _m.Called(ctx, id, opts, userID, sanitizeOptions)
var r0 *model.PostList var r0 *model.PostList
if rf, ok := ret.Get(0).(func(context.Context, string, model.GetPostsOptions, string) *model.PostList); ok { if rf, ok := ret.Get(0).(func(context.Context, string, model.GetPostsOptions, string, map[string]bool) *model.PostList); ok {
r0 = rf(ctx, id, opts, userID) r0 = rf(ctx, id, opts, userID, sanitizeOptions)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PostList) r0 = ret.Get(0).(*model.PostList)
@@ -137,8 +137,8 @@ func (_m *PostStore) Get(ctx context.Context, id string, opts model.GetPostsOpti
} }
var r1 error var r1 error
if rf, ok := ret.Get(1).(func(context.Context, string, model.GetPostsOptions, string) error); ok { if rf, ok := ret.Get(1).(func(context.Context, string, model.GetPostsOptions, string, map[string]bool) error); ok {
r1 = rf(ctx, id, opts, userID) r1 = rf(ctx, id, opts, userID, sanitizeOptions)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
} }
@@ -419,13 +419,13 @@ func (_m *PostStore) GetPostIdBeforeTime(channelID string, time int64, collapsed
return r0, r1 return r0, r1
} }
// GetPosts provides a mock function with given fields: options, allowFromCache // GetPosts provides a mock function with given fields: options, allowFromCache, sanitizeOptions
func (_m *PostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) { func (_m *PostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
ret := _m.Called(options, allowFromCache) ret := _m.Called(options, allowFromCache, sanitizeOptions)
var r0 *model.PostList var r0 *model.PostList
if rf, ok := ret.Get(0).(func(model.GetPostsOptions, bool) *model.PostList); ok { if rf, ok := ret.Get(0).(func(model.GetPostsOptions, bool, map[string]bool) *model.PostList); ok {
r0 = rf(options, allowFromCache) r0 = rf(options, allowFromCache, sanitizeOptions)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PostList) r0 = ret.Get(0).(*model.PostList)
@@ -433,8 +433,8 @@ func (_m *PostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool
} }
var r1 error var r1 error
if rf, ok := ret.Get(1).(func(model.GetPostsOptions, bool) error); ok { if rf, ok := ret.Get(1).(func(model.GetPostsOptions, bool, map[string]bool) error); ok {
r1 = rf(options, allowFromCache) r1 = rf(options, allowFromCache, sanitizeOptions)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
} }
@@ -442,13 +442,13 @@ func (_m *PostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool
return r0, r1 return r0, r1
} }
// GetPostsAfter provides a mock function with given fields: options // GetPostsAfter provides a mock function with given fields: options, sanitizeOptions
func (_m *PostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) { func (_m *PostStore) GetPostsAfter(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
ret := _m.Called(options) ret := _m.Called(options, sanitizeOptions)
var r0 *model.PostList var r0 *model.PostList
if rf, ok := ret.Get(0).(func(model.GetPostsOptions) *model.PostList); ok { if rf, ok := ret.Get(0).(func(model.GetPostsOptions, map[string]bool) *model.PostList); ok {
r0 = rf(options) r0 = rf(options, sanitizeOptions)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PostList) r0 = ret.Get(0).(*model.PostList)
@@ -456,8 +456,8 @@ func (_m *PostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostLi
} }
var r1 error var r1 error
if rf, ok := ret.Get(1).(func(model.GetPostsOptions) error); ok { if rf, ok := ret.Get(1).(func(model.GetPostsOptions, map[string]bool) error); ok {
r1 = rf(options) r1 = rf(options, sanitizeOptions)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
} }
@@ -488,13 +488,13 @@ func (_m *PostStore) GetPostsBatchForIndexing(startTime int64, startPostID strin
return r0, r1 return r0, r1
} }
// GetPostsBefore provides a mock function with given fields: options // GetPostsBefore provides a mock function with given fields: options, sanitizeOptions
func (_m *PostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) { func (_m *PostStore) GetPostsBefore(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
ret := _m.Called(options) ret := _m.Called(options, sanitizeOptions)
var r0 *model.PostList var r0 *model.PostList
if rf, ok := ret.Get(0).(func(model.GetPostsOptions) *model.PostList); ok { if rf, ok := ret.Get(0).(func(model.GetPostsOptions, map[string]bool) *model.PostList); ok {
r0 = rf(options) r0 = rf(options, sanitizeOptions)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PostList) r0 = ret.Get(0).(*model.PostList)
@@ -502,8 +502,8 @@ func (_m *PostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostL
} }
var r1 error var r1 error
if rf, ok := ret.Get(1).(func(model.GetPostsOptions) error); ok { if rf, ok := ret.Get(1).(func(model.GetPostsOptions, map[string]bool) error); ok {
r1 = rf(options) r1 = rf(options, sanitizeOptions)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
} }
@@ -557,13 +557,13 @@ func (_m *PostStore) GetPostsCreatedAt(channelID string, time int64) ([]*model.P
return r0, r1 return r0, r1
} }
// GetPostsSince provides a mock function with given fields: options, allowFromCache // GetPostsSince provides a mock function with given fields: options, allowFromCache, sanitizeOptions
func (_m *PostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) { func (_m *PostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
ret := _m.Called(options, allowFromCache) ret := _m.Called(options, allowFromCache, sanitizeOptions)
var r0 *model.PostList var r0 *model.PostList
if rf, ok := ret.Get(0).(func(model.GetPostsSinceOptions, bool) *model.PostList); ok { if rf, ok := ret.Get(0).(func(model.GetPostsSinceOptions, bool, map[string]bool) *model.PostList); ok {
r0 = rf(options, allowFromCache) r0 = rf(options, allowFromCache, sanitizeOptions)
} else { } else {
if ret.Get(0) != nil { if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PostList) r0 = ret.Get(0).(*model.PostList)
@@ -571,8 +571,8 @@ func (_m *PostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFrom
} }
var r1 error var r1 error
if rf, ok := ret.Get(1).(func(model.GetPostsSinceOptions, bool) error); ok { if rf, ok := ret.Get(1).(func(model.GetPostsSinceOptions, bool, map[string]bool) error); ok {
r1 = rf(options, allowFromCache) r1 = rf(options, allowFromCache, sanitizeOptions)
} else { } else {
r1 = ret.Error(1) r1 = ret.Error(1)
} }

194
store/storetest/post_store.go
Просмотреть файл

@@ -492,14 +492,14 @@ func testPostStoreGet(t *testing.T, ss store.Store) {
etag2 := ss.Post().GetEtag(o1.ChannelId, false, false) etag2 := ss.Post().GetEtag(o1.ChannelId, false, false)
require.Equal(t, 0, strings.Index(etag2, fmt.Sprintf("%v.%v", model.CurrentVersion, o1.UpdateAt)), "Invalid Etag") require.Equal(t, 0, strings.Index(etag2, fmt.Sprintf("%v.%v", model.CurrentVersion, o1.UpdateAt)), "Invalid Etag")
r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post") require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post")
_, err = ss.Post().Get(context.Background(), "123", model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), "123", model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Missing id should have failed") require.Error(t, err, "Missing id should have failed")
_, err = ss.Post().Get(context.Background(), "", model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), "", model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "should fail for blank post ids") require.Error(t, err, "should fail for blank post ids")
} }
@@ -519,7 +519,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
opts := model.GetPostsOptions{ opts := model.GetPostsOptions{
CollapsedThreads: true, CollapsedThreads: true,
} }
r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post") require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post")
require.True(t, *r1.Posts[o1.Id].IsFollowing) require.True(t, *r1.Posts[o1.Id].IsFollowing)
@@ -540,7 +540,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
opts := model.GetPostsOptions{ opts := model.GetPostsOptions{
CollapsedThreads: true, CollapsedThreads: true,
} }
r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post") require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post")
require.False(t, *r1.Posts[o1.Id].IsFollowing) require.False(t, *r1.Posts[o1.Id].IsFollowing)
@@ -556,7 +556,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
opts := model.GetPostsOptions{ opts := model.GetPostsOptions{
CollapsedThreads: true, CollapsedThreads: true,
} }
r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post") require.Equal(t, r1.Posts[o1.Id].CreateAt, o1.CreateAt, "invalid returned post")
require.Nil(t, r1.Posts[o1.Id].IsFollowing) require.Nil(t, r1.Posts[o1.Id].IsFollowing)
@@ -579,7 +579,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
PerPage: 2, PerPage: 2,
Direction: "down", Direction: "down",
} }
r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err := ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 3) // including the root post assert.Len(t, r1.Order, 3) // including the root post
assert.True(t, r1.HasNext) assert.True(t, r1.HasNext)
@@ -594,7 +594,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
FromPost: lastPostID, FromPost: lastPostID,
FromCreateAt: lastPostCreateAt, FromCreateAt: lastPostCreateAt,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 3) // including the root post assert.Len(t, r1.Order, 3) // including the root post
assert.GreaterOrEqual(t, r1.Posts[r1.Order[len(r1.Order)-1]].CreateAt, lastPostCreateAt) assert.GreaterOrEqual(t, r1.Posts[r1.Order[len(r1.Order)-1]].CreateAt, lastPostCreateAt)
@@ -609,7 +609,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
FromPost: r1.Order[1], FromPost: r1.Order[1],
FromCreateAt: firstPostCreateAt, FromCreateAt: firstPostCreateAt,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 3) // including the root post assert.Len(t, r1.Order, 3) // including the root post
assert.LessOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, firstPostCreateAt) assert.LessOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, firstPostCreateAt)
@@ -623,7 +623,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
FromCreateAt: m1.CreateAt, FromCreateAt: m1.CreateAt,
SkipFetchThreads: false, SkipFetchThreads: false,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 2) // including the root post assert.Len(t, r1.Order, 2) // including the root post
assert.LessOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, m1.CreateAt) assert.LessOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, m1.CreateAt)
@@ -636,7 +636,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
Direction: "down", Direction: "down",
SkipFetchThreads: false, SkipFetchThreads: false,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 3) // including the root post assert.Len(t, r1.Order, 3) // including the root post
assert.True(t, r1.HasNext) assert.True(t, r1.HasNext)
@@ -652,7 +652,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
FromCreateAt: lastPostCreateAt, FromCreateAt: lastPostCreateAt,
SkipFetchThreads: false, SkipFetchThreads: false,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 4) // including the root post assert.Len(t, r1.Order, 4) // including the root post
assert.GreaterOrEqual(t, r1.Posts[r1.Order[len(r1.Order)-1]].CreateAt, lastPostCreateAt) assert.GreaterOrEqual(t, r1.Posts[r1.Order[len(r1.Order)-1]].CreateAt, lastPostCreateAt)
@@ -668,7 +668,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
FromCreateAt: firstPostCreateAt, FromCreateAt: firstPostCreateAt,
SkipFetchThreads: false, SkipFetchThreads: false,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 3) // including the root post assert.Len(t, r1.Order, 3) // including the root post
assert.LessOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, firstPostCreateAt) assert.LessOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, firstPostCreateAt)
@@ -682,7 +682,7 @@ func testPostStoreGetForThread(t *testing.T, ss store.Store) {
FromCreateAt: m1.CreateAt, FromCreateAt: m1.CreateAt,
SkipFetchThreads: false, SkipFetchThreads: false,
} }
r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId) r1, err = ss.Post().Get(context.Background(), o1.Id, opts, o1.UserId, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Len(t, r1.Order, 2) // including the root post assert.Len(t, r1.Order, 2) // including the root post
assert.GreaterOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, m1.CreateAt) assert.GreaterOrEqual(t, r1.Posts[r1.Order[1]].CreateAt, m1.CreateAt)
@@ -772,15 +772,15 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
o3, err = ss.Post().Save(o3) o3, err = ss.Post().Save(o3)
require.NoError(t, err) require.NoError(t, err)
r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro1 := r1.Posts[o1.Id] ro1 := r1.Posts[o1.Id]
r2, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r2, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro2 := r2.Posts[o2.Id] ro2 := r2.Posts[o2.Id]
r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro3 := r3.Posts[o3.Id] ro3 := r3.Posts[o3.Id]
@@ -791,7 +791,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
_, err = ss.Post().Update(o1a, ro1) _, err = ss.Post().Update(o1a, ro1)
require.NoError(t, err) require.NoError(t, err)
r1, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro1a := r1.Posts[o1.Id] ro1a := r1.Posts[o1.Id]
@@ -802,7 +802,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
_, err = ss.Post().Update(o2a, ro2) _, err = ss.Post().Update(o2a, ro2)
require.NoError(t, err) require.NoError(t, err)
r2, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r2, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro2a := r2.Posts[o2.Id] ro2a := r2.Posts[o2.Id]
@@ -813,7 +813,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
_, err = ss.Post().Update(o3a, ro3) _, err = ss.Post().Update(o3a, ro3)
require.NoError(t, err) require.NoError(t, err)
r3, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro3a := r3.Posts[o3.Id] ro3a := r3.Posts[o3.Id]
@@ -829,7 +829,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
}) })
require.NoError(t, err) require.NoError(t, err)
r4, err := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") r4, err := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro4 := r4.Posts[o4.Id] ro4 := r4.Posts[o4.Id]
@@ -839,7 +839,7 @@ func testPostStoreUpdate(t *testing.T, ss store.Store) {
_, err = ss.Post().Update(o4a, ro4) _, err = ss.Post().Update(o4a, ro4)
require.NoError(t, err) require.NoError(t, err)
r4, err = ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") r4, err = ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro4a := r4.Posts[o4.Id] ro4a := r4.Posts[o4.Id]
@@ -862,7 +862,7 @@ func testPostStoreDelete(t *testing.T, ss store.Store) {
require.Equal(t, 0, strings.Index(etag1, model.CurrentVersion+"."), "Invalid Etag") require.Equal(t, 0, strings.Index(etag1, model.CurrentVersion+"."), "Invalid Etag")
// Verify the created post. // Verify the created post.
r1, err := ss.Post().Get(context.Background(), rootPost.Id, model.GetPostsOptions{}, "") r1, err := ss.Post().Get(context.Background(), rootPost.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.NotNil(t, r1.Posts[rootPost.Id]) require.NotNil(t, r1.Posts[rootPost.Id])
require.Equal(t, rootPost, r1.Posts[rootPost.Id]) require.Equal(t, rootPost, r1.Posts[rootPost.Id])
@@ -879,7 +879,7 @@ func testPostStoreDelete(t *testing.T, ss store.Store) {
assert.Equal(t, deleteByID, posts[0].GetProp(model.PostPropsDeleteBy), "unexpected Props[model.PostPropsDeleteBy]") assert.Equal(t, deleteByID, posts[0].GetProp(model.PostPropsDeleteBy), "unexpected Props[model.PostPropsDeleteBy]")
// Verify that the post is no longer fetched by default. // Verify that the post is no longer fetched by default.
_, err = ss.Post().Get(context.Background(), rootPost.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), rootPost.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "fetching deleted post should have failed") require.Error(t, err, "fetching deleted post should have failed")
require.IsType(t, &store.ErrNotFound{}, err) require.IsType(t, &store.ErrNotFound{}, err)
@@ -911,12 +911,12 @@ func testPostStoreDelete(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
// Verify the root post deleted // Verify the root post deleted
_, err = ss.Post().Get(context.Background(), rootPost.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), rootPost.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
require.IsType(t, &store.ErrNotFound{}, err) require.IsType(t, &store.ErrNotFound{}, err)
// Verify the reply post deleted // Verify the reply post deleted
_, err = ss.Post().Get(context.Background(), replyPost.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), replyPost.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
require.IsType(t, &store.ErrNotFound{}, err) require.IsType(t, &store.ErrNotFound{}, err)
}) })
@@ -961,17 +961,17 @@ func testPostStoreDelete(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
// Verify the root post and replies deleted // Verify the root post and replies deleted
_, err = ss.Post().Get(context.Background(), rootPost1.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), rootPost1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), replyPost1.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), replyPost1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), replyPost2.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), replyPost2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
// Verify other root posts remain undeleted. // Verify other root posts remain undeleted.
_, err = ss.Post().Get(context.Background(), rootPost2.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), rootPost2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
}) })
} }
@@ -1038,10 +1038,10 @@ func testPostStorePermDelete1Level(t *testing.T, ss store.Store) {
require.EqualValues(t, 0, thread.ReplyCount) require.EqualValues(t, 0, thread.ReplyCount)
require.EqualValues(t, model.StringArray{}, thread.Participants) require.EqualValues(t, model.StringArray{}, thread.Participants)
_, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err, "Deleted id shouldn't have failed") require.NoError(t, err, "Deleted id shouldn't have failed")
_, err = ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
thread, err = ss.Thread().Get(o5.Id) thread, err = ss.Thread().Get(o5.Id)
@@ -1055,16 +1055,16 @@ func testPostStorePermDelete1Level(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
require.Nil(t, thread) require.Nil(t, thread)
_, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), o5.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o5.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), o6.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o6.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
} }
@@ -1094,13 +1094,13 @@ func testPostStorePermDelete1Level2(t *testing.T, ss store.Store) {
err2 := ss.Post().PermanentDeleteByUser(o1.UserId) err2 := ss.Post().PermanentDeleteByUser(o1.UserId)
require.NoError(t, err2) require.NoError(t, err2)
_, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Deleted id should have failed") require.Error(t, err, "Deleted id should have failed")
_, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err, "Deleted id should have failed") require.NoError(t, err, "Deleted id should have failed")
} }
@@ -1128,7 +1128,7 @@ func testPostStoreGetWithChildren(t *testing.T, ss store.Store) {
o3, err = ss.Post().Save(o3) o3, err = ss.Post().Save(o3)
require.NoError(t, err) require.NoError(t, err)
pl, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") pl, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, pl.Posts, 3, "invalid returned post") require.Len(t, pl.Posts, 3, "invalid returned post")
@@ -1136,7 +1136,7 @@ func testPostStoreGetWithChildren(t *testing.T, ss store.Store) {
dErr := ss.Post().Delete(o3.Id, model.GetMillis(), "") dErr := ss.Post().Delete(o3.Id, model.GetMillis(), "")
require.NoError(t, dErr) require.NoError(t, dErr)
pl, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") pl, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, pl.Posts, 2, "invalid returned post") require.Len(t, pl.Posts, 2, "invalid returned post")
@@ -1144,7 +1144,7 @@ func testPostStoreGetWithChildren(t *testing.T, ss store.Store) {
dErr = ss.Post().Delete(o2.Id, model.GetMillis(), "") dErr = ss.Post().Delete(o2.Id, model.GetMillis(), "")
require.NoError(t, dErr) require.NoError(t, dErr)
pl, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") pl, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Len(t, pl.Posts, 1, "invalid returned post") require.Len(t, pl.Posts, 1, "invalid returned post")
@@ -1202,7 +1202,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
o5, err = ss.Post().Save(o5) o5, err = ss.Post().Save(o5)
require.NoError(t, err) require.NoError(t, err)
r1, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 4}, false) r1, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 4}, false, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, r1.Order[0], o5.Id, "invalid order") require.Equal(t, r1.Order[0], o5.Id, "invalid order")
@@ -1215,7 +1215,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
require.Equal(t, r1.Posts[o1.Id].Message, o1.Message, "Missing parent") require.Equal(t, r1.Posts[o1.Id].Message, o1.Message, "Missing parent")
r2, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 4}, false) r2, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 4}, false, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, r2.Order[0], o5.Id, "invalid order") require.Equal(t, r2.Order[0], o5.Id, "invalid order")
@@ -1229,7 +1229,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
require.Equal(t, r2.Posts[o1.Id].Message, o1.Message, "Missing parent") require.Equal(t, r2.Posts[o1.Id].Message, o1.Message, "Missing parent")
// Run once to fill cache // Run once to fill cache
_, err = ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, false) _, err = ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, false, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
o6 := &model.Post{} o6 := &model.Post{}
@@ -1239,7 +1239,7 @@ func testPostStoreGetPostsWithDetails(t *testing.T, ss store.Store) {
_, err = ss.Post().Save(o6) _, err = ss.Post().Save(o6)
require.NoError(t, err) require.NoError(t, err)
r3, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, false) r3, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: o1.ChannelId, Page: 0, PerPage: 30}, false, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, 7, len(r3.Order)) assert.Equal(t, 7, len(r3.Order))
} }
@@ -1264,19 +1264,19 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
} }
t.Run("should return error if negative Page/PerPage options are passed", func(t *testing.T) { t.Run("should return error if negative Page/PerPage options are passed", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: 0, PerPage: -1}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: 0, PerPage: -1}, map[string]bool{})
assert.Nil(t, postList) assert.Nil(t, postList)
assert.Error(t, err) assert.Error(t, err)
assert.IsType(t, &store.ErrInvalidInput{}, err) assert.IsType(t, &store.ErrInvalidInput{}, err)
postList, err = ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: -1, PerPage: 10}) postList, err = ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: -1, PerPage: 10}, map[string]bool{})
assert.Nil(t, postList) assert.Nil(t, postList)
assert.Error(t, err) assert.Error(t, err)
assert.IsType(t, &store.ErrInvalidInput{}, err) assert.IsType(t, &store.ErrInvalidInput{}, err)
}) })
t.Run("should not return anything before the first post", func(t *testing.T) { t.Run("should not return anything before the first post", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: 0, PerPage: 10}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[0].Id, Page: 0, PerPage: 10}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{}, postList.Order) assert.Equal(t, []string{}, postList.Order)
@@ -1284,7 +1284,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should return posts before a post", func(t *testing.T) { t.Run("should return posts before a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, Page: 0, PerPage: 10}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, Page: 0, PerPage: 10}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{posts[4].Id, posts[3].Id, posts[2].Id, posts[1].Id, posts[0].Id}, postList.Order) assert.Equal(t, []string{posts[4].Id, posts[3].Id, posts[2].Id, posts[1].Id, posts[0].Id}, postList.Order)
@@ -1298,7 +1298,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should limit posts before", func(t *testing.T) { t.Run("should limit posts before", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 2}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 2}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{posts[4].Id, posts[3].Id}, postList.Order) assert.Equal(t, []string{posts[4].Id, posts[3].Id}, postList.Order)
@@ -1309,7 +1309,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should not return anything after the last post", func(t *testing.T) { t.Run("should not return anything after the last post", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[len(posts)-1].Id, PerPage: 10}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[len(posts)-1].Id, PerPage: 10}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{}, postList.Order) assert.Equal(t, []string{}, postList.Order)
@@ -1317,7 +1317,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should return posts after a post", func(t *testing.T) { t.Run("should return posts after a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 10}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 10}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{posts[9].Id, posts[8].Id, posts[7].Id, posts[6].Id}, postList.Order) assert.Equal(t, []string{posts[9].Id, posts[8].Id, posts[7].Id, posts[6].Id}, postList.Order)
@@ -1330,7 +1330,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should limit posts after", func(t *testing.T) { t.Run("should limit posts after", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 2}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: posts[5].Id, PerPage: 2}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{posts[7].Id, posts[6].Id}, postList.Order) assert.Equal(t, []string{posts[7].Id, posts[6].Id}, postList.Order)
@@ -1412,7 +1412,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
post2.UpdateAt = post6.UpdateAt post2.UpdateAt = post6.UpdateAt
t.Run("should return each post and thread before a post", func(t *testing.T) { t.Run("should return each post and thread before a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post3.Id, post2.Id}, postList.Order) assert.Equal(t, []string{post3.Id, post2.Id}, postList.Order)
@@ -1426,7 +1426,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should return each post and the root of each thread after a post", func(t *testing.T) { t.Run("should return each post and the root of each thread after a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post6.Id, post5.Id}, postList.Order) assert.Equal(t, []string{post6.Id, post5.Id}, postList.Order)
@@ -1510,7 +1510,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
post2.UpdateAt = post6.UpdateAt post2.UpdateAt = post6.UpdateAt
t.Run("should return each post and thread before a post", func(t *testing.T) { t.Run("should return each post and thread before a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, SkipFetchThreads: true}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, SkipFetchThreads: true}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post3.Id, post2.Id}, postList.Order) assert.Equal(t, []string{post3.Id, post2.Id}, postList.Order)
@@ -1522,7 +1522,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should return each post and thread before a post with limit", func(t *testing.T) { t.Run("should return each post and thread before a post with limit", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 1, SkipFetchThreads: true}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 1, SkipFetchThreads: true}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post3.Id}, postList.Order) assert.Equal(t, []string{post3.Id}, postList.Order)
@@ -1533,7 +1533,7 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
}) })
t.Run("should return each post and the root of each thread after a post", func(t *testing.T) { t.Run("should return each post and the root of each thread after a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, SkipFetchThreads: true}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, SkipFetchThreads: true}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post6.Id, post5.Id}, postList.Order) assert.Equal(t, []string{post6.Id, post5.Id}, postList.Order)
@@ -1616,21 +1616,21 @@ func testPostStoreGetPostsBeforeAfter(t *testing.T, ss store.Store) {
post2.UpdateAt = post6.UpdateAt post2.UpdateAt = post6.UpdateAt
t.Run("should return each root post before a post", func(t *testing.T) { t.Run("should return each root post before a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, CollapsedThreads: true}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, CollapsedThreads: true}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post2.Id, post1.Id}, postList.Order) assert.Equal(t, []string{post2.Id, post1.Id}, postList.Order)
}) })
t.Run("should return each root post before a post with limit", func(t *testing.T) { t.Run("should return each root post before a post with limit", func(t *testing.T) {
postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 1, CollapsedThreads: true}) postList, err := ss.Post().GetPostsBefore(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 1, CollapsedThreads: true}, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{post2.Id}, postList.Order) assert.Equal(t, []string{post2.Id}, postList.Order)
}) })
t.Run("should return each root after a post", func(t *testing.T) { t.Run("should return each root after a post", func(t *testing.T) {
postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, CollapsedThreads: true}) postList, err := ss.Post().GetPostsAfter(model.GetPostsOptions{ChannelId: channelId, PostId: post4.Id, PerPage: 2, CollapsedThreads: true}, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, []string{post5.Id}, postList.Order) assert.Equal(t, []string{post5.Id}, postList.Order)
@@ -1693,7 +1693,7 @@ func testPostStoreGetPostsSince(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
time.Sleep(time.Millisecond) time.Sleep(time.Millisecond)
postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post3.CreateAt}, false) postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post3.CreateAt}, false, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, []string{ assert.Equal(t, []string{
@@ -1724,7 +1724,7 @@ func testPostStoreGetPostsSince(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
time.Sleep(time.Millisecond) time.Sleep(time.Millisecond)
postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt}, false) postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt}, false, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{}, postList.Order) assert.Equal(t, []string{}, postList.Order)
@@ -1746,12 +1746,12 @@ func testPostStoreGetPostsSince(t *testing.T, ss store.Store) {
time.Sleep(time.Millisecond) time.Sleep(time.Millisecond)
// Make a request that returns no results // Make a request that returns no results
postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt}, true) postList, err := ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt}, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, model.NewPostList(), postList) require.Equal(t, model.NewPostList(), postList)
// And then ensure that it doesn't cause future requests to also return no results // And then ensure that it doesn't cause future requests to also return no results
postList, err = ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt - 1}, true) postList, err = ss.Post().GetPostsSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post1.CreateAt - 1}, true, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, []string{post1.Id}, postList.Order) assert.Equal(t, []string{post1.Id}, postList.Order)
@@ -1815,7 +1815,7 @@ func testPostStoreGetPosts(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
t.Run("should return the last posts created in a channel", func(t *testing.T) { t.Run("should return the last posts created in a channel", func(t *testing.T) {
postList, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: channelId, Page: 0, PerPage: 30, SkipFetchThreads: false}, false) postList, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: channelId, Page: 0, PerPage: 30, SkipFetchThreads: false}, false, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{ assert.Equal(t, []string{
@@ -1837,7 +1837,7 @@ func testPostStoreGetPosts(t *testing.T, ss store.Store) {
}) })
t.Run("should return the last posts created in a channel and the threads and the reply count must be 0", func(t *testing.T) { t.Run("should return the last posts created in a channel and the threads and the reply count must be 0", func(t *testing.T) {
postList, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: channelId, Page: 0, PerPage: 2, SkipFetchThreads: false}, false) postList, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: channelId, Page: 0, PerPage: 2, SkipFetchThreads: false}, false, map[string]bool{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, []string{ assert.Equal(t, []string{
@@ -1857,7 +1857,7 @@ func testPostStoreGetPosts(t *testing.T, ss store.Store) {
}) })
t.Run("should return the last posts created in a channel without the threads and the reply count must be correct", func(t *testing.T) { t.Run("should return the last posts created in a channel without the threads and the reply count must be correct", func(t *testing.T) {
postList, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: channelId, Page: 0, PerPage: 2, SkipFetchThreads: true}, false) postList, err := ss.Post().GetPosts(model.GetPostsOptions{ChannelId: channelId, Page: 0, PerPage: 2, SkipFetchThreads: true}, false, map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, []string{ assert.Equal(t, []string{
@@ -2753,23 +2753,23 @@ func testPostStoreOverwriteMultiple(t *testing.T, ss store.Store) {
}) })
require.NoError(t, err) require.NoError(t, err)
r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro1 := r1.Posts[o1.Id] ro1 := r1.Posts[o1.Id]
r2, err := ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "") r2, err := ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro2 := r2.Posts[o2.Id] ro2 := r2.Posts[o2.Id]
r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro3 := r3.Posts[o3.Id] ro3 := r3.Posts[o3.Id]
r4, err := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") r4, err := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro4 := r4.Posts[o4.Id] ro4 := r4.Posts[o4.Id]
r5, err := ss.Post().Get(context.Background(), o5.Id, model.GetPostsOptions{}, "") r5, err := ss.Post().Get(context.Background(), o5.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro5 := r5.Posts[o5.Id] ro5 := r5.Posts[o5.Id]
@@ -2795,15 +2795,15 @@ func testPostStoreOverwriteMultiple(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, -1, errIdx) require.Equal(t, -1, errIdx)
r1, nErr := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, nErr := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, nErr) require.NoError(t, nErr)
ro1a := r1.Posts[o1.Id] ro1a := r1.Posts[o1.Id]
r2, nErr = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r2, nErr = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, nErr) require.NoError(t, nErr)
ro2a := r2.Posts[o2.Id] ro2a := r2.Posts[o2.Id]
r3, nErr = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, nErr = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, nErr) require.NoError(t, nErr)
ro3a := r3.Posts[o3.Id] ro3a := r3.Posts[o3.Id]
@@ -2825,11 +2825,11 @@ func testPostStoreOverwriteMultiple(t *testing.T, ss store.Store) {
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, -1, errIdx) require.Equal(t, -1, errIdx)
r4, nErr := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") r4, nErr := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, nErr) require.NoError(t, nErr)
ro4a := r4.Posts[o4.Id] ro4a := r4.Posts[o4.Id]
r5, nErr = ss.Post().Get(context.Background(), o5.Id, model.GetPostsOptions{}, "") r5, nErr = ss.Post().Get(context.Background(), o5.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, nErr) require.NoError(t, nErr)
ro5a := r5.Posts[o5.Id] ro5a := r5.Posts[o5.Id]
@@ -2871,19 +2871,19 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
}) })
require.NoError(t, err) require.NoError(t, err)
r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro1 := r1.Posts[o1.Id] ro1 := r1.Posts[o1.Id]
r2, err := ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "") r2, err := ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro2 := r2.Posts[o2.Id] ro2 := r2.Posts[o2.Id]
r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro3 := r3.Posts[o3.Id] ro3 := r3.Posts[o3.Id]
r4, err := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") r4, err := ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro4 := r4.Posts[o4.Id] ro4 := r4.Posts[o4.Id]
@@ -2908,15 +2908,15 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
_, err = ss.Post().Overwrite(o3a) _, err = ss.Post().Overwrite(o3a)
require.NoError(t, err) require.NoError(t, err)
r1, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro1a := r1.Posts[o1.Id] ro1a := r1.Posts[o1.Id]
r2, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r2, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro2a := r2.Posts[o2.Id] ro2a := r2.Posts[o2.Id]
r3, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro3a := r3.Posts[o3.Id] ro3a := r3.Posts[o3.Id]
@@ -2932,7 +2932,7 @@ func testPostStoreOverwrite(t *testing.T, ss store.Store) {
_, err = ss.Post().Overwrite(o4a) _, err = ss.Post().Overwrite(o4a)
require.NoError(t, err) require.NoError(t, err)
r4, err = ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "") r4, err = ss.Post().Get(context.Background(), o4.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro4a := r4.Posts[o4.Id] ro4a := r4.Posts[o4.Id]
@@ -2963,15 +2963,15 @@ func testPostStoreGetPostsByIds(t *testing.T, ss store.Store) {
o3, err = ss.Post().Save(o3) o3, err = ss.Post().Save(o3)
require.NoError(t, err) require.NoError(t, err)
r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") r1, err := ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro1 := r1.Posts[o1.Id] ro1 := r1.Posts[o1.Id]
r2, err := ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "") r2, err := ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro2 := r2.Posts[o2.Id] ro2 := r2.Posts[o2.Id]
r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") r3, err := ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
ro3 := r3.Posts[o3.Id] ro3 := r3.Posts[o3.Id]
@@ -3096,13 +3096,13 @@ func testPostStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
_, _, err = ss.Post().PermanentDeleteBatchForRetentionPolicies(0, 2000, 1000, model.RetentionPolicyCursor{}) _, _, err = ss.Post().PermanentDeleteBatchForRetentionPolicies(0, 2000, 1000, model.RetentionPolicyCursor{})
require.NoError(t, err) require.NoError(t, err)
_, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o1.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Should have not found post 1 after purge") require.Error(t, err, "Should have not found post 1 after purge")
_, err = ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err, "Should have not found post 2 after purge") require.Error(t, err, "Should have not found post 2 after purge")
_, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "") _, err = ss.Post().Get(context.Background(), o3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err, "Should have found post 3 after purge") require.NoError(t, err, "Should have found post 3 after purge")
t.Run("with pagination", func(t *testing.T) { t.Run("with pagination", func(t *testing.T) {
@@ -3146,13 +3146,13 @@ func testPostStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
_, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(0, 2000, 1000, model.RetentionPolicyCursor{}) _, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(0, 2000, 1000, model.RetentionPolicyCursor{})
require.NoError(t, err2) require.NoError(t, err2)
_, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") _, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err2, "global policy should have been ignored due to granular policy") require.NoError(t, err2, "global policy should have been ignored due to granular policy")
nowMillis := post.CreateAt + *channelPolicy.PostDurationDays*model.DayInMilliseconds + 1 nowMillis := post.CreateAt + *channelPolicy.PostDurationDays*model.DayInMilliseconds + 1
_, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(nowMillis, 0, 1000, model.RetentionPolicyCursor{}) _, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(nowMillis, 0, 1000, model.RetentionPolicyCursor{})
require.NoError(t, err2) require.NoError(t, err2)
_, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") _, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err2, "post should have been deleted by channel policy") require.Error(t, err2, "post should have been deleted by channel policy")
// Create a team policy which is stricter than the channel policy // Create a team policy which is stricter than the channel policy
@@ -3171,7 +3171,7 @@ func testPostStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
nowMillis = post.CreateAt + *teamPolicy.PostDurationDays*model.DayInMilliseconds + 1 nowMillis = post.CreateAt + *teamPolicy.PostDurationDays*model.DayInMilliseconds + 1
_, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(nowMillis, 0, 1000, model.RetentionPolicyCursor{}) _, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(nowMillis, 0, 1000, model.RetentionPolicyCursor{})
require.NoError(t, err2) require.NoError(t, err2)
_, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") _, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err2, "channel policy should have overridden team policy") require.NoError(t, err2, "channel policy should have overridden team policy")
// Delete channel policy and re-run team policy // Delete channel policy and re-run team policy
@@ -3183,7 +3183,7 @@ func testPostStorePermanentDeleteBatch(t *testing.T, ss store.Store) {
_, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(nowMillis, 0, 1000, model.RetentionPolicyCursor{}) _, _, err2 = ss.Post().PermanentDeleteBatchForRetentionPolicies(nowMillis, 0, 1000, model.RetentionPolicyCursor{})
require.NoError(t, err2) require.NoError(t, err2)
_, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") _, err2 = ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.Error(t, err2, "post should have been deleted by team policy") require.Error(t, err2, "post should have been deleted by team policy")
err2 = ss.RetentionPolicy().RemoveTeams(teamPolicy.ID, []string{team.Id}) err2 = ss.RetentionPolicy().RemoveTeams(teamPolicy.ID, []string{team.Id})

14
store/storetest/reaction_store.go
Просмотреть файл

@@ -55,7 +55,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
assert.Zero(t, saved.DeleteAt, "should've saved reaction delete_at with zero value and returned it") assert.Zero(t, saved.DeleteAt, "should've saved reaction delete_at with zero value and returned it")
var secondUpdateAt int64 var secondUpdateAt int64
postList, err := ss.Post().Get(context.Background(), reaction1.PostId, model.GetPostsOptions{}, "") postList, err := ss.Post().Get(context.Background(), reaction1.PostId, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.True(t, postList.Posts[post.Id].HasReactions, "should've set HasReactions = true on post") assert.True(t, postList.Posts[post.Id].HasReactions, "should've set HasReactions = true on post")
@@ -79,7 +79,7 @@ func testReactionSave(t *testing.T, ss store.Store) {
_, nErr = ss.Reaction().Save(reaction2) _, nErr = ss.Reaction().Save(reaction2)
require.NoError(t, nErr) require.NoError(t, nErr)
postList, err = ss.Post().Get(context.Background(), reaction2.PostId, model.GetPostsOptions{}, "") postList, err = ss.Post().Get(context.Background(), reaction2.PostId, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.NotEqual(t, postList.Posts[post.Id].UpdateAt, secondUpdateAt, "should've marked post as updated even if HasReactions doesn't change") assert.NotEqual(t, postList.Posts[post.Id].UpdateAt, secondUpdateAt, "should've marked post as updated even if HasReactions doesn't change")
@@ -129,7 +129,7 @@ func testReactionDelete(t *testing.T, ss store.Store) {
_, nErr := ss.Reaction().Save(reaction) _, nErr := ss.Reaction().Save(reaction)
require.NoError(t, nErr) require.NoError(t, nErr)
result, err := ss.Post().Get(context.Background(), reaction.PostId, model.GetPostsOptions{}, "") result, err := ss.Post().Get(context.Background(), reaction.PostId, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
firstUpdateAt := result.Posts[post.Id].UpdateAt firstUpdateAt := result.Posts[post.Id].UpdateAt
@@ -142,7 +142,7 @@ func testReactionDelete(t *testing.T, ss store.Store) {
assert.Empty(t, reactions, "should've deleted reaction") assert.Empty(t, reactions, "should've deleted reaction")
postList, err := ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") postList, err := ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.False(t, postList.Posts[post.Id].HasReactions, "should've set HasReactions = false on post") assert.False(t, postList.Posts[post.Id].HasReactions, "should've set HasReactions = false on post")
@@ -507,15 +507,15 @@ func testReactionDeleteAllWithEmojiName(t *testing.T, ss store.Store, s SqlStore
assert.Empty(t, returned, "should've only removed reactions with emoji name") assert.Empty(t, returned, "should've only removed reactions with emoji name")
// check that the posts are updated // check that the posts are updated
postList, err := ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "") postList, err := ss.Post().Get(context.Background(), post.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.True(t, postList.Posts[post.Id].HasReactions, "post should still have reactions") assert.True(t, postList.Posts[post.Id].HasReactions, "post should still have reactions")
postList, err = ss.Post().Get(context.Background(), post2.Id, model.GetPostsOptions{}, "") postList, err = ss.Post().Get(context.Background(), post2.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.True(t, postList.Posts[post2.Id].HasReactions, "post should still have reactions") assert.True(t, postList.Posts[post2.Id].HasReactions, "post should still have reactions")
postList, err = ss.Post().Get(context.Background(), post3.Id, model.GetPostsOptions{}, "") postList, err = ss.Post().Get(context.Background(), post3.Id, model.GetPostsOptions{}, "", map[string]bool{})
require.NoError(t, err) require.NoError(t, err)
assert.False(t, postList.Posts[post3.Id].HasReactions, "post shouldn't have reactions any more") assert.False(t, postList.Posts[post3.Id].HasReactions, "post shouldn't have reactions any more")

2
store/storetest/thread_store.go
Просмотреть файл

@@ -83,7 +83,7 @@ func testThreadStorePopulation(t *testing.T, ss store.Store) {
opts := model.GetPostsOptions{ opts := model.GetPostsOptions{
SkipFetchThreads: true, SkipFetchThreads: true,
} }
olist, _ := ss.Post().Get(context.Background(), otmp.Id, opts, "") olist, _ := ss.Post().Get(context.Background(), otmp.Id, opts, "", map[string]bool{})
o1 := olist.Posts[olist.Order[0]] o1 := olist.Posts[olist.Order[0]]
newPosts = append([]*model.Post{o1}, newPosts...) newPosts = append([]*model.Post{o1}, newPosts...)

20
store/timerlayer/timerlayer.go
Просмотреть файл

@@ -4970,10 +4970,10 @@ func (s *TimerLayerPostStore) DeleteOrphanedRows(limit int) (int64, error) {
return result, err return result, err
} }
func (s *TimerLayerPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string) (*model.PostList, error) { func (s *TimerLayerPostStore) Get(ctx context.Context, id string, opts model.GetPostsOptions, userID string, sanitizeOptions map[string]bool) (*model.PostList, error) {
start := timemodule.Now() start := timemodule.Now()
result, err := s.PostStore.Get(ctx, id, opts, userID) result, err := s.PostStore.Get(ctx, id, opts, userID, sanitizeOptions)
elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second) elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
if s.Root.Metrics != nil { if s.Root.Metrics != nil {
@@ -5194,10 +5194,10 @@ func (s *TimerLayerPostStore) GetPostIdBeforeTime(channelID string, time int64,
return result, err return result, err
} }
func (s *TimerLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) { func (s *TimerLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
start := timemodule.Now() start := timemodule.Now()
result, err := s.PostStore.GetPosts(options, allowFromCache) result, err := s.PostStore.GetPosts(options, allowFromCache, sanitizeOptions)
elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second) elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
if s.Root.Metrics != nil { if s.Root.Metrics != nil {
@@ -5210,10 +5210,10 @@ func (s *TimerLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromC
return result, err return result, err
} }
func (s *TimerLayerPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) { func (s *TimerLayerPostStore) GetPostsAfter(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
start := timemodule.Now() start := timemodule.Now()
result, err := s.PostStore.GetPostsAfter(options) result, err := s.PostStore.GetPostsAfter(options, sanitizeOptions)
elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second) elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
if s.Root.Metrics != nil { if s.Root.Metrics != nil {
@@ -5242,10 +5242,10 @@ func (s *TimerLayerPostStore) GetPostsBatchForIndexing(startTime int64, startPos
return result, err return result, err
} }
func (s *TimerLayerPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) { func (s *TimerLayerPostStore) GetPostsBefore(options model.GetPostsOptions, sanitizeOptions map[string]bool) (*model.PostList, error) {
start := timemodule.Now() start := timemodule.Now()
result, err := s.PostStore.GetPostsBefore(options) result, err := s.PostStore.GetPostsBefore(options, sanitizeOptions)
elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second) elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
if s.Root.Metrics != nil { if s.Root.Metrics != nil {
@@ -5290,10 +5290,10 @@ func (s *TimerLayerPostStore) GetPostsCreatedAt(channelID string, time int64) ([
return result, err return result, err
} }
func (s *TimerLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) { func (s *TimerLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
start := timemodule.Now() start := timemodule.Now()
result, err := s.PostStore.GetPostsSince(options, allowFromCache) result, err := s.PostStore.GetPostsSince(options, allowFromCache, sanitizeOptions)
elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second) elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
if s.Root.Metrics != nil { if s.Root.Metrics != nil {