appview: use less RepoInfo for ResolvedRepo #810

···

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

     

       
227
       
 
       
	noticeId := "issue-actions-error"

     

       
228
       
 
       


     

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

     

       
230
       
-
       


     

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

     

       
232
       
 
       
	if err != nil {

     

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

     
···

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

     

       
272
       
 
       


     

       
273
       
 
       
	// return to all issues page

     

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

     

       
0
       
 
       

     

       
275
       
 
       
}

     

       
276
       
 
       


     

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

     

···

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

     

       
227
       
 
       
	noticeId := "issue-actions-error"

     

       
228
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
230
       
 
       
	if err != nil {

     

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

     
···

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

     

       
270
       
 
       


     

       
271
       
 
       
	// return to all issues page

     

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

     

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

     

       
274
       
 
       
}

     

       
275
       
 
       


     

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

     

···

       
78
       
 
       
		return

     

       
79
       
 
       
	}

     

       
80
       
 
       


     

       
81
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
82
       
-
       


     

       
83
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
84
       
 
       
		p.db,

     

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

     

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

     

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

     

       
88
       
 
       
	)

     

       
89
       
 
       
	if err != nil {

     

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

     
···

       
93
       
 
       


     

       
94
       
 
       
	p.pages.Pipelines(w, pages.PipelinesParams{

     

       
95
       
 
       
		LoggedInUser: user,

     

       
96
       
-
       
		RepoInfo:     repoInfo,

     

       
97
       
 
       
		Pipelines:    ps,

     

       
98
       
 
       
	})

     

       
99
       
 
       
}

     
···

       
108
       
 
       
		return

     

       
109
       
 
       
	}

     

       
110
       
 
       


     

       
111
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
112
       
-
       


     

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

     

       
114
       
 
       
	if pipelineId == "" {

     

       
115
       
 
       
		l.Error("empty pipeline ID")

     
···

       
124
       
 
       


     

       
125
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
126
       
 
       
		p.db,

     

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

     

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

     

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

     

       
130
       
 
       
		db.FilterEq("id", pipelineId),

     

       
131
       
 
       
	)

     

       
132
       
 
       
	if err != nil {

     
···

       
143
       
 
       


     

       
144
       
 
       
	p.pages.Workflow(w, pages.WorkflowParams{

     

       
145
       
 
       
		LoggedInUser: user,

     

       
146
       
-
       
		RepoInfo:     repoInfo,

     

       
147
       
 
       
		Pipeline:     singlePipeline,

     

       
148
       
 
       
		Workflow:     workflow,

     

       
149
       
 
       
	})

     
···

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

     

       
175
       
 
       
	defer cancel()

     

       
176
       
 
       


     

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

     

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

     

       
179
       
 
       
	if err != nil {

     

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

     
···

       
182
       
 
       
		return

     

       
183
       
 
       
	}

     

       
184
       
 
       


     

       
185
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
186
       
-
       


     

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

     

       
188
       
 
       
	workflow := chi.URLParam(r, "workflow")

     

       
189
       
 
       
	if pipelineId == "" || workflow == "" {

     
···

       
193
       
 
       


     

       
194
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
195
       
 
       
		p.db,

     

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

     

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

     

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

     

       
199
       
 
       
		db.FilterEq("id", pipelineId),

     

       
200
       
 
       
	)

     

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

     
···

       
205
       
 
       
	}

     

       
206
       
 
       


     

       
207
       
 
       
	singlePipeline := ps[0]

     

       
208
       
-
       
	spindle := repoInfo.Spindle

     

       
209
       
-
       
	knot := repoInfo.Knot

     

       
210
       
 
       
	rkey := singlePipeline.Rkey

     

       
211
       
 
       


     

       
212
       
 
       
	if spindle == "" || knot == "" || rkey == "" {

     

···

       
78
       
 
       
		return

     

       
79
       
 
       
	}

     

       
80
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
81
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
82
       
 
       
		p.db,

     

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

     

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

     

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

     

       
86
       
 
       
	)

     

       
87
       
 
       
	if err != nil {

     

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

     
···

       
91
       
 
       


     

       
92
       
 
       
	p.pages.Pipelines(w, pages.PipelinesParams{

     

       
93
       
 
       
		LoggedInUser: user,

     

       
94
       
+
       
		RepoInfo:     f.RepoInfo(user),

     

       
95
       
 
       
		Pipelines:    ps,

     

       
96
       
 
       
	})

     

       
97
       
 
       
}

     
···

       
106
       
 
       
		return

     

       
107
       
 
       
	}

     

       
