Merge pull request #1164 from hmhealey/plt778

PLT-778 Changed post searching to allow searching by multiple users/channels

4 files changed, 104 insertions, 44 deletions

diff --git a/model/post_list.go b/model/post_list.go
index 862673ef3..4c0f5408e 100644
--- a/model/post_list.go
+++ b/model/post_list.go
@@ -54,6 +54,15 @@ func (o *PostList) AddPost(post *Post) {
 	o.Posts[post.Id] = post
 }
 
+func (o *PostList) Extend(other *PostList) {
+	for _, postId := range other.Order {
+		if _, ok := o.Posts[postId]; !ok {
+			o.AddPost(other.Posts[postId])
+			o.AddOrder(postId)
+		}
+	}
+}
+
 func (o *PostList) Etag() string {
 
 	id := "0"
diff --git a/model/post_list_test.go b/model/post_list_test.go
index 8a34327ce..9ce6447e1 100644
--- a/model/post_list_test.go
+++ b/model/post_list_test.go
@@ -34,3 +34,37 @@ func TestPostListJson(t *testing.T) {
 		t.Fatal("failed to serialize")
 	}
 }
+
+func TestPostListExtend(t *testing.T) {
+	l1 := PostList{}
+
+	p1 := &Post{Id: NewId(), Message: NewId()}
+	l1.AddPost(p1)
+	l1.AddOrder(p1.Id)
+
+	p2 := &Post{Id: NewId(), Message: NewId()}
+	l1.AddPost(p2)
+	l1.AddOrder(p2.Id)
+
+	l2 := PostList{}
+
+	p3 := &Post{Id: NewId(), Message: NewId()}
+	l2.AddPost(p3)
+	l2.AddOrder(p3.Id)
+
+	l2.Extend(&l1)
+
+	if len(l1.Posts) != 2 || len(l1.Order) != 2 {
+		t.Fatal("extending l2 changed l1")
+	} else if len(l2.Posts) != 3 {
+		t.Fatal("failed to extend posts l2")
+	} else if l2.Order[0] != p3.Id || l2.Order[1] != p1.Id || l2.Order[2] != p2.Id {
+		t.Fatal("failed to extend order of l2")
+	}
+
+	if len(l1.Posts) != 2 || len(l1.Order) != 2 {
+		t.Fatal("extending l2 again changed l1")
+	} else if len(l2.Posts) != 3 || len(l2.Order) != 3 {
+		t.Fatal("extending l2 again changed l2")
+	}
+}
diff --git a/model/search_params.go b/model/search_params.go
index 7eeeed10f..144e8e461 100644
--- a/model/search_params.go
+++ b/model/search_params.go
@@ -8,10 +8,10 @@ import (
 )
 
 type SearchParams struct {
-	Terms     string
-	IsHashtag bool
-	InChannel string
-	FromUser  string
+	Terms      string
+	IsHashtag  bool
+	InChannels []string
+	FromUsers  []string
 }
 
 var searchFlags = [...]string{"from", "channel", "in"}
@@ -31,9 +31,9 @@ func splitWords(text string) []string {
 	return words
 }
 
