Merge branch 'master' into post-metadata

2018-11-14 09:58:56 -05:00
--- a/store/sqlstore/store.go
+++ b/store/sqlstore/store.go
@@ -94,4 +94,5 @@ type SqlStore interface {
 	Role() store.RoleStore
 	Scheme() store.SchemeStore
 	TermsOfService() store.TermsOfServiceStore
+	UserTermsOfService() store.UserTermsOfServiceStore
 }
--- a/store/sqlstore/supplier.go
+++ b/store/sqlstore/supplier.go
@@ -93,6 +93,7 @@ type SqlSupplierOldStores struct {
 	role                 store.RoleStore
 	scheme               store.SchemeStore
 	TermsOfService       store.TermsOfServiceStore
+	UserTermsOfService   store.UserTermsOfServiceStore
 }

 type SqlSupplier struct {
@@ -142,6 +143,7 @@ func NewSqlSupplier(settings model.SqlSettings, metrics einterfaces.MetricsInter
 	supplier.oldStores.channelMemberHistory = NewSqlChannelMemberHistoryStore(supplier)
 	supplier.oldStores.plugin = NewSqlPluginStore(supplier)
 	supplier.oldStores.TermsOfService = NewSqlTermsOfServiceStore(supplier, metrics)
+	supplier.oldStores.UserTermsOfService = NewSqlUserTermsOfServiceStore(supplier)

 	initSqlSupplierReactions(supplier)
 	initSqlSupplierRoles(supplier)
@@ -178,6 +180,7 @@ func NewSqlSupplier(settings model.SqlSettings, metrics einterfaces.MetricsInter
 	supplier.oldStores.userAccessToken.(*SqlUserAccessTokenStore).CreateIndexesIfNotExists()
 	supplier.oldStores.plugin.(*SqlPluginStore).CreateIndexesIfNotExists()
 	supplier.oldStores.TermsOfService.(SqlTermsOfServiceStore).CreateIndexesIfNotExists()
+	supplier.oldStores.UserTermsOfService.(SqlUserTermsOfServiceStore).CreateIndexesIfNotExists()

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

@@ -963,6 +966,10 @@ func (ss *SqlSupplier) TermsOfService() store.TermsOfServiceStore {
 	return ss.oldStores.TermsOfService
 }

+func (ss *SqlSupplier) UserTermsOfService() store.UserTermsOfServiceStore {
+	return ss.oldStores.UserTermsOfService
+}
+
 func (ss *SqlSupplier) Scheme() store.SchemeStore {
 	return ss.oldStores.scheme
 }
--- a/store/sqlstore/terms_of_service_store.go
+++ b/store/sqlstore/terms_of_service_store.go
@@ -5,11 +5,12 @@ package sqlstore

 import (
 	"database/sql"
+	"net/http"
+
 	"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 {
@@ -19,7 +20,9 @@ type SqlTermsOfServiceStore struct {

 var termsOfServiceCache = utils.NewLru(model.TERMS_OF_SERVICE_CACHE_SIZE)

-const termsOfServiceCacheName = "TermsOfServiceStore"
+const (
+	termsOfServiceCacheName = "TermsOfServiceStore"
+)

 func NewSqlTermsOfServiceStore(sqlStore SqlStore, metrics einterfaces.MetricsInterface) store.TermsOfServiceStore {
 	s := SqlTermsOfServiceStore{sqlStore, metrics}
--- a/store/sqlstore/terms_of_service_store_test.go
+++ b/store/sqlstore/terms_of_service_store_test.go
@@ -1,8 +1,9 @@
 package sqlstore

 import (
-	"github.com/mattermost/mattermost-server/store/storetest"
 	"testing"
+
+	"github.com/mattermost/mattermost-server/store/storetest"
 )

 func TestTermsOfServiceStore(t *testing.T) {
--- a/store/sqlstore/upgrade.go
+++ b/store/sqlstore/upgrade.go
@@ -15,6 +15,7 @@ import (
 )

 const (
+	VERSION_5_6_0            = "5.6.0"
 	VERSION_5_5_0            = "5.5.0"
 	VERSION_5_4_0            = "5.4.0"
 	VERSION_5_3_0            = "5.3.0"
@@ -88,6 +89,7 @@ func UpgradeDatabase(sqlStore SqlStore) {
 	UpgradeDatabaseToVersion53(sqlStore)
 	UpgradeDatabaseToVersion54(sqlStore)
 	UpgradeDatabaseToVersion55(sqlStore)
+	UpgradeDatabaseToVersion56(sqlStore)

 	// If the SchemaVersion is empty this this is the first time it has ran
 	// so lets set it to the current version.
@@ -502,15 +504,31 @@ func UpgradeDatabaseToVersion54(sqlStore SqlStore) {
 			time.Sleep(time.Second)
 			os.Exit(EXIT_GENERIC_FAILURE)
 		}
-		sqlStore.CreateColumnIfNotExists("Users", "AcceptedTermsOfServiceId", "varchar(64)", "varchar(64)", "")
 		saveSchemaVersion(sqlStore, VERSION_5_4_0)
 	}
 }

 func UpgradeDatabaseToVersion55(sqlStore SqlStore) {
-	// TODO: Uncomment following condition when version 5.5.0 is released
-	// if shouldPerformUpgrade(sqlStore, VERSION_5_4_0, VERSION_5_5_0) {
-	sqlStore.CreateColumnIfNotExists("PluginKeyValueStore", "ExpireAt", "bigint(20)", "bigint", "0")
-	// 	saveSchemaVersion(sqlStore, VERSION_5_5_0)
-	// }
+	if shouldPerformUpgrade(sqlStore, VERSION_5_4_0, VERSION_5_5_0) {
+		saveSchemaVersion(sqlStore, VERSION_5_5_0)
+	}
+}
+
+func UpgradeDatabaseToVersion56(sqlStore SqlStore) {
+	// TODO: Uncomment following condition when version 5.6.0 is released
+	//if shouldPerformUpgrade(sqlStore, VERSION_5_5_0, VERSION_5_6_0) {
+	sqlStore.CreateColumnIfNotExists("PluginKeyValueStore", "ExpireAt", "bigint(20)", "bigint", "0")
+
+	// migrating user's accepted terms of service data into the new table
+	sqlStore.GetMaster().Exec("INSERT INTO UserTermsOfService SELECT Id, AcceptedTermsOfServiceId as TermsOfServiceId, :CreateAt FROM Users WHERE AcceptedTermsOfServiceId != \"\" AND AcceptedTermsOfServiceId IS NOT NULL", map[string]interface{}{"CreateAt": model.GetMillis()})
+
+	if sqlStore.DriverName() == model.DATABASE_DRIVER_POSTGRES {
+		sqlStore.RemoveIndexIfExists("idx_users_email_lower", "lower(Email)")
+		sqlStore.RemoveIndexIfExists("idx_users_username_lower", "lower(Username)")
+		sqlStore.RemoveIndexIfExists("idx_users_nickname_lower", "lower(Nickname)")
+		sqlStore.RemoveIndexIfExists("idx_users_firstname_lower", "lower(FirstName)")
+		sqlStore.RemoveIndexIfExists("idx_users_lastname_lower", "lower(LastName)")
+	}
+	//saveSchemaVersion(sqlStore, VERSION_5_6_0)
+	//}
 }
--- a/store/sqlstore/user_store.go
+++ b/store/sqlstore/user_store.go
@@ -82,7 +82,6 @@ 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
@@ -95,11 +94,11 @@ func (us SqlUserStore) CreateIndexesIfNotExists() {
 	us.CreateIndexIfNotExists("idx_users_delete_at", "Users", "DeleteAt")

 	if us.DriverName() == model.DATABASE_DRIVER_POSTGRES {
-		us.CreateIndexIfNotExists("idx_users_email_lower", "Users", "lower(Email)")
-		us.CreateIndexIfNotExists("idx_users_username_lower", "Users", "lower(Username)")
-		us.CreateIndexIfNotExists("idx_users_nickname_lower", "Users", "lower(Nickname)")
-		us.CreateIndexIfNotExists("idx_users_firstname_lower", "Users", "lower(FirstName)")
-		us.CreateIndexIfNotExists("idx_users_lastname_lower", "Users", "lower(LastName)")
+		us.CreateIndexIfNotExists("idx_users_email_lower_textpattern", "Users", "lower(Email) text_pattern_ops")
+		us.CreateIndexIfNotExists("idx_users_username_lower_textpattern", "Users", "lower(Username) text_pattern_ops")
+		us.CreateIndexIfNotExists("idx_users_nickname_lower_textpattern", "Users", "lower(Nickname) text_pattern_ops")
+		us.CreateIndexIfNotExists("idx_users_firstname_lower_textpattern", "Users", "lower(FirstName) text_pattern_ops")
+		us.CreateIndexIfNotExists("idx_users_lastname_lower_textpattern", "Users", "lower(LastName) text_pattern_ops")
 	}

 	us.CreateFullTextIndexIfNotExists("idx_users_all_txt", "Users", strings.Join(USER_SEARCH_TYPE_ALL, ", "))
@@ -1167,7 +1166,7 @@ func generateSearchQuery(searchQuery string, terms []string, fields []string, pa
 			}
 		}
 		searchTerms = append(searchTerms, fmt.Sprintf("(%s)", strings.Join(searchFields, " OR ")))
-		parameters[fmt.Sprintf("Term%d", i)] = fmt.Sprintf("%s%%", term)
+		parameters[fmt.Sprintf("Term%d", i)] = fmt.Sprintf("%s%%", strings.TrimLeft(term, "@"))
 	}

 	searchClause := strings.Join(searchTerms, " AND ")
--- a/store/sqlstore/user_terms_of_service.go
+++ b/store/sqlstore/user_terms_of_service.go
@@ -0,0 +1,89 @@
+// Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package sqlstore
+
+import (
+	"database/sql"
+	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/store"
+	"net/http"
+)
+
+type SqlUserTermsOfServiceStore struct {
+	SqlStore
+}
+
+func NewSqlUserTermsOfServiceStore(sqlStore SqlStore) store.UserTermsOfServiceStore {
+	s := SqlUserTermsOfServiceStore{sqlStore}
+
+	for _, db := range sqlStore.GetAllConns() {
+		table := db.AddTableWithName(model.UserTermsOfService{}, "UserTermsOfService").SetKeys(false, "UserId")
+		table.ColMap("UserId").SetMaxSize(26)
+		table.ColMap("TermsOfServiceId").SetMaxSize(26)
+	}
+
+	return s
+}
+
+func (s SqlUserTermsOfServiceStore) CreateIndexesIfNotExists() {
+	s.CreateIndexIfNotExists("idx_user_terms_of_service_user_id", "UserTermsOfService", "UserId")
+}
+
+func (s SqlUserTermsOfServiceStore) GetByUser(userId string) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		var userTermsOfService *model.UserTermsOfService
+
+		err := s.GetReplica().SelectOne(&userTermsOfService, "SELECT * FROM UserTermsOfService WHERE UserId = :userId", map[string]interface{}{"userId": userId})
+		if err != nil {
+			if err == sql.ErrNoRows {
+				result.Err = model.NewAppError("NewSqlUserTermsOfServiceStore.GetByUser", "store.sql_user_terms_of_service.get_by_user.no_rows.app_error", nil, "", http.StatusNotFound)
+			} else {
+				result.Err = model.NewAppError("NewSqlUserTermsOfServiceStore.GetByUser", "store.sql_user_terms_of_service.get_by_user.app_error", nil, "", http.StatusInternalServerError)
+			}
+		} else {
+			result.Data = userTermsOfService
+		}
+	})
+}
+
+func (s SqlUserTermsOfServiceStore) Save(userTermsOfService *model.UserTermsOfService) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		userTermsOfService.PreSave()
+
+		if result.Err = userTermsOfService.IsValid(); result.Err != nil {
+			return
+		}
+
+		if c, err := s.GetMaster().Update(userTermsOfService); err != nil {
+			result.Err = model.NewAppError(
+				"SqlUserTermsOfServiceStore.Save",
+				"store.sql_user_terms_of_service.save.app_error",
+				nil,
+				"user_terms_of_service_user_id="+userTermsOfService.UserId+",user_terms_of_service_terms_of_service_id="+userTermsOfService.TermsOfServiceId+",err="+err.Error(),
+				http.StatusInternalServerError,
+			)
+		} else if c == 0 {
+			if err := s.GetMaster().Insert(userTermsOfService); err != nil {
+				result.Err = model.NewAppError(
+					"SqlUserTermsOfServiceStore.Save",
+					"store.sql_user_terms_of_service.save.app_error",
+					nil,
+					"user_terms_of_service_user_id="+userTermsOfService.UserId+",user_terms_of_service_terms_of_service_id="+userTermsOfService.TermsOfServiceId+",err="+err.Error(),
+					http.StatusInternalServerError,
+				)
+			}
+		}
+
+		result.Data = userTermsOfService
+	})
+}
+
+func (s SqlUserTermsOfServiceStore) Delete(userId, termsOfServiceId string) store.StoreChannel {
+	return store.Do(func(result *store.StoreResult) {
+		if _, err := s.GetMaster().Exec("DELETE FROM UserTermsOfService WHERE UserId = :UserId AND TermsOfServiceId = :TermsOfServiceId", map[string]interface{}{"UserId": userId, "TermsOfServiceId": termsOfServiceId}); err != nil {
+			result.Err = model.NewAppError("SqlUserTermsOfServiceStore.Delete", "store.sql_user_terms_of_service.delete.app_error", nil, "userId="+userId+", termsOfServiceId="+termsOfServiceId, http.StatusInternalServerError)
+			return
+		}
+	})
+}
--- a/store/sqlstore/user_terms_of_service_store_test.go
+++ b/store/sqlstore/user_terms_of_service_store_test.go
@@ -0,0 +1,10 @@
+package sqlstore
+
+import (
+	"github.com/mattermost/mattermost-server/store/storetest"
+	"testing"
+)
+
+func TestUserTermsOfServiceStore(t *testing.T) {
+	StoreTest(t, storetest.TestUserTermsOfServiceStore)
+}