patch of appview: remove `ResolvedRepo` for eternity · round #1 · pull #821 · tangled.org/core

+8 -8

appview/issues/issues.go

···

       103
        
       

     

       104
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       105
        
       		rp.db,

     

       106
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       107
        
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       108
        
       	)

     

       109
        
       	if err != nil {

     
···

       264
        
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       265
        
       

     

       266
        
       	// return to all issues page

     

       267
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       268
        
       	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")

     

       269
        
       }

     

       270
        
       

     
···

       306
        
       		// notify about the issue closure

     

       307
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       308
        
       

     

       309
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       310
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       311
        
       		return

     

       312
        
       	} else {

     
···

       353
        
       		// notify about the issue reopen

     

       354
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       355
        
       

     

       356
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       357
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       358
        
       		return

     

       359
        
       	} else {

     
···

       458
        
       	}

     

       459
        
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       460
        
       

     

       461
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       462
        
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))

     

       463
        
       }

     

       464
        
       

     
···

       827
        
       

     

       828
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       829
        
       		rp.db,

     

       830
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       831
        
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       832
        
       	)

     

       833
        
       	if err != nil {

     
···

       878
        
       			Open:    true,

     

       879
        
       			Did:     user.Did,

     

       880
        
       			Created: time.Now(),

     

       881
       -
       			Repo:    &f.Repo,

     

       882
        
       		}

     

       883
        
       

     

       884
        
       		if err := rp.validator.ValidateIssue(issue); err != nil {

     
···

       957
        
       		}

     

       958
        
       		rp.notifier.NewIssue(r.Context(), issue, mentions)

     

       959
        
       

     

       960
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       961
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       962
        
       		return

     

       963
        
       	}

···

       103
        
       

     

       104
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       105
        
       		rp.db,

     

       106
       +
       		db.FilterIn("at_uri", f.Labels),

     

       107
        
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       108
        
       	)

     

       109
        
       	if err != nil {

     
···

       264
        
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       265
        
       

     

       266
        
       	// return to all issues page

     

       267
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       268
        
       	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")

     

       269
        
       }

     

       270
        
       

     
···

       306
        
       		// notify about the issue closure

     

       307
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       308
        
       

     

       309
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       310
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       311
        
       		return

     

       312
        
       	} else {

     
···

       353
        
       		// notify about the issue reopen

     

       354
        
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       355
        
       

     

       356
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       357
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       358
        
       		return

     

       359
        
       	} else {

     
···

       458
        
       	}

     

       459
        
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       460
        
       

     

       461
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       462
        
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))

     

       463
        
       }

     

       464
        
       

     
···

       827
        
       

     

       828
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       829
        
       		rp.db,

     

       830
       +
       		db.FilterIn("at_uri", f.Labels),

     

       831
        
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       832
        
       	)

     

       833
        
       	if err != nil {

     
···

       878
        
       			Open:    true,

     

       879
        
       			Did:     user.Did,

     

       880
        
       			Created: time.Now(),

     

       881
       +
       			Repo:    f,

     

       882
        
       		}

     

       883
        
       

     

       884
        
       		if err := rp.validator.ValidateIssue(issue); err != nil {

     
···

       957
        
       		}

     

       958
        
       		rp.notifier.NewIssue(r.Context(), issue, mentions)

     

       959
        
       

     

       960
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       961
        
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       962
        
       		return

     

       963
        
       	}

+3 -3

appview/issues/opengraph.go

···

       232
        
       

     

       233
        
       	// Get owner handle for avatar

     

       234
        
       	var ownerHandle string

     

       235
       -
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Repo.Did)

     

       236
        
       	if err != nil {

     

       237
       -
       		ownerHandle = f.Repo.Did

     

       238
        
       	} else {

     

       239
        
       		ownerHandle = "@" + owner.Handle.String()

     

       240
        
       	}

     

       241
        
       

     

       242
       -
       	card, err := rp.drawIssueSummaryCard(issue, &f.Repo, commentCount, ownerHandle)

     

       243
        
       	if err != nil {

     

       244
        
       		log.Println("failed to draw issue summary card", err)

     

       245
        
       		http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)

