tjh.dev
forked from
tangled.org/core
Mirror of @tangled.org/core. Running on a Raspberry Pi Zero 2
appview/notify: introduce loggingNotifier as a separate notifier
this was previously clubbed into mergedNotifier. this changeset also
employes the new context-logger in every notifier.
Signed-off-by: oppiliappan <me@oppi.li>
authored by
+42
-14
appview/notify/db/db.go
+42
-14
appview/notify/db/db.go
···
2
3
import (
4
"context"
5
-
"log"
6
"slices"
7
8
"github.com/bluesky-social/indigo/atproto/syntax"
···
10
"tangled.org/core/appview/models"
11
"tangled.org/core/appview/notify"
12
"tangled.org/core/idresolver"
13
"tangled.org/core/orm"
14
"tangled.org/core/sets"
15
)
···
38
}
39
40
func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {
41
if star.RepoAt.Collection().String() != tangled.RepoNSID {
42
// skip string stars for now
43
return
···
47
var err error
48
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(star.RepoAt)))
49
if err != nil {
50
-
log.Printf("NewStar: failed to get repos: %v", err)
51
return
52
}
53
···
61
var pullId *int64
62
63
n.notifyEvent(
64
actorDid,
65
recipients,
66
eventType,
···
78
}
79
80
func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
81
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))
82
if err != nil {
83
-
log.Printf("failed to fetch collaborators: %v", err)
84
return
85
}
86
···
106
var pullId *int64
107
108
n.notifyEvent(
109
actorDid,
110
recipients,
111
models.NotificationTypeIssueCreated,
···
117
pullId,
118
)
119
n.notifyEvent(
120
actorDid,
121
sets.Collect(slices.Values(mentions)),
122
models.NotificationTypeUserMentioned,
···
130
}
131
132
func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
133
issues, err := db.GetIssues(n.db, orm.FilterEq("at_uri", comment.IssueAt))
134
if err != nil {
135
-
log.Printf("NewIssueComment: failed to get issues: %v", err)
136
return
137
}
138
if len(issues) == 0 {
139
-
log.Printf("NewIssueComment: no issue found for %s", comment.IssueAt)
140
return
141
}
142
issue := issues[0]
···
179
var pullId *int64
180
181
n.notifyEvent(
182
actorDid,
183
recipients,
184
models.NotificationTypeIssueCommented,
···
190
pullId,
191
)
192
n.notifyEvent(
193
actorDid,
194
sets.Collect(slices.Values(mentions)),
195
models.NotificationTypeUserMentioned,
···
215
var repoId, issueId, pullId *int64
216
217
n.notifyEvent(
218
actorDid,
219
recipients,
220
eventType,
···
232
}
233
234
func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {
235
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))
236
if err != nil {
237
-
log.Printf("NewPull: failed to get repos: %v", err)
238
return
239
}
240
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))
241
if err != nil {
242
-
log.Printf("failed to fetch collaborators: %v", err)
243
return
244
}
245
···
263
pullId := &p
264
265
n.notifyEvent(
266
actorDid,
267
recipients,
268
eventType,
···
276
}
277
278
func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) {
279
pull, err := db.GetPull(n.db,
280
syntax.ATURI(comment.RepoAt),
281
comment.PullId,
282
)
283
if err != nil {
284
-
log.Printf("NewPullComment: failed to get pulls: %v", err)
285
return
286
}
287
288
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", comment.RepoAt))
289
if err != nil {
290
-
log.Printf("NewPullComment: failed to get repos: %v", err)
291
return
292
}
293
···
315
pullId := &p
316
317
n.notifyEvent(
318
actorDid,
319
recipients,
320
eventType,
···
326
pullId,
327
)
328
n.notifyEvent(
329
actorDid,
330
sets.Collect(slices.Values(mentions)),
331
models.NotificationTypeUserMentioned,
···
355
}
356
357
func (n *databaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {
358
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))
359
if err != nil {
360
-
log.Printf("failed to fetch collaborators: %v", err)
361
return
362
}
363
···
389
}
390
391
n.notifyEvent(
392
actor,
393
recipients,
394
eventType,
···
402
}
403
404
func (n *databaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {
405
// Get repo details
406
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))
407
if err != nil {
408
-
log.Printf("NewPullState: failed to get repos: %v", err)
409
return
410
}
411
412
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))
413
if err != nil {
414
-
log.Printf("failed to fetch collaborators: %v", err)
415
return
416
}
417
···
441
case models.PullMerged:
442
eventType = models.NotificationTypePullMerged
443
default:
444
-
log.Println("NewPullState: unexpected new PR state:", pull.State)
445
return
446
}
447
p := int64(pull.ID)
448
pullId := &p
449
450
n.notifyEvent(
451
actor,
452
recipients,
453
eventType,
···
461
}
462
463
func (n *databaseNotifier) notifyEvent(
464
actorDid syntax.DID,
465
recipients sets.Set[syntax.DID],
466
eventType models.NotificationType,
···
471
issueId *int64,
472
pullId *int64,
473
) {
474
// if the user is attempting to mention >maxMentions users, this is probably spam, do not mention anybody
475
if eventType == models.NotificationTypeUserMentioned && recipients.Len() > maxMentions {
476
return
···
522
}
523
524
if err := db.CreateNotification(tx, notif); err != nil {
525
-
log.Printf("notifyEvent: failed to create notification for %s: %v", recipientDid, err)
526
}
527
}
528
···
2
3
import (
4
"context"
5
"slices"
6
7
"github.com/bluesky-social/indigo/atproto/syntax"
···
11
"tangled.org/core/appview/models"
12
"tangled.org/core/appview/notify"
13
"tangled.org/core/idresolver"
14
+
"tangled.org/core/log"
15
"tangled.org/core/orm"
16
"tangled.org/core/sets"
17
)
···
38
}
39
40
func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {
41
+
l := log.FromContext(ctx)
42
+
43
if star.RepoAt.Collection().String() != tangled.RepoNSID {
44
// skip string stars for now
45
return
···
45
var err error
46
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(star.RepoAt)))
47
if err != nil {
48
+
l.Error("failed to get repos", "err", err)
49
return
50
}
51
···
59
var pullId *int64
60
61
n.notifyEvent(
62
+
ctx,
63
actorDid,
64
recipients,
65
eventType,
···
75
}
76
77
func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
78
+
l := log.FromContext(ctx)
79
+
80
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))
81
if err != nil {
82
+
l.Error("failed to fetch collaborators", "err", err)
83
return
84
}
85
···
101
var pullId *int64
102
103
n.notifyEvent(
104
+
ctx,
105
actorDid,
106
recipients,
107
models.NotificationTypeIssueCreated,
···
111
pullId,
112
)
113
n.notifyEvent(
114
+
ctx,
115
actorDid,
116
sets.Collect(slices.Values(mentions)),
117
models.NotificationTypeUserMentioned,
···
123
}
124
125
func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
126
+
l := log.FromContext(ctx)
127
+
128
issues, err := db.GetIssues(n.db, orm.FilterEq("at_uri", comment.IssueAt))
129
if err != nil {
130
+
l.Error("failed to get issues", "err", err)
131
return
132
}
133
if len(issues) == 0 {
134
+
l.Error("no issue found for", "err", comment.IssueAt)
135
return
136
}
137
issue := issues[0]
···
170
var pullId *int64
171
172
n.notifyEvent(
173
+
ctx,
174
actorDid,
175
recipients,
176
models.NotificationTypeIssueCommented,
···
180
pullId,
181
)
182
n.notifyEvent(
183
+
ctx,
184
actorDid,
185
sets.Collect(slices.Values(mentions)),
186
models.NotificationTypeUserMentioned,
···
204
var repoId, issueId, pullId *int64
205
206
n.notifyEvent(
207
+
ctx,
208
actorDid,
209
recipients,
210
eventType,
···
220
}
221
222
func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {
223
+
l := log.FromContext(ctx)
224
+
225
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))
226
if err != nil {
227
+
l.Error("failed to get repos", "err", err)
228
return
229
}
230
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))
231
if err != nil {
232
+
l.Error("failed to fetch collaborators", "err", err)
233
return
234
}
235
···
249
pullId := &p
250
251
n.notifyEvent(
252
+
ctx,
253
actorDid,
254
recipients,
255
eventType,
···
261
}
262
263
func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) {
264
+
l := log.FromContext(ctx)
265
+
266
pull, err := db.GetPull(n.db,
267
syntax.ATURI(comment.RepoAt),
268
comment.PullId,
269
)
270
if err != nil {
271
+
l.Error("failed to get pulls", "err", err)
272
return
273
}
274
275
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", comment.RepoAt))
276
if err != nil {
277
+
l.Error("failed to get repos", "err", err)
278
return
279
}
280
···
298
pullId := &p
299
300
n.notifyEvent(
301
+
ctx,
302
actorDid,
303
recipients,
304
eventType,
···
308
pullId,
309
)
310
n.notifyEvent(
311
+
ctx,
312
actorDid,
313
sets.Collect(slices.Values(mentions)),
314
models.NotificationTypeUserMentioned,
···
336
}
337
338
func (n *databaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {
339
+
l := log.FromContext(ctx)
340
+
341
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))
342
if err != nil {
343
+
l.Error("failed to fetch collaborators", "err", err)
344
return
345
}
346
···
368
}
369
370
n.notifyEvent(
371
+
ctx,
372
actor,
373
recipients,
374
eventType,
···
380
}
381
382
func (n *databaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {
383
+
l := log.FromContext(ctx)
384
+
385
// Get repo details
386
repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))
387
if err != nil {
388
+
l.Error("failed to get repos", "err", err)
389
return
390
}
391
392
collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))
393
if err != nil {
394
+
l.Error("failed to fetch collaborators", "err", err)
395
return
396
}
397
···
417
case models.PullMerged:
418
eventType = models.NotificationTypePullMerged
419
default:
420
+
l.Error("unexpected new PR state", "state", pull.State)
421
return
422
}
423
p := int64(pull.ID)
424
pullId := &p
425
426
n.notifyEvent(
427
+
ctx,
428
actor,
429
recipients,
430
eventType,
···
436
}
437
438
func (n *databaseNotifier) notifyEvent(
439
+
ctx context.Context,
440
actorDid syntax.DID,
441
recipients sets.Set[syntax.DID],
442
eventType models.NotificationType,
···
445
issueId *int64,
446
pullId *int64,
447
) {
448
+
l := log.FromContext(ctx)
449
+
450
// if the user is attempting to mention >maxMentions users, this is probably spam, do not mention anybody
451
if eventType == models.NotificationTypeUserMentioned && recipients.Len() > maxMentions {
452
return
···
494
}
495
496
if err := db.CreateNotification(tx, notif); err != nil {
497
+
l.Error("failed to create notification", "recipientDid", recipientDid, "err", err)
498
}
499
}
500
+105
appview/notify/logging_notifier.go
+105
appview/notify/logging_notifier.go
···
···
1
+
package notify
2
+
3
+
import (
4
+
"context"
5
+
"log/slog"
6
+
7
+
"tangled.org/core/appview/models"
8
+
tlog "tangled.org/core/log"
9
+
10
+
"github.com/bluesky-social/indigo/atproto/syntax"
11
+
)
12
+
13
+
type loggingNotifier struct {
14
+
inner Notifier
15
+
logger *slog.Logger
16
+
}
17
+
18
+
func NewLoggingNotifier(inner Notifier, logger *slog.Logger) Notifier {
19
+
return &loggingNotifier{
20
+
inner,
21
+
logger,
22
+
}
23
+
}
24
+
25
+
var _ Notifier = &loggingNotifier{}
26
+
27
+
func (l *loggingNotifier) NewRepo(ctx context.Context, repo *models.Repo) {
28
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewRepo"))
29
+
l.inner.NewRepo(ctx, repo)
30
+
}
31
+
32
+
func (l *loggingNotifier) NewStar(ctx context.Context, star *models.Star) {
33
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewStar"))
34
+
l.inner.NewStar(ctx, star)
35
+
}
36
+
37
+
func (l *loggingNotifier) DeleteStar(ctx context.Context, star *models.Star) {
38
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "DeleteStar"))
39
+
l.inner.DeleteStar(ctx, star)
40
+
}
41
+
42
+
func (l *loggingNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
43
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewIssue"))
44
+
l.inner.NewIssue(ctx, issue, mentions)
45
+
}
46
+
47
+
func (l *loggingNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
48
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewIssueComment"))
49
+
l.inner.NewIssueComment(ctx, comment, mentions)
50
+
}
51
+
52
+
func (l *loggingNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {
53
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewIssueState"))
54
+
l.inner.NewIssueState(ctx, actor, issue)
55
+
}
56
+
57
+
func (l *loggingNotifier) DeleteIssue(ctx context.Context, issue *models.Issue) {
58
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "DeleteIssue"))
59
+
l.inner.DeleteIssue(ctx, issue)
60
+
}
61
+
62
+
func (l *loggingNotifier) NewFollow(ctx context.Context, follow *models.Follow) {
63
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewFollow"))
64
+
l.inner.NewFollow(ctx, follow)
65
+
}
66
+
67
+
func (l *loggingNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {
68
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "DeleteFollow"))
69
+
l.inner.DeleteFollow(ctx, follow)
70
+
}
71
+
72
+
func (l *loggingNotifier) NewPull(ctx context.Context, pull *models.Pull) {
73
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewPull"))
74
+
l.inner.NewPull(ctx, pull)
75
+
}
76
+
77
+
func (l *loggingNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) {
78
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewPullComment"))
79
+
l.inner.NewPullComment(ctx, comment, mentions)
80
+
}
81
+
82
+
func (l *loggingNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {
83
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewPullState"))
84
+
l.inner.NewPullState(ctx, actor, pull)
85
+
}
86
+
87
+
func (l *loggingNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {
88
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "UpdateProfile"))
89
+
l.inner.UpdateProfile(ctx, profile)
90
+
}
91
+
92
+
func (l *loggingNotifier) NewString(ctx context.Context, s *models.String) {
93
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "NewString"))
94
+
l.inner.NewString(ctx, s)
95
+
}
96
+
97
+
func (l *loggingNotifier) EditString(ctx context.Context, s *models.String) {
98
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "EditString"))
99
+
l.inner.EditString(ctx, s)
100
+
}
101
+
102
+
func (l *loggingNotifier) DeleteString(ctx context.Context, did, rkey string) {
103
+
ctx = tlog.IntoContext(ctx, tlog.SubLogger(l.logger, "DeleteString"))
104
+
l.inner.DeleteString(ctx, did, rkey)
105
+
}
+2
-1
appview/state/state.go
+2
-1
appview/state/state.go