commit e590d819e4b66c45d131a55de2d4faaaecbdcb59 · julien.rbrt.fr/tangled-core

+9 -2

appview/db/repos.go

···

       73
       73
        
       	return repos, nil

     

       74
       74
        
       }

     

       75
       75
        
       

     

       76
       76
       -
       func GetRepos(e Execer, filters ...filter) ([]Repo, error) {

     

       76
       76
       +
       func GetRepos(e Execer, limit int, filters ...filter) ([]Repo, error) {

     

       77
       77
        
       	repoMap := make(map[syntax.ATURI]*Repo)

     

       78
       78
        
       

     

       79
       79
        
       	var conditions []string

     
···

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

     

       89
       89
        
       	}

     

       90
       90
        
       

     

       91
       91
       +
       	limitClause := ""

     

       92
       92
       +
       	if limit != 0 {

     

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

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       91
       96
        
       	repoQuery := fmt.Sprintf(

     

       92
       97
        
       		`select

     

       93
       98
        
       			did,

     
···

       100
       105
        
       			spindle

     

       101
       106
        
       		from

     

       102
       107
        
       			repos r

     

       108
       108
       +
       		%s

     

       103
       109
        
       		%s`,

     

       104
       110
        
       		whereClause,

     

       111
       111
       +
       		limitClause,

     

       105
       112
        
       	)

     

       106
       113
        
       	rows, err := e.Query(repoQuery, args...)

     

       107
       114
        
       

     
···

       585
       592
        
       		return nil, nil

     

       586
       593
        
       	}

     

       587
       594
        
       

     

       588
       588
       -
       	return GetRepos(e, FilterIn("id", repoIds))

     

       595
       595
       +
       	return GetRepos(e, 0, FilterIn("id", repoIds))

     

       589
       596
        
       }

     

       590
       597
        
       

     

       591
       598
        
       type RepoStats struct {

+1

appview/knots/knots.go

···

       319
       319
        
       

     

       320
       320
        
       	repos, err := db.GetRepos(

     

       321
       321
        
       		k.Db,

     

       322
       322
       +
       		0,

     

       322
       323
        
       		db.FilterEq("knot", domain),

     

       323
       324
        
       		db.FilterIn("did", members),

     

       324
       325
        
       	)

+1

appview/spindles/spindles.go

···

       104
       104
        
       

     

       105
       105
        
       	repos, err := db.GetRepos(

     

       106
       106
        
       		s.Db,

     

       107
       107
       +
       		0,

     

       107
       108
        
       		db.FilterEq("spindle", instance),

     

       108
       109
        
       	)

     

       109
       110
        
       	if err != nil {

+2

appview/state/knotstream.go

···

       136
       136
        
       

     

       137
       137
        
       	repos, err := db.GetRepos(

     

       138
       138
        
       		d,

     

       139
       139
       +
       		0,

     

       139
       140
        
       		db.FilterEq("did", record.RepoDid),

     

       140
       141
        
       		db.FilterEq("name", record.RepoName),

     

       141
       142
        
       	)

     
···

       188
       189
        
       	// does this repo have a spindle configured?

     

       189
       190
        
       	repos, err := db.GetRepos(

     

       190
       191
        
       		d,

     

       192
       192
       +
       		0,

     

       191
       193
        
       		db.FilterEq("did", record.TriggerMetadata.Repo.Did),

     

       192
       194
        
       		db.FilterEq("name", record.TriggerMetadata.Repo.Repo),

     

       193
       195
        
       	)

+2

appview/state/profile.go

···

       52
       52
        
       

     

       53
       53
        
       	repos, err := db.GetRepos(

     

       54
       54
        
       		s.db,

     

       55
       55
       +
       		0,

     

       55
       56
        
       		db.FilterEq("did", ident.DID.String()),

     

       56
       57
        
       	)

     

       57
       58
        
       	if err != nil {

     
···

       176
       177
        
       

     

       177
       178
        
       	repos, err := db.GetRepos(

     

       178
       179
        
       		s.db,

     

       180
       180
       +
       		0,

     

       179
       181
        
       		db.FilterEq("did", ident.DID.String()),

     

       180
       182
        
       	)

     

       181
       183
        
       	if err != nil {