···

       232
        
       

     

       233
        
       	// Get owner handle for avatar

     

       234
        
       	var ownerHandle string

     

       235
       +
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)

     

       236
        
       	if err != nil {

     

       237
       +
       		ownerHandle = f.Did

     

       238
        
       	} else {

     

       239
        
       		ownerHandle = "@" + owner.Handle.String()

     

       240
        
       	}

     

       241
        
       

     

       242
       +
       	card, err := rp.drawIssueSummaryCard(issue, f, commentCount, ownerHandle)

     

       243
        
       	if err != nil {

     

       244
        
       		log.Println("failed to draw issue summary card", err)

     

       245
        
       		http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)

+1 -1

appview/middleware/middleware.go

···

       327
        
       				return

     

       328
        
       			}

     

       329
        
       

     

       330
       -
       			fullName := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       331
        
       

     

       332
        
       			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {

     

       333
        
       				if r.URL.Query().Get("go-get") == "1" {

···

       327
        
       				return

     

       328
        
       			}

     

       329
        
       

     

       330
       +
       			fullName := reporesolver.GetBaseRepoPath(r, f)

     

       331
        
       

     

       332
        
       			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {

     

       333
        
       				if r.URL.Query().Get("go-get") == "1" {

+1 -1

appview/pulls/opengraph.go

···

       293
        
       		filesChanged = niceDiff.Stat.FilesChanged

     

       294
        
       	}

     

       295
        
       

     

       296
       -
       	card, err := s.drawPullSummaryCard(pull, &f.Repo, commentCount, diffStats, filesChanged)

     

       297
        
       	if err != nil {

     

       298
        
       		log.Println("failed to draw pull summary card", err)

     

       299
        
       		http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)

···

       293
        
       		filesChanged = niceDiff.Stat.FilesChanged

     

       294
        
       	}

     

       295
        
       

     

       296
       +
       	card, err := s.drawPullSummaryCard(pull, f, commentCount, diffStats, filesChanged)

     

       297
        
       	if err != nil {

     

       298
        
       		log.Println("failed to draw pull summary card", err)

     

       299
        
       		http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)

+18 -18

appview/pulls/pulls.go

···

       115
        
       			return

     

       116
        
       		}

     

       117
        
       

     

       118
       -
       		mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)

     

       119
       -
       		branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)

     

       120
        
       		resubmitResult := pages.Unknown

     

       121
        
       		if user.Did == pull.OwnerDid {

     

       122
       -
       			resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)

     

       123
        
       		}

     

       124
        
       

     

       125
        
       		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     
···

       155
        
       	stack, _ := r.Context().Value("stack").(models.Stack)

     

       156
        
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)

     

       157
        
       

     

       158
       -
       	mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)

     

       159
       -
       	branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)

     

       160
        
       	resubmitResult := pages.Unknown

     

       161
        
       	if user != nil && user.Did == pull.OwnerDid {

     

       162
       -
       		resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)

     

       163
        
       	}

     

       164
        
       

     

       165
        
       	m := make(map[string]models.Pipeline)

     
···

       205
        
       

     

       206
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       207
        
       		s.db,

     

       208
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       209
        
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       210
        
       	)

     

       211
        
       	if err != nil {

     
···

       651
        
       

     

       652
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       653
        
       		s.db,

     

       654
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       655
        
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       656
        
       	)

     

       657
        
       	if err != nil {

     
···

       787
        
       		}

     

       788
        
       		s.notifier.NewPullComment(r.Context(), comment, mentions)

     

       789
        
       

     

       790
       -
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       791
        
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))

     

       792
        
       		return

     

       793
        
       	}

     
···

       940
        
       				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")

     

       941
        
       				return

     

       942
        
       			}

     

       943
       -
       			s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked)

     

       944
        
       		} else if isForkBased {

     

       945
        
       			if !caps.PullRequests.ForkSubmissions {

     

       946
        
       				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")

     

       947
        
       				return

     

       948
        
       			}

     

       949
       -
       			s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       950
        
       		} else if isPatchBased {

     

       951
        
       			if !caps.PullRequests.PatchSubmissions {

     

       952
        
       				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")

     

       953
        
       				return

     

       954
        
       			}

     

       955
       -
       			s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked)

     

       956
        
       		}

     

       957
        
       		return

     

       958
        
       	}

     
