···

       
639
       
639
       
 
       
			return

     

       
640
       
640
       
 
       
		}

     

       
641
       
641
       
 
       


     

       
642
       
642
       
-
       
		resp, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
642
       
642
       
+
       
		result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
643
       
643
       
 
       
		if err != nil {

     

       
644
       
644
       
 
       
			log.Println("failed to reach knotserver", err)

     

       
645
       
645
       
-
       
			return

     

       
646
       
646
       
-
       
		}

     

       
647
       
647
       
-
       


     

       
648
       
648
       
-
       
		body, err := io.ReadAll(resp.Body)

     

       
649
       
649
       
-
       
		if err != nil {

     

       
650
       
650
       
-
       
			log.Printf("Error reading response body: %v", err)

     

       
651
       
651
       
-
       
			return

     

       
652
       
652
       
-
       
		}

     

       
653
       
653
       
-
       


     

       
654
       
654
       
-
       
		var result types.RepoBranchesResponse

     

       
655
       
655
       
-
       
		err = json.Unmarshal(body, &result)

     

       
656
       
656
       
-
       
		if err != nil {

     

       
657
       
657
       
-
       
			log.Println("failed to parse response:", err)

     

       
658
       
645
       
 
       
			return

     

       
659
       
646
       
 
       
		}

     

       
660
       
647
       
 
       


     
···

       
1162
       
1149
       
 
       
		return

     

       
1163
       
1150
       
 
       
	}

     

       
1164
       
1151
       
 
       


     

       
1165
       
1165
       
-
       
	resp, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
1152
       
1152
       
+
       
	result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
1166
       
1153
       
 
       
	if err != nil {

     

       
1167
       
1154
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
1168
       
1168
       
-
       
		return

     

       
1169
       
1169
       
-
       
	}

     

       
1170
       
1170
       
-
       


     

       
1171
       
1171
       
-
       
	body, err := io.ReadAll(resp.Body)

     

       
1172
       
1172
       
-
       
	if err != nil {

     

       
1173
       
1173
       
-
       
		log.Printf("Error reading response body: %v", err)

     

       
1174
       
1174
       
-
       
		return

     

       
1175
       
1175
       
-
       
	}

     

       
1176
       
1176
       
-
       


     

       
1177
       
1177
       
-
       
	var result types.RepoBranchesResponse

     

       
1178
       
1178
       
-
       
	err = json.Unmarshal(body, &result)

     

       
1179
       
1179
       
-
       
	if err != nil {

     

       
1180
       
1180
       
-
       
		log.Println("failed to parse response:", err)

     

       
1181
       
1155
       
 
       
		return

     

       
1182
       
1156
       
 
       
	}

     

       
1183
       
1157
       
 
       


     
···

       
1245
       
1219
       
 
       
		return

     

       
1246
       
1220
       
 
       
	}

     

       
1247
       
1221
       
 
       


     

       
1248
       
1248
       
-
       
	sourceResp, err := sourceBranchesClient.Branches(user.Did, repo.Name)

     

       
1222
       
1222
       
+
       
	sourceResult, err := sourceBranchesClient.Branches(user.Did, repo.Name)

     

       
1249
       
1223
       
 
       
	if err != nil {

     

       
1250
       
1224
       
 
       
		log.Println("failed to reach knotserver for source branches", err)

     

       
1251
       
1251
       
-
       
		return

     

       
1252
       
1252
       
-
       
	}

     

       
1253
       
1253
       
-
       


     

       
1254
       
1254
       
-
       
	sourceBody, err := io.ReadAll(sourceResp.Body)

     

       
1255
       
1255
       
-
       
	if err != nil {

     

       
1256
       
1256
       
-
       
		log.Println("failed to read source response body", err)

     

       
1257
       
1257
       
-
       
		return

     

       
1258
       
1258
       
-
       
	}

     

       
1259
       
1259
       
-
       
	defer sourceResp.Body.Close()

     

       
1260
       
1260
       
-
       


     

       
1261
       
1261
       
-
       
	var sourceResult types.RepoBranchesResponse

     

       
1262
       
1262
       
-
       
	err = json.Unmarshal(sourceBody, &sourceResult)

     

       
1263
       
1263
       
-
       
	if err != nil {

     

       
1264
       
1264
       
-
       
		log.Println("failed to parse source branches response:", err)

     

       
1265
       
1225
       
 
       
		return

     

       
1266
       
1226
       
 
       
	}

     

       
1267
       
1227
       
 
       


     
···

       
1272
       
1232
       
 
       
		return

     

       
1273
       
1233
       
 
       
	}

     

       
1274
       
1234
       
 
       


     

       
1275
       
1275
       
-
       
	targetResp, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)

     

       
1235
       
1235
       
