appview/pulls: remove dependencies to `oauth.MultiAccountUser`

In most helper methods, DID is enough. Don't pass entire session info.

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

appview/pulls/pulls.go

···
 		fromFork := r.FormValue("fork")
 		sourceBranch := r.FormValue("sourceBranch")
 		patch := r.FormValue("patch")
+		userDid := syntax.DID(user.Active.Did)
 
 		if targetBranch == "" {
 			s.pages.Notice(w, "pull", "Target branch is required.")
···
 		}
 
 		// Determine PR type based on input parameters
-		roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
+		roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(userDid.String(), f.Knot, f.DidSlashRepo())}
 		isPushAllowed := roles.IsPushAllowed()
 		isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""
 		isForkBased := fromFork != "" && sourceBranch != ""
···
 				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")
 				return
 			}
-			s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)
+			s.handleBranchBasedPull(w, r, f, userDid, title, body, targetBranch, sourceBranch, isStacked)
 		} else if isForkBased {
 			if !caps.PullRequests.ForkSubmissions {
 				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")
 				return
 			}
-			s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
+			s.handleForkBasedPull(w, r, f, userDid, fromFork, title, body, targetBranch, sourceBranch, isStacked)
 		} else if isPatchBased {
 			if !caps.PullRequests.PatchSubmissions {
 				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")
 				return
 			}
-			s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)
+			s.handlePatchBasedPull(w, r, f, userDid, title, body, targetBranch, patch, isStacked)
 		}
 		return
 	}
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.MultiAccountUser,
+	userDid syntax.DID,
 	title,
 	body,
 	targetBranch,
···
 		Sha:    comparison.Rev2,
 	}
 
-	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
+	s.createPullRequest(w, r, repo, userDid, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
 }
 
-func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.MultiAccountUser, title, body, targetBranch, patch string, isStacked bool) {
+func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, userDid syntax.DID, title, body, targetBranch, patch string, isStacked bool) {
 	if err := s.validator.ValidatePatch(&patch); err != nil {
 		s.logger.Error("patch validation failed", "err", err)
 		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
 		return
 	}
 
-	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)
+	s.createPullRequest(w, r, repo, userDid, title, body, targetBranch, patch, "", "", nil, nil, isStacked)
 }
 
-func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.MultiAccountUser, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
+func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, userDid syntax.DID, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
 	repoString := strings.SplitN(forkRepo, "/", 2)
 	forkOwnerDid := repoString[0]
 	repoName := repoString[1]
···
 		Sha:    sourceRev,
 	}
 
-	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
+	s.createPullRequest(w, r, repo, userDid, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
 }
 
 func (s *Pulls) createPullRequest(
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.MultiAccountUser,
+	userDid syntax.DID,
 	title, body, targetBranch string,
 	patch string,
 	combined string,
···
 			w,
 			r,
 			repo,
-			user,
+			userDid,
 			targetBranch,
 			patch,
 			sourceRev,
···
 		Title:        title,
 		Body:         body,
 		TargetBranch: targetBranch,
-		OwnerDid:     user.Active.Did,
+		OwnerDid:     userDid.String(),
 		RepoAt:       repo.RepoAt(),
 		Rkey:         rkey,
 		Mentions:     mentions,
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoPullNSID,
-		Repo:       user.Active.Did,
+		Repo:       userDid.String(),
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoPull{
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.MultiAccountUser,
+	userDid syntax.DID,
 	targetBranch string,
 	patch string,
 	sourceRev string,
···
 
 	// build a stack out of this patch
 	stackId := uuid.New()
-	stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String())
+	stack, err := s.newStack(r.Context(), repo, userDid, targetBranch, patch, pullSource, stackId.String())
 	if err != nil {
 		log.Println("failed to create stack", err)
 		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))
···
 		})
 	}
 	_, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
-		Repo:   user.Active.Did,
+		Repo:   userDid.String(),
 		Writes: writes,
 	})
 	if err != nil {
···
 		return
 	}
 
