+7

appview/indexer/bleve/query.go

··· 13 13 return q 14 14 } 15 15 16 16 + func MatchPhraseQuery(field, phrase, analyzer string) query.Query { 17 17 + q := bleve.NewMatchPhraseQuery(phrase) 18 18 + q.FieldVal = field 19 19 + q.Analyzer = analyzer 20 20 + return q 21 21 + } 22 22 + 16 23 func BoolFieldQuery(field string, val bool) query.Query { 17 24 q := bleve.NewBoolFieldQuery(val) 18 25 q.FieldVal = field

+69 -23

appview/indexer/issues/indexer.go

··· 84 84 85 85 docMapping.AddFieldMappingsAt("repo_at", keywordFieldMapping) 86 86 docMapping.AddFieldMappingsAt("is_open", boolFieldMapping) 87 87 + docMapping.AddFieldMappingsAt("author_did", keywordFieldMapping) 88 88 + docMapping.AddFieldMappingsAt("labels", keywordFieldMapping) 87 89 88 90 err := mapping.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{ 89 91 "type": unicodenorm.Name, ··· 168 170 return err 169 171 } 170 172 171 171 - // issueData data stored and will be indexed 172 173 type issueData struct { 173 173 - ID int64 `json:"id"` 174 174 - RepoAt string `json:"repo_at"` 175 175 - IssueID int `json:"issue_id"` 176 176 - Title string `json:"title"` 177 177 - Body string `json:"body"` 174 174 + ID int64 `json:"id"` 175 175 + RepoAt string `json:"repo_at"` 176 176 + IssueID int `json:"issue_id"` 177 177 + Title string `json:"title"` 178 178 + Body string `json:"body"` 179 179 + IsOpen bool `json:"is_open"` 180 180 + AuthorDid string `json:"author_did"` 181 181 + Labels []string `json:"labels"` 178 182 179 179 - IsOpen bool `json:"is_open"` 180 183 Comments []IssueCommentData `json:"comments"` 181 184 } 182 185 183 186 func makeIssueData(issue *models.Issue) *issueData { 184 187 return &issueData{ 185 185 - ID: issue.Id, 186 186 - RepoAt: issue.RepoAt.String(), 187 187 - IssueID: issue.IssueId, 188 188 - Title: issue.Title, 189 189 - Body: issue.Body, 190 190 - IsOpen: issue.Open, 188 188 + ID: issue.Id, 189 189 + RepoAt: issue.RepoAt.String(), 190 190 + IssueID: issue.IssueId, 191 191 + Title: issue.Title, 192 192 + Body: issue.Body, 193 193 + IsOpen: issue.Open, 194 194 + AuthorDid: issue.Did, 195 195 + Labels: issue.Labels.LabelNames(), 191 196 } 192 197 } 193 198 ··· 222 227 return ix.indexer.Delete(base36.Encode(issueId)) 223 228 } 224 229 225 225 - // Search searches for issues 226 230 func (ix *Indexer) Search(ctx context.Context, opts models.IssueSearchOptions) (*SearchResult, error) { 227 227 - var queries []query.Query 231 231 + var musts []query.Query 232 232 + var mustNots []query.Query 228 233 229 229 - if opts.Keyword != "" { 230 230 - queries = append(queries, bleve.NewDisjunctionQuery( 231 231 - bleveutil.MatchAndQuery("title", opts.Keyword, issueIndexerAnalyzer, 0), 232 232 - bleveutil.MatchAndQuery("body", opts.Keyword, issueIndexerAnalyzer, 0), 234 234 + for _, keyword := range opts.Keywords { 235 235 + musts = append(musts, bleve.NewDisjunctionQuery( 236 236 + bleveutil.MatchAndQuery("title", keyword, issueIndexerAnalyzer, 0), 237 237 + bleveutil.MatchAndQuery("body", keyword, issueIndexerAnalyzer, 0), 233 238 )) 234 239 } 235 235 - queries = append(queries, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 236 236 - queries = append(queries, bleveutil.BoolFieldQuery("is_open", opts.IsOpen)) 237 237 - // TODO: append more queries 238 240 239 239 - var indexerQuery query.Query = bleve.NewConjunctionQuery(queries...) 241 241 + for _, phrase := range opts.Phrases { 242 242 + musts = append(musts, bleve.NewDisjunctionQuery( 243 243 + bleveutil.MatchPhraseQuery("title", phrase, issueIndexerAnalyzer), 244 244 + bleveutil.MatchPhraseQuery("body", phrase, issueIndexerAnalyzer), 245 245 + )) 246 246 + } 247 247 + 248 248 + for _, keyword := range opts.NegatedKeywords { 249 249 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 250 250 + bleveutil.MatchAndQuery("title", keyword, issueIndexerAnalyzer, 0), 251 251 + bleveutil.MatchAndQuery("body", keyword, issueIndexerAnalyzer, 0), 252 252 + )) 253 253 + } 254 254 + 255 255 + for _, phrase := range opts.NegatedPhrases { 256 256 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 257 257 + bleveutil.MatchPhraseQuery("title", phrase, issueIndexerAnalyzer), 258 258 + bleveutil.MatchPhraseQuery("body", phrase, issueIndexerAnalyzer), 259 259 + )) 260 260 + } 261 261 + 262 262 + musts = append(musts, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 263 263 + if opts.IsOpen != nil { 264 264 + musts = append(musts, bleveutil.BoolFieldQuery("is_open", *opts.IsOpen)) 265 265 + } 266 266 + 267 267 + if opts.AuthorDid != "" { 268 268 + musts = append(musts, bleveutil.KeywordFieldQuery("author_did", opts.AuthorDid)) 269 269 + } 270 270 + 271 271 + for _, label := range opts.Labels { 272 272 + musts = append(musts, bleveutil.KeywordFieldQuery("labels", label)) 273 273 + } 274 274 + 275 275 + if opts.NegatedAuthorDid != "" { 276 276 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("author_did", opts.NegatedAuthorDid)) 277 277 + } 278 278 + 279 279 + for _, label := range opts.NegatedLabels { 280 280 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("labels", label)) 281 281 + } 282 282 + 283 283 + indexerQuery := bleve.NewBooleanQuery() 284 284 + indexerQuery.AddMust(musts...) 285 285 + indexerQuery.AddMustNot(mustNots...) 240 286 searchReq := bleve.NewSearchRequestOptions(indexerQuery, opts.Page.Limit, opts.Page.Offset, false) 241 287 res, err := ix.indexer.SearchInContext(ctx, searchReq) 242 288 if err != nil {

+264

appview/indexer/issues/indexer_test.go

··· 1 1 + package issues_indexer 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "os" 6 6 + "testing" 7 7 + 8 8 + "github.com/blevesearch/bleve/v2" 9 9 + "github.com/stretchr/testify/assert" 10 10 + "github.com/stretchr/testify/require" 11 11 + "tangled.org/core/appview/models" 12 12 + "tangled.org/core/appview/pagination" 13 13 + "tangled.org/core/appview/searchquery" 14 14 + ) 15 15 + 16 16 + func setupTestIndexer(t *testing.T) (*Indexer, func()) { 17 17 + t.Helper() 18 18 + 19 19 + tmpDir, err := os.MkdirTemp("", "issue_indexer_test") 20 20 + require.NoError(t, err) 21 21 + 22 22 + ix := NewIndexer(tmpDir) 23 23 + 24 24 + mapping, err := generateIssueIndexMapping() 25 25 + require.NoError(t, err) 26 26 + 27 27 + indexer, err := bleve.New(tmpDir, mapping) 28 28 + require.NoError(t, err) 29 29 + ix.indexer = indexer 30 30 + 31 31 + cleanup := func() { 32 32 + ix.indexer.Close() 33 33 + os.RemoveAll(tmpDir) 34 34 + } 35 35 + 36 36 + return ix, cleanup 37 37 + } 38 38 + 39 39 + func boolPtr(b bool) *bool { return &b } 40 40 + 41 41 + func makeLabelState(labels ...string) models.LabelState { 42 42 + state := models.NewLabelState() 43 43 + for _, label := range labels { 44 44 + state.Inner()[label] = make(map[string]struct{}) 45 45 + state.SetName(label, label) 46 46 + } 47 47 + return state 48 48 + } 49 49 + 50 50 + func TestSearchFilters(t *testing.T) { 51 51 + ix, cleanup := setupTestIndexer(t) 52 52 + defer cleanup() 53 53 + 54 54 + ctx := context.Background() 55 55 + 56 56 + err := ix.Index(ctx, 57 57 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login bug", Body: "Users cannot login", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 58 58 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Add dark mode", Body: "Implement dark theme", Open: true, Did: "did:plc:bob", Labels: makeLabelState("feature")}, 59 59 + models.Issue{Id: 3, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login timeout", Body: "Login takes too long", Open: false, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 60 60 + ) 61 61 + require.NoError(t, err) 62 62 + 63 63 + opts := func() models.IssueSearchOptions { 64 64 + return models.IssueSearchOptions{ 65 65 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 66 66 + IsOpen: boolPtr(true), 67 67 + Page: pagination.Page{Limit: 10}, 68 68 + } 69 69 + } 70 70 + 71 71 + // Keyword in title 72 72 + o := opts() 73 73 + o.Keywords = []string{"bug"} 74 74 + result, err := ix.Search(ctx, o) 75 75 + require.NoError(t, err) 76 76 + assert.Equal(t, uint64(1), result.Total) 77 77 + assert.Contains(t, result.Hits, int64(1)) 78 78 + 79 79 + // Keyword in body 80 80 + o = opts() 81 81 + o.Keywords = []string{"theme"} 82 82 + result, err = ix.Search(ctx, o) 83 83 + require.NoError(t, err) 84 84 + assert.Equal(t, uint64(1), result.Total) 85 85 + assert.Contains(t, result.Hits, int64(2)) 86 86 + 87 87 + // Phrase match 88 88 + o = opts() 89 89 + o.Phrases = []string{"login bug"} 90 90 + result, err = ix.Search(ctx, o) 91 91 + require.NoError(t, err) 92 92 + assert.Equal(t, uint64(1), result.Total) 93 93 + assert.Contains(t, result.Hits, int64(1)) 94 94 + 95 95 + // Author filter 96 96 + o = opts() 97 97 + o.AuthorDid = "did:plc:alice" 98 98 + result, err = ix.Search(ctx, o) 99 99 + require.NoError(t, err) 100 100 + assert.Equal(t, uint64(1), result.Total) 101 101 + assert.Contains(t, result.Hits, int64(1)) 102 102 + 103 103 + // Label filter 104 104 + o = opts() 105 105 + o.Labels = []string{"bug"} 106 106 + result, err = ix.Search(ctx, o) 107 107 + require.NoError(t, err) 108 108 + assert.Equal(t, uint64(1), result.Total) 109 109 + assert.Contains(t, result.Hits, int64(1)) 110 110 + 111 111 + // State filter (closed) 112 112 + o = opts() 113 113 + o.IsOpen = boolPtr(false) 114 114 + o.Labels = []string{"bug"} 115 115 + result, err = ix.Search(ctx, o) 116 116 + require.NoError(t, err) 117 117 + assert.Equal(t, uint64(1), result.Total) 118 118 + assert.Contains(t, result.Hits, int64(3)) 119 119 + 120 120 + // Combined: keyword + author + label 121 121 + o = opts() 122 122 + o.Keywords = []string{"login"} 123 123 + o.AuthorDid = "did:plc:alice" 124 124 + o.Labels = []string{"bug"} 125 125 + result, err = ix.Search(ctx, o) 126 126 + require.NoError(t, err) 127 127 + assert.Equal(t, uint64(1), result.Total) 128 128 + assert.Contains(t, result.Hits, int64(1)) 129 129 + } 130 130 + 131 131 + func TestSearchLabelAND(t *testing.T) { 132 132 + ix, cleanup := setupTestIndexer(t) 133 133 + defer cleanup() 134 134 + 135 135 + ctx := context.Background() 136 136 + 137 137 + err := ix.Index(ctx, 138 138 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Issue 1", Body: "Body", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 139 139 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Issue 2", Body: "Body", Open: true, Did: "did:plc:bob", Labels: makeLabelState("bug", "urgent")}, 140 140 + ) 141 141 + require.NoError(t, err) 142 142 + 143 143 + result, err := ix.Search(ctx, models.IssueSearchOptions{ 144 144 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 145 145 + IsOpen: boolPtr(true), 146 146 + Labels: []string{"bug", "urgent"}, 147 147 + Page: pagination.Page{Limit: 10}, 148 148 + }) 149 149 + require.NoError(t, err) 150 150 + assert.Equal(t, uint64(1), result.Total) 151 151 + assert.Contains(t, result.Hits, int64(2)) 152 152 + } 153 153 + 154 154 + func TestSearchNegation(t *testing.T) { 155 155 + ix, cleanup := setupTestIndexer(t) 156 156 + defer cleanup() 157 157 + 158 158 + ctx := context.Background() 159 159 + 160 160 + err := ix.Index(ctx, 161 161 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login bug", Body: "Users cannot login", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug")}, 162 162 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Add dark mode", Body: "Implement dark theme", Open: true, Did: "did:plc:bob", Labels: makeLabelState("feature")}, 163 163 + models.Issue{Id: 3, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix timeout bug", Body: "Timeout on save", Open: true, Did: "did:plc:alice", Labels: makeLabelState("bug", "urgent")}, 164 164 + ) 165 165 + require.NoError(t, err) 166 166 + 167 167 + opts := func() models.IssueSearchOptions { 168 168 + return models.IssueSearchOptions{ 169 169 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 170 170 + IsOpen: boolPtr(true), 171 171 + Page: pagination.Page{Limit: 10}, 172 172 + } 173 173 + } 174 174 + 175 175 + // Negated label: exclude "bug", should only return issue 2 176 176 + o := opts() 177 177 + o.NegatedLabels = []string{"bug"} 178 178 + result, err := ix.Search(ctx, o) 179 179 + require.NoError(t, err) 180 180 + assert.Equal(t, uint64(1), result.Total) 181 181 + assert.Contains(t, result.Hits, int64(2)) 182 182 + 183 183 + // Negated keyword: exclude "login", should return issues 2 and 3 184 184 + o = opts() 185 185 + o.NegatedKeywords = []string{"login"} 186 186 + result, err = ix.Search(ctx, o) 187 187 + require.NoError(t, err) 188 188 + assert.Equal(t, uint64(2), result.Total) 189 189 + assert.Contains(t, result.Hits, int64(2)) 190 190 + assert.Contains(t, result.Hits, int64(3)) 191 191 + 192 192 + // Positive label + negated label: bug but not urgent 193 193 + o = opts() 194 194 + o.Labels = []string{"bug"} 195 195 + o.NegatedLabels = []string{"urgent"} 196 196 + result, err = ix.Search(ctx, o) 197 197 + require.NoError(t, err) 198 198 + assert.Equal(t, uint64(1), result.Total) 199 199 + assert.Contains(t, result.Hits, int64(1)) 200 200 + 201 201 + // Negated phrase 202 202 + o = opts() 203 203 + o.NegatedPhrases = []string{"dark theme"} 204 204 + result, err = ix.Search(ctx, o) 205 205 + require.NoError(t, err) 206 206 + assert.Equal(t, uint64(2), result.Total) 207 207 + assert.NotContains(t, result.Hits, int64(2)) 208 208 + } 209 209 + 210 210 + func TestSearchNegatedPhraseParsed(t *testing.T) { 211 211 + ix, cleanup := setupTestIndexer(t) 212 212 + defer cleanup() 213 213 + 214 214 + ctx := context.Background() 215 215 + 216 216 + err := ix.Index(ctx, 217 217 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix login bug", Body: "Users cannot login", Open: true, Did: "did:plc:alice"}, 218 218 + models.Issue{Id: 2, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Add dark mode", Body: "Implement dark theme", Open: true, Did: "did:plc:bob"}, 219 219 + models.Issue{Id: 3, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Fix timeout bug", Body: "Timeout on save", Open: true, Did: "did:plc:alice"}, 220 220 + ) 221 221 + require.NoError(t, err) 222 222 + 223 223 + // Parse a query with a negated quoted phrase, as the handler would 224 224 + query := searchquery.Parse(`-"dark theme"`) 225 225 + var negatedPhrases []string 226 226 + for _, item := range query.Items() { 227 227 + if item.Kind == searchquery.KindQuoted && item.Negated { 228 228 + negatedPhrases = append(negatedPhrases, item.Value) 229 229 + } 230 230 + } 231 231 + require.Equal(t, []string{"dark theme"}, negatedPhrases) 232 232 + 233 233 + result, err := ix.Search(ctx, models.IssueSearchOptions{ 234 234 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 235 235 + IsOpen: boolPtr(true), 236 236 + NegatedPhrases: negatedPhrases, 237 237 + Page: pagination.Page{Limit: 10}, 238 238 + }) 239 239 + require.NoError(t, err) 240 240 + assert.Equal(t, uint64(2), result.Total) 241 241 + assert.NotContains(t, result.Hits, int64(2)) 242 242 + } 243 243 + 244 244 + func TestSearchNoResults(t *testing.T) { 245 245 + ix, cleanup := setupTestIndexer(t) 246 246 + defer cleanup() 247 247 + 248 248 + ctx := context.Background() 249 249 + 250 250 + err := ix.Index(ctx, 251 251 + models.Issue{Id: 1, RepoAt: "at://did:plc:test/sh.tangled.repo/abc", Title: "Issue", Body: "Body", Open: true, Did: "did:plc:alice"}, 252 252 + ) 253 253 + require.NoError(t, err) 254 254 + 255 255 + result, err := ix.Search(ctx, models.IssueSearchOptions{ 256 256 + Keywords: []string{"nonexistent"}, 257 257 + RepoAt: "at://did:plc:test/sh.tangled.repo/abc", 258 258 + IsOpen: boolPtr(true), 259 259 + Page: pagination.Page{Limit: 10}, 260 260 + }) 261 261 + require.NoError(t, err) 262 262 + assert.Equal(t, uint64(0), result.Total) 263 263 + assert.Empty(t, result.Hits) 264 264 + }