···

       1619
        
       

     

       1620
        
       	patch := r.FormValue("patch")

     

       1621
        
       

     

       1622
       -
       	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "")

     

       1623
        
       }

     

       1624
        
       

     

       1625
        
       func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {

     
···

       1684
        
       	patch := comparison.FormatPatchRaw

     

       1685
        
       	combined := comparison.CombinedPatchRaw

     

       1686
        
       

     

       1687
       -
       	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)

     

       1688
        
       }

     

       1689
        
       

     

       1690
        
       func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {

     
···

       1781
        
       	patch := comparison.FormatPatchRaw

     

       1782
        
       	combined := comparison.CombinedPatchRaw

     

       1783
        
       

     

       1784
       -
       	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)

     

       1785
        
       }

     

       1786
        
       

     

       1787
        
       func (s *Pulls) resubmitPullHelper(

     
···

       2210
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2211
        
       	}

     

       2212
        
       

     

       2213
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       2214
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2215
        
       }

     

       2216
        
       

     
···

       2283
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2284
        
       	}

     

       2285
        
       

     

       2286
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       2287
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2288
        
       }

     

       2289
        
       

     
···

       2357
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2358
        
       	}

     

       2359
        
       

     

       2360
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       2361
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2362
        
       }

     

       2363

···

       115
        
       			return

     

       116
        
       		}

     

       117
        
       

     

       118
       +
       		mergeCheckResponse := s.mergeCheck(r, f, pull, stack)

     

       119
       +
       		branchDeleteStatus := s.branchDeleteStatus(r, f, pull)

     

       120
        
       		resubmitResult := pages.Unknown

     

       121
        
       		if user.Did == pull.OwnerDid {

     

       122
       +
       			resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       123
        
       		}

     

       124
        
       

     

       125
        
       		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     
···

       155
        
       	stack, _ := r.Context().Value("stack").(models.Stack)

     

       156
        
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)

     

       157
        
       

     

       158
       +
       	mergeCheckResponse := s.mergeCheck(r, f, pull, stack)

     

       159
       +
       	branchDeleteStatus := s.branchDeleteStatus(r, f, pull)

     

       160
        
       	resubmitResult := pages.Unknown

     

       161
        
       	if user != nil && user.Did == pull.OwnerDid {

     

       162
       +
       		resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       163
        
       	}

     

       164
        
       

     

       165
        
       	m := make(map[string]models.Pipeline)

     
···

       205
        
       

     

       206
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       207
        
       		s.db,

     

       208
       +
       		db.FilterIn("at_uri", f.Labels),

     

       209
        
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       210
        
       	)

     

       211
        
       	if err != nil {

     
···

       651
        
       

     

       652
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       653
        
       		s.db,

     

       654
       +
       		db.FilterIn("at_uri", f.Labels),

     

       655
        
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       656
        
       	)

     

       657
        
       	if err != nil {

     
···

       787
        
       		}

     

       788
        
       		s.notifier.NewPullComment(r.Context(), comment, mentions)

     

       789
        
       

     

       790
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       791
        
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))

     

       792
        
       		return

     

       793
        
       	}

     
···

       940
        
       				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")

     

       941
        
       				return

     

       942
        
       			}

     

       943
       +
       			s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)

     

       944
        
       		} else if isForkBased {

     

       945
        
       			if !caps.PullRequests.ForkSubmissions {

     

       946
        
       				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")

     

       947
        
       				return

     

       948
        
       			}

     

       949
       +
       			s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       950
        
       		} else if isPatchBased {

     

       951
        
       			if !caps.PullRequests.PatchSubmissions {

     

       952
        
       				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")

     

       953
        
       				return

     

       954
        
       			}

     

       955
       +
       			s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)

     

       956
        
       		}

     

       957
        
       		return

     

       958
        
       	}

     
