appview: refactor with service layer (issues) (wip)

appview/issues/issues.go
-> appview/state/router.go
-> appview/service/issue.go

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

appview/issues/issues.go

···
 	"tangled.sh/tangled.sh/core/appview/reporesolver"
 	"tangled.sh/tangled.sh/core/idresolver"
 	"tangled.sh/tangled.sh/core/tid"
+	"tangled.sh/tangled.sh/core/appview/service"
 )
 
 type Issues struct {
···
 	idResolver   *idresolver.Resolver
 	db           *db.DB
 	config       *config.Config
-	notifier     notify.Notifier
+
+	issue        *service.IssueService
 }
 
 func New(
···
 		idResolver:   idResolver,
 		db:           db,
 		config:       config,
-		notifier:     notifier,
+		issue: service.NewIssueService(
+			db,
+			oauth,
+			notifier,
+		),
 	}
 }
 
···
 			return
 		}
 
-		tx, err := rp.db.BeginTx(r.Context(), nil)
-		if err != nil {
-			rp.pages.Notice(w, "issues", "Failed to create issue, try again later")
-			return
-		}
+		issue, err := rp.issue.Create(r.Context(), f.RepoAt(), title, body)
 
-		issue := &db.Issue{
-			RepoAt:   f.RepoAt(),
-			Rkey:     tid.TID(),
-			Title:    title,
-			Body:     body,
-			OwnerDid: user.Did,
-		}
-		err = db.NewIssue(tx, issue)
 		if err != nil {
 			log.Println("failed to create issue", err)
 			rp.pages.Notice(w, "issues", "Failed to create issue.")
 			return
 		}
-
-		client, err := rp.oauth.AuthorizedClient(r)
-		if err != nil {
-			log.Println("failed to get authorized client", err)
-			rp.pages.Notice(w, "issues", "Failed to create issue.")
-			return
-		}
-		atUri := f.RepoAt().String()
-		_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
-			Collection: tangled.RepoIssueNSID,
-			Repo:       user.Did,
-			Rkey:       issue.Rkey,
-			Record: &lexutil.LexiconTypeDecoder{
-				Val: &tangled.RepoIssue{
-					Repo:    atUri,
-					Title:   title,
-					Body:    &body,
-					Owner:   user.Did,
-					IssueId: int64(issue.IssueId),
-				},
-			},
-		})
-		if err != nil {
-			log.Println("failed to create issue", err)
-			rp.pages.Notice(w, "issues", "Failed to create issue.")
-			return
-		}
-
-		rp.notifier.NewIssue(r.Context(), issue)
 
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))
 		return

appview/service/issue.go

···
+package service
+
+import (
+	"context"
+	"net/http"
+
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+
+	"tangled.sh/tangled.sh/core/api/tangled"
+	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/notify"
+	"tangled.sh/tangled.sh/core/appview/oauth"
+	"tangled.sh/tangled.sh/core/tid"
+)
+
+type IssueService struct {
+	db       *db.DB
+
+	// don't need oauth client if we pass current session through context
+	oauth    *oauth.OAuth
+	notifier notify.Notifier
+}
+
+func NewIssueService(db *db.DB, oauth *oauth.OAuth, notifier notify.Notifier) *IssueService {
+	return &IssueService { db, oauth, notifier }
+}
+
+func (s *IssueService) Create(ctx context.Context, repoAt syntax.ATURI, title string, body string) (*db.Issue, error) {
+	// TODO: replace this to something else
+	// ctx -> session -> user|xrpcclient
+	r := &http.Request{}
+
+	user := s.oauth.GetUser(r)
+	client, err := s.oauth.AuthorizedClient(r)
+	if err != nil {
+		return nil, err
+	}
+
+	issue := &db.Issue{
+		OwnerDid: user.Did,
+		Rkey:     tid.TID(),
+		RepoAt:   repoAt,
+		Title:    title,
+		Body:     body,
+		Open:     true,
+	}
+	tx, err := s.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// add to db first to populate IssueId
+	err = db.NewIssue(tx, issue)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = client.RepoPutRecord(ctx, &comatproto.RepoPutRecord_Input{
+		Collection: tangled.RepoIssueNSID,
+		Repo:       issue.OwnerDid,
+		Rkey:       issue.Rkey,
+		Record: &lexutil.LexiconTypeDecoder{
+			Val: &tangled.RepoIssue{
+				Repo:    issue.RepoAt.String(),
+				Title:   issue.Title,
+				Body:    &issue.Body,
+				Owner:   issue.OwnerDid,
+				IssueId: int64(issue.IssueId),
+			},
+		},
+	})
+
+	s.notifier.NewIssue(ctx, issue)
+
+	return issue, nil
+}
+
+func (s *IssueService) UpdateTitle(issue db.Issue) (db.Issue, error) {
+	panic("not implemented yet")
+}
+
+func (s *IssueService) UpdateBody(issue db.Issue) (db.Issue, error) {
+	panic("not implemented yet")
+}
+
+func (s *IssueService) Close(issue db.Issue) (db.Issue, error) {
+	panic("not implemented yet")
+}
+
+func (s *IssueService) Reopen(issue db.Issue) (db.Issue, error) {
+	panic("not implemented yet")
+}

appview/service/pull.go

···
+package service
+
+import (
+	"context"
+
+	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/oauth"
+)
+
+type PullService struct {
+	db    *db.DB
+	oauth *oauth.OAuth
+}
+
+func (s *PullService) Merge(ctx context.Context, pull *db.Pull) error {
+	// side effects
+	// -> Close related issues
+	// -> Update dependent sub-stacked PRs
+	// -> run search indexer
+	// -> run posthog
+	panic("not implemented yet")
+}
+
+func (s *PullService) Close(ctx context.Context, pull *db.Pull) error {
+	// side effects
+	// -> Close descendent PRs
+	panic("not implemented yet")
+}