Add search engine support for files (#16190)

* Add search engine support for files * Fixing i18n * Fix golangci-lint * Fix consistency problem in the Search receiver functio of the SqlFileStore * Fixing some tests * Fixing test * Apply suggestions from code review Co-authored-by: Mario de Frutos Dieguez <mario@defrutos.org> * Addressing PR review comments * Removing some empty lines * Address PR review comments * Fixing problem after merge master * Fixing spelling problem * Add missed translations * Fixing certain global variable usages after merge master * Fixing some constants usage * Fixing goimports order Co-authored-by: Mario de Frutos Dieguez <mario@defrutos.org>
2021-01-11 15:14:16 +01:00
--- a/services/searchengine/bleveengine/bleve.go
+++ b/services/searchengine/bleveengine/bleve.go
@@ -24,12 +24,14 @@ import (
 const (
 	EngineName   = "bleve"
 	PostIndex    = "posts"
+	FileIndex    = "files"
 	UserIndex    = "users"
 	ChannelIndex = "channels"
 )

 type BleveEngine struct {
 	PostIndex    bleve.Index
+	FileIndex    bleve.Index
 	UserIndex    bleve.Index
 	ChannelIndex bleve.Index
 	Mutex        sync.RWMutex
@@ -83,6 +85,23 @@ func getPostIndexMapping() *mapping.IndexMappingImpl {
 	return indexMapping
 }

+func getFileIndexMapping() *mapping.IndexMappingImpl {
+	fileMapping := bleve.NewDocumentMapping()
+	fileMapping.AddFieldMappingsAt("Id", keywordMapping)
+	fileMapping.AddFieldMappingsAt("CreatorId", keywordMapping)
+	fileMapping.AddFieldMappingsAt("ChannelId", keywordMapping)
+	fileMapping.AddFieldMappingsAt("CreateAt", dateMapping)
+	fileMapping.AddFieldMappingsAt("Name", standardMapping)
+	fileMapping.AddFieldMappingsAt("Content", standardMapping)
+	fileMapping.AddFieldMappingsAt("Extension", keywordMapping)
+	fileMapping.AddFieldMappingsAt("Content", standardMapping)
+
+	indexMapping := bleve.NewIndexMapping()
+	indexMapping.AddDocumentMapping("_default", fileMapping)
+
+	return indexMapping
+}
+
 func getUserIndexMapping() *mapping.IndexMappingImpl {
 	userMapping := bleve.NewDocumentMapping()
 	userMapping.AddFieldMappingsAt("Id", keywordMapping)
@@ -132,6 +151,11 @@ func (b *BleveEngine) openIndexes() *model.AppError {
 		return model.NewAppError("Bleveengine.Start", "bleveengine.create_post_index.error", nil, err.Error(), http.StatusInternalServerError)
 	}

+	b.FileIndex, err = b.createOrOpenIndex(FileIndex, getFileIndexMapping())
+	if err != nil {
+		return model.NewAppError("Bleveengine.Start", "bleveengine.create_file_index.error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
 	b.UserIndex, err = b.createOrOpenIndex(UserIndex, getUserIndexMapping())
 	if err != nil {
 		return model.NewAppError("Bleveengine.Start", "bleveengine.create_user_index.error", nil, err.Error(), http.StatusInternalServerError)
@@ -165,6 +189,10 @@ func (b *BleveEngine) closeIndexes() *model.AppError {
 			return model.NewAppError("Bleveengine.Stop", "bleveengine.stop_post_index.error", nil, err.Error(), http.StatusInternalServerError)
 		}

+		if err := b.FileIndex.Close(); err != nil {
+			return model.NewAppError("Bleveengine.Stop", "bleveengine.stop_file_index.error", nil, err.Error(), http.StatusInternalServerError)
+		}
+
 		if err := b.UserIndex.Close(); err != nil {
 			return model.NewAppError("Bleveengine.Stop", "bleveengine.stop_user_index.error", nil, err.Error(), http.StatusInternalServerError)
 		}
--- a/services/searchengine/bleveengine/bleve_test.go
+++ b/services/searchengine/bleveengine/bleve_test.go
@@ -98,6 +98,10 @@ func (s *BleveEngineTestSuite) TestBleveSearchStoreTests() {
 	s.Run("TestSearchPostStore", func() {
 		searchtest.TestSearchPostStore(s.T(), s.Store, searchTestEngine)
 	})
+
+	s.Run("TestSearchFileInfoStore", func() {
+		searchtest.TestSearchFileInfoStore(s.T(), s.Store, searchTestEngine)
+	})
 }

 func (s *BleveEngineTestSuite) TestDeleteChannelPosts() {
--- a/services/searchengine/bleveengine/common.go
+++ b/services/searchengine/bleveengine/common.go
@@ -36,6 +36,16 @@ type BLVPost struct {
 	Attachments string
 }

+type BLVFile struct {
+	Id        string
+	CreatorId string
+	ChannelId string
+	CreateAt  int64
+	Name      string
+	Content   string
+	Extension string
+}
+
 func BLVChannelFromChannel(channel *model.Channel) *BLVChannel {
 	displayNameInputs := searchengine.GetSuggestionInputsSplitBy(channel.DisplayName, " ")
 	nameInputs := searchengine.GetSuggestionInputsSplitByMultiple(channel.Name, []string{"-", "_"})
@@ -114,3 +124,27 @@ func BLVPostFromPostForIndexing(post *model.PostForIndexing) *BLVPost {
 		Hashtags:  strings.Fields(post.Hashtags),
 	}
 }
+
+func BLVFileFromFileInfo(fileInfo *model.FileInfo, channelId string) *BLVFile {
+	return &BLVFile{
+		Id:        fileInfo.Id,
+		ChannelId: channelId,
+		CreatorId: fileInfo.CreatorId,
+		CreateAt:  fileInfo.CreateAt,
+		Content:   fileInfo.Content,
+		Extension: fileInfo.Extension,
+		Name:      fileInfo.Name,
+	}
+}
+
+func BLVFileFromFileForIndexing(file *model.FileForIndexing) *BLVFile {
+	return &BLVFile{
+		Id:        file.Id,
+		ChannelId: file.ChannelId,
+		CreatorId: file.CreatorId,
+		CreateAt:  file.CreateAt,
+		Content:   file.Content,
+		Extension: file.Extension,
+		Name:      file.Name,
+	}
+}
--- a/services/searchengine/bleveengine/indexer/indexing_job.go
+++ b/services/searchengine/bleveengine/indexer/indexing_job.go
@@ -354,6 +354,30 @@ func (worker *BleveIndexerWorker) BulkIndexPosts(posts []*model.PostForIndexing,
 	return lastCreateAt, nil
 }

+func (worker *BleveIndexerWorker) BulkIndexFiles(files []*model.FileForIndexing, progress IndexingProgress) (int64, *model.AppError) {
+	lastCreateAt := int64(0)
+	batch := worker.engine.FileIndex.NewBatch()
+
+	for _, file := range files {
+		if file.DeleteAt == 0 {
+			searchFile := bleveengine.BLVFileFromFileForIndexing(file)
+			batch.Index(searchFile.Id, searchFile)
+		} else {
+			batch.Delete(file.Id)
+		}
+
+		lastCreateAt = file.CreateAt
+	}
+
+	worker.engine.Mutex.RLock()
+	defer worker.engine.Mutex.RUnlock()
+
+	if err := worker.engine.FileIndex.Batch(batch); err != nil {
+		return 0, model.NewAppError("BleveIndexerWorker.BulkIndexPosts", "bleveengine.indexer.do_job.bulk_index_files.batch_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return lastCreateAt, nil
+}
+
 func (worker *BleveIndexerWorker) IndexChannelsBatch(progress IndexingProgress) (IndexingProgress, *model.AppError) {
 	endTime := progress.LastEntityTime + int64(*worker.jobServer.Config().BleveSettings.BulkIndexingTimeWindowSeconds*1000)

--- a/services/searchengine/bleveengine/search.go
+++ b/services/searchengine/bleveengine/search.go
@@ -15,6 +15,7 @@ import (
 )

 const DeletePostsBatchSize = 500
+const DeleteFilesBatchSize = 500

 func (b *BleveEngine) IndexPost(post *model.Post, teamId string) *model.AppError {
 	b.Mutex.RLock()
@@ -507,3 +508,320 @@ func (b *BleveEngine) DeleteUser(user *model.User) *model.AppError {
 	}
 	return nil
 }
+
+func (b *BleveEngine) IndexFile(file *model.FileInfo, channelId string) *model.AppError {
+	b.Mutex.RLock()
+	defer b.Mutex.RUnlock()
+
+	blvFile := BLVFileFromFileInfo(file, channelId)
+	if err := b.FileIndex.Index(blvFile.Id, blvFile); err != nil {
+		return model.NewAppError("Bleveengine.IndexFile", "bleveengine.index_file.error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return nil
+}
+
+func (b *BleveEngine) SearchFiles(channels *model.ChannelList, searchParams []*model.SearchParams, page, perPage int) ([]string, *model.AppError) {
+	channelQueries := []query.Query{}
+	for _, channel := range *channels {
+		channelIdQ := bleve.NewTermQuery(channel.Id)
+		channelIdQ.SetField("ChannelId")
+		channelQueries = append(channelQueries, channelIdQ)
+	}
+	channelDisjunctionQ := bleve.NewDisjunctionQuery(channelQueries...)
+
+	var termQueries []query.Query
+	var notTermQueries []query.Query
+	var filters []query.Query
+	var notFilters []query.Query
+
+	for i, params := range searchParams {
+		var termOperator query.MatchQueryOperator = query.MatchQueryOperatorAnd
+		if searchParams[0].OrTerms {
+			termOperator = query.MatchQueryOperatorOr
+		}
+
+		// Date, channels and FromUsers filters come in all
+		// searchParams iteration, and as they are global to the
+		// query, we only need to process them once
+		if i == 0 {
+			if len(params.InChannels) > 0 {
+				inChannels := []query.Query{}
+				for _, channelId := range params.InChannels {
+					channelQ := bleve.NewTermQuery(channelId)
+					channelQ.SetField("ChannelId")
+					inChannels = append(inChannels, channelQ)
+				}
+				filters = append(filters, bleve.NewDisjunctionQuery(inChannels...))
+			}
+
+			if len(params.ExcludedChannels) > 0 {
+				excludedChannels := []query.Query{}
+				for _, channelId := range params.ExcludedChannels {
+					channelQ := bleve.NewTermQuery(channelId)
+					channelQ.SetField("ChannelId")
+					excludedChannels = append(excludedChannels, channelQ)
+				}
+				notFilters = append(notFilters, bleve.NewDisjunctionQuery(excludedChannels...))
+			}
+
+			if len(params.FromUsers) > 0 {
+				fromUsers := []query.Query{}
+				for _, userId := range params.FromUsers {
+					userQ := bleve.NewTermQuery(userId)
+					userQ.SetField("CreatorId")
+					fromUsers = append(fromUsers, userQ)
+				}
+				filters = append(filters, bleve.NewDisjunctionQuery(fromUsers...))
+			}
+
+			if len(params.ExcludedUsers) > 0 {
+				excludedUsers := []query.Query{}
+				for _, userId := range params.ExcludedUsers {
+					userQ := bleve.NewTermQuery(userId)
+					userQ.SetField("CreatorId")
+					excludedUsers = append(excludedUsers, userQ)
+				}
+				notFilters = append(notFilters, bleve.NewDisjunctionQuery(excludedUsers...))
+			}
+
+			if len(params.Extensions) > 0 {
+				extensions := []query.Query{}
+				for _, extension := range params.Extensions {
+					extensionQ := bleve.NewTermQuery(extension)
+					extensionQ.SetField("Extension")
+					extensions = append(extensions, extensionQ)
+				}
+				filters = append(filters, bleve.NewDisjunctionQuery(extensions...))
+			}
+
+			if len(params.ExcludedExtensions) > 0 {
+				excludedExtensions := []query.Query{}
+				for _, extension := range params.ExcludedExtensions {
+					extensionQ := bleve.NewTermQuery(extension)
+					extensionQ.SetField("Extension")
+					excludedExtensions = append(excludedExtensions, extensionQ)
+				}
+				notFilters = append(notFilters, bleve.NewDisjunctionQuery(excludedExtensions...))
+			}
+
+			if params.OnDate != "" {
+				before, after := params.GetOnDateMillis()
+				beforeFloat64 := float64(before)
+				afterFloat64 := float64(after)
+				onDateQ := bleve.NewNumericRangeQuery(&beforeFloat64, &afterFloat64)
+				onDateQ.SetField("CreateAt")
+				filters = append(filters, onDateQ)
+			} else {
+				if params.AfterDate != "" || params.BeforeDate != "" {
+					var min, max *float64
+					if params.AfterDate != "" {
+						minf := float64(params.GetAfterDateMillis())
+						min = &minf
+					}
+
+					if params.BeforeDate != "" {
+						maxf := float64(params.GetBeforeDateMillis())
+						max = &maxf
+					}
+
+					dateQ := bleve.NewNumericRangeQuery(min, max)
+					dateQ.SetField("CreateAt")
+					filters = append(filters, dateQ)
+				}
+
+				if params.ExcludedAfterDate != "" {
+					minf := float64(params.GetExcludedAfterDateMillis())
+					dateQ := bleve.NewNumericRangeQuery(&minf, nil)
+					dateQ.SetField("CreateAt")
+					notFilters = append(notFilters, dateQ)
+				}
+
+				if params.ExcludedBeforeDate != "" {
+					maxf := float64(params.GetExcludedBeforeDateMillis())
+					dateQ := bleve.NewNumericRangeQuery(nil, &maxf)
+					dateQ.SetField("CreateAt")
+					notFilters = append(notFilters, dateQ)
+				}
+
+				if params.ExcludedDate != "" {
+					before, after := params.GetExcludedDateMillis()
+					beforef := float64(before)
+					afterf := float64(after)
+					onDateQ := bleve.NewNumericRangeQuery(&beforef, &afterf)
+					onDateQ.SetField("CreateAt")
+					notFilters = append(notFilters, onDateQ)
+				}
+			}
+		}
+
+		if len(params.Terms) > 0 {
+			terms := []string{}
+			for _, term := range strings.Split(params.Terms, " ") {
+				if strings.HasSuffix(term, "*") {
+					nameQ := bleve.NewWildcardQuery(term)
+					nameQ.SetField("Name")
+					contentQ := bleve.NewWildcardQuery(term)
+					contentQ.SetField("Content")
+					termQueries = append(termQueries, bleve.NewDisjunctionQuery(nameQ, contentQ))
+				} else {
+					terms = append(terms, term)
+				}
+			}
+
+			if len(terms) > 0 {
+				nameQ := bleve.NewMatchQuery(strings.Join(terms, " "))
+				nameQ.SetField("Name")
+				nameQ.SetOperator(termOperator)
+				contentQ := bleve.NewMatchQuery(strings.Join(terms, " "))
+				contentQ.SetField("Content")
+				contentQ.SetOperator(termOperator)
+				termQueries = append(termQueries, bleve.NewDisjunctionQuery(nameQ, contentQ))
+			}
+		}
+
+		if len(params.ExcludedTerms) > 0 {
+			nameQ := bleve.NewMatchQuery(params.ExcludedTerms)
+			nameQ.SetField("Name")
+			nameQ.SetOperator(termOperator)
+			contentQ := bleve.NewMatchQuery(params.ExcludedTerms)
+			contentQ.SetField("Content")
+			contentQ.SetOperator(termOperator)
+			notTermQueries = append(notTermQueries, bleve.NewDisjunctionQuery(nameQ, contentQ))
+		}
+	}
+
+	allTermsQ := bleve.NewBooleanQuery()
+	allTermsQ.AddMustNot(notTermQueries...)
+	if searchParams[0].OrTerms {
+		allTermsQ.AddShould(termQueries...)
+	} else {
+		allTermsQ.AddMust(termQueries...)
+	}
+
+	query := bleve.NewBooleanQuery()
+	query.AddMust(channelDisjunctionQ)
+
+	if len(termQueries) > 0 || len(notTermQueries) > 0 {
+		query.AddMust(allTermsQ)
+	}
+
+	if len(filters) > 0 {
+		query.AddMust(bleve.NewConjunctionQuery(filters...))
+	}
+	if len(notFilters) > 0 {
+		query.AddMustNot(notFilters...)
+	}
+
+	search := bleve.NewSearchRequestOptions(query, perPage, page*perPage, false)
+	search.SortBy([]string{"-CreateAt"})
+	results, err := b.FileIndex.Search(search)
+	if err != nil {
+		return nil, model.NewAppError("Bleveengine.SearchFiles", "bleveengine.search_files.error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	fileIds := []string{}
+
+	for _, r := range results.Hits {
+		fileIds = append(fileIds, r.ID)
+	}
+
+	return fileIds, nil
+}
+
+func (b *BleveEngine) DeleteFile(fileID string) *model.AppError {
+	b.Mutex.RLock()
+	defer b.Mutex.RUnlock()
+
+	if err := b.FileIndex.Delete(fileID); err != nil {
+		return model.NewAppError("Bleveengine.DeleteFile", "bleveengine.delete_file.error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return nil
+}
+
+func (b *BleveEngine) deleteFiles(searchRequest *bleve.SearchRequest, batchSize int) (int64, error) {
+	resultsCount := int64(0)
+
+	for {
+		// As we are deleting the files after fetching them, we need to keep
+		// From fixed always to 0
+		searchRequest.From = 0
+		searchRequest.Size = batchSize
+		results, err := b.FileIndex.Search(searchRequest)
+		if err != nil {
+			return -1, err
+		}
+		batch := b.FileIndex.NewBatch()
+		for _, file := range results.Hits {
+			batch.Delete(file.ID)
+		}
+		if err := b.FileIndex.Batch(batch); err != nil {
+			return -1, err
+		}
+		resultsCount += int64(results.Hits.Len())
+		if results.Hits.Len() < batchSize {
+			break
+		}
+	}
+
+	return resultsCount, nil
+}
+
+func (b *BleveEngine) DeleteUserFiles(userID string) *model.AppError {
+	b.Mutex.RLock()
+	defer b.Mutex.RUnlock()
+
+	query := bleve.NewTermQuery(userID)
+	query.SetField("CreatorId")
+	search := bleve.NewSearchRequest(query)
+	deleted, err := b.deleteFiles(search, DeleteFilesBatchSize)
+	if err != nil {
+		return model.NewAppError("Bleveengine.DeleteUserFiles",
+			"bleveengine.delete_user_files.error", nil,
+			err.Error(), http.StatusInternalServerError)
+	}
+
+	mlog.Info("Files for user deleted", mlog.String("user_id", userID), mlog.Int64("deleted", deleted))
+
+	return nil
+}
+
+func (b *BleveEngine) DeletePostFiles(postID string) *model.AppError {
+	b.Mutex.RLock()
+	defer b.Mutex.RUnlock()
+
+	query := bleve.NewTermQuery(postID)
+	query.SetField("PostId")
+	search := bleve.NewSearchRequest(query)
+	deleted, err := b.deleteFiles(search, DeleteFilesBatchSize)
+	if err != nil {
+		return model.NewAppError("Bleveengine.DeletePostFiles",
+			"bleveengine.delete_post_files.error", nil,
+			err.Error(), http.StatusInternalServerError)
+	}
+
+	mlog.Info("Files for post deleted", mlog.String("post_id", postID), mlog.Int64("deleted", deleted))
+
+	return nil
+}
+
+func (b *BleveEngine) DeleteFilesBatch(endTime, limit int64) *model.AppError {
+	b.Mutex.RLock()
+	defer b.Mutex.RUnlock()
+
+	endTimeFloat := float64(endTime)
+	query := bleve.NewNumericRangeQuery(nil, &endTimeFloat)
+	query.SetField("CreateAt")
+	search := bleve.NewSearchRequestOptions(query, int(limit), 0, false)
+	search.SortBy([]string{"-CreateAt"})
+
+	deleted, err := b.deleteFiles(search, DeleteFilesBatchSize)
+	if err != nil {
+		return model.NewAppError("Bleveengine.DeleteFilesBatch",
+			"bleveengine.delete_files_batch.error", nil,
+			err.Error(), http.StatusInternalServerError)
+	}
+
+	mlog.Info("Files in batch deleted", mlog.Int64("endTime", endTime), mlog.Int64("limit", limit), mlog.Int64("deleted", deleted))
+
+	return nil
+}
--- a/services/searchengine/interface.go
+++ b/services/searchengine/interface.go
@@ -32,6 +32,12 @@ type SearchEngineInterface interface {
 	SearchUsersInChannel(teamId, channelId string, restrictedToChannels []string, term string, options *model.UserSearchOptions) ([]string, []string, *model.AppError)
 	SearchUsersInTeam(teamId string, restrictedToChannels []string, term string, options *model.UserSearchOptions) ([]string, *model.AppError)
 	DeleteUser(user *model.User) *model.AppError
+	IndexFile(file *model.FileInfo, channelId string) *model.AppError
+	SearchFiles(channels *model.ChannelList, searchParams []*model.SearchParams, page, perPage int) ([]string, *model.AppError)
+	DeleteFile(fileID string) *model.AppError
+	DeletePostFiles(postID string) *model.AppError
+	DeleteUserFiles(userID string) *model.AppError
+	DeleteFilesBatch(endTime, limit int64) *model.AppError
 	TestConfig(cfg *model.Config) *model.AppError
 	PurgeIndexes() *model.AppError
 	RefreshIndexes() *model.AppError
--- a/services/searchengine/mocks/SearchEngineInterface.go
+++ b/services/searchengine/mocks/SearchEngineInterface.go
@@ -64,6 +64,38 @@ func (_m *SearchEngineInterface) DeleteChannelPosts(channelID string) *model.App
 	return r0
 }

+// DeleteFile provides a mock function with given fields: fileID
+func (_m *SearchEngineInterface) DeleteFile(fileID string) *model.AppError {
+	ret := _m.Called(fileID)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(fileID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
+// DeleteFilesBatch provides a mock function with given fields: endTime, limit
+func (_m *SearchEngineInterface) DeleteFilesBatch(endTime int64, limit int64) *model.AppError {
+	ret := _m.Called(endTime, limit)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(int64, int64) *model.AppError); ok {
+		r0 = rf(endTime, limit)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
 // DeletePost provides a mock function with given fields: post
 func (_m *SearchEngineInterface) DeletePost(post *model.Post) *model.AppError {
 	ret := _m.Called(post)
@@ -80,6 +112,22 @@ func (_m *SearchEngineInterface) DeletePost(post *model.Post) *model.AppError {
 	return r0
 }

+// DeletePostFiles provides a mock function with given fields: postID
+func (_m *SearchEngineInterface) DeletePostFiles(postID string) *model.AppError {
+	ret := _m.Called(postID)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
 // DeleteUser provides a mock function with given fields: user
 func (_m *SearchEngineInterface) DeleteUser(user *model.User) *model.AppError {
 	ret := _m.Called(user)
@@ -96,6 +144,22 @@ func (_m *SearchEngineInterface) DeleteUser(user *model.User) *model.AppError {
 	return r0
 }

+// DeleteUserFiles provides a mock function with given fields: userID
+func (_m *SearchEngineInterface) DeleteUserFiles(userID string) *model.AppError {
+	ret := _m.Called(userID)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
 // DeleteUserPosts provides a mock function with given fields: userID
 func (_m *SearchEngineInterface) DeleteUserPosts(userID string) *model.AppError {
 	ret := _m.Called(userID)
@@ -156,6 +220,22 @@ func (_m *SearchEngineInterface) IndexChannel(channel *model.Channel) *model.App
 	return r0
 }

+// IndexFile provides a mock function with given fields: file, channelId
+func (_m *SearchEngineInterface) IndexFile(file *model.FileInfo, channelId string) *model.AppError {
+	ret := _m.Called(file, channelId)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(*model.FileInfo, string) *model.AppError); ok {
+		r0 = rf(file, channelId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
 // IndexPost provides a mock function with given fields: post, teamId
 func (_m *SearchEngineInterface) IndexPost(post *model.Post, teamId string) *model.AppError {
 	ret := _m.Called(post, teamId)
@@ -315,6 +395,31 @@ func (_m *SearchEngineInterface) SearchChannels(teamId string, term string) ([]s
 	return r0, r1
 }

+// SearchFiles provides a mock function with given fields: channels, searchParams, page, perPage
+func (_m *SearchEngineInterface) SearchFiles(channels *model.ChannelList, searchParams []*model.SearchParams, page int, perPage int) ([]string, *model.AppError) {
+	ret := _m.Called(channels, searchParams, page, perPage)
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func(*model.ChannelList, []*model.SearchParams, int, int) []string); ok {
+		r0 = rf(channels, searchParams, page, perPage)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.ChannelList, []*model.SearchParams, int, int) *model.AppError); ok {
+		r1 = rf(channels, searchParams, page, perPage)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
 // SearchPosts provides a mock function with given fields: channels, searchParams, page, perPage
 func (_m *SearchEngineInterface) SearchPosts(channels *model.ChannelList, searchParams []*model.SearchParams, page int, perPage int) ([]string, model.PostSearchMatches, *model.AppError) {
 	ret := _m.Called(channels, searchParams, page, perPage)