···

       1619
        
       

     

       1620
        
       	patch := r.FormValue("patch")

     

       1621
        
       

     

       1622
       +
       	s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")

     

       1623
        
       }

     

       1624
        
       

     

       1625
        
       func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {

     
···

       1684
        
       	patch := comparison.FormatPatchRaw

     

       1685
        
       	combined := comparison.CombinedPatchRaw

     

       1686
        
       

     

       1687
       +
       	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)

     

       1688
        
       }

     

       1689
        
       

     

       1690
        
       func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {

     
···

       1781
        
       	patch := comparison.FormatPatchRaw

     

       1782
        
       	combined := comparison.CombinedPatchRaw

     

       1783
        
       

     

       1784
       +
       	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)

     

       1785
        
       }

     

       1786
        
       

     

       1787
        
       func (s *Pulls) resubmitPullHelper(

     
···

       2210
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2211
        
       	}

     

       2212
        
       

     

       2213
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2214
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2215
        
       }

     

       2216
        
       

     
···

       2283
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2284
        
       	}

     

       2285
        
       

     

       2286
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2287
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2288
        
       }

     

       2289
        
       

     
···

       2357
        
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2358
        
       	}

     

       2359
        
       

     

       2360
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2361
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2362
        
       }

     

       2363

+2 -2

appview/repo/artifact.go

···

       38
        
       		return

     

       39
        
       	}

     

       40
        
       

     

       41
       -
       	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)

     

       42
        
       	if err != nil {

     

       43
        
       		log.Println("failed to resolve tag", err)

     

       44
        
       		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

     
···

       146
        
       	tagParam := chi.URLParam(r, "tag")

     

       147
        
       	filename := chi.URLParam(r, "file")

     

       148
        
       

     

       149
       -
       	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)

     

       150
        
       	if err != nil {

     

       151
        
       		log.Println("failed to resolve tag", err)

     

       152
        
       		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

···

       38
        
       		return

     

       39
        
       	}

     

       40
        
       

     

       41
       +
       	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       42
        
       	if err != nil {

     

       43
        
       		log.Println("failed to resolve tag", err)

     

       44
        
       		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

     
···

       146
        
       	tagParam := chi.URLParam(r, "tag")

     

       147
        
       	filename := chi.URLParam(r, "file")

     

       148
        
       

     

       149
       +
       	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       150
        
       	if err != nil {

     

       151
        
       		log.Println("failed to resolve tag", err)

     

       152
        
       		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

+4 -4

appview/repo/blob.go

···

       54
        
       	xrpcc := &indigoxrpc.Client{

     

       55
        
       		Host: host,

     

       56
        
       	}

     

       57
       -
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)

     

       58
        
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       59
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       60
        
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     
···

       62
        
       		return

     

       63
        
       	}

     

       64
        
       

     

       65
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       66
        
       

     

       67
        
       	// Use XRPC response directly instead of converting to internal types

     

       68
        
       	var breadcrumbs [][]string

     
···

       74
        
       	}

     

       75
        
       

     

       76
        
       	// Create the blob view

     

       77
       -
       	blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query())

     

       78
        
       

     

       79
        
       	user := rp.oauth.GetUser(r)

     

       80
        
       

     
···

       107
        
       	if !rp.config.Core.Dev {

     

       108
        
       		scheme = "https"

     

       109
        
       	}

     

       110
       -
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)

     

       111
        
       	baseURL := &url.URL{

     

       112
        
       		Scheme: scheme,

     

       113
        
       		Host:   f.Knot,

···

       54
        
       	xrpcc := &indigoxrpc.Client{

     

       55
        
       		Host: host,

     

       56
        
       	}

     

       57
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       58
        
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       59
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       60
        
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     
···

       62
        
       		return

     

       63
        
       	}

     

       64
        
       

     

       65
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       66
        
       

     

       67
        
       	// Use XRPC response directly instead of converting to internal types

     

       68
        
       	var breadcrumbs [][]string

     
···

       74
        
       	}

     

       75
        
       

     

       76
        
       	// Create the blob view

     

       77
       +
       	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       78
        
       

     

       79
        
       	user := rp.oauth.GetUser(r)

     

       80
        
       

     
