appview/notify: notify users mentioned in issues

pass mentioned DIDs on `NewIssue*` events

Signed-off-by: Seongmin Lee <[e-mail]>

appview/indexer/notifier.go

···
 
 var _ notify.Notifier = &Indexer{}
 
-func (ix *Indexer) NewIssue(ctx context.Context, issue *models.Issue) {
+func (ix *Indexer) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
 	l := log.FromContext(ctx).With("notifier", "indexer", "issue", issue)
 	l.Debug("indexing new issue")
 	err := ix.Issues.Index(ctx, *issue)

appview/issues/issues.go

···
 	"tangled.org/core/appview/notify"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
+	"tangled.org/core/appview/pages/markup"
 	"tangled.org/core/appview/pagination"
 	"tangled.org/core/appview/reporesolver"
 	"tangled.org/core/appview/validator"
···
 
 	// notify about the new comment
 	comment.Id = commentId
-	rp.notifier.NewIssueComment(r.Context(), &comment)
+
+	rawMentions := markup.FindUserMentions(comment.Body)
+	idents := rp.idResolver.ResolveIdents(r.Context(), rawMentions)
+	l.Debug("parsed mentions", "raw", rawMentions, "idents", idents)
+	var mentions []syntax.DID
+	for _, ident := range idents {
+		if ident != nil && !ident.Handle.IsInvalidHandle() {
+			mentions = append(mentions, ident.DID)
+		}
+	}
+	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)
 
 	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId))
 }
···
 
 		// everything is successful, do not rollback the atproto record
 		atUri = ""
-		rp.notifier.NewIssue(r.Context(), issue)
+
+		rawMentions := markup.FindUserMentions(issue.Body)
+		idents := rp.idResolver.ResolveIdents(r.Context(), rawMentions)
+		l.Debug("parsed mentions", "raw", rawMentions, "idents", idents)
+		var mentions []syntax.DID
+		for _, ident := range idents {
+			if ident != nil && !ident.Handle.IsInvalidHandle() {
+				mentions = append(mentions, ident.DID)
+			}
+		}
+		rp.notifier.NewIssue(r.Context(), issue, mentions)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))
 		return
 	}

appview/notify/db/db.go

···
 	// no-op
 }
 
-func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue) {
+func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
 
 	// build the recipients list
 	// - owner of the repo
···
 	}
 
 	actorDid := syntax.DID(issue.Did)
-	eventType := models.NotificationTypeIssueCreated
 	entityType := "issue"
 	entityId := issue.AtUri().String()
 	repoId := &issue.Repo.Id
···
 	n.notifyEvent(
 		actorDid,
 		recipients,
-		eventType,
+		models.NotificationTypeIssueCreated,
+		entityType,
+		entityId,
+		repoId,
+		issueId,
+		pullId,
+	)
+	n.notifyEvent(
+		actorDid,
+		mentions,
+		models.NotificationTypeUserMentioned,
 		entityType,
 		entityId,
 		repoId,
···
 	)
 }
 
-func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {
+func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
 	issues, err := db.GetIssues(n.db, db.FilterEq("at_uri", comment.IssueAt))
 	if err != nil {
 		log.Printf("NewIssueComment: failed to get issues: %v", err)
···
 	}
 
 	actorDid := syntax.DID(comment.Did)
-	eventType := models.NotificationTypeIssueCommented
 	entityType := "issue"
 	entityId := issue.AtUri().String()
 	repoId := &issue.Repo.Id
···
 	n.notifyEvent(
 		actorDid,
 		recipients,
-		eventType,
+		models.NotificationTypeIssueCommented,
+		entityType,
+		entityId,
+		repoId,
+		issueId,
+		pullId,
+	)
+	n.notifyEvent(
+		actorDid,
+		mentions,
+		models.NotificationTypeUserMentioned,
 		entityType,
 		entityId,
 		repoId,

appview/notify/merged_notifier.go

···
 	m.fanout("DeleteStar", ctx, star)
 }
 
-func (m *mergedNotifier) NewIssue(ctx context.Context, issue *models.Issue) {
-	m.fanout("NewIssue", ctx, issue)
+func (m *mergedNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
+	m.fanout("NewIssue", ctx, issue, mentions)
 }
 
-func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {
-	m.fanout("NewIssueComment", ctx, comment)
+func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
+	m.fanout("NewIssueComment", ctx, comment, mentions)
 }
 
 func (m *mergedNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {

appview/notify/notifier.go

···
 	NewStar(ctx context.Context, star *models.Star)
 	DeleteStar(ctx context.Context, star *models.Star)
 
-	NewIssue(ctx context.Context, issue *models.Issue)
-	NewIssueComment(ctx context.Context, comment *models.IssueComment)
+	NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID)
+	NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID)
 	NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue)
 	DeleteIssue(ctx context.Context, issue *models.Issue)
 
···
 func (m *BaseNotifier) NewStar(ctx context.Context, star *models.Star)    {}
 func (m *BaseNotifier) DeleteStar(ctx context.Context, star *models.Star) {}
 
-func (m *BaseNotifier) NewIssue(ctx context.Context, issue *models.Issue)                        {}
-func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment)        {}
+func (m *BaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {}
+func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
+}
 func (m *BaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {}
 func (m *BaseNotifier) DeleteIssue(ctx context.Context, issue *models.Issue)                     {}
 

appview/notify/posthog/notifier.go

···
 	}
 }
 
-func (n *posthogNotifier) NewIssue(ctx context.Context, issue *models.Issue) {
+func (n *posthogNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {
 	err := n.client.Enqueue(posthog.Capture{
 		DistinctId: issue.Did,
 		Event:      "new_issue",
 		Properties: posthog.Properties{
 			"repo_at":  issue.RepoAt.String(),
 			"issue_id": issue.IssueId,
+			"mentions": mentions,
 		},
 	})
 	if err != nil {
···
 	}
 }
 
-func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {
+func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {
 	err := n.client.Enqueue(posthog.Capture{
 		DistinctId: comment.Did,
 		Event:      "new_issue_comment",
 		Properties: posthog.Properties{
 			"issue_at": comment.IssueAt,
+			"mentions": mentions,
 		},
 	})
 	if err != nil {

appview/pages/markup/markdown.go

···
 	return path.Join(rctx.CurrentDir, dst)
 }
 
+// FindUserMentions returns Set of user handles from given markup soruce.
+// It doesn't guarntee unique DIDs
+func FindUserMentions(source string) []string {
+	var (
+		mentions    []string
+		mentionsSet = make(map[string]struct{})
+		md          = NewMarkdown()
+		sourceBytes = []byte(source)
+		root        = md.Parser().Parse(text.NewReader(sourceBytes))
+	)
+	ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
+		if entering && n.Kind() == textension.KindAt {
+			handle := n.(*textension.AtNode).Handle
+			mentionsSet[handle] = struct{}{}
+			return ast.WalkSkipChildren, nil
+		}
+		return ast.WalkContinue, nil
+	})
+	for handle := range mentionsSet {
+		mentions = append(mentions, handle)
+	}
+	return mentions
+}
+
 func isAbsoluteUrl(link string) bool {
 	parsed, err := url.Parse(link)
 	if err != nil {