108
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
110
       
 
       
	if pipelineId == "" {

     

       
111
       
 
       
		l.Error("empty pipeline ID")

     
···

       
120
       
 
       


     

       
121
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
122
       
 
       
		p.db,

     

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

     

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

     

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

     

       
126
       
 
       
		db.FilterEq("id", pipelineId),

     

       
127
       
 
       
	)

     

       
128
       
 
       
	if err != nil {

     
···

       
139
       
 
       


     

       
140
       
 
       
	p.pages.Workflow(w, pages.WorkflowParams{

     

       
141
       
 
       
		LoggedInUser: user,

     

       
142
       
+
       
		RepoInfo:     f.RepoInfo(user),

     

       
143
       
 
       
		Pipeline:     singlePipeline,

     

       
144
       
 
       
		Workflow:     workflow,

     

       
145
       
 
       
	})

     
···

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

     

       
171
       
 
       
	defer cancel()

     

       
172
       
 
       


     

       
0
       
 
       

     

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

     

       
174
       
 
       
	if err != nil {

     

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

     
···

       
177
       
 
       
		return

     

       
178
       
 
       
	}

     

       
179
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
181
       
 
       
	workflow := chi.URLParam(r, "workflow")

     

       
182
       
 
       
	if pipelineId == "" || workflow == "" {

     
···

       
186
       
 
       


     

       
187
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
188
       
 
       
		p.db,

     

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

     

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

     

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

     

       
192
       
 
       
		db.FilterEq("id", pipelineId),

     

       
193
       
 
       
	)

     

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

     
···

       
198
       
 
       
	}

     

       
199
       
 
       


     

       
200
       
 
       
	singlePipeline := ps[0]

     

       
201
       
+
       
	spindle := f.Spindle

     

       
202
       
+
       
	knot := f.Knot

     

       
203
       
 
       
	rkey := singlePipeline.Rkey

     

       
204
       
 
       


     

       
205
       
 
       
	if spindle == "" || knot == "" || rkey == "" {

     

···

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

     

       
163
       
 
       
	}

     

       
164
       
 
       


     

       
165
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
166
       
-
       


     

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

     

       
168
       
 
       


     

       
169
       
 
       
	var shas []string

     
···

       
179
       
 
       


     

       
180
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
181
       
 
       
		s.db,

     

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

     

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

     

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

     

       
185
       
 
       
		db.FilterIn("sha", shas),

     

       
186
       
 
       
	)

     

       
187
       
 
       
	if err != nil {

     
···

       
222
       
 
       


     

       
223
       
 
       
	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       
224
       
 
       
		LoggedInUser:       user,

     

       
225
       
-
       
		RepoInfo:           repoInfo,

     

       
226
       
 
       
		Pull:               pull,

     

       
227
       
 
       
		Stack:              stack,

     

       
228
       
 
       
		AbandonedPulls:     abandonedPulls,

     
···

       
646
       
 
       
	}

     

       
647
       
 
       
	pulls = pulls[:n]

     

       
648
       
 
       


     

       
649
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
650
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
651
       
 
       
		s.db,

     

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

     

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

     

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

     

       
655
       
 
       
		db.FilterIn("sha", shas),

     

       
656
       
 
       
	)

     

       
657
       
 
       
	if err != nil {

     

···

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

     

       
163
       
 
       
	}

     

       
164
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
166
       
 
       


     

       
167
       
 
       
	var shas []string

     
···

       
177
       
 
       


     

       
178
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
179
       
 
       
		s.db,

     

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

     

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

     

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

     

       
183
       
 
       
		db.FilterIn("sha", shas),

     

       
184
       
 
       
	)

     

       
185
       
 
       
	if err != nil {

     
···

       
220
       
 
       


     

       
221
       
 
       
	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       
222
       
 
       
		LoggedInUser:       user,

     

       
223
       
+
       
		RepoInfo:           f.RepoInfo(user),

     

       
224
       
 
       
		Pull:               pull,

     

       
225
       
 
       
		Stack:              stack,

     

       
226
       
 
       
		AbandonedPulls:     abandonedPulls,

     
···

       
644
       
 
       
	}

     

       
645
       
 
       
	pulls = pulls[:n]

     

       
646
       
 
       


     

       
0
       
 
       

     

       
647
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
648
       
 
       
		s.db,

     

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

     

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

     

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

     

       
652
       
 
       
		db.FilterIn("sha", shas),

     

       
653
       
 
       
	)

     

       
