Removed Preference.AltId

api/preference.go

@@ -15,7 +15,8 @@ func InitPreference(r *mux.Router) {
 
 	sr := r.PathPrefix("/preferences").Subrouter()
 	sr.Handle("/save", ApiAppHandler(savePreferences)).Methods("POST")
-	sr.Handle("/{category:[A-Za-z0-9_]+}/{name:[A-Za-z0-9_]+}", ApiAppHandler(getPreferencesByName)).Methods("GET")
+	sr.Handle("/{category:[A-Za-z0-9_]+}", ApiAppHandler(getPreferenceCategory)).Methods("GET")
+	sr.Handle("/{category:[A-Za-z0-9_]+}/{name:[A-Za-z0-9_]+}", ApiAppHandler(getPreference)).Methods("GET")
 }
 
 func savePreferences(c *Context, w http.ResponseWriter, r *http.Request) {
@@ -42,19 +43,17 @@ func savePreferences(c *Context, w http.ResponseWriter, r *http.Request) {
 	w.Write([]byte("true"))
 }
 
-func getPreferencesByName(c *Context, w http.ResponseWriter, r *http.Request) {
+func getPreferenceCategory(c *Context, w http.ResponseWriter, r *http.Request) {
 	params := mux.Vars(r)
 	category := params["category"]
-	name := params["name"]
 
-	if result := <-Srv.Store.Preference().GetByName(c.Session.UserId, category, name); result.Err != nil {
+	if result := <-Srv.Store.Preference().GetCategory(c.Session.UserId, category); result.Err != nil {
 		c.Err = result.Err
-		return
 	} else {
 		data := result.Data.(model.Preferences)
 
 		if len(data) == 0 {
-			if category == model.PREFERENCE_CATEGORY_DIRECT_CHANNELS && name == model.PREFERENCE_NAME_SHOW {
+			if category == model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW {
 				// add direct channels for a user that existed before preferences were added
 				data = addDirectChannels(c.Session.UserId, c.Session.TeamId)
 			}
@@ -68,7 +67,7 @@ func addDirectChannels(userId, teamId string) model.Preferences {
 	var profiles map[string]*model.User
 	if result := <-Srv.Store.User().GetProfiles(teamId); result.Err != nil {
 		l4g.Error("Failed to add direct channel preferences for user user_id=%s, team_id=%s, err=%v", userId, teamId, result.Err.Error())
-		return []*model.Preference{}
+		return model.Preferences{}
 	} else {
 		profiles = result.Data.(map[string]*model.User)
 	}
@@ -82,11 +81,10 @@ func addDirectChannels(userId, teamId string) model.Preferences {
 
 		profile := profiles[id]
 
-		preference := &model.Preference{
+		preference := model.Preference{
 			UserId:   userId,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
+			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
-			Name:     model.PREFERENCE_NAME_SHOW,
+			Name:     profile.Id,
-			AltId:    profile.Id,
 			Value:    "true",
 		}
 
@@ -104,3 +102,16 @@ func addDirectChannels(userId, teamId string) model.Preferences {
 		return preferences
 	}
 }
+
+func getPreference(c *Context, w http.ResponseWriter, r *http.Request) {
+	params := mux.Vars(r)
+	category := params["category"]
+	name := params["name"]
+
+	if result := <-Srv.Store.Preference().Get(c.Session.UserId, category, name); result.Err != nil {
+		c.Err = result.Err
+	} else {
+		data := result.Data.(model.Preference)
+		w.Write([]byte(data.ToJson()))
+	}
+}

api/preference_test.go

@@ -26,11 +26,10 @@ func TestSetPreferences(t *testing.T) {
 	for i := 0; i < 10; i++ {
 		preference := model.Preference{
 			UserId:   user1.Id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
+			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
-			Name:     model.PREFERENCE_NAME_SHOW,
+			Name:     model.NewId(),
-			AltId:    model.NewId(),
 		}
-		preferences = append(preferences, &preference)
+		preferences = append(preferences, preference)
 	}
 
 	if _, err := Client.SetPreferences(&preferences); err != nil {
@@ -58,7 +57,7 @@ func TestSetPreferences(t *testing.T) {
 	}
 }
 
-func TestGetPreferencesByName(t *testing.T) {
+func TestGetPreferenceCategory(t *testing.T) {
 	Setup()
 
 	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
@@ -72,30 +71,23 @@ func TestGetPreferencesByName(t *testing.T) {
 	user2 = Client.Must(Client.CreateUser(user2, "")).Data.(*model.User)
 	store.Must(Srv.Store.User().VerifyEmail(user2.Id))
 
+	category := model.PREFERENCE_CATEGORY_TEST
+
 	preferences1 := model.Preferences{
 		{
 			UserId:   user1.Id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
+			Category: category,
-			Name:     model.PREFERENCE_NAME_SHOW,
-			AltId:    model.NewId(),
-		},
-		{
-			UserId:   user1.Id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
-			Name:     model.PREFERENCE_NAME_SHOW,
-			AltId:    model.NewId(),
-		},
-		{
-			UserId:   user1.Id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
 			Name:     model.PREFERENCE_NAME_TEST,
-			AltId:    model.NewId(),
+		},
+		{
+			UserId:   user1.Id,
+			Category: category,
+			Name:     model.NewId(),
 		},
 		{
 			UserId:   user1.Id,
 			Category: model.PREFERENCE_CATEGORY_TEST,
-			Name:     model.PREFERENCE_NAME_SHOW,
+			Name:     model.PREFERENCE_NAME_TEST,
-			AltId:    model.NewId(),
 		},
 	}
 
@@ -104,25 +96,72 @@ func TestGetPreferencesByName(t *testing.T) {
 
 	Client.LoginByEmail(team.Name, user1.Email, "pwd")
 
-	if result, err := Client.GetPreferencesByName(model.PREFERENCE_CATEGORY_DIRECT_CHANNELS, model.PREFERENCE_NAME_SHOW); err != nil {
+	if result, err := Client.GetPreferenceCategory(category); err != nil {
 		t.Fatal(err)
 	} else if data := result.Data.(model.Preferences); len(data) != 2 {
 		t.Fatal("received the wrong number of preferences")
-	} else if !((*data[0] == *preferences1[0] && *data[1] == *preferences1[1]) || (*data[0] == *preferences1[1] && *data[1] == *preferences1[0])) {
+	} else if !((data[0] == preferences1[0] && data[1] == preferences1[1]) || (data[0] == preferences1[1] && data[1] == preferences1[0])) {
 		t.Fatal("received incorrect preferences")
 	}
 
 	Client.LoginByEmail(team.Name, user2.Email, "pwd")
 
-	// note that user2 will start with a preference to show user1 in the sidebar by default
+	if result, err := Client.GetPreferenceCategory(category); err != nil {
-	if result, err := Client.GetPreferencesByName(model.PREFERENCE_CATEGORY_DIRECT_CHANNELS, model.PREFERENCE_NAME_SHOW); err != nil {
 		t.Fatal(err)
-	} else if data := result.Data.(model.Preferences); len(data) != 1 {
+	} else if data := result.Data.(model.Preferences); len(data) != 0 {
 		t.Fatal("received the wrong number of preferences")
 	}
 }
 
-func TestSetAndGetProperties(t *testing.T) {
+func TestGetDefaultDirectChannels(t *testing.T) {
+	Setup()
+
+	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
+	team = Client.Must(Client.CreateTeam(team)).Data.(*model.Team)
+
+	user1 := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+	user1 = Client.Must(Client.CreateUser(user1, "")).Data.(*model.User)
+	store.Must(Srv.Store.User().VerifyEmail(user1.Id))
+
+	for i := 0; i < 5; i++ {
+		user := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+		Client.Must(Client.CreateUser(user, ""))
+	}
+
+	Client.Must(Client.LoginByEmail(team.Name, user1.Email, "pwd"))
+
+	if result, err := Client.GetPreferenceCategory(model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW); err != nil {
+		t.Fatal(err)
+	} else if data := result.Data.(model.Preferences); len(data) != 5 {
+		t.Fatal("received the wrong number of direct channels")
+	}
+
+	user2 := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+	user2 = Client.Must(Client.CreateUser(user2, "")).Data.(*model.User)
+	store.Must(Srv.Store.User().VerifyEmail(user2.Id))
+
+	for i := 0; i < 10; i++ {
+		user := &model.User{TeamId: team.Id, Email: model.NewId() + "corey@test.com", Nickname: "Corey Hulen", Password: "pwd"}
+		Client.Must(Client.CreateUser(user, ""))
+	}
+
+	// make sure user1's preferences don't change
+	if result, err := Client.GetPreferenceCategory(model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW); err != nil {
+		t.Fatal(err)
+	} else if data := result.Data.(model.Preferences); len(data) != 5 {
+		t.Fatal("received the wrong number of direct channels")
+	}
+
+	Client.Must(Client.LoginByEmail(team.Name, user2.Email, "pwd"))
+
+	if result, err := Client.GetPreferenceCategory(model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW); err != nil {
+		t.Fatal(err)
+	} else if data := result.Data.(model.Preferences); len(data) != 10 {
+		t.Fatal("received the wrong number of direct channels")
+	}
+}
+
+func TestGetPreference(t *testing.T) {
 	Setup()
 
 	team := &model.Team{DisplayName: "Name", Name: "z-z-" + model.NewId() + "a", Email: "test@nowhere.com", Type: model.TEAM_OPEN}
@@ -137,31 +176,26 @@ func TestSetAndGetProperties(t *testing.T) {
 	preferences := model.Preferences{
 		{
 			UserId:   user.Id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
+			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
-			Name:     model.PREFERENCE_NAME_SHOW,
+			Name:     model.NewId(),
-			AltId:    model.NewId(),
 			Value:    model.NewId(),
 		},
 	}
 
 	Client.Must(Client.SetPreferences(&preferences))
 
-	if result, err := Client.GetPreferencesByName(preferences[0].Category, preferences[0].Name); err != nil {
+	if result, err := Client.GetPreference(preferences[0].Category, preferences[0].Name); err != nil {
 		t.Fatal(err)
-	} else if data := result.Data.(model.Preferences); len(data) != 1 {
+	} else if data := result.Data.(*model.Preference); *data != preferences[0] {
-		t.Fatal("received too many preferences")
-	} else if *data[0] != *preferences[0] {
 		t.Fatal("preference saved incorrectly")
 	}
 
 	preferences[0].Value = model.NewId()
 	Client.Must(Client.SetPreferences(&preferences))
 
-	if result, err := Client.GetPreferencesByName(preferences[0].Category, preferences[0].Name); err != nil {
+	if result, err := Client.GetPreference(preferences[0].Category, preferences[0].Name); err != nil {
 		t.Fatal(err)
-	} else if data := result.Data.(model.Preferences); len(data) != 1 {
+	} else if data := result.Data.(*model.Preference); *data != preferences[0] {
-		t.Fatal("received too many preferences")
-	} else if *data[0] != *preferences[0] {
 		t.Fatal("preference updated incorrectly")
 	}
 }

model/client.go

@@ -853,9 +853,17 @@ func (c *Client) SetPreferences(preferences *Preferences) (*Result, *AppError) {
 	}
 }
 
-func (c *Client) GetPreferencesByName(category string, name string) (*Result, *AppError) {
+func (c *Client) GetPreference(category string, name string) (*Result, *AppError) {
 	if r, err := c.DoApiGet("/preferences/"+category+"/"+name, "", ""); err != nil {
 		return nil, err
+	} else {
+		return &Result{r.Header.Get(HEADER_REQUEST_ID), r.Header.Get(HEADER_ETAG_SERVER), PreferenceFromJson(r.Body)}, nil
+	}
+}
+
+func (c *Client) GetPreferenceCategory(category string) (*Result, *AppError) {
+	if r, err := c.DoApiGet("/preferences/"+category, "", ""); err != nil {
+		return nil, err
 	} else {
 		preferences, _ := PreferencesFromJson(r.Body)
 		return &Result{r.Header.Get(HEADER_REQUEST_ID), r.Header.Get(HEADER_ETAG_SERVER), preferences}, nil

model/preference.go

@@ -9,17 +9,15 @@ import (
 )
 
 const (
-	PREFERENCE_CATEGORY_DIRECT_CHANNELS = "direct_channels"
+	PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW = "direct_channel_show"
-	PREFERENCE_CATEGORY_TEST            = "test" // do not use, just for testing uniqueness while there's only one real category
+	PREFERENCE_CATEGORY_TEST                = "test" // do not use, just for testing uniqueness while there's only one real category
-	PREFERENCE_NAME_SHOW                = "show"
+	PREFERENCE_NAME_TEST                    = "test" // do not use, just for testing while there's no constant name
-	PREFERENCE_NAME_TEST                = "test" // do not use, just for testing uniqueness while there's only one real name
 )
 
 type Preference struct {
 	UserId   string `json:"user_id"`
 	Category string `json:"category"`
 	Name     string `json:"name"`
-	AltId    string `json:"alt_id"`
 	Value    string `json:"value"`
 }
 
@@ -52,14 +50,11 @@ func (o *Preference) IsValid() *AppError {
 		return NewAppError("Preference.IsValid", "Invalid category", "category="+o.Category)
 	}
 
-	if len(o.Name) == 0 || len(o.Name) > 32 || !IsPreferenceNameValid(o.Name) {
+	// name can either be a valid constant or an id
+	if len(o.Name) == 0 || len(o.Name) > 32 || !(len(o.Name) == 26 || IsPreferenceNameValid(o.Name)) {
 		return NewAppError("Preference.IsValid", "Invalid name", "name="+o.Name)
 	}
 
-	if o.AltId != "" && len(o.AltId) != 26 {
-		return NewAppError("Preference.IsValid", "Invalid alternate id", "altId="+o.AltId)
-	}
-
 	if len(o.Value) > 128 {
 		return NewAppError("Preference.IsValid", "Value is too long", "value="+o.Value)
 	}
@@ -68,9 +63,9 @@ func (o *Preference) IsValid() *AppError {
 }
 
 func IsPreferenceCategoryValid(category string) bool {
-	return category == PREFERENCE_CATEGORY_DIRECT_CHANNELS || category == PREFERENCE_CATEGORY_TEST
+	return category == PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW || category == PREFERENCE_CATEGORY_TEST
 }
 
 func IsPreferenceNameValid(name string) bool {
-	return name == PREFERENCE_NAME_SHOW || name == PREFERENCE_NAME_TEST
+	return name == PREFERENCE_NAME_TEST
 }

model/preference_test.go

@@ -9,15 +9,19 @@ import (
 )
 
 func TestPreferenceIsValid(t *testing.T) {
-	preference := Preference{}
+	preference := Preference{
+		UserId:   "1234garbage",
+		Category: PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
+		Name:     PREFERENCE_NAME_TEST,
+	}
 
 	if err := preference.IsValid(); err == nil {
 		t.Fatal()
 	}
 
 	preference.UserId = NewId()
-	if err := preference.IsValid(); err == nil {
+	if err := preference.IsValid(); err != nil {
-		t.Fatal()
+		t.Fatal(err)
 	}
 
 	preference.Category = "1234garbage"
@@ -25,8 +29,8 @@ func TestPreferenceIsValid(t *testing.T) {
 		t.Fatal()
 	}
 
-	preference.Category = PREFERENCE_CATEGORY_DIRECT_CHANNELS
+	preference.Category = PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
-	if err := preference.IsValid(); err == nil {
+	if err := preference.IsValid(); err != nil {
 		t.Fatal()
 	}
 
@@ -35,22 +39,12 @@ func TestPreferenceIsValid(t *testing.T) {
 		t.Fatal()
 	}
 
-	preference.Name = PREFERENCE_NAME_SHOW
+	preference.Name = NewId()
 	if err := preference.IsValid(); err != nil {
 		t.Fatal()
 	}
 
-	preference.AltId = "1234garbage"
+	preference.Name = PREFERENCE_NAME_TEST
-	if err := preference.IsValid(); err == nil {
-		t.Fatal()
-	}
-
-	preference.AltId = NewId()
-	if err := preference.IsValid(); err != nil {
-		t.Fatal()
-	}
-
-	preference.Value = "1234garbage"
 	if err := preference.IsValid(); err != nil {
 		t.Fatal()
 	}
@@ -59,4 +53,9 @@ func TestPreferenceIsValid(t *testing.T) {
 	if err := preference.IsValid(); err == nil {
 		t.Fatal()
 	}
+
+	preference.Value = "1234garbage"
+	if err := preference.IsValid(); err != nil {
+		t.Fatal()
+	}
 }

model/preferences.go

@@ -8,7 +8,7 @@ import (
 	"io"
 )
 
-type Preferences []*Preference
+type Preferences []Preference
 
 func (o *Preferences) ToJson() string {
 	b, err := json.Marshal(o)

store/sql_preference_store.go

@@ -17,11 +17,10 @@ func NewSqlPreferenceStore(sqlStore *SqlStore) PreferenceStore {
 	s := &SqlPreferenceStore{sqlStore}
 
 	for _, db := range sqlStore.GetAllConns() {
-		table := db.AddTableWithName(model.Preference{}, "Preferences").SetKeys(false, "UserId", "Category", "Name", "AltId")
+		table := db.AddTableWithName(model.Preference{}, "Preferences").SetKeys(false, "UserId", "Category", "Name")
 		table.ColMap("UserId").SetMaxSize(26)
 		table.ColMap("Category").SetMaxSize(32)
 		table.ColMap("Name").SetMaxSize(32)
-		table.ColMap("AltId").SetMaxSize(26)
 		table.ColMap("Value").SetMaxSize(128)
 	}
 
@@ -49,7 +48,7 @@ func (s SqlPreferenceStore) Save(preferences *model.Preferences) StoreChannel {
 			result.Err = model.NewAppError("SqlPreferenceStore.Save", "Unable to open transaction to save preferences", err.Error())
 		} else {
 			for _, preference := range *preferences {
-				if upsertResult := s.save(transaction, preference); upsertResult.Err != nil {
+				if upsertResult := s.save(transaction, &preference); upsertResult.Err != nil {
 					result = upsertResult
 					break
 				}
@@ -87,7 +86,6 @@ func (s SqlPreferenceStore) save(transaction *gorp.Transaction, preference *mode
 		"UserId":   preference.UserId,
 		"Category": preference.Category,
 		"Name":     preference.Name,
-		"AltId":    preference.AltId,
 		"Value":    preference.Value,
 	}
 
@@ -95,9 +93,9 @@ func (s SqlPreferenceStore) save(transaction *gorp.Transaction, preference *mode
 		if _, err := transaction.Exec(
 			`INSERT INTO
 				Preferences
-				(UserId, Category, Name, AltId, Value)
+				(UserId, Category, Name, Value)
 			VALUES
-				(:UserId, :Category, :Name, :AltId, :Value)
+				(:UserId, :Category, :Name, :Value)
 			ON DUPLICATE KEY UPDATE
 				Value = :Value`, params); err != nil {
 			result.Err = model.NewAppError("SqlPreferenceStore.save", "We encountered an error while updating preferences", err.Error())
@@ -112,8 +110,7 @@ func (s SqlPreferenceStore) save(transaction *gorp.Transaction, preference *mode
 			WHERE
 				UserId = :UserId
 				AND Category = :Category
-				AND Name = :Name
+				AND Name = :Name`, params)
-				AND AltId = :AltId`, params)
 		if err != nil {
 			result.Err = model.NewAppError("SqlPreferenceStore.save", "We encountered an error while updating preferences", err.Error())
 			return result
@@ -137,11 +134,11 @@ func (s SqlPreferenceStore) insert(transaction *gorp.Transaction, preference *mo
 
 	if err := transaction.Insert(preference); err != nil {
 		if IsUniqueConstraintError(err.Error(), "UserId", "preferences_pkey") {
-			result.Err = model.NewAppError("SqlPreferenceStore.insert", "A preference with that user id, category, name, and alt id already exists",
+			result.Err = model.NewAppError("SqlPreferenceStore.insert", "A preference with that user id, category, and name already exists",
-				"user_id="+preference.UserId+", category="+preference.Category+", name="+preference.Name+", alt_id="+preference.AltId+", "+err.Error())
+				"user_id="+preference.UserId+", category="+preference.Category+", name="+preference.Name+", "+err.Error())
 		} else {
 			result.Err = model.NewAppError("SqlPreferenceStore.insert", "We couldn't save the preference",
-				"user_id="+preference.UserId+", category="+preference.Category+", name="+preference.Name+", alt_id="+preference.AltId+", "+err.Error())
+				"user_id="+preference.UserId+", category="+preference.Category+", name="+preference.Name+", "+err.Error())
 		}
 	}
 
@@ -153,13 +150,13 @@ func (s SqlPreferenceStore) update(transaction *gorp.Transaction, preference *mo
 
 	if _, err := transaction.Update(preference); err != nil {
 		result.Err = model.NewAppError("SqlPreferenceStore.update", "We couldn't update the preference",
-			"user_id="+preference.UserId+", category="+preference.Category+", name="+preference.Name+", alt_id="+preference.AltId+", "+err.Error())
+			"user_id="+preference.UserId+", category="+preference.Category+", name="+preference.Name+", "+err.Error())
 	}
 
 	return result
 }
 
-func (s SqlPreferenceStore) GetByName(userId string, category string, name string) StoreChannel {
+func (s SqlPreferenceStore) Get(userId string, category string, name string) StoreChannel {
 	storeChannel := make(StoreChannel)
 
 	go func() {
@@ -177,6 +174,34 @@ func (s SqlPreferenceStore) GetByName(userId string, category string, name strin
 				AND Category = :Category
 				AND Name = :Name`, map[string]interface{}{"UserId": userId, "Category": category, "Name": name}); err != nil {
 			result.Err = model.NewAppError("SqlPreferenceStore.GetByName", "We encounted an error while finding preferences", err.Error())
+		} else {
+			result.Data = preferences[0]
+		}
+
+		storeChannel <- result
+		close(storeChannel)
+	}()
+
+	return storeChannel
+}
+
+func (s SqlPreferenceStore) GetCategory(userId string, category string) StoreChannel {
+	storeChannel := make(StoreChannel)
+
+	go func() {
+		result := StoreResult{}
+
+		var preferences model.Preferences
+
+		if _, err := s.GetReplica().Select(&preferences,
+			`SELECT
+				*
+			FROM
+				Preferences
+			WHERE
+				UserId = :UserId
+				AND Category = :Category`, map[string]interface{}{"UserId": userId, "Category": category}); err != nil {
+			result.Err = model.NewAppError("SqlPreferenceStore.GetCategory", "We encounted an error while finding preferences", err.Error())
 		} else {
 			result.Data = preferences
 		}

store/sql_preference_store_test.go

@@ -16,14 +16,14 @@ func TestPreferenceSave(t *testing.T) {
 	preferences := model.Preferences{
 		{
 			UserId:   id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
+			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
-			Name:     model.PREFERENCE_NAME_SHOW,
+			Name:     model.NewId(),
 			Value:    "value1a",
 		},
 		{
 			UserId:   id,
-			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNELS,
+			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
-			Name:     model.PREFERENCE_NAME_TEST,
+			Name:     model.NewId(),
 			Value:    "value1b",
 		},
 	}
@@ -32,9 +32,7 @@ func TestPreferenceSave(t *testing.T) {
 	}
 
 	for _, preference := range preferences {
-		if data := Must(store.Preference().GetByName(preference.UserId, preference.Category, preference.Name)).(model.Preferences); len(data) != 1 {
+		if data := Must(store.Preference().Get(preference.UserId, preference.Category, preference.Name)).(model.Preference); preference != data {
-			t.Fatal("got incorrect number of preferences after first Save")
-		} else if *preference != *data[0] {
 			t.Fatal("got incorrect preference after first Save")
 		}
 	}
@@ -46,66 +44,91 @@ func TestPreferenceSave(t *testing.T) {
 	}
 
 	for _, preference := range preferences {
-		if data := Must(store.Preference().GetByName(preference.UserId, preference.Category, preference.Name)).(model.Preferences); len(data) != 1 {
+		if data := Must(store.Preference().Get(preference.UserId, preference.Category, preference.Name)).(model.Preference); preference != data {
-			t.Fatal("got incorrect number of preferences after second Save")
-		} else if *preference != *data[0] {
 			t.Fatal("got incorrect preference after second Save")
 		}
 	}
 }
 
-func TestPreferenceGetByName(t *testing.T) {
+func TestPreferenceGet(t *testing.T) {
 	Setup()
 
 	userId := model.NewId()
-	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNELS
+	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
-	name := model.PREFERENCE_NAME_SHOW
+	name := model.PREFERENCE_NAME_TEST
-	altId := model.NewId()
 
 	preferences := model.Preferences{
 		{
 			UserId:   userId,
 			Category: category,
 			Name:     name,
-			AltId:    altId,
 		},
-		// same user/category/name, different alt id
 		{
 			UserId:   userId,
 			Category: category,
-			Name:     name,
+			Name:     model.NewId(),
-			AltId:    model.NewId(),
 		},
-		// same user/category/alt id, different name
-		{
-			UserId:   userId,
-			Category: category,
-			Name:     model.PREFERENCE_NAME_TEST,
-			AltId:    altId,
-		},
-		// same user/name/alt id, different category
 		{
 			UserId:   userId,
 			Category: model.PREFERENCE_CATEGORY_TEST,
 			Name:     name,
-			AltId:    altId,
 		},
-		// same name/category/alt id, different user
 		{
 			UserId:   model.NewId(),
 			Category: category,
 			Name:     name,
-			AltId:    altId,
 		},
 	}
 
 	Must(store.Preference().Save(&preferences))
 
-	if result := <-store.Preference().GetByName(userId, category, name); result.Err != nil {
+	if result := <-store.Preference().Get(userId, category, name); result.Err != nil {
+		t.Fatal(result.Err)
+	} else if data := result.Data.(model.Preference); data != preferences[0] {
+		t.Fatal("got incorrect preference")
+	}
+}
+
+func TestPreferenceGetCategory(t *testing.T) {
+	Setup()
+
+	userId := model.NewId()
+	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
+	name := model.NewId()
+
+	preferences := model.Preferences{
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     name,
+		},
+		// same user/category, different name
+		{
+			UserId:   userId,
+			Category: category,
+			Name:     model.NewId(),
+		},
+		// same user/name, different category
+		{
+			UserId:   userId,
+			Category: model.PREFERENCE_CATEGORY_TEST,
+			Name:     name,
+		},
+		// same name/category, different user
+		{
+			UserId:   model.NewId(),
+			Category: category,
+			Name:     name,
+		},
+	}
+
+	Must(store.Preference().Save(&preferences))
+
+	if result := <-store.Preference().GetCategory(userId, category); result.Err != nil {
 		t.Fatal(result.Err)
 	} else if data := result.Data.(model.Preferences); len(data) != 2 {
 		t.Fatal("got the wrong number of preferences")
-	} else if !((*data[0] == *preferences[0] && *data[1] == *preferences[1]) || (*data[0] == *preferences[1] && *data[1] == *preferences[0])) {
+	} else if !((data[0] == preferences[0] && data[1] == preferences[1]) || (data[0] == preferences[1] && data[1] == preferences[0])) {
 		t.Fatal("got incorrect preferences")
 	}
 }

store/store.go

@@ -153,5 +153,6 @@ type WebhookStore interface {
 
 type PreferenceStore interface {
 	Save(preferences *model.Preferences) StoreChannel
-	GetByName(userId string, category string, name string) StoreChannel
+	Get(userId string, category string, name string) StoreChannel
+	GetCategory(userId string, category string) StoreChannel
 }

web/react/components/more_direct_channels.jsx

@@ -23,9 +23,8 @@ export default class MoreDirectChannels extends React.Component {
     }
 
     handleJoinDirectChannel(channel) {
-        const preference = PreferenceStore.setPreferenceWithAltId(Constants.Preferences.CATEGORY_DIRECT_CHANNELS,
+        const preference = PreferenceStore.setPreference(Constants.Preferences.CATEGORY_DIRECT_CHANNEL_SHOW, channel.teammate_id, 'true');
-            Constants.Preferences.NAME_SHOW, channel.teammate_id, 'true');
+        AsyncClient.savePreferences([preference]);
-        AsyncClient.setPreferences([preference]);
     }
 
     render() {

web/react/components/sidebar.jsx

@@ -54,7 +54,7 @@ export default class Sidebar extends React.Component {
             teammates.push(teamMemberMap[id]);
         }
 
-        const preferences = PreferenceStore.getPreferences(Constants.Preferences.CATEGORY_DIRECT_CHANNELS, Constants.Preferences.NAME_SHOW);
+        const preferences = PreferenceStore.getPreferences(Constants.Preferences.CATEGORY_DIRECT_CHANNEL_SHOW);
 
         // Create lists of all read and unread direct channels
         var visibleDirectChannels = [];
@@ -95,13 +95,12 @@ export default class Sidebar extends React.Component {
             channel.teammate_id = teammate.id;
             channel.status = UserStore.getStatus(teammate.id);
 
-            if (preferences.some((preference) => (preference.alt_id === teammate.id && preference.value !== 'false'))) {
+            if (preferences.some((preference) => (preference.name === teammate.id && preference.value !== 'false'))) {
                 visibleDirectChannels.push(channel);
             } else if (forceShow) {
                 // make sure that unread direct channels are visible
-                const preference = PreferenceStore.setPreferenceWithAltId(Constants.Preferences.CATEGORY_DIRECT_CHANNELS,
+                const preference = PreferenceStore.setPreference(Constants.Preferences.CATEGORY_DIRECT_CHANNEL_SHOW, teammate.id, 'true');
-                    Constants.Preferences.NAME_SHOW, teammate.id, 'true');
+                AsyncClient.savePreferences([preference]);
-                AsyncClient.setPreferences([preference]);
 
                 visibleDirectChannels.push(channel);
             } else {
@@ -129,7 +128,7 @@ export default class Sidebar extends React.Component {
         SocketStore.addChangeListener(this.onSocketChange);
         PreferenceStore.addChangeListener(this.onChange);
 
-        AsyncClient.getDirectChannels();
+        AsyncClient.getDirectChannelPreferences();
 
         $('.nav-pills__container').perfectScrollbar();
 
@@ -310,9 +309,8 @@ export default class Sidebar extends React.Component {
         if (!this.isLeaving.get(channel.id)) {
             this.isLeaving.set(channel.id, true);
 
-            const preference = PreferenceStore.setPreferenceWithAltId(Constants.Preferences.CATEGORY_DIRECT_CHANNELS,
+            const preference = PreferenceStore.setPreference(Constants.Preferences.CATEGORY_DIRECT_CHANNEL_SHOW, channel.teammate_id, 'false');
-                Constants.Preferences.NAME_SHOW, channel.teammate_id, 'false');
+            AsyncClient.savePreferences(
-            AsyncClient.setPreferences(
                 [preference],
                 () => {
                     this.isLeaving.set(channel.id, false);

web/react/stores/preference_store.jsx

@@ -15,12 +15,10 @@ class PreferenceStoreClass extends EventEmitter {
 
         this.getAllPreferences = this.getAllPreferences.bind(this);
         this.getPreference = this.getPreference.bind(this);
-        this.getPreferenceWithAltId = this.getPreferenceWithAltId.bind(this);
         this.getPreferences = this.getPreferences.bind(this);
         this.getPreferencesWhere = this.getPreferencesWhere.bind(this);
         this.setAllPreferences = this.setAllPreferences.bind(this);
         this.setPreference = this.setPreference.bind(this);
-        this.setPreferenceWithAltId = this.setPreferenceWithAltId.bind(this);
 
         this.emitChange = this.emitChange.bind(this);
         this.addChangeListener = this.addChangeListener.bind(this);
@@ -30,12 +28,12 @@ class PreferenceStoreClass extends EventEmitter {
         this.dispatchToken = AppDispatcher.register(this.handleEventPayload);
     }
 
-    getKey(category, name, altId = '') {
+    getKey(category, name) {
-        return `${category}-${name}-${altId}`;
+        return `${category}-${name}`;
     }
 
     getKeyForModel(preference) {
-        return `${preference.category}-${preference.name}-${preference.alt_id}`;
+        return `${preference.category}-${preference.name}`;
     }
 
     getAllPreferences() {
@@ -46,12 +44,8 @@ class PreferenceStoreClass extends EventEmitter {
         return this.getAllPreferences().get(this.getKey(category, name)) || defaultValue;
     }
 
-    getPreferenceWithAltId(category, name, altId, defaultValue = '') {
+    getPreferences(category) {
-        return this.getAllPreferences().get(this.getKey(category, name, altId)) || defaultValue;
+        return this.getPreferencesWhere((preference) => (preference.category === category));
-    }
-
-    getPreferences(category, name) {
-        return this.getPreferencesWhere((preference) => (preference.category === category && preference.name === name));
     }
 
     getPreferencesWhere(pred) {
@@ -74,21 +68,16 @@ class PreferenceStoreClass extends EventEmitter {
     }
 
     setPreference(category, name, value) {
-        return this.setPreferenceWithAltId(category, name, '', value);
-    }
-
-    setPreferenceWithAltId(category, name, altId, value) {
         const preferences = this.getAllPreferences();
 
-        const key = this.getKey(category, name, altId);
+        const key = this.getKey(category, name);
         let preference = preferences.get(key);
 
         if (!preference) {
             preference = {
                 user_id: UserStore.getCurrentId(),
                 category,
-                name,
+                name
-                alt_id: altId
             };
         }
         preference.value = value;

web/react/utils/async_client.jsx

@@ -638,17 +638,16 @@ export function getMyTeam() {
     );
 }
 
-export function getDirectChannels() {
+export function getDirectChannelPreferences() {
-    if (isCallInProgress('getDirectChannels')) {
+    if (isCallInProgress('getDirectChannelPreferences')) {
         return;
     }
 
-    callTracker.getDirectChannels = utils.getTimestamp();
+    callTracker.getDirectChannelPreferences = utils.getTimestamp();
-    client.getPreferencesByName(
+    client.getPreferenceCategory(
-        Constants.Preferences.CATEGORY_DIRECT_CHANNELS,
+        Constants.Preferences.CATEGORY_DIRECT_CHANNEL_SHOW,
-        Constants.Preferences.NAME_SHOW,
         (data, textStatus, xhr) => {
-            callTracker.getDirectChannels = 0;
+            callTracker.getDirectChannelPreferences = 0;
 
             if (xhr.status === 304 || !data) {
                 return;
@@ -660,14 +659,14 @@ export function getDirectChannels() {
             });
         },
         (err) => {
-            callTracker.getDirectChannels = 0;
+            callTracker.getDirectChannelPreferences = 0;
-            dispatchError(err, 'getDirectChannels');
+            dispatchError(err, 'getDirectChannelPreferences');
         }
     );
 }
 
-export function setPreferences(preferences, success, error) {
+export function savePreferences(preferences, success, error) {
-    client.setPreferences(
+    client.savePreferences(
         preferences,
         (data, textStatus, xhr) => {
             if (xhr.status !== 304) {
@@ -682,7 +681,7 @@ export function setPreferences(preferences, success, error) {
             }
         },
         (err) => {
-            dispatchError(err, 'setPreferences');
+            dispatchError(err, 'savePreferences');
 
             if (error) {
                 error();

web/react/utils/client.jsx

@@ -1142,29 +1142,29 @@ export function listIncomingHooks(success, error) {
     });
 }
 
-export function getPreferencesByName(category, name, success, error) {
+export function getPreferenceCategory(category, success, error) {
     $.ajax({
-        url: `/api/v1/preferences/${category}/${name}`,
+        url: `/api/v1/preferences/${category}`,
         dataType: 'json',
         type: 'GET',
         success,
         error: (xhr, status, err) => {
-            var e = handleError('getPreferencesByName', xhr, status, err);
+            var e = handleError('getPreferenceCategory', xhr, status, err);
             error(e);
         }
     });
 }
 
-export function setPreferences(preferences, success, error) {
+export function savePreferences(preferences, success, error) {
     $.ajax({
-        url: '/api/v1/preferences/set',
+        url: '/api/v1/preferences/save',
         dataType: 'json',
         contentType: 'application/json',
         type: 'POST',
         data: JSON.stringify(preferences),
         success,
         error: (xhr, status, err) => {
-            var e = handleError('setPreferences', xhr, status, err);
+            var e = handleError('savePreferences', xhr, status, err);
             error(e);
         }
     });

web/react/utils/constants.jsx

@@ -288,7 +288,6 @@ module.exports = {
         }
     ],
     Preferences: {
-        CATEGORY_DIRECT_CHANNELS: 'direct_channels',
+        CATEGORY_DIRECT_CHANNEL_SHOW: 'direct_channel_show'
-        NAME_SHOW: 'show'
     }
 };