···

       107
        
       	if !rp.config.Core.Dev {

     

       108
        
       		scheme = "https"

     

       109
        
       	}

     

       110
       +
       	repo := f.DidSlashRepo()

     

       111
        
       	baseURL := &url.URL{

     

       112
        
       		Scheme: scheme,

     

       113
        
       		Host:   f.Knot,

+1 -1

appview/repo/feed.go

···

       159
        
       	}

     

       160
        
       	ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name

     

       161
        
       

     

       162
       -
       	feed, err := rp.getRepoFeed(r.Context(), &f.Repo, ownerSlashRepo)

     

       163
        
       	if err != nil {

     

       164
        
       		log.Println("failed to get repo feed:", err)

     

       165
        
       		rp.pages.Error500(w)

···

       159
        
       	}

     

       160
        
       	ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name

     

       161
        
       

     

       162
       +
       	feed, err := rp.getRepoFeed(r.Context(), f, ownerSlashRepo)

     

       163
        
       	if err != nil {

     

       164
        
       		log.Println("failed to get repo feed:", err)

     

       165
        
       		rp.pages.Error500(w)

+3 -3

appview/repo/index.go

···

       53
        
       	user := rp.oauth.GetUser(r)

     

       54
        
       

     

       55
        
       	// Build index response from multiple XRPC calls

     

       56
       -
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref)

     

       57
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       58
        
       		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {

     

       59
        
       			l.Error("failed to call XRPC repo.index", "err", err)

     
···

       128
        
       	}

     

       129
        
       

     

       130
        
       	// TODO: a bit dirty

     

       131
       -
       	languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "")

     

       132
        
       	if err != nil {

     

       133
        
       		l.Warn("failed to compute language percentages", "err", err)

     

       134
        
       		// non-fatal

     
···

       138
        
       	for _, c := range commitsTrunc {

     

       139
        
       		shas = append(shas, c.Hash.String())

     

       140
        
       	}

     

       141
       -
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)

     

       142
        
       	if err != nil {

     

       143
        
       		l.Error("failed to fetch pipeline statuses", "err", err)

     

       144
        
       		// non-fatal

···

       53
        
       	user := rp.oauth.GetUser(r)

     

       54
        
       

     

       55
        
       	// Build index response from multiple XRPC calls

     

       56
       +
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     

       57
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       58
        
       		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {

     

       59
        
       			l.Error("failed to call XRPC repo.index", "err", err)

     
···

       128
        
       	}

     

       129
        
       

     

       130
        
       	// TODO: a bit dirty

     

       131
       +
       	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")

     

       132
        
       	if err != nil {

     

       133
        
       		l.Warn("failed to compute language percentages", "err", err)

     

       134
        
       		// non-fatal

     
···

       138
        
       	for _, c := range commitsTrunc {

     

       139
        
       		shas = append(shas, c.Hash.String())

     

       140
        
       	}

     

       141
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       142
        
       	if err != nil {

     

       143
        
       		l.Error("failed to fetch pipeline statuses", "err", err)

     

       144
        
       		// non-fatal

+2 -2

appview/repo/log.go

···

       125
        
       	for _, c := range xrpcResp.Commits {

     

       126
        
       		shas = append(shas, c.Hash.String())

     

       127
        
       	}

     

       128
       -
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)

     

       129
        
       	if err != nil {

     

       130
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       131
        
       		// non-fatal

     
···

       198
        
       	}

     

       199
        
       

     

       200
        
       	user := rp.oauth.GetUser(r)

     

       201
       -
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, []string{result.Diff.Commit.This})

     

       202
        
       	if err != nil {

     

       203
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       204
        
       		// non-fatal

···

       125
        
       	for _, c := range xrpcResp.Commits {

     

       126
        
       		shas = append(shas, c.Hash.String())

     

       127
        
       	}

     

       128
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       129
        
       	if err != nil {

     

       130
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       131
        
       		// non-fatal

     
···

       198
        
       	}

     

       199
        
       

     

       200
        
       	user := rp.oauth.GetUser(r)

     

       201
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})

     

       202
        
       	if err != nil {

     

       203
        
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       204
        
       		// non-fatal

+1 -1

appview/repo/opengraph.go

···

       374
        
       		})

     

       375
        
       	}

     

       376
        
       

     

       377
       -
       	card, err := rp.drawRepoSummaryCard(&f.Repo, languageStats)

     

       378
        
       	if err != nil {

     

       379
        
       		log.Println("failed to draw repo summary card", err)

     

       380
        
       		http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)