+	if user == nil || user.Active.Did != pull.OwnerDid {
+		log.Println("unauthorized user")
+		w.WriteHeader(http.StatusUnauthorized)
+		return
+	}
+
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
 		return
 	}
 
-	if user.Active.Did != pull.OwnerDid {
-		log.Println("unauthorized user")
-		w.WriteHeader(http.StatusUnauthorized)
-		return
-	}
-
 	patch := r.FormValue("patch")
 
-	s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")
+	s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, "", "")
 }
 
 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
···
 		return
 	}
 
-	f, err := s.repoResolver.Resolve(r)
-	if err != nil {
-		log.Println("failed to get repo and knot", err)
+	if user == nil || user.Active.Did != pull.OwnerDid {
+		log.Println("unauthorized user")
+		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
 
-	if user.Active.Did != pull.OwnerDid {
-		log.Println("unauthorized user")
-		w.WriteHeader(http.StatusUnauthorized)
+	f, err := s.repoResolver.Resolve(r)
+	if err != nil {
+		log.Println("failed to get repo and knot", err)
 		return
 	}
 
···
 	patch := comparison.FormatPatchRaw
 	combined := comparison.CombinedPatchRaw
 
-	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
+	s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, combined, sourceRev)
 }
 
 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
···
 		return
 	}
 
+	if user == nil || user.Active.Did != pull.OwnerDid {
+		log.Println("unauthorized user")
+		w.WriteHeader(http.StatusUnauthorized)
+		return
+	}
+
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
 		return
 	}
 
-	if user.Active.Did != pull.OwnerDid {
-		log.Println("unauthorized user")
-		w.WriteHeader(http.StatusUnauthorized)
-		return
-	}
-
 	forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
 	if err != nil {
 		log.Println("failed to get source repo", err)
···
 	patch := comparison.FormatPatchRaw
 	combined := comparison.CombinedPatchRaw
 
-	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
+	s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, combined, sourceRev)
 }
 
 func (s *Pulls) resubmitPullHelper(
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.MultiAccountUser,
+	userDid syntax.DID,
 	pull *models.Pull,
 	patch string,
 	combined string,
···
 ) {
 	if pull.IsStacked() {
 		log.Println("resubmitting stacked PR")
-		s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)
+		s.resubmitStackedPullHelper(w, r, repo, userDid, pull, patch, pull.StackId)
 		return
 	}
 
···
 		return
 	}
 
-	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Active.Did, pull.Rkey)
+	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, userDid.String(), pull.Rkey)
 	if err != nil {
 		// failed to get record
 		s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoPullNSID,
-		Repo:       user.Active.Did,
+		Repo:       userDid.String(),
 		Rkey:       pull.Rkey,
 		SwapRecord: ex.Cid,
 		Record: &lexutil.LexiconTypeDecoder{
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.MultiAccountUser,
+	userDid syntax.DID,
 	pull *models.Pull,
 	patch string,
 	stackId string,
···
 	targetBranch := pull.TargetBranch
 
 	origStack, _ := r.Context().Value("stack").(models.Stack)
-	newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId)
+	newStack, err := s.newStack(r.Context(), repo, userDid, targetBranch, patch, pull.PullSource, stackId)
 	if err != nil {
 		log.Println("failed to create resubmitted stack", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
 	}
 
 	_, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
-		Repo:   user.Active.Did,
+		Repo:   userDid.String(),
 		Writes: writes,
 	})
 	if err != nil {
···
 	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
 }
 
-func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.MultiAccountUser, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
+func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, userDid syntax.DID, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
 	formatPatches, err := patchutil.ExtractPatches(patch)
 	if err != nil {
 		return nil, fmt.Errorf("Failed to extract patches: %v", err)
···
 			Title:        title,
 			Body:         body,
 			TargetBranch: targetBranch,
-			OwnerDid:     user.Active.Did,
+			OwnerDid:     userDid.String(),
 			RepoAt:       repo.RepoAt(),
 			Rkey:         rkey,
 			Mentions:     mentions,