patch of appview: use less `RepoInfo` for `ResolvedRepo` · round #4 · pull #810 · tangled.org/core

+2 -3

appview/issues/issues.go

···

       226
       226
        
       	l := rp.logger.With("handler", "DeleteIssue")

     

       227
       227
        
       	noticeId := "issue-actions-error"

     

       228
       228
        
       

     

       229
       229
       -
       	user := rp.oauth.GetUser(r)

     

       230
       230
       -
       

     

       231
       229
        
       	f, err := rp.repoResolver.Resolve(r)

     

       232
       230
        
       	if err != nil {

     

       233
       231
        
       		l.Error("failed to get repo and knot", "err", err)

     
···

       271
       269
        
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       272
       270
        
       

     

       273
       271
        
       	// return to all issues page

     

       274
       274
       -
       	rp.pages.HxRedirect(w, "/"+f.RepoInfo(user).FullName()+"/issues")

     

       272
       272
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

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

     

       275
       274
        
       }

     

       276
       275
        
       

     

       277
       276
        
       func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {

+13 -20

appview/pipelines/pipelines.go

···

       78
       78
        
       		return

     

       79
       79
        
       	}

     

       80
       80
        
       

     

       81
       81
       -
       	repoInfo := f.RepoInfo(user)

     

       82
       82
       -
       

     

       83
       81
        
       	ps, err := db.GetPipelineStatuses(

     

       84
       82
        
       		p.db,

     

       85
       83
        
       		30,

     

       86
       86
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       87
       87
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       88
       88
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       84
       84
       +
       		db.FilterEq("repo_owner", f.Did),

     

       85
       85
       +
       		db.FilterEq("repo_name", f.Name),

     

       86
       86
       +
       		db.FilterEq("knot", f.Knot),

     

       89
       87
        
       	)

     

       90
       88
        
       	if err != nil {

     

       91
       89
        
       		l.Error("failed to query db", "err", err)

     
···

       94
       92
        
       

     

       95
       93
        
       	p.pages.Pipelines(w, pages.PipelinesParams{

     

       96
       94
        
       		LoggedInUser: user,

     

       97
       97
       -
       		RepoInfo:     repoInfo,

     

       95
       95
       +
       		RepoInfo:     f.RepoInfo(user),

     

       98
       96
        
       		Pipelines:    ps,

     

       99
       97
        
       	})

     

       100
       98
        
       }

     
