snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/jobs/recap/worker.go

@@ -0,0 +1,141 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package recap
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/mlog"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/jobs"
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+)
+
+type AppIface interface {
+	ProcessRecapChannelWithOptions(rctx request.CTX, recapID, channelID, userID, agentID string, options model.RecapProcessingOptions) (*model.RecapChannelResult, *model.AppError)
+	Publish(message *model.WebSocketEvent)
+}
+
+func MakeWorker(jobServer *jobs.JobServer, storeInstance store.Store, appInstance AppIface) *jobs.SimpleWorker {
+	isEnabled := func(cfg *model.Config) bool {
+		return cfg.AIRecapsEnabled()
+	}
+
+	execute := func(logger mlog.LoggerIFace, job *model.Job) error {
+		defer jobServer.HandleJobPanic(logger, job)
+		return processRecapJob(logger, job, storeInstance, appInstance, func(progress int64) {
+			_ = jobServer.SetJobProgress(job, progress)
+		})
+	}
+
+	return jobs.NewSimpleWorker("Recap", jobServer, execute, isEnabled)
+}
+
+func processRecapJob(logger mlog.LoggerIFace, job *model.Job, storeInstance store.Store, appInstance AppIface, setProgress func(int64)) error {
+	recapID := job.Data["recap_id"]
+	userID := job.Data["user_id"]
+	channelIDs := strings.Split(job.Data["channel_ids"], ",")
+	agentID := job.Data["agent_id"]
+	options := model.RecapProcessingOptions{
+		TimePeriod:         job.Data["time_period"],
+		CustomInstructions: job.Data["custom_instructions"],
+	}
+
+	logger.Info("Starting recap job",
+		mlog.String("recap_id", recapID),
+		mlog.String("agent_id", agentID),
+		mlog.Int("channel_count", len(channelIDs)))
+
+	// Update status to processing
+	_ = storeInstance.Recap().UpdateRecapStatus(recapID, model.RecapStatusProcessing)
+	publishRecapUpdate(appInstance, recapID, userID)
+
+	totalMessages := 0
+	successfulChannels := []string{}
+	failedChannels := []string{}
+
+	for i, channelID := range channelIDs {
+		// Update progress
+		progress := int64((i * 100) / len(channelIDs))
+		if setProgress != nil {
+			setProgress(progress)
+		}
+
+		// Process the channel - use a context with the user's session so that
+		// session-dependent code (e.g. auto-translation supplements) works correctly.
+		rctx := request.EmptyContext(logger).WithSession(&model.Session{UserId: userID})
+		result, err := appInstance.ProcessRecapChannelWithOptions(rctx, recapID, channelID, userID, agentID, options)
+		if err != nil {
+			logger.Warn("Failed to process channel",
+				mlog.String("channel_id", channelID),
+				mlog.Err(err))
+			failedChannels = append(failedChannels, channelID)
+			continue
+		}
+
+		if !result.Success {
+			logger.Warn("Channel processing unsuccessful", mlog.String("channel_id", channelID))
+			failedChannels = append(failedChannels, channelID)
+			continue
+		}
+
+		totalMessages += result.MessageCount
+		successfulChannels = append(successfulChannels, channelID)
+	}
+
+	// Update recap with final data (title is already set by user in CreateRecap)
+	recap, err := storeInstance.Recap().GetRecap(recapID)
+	if err != nil || recap == nil {
+		logger.Warn("Recap no longer available while finalizing job",
+			mlog.String("recap_id", recapID),
+			mlog.Err(err))
+		return nil
+	}
+	recap.TotalMessageCount = totalMessages
+	recap.UpdateAt = model.GetMillis()
+
+	if len(failedChannels) > 0 && len(successfulChannels) == 0 {
+		recap.Status = model.RecapStatusFailed
+		_, err := storeInstance.Recap().UpdateRecap(recap)
+		if err != nil {
+			logger.Error("Failed to update recap", mlog.Err(err))
+			return fmt.Errorf("failed to update recap: %w", err)
+		}
+		publishRecapUpdate(appInstance, recapID, userID)
+		return fmt.Errorf("all channels failed to process")
+	} else if len(failedChannels) > 0 {
+		recap.Status = model.RecapStatusCompleted
+		_, err := storeInstance.Recap().UpdateRecap(recap)
+		if err != nil {
+			logger.Error("Failed to update recap", mlog.Err(err))
+			return fmt.Errorf("failed to update recap: %w", err)
+		}
+		publishRecapUpdate(appInstance, recapID, userID)
+		logger.Warn("Some channels failed", mlog.Int("failed_count", len(failedChannels)))
+		// Job succeeds with warning
+	} else {
+		recap.Status = model.RecapStatusCompleted
+		_, err := storeInstance.Recap().UpdateRecap(recap)
+		if err != nil {
+			logger.Error("Failed to update recap", mlog.Err(err))
+			return fmt.Errorf("failed to update recap: %w", err)
+		}
+		publishRecapUpdate(appInstance, recapID, userID)
+	}
+
+	logger.Info("Recap job completed",
+		mlog.String("recap_id", recapID),
+		mlog.Int("successful_channels", len(successfulChannels)),
+		mlog.Int("failed_channels", len(failedChannels)))
+
+	return nil
+}
+
+func publishRecapUpdate(appInstance AppIface, recapID, userID string) {
+	message := model.NewWebSocketEvent(model.WebsocketEventRecapUpdated, "", "", userID, nil, "")
+	message.Add("recap_id", recapID)
+	appInstance.Publish(message)
+}

