···

       
5
       
 
       
	"strings"

     

       
6
       
 
       
	"time"

     

       
7
       
 
       


     

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

     

       
9
       
 
       
	"github.com/go-git/go-git/v5/plumbing"

     

       
10
       
 
       
	"github.com/ipfs/go-cid"

     

       
11
       
-
       
	"tangled.org/core/api/tangled"

     

       
12
       
 
       
)

     

       
13
       
 
       


     

       
14
       
-
       
type Artifact struct {

     

       
15
       
-
       
	Id   uint64

     

       
16
       
-
       
	Did  string

     

       
17
       
-
       
	Rkey string

     

       
18
       
-
       


     

       
19
       
-
       
	RepoAt    syntax.ATURI

     

       
20
       
-
       
	Tag       plumbing.Hash

     

       
21
       
-
       
	CreatedAt time.Time

     

       
22
       
-
       


     

       
23
       
-
       
	BlobCid  cid.Cid

     

       
24
       
-
       
	Name     string

     

       
25
       
-
       
	Size     uint64

     

       
26
       
-
       
	MimeType string

     

       
27
       
-
       
}

     

       
28
       
-
       


     

       
29
       
-
       
func (a *Artifact) ArtifactAt() syntax.ATURI {

     

       
30
       
-
       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey))

     

       
31
       
-
       
}

     

       
32
       
-
       


     

       
33
       
-
       