+
       
	targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)

     

       
1276
       
1236
       
 
       
	if err != nil {

     

       
1277
       
1237
       
 
       
		log.Println("failed to reach knotserver for target branches", err)

     

       
1278
       
1278
       
-
       
		return

     

       
1279
       
1279
       
-
       
	}

     

       
1280
       
1280
       
-
       


     

       
1281
       
1281
       
-
       
	targetBody, err := io.ReadAll(targetResp.Body)

     

       
1282
       
1282
       
-
       
	if err != nil {

     

       
1283
       
1283
       
-
       
		log.Println("failed to read target response body", err)

     

       
1284
       
1284
       
-
       
		return

     

       
1285
       
1285
       
-
       
	}

     

       
1286
       
1286
       
-
       
	defer targetResp.Body.Close()

     

       
1287
       
1287
       
-
       


     

       
1288
       
1288
       
-
       
	var targetResult types.RepoBranchesResponse

     

       
1289
       
1289
       
-
       
	err = json.Unmarshal(targetBody, &targetResult)

     

       
1290
       
1290
       
-
       
	if err != nil {

     

       
1291
       
1291
       
-
       
		log.Println("failed to parse target branches response:", err)

     

       
1292
       
1238
       
 
       
		return

     

       
1293
       
1239
       
 
       
	}

     

       
1294
       
1240
       
 
       


     

···

       
179
       
179
       
 
       
		return nil, err

     

       
180
       
180
       
 
       
	}

     

       
181
       
181
       
 
       


     

       
182
       
182
       
-
       
	resp, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name)

     

       
182
       
182
       
+
       
	result, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name)

     

       
183
       
183
       
 
       
	if err != nil {

     

       
184
       
184
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
185
       
185
       
-
       
		return nil, err

     

       
186
       
186
       
-
       
	}

     

       
187
       
187
       
-
       


     

       
188
       
188
       
-
       
	body, err := io.ReadAll(resp.Body)

     

       
189
       
189
       
-
       
	if err != nil {

     

       
190
       
190
       
-
       
		log.Printf("Error reading forkResponse forkBody: %v", err)

     

       
191
       
191
       
-
       
		return nil, err

     

       
192
       
192
       
-
       
	}

     

       
193
       
193
       
-
       


     

       
194
       
194
       
-
       
	var result types.RepoBranchesResponse

     

       
195
       
195
       
-
       
	err = json.Unmarshal(body, &result)

     

       
196
       
196
       
-
       
	if err != nil {

     

       
197
       
197
       
-
       
		log.Println("failed to parse forkResponse:", err)

     

       
198
       
185
       
 
       
		return nil, err

     

       
199
       
186
       
 
       
	}

     

       
200
       
187
       
 
       


     
···

       
563
       
550
       
 
       
		return

     

       
564
       
551
       
 
       
	}

     

       
565
       
552
       
 
       


     

       
566
       
566
       
-
       
	resp, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
553
       
553
       
+
       
	result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
567
       
554
       
 
       
	if err != nil {

     

       
568
       
555
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
569
       
556
       
 
       
		return

     

       
570
       
557
       
 
       
	}

     

       
571
       
558
       
 
       


     

       
572
       
572
       
-
       
	body, err := io.ReadAll(resp.Body)

     

       
573
       
573
       
-
       
	if err != nil {

     

       
574
       
574
       
-
       
		log.Printf("Error reading response body: %v", err)

     

       
575
       
575
       
-
       
		return

     

       
576
       
576
       
-
       
	}

     

       
577
       
577
       
-
       


     

       
578
       
578
       
-
       
	var result types.RepoBranchesResponse

     

       
579
       
579
       
-
       
	err = json.Unmarshal(body, &result)

     

       
580
       
580
       
-
       
	if err != nil {

     

       
581
       
581
       
-
       
		log.Println("failed to parse response:", err)

     

       
582
       
582
       
-
       
		return

     

       
583
       
583
       
-
       
	}

     

       
584
       
584
       
-
       


     

       
585
       
559
       
 
       
	slices.SortFunc(result.Branches, func(a, b types.Branch) int {

     

       
586
       
560
       
 
       
		if a.IsDefault {

     

       
587
       
561
       
 
       
			return -1

     
···

       
603
       
577
       
 
       
	s.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       
604
       
578
       
 
       
		LoggedInUser:         user,

     

       
605
       
579
       
 
       
		RepoInfo:             f.RepoInfo(s, user),

     

       
606
       
606
       
-
       
		RepoBranchesResponse: result,

     

       
580
       
580
       
+
       
		RepoBranchesResponse: *result,

     

       
607
       
581
       
 
       
	})

     

       
608
       
582
       
 
       
	return

     

       
609
       
583
       
 
       
}

     
···

       
980
       