···

       374
        
       		})

     

       375
        
       	}

     

       376
        
       

     

       377
       +
       	card, err := rp.drawRepoSummaryCard(f, languageStats)

     

       378
        
       	if err != nil {

     

       379
        
       		log.Println("failed to draw repo summary card", err)

     

       380
        
       		http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)

+11 -11

appview/repo/repo.go

···

       118
        
       		}

     

       119
        
       	}

     

       120
        
       

     

       121
       -
       	newRepo := f.Repo

     

       122
        
       	newRepo.Spindle = newSpindle

     

       123
        
       	record := newRepo.AsRecord()

     

       124
        
       

     
···

       257
        
       	l.Info("wrote label record to PDS")

     

       258
        
       

     

       259
        
       	// update the repo to subscribe to this label

     

       260
       -
       	newRepo := f.Repo

     

       261
        
       	newRepo.Labels = append(newRepo.Labels, aturi)

     

       262
        
       	repoRecord := newRepo.AsRecord()

     

       263
        
       

     
···

       369
        
       	}

     

       370
        
       

     

       371
        
       	// update repo record to remove the label reference

     

       372
       -
       	newRepo := f.Repo

     

       373
        
       	var updated []string

     

       374
        
       	removedAt := label.AtUri().String()

     

       375
        
       	for _, l := range newRepo.Labels {

     
···

       462
        
       		return

     

       463
        
       	}

     

       464
        
       

     

       465
       -
       	newRepo := f.Repo

     

       466
        
       	newRepo.Labels = append(newRepo.Labels, labelAts...)

     

       467
        
       

     

       468
        
       	// dedup

     
···

       477
        
       		return

     

       478
        
       	}

     

       479
        
       

     

       480
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       481
        
       	if err != nil {

     

       482
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       483
        
       		return

     
···

       549
        
       	}

     

       550
        
       

     

       551
        
       	// update repo record to remove the label reference

     

       552
       -
       	newRepo := f.Repo

     

       553
        
       	var updated []string

     

       554
        
       	for _, l := range newRepo.Labels {

     

       555
        
       		if !slices.Contains(labelAts, l) {

     
···

       565
        
       		return

     

       566
        
       	}

     

       567
        
       

     

       568
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       569
        
       	if err != nil {

     

       570
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       571
        
       		return

     
···

       612
        
       

     

       613
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       614
        
       		rp.db,

     

       615
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       616
        
       		db.FilterContains("scope", subject.Collection().String()),

     

       617
        
       	)

     

       618
        
       	if err != nil {

     
···

       660
        
       

     

       661
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       662
        
       		rp.db,

     

       663
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       664
        
       		db.FilterContains("scope", subject.Collection().String()),

     

       665
        
       	)

     

       666
        
       	if err != nil {

     
···

       1057
        
       			uri = "http"

     

       1058
        
       		}

     

       1059
        
       

     

       1060
       -
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Repo.Name)

     

       1061
        
       		l = l.With("cloneUrl", forkSourceUrl)

     

       1062
        
       

     

       1063
        
       		sourceAt := f.RepoAt().String()

     
···

       1070
        
       			Knot:        targetKnot,

     

       1071
        
       			Rkey:        rkey,

     

       1072
        
       			Source:      sourceAt,

     

       1073
       -
       			Description: f.Repo.Description,

     

       1074
        
       			Created:     time.Now(),

     

       1075
        
       			Labels:      rp.config.Label.DefaultLabelDefs,

     

       1076
        
       		}

···

       118
        
       		}

     

       119
        
       	}

     

       120
        
       

     

       121
       +
       	newRepo := *f

     

       122
        
       	newRepo.Spindle = newSpindle

     

       123
        
       	record := newRepo.AsRecord()

     

       124
        
       

     