func AddArtifact(e Execer, artifact Artifact) error {

     

       
34
       
 
       
	_, err := e.Exec(

     

       
35
       
 
       
		`insert or ignore into artifacts (

     

       
36
       
 
       
			did,

     
···

       
57
       
 
       
	return err

     

       
58
       
 
       
}

     

       
59
       
 
       


     

       
60
       
-
       
func GetArtifact(e Execer, filters ...filter) ([]Artifact, error) {

     

       
61
       
-
       
	var artifacts []Artifact

     

       
62
       
 
       


     

       
63
       
 
       
	var conditions []string

     

       
64
       
 
       
	var args []any

     
···

       
94
       
 
       
	defer rows.Close()

     

       
95
       
 
       


     

       
96
       
 
       
	for rows.Next() {

     

       
97
       
-
       
		var artifact Artifact

     

       
98
       
 
       
		var createdAt string

     

       
99
       
 
       
		var tag []byte

     

       
100
       
 
       
		var blobCid string

     

···

       
5
       
 
       
	"strings"

     

       
6
       
 
       
	"time"

     

       
7
       
 
       


     

       
0
       
 
       

     

       
8
       
 
       
	"github.com/go-git/go-git/v5/plumbing"

     

       
9
       
 
       
	"github.com/ipfs/go-cid"

     

       
10
       
+
       
	"tangled.org/core/appview/models"

     

       
11
       
 
       
)

     

       
12
       
 
       


     

       
13
       
+
       
func AddArtifact(e Execer, artifact models.Artifact) error {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
14
       
 
       
	_, err := e.Exec(

     

       
15
       
 
       
		`insert or ignore into artifacts (

     

       
16
       
 
       
			did,

     
···

       
37
       
 
       
	return err

     

       
38
       
 
       
}

     

       
39
       
 
       


     

       
40
       
+
       
func GetArtifact(e Execer, filters ...filter) ([]models.Artifact, error) {

     

       
41
       
+
       
	var artifacts []models.Artifact

     

       
42
       
 
       


     

       
43
       
 
       
	var conditions []string

     

       
44
       
 
       
	var args []any

     
···

       
74
       
 
       
	defer rows.Close()

     

       
75
       
 
       


     

       
76
       
 
       
	for rows.Next() {

     

       
77
       
+
       
		var artifact models.Artifact

     

       
78
       
 
       
		var createdAt string

     

       
79
       
 
       
		var tag []byte

     

       
80
       
 
       
		var blobCid string

     

···

       
9
       
 
       
	"time"

     

       
10
       
 
       


     

       
11
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
12
       
-
       
	"github.com/bluesky-social/jetstream/pkg/models"

     

       
13
       
 
       
	"github.com/go-git/go-git/v5/plumbing"

     

       
14
       
 
       
	"github.com/ipfs/go-cid"

     

       
15
       
 
       
	"tangled.org/core/api/tangled"

     

       
16
       
 
       
	"tangled.org/core/appview/config"

     

       
17
       
 
       
	"tangled.org/core/appview/db"

     

       
0
       
 
       

     

       
18
       
 
       
	"tangled.org/core/appview/serververify"

     

       
19
       
 
       
	"tangled.org/core/appview/validator"

     

       
20
       
 
       
	"tangled.org/core/idresolver"

     
···

       
30
       
 
       
	Validator  *validator.Validator

     

       
31
       
 
       
}

     

       
32
       
 
       


     

       
33
       
-
       
type processFunc func(ctx context.Context, e *models.Event) error

     

       
34
       
 
       


     

       
35
       
 
       
func (i *Ingester) Ingest() processFunc {

     

       
36
       
-
       
	return func(ctx context.Context, e *models.Event) error {

     

       
37
       
 
       
		var err error

     

       
38
       
 
       
		defer func() {

     

       
39
       
 
       
			eventTime := e.TimeUS

     
···

       
45
       
 
       


     

       
46
       
 
       
		l := i.Logger.With("kind", e.Kind)

     

       
47
       
 
       
		switch e.Kind {

     

       
48
       
-
       
		case models.EventKindAccount:

     

       
49
       
 
       
			if !e.Account.Active && *e.Account.Status == "deactivated" {

     

       
50
       
 
       
				err = i.IdResolver.InvalidateIdent(ctx, e.Account.Did)

     

       
51
       
 
       
			}

     

       
52
       
-
       
		case models.EventKindIdentity:

     

       
53
       
 
       
			err = i.IdResolver.InvalidateIdent(ctx, e.Identity.Did)

     

       
54
       
-
       
		case models.EventKindCommit:

     

       
55
       
 
       
			switch e.Commit.Collection {

     

       
56
       
 
       
			case tangled.GraphFollowNSID:

     

       
57
       
 
       
				err = i.ingestFollow(e)

     
···

       
91
       
 
       
	}

     

       
92
       
 
       
}

     

       
93
       
 
       


     

       
94
       
-
       
func (i *Ingester) ingestStar(e *models.Event) error {

     

       
95
       
 
       
	var err error

     

       
96
       
 
       
	did := e.Did

     

       
97
       
 
       


     
···

       
99
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
100
       
 
       


     

       
101
       
 
       
	switch e.Commit.Operation {

     

       
102
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
103
       
 
       
		var subjectUri syntax.ATURI

     

       
104
       
 
       


     

       
105
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     
···

       
120
       
 
       
			RepoAt:       subjectUri,

     

       
121
       
 
       
			Rkey:         e.Commit.RKey,

     

       
122
       
 
       
		})

     

       
123
       
-
       
	case models.CommitOperationDelete:

     

       
124
       
 
       
		err = db.DeleteStarByRkey(i.Db, did, e.Commit.RKey)

     

       
125
       
 
       
	}

     

       
126
       
 
       


     
···

       
131
       
 
       
	return nil

     

       
132
       
 
       
}

     

       
133
       
 
       


     

       
134
       
-
       
func (i *Ingester) ingestFollow(e *models.Event) error {

     

       
135
       
 
       
	var err error

     

       
136
       
 
       
	did := e.Did

     

       
137
       
 
       


     
···

       
139
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
140
       
 
       


     

       
141
       
 
       
	switch e.Commit.Operation {

     

       
142
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
143
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
144
       
 
       
		record := tangled.GraphFollow{}

     

       
145
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
153
       
 
       
			SubjectDid: record.Subject,

     

       
154
       
 
       
			Rkey:       e.Commit.RKey,

     

       
155
       
 
       
		})

     

       
156
       
-
       
	case models.CommitOperationDelete:

     

       
157
       
 
       
		err = db.DeleteFollowByRkey(i.Db, did, e.Commit.RKey)

     

       
158
       
 
       
	}

     

       
159
       
 
       


     
···

       
164
       
 
       
	return nil

     

       
165
       
 
       
}

     

       
166
       
 
       


     

       
167
       
-
       
func (i *Ingester) ingestPublicKey(e *models.Event) error {

     

       
168
       
 
       
	did := e.Did

     

       
169
       
 
       
	var err error

     

       
170
       
 
       


     
···

       
172
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
173
       
 
       


     

       
174
       
 
       
	switch e.Commit.Operation {

     

       
175
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
176
       
 
       
		l.Debug("processing add of pubkey")

     

       
177
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
178
       
 
       
		record := tangled.PublicKey{}

     
···

       
185
       
 
       
		name := record.Name

     

       
186
       
 
       
		key := record.Key

     

       
187
       
 
       
		err = db.AddPublicKey(i.Db, did, name, key, e.Commit.RKey)

     

       
188
       
-
       
	case models.CommitOperationDelete:

     

       
189
       
 
       
		l.Debug("processing delete of pubkey")

     

       
190
       
 
       
		err = db.DeletePublicKeyByRkey(i.Db, did, e.Commit.RKey)

     

       
191
       
 
       
	}

     
···

       
197
       
 
       
	return nil

     

       
198
       
 
       
}

     

       
199
       
 
       


     

       
200
       
-
       
func (i *Ingester) ingestArtifact(e *models.Event) error {

     

       
201
       
 
       
	did := e.Did

     

       
202
       
 
       
	var err error

     

       
203
       
 
       


     
···

       
205
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
206
       
 
       


     

       
207
       
 
       
	switch e.Commit.Operation {

     

       
208
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
209
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
210
       
 
       
		record := tangled.RepoArtifact{}

     

       
211
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
234
       
 
       
			createdAt = time.Now()

     

       
235
       
 
       
		}

     

       
236
       
 
       


     

       
237
       
-
       
		artifact := db.Artifact{

     

       
238
       
 
       
			Did:       did,

     

       
239
       
 
       
			Rkey:      e.Commit.RKey,

     

       
240
       
 
       
			RepoAt:    repoAt,

     
···

       
247
       
 
       
		}

     

       
248
       
 
       


     

       
249
       
 
       
		err = db.AddArtifact(i.Db, artifact)

     

       
250
       
-
       
	case models.CommitOperationDelete:

     

       
251
       
 
       
		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       
252
       
 
       
	}

     

       
253
       
 
       


     
···

       
258
       
 
       
	return nil

     

       
259
       
 
       
}

     

       
260
       
 
       


     

       
261
       
-
       
func (i *Ingester) ingestProfile(e *models.Event) error {

     

       
262
       
 
       
	did := e.Did

     

       
263
       
 
       
	var err error

     

       
264
       
 
       


     
···

       
270
       
 
       
	}

     

       
271
       
 
       


     

       
272
       
 
       
	switch e.Commit.Operation {

     

       
273
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
274
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
275
       
 
       
		record := tangled.ActorProfile{}

     

       
276
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
338
       
 
       
		}

     

       
339
       
 
       


     

       
340
       
 
       
		err = db.UpsertProfile(tx, &profile)

     

       
341
       
-
       
	case models.CommitOperationDelete:

     

       
342
       
 
       
		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       
343
       
 
       
	}

     

       
