#MM-12130 changes for custom service terms (#9450)

* #MM-12130 changes for custom service terms

* Fixed styling

* Added getServiceTerms API

* removed unnecessary panic

* removed custom service terms text from flat config

* reverted user sql store as those changes are no longer needed

* added tests

* Updated a config key to be more standard

* Added copyright info

* Loading service terms only if the feature is enabled

* Loading service terms only if the feature is enabled

* removed unused index

* added createservice termns API

* made a param to bool instead of string

* added createservice termns API

* review fixes

* fixed styling

* Minor refactoring

* removed saveConfig and loadConfig magic

* added empty service terms text check to createServiceTerms API

* refactoed some urls to be terms_of_service instead of service_terms

* removed check for support settings

* changed URLs in tests

* removed unused code

* fixed a bug

* added service termd id in conif

* fixed a test

* review fixes

* minor fixes

* Fixed TestCreateServiceTerms

5 files changed, 162 insertions, 1 deletions

diff --git a/store/sqlstore/service_terms_store.go b/store/sqlstore/service_terms_store.go
new file mode 100644
index 000000000..43a1189f6
--- /dev/null
+++ b/store/sqlstore/service_terms_store.go
@@ -0,0 +1,143 @@
+// 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/einterfaces"
+	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/store"
+	"github.com/mattermost/mattermost-server/utils"
+	"net/http"
+)
+
+type SqlServiceTermsStore struct {
+	SqlStore
+	metrics einterfaces.MetricsInterface
+}
+
+var serviceTermsCache = utils.NewLru(model.SERVICE_TERMS_CACHE_SIZE)
+
+const serviceTermsCacheName = "ServiceTerms"
+
+func NewSqlTermStore(sqlStore SqlStore, metrics einterfaces.MetricsInterface) store.ServiceTermsStore {
+	s := SqlServiceTermsStore{sqlStore, metrics}
+
+	for _, db := range sqlStore.GetAllConns() {
+		table := db.AddTableWithName(model.ServiceTerms{}, "ServiceTerms").SetKeys(false, "Id")
+		table.ColMap("Id").SetMaxSize(26)
+		table.ColMap("UserId").SetMaxSize(26)
+		table.ColMap("Text").SetMaxSize(model.POST_MESSAGE_MAX_BYTES_V2)
+	}
+
+	return s
+}
+
+func (s SqlServiceTermsStore) CreateIndexesIfNotExists() {
+}
+
+func (s SqlServiceTermsStore) Save(serviceTerms *model.ServiceTerms) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if len(serviceTerms.Id) > 0 {
+			result.Err = model.NewAppError(
+				"SqlServiceTermsStore.Save",
+				"store.sql_service_terms_store.save.existing.app_error",
+				nil,
+				"id="+serviceTerms.Id, http.StatusBadRequest,
+			)
+			return
+		}
+
+		serviceTerms.PreSave()
+
+		if result.Err = serviceTerms.IsValid(); result.Err != nil {
+			return
+		}
+
+		if err := s.GetMaster().Insert(serviceTerms); err != nil {
+			result.Err = model.NewAppError(
+				"SqlServiceTermsStore.Save",
+				"store.sql_service_terms.save.app_error",
+				nil,
+				"service_term_id="+serviceTerms.Id+",err="+err.Error(),
+				http.StatusInternalServerError,
+			)
+		}
+
+		result.Data = serviceTerms
+
+		serviceTermsCache.AddWithDefaultExpires(serviceTerms.Id, serviceTerms)
+	})
+}
+
+func (s SqlServiceTermsStore) GetLatest(allowFromCache bool) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if allowFromCache {
+			if serviceTermsCache.Len() == 0 {
+				if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
+				}
+			} else {
+				if cacheItem, ok := serviceTermsCache.Get(serviceTermsCache.Keys()[0]); ok {
+					if s.metrics != nil {
+						s.metrics.IncrementMemCacheHitCounter(serviceTermsCacheName)
+					}
+
+					result.Data = cacheItem.(*model.ServiceTerms)
+					return
+				} else if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
+				}
+			}
+		}
+
+		var serviceTerms *model.ServiceTerms
+
+		err := s.GetReplica().SelectOne(&serviceTerms, "SELECT * FROM ServiceTerms ORDER BY CreateAt DESC LIMIT 1")
+		if err != nil {
+			if err == sql.ErrNoRows {
+				result.Err = model.NewAppError("SqlServiceTermsStore.GetLatest", "store.sql_service_terms_store.get.no_rows.app_error", nil, "err="+err.Error(), http.StatusNotFound)
+			} else {
+				result.Err = model.NewAppError("SqlServiceTermsStore.GetLatest", "store.sql_service_terms_store.get.app_error", nil, "err="+err.Error(), http.StatusInternalServerError)
+			}
+		} else {
+			result.Data = serviceTerms
+
+			if allowFromCache {
+				serviceTermsCache.AddWithDefaultExpires(serviceTerms.Id, serviceTerms)
+			}
+		}
+	})
+}
+
+func (s SqlServiceTermsStore) Get(id string, allowFromCache bool) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if allowFromCache {
+			if serviceTermsCache.Len() == 0 {
+				if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
+				}
+			} else {
+				if cacheItem, ok := serviceTermsCache.Get(id); ok {
+					if s.metrics != nil {
+						s.metrics.IncrementMemCacheHitCounter(serviceTermsCacheName)
+					}
+
+					result.Data = cacheItem.(*model.ServiceTerms)
+					return
+				} else if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
+				}
+			}
+		}
+
+		if obj, err := s.GetReplica().Get(model.ServiceTerms{}, id); err != nil {
+			result.Err = model.NewAppError("SqlServiceTermsStore.Get", "store.sql_service_terms_store.get.app_error", nil, "err="+err.Error(), http.StatusInternalServerError)
+		} else if obj == nil {
+			result.Err = model.NewAppError("SqlServiceTermsStore.GetLatest", "store.sql_service_terms_store.get.no_rows.app_error", nil, "", http.StatusNotFound)
+		} else {
+			result.Data = obj.(*model.ServiceTerms)
+		}
+	})
+}
diff --git a/store/sqlstore/service_terms_store_test.go b/store/sqlstore/service_terms_store_test.go
new file mode 100644
index 000000000..030d0d7ae
--- /dev/null
+++ b/store/sqlstore/service_terms_store_test.go
@@ -0,0 +1,10 @@
+package sqlstore
+
+import (
+	"github.com/mattermost/mattermost-server/store/storetest"
+	"testing"
+)
+
+func TestServiceTermsStore(t *testing.T) {
+	StoreTest(t, storetest.TestServiceTermsStore)
+}
diff --git a/store/sqlstore/store.go b/store/sqlstore/store.go
index df912028b..b6f0fa84e 100644
--- a/store/sqlstore/store.go
+++ b/store/sqlstore/store.go
@@ -93,4 +93,5 @@ type SqlStore interface {
 	UserAccessToken() store.UserAccessTokenStore
 	Role() store.RoleStore
 	Scheme() store.SchemeStore
+	ServiceTerms() store.ServiceTermsStore
 }