954
       
 
       
			return

     

       
981
       
955
       
 
       
		}

     

       
982
       
956
       
 
       


     

       
983
       
983
       
-
       
		resp, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
957
       
957
       
+
       
		result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
984
       
958
       
 
       
		if err != nil {

     

       
985
       
959
       
 
       
			log.Println("failed to reach knotserver", err)

     

       
986
       
960
       
 
       
			return

     

       
987
       
961
       
 
       
		}

     

       
988
       
988
       
-
       
		defer resp.Body.Close()

     

       
989
       
989
       
-
       


     

       
990
       
990
       
-
       
		body, err := io.ReadAll(resp.Body)

     

       
991
       
991
       
-
       
		if err != nil {

     

       
992
       
992
       
-
       
			log.Printf("Error reading response body: %v", err)

     

       
993
       
993
       
-
       
		}

     

       
994
       
994
       
-
       


     

       
995
       
995
       
-
       
		var result types.RepoBranchesResponse

     

       
996
       
996
       
-
       
		err = json.Unmarshal(body, &result)

     

       
997
       
997
       
-
       
		if err != nil {

     

       
998
       
998
       
-
       
			log.Println("failed to parse response:", err)

     

       
999
       
999
       
-
       
		}

     

       
1000
       
962
       
 
       


     

       
1001
       
963
       
 
       
		s.pages.RepoSettings(w, pages.RepoSettingsParams{

     

       
1002
       
964
       
 
       
			LoggedInUser:                user,

     
···

       
1136
       
1098
       
 
       
	if err != nil {

     

       
1137
       
1099
       
 
       
		log.Printf("failed to create unsigned client for %s: %v", knot, err)

     

       
1138
       
1100
       
 
       
	} else {

     

       
1139
       
1139
       
-
       
		resp, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
1101
       
1101
       
+
       
		result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       
1140
       
1102
       
 
       
		if err != nil {

     

       
1141
       
1103
       
 
       
			log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err)

     

       
1142
       
1142
       
-
       
		} else {

     

       
1143
       
1143
       
-
       
			defer resp.Body.Close()

     

       
1144
       
1144
       
-
       
			body, err := io.ReadAll(resp.Body)

     

       
1145
       
1145
       
-
       
			if err != nil {

     

       
1146
       
1146
       
-
       
				log.Printf("error reading branch response body: %v", err)

     

       
1147
       
1147
       
-
       
			} else {

     

       
1148
       
1148
       
-
       
				var branchesResp types.RepoBranchesResponse

     

       
1149
       
1149
       
-
       
				if err := json.Unmarshal(body, &branchesResp); err != nil {

     

       
1150
       
1150
       
-
       
					log.Printf("error parsing branch response: %v", err)

     

       
1151
       
1151
       
-
       
				} else {

     

       
1152
       
1152
       
-
       
					disableFork = false

     

       
1153
       
1153
       
-
       
				}

     

       
1104
       
1104
       
+
       
		}

     

       
1154
       
1105
       
 
       


     

       
1155
       
1155
       
-
       
				if len(branchesResp.Branches) == 0 {

     

       
1156
       
1156
       
-
       
					disableFork = true

     

       
1157
       
1157
       
-
       
				}

     

       
1158
       
1158
       
-
       
			}

     

       
1106
       
1106
       
+
       
		if len(result.Branches) == 0 {

     

       
1107
       
1107
       
+
       
			disableFork = true

     

       
1159
       
1108
       
 
       
		}

     

       
1160
       
1109
       
 
       
	}

     

       
1161
       
1110
       
 
       


     

···

       
112
       
112
       
 
       
	return do[types.RepoLogResponse](us, req)

     

       
113
       
113
       
 
       
}

     

       
114
       
114
       
 
       


     

       
115
       
115
       
-
       
func (us *UnsignedClient) Branches(ownerDid, repoName string) (*http.Response, error) {

     

       
115
       
115
       
+
       
func (us *UnsignedClient) Branches(ownerDid, repoName string) (*types.RepoBranchesResponse, error) {

     

       
116
       
116
       
 
       
	const (

     

       
117
       
117
       
 
       
		Method = "GET"

     

       
118
       
118
       
 
       
	)

     
···

       
124
       
124
       
 
       
		return nil, err

     

       
125
       
125
       
 
       
	}

     

       
126
       
126
       
 
       


     

       
127
       
127
       
-
       
	return us.client.Do(req)

     

       
127
       
127
       
+
       
	return do[types.RepoBranchesResponse](us, req)

     

       
128
       
128
       
 
       
}

     

       
129
       
129
       
 
       


     

       
130
       
130
       
 
       
func (us *UnsignedClient) Tags(ownerDid, repoName string) (*types.RepoTagsResponse, error) {