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

server/channels/jobs/resend_invitation_email/worker.go

@@ -0,0 +1,252 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+package resend_invitation_email
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"strconv"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/configservice"
+	"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"
+)
+
+const FourtyEightHoursInMillis int64 = 172800000
+
+type AppIface interface {
+	configservice.ConfigService
+	GetUserByEmail(email string) (*model.User, *model.AppError)
+	GetTeamMembersByIds(teamID string, userIDs []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError)
+	InviteNewUsersToTeamGracefully(rctx request.CTX, memberInvite *model.MemberInvite, teamID, senderId string, reminderInterval string) ([]*model.EmailInviteWithError, *model.AppError)
+}
+
+type ResendInvitationEmailWorker struct {
+	name      string
+	stop      chan bool
+	stopped   chan bool
+	jobs      chan model.Job
+	jobServer *jobs.JobServer
+	logger    mlog.LoggerIFace
+	app       AppIface
+	store     store.Store
+}
+
+func MakeWorker(jobServer *jobs.JobServer, app AppIface, store store.Store) *ResendInvitationEmailWorker {
+	const workerName = "ResendInvitationEmail"
+	worker := ResendInvitationEmailWorker{
+		name:      workerName,
+		stop:      make(chan bool, 1),
+		stopped:   make(chan bool, 1),
+		jobs:      make(chan model.Job),
+		jobServer: jobServer,
+		logger:    jobServer.Logger().With(mlog.String("worker_name", workerName)),
+		app:       app,
+		store:     store,
+	}
+	return &worker
+}
+
+func (rseworker *ResendInvitationEmailWorker) Run() {
+	rseworker.logger.Debug("Worker started")
+
+	defer func() {
+		rseworker.logger.Debug("Worker finished")
+		rseworker.stopped <- true
+	}()
+
+	for {
+		select {
+		case <-rseworker.stop:
+			rseworker.logger.Debug("Worker received stop signal")
+			return
+		case job := <-rseworker.jobs:
+			rseworker.DoJob(&job)
+		}
+	}
+}
+
+func (rseworker *ResendInvitationEmailWorker) IsEnabled(cfg *model.Config) bool {
+	return *cfg.ServiceSettings.EnableEmailInvitations
+}
+
+func (rseworker *ResendInvitationEmailWorker) Stop() {
+	rseworker.logger.Debug("Worker stopping")
+	rseworker.stop <- true
+	<-rseworker.stopped
+}
+
+func (rseworker *ResendInvitationEmailWorker) JobChannel() chan<- model.Job {
+	return rseworker.jobs
+}
+
+func (rseworker *ResendInvitationEmailWorker) DoJob(job *model.Job) {
+	logger := rseworker.logger.With(jobs.JobLoggerFields(job)...)
+	logger.Debug("Worker: Received a new candidate job.")
+	defer rseworker.jobServer.HandleJobPanic(logger, job)
+
+	elapsedTimeSinceSchedule, DurationInMillis := rseworker.GetDurations(job)
+	if elapsedTimeSinceSchedule > DurationInMillis {
+		if appErr := rseworker.ResendEmails(logger, job, "48"); appErr != nil {
+			rseworker.setJobError(logger, job, appErr)
+			return
+		}
+		rseworker.TearDown(logger, job)
+	}
+}
+
+func (rseworker *ResendInvitationEmailWorker) setJobSuccess(logger mlog.LoggerIFace, job *model.Job) {
+	if err := rseworker.jobServer.SetJobSuccess(job); err != nil {
+		logger.Error("Worker: Failed to set success for job", mlog.Err(err))
+		rseworker.setJobError(logger, job, err)
+	}
+}
+
+func (rseworker *ResendInvitationEmailWorker) setJobError(logger mlog.LoggerIFace, job *model.Job, appError *model.AppError) {
+	if err := rseworker.jobServer.SetJobError(job, appError); err != nil {
+		logger.Error("Worker: Failed to set job error", mlog.Err(err))
+	}
+}
+
+func (rseworker *ResendInvitationEmailWorker) cleanEmailData(emailStringData string) ([]string, error) {
+	// emailStringData looks like this ["user1@gmail.com","user2@gmail.com"]
+	emails := []string{}
+	err := json.Unmarshal([]byte(emailStringData), &emails)
+	if err != nil {
+		return nil, err
+	}
+
+	return emails, nil
+}
+
+func (rseworker *ResendInvitationEmailWorker) cleanChannelsData(channelStringData string) ([]string, error) {
+	// channelStringData looks like this ["uuuiiiiidddd","uuuiiiiidddd"]
+	channels := []string{}
+	err := json.Unmarshal([]byte(channelStringData), &channels)
+	if err != nil {
+		return nil, err
+	}
+
+	return channels, nil
+}
+
+func (rseworker *ResendInvitationEmailWorker) removeAlreadyJoined(teamID string, emailList []string) []string {
+	var notJoinedYet []string
+	for _, email := range emailList {
+		// check if the user with this email is on the system already
+		user, appErr := rseworker.app.GetUserByEmail(email)
+		if appErr != nil {
+			notJoinedYet = append(notJoinedYet, email)
+			continue
+		}
+		// now we check if they are part of the team already
+		userID := []string{user.Id}
+		members, appErr := rseworker.app.GetTeamMembersByIds(teamID, userID, nil)
+		if len(members) == 0 || appErr != nil {
+			notJoinedYet = append(notJoinedYet, email)
+		}
+	}
+
+	return notJoinedYet
+}
+
+func (rseworker *ResendInvitationEmailWorker) GetDurations(job *model.Job) (int64, int64) {
+	scheduledAt, _ := strconv.ParseInt(job.Data["scheduledAt"], 10, 64)
+	now := model.GetMillis()
+
+	elapsedTimeSinceSchedule := now - scheduledAt
+
+	duration := os.Getenv("MM_RESEND_INVITATION_EMAIL_JOB_DURATION")
+	DurationInMillis, parseError := strconv.ParseInt(duration, 10, 64)
+	if parseError != nil {
+		// default to 48 hours
+		DurationInMillis = FourtyEightHoursInMillis
+	}
+
+	return elapsedTimeSinceSchedule, DurationInMillis
+}
+
+func (rseworker *ResendInvitationEmailWorker) TearDown(logger mlog.LoggerIFace, job *model.Job) {
+	if _, err := rseworker.store.System().PermanentDeleteByName(job.Id); err != nil {
+		logger.Error("Worker: Failed to tear down data", mlog.Err(err))
+	}
+
+	rseworker.setJobSuccess(logger, job)
+}
+
+func (rseworker *ResendInvitationEmailWorker) ResendEmails(logger mlog.LoggerIFace, job *model.Job, interval string) *model.AppError {
+	rctx := request.EmptyContext(logger)
+
+	teamID := job.Data["teamID"]
+	emailListData := job.Data["emailList"]
+
+	emailList, err := rseworker.cleanEmailData(emailListData)
+	if err != nil {
+		appErr := model.NewAppError("worker: "+rseworker.name, "job_id: "+job.Id, nil, "", http.StatusInternalServerError).Wrap(err)
+		logger.Error("Worker: Failed to clean emails string data", mlog.Err(appErr))
+		return appErr
+	}
+
+	var channelList []string
+	if channelListData := job.Data["channelList"]; channelListData != "" {
+		channelList, err = rseworker.cleanChannelsData(channelListData)
+		if err != nil {
+			appErr := model.NewAppError("worker: "+rseworker.name, "job_id: "+job.Id, nil, "", http.StatusInternalServerError).Wrap(err)
+			logger.Error("Worker: Failed to clean channel string data", mlog.Err(appErr))
+			return appErr
+		}
+	}
+
+	emailList = rseworker.removeAlreadyJoined(teamID, emailList)
+	if len(emailList) == 0 {
+		return nil
+	}
+
+	memberInvite := model.MemberInvite{
+		Emails: emailList,
+	}
+
+	if len(channelList) > 0 {
+		memberInvite.ChannelIds = channelList
+	}
+
+	if profileListData := job.Data["profilesList"]; profileListData != "" {
+		var profiles []*model.MemberInviteProfile
+		if err := json.Unmarshal([]byte(profileListData), &profiles); err != nil {
+			appErr := model.NewAppError("worker: "+rseworker.name, "job_id: "+job.Id, nil, "", http.StatusInternalServerError).Wrap(err)
+			logger.Error("Worker: Failed to clean profiles string data", mlog.Err(appErr))
+			return appErr
+		}
+
+		remainingEmails := make(map[string]struct{}, len(emailList))
+		for _, email := range emailList {
+			remainingEmails[model.NormalizeEmail(email)] = struct{}{}
+		}
+		for _, profile := range profiles {
+			if profile == nil {
+				memberInvite.Profiles = append(memberInvite.Profiles, profile)
+				continue
+			}
+			if _, ok := remainingEmails[model.NormalizeEmail(profile.Email)]; ok {
+				memberInvite.Profiles = append(memberInvite.Profiles, profile)
+			}
+		}
+	}
+
+	invitesWithErrors, appErr := rseworker.app.InviteNewUsersToTeamGracefully(rctx, &memberInvite, teamID, job.Data["senderID"], interval)
+	if appErr != nil {
+		logger.Error("Worker: Failed to send emails", mlog.Err(appErr))
+		return appErr
+	}
+	for _, invite := range invitesWithErrors {
+		if invite != nil && invite.Error != nil {
+			logger.Error("Worker: Failed to resend invitation", mlog.String("email", invite.Email), mlog.Err(invite.Error))
+			return invite.Error
+		}
+	}
+	return nil
+}

