mirror of
https://github.com/mattermost/focalboard.git
synced 2024-12-03 08:45:40 +02:00
8d94422d5f
* Adding sever side undelete endpoint * Removing long lines golangci-lint errors * Fixing linter errors * Fixing a test problem * Fixing tests Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
298 lines
8.3 KiB
Go
298 lines
8.3 KiB
Go
package app
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
|
|
"github.com/mattermost/focalboard/server/model"
|
|
"github.com/mattermost/focalboard/server/services/notify"
|
|
"github.com/mattermost/focalboard/server/services/store"
|
|
"github.com/mattermost/focalboard/server/utils"
|
|
|
|
"github.com/mattermost/mattermost-server/v6/shared/mlog"
|
|
)
|
|
|
|
func (a *App) GetBlocks(c store.Container, parentID string, blockType string) ([]model.Block, error) {
|
|
if blockType != "" && parentID != "" {
|
|
return a.store.GetBlocksWithParentAndType(c, parentID, blockType)
|
|
}
|
|
|
|
if blockType != "" {
|
|
return a.store.GetBlocksWithType(c, blockType)
|
|
}
|
|
|
|
return a.store.GetBlocksWithParent(c, parentID)
|
|
}
|
|
|
|
func (a *App) GetBlocksWithRootID(c store.Container, rootID string) ([]model.Block, error) {
|
|
return a.store.GetBlocksWithRootID(c, rootID)
|
|
}
|
|
|
|
func (a *App) GetRootID(c store.Container, blockID string) (string, error) {
|
|
return a.store.GetRootID(c, blockID)
|
|
}
|
|
|
|
func (a *App) GetParentID(c store.Container, blockID string) (string, error) {
|
|
return a.store.GetParentID(c, blockID)
|
|
}
|
|
|
|
func (a *App) PatchBlock(c store.Container, blockID string, blockPatch *model.BlockPatch, modifiedByID string) error {
|
|
oldBlock, err := a.store.GetBlock(c, blockID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
err = a.store.PatchBlock(c, blockID, blockPatch, modifiedByID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
a.metrics.IncrementBlocksPatched(1)
|
|
block, err := a.store.GetBlock(c, blockID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
a.wsAdapter.BroadcastBlockChange(c.WorkspaceID, *block)
|
|
go func() {
|
|
a.webhook.NotifyUpdate(*block)
|
|
a.notifyBlockChanged(notify.Update, c, block, oldBlock, modifiedByID)
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func (a *App) PatchBlocks(c store.Container, blockPatches *model.BlockPatchBatch, modifiedByID string) error {
|
|
oldBlocks := make([]model.Block, 0, len(blockPatches.BlockIDs))
|
|
for _, blockID := range blockPatches.BlockIDs {
|
|
oldBlock, err := a.store.GetBlock(c, blockID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
oldBlocks = append(oldBlocks, *oldBlock)
|
|
}
|
|
|
|
err := a.store.PatchBlocks(c, blockPatches, modifiedByID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
a.metrics.IncrementBlocksPatched(len(oldBlocks))
|
|
for i, blockID := range blockPatches.BlockIDs {
|
|
newBlock, err := a.store.GetBlock(c, blockID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
a.wsAdapter.BroadcastBlockChange(c.WorkspaceID, *newBlock)
|
|
go func(currentIndex int) {
|
|
a.webhook.NotifyUpdate(*newBlock)
|
|
a.notifyBlockChanged(notify.Update, c, newBlock, &oldBlocks[currentIndex], modifiedByID)
|
|
}(i)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *App) InsertBlock(c store.Container, block model.Block, modifiedByID string) error {
|
|
err := a.store.InsertBlock(c, &block, modifiedByID)
|
|
if err == nil {
|
|
a.wsAdapter.BroadcastBlockChange(c.WorkspaceID, block)
|
|
a.metrics.IncrementBlocksInserted(1)
|
|
go func() {
|
|
a.webhook.NotifyUpdate(block)
|
|
a.notifyBlockChanged(notify.Add, c, &block, nil, modifiedByID)
|
|
}()
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (a *App) InsertBlocks(c store.Container, blocks []model.Block, modifiedByID string, allowNotifications bool) ([]model.Block, error) {
|
|
needsNotify := make([]model.Block, 0, len(blocks))
|
|
for i := range blocks {
|
|
err := a.store.InsertBlock(c, &blocks[i], modifiedByID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
blocks[i].WorkspaceID = c.WorkspaceID
|
|
needsNotify = append(needsNotify, blocks[i])
|
|
|
|
a.wsAdapter.BroadcastBlockChange(c.WorkspaceID, blocks[i])
|
|
a.metrics.IncrementBlocksInserted(1)
|
|
}
|
|
|
|
go func() {
|
|
for _, b := range needsNotify {
|
|
block := b
|
|
a.webhook.NotifyUpdate(block)
|
|
if allowNotifications {
|
|
a.notifyBlockChanged(notify.Add, c, &block, nil, modifiedByID)
|
|
}
|
|
}
|
|
}()
|
|
|
|
return blocks, nil
|
|
}
|
|
|
|
func (a *App) CopyCardFiles(sourceBoardID string, destWorkspaceID string, blocks []model.Block) error {
|
|
// Images attached in cards have a path comprising the card's board ID.
|
|
// When we create a template from this board, we need to copy the files
|
|
// with the new board ID in path.
|
|
// Not doing so causing images in templates (and boards created from this
|
|
// template) to fail to load.
|
|
|
|
// look up ID of source board, which may be different than the blocks.
|
|
board, err := a.GetBlockByID(store.Container{}, sourceBoardID)
|
|
if err != nil || board == nil {
|
|
return fmt.Errorf("cannot fetch board %s for CopyCardFiles: %w", sourceBoardID, err)
|
|
}
|
|
|
|
for i := range blocks {
|
|
block := blocks[i]
|
|
|
|
fileName, ok := block.Fields["fileId"]
|
|
if block.Type == model.TypeImage && ok {
|
|
// create unique filename in case we are copying cards within the same board.
|
|
ext := filepath.Ext(fileName.(string))
|
|
destFilename := utils.NewID(utils.IDTypeNone) + ext
|
|
|
|
sourceFilePath := filepath.Join(board.WorkspaceID, sourceBoardID, fileName.(string))
|
|
destinationFilePath := filepath.Join(destWorkspaceID, block.RootID, destFilename)
|
|
|
|
a.logger.Debug(
|
|
"Copying card file",
|
|
mlog.String("sourceFilePath", sourceFilePath),
|
|
mlog.String("destinationFilePath", destinationFilePath),
|
|
)
|
|
|
|
if err := a.filesBackend.CopyFile(sourceFilePath, destinationFilePath); err != nil {
|
|
a.logger.Error(
|
|
"CopyCardFiles failed to copy file",
|
|
mlog.String("sourceFilePath", sourceFilePath),
|
|
mlog.String("destinationFilePath", destinationFilePath),
|
|
mlog.Err(err),
|
|
)
|
|
|
|
return err
|
|
}
|
|
block.Fields["fileId"] = destFilename
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *App) GetSubTree(c store.Container, blockID string, levels int) ([]model.Block, error) {
|
|
// Only 2 or 3 levels are supported for now
|
|
if levels >= 3 {
|
|
return a.store.GetSubTree3(c, blockID, model.QuerySubtreeOptions{})
|
|
}
|
|
return a.store.GetSubTree2(c, blockID, model.QuerySubtreeOptions{})
|
|
}
|
|
|
|
func (a *App) GetAllBlocks(c store.Container) ([]model.Block, error) {
|
|
return a.store.GetAllBlocks(c)
|
|
}
|
|
|
|
func (a *App) GetBlockByID(c store.Container, blockID string) (*model.Block, error) {
|
|
return a.store.GetBlock(c, blockID)
|
|
}
|
|
|
|
func (a *App) DeleteBlock(c store.Container, blockID string, modifiedBy string) error {
|
|
block, err := a.store.GetBlock(c, blockID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if block == nil {
|
|
// deleting non-existing block not considered an error
|
|
return nil
|
|
}
|
|
|
|
err = a.store.DeleteBlock(c, blockID, modifiedBy)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if block.Type == model.TypeImage {
|
|
fileName, fileIDExists := block.Fields["fileId"]
|
|
if fileName, fileIDIsString := fileName.(string); fileIDExists && fileIDIsString {
|
|
filePath := filepath.Join(block.WorkspaceID, block.RootID, fileName)
|
|
err = a.filesBackend.RemoveFile(filePath)
|
|
|
|
if err != nil {
|
|
a.logger.Error("Error deleting image file",
|
|
mlog.String("FilePath", filePath),
|
|
mlog.Err(err))
|
|
}
|
|
}
|
|
}
|
|
|
|
a.wsAdapter.BroadcastBlockDelete(c.WorkspaceID, blockID, block.ParentID)
|
|
a.metrics.IncrementBlocksDeleted(1)
|
|
go func() {
|
|
a.notifyBlockChanged(notify.Delete, c, block, block, modifiedBy)
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func (a *App) UndeleteBlock(c store.Container, blockID string, modifiedBy string) error {
|
|
blocks, err := a.store.GetBlockHistory(c, blockID, model.QueryBlockHistoryOptions{Limit: 1, Descending: true})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(blocks) == 0 {
|
|
// deleting non-existing block not considered an error
|
|
return nil
|
|
}
|
|
|
|
err = a.store.UndeleteBlock(c, blockID, modifiedBy)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
block, err := a.store.GetBlock(c, blockID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if block == nil {
|
|
a.logger.Error("Error loading the block after undelete, not propagating through websockets or notifications")
|
|
return nil
|
|
}
|
|
|
|
a.wsAdapter.BroadcastBlockChange(c.WorkspaceID, *block)
|
|
a.metrics.IncrementBlocksInserted(1)
|
|
go func() {
|
|
a.webhook.NotifyUpdate(*block)
|
|
a.notifyBlockChanged(notify.Add, c, block, nil, modifiedBy)
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func (a *App) GetBlockCountsByType() (map[string]int64, error) {
|
|
return a.store.GetBlockCountsByType()
|
|
}
|
|
|
|
func (a *App) notifyBlockChanged(action notify.Action, c store.Container, block *model.Block, oldBlock *model.Block, modifiedByID string) {
|
|
if a.notifications == nil {
|
|
return
|
|
}
|
|
|
|
// find card and board for the changed block.
|
|
board, card, err := a.store.GetBoardAndCard(c, block)
|
|
if err != nil {
|
|
a.logger.Error("Error notifying for block change; cannot determine board or card", mlog.Err(err))
|
|
return
|
|
}
|
|
|
|
evt := notify.BlockChangeEvent{
|
|
Action: action,
|
|
Workspace: c.WorkspaceID,
|
|
Board: board,
|
|
Card: card,
|
|
BlockChanged: block,
|
|
BlockOld: oldBlock,
|
|
ModifiedByID: modifiedByID,
|
|
}
|
|
a.notifications.BlockChanged(evt)
|
|
}
|