···

       109
       107
        
       		return

     

       110
       108
        
       	}

     

       111
       109
        
       

     

       112
       112
       -
       	repoInfo := f.RepoInfo(user)

     

       113
       113
       -
       

     

       114
       110
        
       	pipelineId := chi.URLParam(r, "pipeline")

     

       115
       111
        
       	if pipelineId == "" {

     

       116
       112
        
       		l.Error("empty pipeline ID")

     
···

       126
       122
        
       	ps, err := db.GetPipelineStatuses(

     

       127
       123
        
       		p.db,

     

       128
       124
        
       		1,

     

       129
       129
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       130
       130
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       131
       131
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       125
       125
       +
       		db.FilterEq("repo_owner", f.Did),

     

       126
       126
       +
       		db.FilterEq("repo_name", f.Name),

     

       127
       127
       +
       		db.FilterEq("knot", f.Knot),

     

       132
       128
        
       		db.FilterEq("id", pipelineId),

     

       133
       129
        
       	)

     

       134
       130
        
       	if err != nil {

     
···

       145
       141
        
       

     

       146
       142
        
       	p.pages.Workflow(w, pages.WorkflowParams{

     

       147
       143
        
       		LoggedInUser: user,

     

       148
       148
       -
       		RepoInfo:     repoInfo,

     

       144
       144
       +
       		RepoInfo:     f.RepoInfo(user),

     

       149
       145
        
       		Pipeline:     singlePipeline,

     

       150
       146
        
       		Workflow:     workflow,

     

       151
       147
        
       	})

     
···

       176
       172
        
       	ctx, cancel := context.WithCancel(r.Context())

     

       177
       173
        
       	defer cancel()

     

       178
       174
        
       

     

       179
       179
       -
       	user := p.oauth.GetUser(r)

     

       180
       175
        
       	f, err := p.repoResolver.Resolve(r)

     

       181
       176
        
       	if err != nil {

     

       182
       177
        
       		l.Error("failed to get repo and knot", "err", err)

     
···

       184
       179
        
       		return

     

       185
       180
        
       	}

     

       186
       181
        
       

     

       187
       187
       -
       	repoInfo := f.RepoInfo(user)

     

       188
       188
       -
       

     

       189
       182
        
       	pipelineId := chi.URLParam(r, "pipeline")

     

       190
       183
        
       	workflow := chi.URLParam(r, "workflow")

     

       191
       184
        
       	if pipelineId == "" || workflow == "" {

     
···

       196
       189
        
       	ps, err := db.GetPipelineStatuses(

     

       197
       190
        
       		p.db,

     

       198
       191
        
       		1,

     

       199
       199
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       200
       200
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       201
       201
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       192
       192
       +
       		db.FilterEq("repo_owner", f.Did),

     

       193
       193
       +
       		db.FilterEq("repo_name", f.Name),

     

       194
       194
       +
       		db.FilterEq("knot", f.Knot),

     

       202
       195
        
       		db.FilterEq("id", pipelineId),

     

       203
       196
        
       	)

     

       204
       197
        
       	if err != nil || len(ps) != 1 {

     
···

       208
       201
        
       	}

     

       209
       202
        
       

     

       210
       203
        
       	singlePipeline := ps[0]

     

       211
       211
       -
       	spindle := repoInfo.Spindle

     

       212
       212
       -
       	knot := repoInfo.Knot

     

       204
       204
       +
       	spindle := f.Spindle

     

       205
       205
       +
       	knot := f.Knot

     

       213
       206
        
       	rkey := singlePipeline.Rkey

     

       214
       207
        
       

     

       215
       208
        
       	if spindle == "" || knot == "" || rkey == "" {

+7 -10

appview/pulls/pulls.go

···

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

     

       163
       163
        
       	}

     

       164
       164
        
       

     

       165
       165
       -
       	repoInfo := f.RepoInfo(user)

     

       166
       166
       -
       

     

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

     

       168
       166
        
       

     

       169
       167
        
       	var shas []string

     
···

       180
       178
        
       	ps, err := db.GetPipelineStatuses(

     

       181
       179
        
       		s.db,

     

       182
       180
        
       		len(shas),

     

       183
       183
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       184
       184
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       185
       185
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       181
       181
       +
       		db.FilterEq("repo_owner", f.Did),

     

       182
       182
       +
       		db.FilterEq("repo_name", f.Name),

     

       183
       183
       +
       		db.FilterEq("knot", f.Knot),

     

       186
       184
        
       		db.FilterIn("sha", shas),

     

       187
       185
        
       	)

     

       188
       186
        
       	if err != nil {

     
···

       223
       221
        
       

     

       224
       222
        
       	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       225
       223
        
       		LoggedInUser:       user,

     

       226
       226
       -
       		RepoInfo:           repoInfo,

     

       224
       224
       +
       		RepoInfo:           f.RepoInfo(user),

     

       227
       225
        
       		Pull:               pull,

     

       228
       226
        
       		Stack:              stack,

     

       229
       227
        
       		AbandonedPulls:     abandonedPulls,

     
···

       647
       645
        
       	}

     

       648
       646
        
       	pulls = pulls[:n]

     

       649
       647
        
       

     

       650
       650
       -
       	repoInfo := f.RepoInfo(user)

     

       651
       648
        
       	ps, err := db.GetPipelineStatuses(

     

       652
       649
        
       		s.db,

     

       653
       650
        
       		len(shas),

     

       654
       654
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       655
       655
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       656
       656
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       651
       651
       +
       		db.FilterEq("repo_owner", f.Did),

     

       652
       652
       +
       		db.FilterEq("repo_name", f.Name),

     

       653
       653
       +
       		db.FilterEq("knot", f.Knot),

     

       657
       654
        
       		db.FilterIn("sha", shas),

     

       658
       655
        
       	)

     

       659
       656
        
       	if err != nil {

+2 -6

appview/repo/compare.go

···

       88
       88
        
       		return

     

       89
       89
        
       	}

     

       90
       90
        
       

     

       91
       91
       -
       	repoinfo := f.RepoInfo(user)

     

       92
       92
       -
       

     

       93
       91
        
       	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       94
       92
        
       		LoggedInUser: user,

     

       95
       95
       -
       		RepoInfo:     repoinfo,

     

       93
       93
       +
       		RepoInfo:     f.RepoInfo(user),

     

       96
       94
        
       		Branches:     branches,

     

       97
       95
        
       		Tags:         tags.Tags,

     

       98
       96
        
       		Base:         base,

     
···

       202
       200
        
       		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       203
       201
        
       	}

     

       204
       202
        
       

     

       205
       205
       -
       	repoinfo := f.RepoInfo(user)

     

       206
       206
       -
       

     

       207
       203
        
       	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       208
       204
        
       		LoggedInUser: user,

     

       209
       209
       -
       		RepoInfo:     repoinfo,

     

       205
       205
       +
       		RepoInfo:     f.RepoInfo(user),

     

       210
       206
        
       		Branches:     branches.Branches,

     

       211
       207
        
       		Tags:         tags.Tags,

     

       212
       208
        
       		Base:         base,

+3 -4

appview/repo/index.go

···

       52
       52
        
       	}

     

       53
       53
        
       

     

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

     

       55
       55
       -
       	repoInfo := f.RepoInfo(user)

     

       56
       55
        
       

     

       57
       56
        
       	// Build index response from multiple XRPC calls

     

       58
       57
        
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     
···

       62
       61
        
       			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       63
       62
        
       				LoggedInUser:     user,

     

       64
       63
        
       				NeedsKnotUpgrade: true,

     

       65
       65
       -
       				RepoInfo:         repoInfo,

     

       64
       64
       +
       				RepoInfo:         f.RepoInfo(user),

     

       66
       65
        
       			})

     

       67
       66
        
       			return

     

       68
       67
        
       		}

     