···

       257
        
       	l.Info("wrote label record to PDS")

     

       258
        
       

     

       259
        
       	// update the repo to subscribe to this label

     

       260
       +
       	newRepo := *f

     

       261
        
       	newRepo.Labels = append(newRepo.Labels, aturi)

     

       262
        
       	repoRecord := newRepo.AsRecord()

     

       263
        
       

     
···

       369
        
       	}

     

       370
        
       

     

       371
        
       	// update repo record to remove the label reference

     

       372
       +
       	newRepo := *f

     

       373
        
       	var updated []string

     

       374
        
       	removedAt := label.AtUri().String()

     

       375
        
       	for _, l := range newRepo.Labels {

     
···

       462
        
       		return

     

       463
        
       	}

     

       464
        
       

     

       465
       +
       	newRepo := *f

     

       466
        
       	newRepo.Labels = append(newRepo.Labels, labelAts...)

     

       467
        
       

     

       468
        
       	// dedup

     
···

       477
        
       		return

     

       478
        
       	}

     

       479
        
       

     

       480
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       481
        
       	if err != nil {

     

       482
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       483
        
       		return

     
···

       549
        
       	}

     

       550
        
       

     

       551
        
       	// update repo record to remove the label reference

     

       552
       +
       	newRepo := *f

     

       553
        
       	var updated []string

     

       554
        
       	for _, l := range newRepo.Labels {

     

       555
        
       		if !slices.Contains(labelAts, l) {

     
···

       565
        
       		return

     

       566
        
       	}

     

       567
        
       

     

       568
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       569
        
       	if err != nil {

     

       570
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       571
        
       		return

     
···

       612
        
       

     

       613
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       614
        
       		rp.db,

     

       615
       +
       		db.FilterIn("at_uri", f.Labels),

     

       616
        
       		db.FilterContains("scope", subject.Collection().String()),

     

       617
        
       	)

     

       618
        
       	if err != nil {

     
···

       660
        
       

     

       661
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       662
        
       		rp.db,

     

       663
       +
       		db.FilterIn("at_uri", f.Labels),

     

       664
        
       		db.FilterContains("scope", subject.Collection().String()),

     

       665
        
       	)

     

       666
        
       	if err != nil {

     
···

       1057
        
       			uri = "http"

     

       1058
        
       		}

     

       1059
        
       

     

       1060
       +
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Name)

     

       1061
        
       		l = l.With("cloneUrl", forkSourceUrl)

     

       1062
        
       

     

       1063
        
       		sourceAt := f.RepoAt().String()

     
···

       1070
        
       			Knot:        targetKnot,

     

       1071
        
       			Rkey:        rkey,

     

       1072
        
       			Source:      sourceAt,

     

       1073
       +
       			Description: f.Description,

     

       1074
        
       			Created:     time.Now(),

     

       1075
        
       			Labels:      rp.config.Label.DefaultLabelDefs,

     

       1076
        
       		}

+4 -4

appview/repo/settings.go

···

       217
        
       		return

     

       218
        
       	}

     

       219
        
       

     

       220
       -
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       221
        
       	if err != nil {

     

       222
        
       		l.Error("failed to fetch labels", "err", err)

     

       223
        
       		rp.pages.Error503(w)

     
···

       238
        
       	labels = labels[:n]

     

       239
        
       

     

       240
        
       	subscribedLabels := make(map[string]struct{})

     

       241
       -
       	for _, l := range f.Repo.Labels {

     

       242
        
       		subscribedLabels[l] = struct{}{}

     

       243
        
       	}

     

       244
        
       

     
···

       299
        
       			collaborators = append(collaborators, c)

     

       300
        
       		}

     

       301
        
       		return collaborators, nil

     

       302
       -
       	}(&f.Repo)

     

       303
        
       	if err != nil {

     

       304
        
       		l.Error("failed to get collaborators", "err", err)

     

       305
        
       	}

     
···

       416
        
       	}

     

       417
        
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       418
        
       

     

       419
       -
       	newRepo := f.Repo

     

       420
        
       	newRepo.Description = description

     

       421
        
       	newRepo.Website = website

     

       422
        
       	newRepo.Topics = topics

