Refactored to rename "service terms" to "terms of service" (#9581)

* #124 renamed identififers from service terms to terms of service * #124 renamed identififers from service terms to terms of service * 124 renamed ServiceTerms model to TermsOfService * 124 Renamed EnableCustomServiceTerms feature flag to EnableCustomTermsOfService * 124 Renamed EnableCustomServiceTerms feature flag to EnableCustomTermsOfService * #124 fixed formatting * #124 fixed formatting * #132 renamed table ServiceTerms to TermsOfService * #124 renamed some missed files from 'service_terms' to 'terms_of_service' * #124 removed fixed TODOs * drop migrate of ServiceTerms table, since backporting * s/ServiceTerms/TermsOfService/ in tests * s/AcceptedServiceTermsId/AcceptedTermsOfServiceId/ Change the model attribute, even though the column name will eventually be removed. * s/accepted_service_terms_id/accepted_terms_of_service_id/ to match redux * s/serviceTerms/termsOfService * rename column too, and add max size constraint * s/EnableCustomServiceTerms/EnableCustomTermsOfService
2018-10-10 00:55:47 +00:00
--- a/store/sqlstore/service_terms_store.go
+++ b/store/sqlstore/service_terms_store.go
@@ -1,143 +0,0 @@
-// 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)
-		}
-	})
-}
--- a/store/sqlstore/store.go
+++ b/store/sqlstore/store.go
@@ -93,5 +93,5 @@ type SqlStore interface {
 	UserAccessToken() store.UserAccessTokenStore
 	Role() store.RoleStore
 	Scheme() store.SchemeStore
-	ServiceTerms() store.ServiceTermsStore
+	TermsOfService() store.TermsOfServiceStore
 }
--- a/store/sqlstore/supplier.go
+++ b/store/sqlstore/supplier.go
@@ -92,7 +92,7 @@ type SqlSupplierOldStores struct {
 	channelMemberHistory store.ChannelMemberHistoryStore
 	role                 store.RoleStore
 	scheme               store.SchemeStore
-	serviceTerms         store.ServiceTermsStore
+	TermsOfService       store.TermsOfServiceStore
 }

 type SqlSupplier struct {
@@ -146,7 +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)
+	supplier.oldStores.TermsOfService = NewSqlTermsOfServiceStore(supplier, metrics)

 	initSqlSupplierReactions(supplier)
 	initSqlSupplierRoles(supplier)
@@ -182,7 +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.TermsOfService.(SqlTermsOfServiceStore).CreateIndexesIfNotExists()

 	supplier.oldStores.preference.(*SqlPreferenceStore).DeleteUnusedFeatures()

@@ -964,8 +964,8 @@ func (ss *SqlSupplier) Role() store.RoleStore {
 	return ss.oldStores.role
 }