server/channels/jobs/recap/worker_test.go

@@ -0,0 +1,167 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package recap
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/mlog"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/v8/channels/store/storetest/mocks"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+type MockAppIface struct {
+	mock.Mock
+}
+
+func (m *MockAppIface) ProcessRecapChannelWithOptions(rctx request.CTX, recapID, channelID, userID, agentID string, options model.RecapProcessingOptions) (*model.RecapChannelResult, *model.AppError) {
+	args := m.Called(rctx, recapID, channelID, userID, agentID, options)
+	if args.Get(0) == nil {
+		return nil, args.Get(1).(*model.AppError)
+	}
+	return args.Get(0).(*model.RecapChannelResult), nil
+}
+
+func (m *MockAppIface) Publish(message *model.WebSocketEvent) {
+	m.Called(message)
+}
+
+func TestProcessRecapJob(t *testing.T) {
+	logger := mlog.CreateConsoleTestLogger(t)
+	job := &model.Job{
+		Data: map[string]string{
+			"recap_id":    "recap1",
+			"user_id":     "user1",
+			"channel_ids": "channel1,channel2",
+			"agent_id":    "agent1",
+		},
+	}
+
+	t.Run("successful processing", func(t *testing.T) {
+		mockStore := &mocks.Store{}
+		mockRecapStore := &mocks.RecapStore{}
+		mockStore.On("Recap").Return(mockRecapStore)
+
+		mockApp := &MockAppIface{}
+
+		// Setup expectations
+		mockRecapStore.On("UpdateRecapStatus", "recap1", model.RecapStatusProcessing).Return(nil)
+		mockApp.On("Publish", mock.Anything).Return()
+
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel1", "user1", "agent1", model.RecapProcessingOptions{}).Return(&model.RecapChannelResult{
+			ChannelID:    "channel1",
+			Success:      true,
+			MessageCount: 10,
+		}, nil)
+
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel2", "user1", "agent1", model.RecapProcessingOptions{}).Return(&model.RecapChannelResult{
+			ChannelID:    "channel2",
+			Success:      true,
+			MessageCount: 5,
+		}, nil)
+
+		recap := &model.Recap{Id: "recap1"}
+		mockRecapStore.On("GetRecap", "recap1").Return(recap, nil)
+		mockRecapStore.On("UpdateRecap", mock.MatchedBy(func(r *model.Recap) bool {
+			return r.TotalMessageCount == 15 && r.Status == model.RecapStatusCompleted
+		})).Return(recap, nil)
+
+		err := processRecapJob(logger, job, mockStore, mockApp, nil)
+		require.NoError(t, err)
+	})
+
+	t.Run("partial failure", func(t *testing.T) {
+		mockStore := &mocks.Store{}
+		mockRecapStore := &mocks.RecapStore{}
+		mockStore.On("Recap").Return(mockRecapStore)
+
+		mockApp := &MockAppIface{}
+
+		mockRecapStore.On("UpdateRecapStatus", "recap1", model.RecapStatusProcessing).Return(nil)
+		mockApp.On("Publish", mock.Anything).Return()
+
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel1", "user1", "agent1", model.RecapProcessingOptions{}).Return(&model.RecapChannelResult{
+			ChannelID:    "channel1",
+			Success:      true,
+			MessageCount: 10,
+		}, nil)
+
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel2", "user1", "agent1", model.RecapProcessingOptions{}).Return(nil, model.NewAppError("fail", "fail", nil, "", 500))
+
+		recap := &model.Recap{Id: "recap1"}
+		mockRecapStore.On("GetRecap", "recap1").Return(recap, nil)
+		mockRecapStore.On("UpdateRecap", mock.MatchedBy(func(r *model.Recap) bool {
+			return r.TotalMessageCount == 10 && r.Status == model.RecapStatusCompleted
+		})).Return(recap, nil)
+
+		err := processRecapJob(logger, job, mockStore, mockApp, nil)
+		require.NoError(t, err)
+	})
+
+	t.Run("complete failure", func(t *testing.T) {
+		mockStore := &mocks.Store{}
+		mockRecapStore := &mocks.RecapStore{}
+		mockStore.On("Recap").Return(mockRecapStore)
+
+		mockApp := &MockAppIface{}
+
+		mockRecapStore.On("UpdateRecapStatus", "recap1", model.RecapStatusProcessing).Return(nil)
+		mockApp.On("Publish", mock.Anything).Return()
+
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel1", "user1", "agent1", model.RecapProcessingOptions{}).Return(nil, model.NewAppError("fail", "fail", nil, "", 500))
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel2", "user1", "agent1", model.RecapProcessingOptions{}).Return(nil, model.NewAppError("fail", "fail", nil, "", 500))
+
+		recap := &model.Recap{Id: "recap1"}
+		mockRecapStore.On("GetRecap", "recap1").Return(recap, nil)
+		mockRecapStore.On("UpdateRecap", mock.MatchedBy(func(r *model.Recap) bool {
+			return r.TotalMessageCount == 0 && r.Status == model.RecapStatusFailed
+		})).Return(recap, nil)
+
+		err := processRecapJob(logger, job, mockStore, mockApp, nil)
+		require.Error(t, err)
+		require.Equal(t, "all channels failed to process", err.Error())
+	})
+
+	t.Run("passes scheduled options to channel processing", func(t *testing.T) {
+		jobWithOptions := &model.Job{
+			Data: map[string]string{
+				"recap_id":            "recap1",
+				"user_id":             "user1",
+				"channel_ids":         "channel1",
+				"agent_id":            "agent1",
+				"time_period":         model.TimePeriodLastWeek,
+				"custom_instructions": "Focus on blockers",
+			},
+		}
+
+		mockStore := &mocks.Store{}
+		mockRecapStore := &mocks.RecapStore{}
+		mockStore.On("Recap").Return(mockRecapStore)
+
+		mockApp := &MockAppIface{}
+		mockRecapStore.On("UpdateRecapStatus", "recap1", model.RecapStatusProcessing).Return(nil)
+		mockApp.On("Publish", mock.Anything).Return()
+		mockApp.On("ProcessRecapChannelWithOptions", mock.Anything, "recap1", "channel1", "user1", "agent1", model.RecapProcessingOptions{
+			TimePeriod:         model.TimePeriodLastWeek,
+			CustomInstructions: "Focus on blockers",
+		}).Return(&model.RecapChannelResult{
+			ChannelID:    "channel1",
+			Success:      true,
+			MessageCount: 3,
+		}, nil)
+
+		recap := &model.Recap{Id: "recap1"}
+		mockRecapStore.On("GetRecap", "recap1").Return(recap, nil)
+		mockRecapStore.On("UpdateRecap", mock.MatchedBy(func(r *model.Recap) bool {
+			return r.TotalMessageCount == 3 && r.Status == model.RecapStatusCompleted
+		})).Return(recap, nil)
+
+		err := processRecapJob(logger, jobWithOptions, mockStore, mockApp, nil)
+		require.NoError(t, err)
+		mockApp.AssertExpectations(t)
+	})
+}