···

       217
        
       		return

     

       218
        
       	}

     

       219
        
       

     

       220
       +
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Labels))

     

       221
        
       	if err != nil {

     

       222
        
       		l.Error("failed to fetch labels", "err", err)

     

       223
        
       		rp.pages.Error503(w)

     
···

       238
        
       	labels = labels[:n]

     

       239
        
       

     

       240
        
       	subscribedLabels := make(map[string]struct{})

     

       241
       +
       	for _, l := range f.Labels {

     

       242
        
       		subscribedLabels[l] = struct{}{}

     

       243
        
       	}

     

       244
        
       

     
···

       299
        
       			collaborators = append(collaborators, c)

     

       300
        
       		}

     

       301
        
       		return collaborators, nil

     

       302
       +
       	}(f)

     

       303
        
       	if err != nil {

     

       304
        
       		l.Error("failed to get collaborators", "err", err)

     

       305
        
       	}

     
···

       416
        
       	}

     

       417
        
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       418
        
       

     

       419
       +
       	newRepo := *f

     

       420
        
       	newRepo.Description = description

     

       421
        
       	newRepo.Website = website

     

       422
        
       	newRepo.Topics = topics

+1 -1

appview/repo/tree.go

···

       80
        
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       81
        
       		result.Readme = xrpcResp.Readme.Contents

     

       82
        
       	}

     

       83
       -
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       84
        
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       85
        
       	// so we can safely redirect to the "parent" (which is the same file).

     

       86
        
       	if len(result.Files) == 0 && result.Parent == treePath {

···

       80
        
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       81
        
       		result.Readme = xrpcResp.Readme.Contents

     

       82
        
       	}

     

       83
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       84
        
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       85
        
       	// so we can safely redirect to the "parent" (which is the same file).

     

       86
        
       	if len(result.Files) == 0 && result.Parent == treePath {

+2 -8

appview/reporesolver/resolver.go

···

       18
        
       	"tangled.org/core/rbac"

     

       19
        
       )

     

       20
        
       

     

       21
       -
       type ResolvedRepo struct {

     

       22
       -
       	models.Repo

     

       23
       -
       }

     

       24
       -
       

     

       25
        
       type RepoResolver struct {

     

       26
        
       	config   *config.Config

     

       27
        
       	enforcer *rbac.Enforcer

     
···

       45
        
       }

     

       46
        
       

     

       47
        
       // TODO: move this out of `RepoResolver` struct

     

       48
       -
       func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {

     

       49
        
       	repo, ok := r.Context().Value("repo").(*models.Repo)

     

       50
        
       	if !ok {

     

       51
        
       		log.Println("malformed middleware: `repo` not exist in context")

     

       52
        
       		return nil, fmt.Errorf("malformed middleware")

     

       53
        
       	}

     

       54
        
       

     

       55
       -
       	return &ResolvedRepo{

     

       56
       -
       		Repo: *repo,

     

       57
       -
       	}, nil

     

       58
        
       }

     

       59
        
       

     

       60
        
       // 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`

···

       18
        
       	"tangled.org/core/rbac"

     

       19
        
       )

     

       20
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       21
        
       type RepoResolver struct {

     

       22
        
       	config   *config.Config

     

       23
        
       	enforcer *rbac.Enforcer

     
···

       41
        
       }

     

       42
        
       

     

       43
        
       // TODO: move this out of `RepoResolver` struct

     

       44
       +
       func (rr *RepoResolver) Resolve(r *http.Request) (*models.Repo, error) {

     

       45
        
       	repo, ok := r.Context().Value("repo").(*models.Repo)

     

       46
        
       	if !ok {

     

       47
        
       		log.Println("malformed middleware: `repo` not exist in context")

     

       48
        
       		return nil, fmt.Errorf("malformed middleware")

     

       49
        
       	}

     

       50
        
       

     

       51
       +
       	return repo, nil

     

       0
        
       
     

       0
        
       
     

       52
        
       }

     

       53
        
       

     

       54
        
       // 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`