patch of appview: add issue search endpoint · round #2 · pull #496 · tangled.org/core

+84 -37

appview/db/issues.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"database/sql"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	"strconv"

     

       6
       7
        
       	"strings"

     

       7
       8
        
       	"time"

     

       8
       9
        
       

     

       9
       10
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
       11
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       12
       12
       +
       	"tangled.sh/tangled.sh/core/appview/models"

     

       11
       13
        
       	"tangled.sh/tangled.sh/core/appview/pagination"

     

       12
       14
        
       )

     

       13
       15
        
       

     
···

       162
       164
        
       	return issues, nil

     

       163
       165
        
       }

     

       164
       166
        
       

     

       165
       165
       -
       func GetIssuesPaginated(e Execer, repoAt syntax.ATURI, isOpen bool, page pagination.Page) ([]Issue, error) {

     

       166
       166
       -
       	var issues []Issue

     

       167
       167
       +
       // GetIssueIDs gets list of all existing issue's IDs

     

       168
       168
       +
       func GetIssueIDs(e Execer, opts models.IssueSearchOptions) ([]int64, error) {

     

       169
       169
       +
       	var ids []int64

     

       170
       170
       +
       

     

       171
       171
       +
       	var filters []filter

     

       167
       172
        
       	openValue := 0

     

       168
       168
       -
       	if isOpen {

     

       173
       173
       +
       	if opts.IsOpen {

     

       169
       174
        
       		openValue = 1

     

       170
       175
        
       	}

     

       176
       176
       +
       	filters = append(filters, FilterEq("open", openValue))

     

       177
       177
       +
       	if opts.RepoAt != "" {

     

       178
       178
       +
       		filters = append(filters, FilterEq("repo_at", opts.RepoAt))

     

       179
       179
       +
       	}

     

       171
       180
        
       

     

       172
       172
       -
       	rows, err := e.Query(

     

       181
       181
       +
       	var conditions []string

     

       182
       182
       +
       	var args []any

     

       183
       183
       +
       

     

       184
       184
       +
       	for _, filter := range filters {

     

       185
       185
       +
       		conditions = append(conditions, filter.Condition())

     

       186
       186
       +
       		args = append(args, filter.Arg()...)

     

       187
       187
       +
       	}

     

       188
       188
       +
       

     

       189
       189
       +
       	whereClause := ""

     

       190
       190
       +
       	if conditions != nil {

     

       191
       191
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       192
       192
       +
       	}

     

       193
       193
       +
       	query := fmt.Sprintf(

     

       173
       194
        
       		`

     

       174
       174
       -
       		with numbered_issue as (

     

       175
       175
       -
       			select

     

       176
       176
       -
       				i.id,

     

       177
       177
       -
       				i.owner_did,

     

       178
       178
       -
       				i.rkey,

     

       179
       179
       -
       				i.issue_id,

     

       180
       180
       -
       				i.created,

     

       181
       181
       -
       				i.title,

     

       182
       182
       -
       				i.body,

     

       183
       183
       -
       				i.open,

     

       184
       184
       -
       				count(c.id) as comment_count,

     

       185
       185
       -
       				row_number() over (order by i.created desc) as row_num

     

       186
       186
       -
       			from

     

       187
       187
       -
       				issues i

     

       188
       188
       -
       			left join

     

       189
       189
       -
       				comments c on i.repo_at = c.repo_at and i.issue_id = c.issue_id

     

       190
       190
       -
       			where

     

       191
       191
       -
       				i.repo_at = ? and i.open = ?

     

       192
       192
       -
       			group by

     

       193
       193
       -
       				i.id, i.owner_did, i.issue_id, i.created, i.title, i.body, i.open

     

       194
       194
       -
       		)

     

       195
       195
        
       		select

     

       196
       196
       -
       			id,

     

       197
       197
       -
       			owner_did,

     

       198
       198
       -
       			rkey,

     

       199
       199
       -
       			issue_id,

     

       200
       200
       -
       			created,

     

       201
       201
       -
       			title,

     

       202
       202
       -
       			body,

     

       203
       203
       -
       			open,

     

       204
       204
       -
       			comment_count

     

       196
       196
       +
       			id

     

       205
       197
        
       		from

     

       206
       206
       -
       			numbered_issue

     

       198
       198
       +
       			issues

     

       199
       199
       +
       		%s

     

       200
       200
       +
       		limit ? offset ?`,

     

       201
       201
       +
       		whereClause,

     

       202
       202
       +
       	)

     

       203
       203
       +
       	args = append(args, opts.Page.Limit, opts.Page.Offset)

     

       204
       204
       +
       	rows, err := e.Query(query, args...)

     

       205
       205
       +
       	if err != nil {

     

       206
       206
       +
       		return nil, err

     

       207
       207
       +
       	}

     

       208
       208
       +
       	defer rows.Close()

     

       209
       209
       +
       

     

       210
       210
       +
       	for rows.Next() {

     

       211
       211
       +
       		var id int64

     

       212
       212
       +
       		err := rows.Scan(&id)

     

       213
       213
       +
       		if err != nil {

     

       214
       214
       +
       			return nil, err

     

       215
       215
       +
       		}

     

       216
       216
       +
       

     

       217
       217
       +
       		ids = append(ids, id)

     

       218
       218
       +
       	}

     

       219
       219
       +
       

     

       220
       220
       +
       	return ids, nil

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       // GetIssuesByIDs gets list of issues from given IDs

     

       224
       224
       +
       func GetIssuesByIDs(e Execer, ids []int64) ([]Issue, error) {

     

       225
       225
       +
       	var issues []Issue

     

       226
       226
       +
       

     

       227
       227
       +
       	// HACK: would be better to create "?,?,?,..." or use something like sqlx

     

       228
       228
       +
       	idStrings := make([]string, len(ids))

     

       229
       229
       +
       	for i, id := range ids {

     

       230
       230
       +
       		idStrings[i] = strconv.FormatInt(id, 10)

     

       231
       231
       +
       	}

     

       232
       232
       +
       	idList := strings.Join(idStrings, ",")

     

       233
       233
       +
       	query := fmt.Sprintf(

     

       234
       234
       +
       		`

     

       235
       235
       +
       		select

     

       236
       236
       +
       			i.id,

     

       237
       237
       +
       			i.owner_did,

     

       238
       238
       +
       			i.rkey,

     

       239
       239
       +
       			i.issue_id,

     

       240
       240
       +
       			i.created,

     

       241
       241
       +
       			i.title,

     

       242
       242
       +
       			i.body,

     

       243
       243
       +
       			i.open,

     

       244
       244
       +
       			count(c.id) as comment_count

     

       245
       245
       +
       		from

     

       246
       246
       +
       			issues i

     

       247
       247
       +
       		left join

     

       248
       248
       +
       			comments c on i.repo_at = c.repo_at and i.issue_id = c.issue_id

     

       207
       249
        
       		where

     

       208
       208
       -
       			row_num between ? and ?`,

     

       209
       209
       -
       		repoAt, openValue, page.Offset+1, page.Offset+page.Limit)

     

       250
       250
       +
       			i.id in (%s)

     

       251
       251
       +
       		group by

     

       252
       252
       +
       			i.id

     

       253
       253
       +
       		order by i.created desc`,

     

       254
       254
       +
       		idList,

     

       255
       255
       +
       	)

     

       256
       256
       +
       	rows, err := e.Query(query)

     

       210
       257
        
       	if err != nil {

     

       211
       258
        
       		return nil, err

     

       212
       259
        
       	}

+28 -1

appview/issues/issues.go

···

       19
       19
        
       	"tangled.sh/tangled.sh/core/appview/config"

     

       20
       20
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       21
       21
        
       	issues_indexer "tangled.sh/tangled.sh/core/appview/indexer/issues"

     

       22
       22
       +
       	"tangled.sh/tangled.sh/core/appview/models"

     

       22
       23
        
       	"tangled.sh/tangled.sh/core/appview/notify"

     

       23
       24
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       24
       25
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     
···

       608
       609
        
       		return

     

       609
       610
        
       	}

     

       610
       611
        
       

     

       611
       611
       -
       	issues, err := db.GetIssuesPaginated(rp.db, f.RepoAt(), isOpen, page)

     

       612
       612
       +
       	keyword := params.Get("q")

     

       613
       613
       +
       

     

       614
       614
       +
       	var ids []int64

     

       615
       615
       +
       	searchOpts := models.IssueSearchOptions{

     

       616
       616
       +
       		Keyword: keyword,

     

       617
       617
       +
       		RepoAt: f.RepoAt().String(),

     

       618
       618
       +
       		IsOpen: isOpen,

     

       619
       619
       +
       		Page: page,

     

       620
       620
       +
       	}

     

       621
       621
       +
       	if keyword != "" {

     

       622
       622
       +
       		res, err := rp.indexer.Search(r.Context(), searchOpts)

     

       623
       623
       +
       		if err != nil {

     

       624
       624
       +
       			log.Println("failed to search for issues", err)

     

       625
       625
       +
       			return

     

       626
       626
       +
       		}

     

       627
       627
       +
       		log.Println("searched issues:", res.Hits)

     

       628
       628
       +
       		ids = res.Hits

     

       629
       629
       +
       	} else {

     

       630
       630
       +
       		ids, err = db.GetIssueIDs(rp.db, searchOpts)

     

       631
       631
       +
       		if err != nil {

     

       632
       632
       +
       			log.Println("failed to search for issues", err)

     

       633
       633
       +
       			return

     

       634
       634
       +
       		}

     

       635
       635
       +
       	}

     

       636
       636
       +
       

     

       637
       637
       +
       	issues, err := db.GetIssuesByIDs(rp.db, ids)

     

       612
       638
        
       	if err != nil {

     

       613
       639
        
       		log.Println("failed to get issues", err)

     

       614
       640
        
       		rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     
···

       620
       646
        
       		RepoInfo:        f.RepoInfo(user),

     

       621
       647
        
       		Issues:          issues,

     

       622
       648
        
       		FilteringByOpen: isOpen,

     

       649
       649
       +
       		FilterQuery:     keyword,

     

       623
       650
        
       		Page:            page,

     

       624
       651
        
       	})

     

       625
       652
        
       }

+9 -2

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

···

       24
       24
        
               {{ i "ban" "w-4 h-4" }}

     

       25
       25
        
               <span>{{ .RepoInfo.Stats.IssueCount.Closed }} closed</span>

     

       26
       26
        
           </a>

     

       27
       27
       +
           <form class="flex gap-4" method="GET">

     

       28
       28
       +
               <input type="hidden" name="state" value="{{ if .FilteringByOpen }}open{{ else }}closed{{ end }}">

     

       29
       29
       +
               <input class="" type="text" name="q" value="{{ .FilterQuery }}">

     

       30
       30
       +
               <button class="btn" type="submit">

     

       31
       31
       +
                   search

     

       32
       32
       +
               </button>

     

       33
       33
       +
           </form>

     

       27
       34
        
         </div>

     

       28
       35
        
         <a

     

       29
       36
        
             href="/{{ .RepoInfo.FullName }}/issues/new"

     
···

       100
       107
        
               <a

     

       101
       108
        
                   class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       102
       109
        
                   hx-boost="true"

     

       103
       103
       -
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"

     

       110
       110
       +
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"

     

       104
       111
        
               >

     

       105
       112
        
                   {{ i "chevron-left" "w-4 h-4" }}

     

       106
       113
        
                   previous

     
···

       114
       121
        
               <a

     

       115
       122
        
                   class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       116
       123
        
                   hx-boost="true"

     

       117
       117
       -
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&offset={{ $next.Offset }}&limit={{ $next.Limit }}"

     

       124
       124
       +
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $next.Offset }}&limit={{ $next.Limit }}"

     

       118
       125
        
               >

     

       119
       126
        
                   next

     

       120
       127
        
                   {{ i "chevron-right" "w-4 h-4" }}