···
"github.com/go-chi/chi/v5"
···
"tangled.sh/tangled.sh/core/appview/middleware"
"tangled.sh/tangled.sh/core/appview/oauth"
"tangled.sh/tangled.sh/core/appview/pages"
18
+
"tangled.sh/tangled.sh/core/appview/serververify"
"tangled.sh/tangled.sh/core/eventconsumer"
"tangled.sh/tangled.sh/core/idresolver"
23
-
"tangled.sh/tangled.sh/core/knotclient"
"tangled.sh/tangled.sh/core/rbac"
"tangled.sh/tangled.sh/core/tid"
···
Knotstream *eventconsumer.Consumer
42
-
func (k *Knots) Router(mw *middleware.Middleware) http.Handler {
39
+
func (k *Knots) Router() http.Handler {
45
-
r.Use(middleware.AuthMiddleware(k.OAuth))
42
+
r.With(middleware.AuthMiddleware(k.OAuth)).Get("/", k.knots)
43
+
r.With(middleware.AuthMiddleware(k.OAuth)).Post("/register", k.register)
48
-
r.Post("/key", k.generateKey)
45
+
r.With(middleware.AuthMiddleware(k.OAuth)).Get("/{domain}", k.dashboard)
46
+
r.With(middleware.AuthMiddleware(k.OAuth)).Delete("/{domain}", k.delete)
50
-
r.Route("/{domain}", func(r chi.Router) {
51
-
r.Post("/init", k.init)
52
-
r.Get("/", k.dashboard)
53
-
r.Route("/member", func(r chi.Router) {
54
-
r.Use(mw.KnotOwner())
55
-
r.Get("/", k.members)
56
-
r.Put("/", k.addMember)
57
-
r.Delete("/", k.removeMember)
48
+
r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/retry", k.retry)
49
+
r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/add", k.addMember)
50
+
r.With(middleware.AuthMiddleware(k.OAuth)).Post("/{domain}/remove", k.removeMember)
64
-
// get knots registered by this user
65
-
func (k *Knots) index(w http.ResponseWriter, r *http.Request) {
66
-
l := k.Logger.With("handler", "index")
55
+
func (k *Knots) knots(w http.ResponseWriter, r *http.Request) {
user := k.OAuth.GetUser(r)
registrations, err := db.RegistrationsByDid(k.Db, user.Did)
71
-
l.Error("failed to get registrations by did", "err", err)
59
+
k.Logger.Error("failed to fetch knot registrations", "err", err)
60
+
w.WriteHeader(http.StatusInternalServerError)
k.Pages.Knots(w, pages.KnotsParams{
···
81
-
func (k *Knots) generateKey(w http.ResponseWriter, r *http.Request) {
82
-
l := k.Logger.With("handler", "generateKey")
70
+
func (k *Knots) dashboard(w http.ResponseWriter, r *http.Request) {
71
+
l := k.Logger.With("handler", "dashboard")
user := k.OAuth.GetUser(r)
86
-
l = l.With("did", did)
74
+
l = l.With("user", user.Did)
88
-
// check if domain is valid url, and strip extra bits down to just host
89
-
domain := r.FormValue("domain")
76
+
domain := chi.URLParam(r, "domain")
91
-
l.Error("empty domain")
92
-
http.Error(w, "Invalid form", http.StatusBadRequest)
l = l.With("domain", domain)
97
-
noticeId := "registration-error"
99
-
k.Pages.Notice(w, noticeId, "Failed to generate registration key.")
82
+
registrations, err := db.GetRegistrations(
84
+
db.FilterEq("did", user.Did),
85
+
db.FilterEq("domain", domain),
88
+
l.Error("failed to get registrations", "err", err)
89
+
http.Error(w, "Not found", http.StatusNotFound)
102
-
key, err := db.GenerateRegistrationKey(k.Db, domain, did)
93
+
// Find the specific registration for this domain
94
+
var registration *db.Registration
95
+
for _, reg := range registrations {
96
+
if reg.Domain == domain && reg.ByDid == user.Did && reg.Registered != nil {
102
+
if registration == nil {
103
+
l.Error("registration not found or not verified")
104
+
http.Error(w, "Not found", http.StatusNotFound)
107
+
registration := registrations[0]
109
+
members, err := k.Enforcer.GetUserByRole("server:member", domain)
104
-
l.Error("failed to generate registration key", "err", err)
111
+
l.Error("failed to get knot members", "err", err)
112
+
http.Error(w, "Not found", http.StatusInternalServerError)
115
+
slices.Sort(members)
109
-
allRegs, err := db.RegistrationsByDid(k.Db, did)
117
+
repos, err := db.GetRepos(
120
+
db.FilterEq("knot", domain),
111
-
l.Error("failed to generate registration key", "err", err)
123
+
l.Error("failed to get knot repos", "err", err)
124
+
http.Error(w, "Not found", http.StatusInternalServerError)
116
-
k.Pages.KnotListingFull(w, pages.KnotListingFullParams{
117
-
Registrations: allRegs,
119
-
k.Pages.KnotSecret(w, pages.KnotSecretParams{
128
+
// organize repos by did
129
+
repoMap := make(map[string][]db.Repo)
130
+
for _, r := range repos {
131
+
repoMap[r.Did] = append(repoMap[r.Did], r)
134
+
k.Pages.Knot(w, pages.KnotParams{
135
+
LoggedInUser: user,
136
+
Registration: ®istration,
124
-
// create a signed request and check if a node responds to that
125
-
func (k *Knots) init(w http.ResponseWriter, r *http.Request) {
126
-
l := k.Logger.With("handler", "init")
143
+
func (k *Knots) register(w http.ResponseWriter, r *http.Request) {
user := k.OAuth.GetUser(r)
145
+
l := k.Logger.With("handler", "register")
129
-
noticeId := "operation-error"
130
-
defaultErr := "Failed to initialize knot. Try again later."
147
+
noticeId := "register-error"
148
+
defaultErr := "Failed to register knot. Try again later."
k.Pages.Notice(w, noticeId, defaultErr)
135
-
domain := chi.URLParam(r, "domain")
153
+
domain := r.FormValue("domain")
137
-
http.Error(w, "malformed url", http.StatusBadRequest)
155
+
k.Pages.Notice(w, noticeId, "Incomplete form.")
l = l.With("domain", domain)
159
+
l = l.With("user", user.Did)
142
-
l.Info("checking domain")
161
+
tx, err := k.Db.Begin()
163
+
l.Error("failed to start transaction", "err", err)
169
+
k.Enforcer.E.LoadPolicy()
144
-
registration, err := db.RegistrationByDomain(k.Db, domain)
172
+
err = db.AddKnot(tx, domain, user.Did)
146
-
l.Error("failed to get registration for domain", "err", err)
174
+
l.Error("failed to insert", "err", err)
150
-
if registration.ByDid != user.Did {
151
-
l.Error("unauthorized", "wantedDid", registration.ByDid, "gotDid", user.Did)
152
-
w.WriteHeader(http.StatusUnauthorized)
179
+
err = k.Enforcer.AddKnot(domain)
181
+
l.Error("failed to create knot", "err", err)
156
-
secret, err := db.GetRegistrationKey(k.Db, domain)
186
+
// create record on pds
187
+
client, err := k.OAuth.AuthorizedClient(r)
158
-
l.Error("failed to get registration key for domain", "err", err)
189
+
l.Error("failed to authorize client", "err", err)
163
-
client, err := knotclient.NewSignedClient(domain, secret, k.Config.Core.Dev)
194
+
ex, _ := client.RepoGetRecord(r.Context(), "", tangled.KnotNSID, user.Did, domain)
200
+
// re-announce by registering under same rkey
201
+
_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
202
+
Collection: tangled.KnotNSID,
205
+
Record: &lexutil.LexiconTypeDecoder{
206
+
Val: &tangled.Knot{
207
+
CreatedAt: time.Now().Format(time.RFC3339),
165
-
l.Error("failed to create knotclient", "err", err)
214
+
l.Error("failed to put record", "err", err)
170
-
resp, err := client.Init(user.Did)
172
-
k.Pages.Notice(w, noticeId, fmt.Sprintf("Failed to make request: %s", err.Error()))
173
-
l.Error("failed to make init request", "err", err)
221
+
l.Error("failed to commit transaction", "err", err)
177
-
if resp.StatusCode == http.StatusConflict {
178
-
k.Pages.Notice(w, noticeId, "This knot is already registered")
179
-
l.Error("knot already registered", "statuscode", resp.StatusCode)
226
+
err = k.Enforcer.E.SavePolicy()
228
+
l.Error("failed to update ACL", "err", err)
229
+
k.Pages.HxRefresh(w)
183
-
if resp.StatusCode != http.StatusNoContent {
184
-
k.Pages.Notice(w, noticeId, fmt.Sprintf("Received status %d from knot, expected %d", resp.StatusCode, http.StatusNoContent))
185
-
l.Error("incorrect statuscode returned", "statuscode", resp.StatusCode, "expected", http.StatusNoContent)
233
+
// begin verification
234
+
err = serververify.RunVerification(r.Context(), domain, user.Did, k.Config.Core.Dev)
236
+
l.Error("verification failed", "err", err)
237
+
k.Pages.HxRefresh(w)
189
-
// verify response mac
190
-
signature := resp.Header.Get("X-Signature")
191
-
signatureBytes, err := hex.DecodeString(signature)
241
+
err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Did)
243
+
l.Error("failed to mark verified", "err", err)
244
+
k.Pages.HxRefresh(w)
196
-
expectedMac := hmac.New(sha256.New, []byte(secret))
197
-
expectedMac.Write([]byte("ok"))
248
+
// add this knot to knotstream
249
+
go k.Knotstream.AddSource(
251
+
eventconsumer.NewKnotSource(domain),
199
-
if !hmac.Equal(expectedMac.Sum(nil), signatureBytes) {
200
-
k.Pages.Notice(w, noticeId, "Response signature mismatch, consider regenerating the secret and retrying.")
201
-
l.Error("signature mismatch", "bytes", signatureBytes)
255
+
k.Pages.HxRefresh(w)
258
+
func (k *Knots) delete(w http.ResponseWriter, r *http.Request) {
259
+
user := k.OAuth.GetUser(r)
260
+
l := k.Logger.With("handler", "delete")
262
+
noticeId := "operation-error"
263
+
defaultErr := "Failed to delete knot. Try again later."
265
+
k.Pages.Notice(w, noticeId, defaultErr)
268
+
domain := chi.URLParam(r, "domain")
270
+
l.Error("empty domain")
275
+
// get record from db first
276
+
registrations, err := db.GetRegistrations(
278
+
db.FilterEq("did", user.Did),
279
+
db.FilterEq("domain", domain),
282
+
l.Error("failed to get registration", "err", err)
286
+
if len(registrations) != 1 {
287
+
l.Error("got incorret number of registrations", "got", len(registrations), "expected", 1)
291
+
registration := registrations[0]
205
-
tx, err := k.Db.BeginTx(r.Context(), nil)
293
+
tx, err := k.Db.Begin()
207
-
l.Error("failed to start tx", "err", err)
295
+
l.Error("failed to start txn", "err", err)
213
-
err = k.Enforcer.E.LoadPolicy()
215
-
l.Error("rollback failed", "err", err)
301
+
k.Enforcer.E.LoadPolicy()
219
-
// mark as registered
220
-
err = db.Register(tx, domain)
304
+
err = db.DeleteKnot(
306
+
db.FilterEq("did", user.Did),
307
+
db.FilterEq("domain", domain),
222
-
l.Error("failed to register domain", "err", err)
310
+
l.Error("failed to delete registration", "err", err)
227
-
// set permissions for this did as owner
228
-
reg, err := db.RegistrationByDomain(tx, domain)
230
-
l.Error("failed get registration by domain", "err", err)
315
+
// delete from enforcer if it was registered
316
+
if registration.Registered != nil {
317
+
err = k.Enforcer.RemoveKnot(domain)
319
+
l.Error("failed to update ACL", "err", err)
235
-
// add basic acls for this domain
236
-
err = k.Enforcer.AddKnot(domain)
325
+
client, err := k.OAuth.AuthorizedClient(r)
238
-
l.Error("failed to add knot to enforcer", "err", err)
327
+
l.Error("failed to authorize client", "err", err)
243
-
// add this did as owner of this domain
244
-
err = k.Enforcer.AddKnotOwner(domain, reg.ByDid)
332
+
_, err = client.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
333
+
Collection: tangled.KnotNSID,
246
-
l.Error("failed to add knot owner to enforcer", "err", err)
339
+
l.Error("failed to delete record", "err", err)
253
-
l.Error("failed to commit changes", "err", err)
344
+
l.Error("failed to delete knot", "err", err)
err = k.Enforcer.E.SavePolicy()
260
-
l.Error("failed to update ACLs", "err", err)
351
+
l.Error("failed to update ACL", "err", err)
352
+
k.Pages.HxRefresh(w)
265
-
// add this knot to knotstream
266
-
go k.Knotstream.AddSource(
267
-
context.Background(),
268
-
eventconsumer.NewKnotSource(domain),
356
+
shouldRedirect := r.Header.Get("shouldRedirect")
357
+
if shouldRedirect == "true" {
358
+
k.Pages.HxRedirect(w, "/knots")
271
-
k.Pages.KnotListing(w, pages.KnotListingParams{
272
-
Registration: *reg,
276
-
func (k *Knots) dashboard(w http.ResponseWriter, r *http.Request) {
277
-
l := k.Logger.With("handler", "dashboard")
365
+
func (k *Knots) retry(w http.ResponseWriter, r *http.Request) {
366
+
user := k.OAuth.GetUser(r)
367
+
l := k.Logger.With("handler", "retry")
369
+
noticeId := "operation-error"
370
+
defaultErr := "Failed to verify knot. Try again later."
279
-
w.WriteHeader(http.StatusInternalServerError)
372
+
k.Pages.Notice(w, noticeId, defaultErr)
domain := chi.URLParam(r, "domain")
284
-
http.Error(w, "malformed url", http.StatusBadRequest)
377
+
l.Error("empty domain")
l = l.With("domain", domain)
382
+
l = l.With("user", user.Did)
289
-
user := k.OAuth.GetUser(r)
290
-
l = l.With("did", user.Did)
292
-
// dashboard is only available to owners
293
-
ok, err := k.Enforcer.IsKnotOwner(user.Did, domain)
384
+
// get record from db first
385
+
registrations, err := db.GetRegistrations(
387
+
db.FilterEq("did", user.Did),
388
+
db.FilterEq("domain", domain),
295
-
l.Error("failed to query enforcer", "err", err)
391
+
l.Error("failed to get registration", "err", err)
299
-
http.Error(w, "only owners can view dashboards", http.StatusUnauthorized)
395
+
if len(registrations) != 1 {
396
+
l.Error("got incorret number of registrations", "got", len(registrations), "expected", 1)
400
+
registration := registrations[0]
303
-
reg, err := db.RegistrationByDomain(k.Db, domain)
402
+
// begin verification
403
+
err = serververify.RunVerification(r.Context(), domain, user.Did, k.Config.Core.Dev)
305
-
l.Error("failed to get registration by domain", "err", err)
405
+
l.Error("verification failed", "err", err)
407
+
if errors.Is(err, serververify.FetchError) {
408
+
k.Pages.Notice(w, noticeId, "Failed to verify knot, unable to fetch owner.")
412
+
if e, ok := err.(*serververify.OwnerMismatch); ok {
413
+
k.Pages.Notice(w, noticeId, e.Error())
310
-
var members []string
311
-
if reg.Registered != nil {
312
-
members, err = k.Enforcer.GetUserByRole("server:member", domain)
421
+
err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Did)
423
+
l.Error("failed to mark verified", "err", err)
424
+
k.Pages.Notice(w, noticeId, err.Error())
428
+
// if this knot was previously read-only, then emit a record too
430
+
// this is part of migrating from the old knot system to the new one
431
+
if registration.ReadOnly {
432
+
// re-announce by registering under same rkey
433
+
client, err := k.OAuth.AuthorizedClient(r)
314
-
l.Error("failed to get members list", "err", err)
435
+
l.Error("failed to authorize client", "err", err)
440
+
ex, _ := client.RepoGetRecord(r.Context(), "", tangled.KnotNSID, user.Did, domain)
446
+
// ignore the error here
447
+
_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
448
+
Collection: tangled.KnotNSID,
451
+
Record: &lexutil.LexiconTypeDecoder{
452
+
Val: &tangled.Knot{
453
+
CreatedAt: time.Now().Format(time.RFC3339),
459
+
l.Error("non-fatal: failed to reannouce knot", "err", err)
320
-
repos, err := db.GetRepos(
463
+
// add this knot to knotstream
464
+
go k.Knotstream.AddSource(
466
+
eventconsumer.NewKnotSource(domain),
469
+
shouldRefresh := r.Header.Get("shouldRefresh")
470
+
if shouldRefresh == "true" {
471
+
k.Pages.HxRefresh(w)
475
+
// Get updated registration to show
476
+
registrations, err = db.GetRegistrations(
323
-
db.FilterEq("knot", domain),
324
-
db.FilterIn("did", members),
478
+
db.FilterEq("did", user.Did),
479
+
db.FilterEq("domain", domain),
327
-
l.Error("failed to get repos list", "err", err)
482
+
l.Error("failed to get registration", "err", err)
332
-
repoByMember := make(map[string][]db.Repo)
333
-
for _, r := range repos {
334
-
repoByMember[r.Did] = append(repoByMember[r.Did], r)
337
-
k.Pages.Knot(w, pages.KnotParams{
338
-
LoggedInUser: user,
341
-
Repos: repoByMember,
346
-
// list members of domain, requires auth and requires owner status
347
-
func (k *Knots) members(w http.ResponseWriter, r *http.Request) {
348
-
l := k.Logger.With("handler", "members")
350
-
domain := chi.URLParam(r, "domain")
352
-
http.Error(w, "malformed url", http.StatusBadRequest)
486
+
if len(registrations) != 1 {
487
+
l.Error("got incorret number of registrations", "got", len(registrations), "expected", 1)
355
-
l = l.With("domain", domain)
491
+
updatedRegistration := registrations[0]
357
-
// list all members for this domain
358
-
memberDids, err := k.Enforcer.GetUserByRole("server:member", domain)
360
-
w.Write([]byte("failed to fetch member list"))
493
+
log.Println(updatedRegistration)
364
-
w.Write([]byte(strings.Join(memberDids, "\n")))
495
+
w.Header().Set("HX-Reswap", "outerHTML")
496
+
k.Pages.KnotListing(w, pages.KnotListingParams{
497
+
Registration: &updatedRegistration,
367
-
// add member to domain, requires auth and requires invite access
func (k *Knots) addMember(w http.ResponseWriter, r *http.Request) {
369
-
l := k.Logger.With("handler", "members")
502
+
user := k.OAuth.GetUser(r)
503
+
l := k.Logger.With("handler", "addMember")
domain := chi.URLParam(r, "domain")
373
-
http.Error(w, "malformed url", http.StatusBadRequest)
507
+
l.Error("empty domain")
508
+
http.Error(w, "Not found", http.StatusNotFound)
l = l.With("domain", domain)
512
+
l = l.With("user", user.Did)
378
-
reg, err := db.RegistrationByDomain(k.Db, domain)
514
+
registrations, err := db.GetRegistrations(
516
+
db.FilterEq("did", user.Did),
517
+
db.FilterEq("domain", domain),
518
+
db.FilterIsNot("registered", "null"),
380
-
l.Error("failed to get registration by domain", "err", err)
381
-
http.Error(w, "malformed url", http.StatusBadRequest)
521
+
l.Error("failed to retrieve domain registration", "err", err)
522
+
http.Error(w, "Not found", http.StatusNotFound)
385
-
noticeId := fmt.Sprintf("add-member-error-%d", reg.Id)
386
-
l = l.With("notice-id", noticeId)
526
+
noticeId := fmt.Sprintf("add-member-error-%d", registration.Id)
defaultErr := "Failed to add member. Try again later."
k.Pages.Notice(w, noticeId, defaultErr)
392
-
subjectIdentifier := r.FormValue("subject")
393
-
if subjectIdentifier == "" {
394
-
http.Error(w, "malformed form", http.StatusBadRequest)
532
+
member := r.FormValue("member")
534
+
l.Error("empty member")
535
+
k.Pages.Notice(w, noticeId, "Failed to add member, empty form.")
397
-
l = l.With("subjectIdentifier", subjectIdentifier)
538
+
l = l.With("member", member)
399
-
subjectIdentity, err := k.IdResolver.ResolveIdent(r.Context(), subjectIdentifier)
540
+
memberId, err := k.IdResolver.ResolveIdent(r.Context(), member)
401
-
l.Error("failed to resolve identity", "err", err)
542
+
l.Error("failed to resolve member identity to handle", "err", err)
k.Pages.Notice(w, noticeId, "Failed to add member, identity resolution failed.")
405
-
l = l.With("subjectDid", subjectIdentity.DID)
407
-
l.Info("adding member to knot")
546
+
if memberId.Handle.IsInvalidHandle() {
547
+
l.Error("failed to resolve member identity to handle")
548
+
k.Pages.Notice(w, noticeId, "Failed to add member, identity resolution failed.")
409
-
// announce this relation into the firehose, store into owners' pds
client, err := k.OAuth.AuthorizedClient(r)
412
-
l.Error("failed to create client", "err", err)
555
+
l.Error("failed to authorize client", "err", err)
417
-
currentUser := k.OAuth.GetUser(r)
418
-
createdAt := time.Now().Format(time.RFC3339)
419
-
resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
562
+
_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
Collection: tangled.KnotMemberNSID,
421
-
Repo: currentUser.Did,
Record: &lexutil.LexiconTypeDecoder{
Val: &tangled.KnotMember{
425
-
Subject: subjectIdentity.DID.String(),
568
+
CreatedAt: time.Now().Format(time.RFC3339),
427
-
CreatedAt: createdAt,
570
+
Subject: memberId.DID.String(),
432
-
l.Error("failed to write to PDS", "err", err)
575
+
l.Error("failed to add record to PDS", "err", err)
576
+
k.Pages.Notice(w, noticeId, "Failed to add record to PDS, try again later.")
580
+
err = k.Enforcer.AddKnotMember(domain, memberId.DID.String())
582
+
l.Error("failed to add member to ACLs", "err", err)
436
-
l = l.With("at-uri", resp.Uri)
437
-
l.Info("wrote record to PDS")
439
-
secret, err := db.GetRegistrationKey(k.Db, domain)
587
+
err = k.Enforcer.E.SavePolicy()
441
-
l.Error("failed to get registration key", "err", err)
589
+
l.Error("failed to save ACL policy", "err", err)
595
+
k.Pages.HxRedirect(w, fmt.Sprintf("/knots/%s", domain))
598
+
func (k *Knots) removeMember(w http.ResponseWriter, r *http.Request) {
599
+
user := k.OAuth.GetUser(r)
600
+
l := k.Logger.With("handler", "removeMember")
602
+
noticeId := "operation-error"
603
+
defaultErr := "Failed to remove member. Try again later."
605
+
k.Pages.Notice(w, noticeId, defaultErr)
608
+
domain := chi.URLParam(r, "domain")
610
+
l.Error("empty domain")
614
+
l = l.With("domain", domain)
615
+
l = l.With("user", user.Did)
446
-
ksClient, err := knotclient.NewSignedClient(domain, secret, k.Config.Core.Dev)
617
+
registrations, err := db.GetRegistrations(
619
+
db.FilterEq("did", user.Did),
620
+
db.FilterEq("domain", domain),
621
+
db.FilterIsNot("registered", "null"),
448
-
l.Error("failed to create client", "err", err)
624
+
l.Error("failed to get registration", "err", err)
627
+
if len(registrations) != 1 {
628
+
l.Error("got incorret number of registrations", "got", len(registrations), "expected", 1)
453
-
ksResp, err := ksClient.AddMember(subjectIdentity.DID.String())
632
+
member := r.FormValue("member")
634
+
l.Error("empty member")
635
+
k.Pages.Notice(w, noticeId, "Failed to remove member, empty form.")
638
+
l = l.With("member", member)
640
+
memberId, err := k.IdResolver.ResolveIdent(r.Context(), member)
455
-
l.Error("failed to reach knotserver", "err", err)
456
-
k.Pages.Notice(w, noticeId, "Failed to reach to knotserver.")
642
+
l.Error("failed to resolve member identity to handle", "err", err)
643
+
k.Pages.Notice(w, noticeId, "Failed to remove member, identity resolution failed.")
646
+
if memberId.Handle.IsInvalidHandle() {
647
+
l.Error("failed to resolve member identity to handle")
648
+
k.Pages.Notice(w, noticeId, "Failed to remove member, identity resolution failed.")
460
-
if ksResp.StatusCode != http.StatusNoContent {
461
-
l.Error("status mismatch", "got", ksResp.StatusCode, "expected", http.StatusNoContent)
462
-
k.Pages.Notice(w, noticeId, fmt.Sprintf("Unexpected status code from knotserver %d, expected %d", ksResp.StatusCode, http.StatusNoContent))
652
+
// remove from enforcer
653
+
err = k.Enforcer.RemoveKnotMember(domain, memberId.DID.String())
655
+
l.Error("failed to update ACLs", "err", err)
466
-
err = k.Enforcer.AddKnotMember(domain, subjectIdentity.DID.String())
660
+
client, err := k.OAuth.AuthorizedClient(r)
468
-
l.Error("failed to add member to enforcer", "err", err)
662
+
l.Error("failed to authorize client", "err", err)
474
-
k.Pages.HxRedirect(w, fmt.Sprintf("/knots/%s", domain))
667
+
// TODO: We need to track the rkey for knot members to delete the record
668
+
// For now, just remove from ACLs
671
+
// commit everything
672
+
err = k.Enforcer.E.SavePolicy()
674
+
l.Error("failed to save ACLs", "err", err)
477
-
func (k *Knots) removeMember(w http.ResponseWriter, r *http.Request) {
680
+
k.Pages.HxRefresh(w)
veryroundbird.house
anirudh.fi