MM-47750: Adds PostAcknowledgements table and apis (#21689)

* MM-46410: adds urgency on mention counts

We have introduced priority for posts in
https://github.com/mattermost/mattermost-webapp/pull/10951.
We do need to color the mention badges in the webapp with a prominent
color when a mention is posted in an urgent message.
A thread has urgent mentions if the root post is marked as urgent, and
the replies contain mentions to the user viewing the thread.

This PR adds two columns, urgentmentioncount, and isurgent, in
channelmembers, and threads tables respectively.
Furthermore when asking for team/thread mention counts, we also return
urgent mention counts for the user.

* Fixes method in tests

* empty commit

* Fixes method call

* Fixes single thread response is_urgent

* Fixes errors

* Fixes mysql migration and adds graphql schema

* Fixes tests

* Refactors IsUrgent and Adds PostsPriority table

Changes:
- removes is_urgent from the threads table
- adds a new table to hold posts priorities
- refactors priority out of the props and into the new table

* Fixes

* Adds translation strings

* Fixes migrations and tests

* Fixes tests

* empty

* Adds Priority to Copy

* empty

* Fixes priority not saved when boards is enabled

We are nilifying Metadata when post.ForPlugin(), which didn't save Priority
for a post when Boards was enabled.
This commit copies metadata again to the post, so metadata are
reinstated.

* Fixes tests

* Adding store tests and fixes syntax error

* Uses threads.ThreadTeamId

* Fixes error

* Adds UrgentMentionCount in graphql api test

* Fetches post priority in batches

* Addresses review comments

* Restore only priority on create post

* Fixes tests

* Nits

* Some refactoring

* Fixes get thread options when post priority enabled

* Adds missing translation

* Use the constant instead of "urgent" string

* Renames urgent constant

* MM-47750: Adds PostAcknowledgements table and apis

- Adds post acknowledgement api/app/store methods to be able to save and
delete post acknowledgements by users.
- Adds wesbsocket events for acknowledgement created/deleted
- Returns post acknowledgements in the post's metadata

* Empty

* Fixes incorrect urgent count when marking a post as unread

* Adds license

* Fixes ACK api, and adds tests

* Fixes vet

* Fixes tests

* Addresses review comments

* Remove unnecessary lines

* Adds config option and changes return of delete ack

* Empty

* Empty

* Enable config by default

* Fixes intl

* Fixes test after setting config default true

* Changes endpoints to PostForUser

* Avoids replica lag

* Fixes error in merge

* Fixes RetryLayer tests due to merge

* Empty

* Empty

* Empty

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

store/opentracinglayer/opentracinglayer.go

@@ -37,6 +37,7 @@ type OpenTracingLayer struct {
 	OAuthStore                store.OAuthStore
 	PluginStore               store.PluginStore
 	PostStore                 store.PostStore
+	PostAcknowledgementStore  store.PostAcknowledgementStore
 	PostPriorityStore         store.PostPriorityStore
 	PreferenceStore           store.PreferenceStore
 	ProductNoticesStore       store.ProductNoticesStore
@@ -132,6 +133,10 @@ func (s *OpenTracingLayer) Post() store.PostStore {
 	return s.PostStore
 }
 
+func (s *OpenTracingLayer) PostAcknowledgement() store.PostAcknowledgementStore {
+	return s.PostAcknowledgementStore
+}
+
 func (s *OpenTracingLayer) PostPriority() store.PostPriorityStore {
 	return s.PostPriorityStore
 }
@@ -306,6 +311,11 @@ type OpenTracingLayerPostStore struct {
 	Root *OpenTracingLayer
 }
 
+type OpenTracingLayerPostAcknowledgementStore struct {
+	store.PostAcknowledgementStore
+	Root *OpenTracingLayer
+}
+
 type OpenTracingLayerPostPriorityStore struct {
 	store.PostPriorityStore
 	Root *OpenTracingLayer
@@ -6544,6 +6554,96 @@ func (s *OpenTracingLayerPostStore) Update(newPost *model.Post, oldPost *model.P
 	return result, err
 }
 
+func (s *OpenTracingLayerPostAcknowledgementStore) Delete(acknowledgement *model.PostAcknowledgement) error {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostAcknowledgementStore.Delete")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	err := s.PostAcknowledgementStore.Delete(acknowledgement)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return err
+}
+
+func (s *OpenTracingLayerPostAcknowledgementStore) Get(postID string, userID string) (*model.PostAcknowledgement, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostAcknowledgementStore.Get")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.PostAcknowledgementStore.Get(postID, userID)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
+func (s *OpenTracingLayerPostAcknowledgementStore) GetForPost(postID string) ([]*model.PostAcknowledgement, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostAcknowledgementStore.GetForPost")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.PostAcknowledgementStore.GetForPost(postID)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
+func (s *OpenTracingLayerPostAcknowledgementStore) GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostAcknowledgementStore.GetForPosts")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.PostAcknowledgementStore.GetForPosts(postIds)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
+func (s *OpenTracingLayerPostAcknowledgementStore) Save(postID string, userID string, acknowledgedAt int64) (*model.PostAcknowledgement, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostAcknowledgementStore.Save")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.PostAcknowledgementStore.Save(postID, userID, acknowledgedAt)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
 func (s *OpenTracingLayerPostPriorityStore) GetForPost(postId string) (*model.PostPriority, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostPriorityStore.GetForPost")
@@ -12591,6 +12691,7 @@ func New(childStore store.Store, ctx context.Context) *OpenTracingLayer {
 	newStore.OAuthStore = &OpenTracingLayerOAuthStore{OAuthStore: childStore.OAuth(), Root: &newStore}
 	newStore.PluginStore = &OpenTracingLayerPluginStore{PluginStore: childStore.Plugin(), Root: &newStore}
 	newStore.PostStore = &OpenTracingLayerPostStore{PostStore: childStore.Post(), Root: &newStore}
+	newStore.PostAcknowledgementStore = &OpenTracingLayerPostAcknowledgementStore{PostAcknowledgementStore: childStore.PostAcknowledgement(), Root: &newStore}
 	newStore.PostPriorityStore = &OpenTracingLayerPostPriorityStore{PostPriorityStore: childStore.PostPriority(), Root: &newStore}
 	newStore.PreferenceStore = &OpenTracingLayerPreferenceStore{PreferenceStore: childStore.Preference(), Root: &newStore}
 	newStore.ProductNoticesStore = &OpenTracingLayerProductNoticesStore{ProductNoticesStore: childStore.ProductNotices(), Root: &newStore}

store/retrylayer/retrylayer.go

@@ -40,6 +40,7 @@ type RetryLayer struct {
 	OAuthStore                store.OAuthStore
 	PluginStore               store.PluginStore
 	PostStore                 store.PostStore
+	PostAcknowledgementStore  store.PostAcknowledgementStore
 	PostPriorityStore         store.PostPriorityStore
 	PreferenceStore           store.PreferenceStore
 	ProductNoticesStore       store.ProductNoticesStore
@@ -135,6 +136,10 @@ func (s *RetryLayer) Post() store.PostStore {
 	return s.PostStore
 }
 
+func (s *RetryLayer) PostAcknowledgement() store.PostAcknowledgementStore {
+	return s.PostAcknowledgementStore
+}
+
 func (s *RetryLayer) PostPriority() store.PostPriorityStore {
 	return s.PostPriorityStore
 }
@@ -309,6 +314,11 @@ type RetryLayerPostStore struct {
 	Root *RetryLayer
 }
 
+type RetryLayerPostAcknowledgementStore struct {
+	store.PostAcknowledgementStore
+	Root *RetryLayer
+}
+
 type RetryLayerPostPriorityStore struct {
 	store.PostPriorityStore
 	Root *RetryLayer
@@ -7420,6 +7430,111 @@ func (s *RetryLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (
 
 }
 
+func (s *RetryLayerPostAcknowledgementStore) Delete(acknowledgement *model.PostAcknowledgement) error {
+
+	tries := 0
+	for {
+		err := s.PostAcknowledgementStore.Delete(acknowledgement)
+		if err == nil {
+			return nil
+		}
+		if !isRepeatableError(err) {
+			return err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
+func (s *RetryLayerPostAcknowledgementStore) Get(postID string, userID string) (*model.PostAcknowledgement, error) {
+
+	tries := 0
+	for {
+		result, err := s.PostAcknowledgementStore.Get(postID, userID)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
+func (s *RetryLayerPostAcknowledgementStore) GetForPost(postID string) ([]*model.PostAcknowledgement, error) {
+
+	tries := 0
+	for {
+		result, err := s.PostAcknowledgementStore.GetForPost(postID)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
+func (s *RetryLayerPostAcknowledgementStore) GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error) {
+
+	tries := 0
+	for {
+		result, err := s.PostAcknowledgementStore.GetForPosts(postIds)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
+func (s *RetryLayerPostAcknowledgementStore) Save(postID string, userID string, acknowledgedAt int64) (*model.PostAcknowledgement, error) {
+
+	tries := 0
+	for {
+		result, err := s.PostAcknowledgementStore.Save(postID, userID, acknowledgedAt)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
 func (s *RetryLayerPostPriorityStore) GetForPost(postId string) (*model.PostPriority, error) {
 
 	tries := 0
@@ -14355,6 +14470,7 @@ func New(childStore store.Store) *RetryLayer {
 	newStore.OAuthStore = &RetryLayerOAuthStore{OAuthStore: childStore.OAuth(), Root: &newStore}
 	newStore.PluginStore = &RetryLayerPluginStore{PluginStore: childStore.Plugin(), Root: &newStore}
 	newStore.PostStore = &RetryLayerPostStore{PostStore: childStore.Post(), Root: &newStore}
+	newStore.PostAcknowledgementStore = &RetryLayerPostAcknowledgementStore{PostAcknowledgementStore: childStore.PostAcknowledgement(), Root: &newStore}
 	newStore.PostPriorityStore = &RetryLayerPostPriorityStore{PostPriorityStore: childStore.PostPriority(), Root: &newStore}
 	newStore.PreferenceStore = &RetryLayerPreferenceStore{PreferenceStore: childStore.Preference(), Root: &newStore}
 	newStore.ProductNoticesStore = &RetryLayerProductNoticesStore{ProductNoticesStore: childStore.ProductNotices(), Root: &newStore}

store/retrylayer/retrylayer_test.go

@@ -55,6 +55,7 @@ func genStore() *mocks.Store {
 	mock.On("Webhook").Return(&mocks.WebhookStore{})
 	mock.On("NotifyAdmin").Return(&mocks.NotifyAdminStore{})
 	mock.On("PostPriority").Return(&mocks.PostPriorityStore{})
+	mock.On("PostAcknowledgement").Return(&mocks.PostAcknowledgementStore{})
 	return mock
 }
 

store/sqlstore/post_acknowledgements_store.go

@@ -0,0 +1,144 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sqlstore
+
+import (
+	"database/sql"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/store"
+	sq "github.com/mattermost/squirrel"
+	"github.com/pkg/errors"
+)
+
+type SqlPostAcknowledgementStore struct {
+	*SqlStore
+}
+
+func newSqlPostAcknowledgementStore(sqlStore *SqlStore) store.PostAcknowledgementStore {
+	return &SqlPostAcknowledgementStore{sqlStore}
+}
+
+func (s *SqlPostAcknowledgementStore) Get(postID, userID string) (*model.PostAcknowledgement, error) {
+	query := s.getQueryBuilder().
+		Select("PostId", "UserId", "AcknowledgedAt").
+		From("PostAcknowledgements").
+		Where(sq.And{
+			sq.Eq{"PostId": postID},
+			sq.Eq{"UserId": userID},
+			sq.NotEq{"AcknowledgedAt": 0},
+		})
+
+	var acknowledgement model.PostAcknowledgement
+	err := s.GetReplicaX().GetBuilder(&acknowledgement, query)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, store.NewErrNotFound("PostAcknowledgement", postID)
+		}
+
+		return nil, err
+	}
+
+	return &acknowledgement, nil
+}
+
+func (s *SqlPostAcknowledgementStore) Save(postID, userID string, acknowledgedAt int64) (*model.PostAcknowledgement, error) {
+	if acknowledgedAt == 0 {
+		acknowledgedAt = model.GetMillis()
+	}
+
+	acknowledgement := &model.PostAcknowledgement{
+		UserId:         userID,
+		PostId:         postID,
+		AcknowledgedAt: acknowledgedAt,
+	}
+
+	if err := acknowledgement.IsValid(); err != nil {
+		return nil, err
+	}
+
+	query := s.getQueryBuilder().
+		Insert("PostAcknowledgements").
+		Columns("PostId", "UserId", "AcknowledgedAt").
+		Values(acknowledgement.PostId, acknowledgement.UserId, acknowledgement.AcknowledgedAt)
+
+	if s.DriverName() == model.DatabaseDriverMysql {
+		query = query.SuffixExpr(sq.Expr("ON DUPLICATE KEY UPDATE AcknowledgedAt = ?", acknowledgement.AcknowledgedAt))
+	} else {
+		query = query.SuffixExpr(sq.Expr("ON CONFLICT (postid, userid) DO UPDATE SET AcknowledgedAt = ?", acknowledgement.AcknowledgedAt))
+	}
+
+	_, err := s.GetMasterX().ExecBuilder(query)
+	if err != nil {
+		return nil, err
+	}
+
+	return acknowledgement, nil
+}
+
+func (s *SqlPostAcknowledgementStore) Delete(ack *model.PostAcknowledgement) error {
+	query := s.getQueryBuilder().
+		Update("PostAcknowledgements").
+		Set("AcknowledgedAt", 0).
+		Where(sq.And{
+			sq.Eq{"PostId": ack.PostId},
+			sq.Eq{"UserId": ack.UserId},
+		})
+
+	_, err := s.GetMasterX().ExecBuilder(query)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *SqlPostAcknowledgementStore) GetForPost(postID string) ([]*model.PostAcknowledgement, error) {
+	var acknowledgements []*model.PostAcknowledgement
+
+	query := s.getQueryBuilder().
+		Select("PostId", "UserId", "AcknowledgedAt").
+		From("PostAcknowledgements").
+		Where(sq.And{
+			sq.NotEq{"AcknowledgedAt": 0},
+			sq.Eq{"PostId": postID},
+		})
+
+	err := s.GetReplicaX().SelectBuilder(&acknowledgements, query)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get PostAcknowledgements for postID=%s", postID)
+	}
+
+	return acknowledgements, nil
+}
+
+func (s *SqlPostAcknowledgementStore) GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error) {
+	var acknowledgements []*model.PostAcknowledgement
+
+	perPage := 200
+	for i := 0; i < len(postIds); i += perPage {
+		j := i + perPage
+		if len(postIds) < j {
+			j = len(postIds)
+		}
+
+		query := s.getQueryBuilder().
+			Select("PostId", "UserId", "AcknowledgedAt").
+			From("PostAcknowledgements").
+			Where(sq.And{
+				sq.Eq{"PostId": postIds[i:j]},
+				sq.NotEq{"AcknowledgedAt": 0},
+			})
+
+		var acknowledgementsBatch []*model.PostAcknowledgement
+		err := s.GetReplicaX().SelectBuilder(&acknowledgementsBatch, query)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to get PostAcknowledgements for post list")
+		}
+
+		acknowledgements = append(acknowledgements, acknowledgementsBatch...)
+	}
+
+	return acknowledgements, nil
+}

store/sqlstore/post_acknowledgements_store_test.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sqlstore
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost-server/v6/store/storetest"
+)
+
+func TestPostAcknowledgementsStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestPostAcknowledgementsStore)
+}

store/sqlstore/store.go

@@ -110,6 +110,7 @@ type SqlStoreStores struct {
 	sharedchannel        store.SharedChannelStore
 	notifyAdmin          store.NotifyAdminStore
 	postPriority         store.PostPriorityStore
+	postAcknowledgement  store.PostAcknowledgementStore
 }
 
 type SqlStore struct {
@@ -216,6 +217,7 @@ func New(settings model.SqlSettings, metrics einterfaces.MetricsInterface) *SqlS
 	store.stores.productNotices = newSqlProductNoticesStore(store)
 	store.stores.notifyAdmin = newSqlNotifyAdminStore(store)
 	store.stores.postPriority = newSqlPostPriorityStore(store)
+	store.stores.postAcknowledgement = newSqlPostAcknowledgementStore(store)
 
 	store.stores.preference.(*SqlPreferenceStore).deleteUnusedFeatures()
 
@@ -961,6 +963,10 @@ func (ss *SqlStore) PostPriority() store.PostPriorityStore {
 	return ss.stores.postPriority
 }
 
+func (ss *SqlStore) PostAcknowledgement() store.PostAcknowledgementStore {
+	return ss.stores.postAcknowledgement
+}
+
 func (ss *SqlStore) DropAllTables() {
 	if ss.DriverName() == model.DatabaseDriverPostgres {
 		ss.masterX.Exec(`DO

store/store.go

@@ -85,6 +85,7 @@ type Store interface {
 	Context() context.Context
 	NotifyAdmin() NotifyAdminStore
 	PostPriority() PostPriorityStore
+	PostAcknowledgement() PostAcknowledgementStore
 }
 
 type RetentionPolicyStore interface {
@@ -978,6 +979,14 @@ type PostPriorityStore interface {
 	GetForPosts(ids []string) ([]*model.PostPriority, error)
 }
 
+type PostAcknowledgementStore interface {
+	Get(postID, userID string) (*model.PostAcknowledgement, error)
+	GetForPost(postID string) ([]*model.PostAcknowledgement, error)
+	GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error)
+	Save(postID, userID string, acknowledgedAt int64) (*model.PostAcknowledgement, error)
+	Delete(acknowledgement *model.PostAcknowledgement) error
+}
+
 // ChannelSearchOpts contains options for searching channels.
 //
 // NotAssociatedToGroup will exclude channels that have associated, active GroupChannels records.

store/storetest/mocks/PostAcknowledgementStore.go

@@ -0,0 +1,121 @@
+// Code generated by mockery v2.10.4. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost-server/v6/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// PostAcknowledgementStore is an autogenerated mock type for the PostAcknowledgementStore type
+type PostAcknowledgementStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: acknowledgement
+func (_m *PostAcknowledgementStore) Delete(acknowledgement *model.PostAcknowledgement) error {
+	ret := _m.Called(acknowledgement)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.PostAcknowledgement) error); ok {
+		r0 = rf(acknowledgement)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: postID, userID
+func (_m *PostAcknowledgementStore) Get(postID string, userID string) (*model.PostAcknowledgement, error) {
+	ret := _m.Called(postID, userID)
+
+	var r0 *model.PostAcknowledgement
+	if rf, ok := ret.Get(0).(func(string, string) *model.PostAcknowledgement); ok {
+		r0 = rf(postID, userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostAcknowledgement)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(postID, userID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPost provides a mock function with given fields: postID
+func (_m *PostAcknowledgementStore) GetForPost(postID string) ([]*model.PostAcknowledgement, error) {
+	ret := _m.Called(postID)
+
+	var r0 []*model.PostAcknowledgement
+	if rf, ok := ret.Get(0).(func(string) []*model.PostAcknowledgement); ok {
+		r0 = rf(postID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostAcknowledgement)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(postID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForPosts provides a mock function with given fields: postIds
+func (_m *PostAcknowledgementStore) GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error) {
+	ret := _m.Called(postIds)
+
+	var r0 []*model.PostAcknowledgement
+	if rf, ok := ret.Get(0).(func([]string) []*model.PostAcknowledgement); ok {
+		r0 = rf(postIds)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.PostAcknowledgement)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]string) error); ok {
+		r1 = rf(postIds)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: postID, userID, acknowledgedAt
+func (_m *PostAcknowledgementStore) Save(postID string, userID string, acknowledgedAt int64) (*model.PostAcknowledgement, error) {
+	ret := _m.Called(postID, userID, acknowledgedAt)
+
+	var r0 *model.PostAcknowledgement
+	if rf, ok := ret.Get(0).(func(string, string, int64) *model.PostAcknowledgement); ok {
+		r0 = rf(postID, userID, acknowledgedAt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PostAcknowledgement)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string, int64) error); ok {
+		r1 = rf(postID, userID, acknowledgedAt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

store/storetest/mocks/Store.go

@@ -475,6 +475,22 @@ func (_m *Store) Post() store.PostStore {
 	return r0
 }
 
+// PostAcknowledgement provides a mock function with given fields:
+func (_m *Store) PostAcknowledgement() store.PostAcknowledgementStore {
+	ret := _m.Called()
+
+	var r0 store.PostAcknowledgementStore
+	if rf, ok := ret.Get(0).(func() store.PostAcknowledgementStore); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(store.PostAcknowledgementStore)
+		}
+	}
+
+	return r0
+}
+
 // PostPriority provides a mock function with given fields:
 func (_m *Store) PostPriority() store.PostPriorityStore {
 	ret := _m.Called()

store/storetest/post_acknowledgements_store.go

@@ -0,0 +1,181 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/store"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPostAcknowledgementsStore(t *testing.T, ss store.Store, s SqlStore) {
+	t.Run("Save", func(t *testing.T) { testPostAcknowledgementsStoreSave(t, ss) })
+	t.Run("GetForPost", func(t *testing.T) { testPostAcknowledgementsStoreGetForPost(t, ss) })
+	t.Run("GetForPosts", func(t *testing.T) { testPostAcknowledgementsStoreGetForPosts(t, ss) })
+}
+
+func testPostAcknowledgementsStoreSave(t *testing.T, ss store.Store) {
+	userId1 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestId()
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewString("important"),
+			RequestedAck:            model.NewBool(true),
+			PersistentNotifications: model.NewBool(false),
+		},
+	}
+	_, err := ss.Post().Save(&p1)
+	require.NoError(t, err)
+
+	t.Run("consecutive saves should just update the acknowledged at", func(t *testing.T) {
+		_, err := ss.PostAcknowledgement().Save(p1.Id, userId1, 0)
+		require.NoError(t, err)
+
+		_, err = ss.PostAcknowledgement().Save(p1.Id, userId1, 0)
+		require.NoError(t, err)
+
+		ack1, err := ss.PostAcknowledgement().Save(p1.Id, userId1, 0)
+		require.NoError(t, err)
+
+		acknowledgements, err := ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1})
+	})
+}
+
+func testPostAcknowledgementsStoreGetForPost(t *testing.T, ss store.Store) {
+	userId1 := model.NewId()
+	userId2 := model.NewId()
+	userId3 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestId()
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewString("important"),
+			RequestedAck:            model.NewBool(true),
+			PersistentNotifications: model.NewBool(false),
+		},
+	}
+	_, err := ss.Post().Save(&p1)
+	require.NoError(t, err)
+
+	t.Run("get acknowledgements for post", func(t *testing.T) {
+		ack1, err := ss.PostAcknowledgement().Save(p1.Id, userId1, 0)
+		require.NoError(t, err)
+		ack2, err := ss.PostAcknowledgement().Save(p1.Id, userId2, 0)
+		require.NoError(t, err)
+		ack3, err := ss.PostAcknowledgement().Save(p1.Id, userId3, 0)
+		require.NoError(t, err)
+
+		acknowledgements, err := ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1, ack2, ack3})
+
+		err = ss.PostAcknowledgement().Delete(ack1)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack2, ack3})
+
+		err = ss.PostAcknowledgement().Delete(ack2)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack3})
+
+		err = ss.PostAcknowledgement().Delete(ack3)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPost(p1.Id)
+		require.NoError(t, err)
+		require.Empty(t, acknowledgements)
+	})
+}
+
+func testPostAcknowledgementsStoreGetForPosts(t *testing.T, ss store.Store) {
+	userId1 := model.NewId()
+	userId2 := model.NewId()
+	userId3 := model.NewId()
+
+	p1 := model.Post{}
+	p1.ChannelId = model.NewId()
+	p1.UserId = model.NewId()
+	p1.Message = NewTestId()
+	p1.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewString("important"),
+			RequestedAck:            model.NewBool(true),
+			PersistentNotifications: model.NewBool(false),
+		},
+	}
+	p2 := model.Post{}
+	p2.ChannelId = model.NewId()
+	p2.UserId = model.NewId()
+	p2.Message = NewTestId()
+	p2.Metadata = &model.PostMetadata{
+		Priority: &model.PostPriority{
+			Priority:                model.NewString(""),
+			RequestedAck:            model.NewBool(true),
+			PersistentNotifications: model.NewBool(false),
+		},
+	}
+	_, errIdx, err := ss.Post().SaveMultiple([]*model.Post{&p1, &p2})
+	require.NoError(t, err)
+	require.Equal(t, -1, errIdx)
+
+	t.Run("get acknowledgements for post", func(t *testing.T) {
+		ack1, err := ss.PostAcknowledgement().Save(p1.Id, userId1, 0)
+		require.NoError(t, err)
+		ack2, err := ss.PostAcknowledgement().Save(p1.Id, userId2, 0)
+		require.NoError(t, err)
+		ack3, err := ss.PostAcknowledgement().Save(p2.Id, userId2, 0)
+		require.NoError(t, err)
+		ack4, err := ss.PostAcknowledgement().Save(p2.Id, userId3, 0)
+		require.NoError(t, err)
+
+		acknowledgements, err := ss.PostAcknowledgement().GetForPosts([]string{p1.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1, ack2})
+
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack3, ack4})
+
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack1, ack2, ack3, ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack1)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack2, ack3, ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack2)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack3, ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack3)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.ElementsMatch(t, acknowledgements, []*model.PostAcknowledgement{ack4})
+
+		err = ss.PostAcknowledgement().Delete(ack4)
+		require.NoError(t, err)
+		acknowledgements, err = ss.PostAcknowledgement().GetForPosts([]string{p1.Id, p2.Id})
+		require.NoError(t, err)
+		require.Empty(t, acknowledgements)
+	})
+}

store/storetest/store.go

@@ -57,6 +57,7 @@ type Store struct {
 	context                   context.Context
 	NotifyAdminStore          mocks.NotifyAdminStore
 	PostPriorityStore         mocks.PostPriorityStore
+	PostAcknowledgementStore  mocks.PostAcknowledgementStore
 }
 
 func (s *Store) SetContext(context context.Context)                { s.context = context }
@@ -102,17 +103,20 @@ func (s *Store) Group() store.GroupStore                 { return &s.GroupStore
 func (s *Store) LinkMetadata() store.LinkMetadataStore   { return &s.LinkMetadataStore }
 func (s *Store) SharedChannel() store.SharedChannelStore { return &s.SharedChannelStore }
 func (s *Store) PostPriority() store.PostPriorityStore   { return &s.PostPriorityStore }
-func (s *Store) MarkSystemRanUnitTests()                 { /* do nothing */ }
-func (s *Store) Close()                                  { /* do nothing */ }
-func (s *Store) LockToMaster()                           { /* do nothing */ }
-func (s *Store) UnlockFromMaster()                       { /* do nothing */ }
-func (s *Store) DropAllTables()                          { /* do nothing */ }
-func (s *Store) GetDbVersion(bool) (string, error)       { return "", nil }
-func (s *Store) GetInternalMasterDB() *sql.DB            { return nil }
-func (s *Store) GetInternalReplicaDB() *sql.DB           { return nil }
-func (s *Store) GetInternalReplicaDBs() []*sql.DB        { return nil }
-func (s *Store) RecycleDBConnections(time.Duration)      {}
-func (s *Store) GetDBSchemaVersion() (int, error)        { return 1, nil }
+func (s *Store) PostAcknowledgement() store.PostAcknowledgementStore {
+	return &s.PostAcknowledgementStore
+}
+func (s *Store) MarkSystemRanUnitTests()            { /* do nothing */ }
+func (s *Store) Close()                             { /* do nothing */ }
+func (s *Store) LockToMaster()                      { /* do nothing */ }
+func (s *Store) UnlockFromMaster()                  { /* do nothing */ }
+func (s *Store) DropAllTables()                     { /* do nothing */ }
+func (s *Store) GetDbVersion(bool) (string, error)  { return "", nil }
+func (s *Store) GetInternalMasterDB() *sql.DB       { return nil }
+func (s *Store) GetInternalReplicaDB() *sql.DB      { return nil }
+func (s *Store) GetInternalReplicaDBs() []*sql.DB   { return nil }
+func (s *Store) RecycleDBConnections(time.Duration) {}
+func (s *Store) GetDBSchemaVersion() (int, error)   { return 1, nil }
 func (s *Store) GetAppliedMigrations() ([]model.AppliedMigration, error) {
 	return []model.AppliedMigration{}, nil
 }
@@ -161,5 +165,6 @@ func (s *Store) AssertExpectations(t mock.TestingT) bool {
 		&s.SharedChannelStore,
 		&s.NotifyAdminStore,
 		&s.PostPriorityStore,
+		&s.PostAcknowledgementStore,
 	)
 }

store/timerlayer/timerlayer.go

@@ -36,6 +36,7 @@ type TimerLayer struct {
 	OAuthStore                store.OAuthStore
 	PluginStore               store.PluginStore
 	PostStore                 store.PostStore
+	PostAcknowledgementStore  store.PostAcknowledgementStore
 	PostPriorityStore         store.PostPriorityStore
 	PreferenceStore           store.PreferenceStore
 	ProductNoticesStore       store.ProductNoticesStore
@@ -131,6 +132,10 @@ func (s *TimerLayer) Post() store.PostStore {
 	return s.PostStore
 }
 
+func (s *TimerLayer) PostAcknowledgement() store.PostAcknowledgementStore {
+	return s.PostAcknowledgementStore
+}
+
 func (s *TimerLayer) PostPriority() store.PostPriorityStore {
 	return s.PostPriorityStore
 }
@@ -305,6 +310,11 @@ type TimerLayerPostStore struct {
 	Root *TimerLayer
 }
 
+type TimerLayerPostAcknowledgementStore struct {
+	store.PostAcknowledgementStore
+	Root *TimerLayer
+}
+
 type TimerLayerPostPriorityStore struct {
 	store.PostPriorityStore
 	Root *TimerLayer
@@ -5917,6 +5927,86 @@ func (s *TimerLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (
 	return result, err
 }
 
+func (s *TimerLayerPostAcknowledgementStore) Delete(acknowledgement *model.PostAcknowledgement) error {
+	start := time.Now()
+
+	err := s.PostAcknowledgementStore.Delete(acknowledgement)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("PostAcknowledgementStore.Delete", success, elapsed)
+	}
+	return err
+}
+
+func (s *TimerLayerPostAcknowledgementStore) Get(postID string, userID string) (*model.PostAcknowledgement, error) {
+	start := time.Now()
+
+	result, err := s.PostAcknowledgementStore.Get(postID, userID)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("PostAcknowledgementStore.Get", success, elapsed)
+	}
+	return result, err
+}
+
+func (s *TimerLayerPostAcknowledgementStore) GetForPost(postID string) ([]*model.PostAcknowledgement, error) {
+	start := time.Now()
+
+	result, err := s.PostAcknowledgementStore.GetForPost(postID)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("PostAcknowledgementStore.GetForPost", success, elapsed)
+	}
+	return result, err
+}
+
+func (s *TimerLayerPostAcknowledgementStore) GetForPosts(postIds []string) ([]*model.PostAcknowledgement, error) {
+	start := time.Now()
+
+	result, err := s.PostAcknowledgementStore.GetForPosts(postIds)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("PostAcknowledgementStore.GetForPosts", success, elapsed)
+	}
+	return result, err
+}
+
+func (s *TimerLayerPostAcknowledgementStore) Save(postID string, userID string, acknowledgedAt int64) (*model.PostAcknowledgement, error) {
+	start := time.Now()
+
+	result, err := s.PostAcknowledgementStore.Save(postID, userID, acknowledgedAt)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("PostAcknowledgementStore.Save", success, elapsed)
+	}
+	return result, err
+}
+
 func (s *TimerLayerPostPriorityStore) GetForPost(postId string) (*model.PostPriority, error) {
 	start := time.Now()
 
@@ -11344,6 +11434,7 @@ func New(childStore store.Store, metrics einterfaces.MetricsInterface) *TimerLay
 	newStore.OAuthStore = &TimerLayerOAuthStore{OAuthStore: childStore.OAuth(), Root: &newStore}
 	newStore.PluginStore = &TimerLayerPluginStore{PluginStore: childStore.Plugin(), Root: &newStore}
 	newStore.PostStore = &TimerLayerPostStore{PostStore: childStore.Post(), Root: &newStore}
+	newStore.PostAcknowledgementStore = &TimerLayerPostAcknowledgementStore{PostAcknowledgementStore: childStore.PostAcknowledgement(), Root: &newStore}
 	newStore.PostPriorityStore = &TimerLayerPostPriorityStore{PostPriorityStore: childStore.PostPriority(), Root: &newStore}
 	newStore.PreferenceStore = &TimerLayerPreferenceStore{PreferenceStore: childStore.Preference(), Root: &newStore}
 	newStore.ProductNoticesStore = &TimerLayerProductNoticesStore{ProductNoticesStore: childStore.ProductNotices(), Root: &newStore}