654
       
 
       
	if err != nil {

     

···

       
88
       
 
       
		return

     

       
89
       
 
       
	}

     

       
90
       
 
       


     

       
91
       
-
       
	repoinfo := f.RepoInfo(user)

     

       
92
       
-
       


     

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

     

       
94
       
 
       
		LoggedInUser: user,

     

       
95
       
-
       
		RepoInfo:     repoinfo,

     

       
96
       
 
       
		Branches:     branches,

     

       
97
       
 
       
		Tags:         tags.Tags,

     

       
98
       
 
       
		Base:         base,

     
···

       
198
       
 
       
		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       
199
       
 
       
	}

     

       
200
       
 
       


     

       
201
       
-
       
	repoinfo := f.RepoInfo(user)

     

       
202
       
-
       


     

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

     

       
204
       
 
       
		LoggedInUser: user,

     

       
205
       
-
       
		RepoInfo:     repoinfo,

     

       
206
       
 
       
		Branches:     branches.Branches,

     

       
207
       
 
       
		Tags:         tags.Tags,

     

       
208
       
 
       
		Base:         base,

     

···

       
88
       
 
       
		return

     

       
89
       
 
       
	}

     

       
90
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
92
       
 
       
		LoggedInUser: user,

     

       
93
       
+
       
		RepoInfo:     f.RepoInfo(user),

     

       
94
       
 
       
		Branches:     branches,

     

       
95
       
 
       
		Tags:         tags.Tags,

     

       
96
       
 
       
		Base:         base,

     
···

       
196
       
 
       
		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       
197
       
 
       
	}

     

       
198
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
199
       
 
       
	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       
200
       
 
       
		LoggedInUser: user,

     

       
201
       
+
       
		RepoInfo:     f.RepoInfo(user),

     

       
202
       
 
       
		Branches:     branches.Branches,

     

       
203
       
 
       
		Tags:         tags.Tags,

     

       
204
       
 
       
		Base:         base,

     

···

       
52
       
 
       
	}

     

       
53
       
 
       


     

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

     

       
55
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
56
       
 
       


     

       
57
       
 
       
	// Build index response from multiple XRPC calls

     

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

     
···

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

     

       
63
       
 
       
				LoggedInUser:     user,

     

       
64
       
 
       
				NeedsKnotUpgrade: true,

     

       
65
       
-
       
				RepoInfo:         repoInfo,

     

       
66
       
 
       
			})

     

       
67
       
 
       
			return

     

       
68
       
 
       
		}

     
···

       
140
       
 
       
	for _, c := range commitsTrunc {

     

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

     

       
142
       
 
       
	}

     

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

     

       
144
       
 
       
	if err != nil {

     

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

     

       
146
       
 
       
		// non-fatal

     
···

       
148
       
 
       


     

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

     

       
150
       
 
       
		LoggedInUser:      user,

     

       
151
       
-
       
		RepoInfo:          repoInfo,

     

       
152
       
 
       
		TagMap:            tagMap,

     

       
153
       
 
       
		RepoIndexResponse: *result,

     

       
154
       
 
       
		CommitsTrunc:      commitsTrunc,

     

···

       
52
       
 
       
	}

     

       
53
       
 
       


     

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

     

       
0
       
 
       

     

       
55
       
 
       


     

       
56
       
 
       
	// Build index response from multiple XRPC calls

     

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

     
···

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

     

       
62
       
 
       
				LoggedInUser:     user,

     

       
63
       
 
       
				NeedsKnotUpgrade: true,

     

       
64
       
+
       
				RepoInfo:         f.RepoInfo(user),

     

       
65
       
 
       
			})

     

       
66
       
 
       
			return

     

       
67
       
 
       
		}

     
···

       
139
       
 
       
	for _, c := range commitsTrunc {

     

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

     

       
141
       
 
       
	}

     

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

     

       
143
       
 
       
	if err != nil {

     

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

     

       
145
       
 
       
		// non-fatal

     
···

       
147
       
 
       


     

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

     

       
149
       
 
       
		LoggedInUser:      user,

     

       
150
       
+
       
		RepoInfo:          f.RepoInfo(user),

     

       
151
       
 
       
		TagMap:            tagMap,

     

       
152
       
 
       
		RepoIndexResponse: *result,

     

       
153
       
 
       
		CommitsTrunc:      commitsTrunc,

     

···

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

     

       
122
       
 
       
	}

     

       
123
       
 
       


     

       
124
       
-
       
	repoInfo := f.RepoInfo(user)

     

       
125
       