+69 -22

appview/indexer/pulls/indexer.go

··· 79 79 80 80 docMapping.AddFieldMappingsAt("repo_at", keywordFieldMapping) 81 81 docMapping.AddFieldMappingsAt("state", keywordFieldMapping) 82 82 + docMapping.AddFieldMappingsAt("author_did", keywordFieldMapping) 83 83 + docMapping.AddFieldMappingsAt("labels", keywordFieldMapping) 82 84 83 85 err := mapping.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{ 84 86 "type": unicodenorm.Name, ··· 163 165 return err 164 166 } 165 167 166 166 - // pullData data stored and will be indexed 167 168 type pullData struct { 168 168 - ID int64 `json:"id"` 169 169 - RepoAt string `json:"repo_at"` 170 170 - PullID int `json:"pull_id"` 171 171 - Title string `json:"title"` 172 172 - Body string `json:"body"` 173 173 - State string `json:"state"` 169 169 + ID int64 `json:"id"` 170 170 + RepoAt string `json:"repo_at"` 171 171 + PullID int `json:"pull_id"` 172 172 + Title string `json:"title"` 173 173 + Body string `json:"body"` 174 174 + State string `json:"state"` 175 175 + AuthorDid string `json:"author_did"` 176 176 + Labels []string `json:"labels"` 174 177 175 178 Comments []pullCommentData `json:"comments"` 176 179 } 177 180 178 181 func makePullData(pull *models.Pull) *pullData { 179 182 return &pullData{ 180 180 - ID: int64(pull.ID), 181 181 - RepoAt: pull.RepoAt.String(), 182 182 - PullID: pull.PullId, 183 183 - Title: pull.Title, 184 184 - Body: pull.Body, 185 185 - State: pull.State.String(), 183 183 + ID: int64(pull.ID), 184 184 + RepoAt: pull.RepoAt.String(), 185 185 + PullID: pull.PullId, 186 186 + Title: pull.Title, 187 187 + Body: pull.Body, 188 188 + State: pull.State.String(), 189 189 + AuthorDid: pull.OwnerDid, 190 190 + Labels: pull.Labels.LabelNames(), 186 191 } 187 192 } 188 193 ··· 217 222 return ix.indexer.Delete(base36.Encode(pullID)) 218 223 } 219 224 220 220 - // Search searches for pulls 221 225 func (ix *Indexer) Search(ctx context.Context, opts models.PullSearchOptions) (*searchResult, error) { 222 222 - var queries []query.Query 226 226 + var musts []query.Query 227 227 + var mustNots []query.Query 223 228 224 229 // TODO(boltless): remove this after implementing pulls page pagination 225 230 limit := opts.Page.Limit ··· 227 232 limit = 500 228 233 } 229 234 230 230 - if opts.Keyword != "" { 231 231 - queries = append(queries, bleve.NewDisjunctionQuery( 232 232 - bleveutil.MatchAndQuery("title", opts.Keyword, pullIndexerAnalyzer, 0), 233 233 - bleveutil.MatchAndQuery("body", opts.Keyword, pullIndexerAnalyzer, 0), 235 235 + for _, keyword := range opts.Keywords { 236 236 + musts = append(musts, bleve.NewDisjunctionQuery( 237 237 + bleveutil.MatchAndQuery("title", keyword, pullIndexerAnalyzer, 0), 238 238 + bleveutil.MatchAndQuery("body", keyword, pullIndexerAnalyzer, 0), 239 239 + )) 240 240 + } 241 241 + 242 242 + for _, phrase := range opts.Phrases { 243 243 + musts = append(musts, bleve.NewDisjunctionQuery( 244 244 + bleveutil.MatchPhraseQuery("title", phrase, pullIndexerAnalyzer), 245 245 + bleveutil.MatchPhraseQuery("body", phrase, pullIndexerAnalyzer), 246 246 + )) 247 247 + } 248 248 + 249 249 + for _, keyword := range opts.NegatedKeywords { 250 250 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 251 251 + bleveutil.MatchAndQuery("title", keyword, pullIndexerAnalyzer, 0), 252 252 + bleveutil.MatchAndQuery("body", keyword, pullIndexerAnalyzer, 0), 253 253 + )) 254 254 + } 255 255 + 256 256 + for _, phrase := range opts.NegatedPhrases { 257 257 + mustNots = append(mustNots, bleve.NewDisjunctionQuery( 258 258 + bleveutil.MatchPhraseQuery("title", phrase, pullIndexerAnalyzer), 259 259 + bleveutil.MatchPhraseQuery("body", phrase, pullIndexerAnalyzer), 234 260 )) 235 261 } 236 236 - queries = append(queries, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 237 237 - queries = append(queries, bleveutil.KeywordFieldQuery("state", opts.State.String())) 262 262 + 263 263 + musts = append(musts, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt)) 264 264 + if opts.State != nil { 265 265 + musts = append(musts, bleveutil.KeywordFieldQuery("state", opts.State.String())) 266 266 + } 267 267 + 268 268 + if opts.AuthorDid != "" { 269 269 + musts = append(musts, bleveutil.KeywordFieldQuery("author_did", opts.AuthorDid)) 270 270 + } 271 271 + 272 272 + for _, label := range opts.Labels { 273 273 + musts = append(musts, bleveutil.KeywordFieldQuery("labels", label)) 274 274 + } 238 275 239 239 - var indexerQuery query.Query = bleve.NewConjunctionQuery(queries...) 276 276 + if opts.NegatedAuthorDid != "" { 277 277 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("author_did", opts.NegatedAuthorDid)) 278 278 + } 279 279 + 280 280 + for _, label := range opts.NegatedLabels { 281 281 + mustNots = append(mustNots, bleveutil.KeywordFieldQuery("labels", label)) 282 282 + } 283 283 + 284 284 + indexerQuery := bleve.NewBooleanQuery() 285 285 + indexerQuery.AddMust(musts...) 286 286 + indexerQuery.AddMustNot(mustNots...) 240 287 searchReq := bleve.NewSearchRequestOptions(indexerQuery, limit, opts.Page.Offset, false) 241 288 res, err := ix.indexer.SearchInContext(ctx, searchReq) 242 289 if err != nil {

