back round 1 view raw

appview: db: issues: add method for getting any issues a repo might have #474

merged

opened by

ptr.pet 4 months ago targeting master from ptr.pet/core: repo-feed

Signed-off-by: dusk y.bera003.06@protonmail.com

options

unified split

Changed files

+85 -4

appview

issues.go

issues

issues.go

+84 -3

appview/db/issues.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"database/sql"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	"strings"

     

       6
       7
        
       	"time"

     

       7
       8
        
       

     

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

     
···

       105
       106
        
       	return ownerDid, err

     

       106
       107
        
       }

     

       107
       108
        
       

     

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

     

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

     

       109
       110
        
       	var issues []Issue

     

       110
       111
        
       	openValue := 0

     

       111
       112
        
       	if isOpen {

     
···

       145
       146
        
       			body,

     

       146
       147
        
       			open,

     

       147
       148
        
       			comment_count

     

       148
       148
       -
       		from 

     

       149
       149
       +
       		from

     

       149
       150
        
       			numbered_issue

     

       150
       150
       -
       		where 

     

       151
       151
       +
       		where

     

       151
       152
        
       			row_num between ? and ?`,

     

       152
       153
        
       		repoAt, openValue, page.Offset+1, page.Offset+page.Limit)

     

       153
       154
        
       	if err != nil {

     
···

       181
       182
        
       	return issues, nil

     

       182
       183
        
       }

     

       183
       184
        
       

     

       185
       185
       +
       func GetIssuesWithLimit(e Execer, limit int, filters ...filter) ([]Issue, error) {

     

       186
       186
       +
       	issues := make([]Issue, 0, limit)

     

       187
       187
       +
       

     

       188
       188
       +
       	var conditions []string

     

       189
       189
       +
       	var args []any

     

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

     

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

     

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

     

       193
       193
       +
       	}

     

       194
       194
       +
       

     

       195
       195
       +
       	whereClause := ""

     

       196
       196
       +
       	if conditions != nil {

     

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

     

       198
       198
       +
       	}

     

       199
       199
       +
       	limitClause := ""

     

       200
       200
       +
       	if limit != 0 {

     

       201
       201
       +
       		limitClause = fmt.Sprintf(" limit %d ", limit)

     

       202
       202
       +
       	}

     

       203
       203
       +
       

     

       204
       204
       +
       	query := fmt.Sprintf(

     

       205
       205
       +
       		`select

     

       206
       206
       +
       			i.id,

     

       207
       207
       +
       			i.owner_did,

     

       208
       208
       +
       			i.repo_at,

     

       209
       209
       +
       			i.issue_id,

     

       210
       210
       +
       			i.created,

     

       211
       211
       +
       			i.title,

     

       212
       212
       +
       			i.body,

     

       213
       213
       +
       			i.open

     

       214
       214
       +
       		from

     

       215
       215
       +
       		    issues i

     

       216
       216
       +
       		%s

     

       217
       217
       +
       		order by

     

       218
       218
       +
       			i.created desc

     

       219
       219
       +
       		%s`,

     

       220
       220
       +
       		whereClause, limitClause)

     

       221
       221
       +
       

     

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

     

       223
       223
       +
       	if err != nil {

     

       224
       224
       +
       		return nil, err

     

       225
       225
       +
       	}

     

       226
       226
       +
       	defer rows.Close()

     

       227
       227
       +
       

     

       228
       228
       +
       	for rows.Next() {

     

       229
       229
       +
       		var issue Issue

     

       230
       230
       +
       		var issueCreatedAt string

     

       231
       231
       +
       		err := rows.Scan(

     

       232
       232
       +
       			&issue.ID,

     

       233
       233
       +
       			&issue.OwnerDid,

     

       234
       234
       +
       			&issue.RepoAt,

     

       235
       235
       +
       			&issue.IssueId,

     

       236
       236
       +
       			&issueCreatedAt,

     

       237
       237
       +
       			&issue.Title,

     

       238
       238
       +
       			&issue.Body,

     

       239
       239
       +
       			&issue.Open,

     

       240
       240
       +
       		)

     

       241
       241
       +
       		if err != nil {

     

       242
       242
       +
       			return nil, err

     

       243
       243
       +
       		}

     

       244
       244
       +
       

     

       245
       245
       +
       		issueCreatedTime, err := time.Parse(time.RFC3339, issueCreatedAt)

     

       246
       246
       +
       		if err != nil {

     

       247
       247
       +
       			return nil, err

     

       248
       248
       +
       		}

     

       249
       249
       +
       		issue.Created = issueCreatedTime

     

       250
       250
       +
       

     

       251
       251
       +
       		issues = append(issues, issue)

     

       252
       252
       +
       	}

     

       253
       253
       +
       

     

       254
       254
       +
       	if err := rows.Err(); err != nil {

     

       255
       255
       +
       		return nil, err

     

       256
       256
       +
       	}

     

       257
       257
       +
       

     

       258
       258
       +
       	return issues, nil

     

       259
       259
       +
       }

     

       260
       260
       +
       

     

       261
       261
       +
       func GetIssues(e Execer, filters ...filter) ([]Issue, error) {

     

       262
       262
       +
       	return GetIssuesWithLimit(e, 0, filters...)

     

       263
       263
       +
       }

     

       264
       264
       +
       

     

       184
       265
        
       // timeframe here is directly passed into the sql query filter, and any

     

       185
       266
        
       // timeframe in the past should be negative; e.g.: "-3 months"

     

       186
       267
        
       func GetIssuesByOwnerDid(e Execer, ownerDid string, timeframe string) ([]Issue, error) {

+1 -1

appview/issues/issues.go

···

       604
       604
        
       		return

     

       605
       605
        
       	}

     

       606
       606
        
       

     

       607
       607
       -
       	issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page)

     

       607
       607
       +
       	issues, err := db.GetIssuesPaginated(rp.db, f.RepoAt(), isOpen, page)

     

       608
       608
        
       	if err != nil {

     

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

     

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