···

       140
       139
        
       	for _, c := range commitsTrunc {

     

       141
       140
        
       		shas = append(shas, c.Hash.String())

     

       142
       141
        
       	}

     

       143
       143
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       142
       142
       +
       	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)

     

       144
       143
        
       	if err != nil {

     

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

     

       146
       145
        
       		// non-fatal

     
···

       148
       147
        
       

     

       149
       148
        
       	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       150
       149
        
       		LoggedInUser:      user,

     

       151
       151
       -
       		RepoInfo:          repoInfo,

     

       150
       150
       +
       		RepoInfo:          f.RepoInfo(user),

     

       152
       151
        
       		TagMap:            tagMap,

     

       153
       152
        
       		RepoIndexResponse: *result,

     

       154
       153
        
       		CommitsTrunc:      commitsTrunc,

+3 -6

appview/repo/log.go

···

       121
       121
        
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       122
       122
        
       	}

     

       123
       123
        
       

     

       124
       124
       -
       	repoInfo := f.RepoInfo(user)

     

       125
       125
       -
       

     

       126
       124
        
       	var shas []string

     

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

     

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

     

       129
       127
        
       	}

     

       130
       130
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

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

     

       131
       129
        
       	if err != nil {

     

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

     

       133
       131
        
       		// non-fatal

     
···

       136
       134
        
       	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       137
       135
        
       		LoggedInUser:    user,

     

       138
       136
        
       		TagMap:          tagMap,

     

       139
       139
       -
       		RepoInfo:        repoInfo,

     

       137
       137
       +
       		RepoInfo:        f.RepoInfo(user),

     

       140
       138
        
       		RepoLogResponse: xrpcResp,

     

       141
       139
        
       		EmailToDid:      emailToDidMap,

     

       142
       140
        
       		VerifiedCommits: vc,

     
···

       200
       198
        
       	}

     

       201
       199
        
       

     

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

     

       203
       203
       -
       	repoInfo := f.RepoInfo(user)

     

       204
       204
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})

     

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

     

       205
       202
        
       	if err != nil {

     

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

     

       207
       204
        
       		// non-fatal

+2 -3

appview/repo/repo.go

···

       959
       959
        
       			return

     

       960
       960
        
       		}

     

       961
       961
        
       

     

       962
       962
       -
       		repoInfo := f.RepoInfo(user)

     

       963
       963
       -
       		if repoInfo.Source == nil {

     

       962
       962
       +
       		if f.Source == "" {

     

       964
       963
        
       			rp.pages.Notice(w, "repo", "This repository is not a fork.")

     

       965
       964
        
       			return

     

       966
       965
        
       		}

     
···

       971
       970
        
       			&tangled.RepoForkSync_Input{

     

       972
       971
        
       				Did:    user.Did,

     

       973
       972
        
       				Name:   f.Name,

     

       974
       974
       -
       				Source: repoInfo.Source.RepoAt().String(),

     

       973
       973
       +
       				Source: f.Source,

     

       975
       974
        
       				Branch: ref,

     

       976
       975
        
       			},

     

       977
       976
        
       		)

+4 -5

appview/repo/repo_util.go

···

       7
       7
        
       

     

       8
       8
        
       	"tangled.org/core/appview/db"

     

       9
       9
        
       	"tangled.org/core/appview/models"

     

       10
       10
       -
       	"tangled.org/core/appview/pages/repoinfo"

     

       11
       10
        
       	"tangled.org/core/types"

     

       12
       11
        
       

     

       13
       12
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     
···

       93
       92
        
       // golang is so blessed that it requires 35 lines of imperative code for this

     

       94
       93
        
       func getPipelineStatuses(

     

       95
       94
        
       	d *db.DB,

     

       96
       96
       -
       	repoInfo repoinfo.RepoInfo,

     

       95
       95
       +
       	repo *models.Repo,

     

       97
       96
        
       	shas []string,

     

       98
       97
        
       ) (map[string]models.Pipeline, error) {

     

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

     
···

       105
       104
        
       	ps, err := db.GetPipelineStatuses(

     

       106
       105
        
       		d,

     

       107
       106
        
       		len(shas),

     

       108
       108
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       109
       109
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       110
       110
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       107
       107
       +
       		db.FilterEq("repo_owner", repo.Did),

     

       108
       108
       +
       		db.FilterEq("repo_name", repo.Name),

     

       109
       109
       +
       		db.FilterEq("knot", repo.Knot),

     

       111
       110
        
       		db.FilterIn("sha", shas),

     

       112
       111
        
       	)

     

       113
       112
        
       	if err != nil {