+124 -59

appview/issues/issues.go

··· 27 27 "tangled.org/core/appview/pages/repoinfo" 28 28 "tangled.org/core/appview/pagination" 29 29 "tangled.org/core/appview/reporesolver" 30 30 + "tangled.org/core/appview/searchquery" 30 31 "tangled.org/core/appview/validator" 31 32 "tangled.org/core/idresolver" 32 33 "tangled.org/core/orm" ··· 793 794 l := rp.logger.With("handler", "RepoIssues") 794 795 795 796 params := r.URL.Query() 796 796 - state := params.Get("state") 797 797 - isOpen := true 798 798 - switch state { 799 799 - case "open": 800 800 - isOpen = true 801 801 - case "closed": 802 802 - isOpen = false 803 803 - default: 804 804 - isOpen = true 805 805 - } 806 806 - 807 797 page := pagination.FromContext(r.Context()) 808 798 809 799 user := rp.oauth.GetMultiAccountUser(r) ··· 811 801 if err != nil { 812 802 l.Error("failed to get repo and knot", "err", err) 813 803 return 804 804 + } 805 805 + 806 806 + query := searchquery.Parse(params.Get("q")) 807 807 + 808 808 + var isOpen *bool 809 809 + if urlState := params.Get("state"); urlState != "" { 810 810 + switch urlState { 811 811 + case "open": 812 812 + isOpen = ptrBool(true) 813 813 + case "closed": 814 814 + isOpen = ptrBool(false) 815 815 + } 816 816 + query.Set("state", urlState) 817 817 + } else if queryState := query.Get("state"); queryState != nil { 818 818 + switch *queryState { 819 819 + case "open": 820 820 + isOpen = ptrBool(true) 821 821 + case "closed": 822 822 + isOpen = ptrBool(false) 823 823 + } 824 824 + } else if _, hasQ := params["q"]; !hasQ { 825 825 + // no q param at all -- default to open 826 826 + isOpen = ptrBool(true) 827 827 + query.Set("state", "open") 828 828 + } 829 829 + 830 830 + var authorDid string 831 831 + if authorHandle := query.Get("author"); authorHandle != nil { 832 832 + identity, err := rp.idResolver.ResolveIdent(r.Context(), *authorHandle) 833 833 + if err != nil { 834 834 + l.Debug("failed to resolve author handle", "handle", *authorHandle, "err", err) 835 835 + } else { 836 836 + authorDid = identity.DID.String() 837 837 + } 838 838 + } 839 839 + 840 840 + var negatedAuthorDid string 841 841 + if negatedAuthors := query.GetAllNegated("author"); len(negatedAuthors) > 0 { 842 842 + identity, err := rp.idResolver.ResolveIdent(r.Context(), negatedAuthors[0]) 843 843 + if err != nil { 844 844 + l.Debug("failed to resolve negated author handle", "handle", negatedAuthors[0], "err", err) 845 845 + } else { 846 846 + negatedAuthorDid = identity.DID.String() 847 847 + } 848 848 + } 849 849 + 850 850 + labels := query.GetAll("label") 851 851 + negatedLabels := query.GetAllNegated("label") 852 852 + 853 853 + var keywords, negatedKeywords []string 854 854 + var phrases, negatedPhrases []string 855 855 + for _, item := range query.Items() { 856 856 + switch item.Kind { 857 857 + case searchquery.KindKeyword: 858 858 + if item.Negated { 859 859 + negatedKeywords = append(negatedKeywords, item.Value) 860 860 + } else { 861 861 + keywords = append(keywords, item.Value) 862 862 + } 863 863 + case searchquery.KindQuoted: 864 864 + if item.Negated { 865 865 + negatedPhrases = append(negatedPhrases, item.Value) 866 866 + } else { 867 867 + phrases = append(phrases, item.Value) 868 868 + } 869 869 + } 870 870 + } 871 871 + 872 872 + searchOpts := models.IssueSearchOptions{ 873 873 + Keywords: keywords, 874 874 + Phrases: phrases, 875 875 + RepoAt: f.RepoAt().String(), 876 876 + IsOpen: isOpen, 877 877 + AuthorDid: authorDid, 878 878 + Labels: labels, 879 879 + NegatedKeywords: negatedKeywords, 880 880 + NegatedPhrases: negatedPhrases, 881 881 + NegatedLabels: negatedLabels, 882 882 + NegatedAuthorDid: negatedAuthorDid, 883 883 + Page: page, 814 884 } 815 885 816 886 totalIssues := 0 817 817 - if isOpen { 887 887 + if isOpen == nil { 888 888 + totalIssues = f.RepoStats.IssueCount.Open + f.RepoStats.IssueCount.Closed 889 889 + } else if *isOpen { 818 890 totalIssues = f.RepoStats.IssueCount.Open 819 891 } else { 820 892 totalIssues = f.RepoStats.IssueCount.Closed 821 893 } 822 894 823 823 - keyword := params.Get("q") 824 824 - 825 825 - repoInfo := rp.repoResolver.GetRepoInfo(r, user) 826 826 - 827 895 var issues []models.Issue 828 828 - searchOpts := models.IssueSearchOptions{ 829 829 - Keyword: keyword, 830 830 - RepoAt: f.RepoAt().String(), 831 831 - IsOpen: isOpen, 832 832 - Page: page, 833 833 - } 834 834 - if keyword != "" { 896 896 + 897 897 + if searchOpts.HasSearchFilters() { 835 898 res, err := rp.indexer.Search(r.Context(), searchOpts) 836 899 if err != nil { 837 900 l.Error("failed to search for issues", "err", err) ··· 840 903 l.Debug("searched issues with indexer", "count", len(res.Hits)) 841 904 totalIssues = int(res.Total) 842 905 843 843 - // count matching issues in the opposite state to display correct counts 844 844 - countRes, err := rp.indexer.Search(r.Context(), models.IssueSearchOptions{ 845 845 - Keyword: keyword, RepoAt: f.RepoAt().String(), IsOpen: !isOpen, 846 846 - Page: pagination.Page{Limit: 1}, 847 847 - }) 848 848 - if err == nil { 849 849 - if isOpen { 850 850 - repoInfo.Stats.IssueCount.Open = int(res.Total) 851 851 - repoInfo.Stats.IssueCount.Closed = int(countRes.Total) 852 852 - } else { 853 853 - repoInfo.Stats.IssueCount.Closed = int(res.Total) 854 854 - repoInfo.Stats.IssueCount.Open = int(countRes.Total) 906 906 + if len(res.Hits) > 0 { 907 907 + issues, err = db.GetIssues( 908 908 + rp.db, 909 909 + orm.FilterIn("id", res.Hits), 910 910 + ) 911 911 + if err != nil { 912 912 + l.Error("failed to get issues", "err", err) 913 913 + rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") 914 914 + return 855 915 } 856 916 } 857 857 - 858 858 - issues, err = db.GetIssues( 859 859 - rp.db, 860 860 - orm.FilterIn("id", res.Hits), 861 861 - ) 862 862 - if err != nil { 863 863 - l.Error("failed to get issues", "err", err) 864 864 - rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") 865 865 - return 917 917 + } else { 918 918 + filters := []orm.Filter{ 919 919 + orm.FilterEq("repo_at", f.RepoAt()), 866 920 } 867 867 - 868 868 - } else { 869 869 - openInt := 0 870 870 - if isOpen { 871 871 - openInt = 1 921 921 + if isOpen != nil { 922 922 + openInt := 0 923 923 + if *isOpen { 924 924 + openInt = 1 925 925 + } 926 926 + filters = append(filters, orm.FilterEq("open", openInt)) 872 927 } 873 928 issues, err = db.GetIssuesPaginated( 874 929 rp.db, 875 930 page, 876 876 - orm.FilterEq("repo_at", f.RepoAt()), 877 877 - orm.FilterEq("open", openInt), 931 931 + filters..., 878 932 ) 879 933 if err != nil { 880 934 l.Error("failed to get issues", "err", err) ··· 899 953 defs[l.AtUri().String()] = &l 900 954 } 901 955 956 956 + filterState := "" 957 957 + if isOpen != nil { 958 958 + if *isOpen { 959 959 + filterState = "open" 960 960 + } else { 961 961 + filterState = "closed" 962 962 + } 963 963 + } 964 964 + 902 965 rp.pages.RepoIssues(w, pages.RepoIssuesParams{ 903 903 - LoggedInUser: rp.oauth.GetMultiAccountUser(r), 904 904 - RepoInfo: repoInfo, 905 905 - Issues: issues, 906 906 - IssueCount: totalIssues, 907 907 - LabelDefs: defs, 908 908 - FilteringByOpen: isOpen, 909 909 - FilterQuery: keyword, 910 910 - Page: page, 966 966 + LoggedInUser: rp.oauth.GetMultiAccountUser(r), 967 967 + RepoInfo: rp.repoResolver.GetRepoInfo(r, user), 968 968 + Issues: issues, 969 969 + IssueCount: totalIssues, 970 970 + LabelDefs: defs, 971 971 + FilterState: filterState, 972 972 + FilterQuery: query.String(), 973 973 + Page: page, 911 974 }) 912 975 } 976 976 + 977 977 + func ptrBool(b bool) *bool { return &b } 913 978 914 979 func (rp *Issues) NewIssue(w http.ResponseWriter, r *http.Request) { 915 980 l := rp.logger.With("handler", "NewIssue")

+35 -17

appview/models/search.go

··· 3 3 import "tangled.org/core/appview/pagination" 4 4 5 5 type IssueSearchOptions struct { 6 6 - Keyword string 7 7 - RepoAt string 8 8 - IsOpen bool 6 6 + Keywords []string 7 7 + Phrases []string 8 8 + RepoAt string 9 9 + IsOpen *bool 10 10 + AuthorDid string 11 11 + Labels []string 12 12 + 13 13 + NegatedKeywords []string 14 14 + NegatedPhrases []string 15 15 + NegatedLabels []string 16 16 + NegatedAuthorDid string 9 17 10 18 Page pagination.Page 11 19 } 12 20 21 21 + func (o *IssueSearchOptions) HasSearchFilters() bool { 22 22 + return len(o.Keywords) > 0 || len(o.Phrases) > 0 || 23 23 + o.AuthorDid != "" || o.NegatedAuthorDid != "" || 24 24 + len(o.Labels) > 0 || len(o.NegatedLabels) > 0 || 25 25 + len(o.NegatedKeywords) > 0 || len(o.NegatedPhrases) > 0 26 26 + } 27 27 + 13 28 type PullSearchOptions struct { 14 14 - Keyword string 15 15 - RepoAt string 16 16 - State PullState 29 29 + Keywords []string 30 30 + Phrases []string 31 31 + RepoAt string 32 32 + State *PullState 33 33 + AuthorDid string 34 34 + Labels []string 35 35 + 36 36 + NegatedKeywords []string 37 37 + NegatedPhrases []string 38 38 + NegatedLabels []string 39 39 + NegatedAuthorDid string 17 40 18 41 Page pagination.Page 19 42 } 20 43 21 21 - // func (so *SearchOptions) ToFilters() []filter { 22 22 - // var filters []filter 23 23 - // if so.IsOpen != nil { 24 24 - // openValue := 0 25 25 - // if *so.IsOpen { 26 26 - // openValue = 1 27 27 - // } 28 28 - // filters = append(filters, FilterEq("open", openValue)) 29 29 - // } 30 30 - // return filters 31 31 - // } 44 44 + func (o *PullSearchOptions) HasSearchFilters() bool { 45 45 + return len(o.Keywords) > 0 || len(o.Phrases) > 0 || 46 46 + o.AuthorDid != "" || o.NegatedAuthorDid != "" || 47 47 + len(o.Labels) > 0 || len(o.NegatedLabels) > 0 || 48 48 + len(o.NegatedKeywords) > 0 || len(o.NegatedPhrases) > 0 49 49 + }

+10 -10

appview/pages/pages.go

··· 965 965 } 966 966 967 967 type RepoIssuesParams struct { 968 968 - LoggedInUser *oauth.MultiAccountUser 969 969 - RepoInfo repoinfo.RepoInfo 970 970 - Active string 971 971 - Issues []models.Issue 972 972 - IssueCount int 973 973 - LabelDefs map[string]*models.LabelDefinition 974 974 - Page pagination.Page 975 975 - FilteringByOpen bool 976 976 - FilterQuery string 968 968 + LoggedInUser *oauth.MultiAccountUser 969 969 + RepoInfo repoinfo.RepoInfo 970 970 + Active string 971 971 + Issues []models.Issue 972 972 + IssueCount int 973 973 + LabelDefs map[string]*models.LabelDefinition 974 974 + Page pagination.Page 975 975 + FilterState string 976 976 + FilterQuery string 977 977 } 978 978 979 979 func (p *Pages) RepoIssues(w io.Writer, params RepoIssuesParams) error { ··· 1103 1103 RepoInfo repoinfo.RepoInfo 1104 1104 Pulls []*models.Pull 1105 1105 Active string 1106 1106 - FilteringBy models.PullState 1106 1106 + FilterState string 1107 1107 FilterQuery string 1108 1108 Stacks map[string]models.Stack 1109 1109 Pipelines map[string]models.Pipeline

+23 -1

appview/pages/templates/fragments/tabSelector.html

··· 3 3 {{ $all := .Values }} 4 4 {{ $active := .Active }} 5 5 {{ $include := .Include }} 6 6 + {{ $form := .Form }} 6 7 <div class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden"> 7 8 {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }} 8 9 {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }} 9 10 {{ range $index, $value := $all }} 10 11 {{ $isActive := eq $value.Key $active }} 12 12 + {{ if $form }} 13 13 + <button type="submit" 14 14 + form="{{ $form }}" 15 15 + name="{{ $name }}" value="{{ $value.Key }}" 16 16 + hx-get="?{{ $name }}={{ $value.Key }}" 17 17 + hx-include="{{ $include }}" 18 18 + hx-push-url="true" 19 19 + hx-target="body" 20 20 + hx-on:htmx:config-request="if(!event.detail.parameters.q) delete event.detail.parameters.q" 21 21 + class="p-2 whitespace-nowrap flex justify-center items-center gap-2 text-sm w-full hover:no-underline text-center {{ if $isActive }} {{$activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}"> 22 22 + {{ if $value.Icon }} 23 23 + {{ i $value.Icon "size-4" }} 24 24 + {{ end }} 25 25 + 26 26 + {{ with $value.Meta }} 27 27 + {{ . }} 28 28 + {{ end }} 29 29 + 30 30 + {{ $value.Value }} 31 31 + </button> 32 32 + {{ else }} 11 33 <a href="?{{ $name }}={{ $value.Key }}" 12 34 {{ if $include }} 13 35 hx-get="?{{ $name }}={{ $value.Key }}" ··· 27 49 28 50 {{ $value.Value }} 29 51 </a> 52 52 + {{ end }} 30 53 {{ end }} 31 54 </div> 32 55 {{ end }} 33 33 -

+10 -18

appview/pages/templates/repo/issues/issues.html

··· 8 8 {{ end }} 9 9 10 10 {{ define "repoContent" }} 11 11 - {{ $active := "closed" }} 12 12 - {{ if .FilteringByOpen }} 13 13 - {{ $active = "open" }} 14 14 - {{ end }} 11 11 + {{ $active := .FilterState }} 15 12 16 16 - {{ $open := 13 13 + {{ $open := 17 14 (dict 18 15 "Key" "open" 19 16 "Value" "open" 20 17 "Icon" "circle-dot" 21 18 "Meta" (string .RepoInfo.Stats.IssueCount.Open)) }} 22 22 - {{ $closed := 19 19 + {{ $closed := 23 20 (dict 24 21 "Key" "closed" 25 22 "Value" "closed" ··· 28 25 {{ $values := list $open $closed }} 29 26 30 27 <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2"> 31 31 - <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 32 32 - <input type="hidden" name="state" value="{{ if .FilteringByOpen }}open{{ else }}closed{{ end }}"> 28 28 + <form id="search-form" class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 33 29 <div class="flex-1 flex relative"> 34 30 <input 35 31 id="search-q" ··· 40 36 placeholder="search issues..." 41 37 > 42 38 <a 43 43 - href="?state={{ if .FilteringByOpen }}open{{ else }}closed{{ end }}" 39 39 + {{ if $active }}href="?q=state:{{ $active }}"{{ else }}href="?"{{ end }} 44 40 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block" 45 41 > 46 42 {{ i "x" "w-4 h-4" }} ··· 54 50 </button> 55 51 </form> 56 52 <div class="sm:row-start-1"> 57 57 - {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }} 53 53 + {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q" "Form" "search-form") }} 58 54 </div> 59 55 <a 60 56 href="/{{ .RepoInfo.FullName }}/issues/new" ··· 72 68 {{ template "repo/issues/fragments/issueListing" (dict "Issues" .Issues "RepoPrefix" .RepoInfo.FullName "LabelDefs" .LabelDefs) }} 73 69 </div> 74 70 {{if gt .IssueCount .Page.Limit }} 75 75 - {{ $state := "closed" }} 76 76 - {{ if .FilteringByOpen }} 77 77 - {{ $state = "open" }} 78 78 - {{ end }} 79 79 - {{ template "fragments/pagination" (dict 80 80 - "Page" .Page 81 81 - "TotalCount" .IssueCount 71 71 + {{ template "fragments/pagination" (dict 72 72 + "Page" .Page 73 73 + "TotalCount" .IssueCount 82 74 "BasePath" (printf "/%s/issues" .RepoInfo.FullName) 83 83 - "QueryParams" (queryParams "state" $state "q" .FilterQuery) 75 75 + "QueryParams" (queryParams "q" .FilterQuery) 84 76 ) }} 85 77 {{ end }} 86 78 {{ end }}

+11 -17

appview/pages/templates/repo/pulls/pulls.html

··· 8 8 {{ end }} 9 9 10 10 {{ define "repoContent" }} 11 11 - {{ $active := "closed" }} 12 12 - {{ if .FilteringBy.IsOpen }} 13 13 - {{ $active = "open" }} 14 14 - {{ else if .FilteringBy.IsMerged }} 15 15 - {{ $active = "merged" }} 16 16 - {{ end }} 17 17 - {{ $open := 11 11 + {{ $active := .FilterState }} 12 12 + {{ $open := 18 13 (dict 19 14 "Key" "open" 20 15 "Value" "open" 21 16 "Icon" "git-pull-request" 22 17 "Meta" (string .RepoInfo.Stats.PullCount.Open)) }} 23 23 - {{ $merged := 18 18 + {{ $merged := 24 19 (dict 25 20 "Key" "merged" 26 21 "Value" "merged" 27 22 "Icon" "git-merge" 28 23 "Meta" (string .RepoInfo.Stats.PullCount.Merged)) }} 29 29 - {{ $closed := 24 24 + {{ $closed := 30 25 (dict 31 26 "Key" "closed" 32 27 "Value" "closed" ··· 34 29 "Meta" (string .RepoInfo.Stats.PullCount.Closed)) }} 35 30 {{ $values := list $open $merged $closed }} 36 31 <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2"> 37 37 - <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 38 38 - <input type="hidden" name="state" value="{{ .FilteringBy.String }}"> 32 32 + <form id="search-form" class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET"> 39 33 <div class="flex-1 flex relative"> 40 34 <input 41 35 id="search-q" ··· 46 40 placeholder="search pulls..." 47 41 > 48 42 <a 49 49 - href="?state={{ .FilteringBy.String }}" 43 43 + {{ if $active }}href="?q=state:{{ $active }}"{{ else }}href="?"{{ end }} 50 44 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block" 51 45 > 52 46 {{ i "x" "w-4 h-4" }} ··· 60 54 </button> 61 55 </form> 62 56 <div class="sm:row-start-1"> 63 63 - {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }} 57 57 + {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q" "Form" "search-form") }} 64 58 </div> 65 59 <a 66 60 href="/{{ .RepoInfo.FullName }}/pulls/new" ··· 162 156 {{ end }} 163 157 </div> 164 158 {{if gt .PullCount .Page.Limit }} 165 165 - {{ template "fragments/pagination" (dict 166 166 - "Page" .Page 167 167 - "TotalCount" .PullCount 159 159 + {{ template "fragments/pagination" (dict 160 160 + "Page" .Page 161 161 + "TotalCount" .PullCount 168 162 "BasePath" (printf "/%s/pulls" .RepoInfo.FullName) 169 169 - "QueryParams" (queryParams "state" .FilteringBy.String "q" .FilterQuery) 163 163 + "QueryParams" (queryParams "q" .FilterQuery) 170 164 ) }} 171 165 {{ end }} 172 166 {{ end }}

+124 -39

appview/pulls/pulls.go

··· 31 31 "tangled.org/core/appview/pages/repoinfo" 32 32 "tangled.org/core/appview/pagination" 33 33 "tangled.org/core/appview/reporesolver" 34 34 + "tangled.org/core/appview/searchquery" 34 35 "tangled.org/core/appview/validator" 35 36 "tangled.org/core/appview/xrpcclient" 36 37 "tangled.org/core/idresolver" ··· 524 525 525 526 user := s.oauth.GetMultiAccountUser(r) 526 527 params := r.URL.Query() 527 527 - 528 528 - state := models.PullOpen 529 529 - switch params.Get("state") { 530 530 - case "closed": 531 531 - state = models.PullClosed 532 532 - case "merged": 533 533 - state = models.PullMerged 534 534 - } 535 535 - 536 528 page := pagination.FromContext(r.Context()) 537 529 538 530 f, err := s.repoResolver.Resolve(r) ··· 541 533 return 542 534 } 543 535 544 544 - var totalPulls int 545 545 - switch state { 546 546 - case models.PullOpen: 547 547 - totalPulls = f.RepoStats.PullCount.Open 548 548 - case models.PullMerged: 549 549 - totalPulls = f.RepoStats.PullCount.Merged 550 550 - case models.PullClosed: 551 551 - totalPulls = f.RepoStats.PullCount.Closed 536 536 + query := searchquery.Parse(params.Get("q")) 537 537 + 538 538 + var state *models.PullState 539 539 + if urlState := params.Get("state"); urlState != "" { 540 540 + switch urlState { 541 541 + case "open": 542 542 + state = ptrPullState(models.PullOpen) 543 543 + case "closed": 544 544 + state = ptrPullState(models.PullClosed) 545 545 + case "merged": 546 546 + state = ptrPullState(models.PullMerged) 547 547 + } 548 548 + query.Set("state", urlState) 549 549 + } else if queryState := query.Get("state"); queryState != nil { 550 550 + switch *queryState { 551 551 + case "open": 552 552 + state = ptrPullState(models.PullOpen) 553 553 + case "closed": 554 554 + state = ptrPullState(models.PullClosed) 555 555 + case "merged": 556 556 + state = ptrPullState(models.PullMerged) 557 557 + } 558 558 + } else if _, hasQ := params["q"]; !hasQ { 559 559 + state = ptrPullState(models.PullOpen) 560 560 + query.Set("state", "open") 552 561 } 553 562 554 554 - keyword := params.Get("q") 563 563 + var authorDid string 564 564 + if authorHandle := query.Get("author"); authorHandle != nil { 565 565 + identity, err := s.idResolver.ResolveIdent(r.Context(), *authorHandle) 566 566 + if err != nil { 567 567 + l.Debug("failed to resolve author handle", "handle", *authorHandle, "err", err) 568 568 + } else { 569 569 + authorDid = identity.DID.String() 570 570 + } 571 571 + } 555 572 556 556 - var pulls []*models.Pull 573 573 + var negatedAuthorDid string 574 574 + if negatedAuthors := query.GetAllNegated("author"); len(negatedAuthors) > 0 { 575 575 + identity, err := s.idResolver.ResolveIdent(r.Context(), negatedAuthors[0]) 576 576 + if err != nil { 577 577 + l.Debug("failed to resolve negated author handle", "handle", negatedAuthors[0], "err", err) 578 578 + } else { 579 579 + negatedAuthorDid = identity.DID.String() 580 580 + } 581 581 + } 582 582 + 583 583 + labels := query.GetAll("label") 584 584 + negatedLabels := query.GetAllNegated("label") 585 585 + 586 586 + var keywords, negatedKeywords []string 587 587 + var phrases, negatedPhrases []string 588 588 + for _, item := range query.Items() { 589 589 + switch item.Kind { 590 590 + case searchquery.KindKeyword: 591 591 + if item.Negated { 592 592 + negatedKeywords = append(negatedKeywords, item.Value) 593 593 + } else { 594 594 + keywords = append(keywords, item.Value) 595 595 + } 596 596 + case searchquery.KindQuoted: 597 597 + if item.Negated { 598 598 + negatedPhrases = append(negatedPhrases, item.Value) 599 599 + } else { 600 600 + phrases = append(phrases, item.Value) 601 601 + } 602 602 + } 603 603 + } 604 604 + 557 605 searchOpts := models.PullSearchOptions{ 558 558 - Keyword: keyword, 559 559 - RepoAt: f.RepoAt().String(), 560 560 - State: state, 561 561 - Page: page, 606 606 + Keywords: keywords, 607 607 + Phrases: phrases, 608 608 + RepoAt: f.RepoAt().String(), 609 609 + State: state, 610 610 + AuthorDid: authorDid, 611 611 + Labels: labels, 612 612 + NegatedKeywords: negatedKeywords, 613 613 + NegatedPhrases: negatedPhrases, 614 614 + NegatedLabels: negatedLabels, 615 615 + NegatedAuthorDid: negatedAuthorDid, 616 616 + Page: page, 562 617 } 563 563 - l.Debug("searching with", "searchOpts", searchOpts) 564 564 - if keyword != "" { 618 618 + 619 619 + var totalPulls int 620 620 + if state == nil { 621 621 + totalPulls = f.RepoStats.PullCount.Open + f.RepoStats.PullCount.Merged + f.RepoStats.PullCount.Closed 622 622 + } else { 623 623 + switch *state { 624 624 + case models.PullOpen: 625 625 + totalPulls = f.RepoStats.PullCount.Open 626 626 + case models.PullMerged: 627 627 + totalPulls = f.RepoStats.PullCount.Merged 628 628 + case models.PullClosed: 629 629 + totalPulls = f.RepoStats.PullCount.Closed 630 630 + } 631 631 + } 632 632 + 633 633 + var pulls []*models.Pull 634 634 + 635 635 + if searchOpts.HasSearchFilters() { 565 636 res, err := s.indexer.Search(r.Context(), searchOpts) 566 637 if err != nil { 567 638 l.Error("failed to search for pulls", "err", err) ··· 570 641 totalPulls = int(res.Total) 571 642 l.Debug("searched pulls with indexer", "count", len(res.Hits)) 572 643 573 573 - pulls, err = db.GetPulls( 574 574 - s.db, 575 575 - orm.FilterIn("id", res.Hits), 576 576 - ) 577 577 - if err != nil { 578 578 - log.Println("failed to get pulls", err) 579 579 - s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.") 580 580 - return 644 644 + if len(res.Hits) > 0 { 645 645 + pulls, err = db.GetPulls( 646 646 + s.db, 647 647 + orm.FilterIn("id", res.Hits), 648 648 + ) 649 649 + if err != nil { 650 650 + l.Error("failed to get pulls", "err", err) 651 651 + s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.") 652 652 + return 653 653 + } 581 654 } 582 655 } else { 656 656 + filters := []orm.Filter{ 657 657 + orm.FilterEq("repo_at", f.RepoAt()), 658 658 + } 659 659 + if state != nil { 660 660 + filters = append(filters, orm.FilterEq("state", *state)) 661 661 + } 583 662 pulls, err = db.GetPullsPaginated( 584 663 s.db, 585 664 page, 586 586 - orm.FilterEq("repo_at", f.RepoAt()), 587 587 - orm.FilterEq("state", searchOpts.State), 665 665 + filters..., 588 666 ) 589 667 if err != nil { 590 590 - log.Println("failed to get pulls", err) 668 668 + l.Error("failed to get pulls", "err", err) 591 669 s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.") 592 670 return 593 671 } ··· 656 734 orm.FilterContains("scope", tangled.RepoPullNSID), 657 735 ) 658 736 if err != nil { 659 659 - log.Println("failed to fetch labels", err) 737 737 + l.Error("failed to fetch labels", "err", err) 660 738 s.pages.Error503(w) 661 739 return 662 740 } ··· 666 744 defs[l.AtUri().String()] = &l 667 745 } 668 746 747 747 + filterState := "" 748 748 + if state != nil { 749 749 + filterState = state.String() 750 750 + } 751 751 + 669 752 s.pages.RepoPulls(w, pages.RepoPullsParams{ 670 753 LoggedInUser: s.oauth.GetMultiAccountUser(r), 671 754 RepoInfo: s.repoResolver.GetRepoInfo(r, user), 672 755 Pulls: pulls, 673 756 LabelDefs: defs, 674 674 - FilteringBy: state, 675 675 - FilterQuery: keyword, 757 757 + FilterState: filterState, 758 758 + FilterQuery: query.String(), 676 759 Stacks: stacks, 677 760 Pipelines: m, 678 761 Page: page, ··· 2450 2533 w.Close() 2451 2534 return &b 2452 2535 } 2536 2536 + 2537 2537 + func ptrPullState(s models.PullState) *models.PullState { return &s }