-
       


     

       
126
       
 
       
	var shas []string

     

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

     

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

     

       
129
       
 
       
	}

     

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

     

       
131
       
 
       
	if err != nil {

     

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

     

       
133
       
 
       
		// non-fatal

     
···

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

     

       
137
       
 
       
		LoggedInUser:    user,

     

       
138
       
 
       
		TagMap:          tagMap,

     

       
139
       
-
       
		RepoInfo:        repoInfo,

     

       
140
       
 
       
		RepoLogResponse: xrpcResp,

     

       
141
       
 
       
		EmailToDid:      emailToDidMap,

     

       
142
       
 
       
		VerifiedCommits: vc,

     
···

       
200
       
 
       
	}

     

       
201
       
 
       


     

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

     

       
203
       
-
       
	repoInfo := f.RepoInfo(user)

     

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

     

       
205
       
 
       
	if err != nil {

     

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

     

       
207
       
 
       
		// non-fatal

     

···

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

     

       
122
       
 
       
	}

     

       
123
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
124
       
 
       
	var shas []string

     

       
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

     
···

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

     

       
135
       
 
       
		LoggedInUser:    user,

     

       
136
       
 
       
		TagMap:          tagMap,

     

       
137
       
+
       
		RepoInfo:        f.RepoInfo(user),

     

       
138
       
 
       
		RepoLogResponse: xrpcResp,

     

       
139
       
 
       
		EmailToDid:      emailToDidMap,

     

       
140
       
 
       
		VerifiedCommits: vc,

     
···

       
198
       
 
       
	}

     

       
199
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
202
       
 
       
	if err != nil {

     

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

     

       
204
       
 
       
		// non-fatal

     

···

       
959
       
 
       
			return

     

       
960
       
 
       
		}

     

       
961
       
 
       


     

       
962
       
-
       
		repoInfo := f.RepoInfo(user)

     

       
963
       
-
       
		if repoInfo.Source == nil {

     

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

     

       
965
       
 
       
			return

     

       
966
       
 
       
		}

     
···

       
971
       
 
       
			&tangled.RepoForkSync_Input{

     

       
972
       
 
       
				Did:    user.Did,

     

       
973
       
 
       
				Name:   f.Name,

     

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

     

       
975
       
 
       
				Branch: ref,

     

       
976
       
 
       
			},

     

       
977
       
 
       
		)

     

···

       
959
       
 
       
			return

     

       
960
       
 
       
		}

     

       
961
       
 
       


     

       
962
       
+
       
		if f.Source == "" {

     

       
0
       
 
       

     

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

     

       
964
       
 
       
			return

     

       
965
       
 
       
		}

     
···

       
970
       
 
       
			&tangled.RepoForkSync_Input{

     

       
971
       
 
       
				Did:    user.Did,

     

       
972
       
 
       
				Name:   f.Name,

     

       
973
       
+
       
				Source: f.Source,

     

       
974
       
 
       
				Branch: ref,

     

       
975
       
 
       
			},

     

       
976
       
 
       
		)

     

···

       
9
       
 
       


     

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

     

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

     

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

     

       
13
       
 
       
	"tangled.org/core/types"

     

       
14
       
 
       


     

       
15
       
 
       
	"github.com/go-git/go-git/v5/plumbing/object"

     
···

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

     

       
108
       
 
       
func getPipelineStatuses(

     

       
109
       
 
       
	d *db.DB,

     

       
110
       
-
       
	repoInfo repoinfo.RepoInfo,

     

       
111
       
 
       
	shas []string,

     

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

     

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

     
···

       
118
       
 
       


     

       
119
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
120
       
 
       
		d,

     

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

     

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

     

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

     

       
124
       
 
       
		db.FilterIn("sha", shas),

     

       
125
       
 
       
	)

     

       
126
       
 
       
	if err != nil {

     

···

       
9
       
 
       


     

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

     

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

     

       
0
       
 
       

     

       
12
       
 
       
	"tangled.org/core/types"

     

       
13
       
 
       


     

       
14
       
 
       
	"github.com/go-git/go-git/v5/plumbing/object"

     
···

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

     

       
107
       
 
       
func getPipelineStatuses(

     

       
108
       
 
       
	d *db.DB,

     

       
109
       
+
       
	repo *models.Repo,

     

       
110
       
 
       
	shas []string,

     

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

     

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

     
···

       
117
       
 
       


     

       
118
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
119
       
 
       
		d,

     

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

     

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

     

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

     

       
123
       
 
       
		db.FilterIn("sha", shas),

     

       
124
       
 
       
	)

     

       
125
       
 
       
	if err != nil {