[MM-8497] Ability to set Do Not Disturb for a specified period of time (#17680)

* Revert "Revert "[MM-8497] Ability to set Do Not Disturb for a specified period of time (#16067)" (#17657)"

This reverts commit ff383990f8.

* add debug log for recurring function

* add feature flag for dnd timed status

* refactoring changes

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>

model/feature_flags.go

@@ -35,6 +35,9 @@ type FeatureFlags struct {
 
 	// Control support for custom data retention policies
 	CustomDataRetentionEnabled bool
+
+	// Enable timed dnd support for user status
+	TimedDND bool
 }
 
 func (f *FeatureFlags) SetDefaults() {
@@ -49,6 +52,7 @@ func (f *FeatureFlags) SetDefaults() {
 	f.PluginApps = ""
 	f.PluginFocalboard = ""
 	f.CustomDataRetentionEnabled = false
+	f.TimedDND = false
 }
 
 func (f *FeatureFlags) Plugins() map[string]string {

model/scheduled_task.go

@@ -11,42 +11,65 @@ import (
 type TaskFunc func()
 
 type ScheduledTask struct {
-	Name      string        `json:"name"`
-	Interval  time.Duration `json:"interval"`
-	Recurring bool          `json:"recurring"`
-	function  func()
-	cancel    chan struct{}
-	cancelled chan struct{}
+	Name                 string        `json:"name"`
+	Interval             time.Duration `json:"interval"`
+	Recurring            bool          `json:"recurring"`
+	function             func()
+	cancel               chan struct{}
+	cancelled            chan struct{}
+	fromNextIntervalTime bool
 }
 
 func CreateTask(name string, function TaskFunc, timeToExecution time.Duration) *ScheduledTask {
-	return createTask(name, function, timeToExecution, false)
+	return createTask(name, function, timeToExecution, false, false)
 }
 
 func CreateRecurringTask(name string, function TaskFunc, interval time.Duration) *ScheduledTask {
-	return createTask(name, function, interval, true)
+	return createTask(name, function, interval, true, false)
 }
 
-func createTask(name string, function TaskFunc, interval time.Duration, recurring bool) *ScheduledTask {
+func CreateRecurringTaskFromNextIntervalTime(name string, function TaskFunc, interval time.Duration) *ScheduledTask {
+	return createTask(name, function, interval, true, true)
+}
+
+func createTask(name string, function TaskFunc, interval time.Duration, recurring bool, fromNextIntervalTime bool) *ScheduledTask {
 	task := &ScheduledTask{
-		Name:      name,
-		Interval:  interval,
-		Recurring: recurring,
-		function:  function,
-		cancel:    make(chan struct{}),
-		cancelled: make(chan struct{}),
+		Name:                 name,
+		Interval:             interval,
+		Recurring:            recurring,
+		function:             function,
+		cancel:               make(chan struct{}),
+		cancelled:            make(chan struct{}),
+		fromNextIntervalTime: fromNextIntervalTime,
 	}
 
 	go func() {
 		defer close(task.cancelled)
 
-		ticker := time.NewTicker(interval)
+		var firstTick <-chan time.Time
+		var ticker *time.Ticker
+
+		if task.fromNextIntervalTime {
+			currTime := time.Now()
+			first := currTime.Truncate(interval)
+			if first.Before(currTime) {
+				first = first.Add(interval)
+			}
+			firstTick = time.After(time.Until(first))
+			ticker = &time.Ticker{C: nil}
+		} else {
+			firstTick = nil
+			ticker = time.NewTicker(interval)
+		}
 		defer func() {
 			ticker.Stop()
 		}()
 
 		for {
 			select {
+			case <-firstTick:
+				ticker = time.NewTicker(interval)
+				function()
 			case <-ticker.C:
 				function()
 			case <-task.cancel:

model/scheduled_task_test.go

@@ -4,6 +4,7 @@
 package model
 
 import (
+	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -73,3 +74,35 @@ func TestCancelTask(t *testing.T) {
 	time.Sleep(TASK_TIME + time.Second)
 	assert.EqualValues(t, 0, atomic.LoadInt32(executionCount))
 }
+
+func TestCreateRecurringTaskFromNextIntervalTime(t *testing.T) {
+	TASK_NAME := "Test Recurring Task starting from next interval time"
+	TASK_TIME := time.Second * 2
+
+	var executionTime time.Time
+	var mu sync.Mutex
+	testFunc := func() {
+		mu.Lock()
+		executionTime = time.Now()
+		mu.Unlock()
+	}
+
+	task := CreateRecurringTaskFromNextIntervalTime(TASK_NAME, testFunc, TASK_TIME)
+	defer task.Cancel()
+
+	time.Sleep(TASK_TIME)
+	mu.Lock()
+	expectedSeconds := executionTime.Second()
+	mu.Unlock()
+	assert.EqualValues(t, 0, expectedSeconds%2)
+
+	time.Sleep(TASK_TIME)
+	mu.Lock()
+	expectedSeconds = executionTime.Second()
+	mu.Unlock()
+	assert.EqualValues(t, 0, expectedSeconds%2)
+
+	assert.Equal(t, TASK_NAME, task.Name)
+	assert.Equal(t, TASK_TIME, task.Interval)
+	assert.True(t, task.Recurring)
+}

model/status.go

@@ -25,6 +25,8 @@ type Status struct {
 	Manual         bool   `json:"manual"`
 	LastActivityAt int64  `json:"last_activity_at"`
 	ActiveChannel  string `json:"active_channel,omitempty" db:"-"`
+	DNDEndTime     int64  `json:"dnd_end_time"`
+	PrevStatus     string `json:"-"`
 }
 
 func (o *Status) ToJson() string {

model/status_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestStatus(t *testing.T) {
-	status := Status{NewId(), STATUS_ONLINE, true, 0, "123"}
+	status := Status{NewId(), STATUS_ONLINE, true, 0, "123", 0, ""}
 	json := status.ToJson()
 	status2 := StatusFromJson(strings.NewReader(json))
 
@@ -29,7 +29,7 @@ func TestStatus(t *testing.T) {
 }
 
 func TestStatusListToJson(t *testing.T) {
-	statuses := []*Status{{NewId(), STATUS_ONLINE, true, 0, "123"}, {NewId(), STATUS_OFFLINE, true, 0, ""}}
+	statuses := []*Status{{NewId(), STATUS_ONLINE, true, 0, "123", 0, ""}, {NewId(), STATUS_OFFLINE, true, 0, "", 0, ""}}
 	jsonStatuses := StatusListToJson(statuses)
 
 	var dat []map[string]interface{}