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

··· 956 956 fromFork := r.FormValue("fork") 957 957 sourceBranch := r.FormValue("sourceBranch") 958 958 patch := r.FormValue("patch") 959 + userDid := syntax.DID(user.Active.Did) 959 960 960 961 if targetBranch == "" { 961 962 s.pages.Notice(w, "pull", "Target branch is required.") ··· 963 964 } 964 965 965 966 // Determine PR type based on input parameters 966 - roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())} 967 + roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(userDid.String(), f.Knot, f.DidSlashRepo())} 967 968 isPushAllowed := roles.IsPushAllowed() 968 969 isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == "" 969 970 isForkBased := fromFork != "" && sourceBranch != "" ··· 1041 1042 s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?") 1042 1043 return 1043 1044 } 1044 - s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked) 1045 + s.handleBranchBasedPull(w, r, f, userDid, title, body, targetBranch, sourceBranch, isStacked) 1045 1046 } else if isForkBased { 1046 1047 if !caps.PullRequests.ForkSubmissions { 1047 1048 s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?") 1048 1049 return 1049 1050 } 1050 - s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked) 1051 + s.handleForkBasedPull(w, r, f, userDid, fromFork, title, body, targetBranch, sourceBranch, isStacked) 1051 1052 } else if isPatchBased { 1052 1053 if !caps.PullRequests.PatchSubmissions { 1053 1054 s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.") 1054 1055 return 1055 1056 } 1056 - s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked) 1057 + s.handlePatchBasedPull(w, r, f, userDid, title, body, targetBranch, patch, isStacked) 1057 1058 } 1058 1059 return 1059 1060 } ··· 1063 1064 w http.ResponseWriter, 1064 1065 r *http.Request, 1065 1066 repo *models.Repo, 1066 - user *oauth.MultiAccountUser, 1067 + userDid syntax.DID, 1067 1068 title, 1068 1069 body, 1069 1070 targetBranch, ··· 1117 1118 Sha: comparison.Rev2, 1118 1119 } 1119 1120 1120 - s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1121 + s.createPullRequest(w, r, repo, userDid, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1121 1122 } 1122 1123 1123 - func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.MultiAccountUser, title, body, targetBranch, patch string, isStacked bool) { 1124 + func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, userDid syntax.DID, title, body, targetBranch, patch string, isStacked bool) { 1124 1125 if err := s.validator.ValidatePatch(&patch); err != nil { 1125 1126 s.logger.Error("patch validation failed", "err", err) 1126 1127 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") 1127 1128 return 1128 1129 } 1129 1130 1130 - s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked) 1131 + s.createPullRequest(w, r, repo, userDid, title, body, targetBranch, patch, "", "", nil, nil, isStacked) 1131 1132 } 1132 1133 1133 - 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) { 1134 + 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) { 1134 1135 repoString := strings.SplitN(forkRepo, "/", 2) 1135 1136 forkOwnerDid := repoString[0] 1136 1137 repoName := repoString[1] ··· 1232 1233 Sha: sourceRev, 1233 1234 } 1234 1235 1235 - s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1236 + s.createPullRequest(w, r, repo, userDid, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1236 1237 } 1237 1238 1238 1239 func (s *Pulls) createPullRequest( 1239 1240 w http.ResponseWriter, 1240 1241 r *http.Request, 1241 1242 repo *models.Repo, 1242 - user *oauth.MultiAccountUser, 1243 + userDid syntax.DID, 1243 1244 title, body, targetBranch string, 1244 1245 patch string, 1245 1246 combined string, ··· 1254 1255 w, 1255 1256 r, 1256 1257 repo, 1257 - user, 1258 + userDid, 1258 1259 targetBranch, 1259 1260 patch, 1260 1261 sourceRev, ··· 1311 1312 Title: title, 1312 1313 Body: body, 1313 1314 TargetBranch: targetBranch, 1314 - OwnerDid: user.Active.Did, 1315 + OwnerDid: userDid.String(), 1315 1316 RepoAt: repo.RepoAt(), 1316 1317 Rkey: rkey, 1317 1318 Mentions: mentions, ··· 1343 1344 1344 1345 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 1345 1346 Collection: tangled.RepoPullNSID, 1346 - Repo: user.Active.Did, 1347 + Repo: userDid.String(), 1347 1348 Rkey: rkey, 1348 1349 Record: &lexutil.LexiconTypeDecoder{ 1349 1350 Val: &tangled.RepoPull{ ··· 1380 1381 w http.ResponseWriter, 1381 1382 r *http.Request, 1382 1383 repo *models.Repo, 1383 - user *oauth.MultiAccountUser, 1384 + userDid syntax.DID, 1384 1385 targetBranch string, 1385 1386 patch string, 1386 1387 sourceRev string, ··· 1411 1412 1412 1413 // build a stack out of this patch 1413 1414 stackId := uuid.New() 1414 - stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String()) 1415 + stack, err := s.newStack(r.Context(), repo, userDid, targetBranch, patch, pullSource, stackId.String()) 1415 1416 if err != nil { 1416 1417 log.Println("failed to create stack", err) 1417 1418 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err)) ··· 1448 1449 }) 1449 1450 } 1450 1451 _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{ 1451 - Repo: user.Active.Did, 1452 + Repo: userDid.String(), 1452 1453 Writes: writes, 1453 1454 }) 1454 1455 if err != nil { ··· 1732 1733 return 1733 1734 } 1734 1735 1736 + if user == nil || user.Active.Did != pull.OwnerDid { 1737 + log.Println("unauthorized user") 1738 + w.WriteHeader(http.StatusUnauthorized) 1739 + return 1740 + } 1741 + 1735 1742 f, err := s.repoResolver.Resolve(r) 1736 1743 if err != nil { 1737 1744 log.Println("failed to get repo and knot", err) 1738 1745 return 1739 1746 } 1740 1747 1741 - if user.Active.Did != pull.OwnerDid { 1742 - log.Println("unauthorized user") 1743 - w.WriteHeader(http.StatusUnauthorized) 1744 - return 1745 - } 1746 - 1747 1748 patch := r.FormValue("patch") 1748 1749 1749 - s.resubmitPullHelper(w, r, f, user, pull, patch, "", "") 1750 + s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, "", "") 1750 1751 } 1751 1752 1752 1753 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) { ··· 1759 1760 return 1760 1761 } 1761 1762 1762 - f, err := s.repoResolver.Resolve(r) 1763 - if err != nil { 1764 - log.Println("failed to get repo and knot", err) 1763 + if user == nil || user.Active.Did != pull.OwnerDid { 1764 + log.Println("unauthorized user") 1765 + w.WriteHeader(http.StatusUnauthorized) 1765 1766 return 1766 1767 } 1767 1768 1768 - if user.Active.Did != pull.OwnerDid { 1769 - log.Println("unauthorized user") 1770 - w.WriteHeader(http.StatusUnauthorized) 1769 + f, err := s.repoResolver.Resolve(r) 1770 + if err != nil { 1771 + log.Println("failed to get repo and knot", err) 1771 1772 return 1772 1773 } 1773 1774 ··· 1811 1812 patch := comparison.FormatPatchRaw 1812 1813 combined := comparison.CombinedPatchRaw 1813 1814 1814 - s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev) 1815 + s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, combined, sourceRev) 1815 1816 } 1816 1817 1817 1818 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) { ··· 1824 1825 return 1825 1826 } 1826 1827 1828 + if user == nil || user.Active.Did != pull.OwnerDid { 1829 + log.Println("unauthorized user") 1830 + w.WriteHeader(http.StatusUnauthorized) 1831 + return 1832 + } 1833 + 1827 1834 f, err := s.repoResolver.Resolve(r) 1828 1835 if err != nil { 1829 1836 log.Println("failed to get repo and knot", err) 1830 1837 return 1831 1838 } 1832 1839 1833 - if user.Active.Did != pull.OwnerDid { 1834 - log.Println("unauthorized user") 1835 - w.WriteHeader(http.StatusUnauthorized) 1836 - return 1837 - } 1838 - 1839 1840 forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String()) 1840 1841 if err != nil { 1841 1842 log.Println("failed to get source repo", err) ··· 1908 1909 patch := comparison.FormatPatchRaw 1909 1910 combined := comparison.CombinedPatchRaw 1910 1911 1911 - s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev) 1912 + s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, combined, sourceRev) 1912 1913 } 1913 1914 1914 1915 func (s *Pulls) resubmitPullHelper( 1915 1916 w http.ResponseWriter, 1916 1917 r *http.Request, 1917 1918 repo *models.Repo, 1918 - user *oauth.MultiAccountUser, 1919 + userDid syntax.DID, 1919 1920 pull *models.Pull, 1920 1921 patch string, 1921 1922 combined string, ··· 1923 1924 ) { 1924 1925 if pull.IsStacked() { 1925 1926 log.Println("resubmitting stacked PR") 1926 - s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId) 1927 + s.resubmitStackedPullHelper(w, r, repo, userDid, pull, patch, pull.StackId) 1927 1928 return 1928 1929 } 1929 1930 ··· 1971 1972 return 1972 1973 } 1973 1974 1974 - ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Active.Did, pull.Rkey) 1975 + ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, userDid.String(), pull.Rkey) 1975 1976 if err != nil { 1976 1977 // failed to get record 1977 1978 s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.") ··· 1994 1995 1995 1996 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 1996 1997 Collection: tangled.RepoPullNSID, 1997 - Repo: user.Active.Did, 1998 + Repo: userDid.String(), 1998 1999 Rkey: pull.Rkey, 1999 2000 SwapRecord: ex.Cid, 2000 2001 Record: &lexutil.LexiconTypeDecoder{ ··· 2021 2022 w http.ResponseWriter, 2022 2023 r *http.Request, 2023 2024 repo *models.Repo, 2024 - user *oauth.MultiAccountUser, 2025 + userDid syntax.DID, 2025 2026 pull *models.Pull, 2026 2027 patch string, 2027 2028 stackId string, ··· 2029 2030 targetBranch := pull.TargetBranch 2030 2031 2031 2032 origStack, _ := r.Context().Value("stack").(models.Stack) 2032 - newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId) 2033 + newStack, err := s.newStack(r.Context(), repo, userDid, targetBranch, patch, pull.PullSource, stackId) 2033 2034 if err != nil { 2034 2035 log.Println("failed to create resubmitted stack", err) 2035 2036 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") ··· 2211 2212 } 2212 2213 2213 2214 _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{ 2214 - Repo: user.Active.Did, 2215 + Repo: userDid.String(), 2215 2216 Writes: writes, 2216 2217 }) 2217 2218 if err != nil { ··· 2490 2491 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId)) 2491 2492 } 2492 2493 2493 - func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.MultiAccountUser, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) { 2494 + func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, userDid syntax.DID, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) { 2494 2495 formatPatches, err := patchutil.ExtractPatches(patch) 2495 2496 if err != nil { 2496 2497 return nil, fmt.Errorf("Failed to extract patches: %v", err) ··· 2526 2527 Title: title, 2527 2528 Body: body, 2528 2529 TargetBranch: targetBranch, 2529 - OwnerDid: user.Active.Did, 2530 + OwnerDid: userDid.String(), 2530 2531 RepoAt: repo.RepoAt(), 2531 2532 Rkey: rkey, 2532 2533 Mentions: mentions,