-func parseSearchFlags(input []string) ([]string, map[string]string) {
+func parseSearchFlags(input []string) ([]string, [][2]string) {
 	words := []string{}
-	flags := make(map[string]string)
+	flags := [][2]string{}
 
 	skipNextWord := false
 	for i, word := range input {
@@ -52,10 +52,10 @@ func parseSearchFlags(input []string) ([]string, map[string]string) {
 				// check for case insensitive equality
 				if strings.EqualFold(flag, searchFlag) {
 					if value != "" {
-						flags[searchFlag] = value
+						flags = append(flags, [2]string{searchFlag, value})
 						isFlag = true
 					} else if i < len(input)-1 {
-						flags[searchFlag] = input[i+1]
+						flags = append(flags, [2]string{searchFlag, input[i+1]})
 						skipNextWord = true
 						isFlag = true
 					}
@@ -75,56 +75,66 @@ func parseSearchFlags(input []string) ([]string, map[string]string) {
 	return words, flags
 }
 
-func ParseSearchParams(text string) (*SearchParams, *SearchParams) {
+func ParseSearchParams(text string) []*SearchParams {
 	words, flags := parseSearchFlags(splitWords(text))
 
-	hashtagTerms := []string{}
-	plainTerms := []string{}
+	hashtagTermList := []string{}
+	plainTermList := []string{}
 
 	for _, word := range words {
 		if validHashtag.MatchString(word) {
-			hashtagTerms = append(hashtagTerms, word)
+			hashtagTermList = append(hashtagTermList, word)
 		} else {
-			plainTerms = append(plainTerms, word)
+			plainTermList = append(plainTermList, word)
 		}
 	}
 
-	inChannel := flags["channel"]
-	if inChannel == "" {
-		inChannel = flags["in"]
+	hashtagTerms := strings.Join(hashtagTermList, " ")
+	plainTerms := strings.Join(plainTermList, " ")
+
+	inChannels := []string{}
+	fromUsers := []string{}
+
+	for _, flagPair := range flags {
+		flag := flagPair[0]
+		value := flagPair[1]
+
+		if flag == "in" || flag == "channel" {
+			inChannels = append(inChannels, value)
+		} else if flag == "from" {
+			fromUsers = append(fromUsers, value)
+		}
 	}
 
-	fromUser := flags["from"]
+	paramsList := []*SearchParams{}
 
-	var plainParams *SearchParams
 	if len(plainTerms) > 0 {
-		plainParams = &SearchParams{
-			Terms:     strings.Join(plainTerms, " "),
-			IsHashtag: false,
-			InChannel: inChannel,
-			FromUser:  fromUser,
-		}
+		paramsList = append(paramsList, &SearchParams{
+			Terms:      plainTerms,
+			IsHashtag:  false,
+			InChannels: inChannels,
+			FromUsers:  fromUsers,
+		})
 	}
 
-	var hashtagParams *SearchParams
 	if len(hashtagTerms) > 0 {
-		hashtagParams = &SearchParams{
-			Terms:     strings.Join(hashtagTerms, " "),
-			IsHashtag: true,
-			InChannel: inChannel,
-			FromUser:  fromUser,
-		}
+		paramsList = append(paramsList, &SearchParams{
+			Terms:      hashtagTerms,
+			IsHashtag:  true,
+			InChannels: inChannels,
+			FromUsers:  fromUsers,
+		})
 	}
 
 	// special case for when no terms are specified but we still have a filter
-	if plainParams == nil && hashtagParams == nil && (inChannel != "" || fromUser != "") {
-		plainParams = &SearchParams{
-			Terms:     "",
-			IsHashtag: false,
-			InChannel: inChannel,
-			FromUser:  fromUser,
-		}
+	if len(plainTerms) == 0 && len(hashtagTerms) == 0 {
+		paramsList = append(paramsList, &SearchParams{
+			Terms:      "",
+			IsHashtag:  true,
+			InChannels: inChannels,
+			FromUsers:  fromUsers,
+		})
 	}
 
-	return plainParams, hashtagParams
+	return paramsList
 }
diff --git a/model/search_params_test.go b/model/search_params_test.go
index 2eba20f4c..e03e82c5a 100644
--- a/model/search_params_test.go
+++ b/model/search_params_test.go
@@ -28,25 +28,25 @@ func TestParseSearchFlags(t *testing.T) {
 
 	if words, flags := parseSearchFlags(splitWords("apple banana from:chan")); len(words) != 2 || words[0] != "apple" || words[1] != "banana" {
 		t.Fatalf("got incorrect words %v", words)
-	} else if len(flags) != 1 || flags["from"] != "chan" {
+	} else if len(flags) != 1 || flags[0][0] != "from" || flags[0][1] != "chan" {
 		t.Fatalf("got incorrect flags %v", flags)
 	}
 
 	if words, flags := parseSearchFlags(splitWords("apple banana from: chan")); len(words) != 2 || words[0] != "apple" || words[1] != "banana" {
 		t.Fatalf("got incorrect words %v", words)
-	} else if len(flags) != 1 || flags["from"] != "chan" {
+	} else if len(flags) != 1 || flags[0][0] != "from" || flags[0][1] != "chan" {
 		t.Fatalf("got incorrect flags %v", flags)
 	}
 
 	if words, flags := parseSearchFlags(splitWords("apple banana in: chan")); len(words) != 2 || words[0] != "apple" || words[1] != "banana" {
 		t.Fatalf("got incorrect words %v", words)
-	} else if len(flags) != 1 || flags["in"] != "chan" {
+	} else if len(flags) != 1 || flags[0][0] != "in" || flags[0][1] != "chan" {
 		t.Fatalf("got incorrect flags %v", flags)
 	}
 
 	if words, flags := parseSearchFlags(splitWords("apple banana channel:chan")); len(words) != 2 || words[0] != "apple" || words[1] != "banana" {
 		t.Fatalf("got incorrect words %v", words)
-	} else if len(flags) != 1 || flags["channel"] != "chan" {
+	} else if len(flags) != 1 || flags[0][0] != "channel" || flags[0][1] != "chan" {
 		t.Fatalf("got incorrect flags %v", flags)
 	}
 
@@ -64,7 +64,14 @@ func TestParseSearchFlags(t *testing.T) {
 
 	if words, flags := parseSearchFlags(splitWords("channel: first in: second from:")); len(words) != 1 || words[0] != "from:" {
 		t.Fatalf("got incorrect words %v", words)
-	} else if len(flags) != 2 || flags["channel"] != "first" || flags["in"] != "second" {
+	} else if len(flags) != 2 || flags[0][0] != "channel" || flags[0][1] != "first" || flags[1][0] != "in" || flags[1][1] != "second" {
+		t.Fatalf("got incorrect flags %v", flags)
+	}
+
+	if words, flags := parseSearchFlags(splitWords("channel: first channel: second from: third from: fourth")); len(words) != 0 {
+		t.Fatalf("got incorrect words %v", words)
+	} else if len(flags) != 4 || flags[0][0] != "channel" || flags[0][1] != "first" || flags[1][0] != "channel" || flags[1][1] != "second" ||
+		flags[2][0] != "from" || flags[2][1] != "third" || flags[3][0] != "from" || flags[3][1] != "fourth" {
 		t.Fatalf("got incorrect flags %v", flags)
 	}
 }