forked from
tangled.org/core
Mirror of @tangled.org/core. Running on a Raspberry Pi Zero 2 (Please be gentle).
appview/models: move db.Repo* into models
- move db.{Repo,RepoStats,IssueCount,PullCount} into models
- moe auxilliary funcs like FromRecord into models
Signed-off-by: oppiliappan <me@oppi.li>
+184
-167
+1
-1
appview/db/collaborators.go
+1
-1
appview/db/collaborators.go
···
34
34
return err
35
35
}
36
36
37
-
func CollaboratingIn(e Execer, collaborator string) ([]Repo, error) {
37
+
func CollaboratingIn(e Execer, collaborator string) ([]models.Repo, error) {
38
38
rows, err := e.Query(`select repo_at from collaborators where subject_did = ?`, collaborator)
39
39
if err != nil {
40
40
return nil, err
+5
-10
appview/db/issues.go
+5
-10
appview/db/issues.go
···
32
32
// like comment counts, parent repo etc.
33
33
Comments []IssueComment
34
34
Labels models.LabelState
35
-
Repo *Repo
35
+
Repo *models.Repo
36
36
}
37
37
38
38
func (i *Issue) AtUri() syntax.ATURI {
···
376
376
return nil, fmt.Errorf("failed to build repo mappings: %w", err)
377
377
}
378
378
379
-
repoMap := make(map[string]*Repo)
379
+
repoMap := make(map[string]*models.Repo)
380
380
for i := range repos {
381
381
repoMap[string(repos[i].RepoAt())] = &repos[i]
382
382
}
···
658
658
return err
659
659
}
660
660
661
-
type IssueCount struct {
662
-
Open int
663
-
Closed int
664
-
}
665
-
666
-
func GetIssueCount(e Execer, repoAt syntax.ATURI) (IssueCount, error) {
661
+
func GetIssueCount(e Execer, repoAt syntax.ATURI) (models.IssueCount, error) {
667
662
row := e.QueryRow(`
668
663
select
669
664
count(case when open = 1 then 1 end) as open_count,
···
668
673
repoAt,
669
674
)
670
675
671
-
var count IssueCount
676
+
var count models.IssueCount
672
677
if err := row.Scan(&count.Open, &count.Closed); err != nil {
673
-
return IssueCount{0, 0}, err
678
+
return models.IssueCount{0, 0}, err
674
679
}
675
680
676
681
return count, nil
+4
-3
appview/db/profile.go
+4
-3
appview/db/profile.go
···
11
11
12
12
"github.com/bluesky-social/indigo/atproto/syntax"
13
13
"tangled.org/core/api/tangled"
14
+
"tangled.org/core/appview/models"
14
15
)
15
16
16
17
type RepoEvent struct {
17
-
Repo *Repo
18
-
Source *Repo
18
+
Repo *models.Repo
19
+
Source *models.Repo
19
20
}
20
21
21
22
type ProfileTimeline struct {
···
163
162
164
163
for _, repo := range repos {
165
164
// TODO: get this in the original query; requires COALESCE because nullable
166
-
var sourceRepo *Repo
165
+
var sourceRepo *models.Repo
167
166
if repo.Source != "" {
168
167
sourceRepo, err = GetRepoByAtUri(e, repo.Source)
169
168
if err != nil {
+8
-14
appview/db/pulls.go
+8
-14
appview/db/pulls.go
···
11
11
12
12
"github.com/bluesky-social/indigo/atproto/syntax"
13
13
"tangled.org/core/api/tangled"
14
+
"tangled.org/core/appview/models"
14
15
"tangled.org/core/patchutil"
15
16
"tangled.org/core/types"
16
17
)
···
80
79
PullSource *PullSource
81
80
82
81
// optionally, populate this when querying for reverse mappings
83
-
Repo *Repo
82
+
Repo *models.Repo
84
83
}
85
84
86
85
func (p Pull) AsRecord() tangled.RepoPull {
···
110
109
RepoAt *syntax.ATURI
111
110
112
111
// optionally populate this for reverse mappings
113
-
Repo *Repo
112
+
Repo *models.Repo
114
113
}
115
114
116
115
func (p PullSource) AsRecord() tangled.RepoPull_Source {
···
724
723
return nil, err
725
724
}
726
725
727
-
var pullSourceRepo *Repo
726
+
var pullSourceRepo *models.Repo
728
727
if pull.PullSource != nil {
729
728
if pull.PullSource.RepoAt != nil {
730
729
pullSourceRepo, err = GetRepoByAtUri(e, pull.PullSource.RepoAt.String())
···
777
776
778
777
for rows.Next() {
779
778
var pull Pull
780
-
var repo Repo
779
+
var repo models.Repo
781
780
var pullCreatedAt, repoCreatedAt string
782
781
err := rows.Scan(
783
782
&pull.OwnerDid,
···
932
931
return err
933
932
}
934
933
935
-
type PullCount struct {
936
-
Open int
937
-
Merged int
938
-
Closed int
939
-
Deleted int
940
-
}
941
-
942
-
func GetPullCount(e Execer, repoAt syntax.ATURI) (PullCount, error) {
934
+
func GetPullCount(e Execer, repoAt syntax.ATURI) (models.PullCount, error) {
943
935
row := e.QueryRow(`
944
936
select
945
937
count(case when state = ? then 1 end) as open_count,
···
948
954
repoAt,
949
955
)
950
956
951
-
var count PullCount
957
+
var count models.PullCount
952
958
if err := row.Scan(&count.Open, &count.Merged, &count.Closed, &count.Deleted); err != nil {
953
-
return PullCount{0, 0, 0, 0}, err
959
+
return models.PullCount{Open: 0, Merged: 0, Closed: 0, Deleted: 0}, err
954
960
}
955
961
956
962
return count, nil
+20
-86
appview/db/repos.go
+20
-86
appview/db/repos.go
···
10
10
"time"
11
11
12
12
"github.com/bluesky-social/indigo/atproto/syntax"
13
-
securejoin "github.com/cyphar/filepath-securejoin"
14
-
"tangled.org/core/api/tangled"
13
+
"tangled.org/core/appview/models"
15
14
)
16
15
17
-
type Repo struct {
18
-
Did string
19
-
Name string
20
-
Knot string
21
-
Rkey string
22
-
Created time.Time
23
-
Description string
24
-
Spindle string
25
-
Labels []string
26
-
27
-
// optionally, populate this when querying for reverse mappings
28
-
RepoStats *RepoStats
29
-
30
-
// optional
31
-
Source string
32
-
}
33
-
34
-
func (r *Repo) AsRecord() tangled.Repo {
35
-
var source, spindle, description *string
36
-
37
-
if r.Source != "" {
38
-
source = &r.Source
39
-
}
40
-
41
-
if r.Spindle != "" {
42
-
spindle = &r.Spindle
43
-
}
44
-
45
-
if r.Description != "" {
46
-
description = &r.Description
47
-
}
48
-
49
-
return tangled.Repo{
50
-
Knot: r.Knot,
51
-
Name: r.Name,
52
-
Description: description,
53
-
CreatedAt: r.Created.Format(time.RFC3339),
54
-
Source: source,
55
-
Spindle: spindle,
56
-
Labels: r.Labels,
57
-
}
58
-
}
59
-
60
-
func (r Repo) RepoAt() syntax.ATURI {
61
-
return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))
62
-
}
63
-
64
-
func (r Repo) DidSlashRepo() string {
65
-
p, _ := securejoin.SecureJoin(r.Did, r.Name)
66
-
return p
67
-
}
68
-
69
-
func GetRepos(e Execer, limit int, filters ...filter) ([]Repo, error) {
70
-
repoMap := make(map[syntax.ATURI]*Repo)
16
+
func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {
17
+
repoMap := make(map[syntax.ATURI]*models.Repo)
71
18
72
19
var conditions []string
73
20
var args []any
···
58
111
}
59
112
60
113
for rows.Next() {
61
-
var repo Repo
114
+
var repo models.Repo
62
115
var createdAt string
63
116
var description, source, spindle sql.NullString
64
117
···
89
142
repo.Spindle = spindle.String
90
143
}
91
144
92
-
repo.RepoStats = &RepoStats{}
145
+
repo.RepoStats = &models.RepoStats{}
93
146
repoMap[repo.RepoAt()] = &repo
94
147
}
95
148
···
267
320
return nil, fmt.Errorf("failed to execute pulls-count query: %w ", err)
268
321
}
269
322
270
-
var repos []Repo
323
+
var repos []models.Repo
271
324
for _, r := range repoMap {
272
325
repos = append(repos, *r)
273
326
}
274
327
275
-
slices.SortFunc(repos, func(a, b Repo) int {
328
+
slices.SortFunc(repos, func(a, b models.Repo) int {
276
329
if a.Created.After(b.Created) {
277
330
return -1
278
331
}
···
283
336
}
284
337
285
338
// helper to get exactly one repo
286
-
func GetRepo(e Execer, filters ...filter) (*Repo, error) {
339
+
func GetRepo(e Execer, filters ...filter) (*models.Repo, error) {
287
340
repos, err := GetRepos(e, 0, filters...)
288
341
if err != nil {
289
342
return nil, err
···
324
377
return count, nil
325
378
}
326
379
327
-
func GetRepoByAtUri(e Execer, atUri string) (*Repo, error) {
328
-
var repo Repo
380
+
func GetRepoByAtUri(e Execer, atUri string) (*models.Repo, error) {
381
+
var repo models.Repo
329
382
var nullableDescription sql.NullString
330
383
331
384
row := e.QueryRow(`select did, name, knot, created, rkey, description from repos where at_uri = ?`, atUri)
···
346
399
return &repo, nil
347
400
}
348
401
349
-
func AddRepo(e Execer, repo *Repo) error {
402
+
func AddRepo(e Execer, repo *models.Repo) error {
350
403
_, err := e.Exec(
351
404
`insert into repos
352
405
(did, name, knot, rkey, at_uri, description, source)
···
370
423
return nullableSource.String, nil
371
424
}
372
425
373
-
func GetForksByDid(e Execer, did string) ([]Repo, error) {
374
-
var repos []Repo
426
+
func GetForksByDid(e Execer, did string) ([]models.Repo, error) {
427
+
var repos []models.Repo
375
428
376
429
rows, err := e.Query(
377
430
`select distinct r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source
···
389
442
defer rows.Close()
390
443
391
444
for rows.Next() {
392
-
var repo Repo
445
+
var repo models.Repo
393
446
var createdAt string
394
447
var nullableDescription sql.NullString
395
448
var nullableSource sql.NullString
···
424
477
return repos, nil
425
478
}
426
479
427
-
func GetForkByDid(e Execer, did string, name string) (*Repo, error) {
428
-
var repo Repo
480
+
func GetForkByDid(e Execer, did string, name string) (*models.Repo, error) {
481
+
var repo models.Repo
429
482
var createdAt string
430
483
var nullableDescription sql.NullString
431
484
var nullableSource sql.NullString
···
472
525
return err
473
526
}
474
527
475
-
type RepoStats struct {
476
-
Language string
477
-
StarCount int
478
-
IssueCount IssueCount
479
-
PullCount PullCount
480
-
}
481
-
482
-
type RepoLabel struct {
483
-
Id int64
484
-
RepoAt syntax.ATURI
485
-
LabelAt syntax.ATURI
486
-
}
487
-
488
-
func SubscribeLabel(e Execer, rl *RepoLabel) error {
528
+
func SubscribeLabel(e Execer, rl *models.RepoLabel) error {
489
529
query := `insert or ignore into repo_labels (repo_at, label_at) values (?, ?)`
490
530
491
531
_, err := e.Exec(query, rl.RepoAt.String(), rl.LabelAt.String())
···
497
563
return err
498
564
}
499
565
500
-
func GetRepoLabels(e Execer, filters ...filter) ([]RepoLabel, error) {
566
+
func GetRepoLabels(e Execer, filters ...filter) ([]models.RepoLabel, error) {
501
567
var conditions []string
502
568
var args []any
503
569
for _, filter := range filters {
···
518
584
}
519
585
defer rows.Close()
520
586
521
-
var labels []RepoLabel
587
+
var labels []models.RepoLabel
522
588
for rows.Next() {
523
-
var label RepoLabel
589
+
var label models.RepoLabel
524
590
525
591
err := rows.Scan(&label.Id, &label.RepoAt, &label.LabelAt)
526
592
if err != nil {
+7
-6
appview/db/star.go
+7
-6
appview/db/star.go
···
9
9
"time"
10
10
11
11
"github.com/bluesky-social/indigo/atproto/syntax"
12
+
"tangled.org/core/appview/models"
12
13
)
13
14
14
15
type Star struct {
···
19
18
Rkey string
20
19
21
20
// optionally, populate this when querying for reverse mappings
22
-
Repo *Repo
21
+
Repo *models.Repo
23
22
}
24
23
25
24
func (star *Star) ResolveRepo(e Execer) error {
···
285
284
286
285
for rows.Next() {
287
286
var star Star
288
-
var repo Repo
287
+
var repo models.Repo
289
288
var starCreatedAt, repoCreatedAt string
290
289
291
290
if err := rows.Scan(
···
323
322
}
324
323
325
324
// GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week
326
-
func GetTopStarredReposLastWeek(e Execer) ([]Repo, error) {
325
+
func GetTopStarredReposLastWeek(e Execer) ([]models.Repo, error) {
327
326
// first, get the top repo URIs by star count from the last week
328
327
query := `
329
328
with recent_starred_repos as (
···
367
366
}
368
367
369
368
if len(repoUris) == 0 {
370
-
return []Repo{}, nil
369
+
return []models.Repo{}, nil
371
370
}
372
371
373
372
// get full repo data
···
377
376
}
378
377
379
378
// sort repos by the original trending order
380
-
repoMap := make(map[string]Repo)
379
+
repoMap := make(map[string]models.Repo)
381
380
for _, repo := range repos {
382
381
repoMap[repo.RepoAt().String()] = repo
383
382
}
384
383
385
-
orderedRepos := make([]Repo, 0, len(repoUris))
384
+
orderedRepos := make([]models.Repo, 0, len(repoUris))
386
385
for _, uri := range repoUris {
387
386
if repo, exists := repoMap[uri]; exists {
388
387
orderedRepos = append(orderedRepos, repo)
+8
-8
appview/db/timeline.go
+8
-8
appview/db/timeline.go
···
9
9
)
10
10
11
11
type TimelineEvent struct {
12
-
*Repo
12
+
*models.Repo
13
13
*models.Follow
14
14
*Star
15
15
16
16
EventAt time.Time
17
17
18
18
// optional: populate only if Repo is a fork
19
-
Source *Repo
19
+
Source *models.Repo
20
20
21
21
// optional: populate only if event is Follow
22
22
*Profile
···
64
64
return events, nil
65
65
}
66
66
67
-
func fetchStarStatuses(e Execer, loggedInUserDid string, repos []Repo) (map[string]bool, error) {
67
+
func fetchStarStatuses(e Execer, loggedInUserDid string, repos []models.Repo) (map[string]bool, error) {
68
68
if loggedInUserDid == "" {
69
69
return nil, nil
70
70
}
···
77
77
return GetStarStatuses(e, loggedInUserDid, repoAts)
78
78
}
79
79
80
-
func getRepoStarInfo(repo *Repo, starStatuses map[string]bool) (bool, int64) {
80
+
func getRepoStarInfo(repo *models.Repo, starStatuses map[string]bool) (bool, int64) {
81
81
var isStarred bool
82
82
if starStatuses != nil {
83
83
isStarred = starStatuses[repo.RepoAt().String()]
···
105
105
}
106
106
}
107
107
108
-
var origRepos []Repo
108
+
var origRepos []models.Repo
109
109
if args != nil {
110
110
origRepos, err = GetRepos(e, 0, FilterIn("at_uri", args))
111
111
}
···
113
113
return nil, err
114
114
}
115
115
116
-
uriToRepo := make(map[string]Repo)
116
+
uriToRepo := make(map[string]models.Repo)
117
117
for _, r := range origRepos {
118
118
uriToRepo[r.RepoAt().String()] = r
119
119
}
···
125
125
126
126
var events []TimelineEvent
127
127
for _, r := range repos {
128
-
var source *Repo
128
+
var source *models.Repo
129
129
if r.Source != "" {
130
130
if origRepo, ok := uriToRepo[r.Source]; ok {
131
131
source = &origRepo
···
162
162
}
163
163
stars = stars[:n]
164
164
165
-
var repos []Repo
165
+
var repos []models.Repo
166
166
for _, s := range stars {
167
167
repos = append(repos, *s.Repo)
168
168
}
+2
-1
appview/knots/knots.go
+2
-1
appview/knots/knots.go
···
13
13
"tangled.org/core/appview/config"
14
14
"tangled.org/core/appview/db"
15
15
"tangled.org/core/appview/middleware"
16
+
"tangled.org/core/appview/models"
16
17
"tangled.org/core/appview/oauth"
17
18
"tangled.org/core/appview/pages"
18
19
"tangled.org/core/appview/serververify"
···
120
119
}
121
120
122
121
// organize repos by did
123
-
repoMap := make(map[string][]db.Repo)
122
+
repoMap := make(map[string][]models.Repo)
124
123
for _, r := range repos {
125
124
repoMap[r.Did] = append(repoMap[r.Did], r)
126
125
}
+87
appview/models/repo.go
+87
appview/models/repo.go
···
1
+
package models
2
+
3
+
import (
4
+
"fmt"
5
+
"time"
6
+
7
+
"github.com/bluesky-social/indigo/atproto/syntax"
8
+
securejoin "github.com/cyphar/filepath-securejoin"
9
+
"tangled.org/core/api/tangled"
10
+
)
11
+
12
+
type Repo struct {
13
+
Did string
14
+
Name string
15
+
Knot string
16
+
Rkey string
17
+
Created time.Time
18
+
Description string
19
+
Spindle string
20
+
Labels []string
21
+
22
+
// optionally, populate this when querying for reverse mappings
23
+
RepoStats *RepoStats
24
+
25
+
// optional
26
+
Source string
27
+
}
28
+
29
+
func (r *Repo) AsRecord() tangled.Repo {
30
+
var source, spindle, description *string
31
+
32
+
if r.Source != "" {
33
+
source = &r.Source
34
+
}
35
+
36
+
if r.Spindle != "" {
37
+
spindle = &r.Spindle
38
+
}
39
+
40
+
if r.Description != "" {
41
+
description = &r.Description
42
+
}
43
+
44
+
return tangled.Repo{
45
+
Knot: r.Knot,
46
+
Name: r.Name,
47
+
Description: description,
48
+
CreatedAt: r.Created.Format(time.RFC3339),
49
+
Source: source,
50
+
Spindle: spindle,
51
+
Labels: r.Labels,
52
+
}
53
+
}
54
+
55
+
func (r Repo) RepoAt() syntax.ATURI {
56
+
return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))
57
+
}
58
+
59
+
func (r Repo) DidSlashRepo() string {
60
+
p, _ := securejoin.SecureJoin(r.Did, r.Name)
61
+
return p
62
+
}
63
+
64
+
type RepoStats struct {
65
+
Language string
66
+
StarCount int
67
+
IssueCount IssueCount
68
+
PullCount PullCount
69
+
}
70
+
71
+
type IssueCount struct {
72
+
Open int
73
+
Closed int
74
+
}
75
+
76
+
type PullCount struct {
77
+
Open int
78
+
Merged int
79
+
Closed int
80
+
Deleted int
81
+
}
82
+
83
+
type RepoLabel struct {
84
+
Id int64
85
+
RepoAt syntax.ATURI
86
+
LabelAt syntax.ATURI
87
+
}
+1
-1
appview/notify/merged_notifier.go
+1
-1
appview/notify/merged_notifier.go
+2
-2
appview/notify/notifier.go
+2
-2
appview/notify/notifier.go
···
8
8
)
9
9
10
10
type Notifier interface {
11
-
NewRepo(ctx context.Context, repo *db.Repo)
11
+
NewRepo(ctx context.Context, repo *models.Repo)
12
12
13
13
NewStar(ctx context.Context, star *db.Star)
14
14
DeleteStar(ctx context.Context, star *db.Star)
···
33
33
34
34
var _ Notifier = &BaseNotifier{}
35
35
36
-
func (m *BaseNotifier) NewRepo(ctx context.Context, repo *db.Repo) {}
36
+
func (m *BaseNotifier) NewRepo(ctx context.Context, repo *models.Repo) {}
37
37
38
38
func (m *BaseNotifier) NewStar(ctx context.Context, star *db.Star) {}
39
39
func (m *BaseNotifier) DeleteStar(ctx context.Context, star *db.Star) {}
+12
-12
appview/pages/pages.go
+12
-12
appview/pages/pages.go
···
284
284
type TimelineParams struct {
285
285
LoggedInUser *oauth.User
286
286
Timeline []db.TimelineEvent
287
-
Repos []db.Repo
287
+
Repos []models.Repo
288
288
}
289
289
290
290
func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {
···
345
345
LoggedInUser *oauth.User
346
346
Registration *db.Registration
347
347
Members []string
348
-
Repos map[string][]db.Repo
348
+
Repos map[string][]models.Repo
349
349
IsOwner bool
350
350
}
351
351
···
382
382
LoggedInUser *oauth.User
383
383
Spindle db.Spindle
384
384
Members []string
385
-
Repos map[string][]db.Repo
385
+
Repos map[string][]models.Repo
386
386
}
387
387
388
388
func (p *Pages) SpindleDashboard(w io.Writer, params SpindleDashboardParams) error {
···
439
439
440
440
type ProfileOverviewParams struct {
441
441
LoggedInUser *oauth.User
442
-
Repos []db.Repo
443
-
CollaboratingRepos []db.Repo
442
+
Repos []models.Repo
443
+
CollaboratingRepos []models.Repo
444
444
ProfileTimeline *db.ProfileTimeline
445
445
Card *ProfileCard
446
446
Active string
···
453
453
454
454
type ProfileReposParams struct {
455
455
LoggedInUser *oauth.User
456
-
Repos []db.Repo
456
+
Repos []models.Repo
457
457
Card *ProfileCard
458
458
Active string
459
459
}
···
465
465
466
466
type ProfileStarredParams struct {
467
467
LoggedInUser *oauth.User
468
-
Repos []db.Repo
468
+
Repos []models.Repo
469
469
Card *ProfileCard
470
470
Active string
471
471
}
···
545
545
546
546
type PinnedRepo struct {
547
547
IsPinned bool
548
-
db.Repo
548
+
models.Repo
549
549
}
550
550
551
551
func (p *Pages) EditPinsFragment(w io.Writer, params EditPinsParams) error {
···
555
555
type RepoStarFragmentParams struct {
556
556
IsStarred bool
557
557
RepoAt syntax.ATURI
558
-
Stats db.RepoStats
558
+
Stats models.RepoStats
559
559
}
560
560
561
561
func (p *Pages) RepoStarFragment(w io.Writer, params RepoStarFragmentParams) error {
···
1122
1122
1123
1123
type PullCompareForkParams struct {
1124
1124
RepoInfo repoinfo.RepoInfo
1125
-
Forks []db.Repo
1125
+
Forks []models.Repo
1126
1126
Selected string
1127
1127
}
1128
1128
···
1179
1179
type RepoCompareParams struct {
1180
1180
LoggedInUser *oauth.User
1181
1181
RepoInfo repoinfo.RepoInfo
1182
-
Forks []db.Repo
1182
+
Forks []models.Repo
1183
1183
Branches []types.Branch
1184
1184
Tags []*types.TagReference
1185
1185
Base string
···
1198
1198
type RepoCompareNewParams struct {
1199
1199
LoggedInUser *oauth.User
1200
1200
RepoInfo repoinfo.RepoInfo
1201
-
Forks []db.Repo
1201
+
Forks []models.Repo
1202
1202
Branches []types.Branch
1203
1203
Tags []*types.TagReference
1204
1204
Base string
+3
-3
appview/pages/repoinfo/repoinfo.go
+3
-3
appview/pages/repoinfo/repoinfo.go
···
7
7
"strings"
8
8
9
9
"github.com/bluesky-social/indigo/atproto/syntax"
10
-
"tangled.org/core/appview/db"
10
+
"tangled.org/core/appview/models"
11
11
"tangled.org/core/appview/state/userutil"
12
12
)
13
13
···
60
60
Spindle string
61
61
RepoAt syntax.ATURI
62
62
IsStarred bool
63
-
Stats db.RepoStats
63
+
Stats models.RepoStats
64
64
Roles RolesInRepo
65
-
Source *db.Repo
65
+
Source *models.Repo
66
66
SourceHandle string
67
67
Ref string
68
68
DisableFork bool
+1
-1
appview/posthog/notifier.go
+1
-1
appview/posthog/notifier.go
···
24
24
25
25
var _ notify.Notifier = &posthogNotifier{}
26
26
27
-
func (n *posthogNotifier) NewRepo(ctx context.Context, repo *db.Repo) {
27
+
func (n *posthogNotifier) NewRepo(ctx context.Context, repo *models.Repo) {
28
28
err := n.client.Enqueue(posthog.Capture{
29
29
DistinctId: repo.Did,
30
30
Event: "new_repo",
+2
-1
appview/pulls/pulls.go
+2
-1
appview/pulls/pulls.go
···
15
15
"tangled.org/core/api/tangled"
16
16
"tangled.org/core/appview/config"
17
17
"tangled.org/core/appview/db"
18
+
"tangled.org/core/appview/models"
18
19
"tangled.org/core/appview/notify"
19
20
"tangled.org/core/appview/oauth"
20
21
"tangled.org/core/appview/pages"
···
501
500
}
502
501
503
502
for _, p := range pulls {
504
-
var pullSourceRepo *db.Repo
503
+
var pullSourceRepo *models.Repo
505
504
if p.PullSource != nil {
506
505
if p.PullSource.RepoAt != nil {
507
506
pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())
+3
-3
appview/repo/repo.go
+3
-3
appview/repo/repo.go
···
1110
1110
return
1111
1111
}
1112
1112
1113
-
err = db.SubscribeLabel(tx, &db.RepoLabel{
1113
+
err = db.SubscribeLabel(tx, &models.RepoLabel{
1114
1114
RepoAt: f.RepoAt(),
1115
1115
LabelAt: label.AtUri(),
1116
1116
})
···
1286
1286
},
1287
1287
})
1288
1288
1289
-
err = db.SubscribeLabel(rp.db, &db.RepoLabel{
1289
+
err = db.SubscribeLabel(rp.db, &models.RepoLabel{
1290
1290
RepoAt: f.RepoAt(),
1291
1291
LabelAt: syntax.ATURI(labelAt),
1292
1292
})
···
2142
2142
2143
2143
// create an atproto record for this fork
2144
2144
rkey := tid.TID()
2145
-
repo := &db.Repo{
2145
+
repo := &models.Repo{
2146
2146
Did: user.Did,
2147
2147
Name: forkName,
2148
2148
Knot: targetKnot,
+5
-4
appview/reporesolver/resolver.go
+5
-4
appview/reporesolver/resolver.go
···
16
16
"github.com/go-chi/chi/v5"
17
17
"tangled.org/core/appview/config"
18
18
"tangled.org/core/appview/db"
19
+
"tangled.org/core/appview/models"
19
20
"tangled.org/core/appview/oauth"
20
21
"tangled.org/core/appview/pages"
21
22
"tangled.org/core/appview/pages/repoinfo"
···
25
24
)
26
25
27
26
type ResolvedRepo struct {
28
-
db.Repo
27
+
models.Repo
29
28
OwnerId identity.Identity
30
29
CurrentDir string
31
30
Ref string
···
45
44
}
46
45
47
46
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
48
-
repo, ok := r.Context().Value("repo").(*db.Repo)
47
+
repo, ok := r.Context().Value("repo").(*models.Repo)
49
48
if !ok {
50
49
log.Println("malformed middleware: `repo` not exist in context")
51
50
return nil, fmt.Errorf("malformed middleware")
···
163
162
log.Println("failed to get repo source for ", repoAt, err)
164
163
}
165
164
166
-
var sourceRepo *db.Repo
165
+
var sourceRepo *models.Repo
167
166
if source != "" {
168
167
sourceRepo, err = db.GetRepoByAtUri(f.rr.execer, source)
169
168
if err != nil {
···
192
191
Knot: knot,
193
192
Spindle: f.Spindle,
194
193
Roles: f.RolesInRepo(user),
195
-
Stats: db.RepoStats{
194
+
Stats: models.RepoStats{
196
195
StarCount: starCount,
197
196
IssueCount: issueCount,
198
197
PullCount: pullCount,
+2
-1
appview/spindles/spindles.go
+2
-1
appview/spindles/spindles.go
···
13
13
"tangled.org/core/appview/config"
14
14
"tangled.org/core/appview/db"
15
15
"tangled.org/core/appview/middleware"
16
+
"tangled.org/core/appview/models"
16
17
"tangled.org/core/appview/oauth"
17
18
"tangled.org/core/appview/pages"
18
19
"tangled.org/core/appview/serververify"
···
116
115
}
117
116
118
117
// organize repos by did
119
-
repoMap := make(map[string][]db.Repo)
118
+
repoMap := make(map[string][]models.Repo)
120
119
for _, r := range repos {
121
120
repoMap[r.Did] = append(repoMap[r.Did], r)
122
121
}
+4
-4
appview/state/git_http.go
+4
-4
appview/state/git_http.go
···
8
8
9
9
"github.com/bluesky-social/indigo/atproto/identity"
10
10
"github.com/go-chi/chi/v5"
11
-
"tangled.org/core/appview/db"
11
+
"tangled.org/core/appview/models"
12
12
)
13
13
14
14
func (s *State) InfoRefs(w http.ResponseWriter, r *http.Request) {
15
15
user := r.Context().Value("resolvedId").(identity.Identity)
16
-
repo := r.Context().Value("repo").(*db.Repo)
16
+
repo := r.Context().Value("repo").(*models.Repo)
17
17
18
18
scheme := "https"
19
19
if s.config.Core.Dev {
···
31
31
http.Error(w, "failed to resolve user", http.StatusInternalServerError)
32
32
return
33
33
}
34
-
repo := r.Context().Value("repo").(*db.Repo)
34
+
repo := r.Context().Value("repo").(*models.Repo)
35
35
36
36
scheme := "https"
37
37
if s.config.Core.Dev {
···
48
48
http.Error(w, "failed to resolve user", http.StatusInternalServerError)
49
49
return
50
50
}
51
-
repo := r.Context().Value("repo").(*db.Repo)
51
+
repo := r.Context().Value("repo").(*models.Repo)
52
52
53
53
scheme := "https"
54
54
if s.config.Core.Dev {
+2
-2
appview/state/profile.go
+2
-2
appview/state/profile.go
···
131
131
}
132
132
133
133
// filter out ones that are pinned
134
-
pinnedRepos := []db.Repo{}
134
+
pinnedRepos := []models.Repo{}
135
135
for i, r := range repos {
136
136
// if this is a pinned repo, add it
137
137
if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
···
149
149
l.Error("failed to fetch collaborating repos", "err", err)
150
150
}
151
151
152
-
pinnedCollaboratingRepos := []db.Repo{}
152
+
pinnedCollaboratingRepos := []models.Repo{}
153
153
for _, r := range collaboratingRepos {
154
154
// if this is a pinned repo, add it
155
155
if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
+3
-2
appview/state/star.go
+3
-2
appview/state/star.go
···
10
10
lexutil "github.com/bluesky-social/indigo/lex/util"
11
11
"tangled.org/core/api/tangled"
12
12
"tangled.org/core/appview/db"
13
+
"tangled.org/core/appview/models"
13
14
"tangled.org/core/appview/pages"
14
15
"tangled.org/core/tid"
15
16
)
···
78
77
s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{
79
78
IsStarred: true,
80
79
RepoAt: subjectUri,
81
-
Stats: db.RepoStats{
80
+
Stats: models.RepoStats{
82
81
StarCount: starCount,
83
82
},
84
83
})
···
120
119
s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{
121
120
IsStarred: false,
122
121
RepoAt: subjectUri,
123
-
Stats: db.RepoStats{
122
+
Stats: models.RepoStats{
124
123
StarCount: starCount,
125
124
},
126
125
})
+2
-2
appview/state/state.go
+2
-2
appview/state/state.go
···
23
23
"tangled.org/core/appview/cache/session"
24
24
"tangled.org/core/appview/config"
25
25
"tangled.org/core/appview/db"
26
+
"tangled.org/core/appview/models"
26
27
"tangled.org/core/appview/notify"
27
28
"tangled.org/core/appview/oauth"
28
29
"tangled.org/core/appview/pages"
···
37
36
tlog "tangled.org/core/log"
38
37
"tangled.org/core/rbac"
39
38
"tangled.org/core/tid"
40
-
// xrpcerr "tangled.org/core/xrpc/errors"
41
39
)
42
40
43
41
type State struct {
···
433
433
434
434
// create atproto record for this repo
435
435
rkey := tid.TID()
436
-
repo := &db.Repo{
436
+
repo := &models.Repo{
437
437
Did: user.Did,
438
438
Name: repoName,
439
439
Knot: domain,