server/channels/jobs/resend_invitation_email/worker_test.go

@@ -0,0 +1,95 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package resend_invitation_email
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/mlog"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+)
+
+type fakeResendApp struct {
+	invitedWith *model.MemberInvite
+	joinedEmail string
+}
+
+func (a *fakeResendApp) Config() *model.Config                                 { return &model.Config{} }
+func (a *fakeResendApp) AddConfigListener(func(old, cur *model.Config)) string { return "" }
+func (a *fakeResendApp) RemoveConfigListener(string)                           {}
+func (a *fakeResendApp) GetUserByEmail(email string) (*model.User, *model.AppError) {
+	if email == a.joinedEmail {
+		return &model.User{Id: email}, nil
+	}
+	return nil, model.NewAppError("GetUserByEmail", "app.user.missing_account.const", nil, "", http.StatusNotFound)
+}
+func (a *fakeResendApp) GetTeamMembersByIds(teamID string, userIDs []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
+	if len(userIDs) == 1 && userIDs[0] == a.joinedEmail {
+		return []*model.TeamMember{{UserId: a.joinedEmail}}, nil
+	}
+	return nil, nil
+}
+func (a *fakeResendApp) InviteNewUsersToTeamGracefully(rctx request.CTX, memberInvite *model.MemberInvite, teamID, senderID, reminderInterval string) ([]*model.EmailInviteWithError, *model.AppError) {
+	a.invitedWith = memberInvite
+	return nil, nil
+}
+
+func newTestWorker(t *testing.T, app AppIface) *ResendInvitationEmailWorker {
+	t.Helper()
+	return &ResendInvitationEmailWorker{
+		name:   "ResendInvitationEmail",
+		logger: mlog.CreateConsoleTestLogger(t),
+		app:    app,
+	}
+}
+
+func TestResendEmailsCarriesProfilesForPendingUsers(t *testing.T) {
+	profiles := []*model.MemberInviteProfile{
+		{Email: "joined@example.com", Username: "joined.user"},
+		{Email: "waiting@example.com", Username: "waiting.user", FirstName: "Waiting", LastName: "User"},
+	}
+	profilesJSON, err := json.Marshal(profiles)
+	require.NoError(t, err)
+
+	app := &fakeResendApp{joinedEmail: "joined@example.com"}
+	worker := newTestWorker(t, app)
+	appErr := worker.ResendEmails(worker.logger, &model.Job{
+		Id: model.NewId(),
+		Data: map[string]string{
+			"emailList":    model.ArrayToJSON([]string{"joined@example.com", "waiting@example.com"}),
+			"teamID":       model.NewId(),
+			"senderID":     model.NewId(),
+			"profilesList": string(profilesJSON),
+		},
+	}, "48")
+
+	require.Nil(t, appErr)
+	require.Equal(t, []string{"waiting@example.com"}, app.invitedWith.Emails)
+	require.Equal(t, profiles[1:], app.invitedWith.Profiles)
+}
+
+func TestResendEmailsRejectsMalformedJobData(t *testing.T) {
+	for _, key := range []string{"emailList", "channelList", "profilesList"} {
+		t.Run(key, func(t *testing.T) {
+			app := &fakeResendApp{}
+			worker := newTestWorker(t, app)
+			data := map[string]string{
+				"emailList": model.ArrayToJSON([]string{"user@example.com"}),
+				"teamID":    model.NewId(),
+				"senderID":  model.NewId(),
+				key:         "not-json",
+			}
+
+			appErr := worker.ResendEmails(worker.logger, &model.Job{Id: model.NewId(), Data: data}, "48")
+
+			require.NotNil(t, appErr)
+			require.Nil(t, app.invitedWith)
+		})
+	}
+}