-func (ss *SqlSupplier) ServiceTerms() store.ServiceTermsStore {
-	return ss.oldStores.serviceTerms
+func (ss *SqlSupplier) TermsOfService() store.TermsOfServiceStore {
+	return ss.oldStores.TermsOfService
 }

 func (ss *SqlSupplier) Scheme() store.SchemeStore {
--- a/store/sqlstore/terms_of_service_store.go
+++ b/store/sqlstore/terms_of_service_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 SqlTermsOfServiceStore struct {
+	SqlStore
+	metrics einterfaces.MetricsInterface
+}
+
+var termsOfServiceCache = utils.NewLru(model.TERMS_OF_SERVICE_CACHE_SIZE)
+
+const termsOfServiceCacheName = "TermsOfServiceStore"
+
+func NewSqlTermsOfServiceStore(sqlStore SqlStore, metrics einterfaces.MetricsInterface) store.TermsOfServiceStore {
+	s := SqlTermsOfServiceStore{sqlStore, metrics}
+
+	for _, db := range sqlStore.GetAllConns() {
+		table := db.AddTableWithName(model.TermsOfService{}, "TermsOfService").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 SqlTermsOfServiceStore) CreateIndexesIfNotExists() {
+}
+
+func (s SqlTermsOfServiceStore) Save(termsOfService *model.TermsOfService) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if len(termsOfService.Id) > 0 {
+			result.Err = model.NewAppError(
+				"SqlTermsOfServiceStore.Save",
+				"store.sql_terms_of_service_store.save.existing.app_error",
+				nil,
+				"id="+termsOfService.Id, http.StatusBadRequest,
+			)
+			return
+		}
+
+		termsOfService.PreSave()
+
+		if result.Err = termsOfService.IsValid(); result.Err != nil {
+			return
+		}
+
+		if err := s.GetMaster().Insert(termsOfService); err != nil {
+			result.Err = model.NewAppError(
+				"SqlTermsOfServiceStore.Save",
+				"store.sql_terms_of_service.save.app_error",
+				nil,
+				"terms_of_service_id="+termsOfService.Id+",err="+err.Error(),
+				http.StatusInternalServerError,
+			)
+		}
+
+		result.Data = termsOfService
+
+		termsOfServiceCache.AddWithDefaultExpires(termsOfService.Id, termsOfService)
+	})
+}
+
+func (s SqlTermsOfServiceStore) GetLatest(allowFromCache bool) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if allowFromCache {
+			if termsOfServiceCache.Len() == 0 {
+				if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(termsOfServiceCacheName)
+				}
+			} else {
+				if cacheItem, ok := termsOfServiceCache.Get(termsOfServiceCache.Keys()[0]); ok {
+					if s.metrics != nil {
+						s.metrics.IncrementMemCacheHitCounter(termsOfServiceCacheName)
+					}
+
+					result.Data = cacheItem.(*model.TermsOfService)
+					return
+				} else if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(termsOfServiceCacheName)
+				}
+			}
+		}
+
+		var termsOfService *model.TermsOfService
+
+		err := s.GetReplica().SelectOne(&termsOfService, "SELECT * FROM TermsOfService ORDER BY CreateAt DESC LIMIT 1")
+		if err != nil {
+			if err == sql.ErrNoRows {
+				result.Err = model.NewAppError("SqlTermsOfServiceStore.GetLatest", "store.sql_terms_of_service_store.get.no_rows.app_error", nil, "err="+err.Error(), http.StatusNotFound)
+			} else {
+				result.Err = model.NewAppError("SqlTermsOfServiceStore.GetLatest", "store.sql_terms_of_service_store.get.app_error", nil, "err="+err.Error(), http.StatusInternalServerError)
+			}
+		} else {
+			result.Data = termsOfService
+
+			if allowFromCache {
+				termsOfServiceCache.AddWithDefaultExpires(termsOfService.Id, termsOfService)
+			}
+		}
+	})
+}
+
+func (s SqlTermsOfServiceStore) Get(id string, allowFromCache bool) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if allowFromCache {
+			if termsOfServiceCache.Len() == 0 {
+				if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(termsOfServiceCacheName)
+				}
+			} else {
+				if cacheItem, ok := termsOfServiceCache.Get(id); ok {
+					if s.metrics != nil {
+						s.metrics.IncrementMemCacheHitCounter(termsOfServiceCacheName)
+					}
+
+					result.Data = cacheItem.(*model.TermsOfService)
+					return
+				} else if s.metrics != nil {
+					s.metrics.IncrementMemCacheMissCounter(termsOfServiceCacheName)
+				}
+			}
+		}
+
+		if obj, err := s.GetReplica().Get(model.TermsOfService{}, id); err != nil {
+			result.Err = model.NewAppError("SqlTermsOfServiceStore.Get", "store.sql_terms_of_service_store.get.app_error", nil, "err="+err.Error(), http.StatusInternalServerError)
+		} else if obj == nil {
+			result.Err = model.NewAppError("SqlTermsOfServiceStore.GetLatest", "store.sql_terms_of_service_store.get.no_rows.app_error", nil, "", http.StatusNotFound)
+		} else {
+			result.Data = obj.(*model.TermsOfService)
+		}
+	})
+}
--- a/store/sqlstore/terms_of_service_store_test.go
+++ b/store/sqlstore/terms_of_service_store_test.go
@@ -5,6 +5,6 @@ import (
 	"testing"
 )

-func TestServiceTermsStore(t *testing.T) {
-	StoreTest(t, storetest.TestServiceTermsStore)
+func TestTermsOfServiceStore(t *testing.T) {
+	StoreTest(t, storetest.TestTermsOfServiceStore)
 }
--- a/store/sqlstore/upgrade.go
+++ b/store/sqlstore/upgrade.go
@@ -502,7 +502,7 @@ func UpgradeDatabaseToVersion54(sqlStore SqlStore) {
 			time.Sleep(time.Second)
 			os.Exit(EXIT_GENERIC_FAILURE)
 		}
-		sqlStore.CreateColumnIfNotExists("Users", "AcceptedServiceTermsId", "varchar(64)", "varchar(64)", "")
+		sqlStore.CreateColumnIfNotExists("Users", "AcceptedTermsOfServiceId", "varchar(64)", "varchar(64)", "")
 		saveSchemaVersion(sqlStore, VERSION_5_4_0)
 	}
 }
--- a/store/sqlstore/user_store.go
+++ b/store/sqlstore/user_store.go
@@ -82,6 +82,7 @@ func NewSqlUserStore(sqlStore SqlStore, metrics einterfaces.MetricsInterface) st
 		table.ColMap("MfaSecret").SetMaxSize(128)
 		table.ColMap("Position").SetMaxSize(128)
 		table.ColMap("Timezone").SetMaxSize(256)
+		table.ColMap("AcceptedTermsOfServiceId").SetMaxSize(64)
 	}

 	return us