diff --git a/store/sqlstore/supplier.go b/store/sqlstore/supplier.go
index 11216dd25..62c1102ca 100644
--- a/store/sqlstore/supplier.go
+++ b/store/sqlstore/supplier.go
@@ -92,6 +92,7 @@ type SqlSupplierOldStores struct {
 	channelMemberHistory store.ChannelMemberHistoryStore
 	role                 store.RoleStore
 	scheme               store.SchemeStore
+	serviceTerms         store.ServiceTermsStore
 }
 
 type SqlSupplier struct {
@@ -145,6 +146,7 @@ func NewSqlSupplier(settings model.SqlSettings, metrics einterfaces.MetricsInter
 	supplier.oldStores.userAccessToken = NewSqlUserAccessTokenStore(supplier)
 	supplier.oldStores.channelMemberHistory = NewSqlChannelMemberHistoryStore(supplier)
 	supplier.oldStores.plugin = NewSqlPluginStore(supplier)
+	supplier.oldStores.serviceTerms = NewSqlTermStore(supplier, metrics)
 
 	initSqlSupplierReactions(supplier)
 	initSqlSupplierRoles(supplier)
@@ -180,6 +182,7 @@ func NewSqlSupplier(settings model.SqlSettings, metrics einterfaces.MetricsInter
 	supplier.oldStores.job.(*SqlJobStore).CreateIndexesIfNotExists()
 	supplier.oldStores.userAccessToken.(*SqlUserAccessTokenStore).CreateIndexesIfNotExists()
 	supplier.oldStores.plugin.(*SqlPluginStore).CreateIndexesIfNotExists()
+	supplier.oldStores.serviceTerms.(SqlServiceTermsStore).CreateIndexesIfNotExists()
 
 	supplier.oldStores.preference.(*SqlPreferenceStore).DeleteUnusedFeatures()
 
@@ -961,6 +964,10 @@ func (ss *SqlSupplier) Role() store.RoleStore {
 	return ss.oldStores.role
 }
 
+func (ss *SqlSupplier) ServiceTerms() store.ServiceTermsStore {
+	return ss.oldStores.serviceTerms
+}
+
 func (ss *SqlSupplier) Scheme() store.SchemeStore {
 	return ss.oldStores.scheme
 }
diff --git a/store/sqlstore/upgrade.go b/store/sqlstore/upgrade.go
index a8be96172..05e10d266 100644
--- a/store/sqlstore/upgrade.go
+++ b/store/sqlstore/upgrade.go
@@ -496,11 +496,11 @@ func UpgradeDatabaseToVersion54(sqlStore SqlStore) {
 	// if shouldPerformUpgrade(sqlStore, VERSION_5_3_0, VERSION_5_4_0) {
 	sqlStore.AlterColumnTypeIfExists("OutgoingWebhooks", "Description", "varchar(500)", "varchar(500)")
 	sqlStore.AlterColumnTypeIfExists("IncomingWebhooks", "Description", "varchar(500)", "varchar(500)")
-
 	if err := sqlStore.Channel().MigratePublicChannels(); err != nil {
 		mlog.Critical("Failed to migrate PublicChannels table", mlog.Err(err))
 		time.Sleep(time.Second)
 		os.Exit(EXIT_GENERIC_FAILURE)
 	}
+	sqlStore.CreateColumnIfNotExists("Users", "AcceptedServiceTermsId", "varchar(64)", "varchar(64)", "")
 	// 	saveSchemaVersion(sqlStore, VERSION_5_4_0)
 }