344
       
 
       


     
···

       
349
       
 
       
	return nil

     

       
350
       
 
       
}

     

       
351
       
 
       


     

       
352
       
-
       
func (i *Ingester) ingestSpindleMember(ctx context.Context, e *models.Event) error {

     

       
353
       
 
       
	did := e.Did

     

       
354
       
 
       
	var err error

     

       
355
       
 
       


     
···

       
357
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
358
       
 
       


     

       
359
       
 
       
	switch e.Commit.Operation {

     

       
360
       
-
       
	case models.CommitOperationCreate:

     

       
361
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
362
       
 
       
		record := tangled.SpindleMember{}

     

       
363
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
402
       
 
       
		}

     

       
403
       
 
       


     

       
404
       
 
       
		l.Info("added spindle member")

     

       
405
       
-
       
	case models.CommitOperationDelete:

     

       
406
       
 
       
		rkey := e.Commit.RKey

     

       
407
       
 
       


     

       
408
       
 
       
		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       
455
       
 
       
	return nil

     

       
456
       
 
       
}

     

       
457
       
 
       


     

       
458
       
-
       
func (i *Ingester) ingestSpindle(ctx context.Context, e *models.Event) error {

     

       
459
       
 
       
	did := e.Did

     

       
460
       
 
       
	var err error

     

       
461
       
 
       


     
···

       
463
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
464
       
 
       


     

       
465
       
 
       
	switch e.Commit.Operation {

     

       
466
       
-
       
	case models.CommitOperationCreate:

     

       
467
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
468
       
 
       
		record := tangled.Spindle{}

     

       
469
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
501
       
 
       


     

       
502
       
 
       
		return nil

     

       
503
       
 
       


     

       
504
       
-
       
	case models.CommitOperationDelete:

     

       
505
       
 
       
		instance := e.Commit.RKey

     

       
506
       
 
       


     

       
507
       
 
       
		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       
569
       
 
       
	return nil

     

       
570
       
 
       
}

     

       
571
       
 
       


     

       
572
       
-
       
func (i *Ingester) ingestString(e *models.Event) error {

     

       
573
       
 
       
	did := e.Did

     

       
574
       
 
       
	rkey := e.Commit.RKey

     

       
575
       
 
       


     
···

       
584
       
 
       
	}

     

       
585
       
 
       


     

       
586
       
 
       
	switch e.Commit.Operation {

     

       
587
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
588
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
589
       
 
       
		record := tangled.String{}

     

       
590
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
607
       
 
       


     

       
608
       
 
       
		return nil

     

       
609
       
 
       


     

       
610
       
-
       
	case models.CommitOperationDelete:

     

       
611
       
 
       
		if err := db.DeleteString(

     

       
612
       
 
       
			ddb,

     

       
613
       
 
       
			db.FilterEq("did", did),

     
···

       
623
       
 
       
	return nil

     

       
624
       
 
       
}

     

       
625
       
 
       


     

       
626
       
-
       
func (i *Ingester) ingestKnotMember(e *models.Event) error {

     

       
627
       
 
       
	did := e.Did

     

       
628
       
 
       
	var err error

     

       
629
       
 
       


     
···

       
631
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
632
       
 
       


     

       
633
       
 
       
	switch e.Commit.Operation {

     

       
634
       
-
       
	case models.CommitOperationCreate:

     

       
635
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
636
       
 
       
		record := tangled.KnotMember{}

     

       
637
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
661
       
 
       
		}

     

       
662
       
 
       


     

       
663
       
 
       
		l.Info("added knot member")

     

       
664
       
-
       
	case models.CommitOperationDelete:

     

       
665
       
 
       
		// we don't store knot members in a table (like we do for spindle)

     

       
666
       
 
       
		// and we can't remove this just yet. possibly fixed if we switch

     

       
667
       
 
       
		// to either:

     
···

       
675
       
 
       
	return nil

     

       
676
       
 
       
}

     

       
677
       
 
       


     

       
678
       
-
       
func (i *Ingester) ingestKnot(e *models.Event) error {

     

       
679
       
 
       
	did := e.Did

     

       
680
       
 
       
	var err error

     

       
681
       
 
       


     
···

       
683
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
684
       
 
       


     

       
685
       
 
       
	switch e.Commit.Operation {

     

       
686
       
-
       
	case models.CommitOperationCreate:

     

       
687
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
688
       
 
       
		record := tangled.Knot{}

     

       
689
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
718
       
 
       


     

       
719
       
 
       
		return nil

     

       
720
       
 
       


     

       
721
       
-
       
	case models.CommitOperationDelete:

     

       
722
       
 
       
		domain := e.Commit.RKey

     

       
723
       
 
       


     

       
724
       
 
       
		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       
778
       
 
       


     

       
779
       
 
       
	return nil

     

       
780
       
 
       
}

     

       
781
       
-
       
func (i *Ingester) ingestIssue(ctx context.Context, e *models.Event) error {

     

       
782
       
 
       
	did := e.Did

     

       
783
       
 
       
	rkey := e.Commit.RKey

     

       
784
       
 
       


     
···

       
793
       
 
       
	}

     

       
794
       
 
       


     

       
795
       
 
       
	switch e.Commit.Operation {

     

       
796
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
797
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
798
       
 
       
		record := tangled.RepoIssue{}

     

       
799
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
829
       
 
       


     

       
830
       
 
       
		return nil

     

       
831
       
 
       


     

       
832
       
-
       
	case models.CommitOperationDelete:

     

       
833
       
 
       
		if err := db.DeleteIssues(

     

       
834
       
 
       
			ddb,

     

       
835
       
 
       
			db.FilterEq("did", did),

     
···

       
845
       
 
       
	return nil

     

       
846
       
 
       
}

     

       
847
       
 
       


     

       
848
       
-
       
func (i *Ingester) ingestIssueComment(e *models.Event) error {

     

       
849
       
 
       
	did := e.Did

     

       
850
       
 
       
	rkey := e.Commit.RKey

     

       
851
       
 
       


     
···

       
860
       
 
       
	}

     

       
861
       
 
       


     

       
862
       
 
       
	switch e.Commit.Operation {

     

       
863
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
864
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
865
       
 
       
		record := tangled.RepoIssueComment{}

     

       
866
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
884
       
 
       


     

       
885
       
 
       
		return nil

     

       
886
       
 
       


     

       
887
       
-
       
	case models.CommitOperationDelete:

     

       
888
       
 
       
		if err := db.DeleteIssueComments(

     

       
889
       
 
       
			ddb,

     

       
890
       
 
       
			db.FilterEq("did", did),

     
···

       
899
       
 
       
	return nil

     

       
900
       
 
       
}

     

       
901
       
 
       


     

       
902
       
-
       
func (i *Ingester) ingestLabelDefinition(e *models.Event) error {

     

       
903
       
 
       
	did := e.Did

     

       
904
       
 
       
	rkey := e.Commit.RKey

     

       
905
       
 
       


     
···

       
914
       
 
       
	}

     

       
915
       
 
       


     

       
916
       
 
       
	switch e.Commit.Operation {

     

       
917
       
-
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
918
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
919
       
 
       
		record := tangled.LabelDefinition{}

     

       
920
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
938
       
 
       


     

       
939
       
 
       
		return nil

     

       
940
       
 
       


     

       
941
       
-
       
	case models.CommitOperationDelete:

     

       
942
       
 
       
		if err := db.DeleteLabelDefinition(

     

       
943
       
 
       
			ddb,

     

       
944
       
 
       
			db.FilterEq("did", did),

     

···

       
9
       
 
       
	"time"

     

       
10
       
 
       


     

       
11
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
12
       
+
       
	jmodels "github.com/bluesky-social/jetstream/pkg/models"

     

       
13
       
 
       
	"github.com/go-git/go-git/v5/plumbing"

     

       
14
       
 
       
	"github.com/ipfs/go-cid"

     

       
15
       
 
       
	"tangled.org/core/api/tangled"

     

       
16
       
 
       
	"tangled.org/core/appview/config"

     

       
17
       
 
       
	"tangled.org/core/appview/db"

     

       
18
       
+
       
	"tangled.org/core/appview/models"

     

       
19
       
 
       
	"tangled.org/core/appview/serververify"

     

       
20
       
 
       
	"tangled.org/core/appview/validator"

     

       
21
       
 
       
	"tangled.org/core/idresolver"

     
···

       
31
       
 
       
	Validator  *validator.Validator

     

       
32
       
 
       
}

     

       
33
       
 
       


     

       
34
       
+
       
type processFunc func(ctx context.Context, e *jmodels.Event) error

     

       
35
       
 
       


     

       
36
       
 
       
func (i *Ingester) Ingest() processFunc {

     

       
37
       
+
       
	return func(ctx context.Context, e *jmodels.Event) error {

     

       
38
       
 
       
		var err error

     

       
39
       
 
       
		defer func() {

     

       
40
       
 
       
			eventTime := e.TimeUS

     
···

       
46
       
 
       


     

       
47
       
 
       
		l := i.Logger.With("kind", e.Kind)

     

       
48
       
 
       
		switch e.Kind {

     

       
49
       
+
       
		case jmodels.EventKindAccount:

     

       
50
       
 
       
			if !e.Account.Active && *e.Account.Status == "deactivated" {

     

       
51
       
 
       
				err = i.IdResolver.InvalidateIdent(ctx, e.Account.Did)

     

       
52
       
 
       
			}

     

       
53
       
+
       
		case jmodels.EventKindIdentity:

     

       
54
       
 
       
			err = i.IdResolver.InvalidateIdent(ctx, e.Identity.Did)

     

       
55
       
+
       
		case jmodels.EventKindCommit:

     

       
56
       
 
       
			switch e.Commit.Collection {

     

       
57
       
 
       
			case tangled.GraphFollowNSID:

     

       
58
       
 
       
				err = i.ingestFollow(e)

     
···

       
92
       
 
       
	}

     

       
93
       
 
       
}

     

       
94
       
 
       


     

       
95
       
+
       
func (i *Ingester) ingestStar(e *jmodels.Event) error {

     

       
96
       
 
       
	var err error

     

       
97
       
 
       
	did := e.Did

     

       
98
       
 
       


     
···

       
100
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
101
       
 
       


     

       
102
       
 
       
	switch e.Commit.Operation {

     

       
103
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
104
       
 
       
		var subjectUri syntax.ATURI

     

       
105
       
 
       


     

       
106
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     
···

       
121
       
 
       
			RepoAt:       subjectUri,

     

       
122
       
 
       
			Rkey:         e.Commit.RKey,

     

       
123
       
 
       
		})

     

       
124
       
+
       
	case jmodels.CommitOperationDelete:

     

       
125
       
 
       
		err = db.DeleteStarByRkey(i.Db, did, e.Commit.RKey)

     

       
126
       
 
       
	}

     

       
127
       
 
       


     
···

       
132
       
 
       
	return nil

     

       
133
       
 
       
}

     

       
134
       
 
       


     

       
135
       
+
       
func (i *Ingester) ingestFollow(e *jmodels.Event) error {

     

       
136
       
 
       
	var err error

     

       
137
       
 
       
	did := e.Did

     

       
138
       
 
       


     
···

       
140
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
141
       
 
       


     

       
142
       
 
       
	switch e.Commit.Operation {

     

       
143
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
144
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
145
       
 
       
		record := tangled.GraphFollow{}

     

       
146
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
154
       
 
       
			SubjectDid: record.Subject,

     

       
155
       
 
       
			Rkey:       e.Commit.RKey,

     

       
156
       
 
       
		})

     

       
157
       
+
       
	case jmodels.CommitOperationDelete:

     

       
158
       
 
       
		err = db.DeleteFollowByRkey(i.Db, did, e.Commit.RKey)

     

       
159
       
 
       
	}

     

       
160
       
 
       


     
···

       
165
       
 
       
	return nil

     

       
166
       
 
       
}

     

       
167
       
 
       


     

       
168
       
+
       
func (i *Ingester) ingestPublicKey(e *jmodels.Event) error {

     

       
169
       
 
       
	did := e.Did

     

       
170
       
 
       
	var err error

     

       
171
       
 
       


     
···

       
173
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
174
       
 
       


     

       
175
       
 
       
	switch e.Commit.Operation {

     

       
176
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
177
       
 
       
		l.Debug("processing add of pubkey")

     

       
178
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
179
       
 
       
		record := tangled.PublicKey{}

     
···

       
186
       
 
       
		name := record.Name

     

       
187
       
 
       
		key := record.Key

     

       
188
       
 
       
		err = db.AddPublicKey(i.Db, did, name, key, e.Commit.RKey)

     

       
189
       
+
       
	case jmodels.CommitOperationDelete:

     

       
190
       
 
       
		l.Debug("processing delete of pubkey")

     

       
191
       
 
       
		err = db.DeletePublicKeyByRkey(i.Db, did, e.Commit.RKey)

     

       
192
       
 
       
	}

     
···

       
198
       
 
       
	return nil

     

       
199
       
 
       
}

     

       
200
       
 
       


     

       
201
       
+
       
func (i *Ingester) ingestArtifact(e *jmodels.Event) error {

     

       
202
       
 
       
	did := e.Did

     

       
203
       
 
       
	var err error

     

       
204
       
 
       


     
···

       
206
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
207
       
 
       


     

       
208
       
 
       
	switch e.Commit.Operation {

     

       
209
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
210
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
211
       
 
       
		record := tangled.RepoArtifact{}

     

       
212
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
235
       
 
       
			createdAt = time.Now()

     

       
236
       
 
       
		}

     

       
237
       
 
       


     

       
238
       
+
       
		artifact := models.Artifact{

     

       
239
       
 
       
			Did:       did,

     

       
240
       
 
       
			Rkey:      e.Commit.RKey,

     

       
241
       
 
       
			RepoAt:    repoAt,

     
···

       
248
       
 
       
		}

     

       
249
       
 
       


     

       
250
       
 
       
		err = db.AddArtifact(i.Db, artifact)

     

       
251
       
+
       
	case jmodels.CommitOperationDelete:

     

       
252
       
 
       
		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       
253
       
 
       
	}

     

       
254
       
 
       


     
···

       
259
       
 
       
	return nil

     

       
260
       
 
       
}

     

       
261
       
 
       


     

       
262
       
+
       
func (i *Ingester) ingestProfile(e *jmodels.Event) error {

     

       
263
       
 
       
	did := e.Did

     

       
264
       
 
       
	var err error

     

       
265
       
 
       


     
···

       
271
       
 
       
	}

     

       
272
       
 
       


     

       
273
       
 
       
	switch e.Commit.Operation {

     

       
274
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
275
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
276
       
 
       
		record := tangled.ActorProfile{}

     

       
277
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
339
       
 
       
		}

     

       
340
       
 
       


     

       
341
       
 
       
		err = db.UpsertProfile(tx, &profile)

     

       
342
       
+
       
	case jmodels.CommitOperationDelete:

     

       
343
       
 
       
		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       
344
       
 
       
	}

     

       
345
       
 
       


     
···

       
350
       
 
       
	return nil

     

       
351
       
 
       
}

     

       
352
       
 
       


     

       
353
       
+
       
func (i *Ingester) ingestSpindleMember(ctx context.Context, e *jmodels.Event) error {

     

       
354
       
 
       
	did := e.Did

     

       
355
       
 
       
	var err error

     

       
356
       
 
       


     
···

       
358
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
359
       
 
       


     

       
360
       
 
       
	switch e.Commit.Operation {

     

       
361
       
+
       
	case jmodels.CommitOperationCreate:

     

       
362
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
363
       
 
       
		record := tangled.SpindleMember{}

     

       
364
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
403
       
 
       
		}

     

       
404
       
 
       


     

       
405
       
 
       
		l.Info("added spindle member")

     

       
406
       
+
       
	case jmodels.CommitOperationDelete:

     

       
407
       
 
       
		rkey := e.Commit.RKey

     

       
408
       
 
       


     

       
409
       
 
       
		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       
456
       
 
       
	return nil

     

       
457
       
 
       
}

     

       
458
       
 
       


     

       
459
       
+
       
func (i *Ingester) ingestSpindle(ctx context.Context, e *jmodels.Event) error {

     

       
460
       
 
       
	did := e.Did

     

       
461
       
 
       
	var err error

     

       
462
       
 
       


     
···

       
464
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
465
       
 
       


     

       
466
       
 
       
	switch e.Commit.Operation {

     

       
467
       
+
       
	case jmodels.CommitOperationCreate:

     

       
468
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
469
       
 
       
		record := tangled.Spindle{}

     

       
470
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
502
       
 
       


     

       
503
       
 
       
		return nil

     

       
504
       
 
       


     

       
505
       
+
       
	case jmodels.CommitOperationDelete:

     

       
506
       
 
       
		instance := e.Commit.RKey

     

       
507
       
 
       


     

       
508
       
 
       
		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       
570
       
 
       
	return nil

     

       
571
       
 
       
}

     

       
572
       
 
       


     

       
573
       
+
       
func (i *Ingester) ingestString(e *jmodels.Event) error {

     

       
574
       
 
       
	did := e.Did

     

       
575
       
 
       
	rkey := e.Commit.RKey

     

       
576
       
 
       


     
···

       
585
       
 
       
	}

     

       
586
       
 
       


     

       
587
       
 
       
	switch e.Commit.Operation {

     

       
588
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
589
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
590
       
 
       
		record := tangled.String{}

     

       
591
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
608
       
 
       


     

       
609
       
 
       
		return nil

     

       
610
       
 
       


     

       
611
       
+
       
	case jmodels.CommitOperationDelete:

     

       
612
       
 
       
		if err := db.DeleteString(

     

       
613
       
 
       
			ddb,

     

       
614
       
 
       
			db.FilterEq("did", did),

     
···

       
624
       
 
       
	return nil

     

       
625
       
 
       
}

     

       
626
       
 
       


     

       
627
       
+
       
func (i *Ingester) ingestKnotMember(e *jmodels.Event) error {

     

       
628
       
 
       
	did := e.Did

     

       
629
       
 
       
	var err error

     

       
630
       
 
       


     
···

       
632
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
633
       
 
       


     

       
634
       
 
       
	switch e.Commit.Operation {

     

       
635
       
+
       
	case jmodels.CommitOperationCreate:

     

       
636
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
637
       
 
       
		record := tangled.KnotMember{}

     

       
638
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
662
       
 
       
		}

     

       
663
       
 
       


     

       
664
       
 
       
		l.Info("added knot member")

     

       
665
       
+
       
	case jmodels.CommitOperationDelete:

     

       
666
       
 
       
		// we don't store knot members in a table (like we do for spindle)

     

       
667
       
 
       
		// and we can't remove this just yet. possibly fixed if we switch

     

       
668
       
 
       
		// to either:

     
···

       
676
       
 
       
	return nil

     

       
677
       
 
       
}

     

       
678
       
 
       


     

       
679
       
+
       
func (i *Ingester) ingestKnot(e *jmodels.Event) error {

     

       
680
       
 
       
	did := e.Did

     

       
681
       
 
       
	var err error

     

       
682
       
 
       


     
···

       
684
       
 
       
	l = l.With("nsid", e.Commit.Collection)

     

       
685
       
 
       


     

       
686
       
 
       
	switch e.Commit.Operation {

     

       
687
       
+
       
	case jmodels.CommitOperationCreate:

     

       
688
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
689
       
 
       
		record := tangled.Knot{}

     

       
690
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
719
       
 
       


     

       
720
       
 
       
		return nil

     

       
721
       
 
       


     

       
722
       
+
       
	case jmodels.CommitOperationDelete:

     

       
723
       
 
       
		domain := e.Commit.RKey

     

       
724
       
 
       


     

       
725
       
 
       
		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       
779
       
 
       


     

       
780
       
 
       
	return nil

     

       
781
       
 
       
}

     

       
782
       
+
       
func (i *Ingester) ingestIssue(ctx context.Context, e *jmodels.Event) error {

     

       
783
       
 
       
	did := e.Did

     

       
784
       
 
       
	rkey := e.Commit.RKey

     

       
785
       
 
       


     
···

       
794
       
 
       
	}

     

       
795
       
 
       


     

       
796
       
 
       
	switch e.Commit.Operation {

     

       
797
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
798
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
799
       
 
       
		record := tangled.RepoIssue{}

     

       
800
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
830
       
 
       


     

       
831
       
 
       
		return nil

     

       
832
       
 
       


     

       
833
       
+
       
	case jmodels.CommitOperationDelete:

     

       
834
       
 
       
		if err := db.DeleteIssues(

     

       
835
       
 
       
			ddb,

     

       
836
       
 
       
			db.FilterEq("did", did),

     
···

       
846
       
 
       
	return nil

     

       
847
       
 
       
}

     

       
848
       
 
       


     

       
849
       
+
       
func (i *Ingester) ingestIssueComment(e *jmodels.Event) error {

     

       
850
       
 
       
	did := e.Did

     

       
851
       
 
       
	rkey := e.Commit.RKey

     

       
852
       
 
       


     
···

       
861
       
 
       
	}

     

       
862
       
 
       


     

       
863
       
 
       
	switch e.Commit.Operation {

     

       
864
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
865
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
866
       
 
       
		record := tangled.RepoIssueComment{}

     

       
867
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
885
       
 
       


     

       
886
       
 
       
		return nil

     

       
887
       
 
       


     

       
888
       
+
       
	case jmodels.CommitOperationDelete:

     

       
889
       
 
       
		if err := db.DeleteIssueComments(

     

       
890
       
 
       
			ddb,

     

       
891
       
 
       
			db.FilterEq("did", did),

     
···

       
900
       
 
       
	return nil

     

       
901
       
 
       
}

     

       
902
       
 
       


     

       
903
       
+
       
func (i *Ingester) ingestLabelDefinition(e *jmodels.Event) error {

     

       
904
       
 
       
	did := e.Did

     

       
905
       
 
       
	rkey := e.Commit.RKey

     

       
906
       
 
       


     
···

       
915
       
 
       
	}

     

       
916
       
 
       


     

       
917
       
 
       
	switch e.Commit.Operation {

     

       
918
       
+
       
	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       
919
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
920
       
 
       
		record := tangled.LabelDefinition{}

     

       
921
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
939
       
 
       


     

       
940
       
 
       
		return nil

     

       
941
       
 
       


     

       
942
       
+
       
	case jmodels.CommitOperationDelete:

     

       
943
       
 
       
		if err := db.DeleteLabelDefinition(

     

       
944
       
 
       
			ddb,

     

       
945
       
 
       
			db.FilterEq("did", did),

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
package models

     

       
2
       
+
       


     

       
3
       
+
       
import (

     

       
4
       
+
       
	"fmt"

     

       
5
       
+
       
	"time"

     

       
6
       
+
       


     

       
7
       
+
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
8
       
+
       
	"github.com/go-git/go-git/v5/plumbing"

     

       
9
       
+
       
	"github.com/ipfs/go-cid"

     

       
10
       
+
       
	"tangled.org/core/api/tangled"

     

       
11
       
+
       
)

     

       
12
       
+
       


     

       
13
       
+
       
type Artifact struct {

     

       
14
       
+
       
	Id   uint64

     

       
15
       
+
       
	Did  string

     

       
16
       
+
       
	Rkey string

     

       
17
       
+
       


     

       
18
       
+
       
	RepoAt    syntax.ATURI

     

       
19
       
+
       
	Tag       plumbing.Hash

     

       
20
       
+
       
	CreatedAt time.Time

     

       
21
       
+
       


     

       
22
       
+
       
	BlobCid  cid.Cid

     

       
23
       
+
       
	Name     string

     

       
24
       
+
       
	Size     uint64

     

       
25
       
+
       
	MimeType string

     

       
26
       
+
       
}

     

       
27
       
+
       


     

       
28
       
+
       
func (a *Artifact) ArtifactAt() syntax.ATURI {

     

       
29
       
+
       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey))

     

       
30
       
+
       
}

     

···

       
20
       
 
       
	"tangled.org/core/appview/commitverify"

     

       
21
       
 
       
	"tangled.org/core/appview/config"

     

       
22
       
 
       
	"tangled.org/core/appview/db"

     

       
0
       
 
       

     

       
23
       
 
       
	"tangled.org/core/appview/oauth"

     

       
24
       
 
       
	"tangled.org/core/appview/pages/markup"

     

       
25
       
 
       
	"tangled.org/core/appview/pages/repoinfo"

     
···

       
729
       
 
       
	RepoInfo     repoinfo.RepoInfo

     

       
730
       
 
       
	Active       string

     

       
731
       
 
       
	types.RepoTagsResponse

     

       
732
       
-
       
	ArtifactMap       map[plumbing.Hash][]db.Artifact

     

       
733
       
-
       
	DanglingArtifacts []db.Artifact

     

       
734
       
 
       
}

     

       
735
       
 
       


     

       
736
       
 
       
func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {

     
···

       
741
       
 
       
type RepoArtifactParams struct {

     

       
742
       
 
       
	LoggedInUser *oauth.User

     

       
743
       
 
       
	RepoInfo     repoinfo.RepoInfo

     

       
744
       
-
       
	Artifact     db.Artifact

     

       
745
       
 
       
}

     

       
746
       
 
       


     

       
747
       
 
       
func (p *Pages) RepoArtifactFragment(w io.Writer, params RepoArtifactParams) error {

     

···

       
20
       
 
       
	"tangled.org/core/appview/commitverify"

     

       
21
       
 
       
	"tangled.org/core/appview/config"

     

       
22
       
 
       
	"tangled.org/core/appview/db"

     

       
23
       
+
       
	"tangled.org/core/appview/models"

     

       
24
       
 
       
	"tangled.org/core/appview/oauth"

     

       
25
       
 
       
	"tangled.org/core/appview/pages/markup"

     

       
26
       
 
       
	"tangled.org/core/appview/pages/repoinfo"

     
···

       
730
       
 
       
	RepoInfo     repoinfo.RepoInfo

     

       
731
       
 
       
	Active       string

     

       
732
       
 
       
	types.RepoTagsResponse

     

       
733
       
+
       
	ArtifactMap       map[plumbing.Hash][]models.Artifact

     

       
734
       
+
       
	DanglingArtifacts []models.Artifact

     

       
735
       
 
       
}

     

       
736
       
 
       


     

       
737
       
 
       
func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {

     
···

       
742
       
 
       
type RepoArtifactParams struct {

     

       
743
       
 
       
	LoggedInUser *oauth.User

     

       
744
       
 
       
	RepoInfo     repoinfo.RepoInfo

     

       
745
       
+
       
	Artifact     models.Artifact

     

       
746
       
 
       
}

     

       
747
       
 
       


     

       
748
       
 
       
func (p *Pages) RepoArtifactFragment(w io.Writer, params RepoArtifactParams) error {

     

···

       
18
       
 
       
	"github.com/ipfs/go-cid"

     

       
19
       
 
       
	"tangled.org/core/api/tangled"

     

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

     

       
0
       
 
       

     

       
21
       
 
       
	"tangled.org/core/appview/pages"

     

       
22
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
23
       
 
       
	"tangled.org/core/appview/xrpcclient"

     
···

       
100
       
 
       
	}

     

       
101
       
 
       
	defer tx.Rollback()

     

       
102
       
 
       


     

       
103
       
-
       
	artifact := db.Artifact{

     

       
104
       
 
       
		Did:       user.Did,

     

       
105
       
 
       
		Rkey:      rkey,

     

       
106
       
 
       
		RepoAt:    f.RepoAt(),

     

···

       
18
       
 
       
	"github.com/ipfs/go-cid"

     

       
19
       
 
       
	"tangled.org/core/api/tangled"

     

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

     

       
21
       
+
       
	"tangled.org/core/appview/models"

     

       
22
       
 
       
	"tangled.org/core/appview/pages"

     

       
23
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
24
       
 
       
	"tangled.org/core/appview/xrpcclient"

     
···

       
101
       
 
       
	}

     

       
102
       
 
       
	defer tx.Rollback()

     

       
103
       
 
       


     

       
104
       
+
       
	artifact := models.Artifact{

     

       
105
       
 
       
		Did:       user.Did,

     

       
106
       
 
       
		Rkey:      rkey,

     

       
107
       
 
       
		RepoAt:    f.RepoAt(),

     

···

       
24
       
 
       
	"tangled.org/core/appview/commitverify"

     

       
25
       
 
       
	"tangled.org/core/appview/config"

     

       
26
       
 
       
	"tangled.org/core/appview/db"

     

       
0
       
 
       

     

       
27
       
 
       
	"tangled.org/core/appview/notify"

     

       
28
       
 
       
	"tangled.org/core/appview/oauth"

     

       
29
       
 
       
	"tangled.org/core/appview/pages"

     
···

       
575
       
 
       
	}

     

       
576
       
 
       


     

       
577
       
 
       
	// convert artifacts to map for easy UI building

     

       
578
       
-
       
	artifactMap := make(map[plumbing.Hash][]db.Artifact)

     

       
579
       
 
       
	for _, a := range artifacts {

     

       
580
       
 
       
		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)

     

       
581
       
 
       
	}

     

       
582
       
 
       


     

       
583
       
-
       
	var danglingArtifacts []db.Artifact

     

       
584
       
 
       
	for _, a := range artifacts {

     

       
585
       
 
       
		found := false

     

       
586
       
 
       
		for _, t := range result.Tags {

     

···

       
24
       
 
       
	"tangled.org/core/appview/commitverify"

     

       
25
       
 
       
	"tangled.org/core/appview/config"

     

       
26
       
 
       
	"tangled.org/core/appview/db"

     

       
27
       
+
       
	"tangled.org/core/appview/models"

     

       
28
       
 
       
	"tangled.org/core/appview/notify"

     

       
29
       
 
       
	"tangled.org/core/appview/oauth"

     

       
30
       
 
       
	"tangled.org/core/appview/pages"

     
···

       
576
       
 
       
	}

     

       
577
       
 
       


     

       
578
       
 
       
	// convert artifacts to map for easy UI building

     

       
579
       
+
       
	artifactMap := make(map[plumbing.Hash][]models.Artifact)

     

       
580
       
 
       
	for _, a := range artifacts {

     

       
581
       
 
       
		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)

     

       
582
       
 
       
	}

     

       
583
       
 
       


     

       
584
       
+
       
	var danglingArtifacts []models.Artifact

     

       
585
       
 
       
	for _, a := range artifacts {

     

       
586
       
 
       
		found := false

     

       
587
       
 
       
		for _, t := range result.Tags {