patch of appview/notify: merge `NewPullClosed/Merged/Reopen` to `NewPullState` · round #5 · pull #711 · tangled.org/core

+1 -10

appview/indexer/notifier.go

···

       46
       46
        
       	}

     

       47
       47
        
       }

     

       48
       48
        
       

     

       49
       49
       -
       func (ix *Indexer) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       50
       50
       -
       	l := log.FromContext(ctx).With("notifier", "indexer", "pull", pull)

     

       51
       51
       -
       	l.Debug("updating a pr")

     

       52
       52
       -
       	err := ix.Pulls.Index(ctx, pull)

     

       53
       53
       -
       	if err != nil {

     

       54
       54
       -
       		l.Error("failed to index a pr", "err", err)

     

       55
       55
       -
       	}

     

       56
       56
       -
       }

     

       57
       57
       -
       

     

       58
       58
       -
       func (ix *Indexer) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       49
       49
       +
       func (ix *Indexer) NewPullState(ctx context.Context, pull *models.Pull) {

     

       59
       50
        
       	l := log.FromContext(ctx).With("notifier", "indexer", "pull", pull)

     

       60
       51
        
       	l.Debug("updating a pr")

     

       61
       52
        
       	err := ix.Pulls.Index(ctx, pull)

+12 -93

appview/notify/db/db.go

···

       328
       328
        
       	)

     

       329
       329
        
       }

     

       330
       330
        
       

     

       331
       331
       -
       func (n *databaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       331
       331
       +
       func (n *databaseNotifier) NewPullState(ctx context.Context, pull *models.Pull) {

     

       332
       332
        
       	// Get repo details

     

       333
       333
        
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       334
       334
        
       	if err != nil {

     

       335
       335
       -
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       335
       335
       +
       		log.Printf("NewPullState: failed to get repos: %v", err)

     

       336
       336
        
       		return

     

       337
       337
        
       	}

     

       338
       338
        
       

     
···

       354
       354
        
       	}

     

       355
       355
        
       

     

       356
       356
        
       	actorDid := syntax.DID(repo.Did)

     

       357
       357
       -
       	eventType := models.NotificationTypePullMerged

     

       358
       357
        
       	entityType := "pull"

     

       359
       358
        
       	entityId := pull.PullAt().String()

     

       360
       359
        
       	repoId := &repo.Id

     

       361
       360
        
       	var issueId *int64

     

       362
       362
       -
       	p := int64(pull.ID)

     

       363
       363
       -
       	pullId := &p

     

       364
       364
       -
       

     

       365
       365
       -
       	n.notifyEvent(

     

       366
       366
       -
       		actorDid,

     

       367
       367
       -
       		recipients,

     

       368
       368
       -
       		eventType,

     

       369
       369
       -
       		entityType,

     

       370
       370
       -
       		entityId,

     

       371
       371
       -
       		repoId,

     

       372
       372
       -
       		issueId,

     

       373
       373
       -
       		pullId,

     

       374
       374
       -
       	)

     

       375
       375
       -
       }

     

       376
       376
       -
       

     

       377
       377
       -
       func (n *databaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       378
       378
       -
       	// Get repo details

     

       379
       379
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       380
       380
       -
       	if err != nil {

     

       381
       381
       -
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       382
       382
       -
       		return

     

       383
       383
       -
       	}

     

       384
       384
       -
       

     

       385
       385
       -
       	// build up the recipients list:

     

       386
       386
       -
       	// - repo owner

     

       387
       387
       -
       	// - all pull participants

     

       388
       388
       -
       	var recipients []syntax.DID

     

       389
       389
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       390
       390
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       391
       391
       -
       	if err != nil {

     

       392
       392
       -
       		log.Printf("failed to fetch collaborators: %v", err)

     

       393
       393
       -
       		return

     

       394
       394
       -
       	}

     

       395
       395
       -
       	for _, c := range collaborators {

     

       396
       396
       -
       		recipients = append(recipients, c.SubjectDid)

     

       397
       397
       -
       	}

     

       398
       398
       -
       	for _, p := range pull.Participants() {

     

       399
       399
       -
       		recipients = append(recipients, syntax.DID(p))

     

       400
       400
       -
       	}

     

       401
       401
       -
       

     

       402
       402
       -
       	actorDid := syntax.DID(repo.Did)

     

       403
       403
       -
       	eventType := models.NotificationTypePullClosed

     

       404
       404
       -
       	entityType := "pull"

     

       405
       405
       -
       	entityId := pull.PullAt().String()

     

       406
       406
       -
       	repoId := &repo.Id

     

       407
       407
       -
       	var issueId *int64

     

       408
       408
       -
       	p := int64(pull.ID)

     

       409
       409
       -
       	pullId := &p

     

       410
       410
       -
       

     

       411
       411
       -
       	n.notifyEvent(

     

       412
       412
       -
       		actorDid,

     

       413
       413
       -
       		recipients,

     

       414
       414
       -
       		eventType,

     

       415
       415
       -
       		entityType,

     

       416
       416
       -
       		entityId,

     

       417
       417
       -
       		repoId,

     

       418
       418
       -
       		issueId,

     

       419
       419
       -
       		pullId,

     

       420
       420
       -
       	)

     

       421
       421
       -
       }

     

       422
       422
       -
       

     

       423
       423
       -
       func (n *databaseNotifier) NewPullReopen(ctx context.Context, pull *models.Pull) {

     

       424
       424
       -
       	// Get repo details

     

       425
       425
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       426
       426
       -
       	if err != nil {

     

       427
       427
       -
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       428
       428
       -
       		return

     

       429
       429
       -
       	}

     

       430
       430
       -
       

     

       431
       431
       -
       	// build up the recipients list:

     

       432
       432
       -
       	// - repo owner

     

       433
       433
       -
       	// - all pull participants

     

       434
       434
       -
       	var recipients []syntax.DID

     

       435
       435
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       436
       436
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       437
       437
       -
       	if err != nil {

     

       438
       438
       -
       		log.Printf("failed to fetch collaborators: %v", err)

     

       361
       361
       +
       	var eventType models.NotificationType

     

       362
       362
       +
       	switch pull.State {

     

       363
       363
       +
       	case models.PullClosed:

     

       364
       364
       +
       		eventType = models.NotificationTypePullClosed

     

       365
       365
       +
       	case models.PullOpen:

     

       366
       366
       +
       		eventType = models.NotificationTypePullReopen

     

       367
       367
       +
       	case models.PullMerged:

     

       368
       368
       +
       		eventType = models.NotificationTypePullMerged

     

       369
       369
       +
       	default:

     

       370
       370
       +
       		log.Println("NewPullState: unexpected new PR state:", pull.State)

     

       439
       371
        
       		return

     

       440
       372
        
       	}

     

       441
       441
       -
       	for _, c := range collaborators {

     

       442
       442
       -
       		recipients = append(recipients, c.SubjectDid)

     

       443
       443
       -
       	}

     

       444
       444
       -
       	for _, p := range pull.Participants() {

     

       445
       445
       -
       		recipients = append(recipients, syntax.DID(p))

     

       446
       446
       -
       	}

     

       447
       447
       -
       

     

       448
       448
       -
       	actorDid := syntax.DID(repo.Did)

     

       449
       449
       -
       	eventType := models.NotificationTypePullReopen

     

       450
       450
       -
       	entityType := "pull"

     

       451
       451
       -
       	entityId := pull.PullAt().String()

     

       452
       452
       -
       	repoId := &repo.Id

     

       453
       453
       -
       	var issueId *int64

     

       454
       373
        
       	p := int64(pull.ID)

     

       455
       374
        
       	pullId := &p

     

       456
       375

+2 -10

appview/notify/merged_notifier.go

···

       85
       85
        
       	m.fanout("NewPullComment", ctx, comment)

     

       86
       86
        
       }

     

       87
       87
        
       

     

       88
       88
       -
       func (m *mergedNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       89
       89
       -
       	m.fanout("NewPullMerged", ctx, pull)

     

       90
       90
       -
       }

     

       91
       91
       -
       

     

       92
       92
       -
       func (m *mergedNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       93
       93
       -
       	m.fanout("NewPullClosed", ctx, pull)

     

       94
       94
       -
       }

     

       95
       95
       -
       

     

       96
       96
       -
       func (m *mergedNotifier) NewPullReopen(ctx context.Context, pull *models.Pull) {

     

       97
       97
       -
       	m.fanout("NewPullReopen", ctx, pull)

     

       88
       88
       +
       func (m *mergedNotifier) NewPullState(ctx context.Context, pull *models.Pull) {

     

       89
       89
       +
       	m.fanout("NewPullState", ctx, pull)

     

       98
       90
        
       }

     

       99
       91
        
       

     

       100
       92
        
       func (m *mergedNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {

+2 -6

appview/notify/notifier.go

···

       22
       22
        
       

     

       23
       23
        
       	NewPull(ctx context.Context, pull *models.Pull)

     

       24
       24
        
       	NewPullComment(ctx context.Context, comment *models.PullComment)

     

       25
       25
       -
       	NewPullMerged(ctx context.Context, pull *models.Pull)

     

       26
       26
       -
       	NewPullClosed(ctx context.Context, pull *models.Pull)

     

       27
       27
       -
       	NewPullReopen(ctx context.Context, pull *models.Pull)

     

       25
       25
       +
       	NewPullState(ctx context.Context, pull *models.Pull)

     

       28
       26
        
       

     

       29
       27
        
       	UpdateProfile(ctx context.Context, profile *models.Profile)

     

       30
       28
        
       

     
···

       53
       51
        
       

     

       54
       52
        
       func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull)                 {}

     

       55
       53
        
       func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.PullComment) {}

     

       56
       56
       -
       func (m *BaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull)           {}

     

       57
       57
       -
       func (m *BaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull)           {}

     

       58
       58
       -
       func (m *BaseNotifier) NewPullReopen(ctx context.Context, pull *models.Pull)           {}

     

       54
       54
       +
       func (m *BaseNotifier) NewPullState(ctx context.Context, pull *models.Pull)            {}

     

       59
       55
        
       

     

       60
       56
        
       func (m *BaseNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {}

     

       61
       57

+14 -2

appview/notify/posthog/notifier.go

···

       210
       210
        
       	}

     

       211
       211
        
       }

     

       212
       212
        
       

     

       213
       213
       -
       func (n *posthogNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       213
       213
       +
       func (n *posthogNotifier) NewPullState(ctx context.Context, pull *models.Pull) {

     

       214
       214
       +
       	var event string

     

       215
       215
       +
       	switch pull.State {

     

       216
       216
       +
       	case models.PullClosed:

     

       217
       217
       +
       		event = "pull_closed"

     

       218
       218
       +
       	case models.PullOpen:

     

       219
       219
       +
       		event = "pull_reopen"

     

       220
       220
       +
       	case models.PullMerged:

     

       221
       221
       +
       		event = "pull_merged"

     

       222
       222
       +
       	default:

     

       223
       223
       +
       		log.Println("posthog: unexpected new PR state:", pull.State)

     

       224
       224
       +
       		return

     

       225
       225
       +
       	}

     

       214
       226
        
       	err := n.client.Enqueue(posthog.Capture{

     

       215
       227
        
       		DistinctId: pull.OwnerDid,

     

       216
       216
       -
       		Event:      "pull_merged",

     

       228
       228
       +
       		Event:      event,

     

       217
       229
        
       		Properties: posthog.Properties{

     

       218
       230
        
       			"repo_at": pull.RepoAt,

     

       219
       231
        
       			"pull_id": pull.PullId,

+3 -3

appview/pulls/pulls.go

···

       2216
       2216
        
       

     

       2217
       2217
        
       	// notify about the pull merge

     

       2218
       2218
        
       	for _, p := range pullsToMerge {

     

       2219
       2219
       -
       		s.notifier.NewPullMerged(r.Context(), p)

     

       2219
       2219
       +
       		s.notifier.NewPullState(r.Context(), p)

     

       2220
       2220
        
       	}

     

       2221
       2221
        
       

     

       2222
       2222
        
       	s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))

     
···

       2288
       2288
        
       	}

     

       2289
       2289
        
       

     

       2290
       2290
        
       	for _, p := range pullsToClose {

     

       2291
       2291
       -
       		s.notifier.NewPullClosed(r.Context(), p)

     

       2291
       2291
       +
       		s.notifier.NewPullState(r.Context(), p)

     

       2292
       2292
        
       	}

     

       2293
       2293
        
       

     

       2294
       2294
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     
···

       2361
       2361
        
       	}

     

       2362
       2362
        
       

     

       2363
       2363
        
       	for _, p := range pullsToReopen {

     

       2364
       2364
       -
       		s.notifier.NewPullReopen(r.Context(), p)

     

       2364
       2364
       +
       		s.notifier.NewPullState(r.Context(), p)

     

       2365
       2365
        
       	}

     

       2366
       2366
        
       

     

       2367
       2367
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))