commit b3324dd8f8ef756840f4323fc55a6cdc597cec0c · kot.pink/core

+134

appview/repo/repo.go

···

       1203
       1203
        
       	rp.pages.HxRefresh(w)

     

       1204
       1204
        
       }

     

       1205
       1205
        
       

     

       1206
       1206
       +
       func (rp *Repo) SubscribeLabel(w http.ResponseWriter, r *http.Request) {

     

       1207
       1207
       +
       	user := rp.oauth.GetUser(r)

     

       1208
       1208
       +
       	l := rp.logger.With("handler", "DeleteLabel")

     

       1209
       1209
       +
       	l = l.With("did", user.Did)

     

       1210
       1210
       +
       	l = l.With("handle", user.Handle)

     

       1211
       1211
       +
       

     

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

     

       1213
       1213
       +
       	if err != nil {

     

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

     

       1215
       1215
       +
       		return

     

       1216
       1216
       +
       	}

     

       1217
       1217
       +
       

     

       1218
       1218
       +
       	errorId := "label-operation"

     

       1219
       1219
       +
       	fail := func(msg string, err error) {

     

       1220
       1220
       +
       		l.Error(msg, "err", err)

     

       1221
       1221
       +
       		rp.pages.Notice(w, errorId, msg)

     

       1222
       1222
       +
       	}

     

       1223
       1223
       +
       

     

       1224
       1224
       +
       	labelAt := r.FormValue("label")

     

       1225
       1225
       +
       	_, err = db.GetLabelDefinition(rp.db, db.FilterEq("at_uri", labelAt))

     

       1226
       1226
       +
       	if err != nil {

     

       1227
       1227
       +
       		fail("Failed to subscribe to label.", err)

     

       1228
       1228
       +
       		return

     

       1229
       1229
       +
       	}

     

       1230
       1230
       +
       

     

       1231
       1231
       +
       	newRepo := f.Repo

     

       1232
       1232
       +
       	newRepo.Labels = append(newRepo.Labels, labelAt)

     

       1233
       1233
       +
       	repoRecord := newRepo.AsRecord()

     

       1234
       1234
       +
       

     

       1235
       1235
       +
       	client, err := rp.oauth.AuthorizedClient(r)

     

       1236
       1236
       +
       	if err != nil {

     

       1237
       1237
       +
       		fail(err.Error(), err)

     

       1238
       1238
       +
       		return

     

       1239
       1239
       +
       	}

     

       1240
       1240
       +
       

     

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

     

       1242
       1242
       +
       	if err != nil {

     

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

     

       1244
       1244
       +
       		return

     

       1245
       1245
       +
       	}

     

       1246
       1246
       +
       	_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       1247
       1247
       +
       		Collection: tangled.RepoNSID,

     

       1248
       1248
       +
       		Repo:       newRepo.Did,

     

       1249
       1249
       +
       		Rkey:       newRepo.Rkey,

     

       1250
       1250
       +
       		SwapRecord: ex.Cid,

     

       1251
       1251
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       1252
       1252
       +
       			Val: &repoRecord,

     

       1253
       1253
       +
       		},

     

       1254
       1254
       +
       	})

     

       1255
       1255
       +
       

     

       1256
       1256
       +
       	err = db.SubscribeLabel(rp.db, &db.RepoLabel{

     

       1257
       1257
       +
       		RepoAt:  f.RepoAt(),

     

       1258
       1258
       +
       		LabelAt: syntax.ATURI(labelAt),

     

       1259
       1259
       +
       	})

     

       1260
       1260
       +
       	if err != nil {

     

       1261
       1261
       +
       		fail("Failed to subscribe to label.", err)

     

       1262
       1262
       +
       		return

     

       1263
       1263
       +
       	}

     

       1264
       1264
       +
       

     

       1265
       1265
       +
       	// everything succeeded

     

       1266
       1266
       +
       	rp.pages.HxRefresh(w)

     

       1267
       1267
       +
       }

     

       1268
       1268
       +
       

     

       1269
       1269
       +
       func (rp *Repo) UnsubscribeLabel(w http.ResponseWriter, r *http.Request) {

     

       1270
       1270
       +
       	user := rp.oauth.GetUser(r)

     

       1271
       1271
       +
       	l := rp.logger.With("handler", "DeleteLabel")

     

       1272
       1272
       +
       	l = l.With("did", user.Did)

     

       1273
       1273
       +
       	l = l.With("handle", user.Handle)

     

       1274
       1274
       +
       

     

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

     

       1276
       1276
       +
       	if err != nil {

     

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

     

       1278
       1278
       +
       		return

     

       1279
       1279
       +
       	}

     

       1280
       1280
       +
       

     

       1281
       1281
       +
       	errorId := "label-operation"

     

       1282
       1282
       +
       	fail := func(msg string, err error) {

     

       1283
       1283
       +
       		l.Error(msg, "err", err)

     

       1284
       1284
       +
       		rp.pages.Notice(w, errorId, msg)

     

       1285
       1285
       +
       	}

     

       1286
       1286
       +
       

     

       1287
       1287
       +
       	labelAt := r.FormValue("label")

     

       1288
       1288
       +
       	_, err = db.GetLabelDefinition(rp.db, db.FilterEq("at_uri", labelAt))

     

       1289
       1289
       +
       	if err != nil {

     

       1290
       1290
       +
       		fail("Failed to unsubscribe to label.", err)

     

       1291
       1291
       +
       		return

     

       1292
       1292
       +
       	}

     

       1293
       1293
       +
       

     

       1294
       1294
       +
       	// update repo record to remove the label reference

     

       1295
       1295
       +
       	newRepo := f.Repo

     

       1296
       1296
       +
       	var updated []string

     

       1297
       1297
       +
       	for _, l := range newRepo.Labels {

     

       1298
       1298
       +
       		if l != labelAt {

     

       1299
       1299
       +
       			updated = append(updated, l)

     

       1300
       1300
       +
       		}

     

       1301
       1301
       +
       	}

     

       1302
       1302
       +
       	newRepo.Labels = updated

     

       1303
       1303
       +
       	repoRecord := newRepo.AsRecord()

     

       1304
       1304
       +
       

     

       1305
       1305
       +
       	client, err := rp.oauth.AuthorizedClient(r)

     

       1306
       1306
       +
       	if err != nil {

     

       1307
       1307
       +
       		fail(err.Error(), err)

     

       1308
       1308
       +
       		return

     

       1309
       1309
       +
       	}

     

       1310
       1310
       +
       

     

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

     

       1312
       1312
       +
       	if err != nil {

     

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

     

       1314
       1314
       +
       		return

     

       1315
       1315
       +
       	}

     

       1316
       1316
       +
       	_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       1317
       1317
       +
       		Collection: tangled.RepoNSID,

     

       1318
       1318
       +
       		Repo:       newRepo.Did,

     

       1319
       1319
       +
       		Rkey:       newRepo.Rkey,

     

       1320
       1320
       +
       		SwapRecord: ex.Cid,

     

       1321
       1321
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       1322
       1322
       +
       			Val: &repoRecord,

     

       1323
       1323
       +
       		},

     

       1324
       1324
       +
       	})

     

       1325
       1325
       +
       

     

       1326
       1326
       +
       	err = db.UnsubscribeLabel(

     

       1327
       1327
       +
       		rp.db,

     

       1328
       1328
       +
       		db.FilterEq("repo_at", f.RepoAt()),

     

       1329
       1329
       +
       		db.FilterEq("label_at", labelAt),

     

       1330
       1330
       +
       	)

     

       1331
       1331
       +
       	if err != nil {

     

       1332
       1332
       +
       		fail("Failed to unsubscribe label.", err)

     

       1333
       1333
       +
       		return

     

       1334
       1334
       +
       	}

     

       1335
       1335
       +
       

     

       1336
       1336
       +
       	// everything succeeded

     

       1337
       1337
       +
       	rp.pages.HxRefresh(w)

     

       1338
       1338
       +
       }

     

       1339
       1339
       +
       

     

       1206
       1340
        
       func (rp *Repo) AddCollaborator(w http.ResponseWriter, r *http.Request) {

     

       1207
       1341
        
       	user := rp.oauth.GetUser(r)

     

       1208
       1342
        
       	l := rp.logger.With("handler", "AddCollaborator")

appview/repo/router.go

···

       78
       78
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Post("/spindle", rp.EditSpindle)

     

       79
       79
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Put("/label", rp.AddLabel)

     

       80
       80
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Delete("/label", rp.DeleteLabel)

     

       81
       81
       +
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Put("/label/subscribe", rp.SubscribeLabel)

     

       82
       82
       +
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Delete("/label/subscribe", rp.UnsubscribeLabel)

     

       81
       83
        
       			r.With(mw.RepoPermissionMiddleware("repo:invite")).Put("/collaborator", rp.AddCollaborator)

     

       82
       84
        
       			r.With(mw.RepoPermissionMiddleware("repo:delete")).Delete("/delete", rp.DeleteRepo)

     

       83
       85
        
       			r.Put("/branches/default", rp.SetDefaultBranch)

+1 -1

appview/state/router.go

···

       252
       252
        
       }

     

       253
       253
        
       

     

       254
       254
        
       func (s *State) LabelsRouter(mw *middleware.Middleware) http.Handler {

     

       255
       255
       -
       	ls := labels.New(s.oauth, s.repoResolver, s.pages, s.spindlestream, s.idResolver, s.db, s.config, s.enforcer)

     

       255
       255
       +
       	ls := labels.New(s.oauth, s.pages, s.db, s.validator)

     

       256
       256
        
       	return ls.Router(mw)

     

       257
       257
        
       }

     

       258
       258