From 36d46a857614752feec8a6c092f9b16384e7019f Mon Sep 17 00:00:00 2001 From: Henry Date: Fri, 19 Mar 2021 12:28:14 +0100 Subject: [PATCH] fix denied list in sqlite --- cmd/server/main.go | 3 +- roomdb/interface.go | 10 ++-- roomdb/mockdb/denied.go | 104 ++++++++++++++++++----------------- roomdb/sqlite/denied.go | 81 +++++++++++++-------------- roomdb/sqlite/denied_test.go | 62 +++++++++++---------- roomdb/sqlite/new.go | 20 +++---- roomdb/types.go | 3 + web/handlers/http.go | 1 + 8 files changed, 143 insertions(+), 141 deletions(-) diff --git a/cmd/server/main.go b/cmd/server/main.go index 483dc22..7abc7ef 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -247,9 +247,10 @@ func runroomsrv() error { handlers.Databases{ Aliases: db.Aliases, AuthFallback: db.AuthFallback, - Members: db.Members, + DeniedList: db.DeniedList, Invites: db.Invites, Notices: db.Notices, + Members: db.Members, PinnedNotices: db.PinnedNotices, }, ) diff --git a/roomdb/interface.go b/roomdb/interface.go index e120e15..c8fc634 100644 --- a/roomdb/interface.go +++ b/roomdb/interface.go @@ -60,10 +60,10 @@ type MembersService interface { SetRole(context.Context, int64, Role) error } -// DeniedListService changes the lists of people that are Denieded to get into the room -type DeniedListService interface { - // Add adds the feed to the list. - Add(context.Context, refs.FeedRef) error +// DeniedKeysService changes the lists of public keys that are not allowed to get into the room +type DeniedKeysService interface { + // Add adds the feed to the list, together with a comment for other members + Add(ctx context.Context, ref refs.FeedRef, comment string) error // HasFeed returns true if a feed is on the list. HasFeed(context.Context, refs.FeedRef) bool @@ -160,7 +160,7 @@ type NoticesService interface { //go:generate counterfeiter -o mockdb/auth_fallback.go . AuthFallbackService -//go:generate counterfeiter -o mockdb/denied.go . DeniedListService +//go:generate counterfeiter -o mockdb/denied.go . DeniedKeysService //go:generate counterfeiter -o mockdb/fixed_pages.go . PinnedNoticesService diff --git a/roomdb/mockdb/denied.go b/roomdb/mockdb/denied.go index db73b5d..b50a9f5 100644 --- a/roomdb/mockdb/denied.go +++ b/roomdb/mockdb/denied.go @@ -9,12 +9,13 @@ import ( refs "go.mindeco.de/ssb-refs" ) -type FakeDeniedListService struct { - AddStub func(context.Context, refs.FeedRef) error +type FakeDeniedKeysService struct { + AddStub func(context.Context, refs.FeedRef, string) error addMutex sync.RWMutex addArgsForCall []struct { arg1 context.Context arg2 refs.FeedRef + arg3 string } addReturns struct { result1 error @@ -101,19 +102,20 @@ type FakeDeniedListService struct { invocationsMutex sync.RWMutex } -func (fake *FakeDeniedListService) Add(arg1 context.Context, arg2 refs.FeedRef) error { +func (fake *FakeDeniedKeysService) Add(arg1 context.Context, arg2 refs.FeedRef, arg3 string) error { fake.addMutex.Lock() ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)] fake.addArgsForCall = append(fake.addArgsForCall, struct { arg1 context.Context arg2 refs.FeedRef - }{arg1, arg2}) + arg3 string + }{arg1, arg2, arg3}) stub := fake.AddStub fakeReturns := fake.addReturns - fake.recordInvocation("Add", []interface{}{arg1, arg2}) + fake.recordInvocation("Add", []interface{}{arg1, arg2, arg3}) fake.addMutex.Unlock() if stub != nil { - return stub(arg1, arg2) + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 @@ -121,26 +123,26 @@ func (fake *FakeDeniedListService) Add(arg1 context.Context, arg2 refs.FeedRef) return fakeReturns.result1 } -func (fake *FakeDeniedListService) AddCallCount() int { +func (fake *FakeDeniedKeysService) AddCallCount() int { fake.addMutex.RLock() defer fake.addMutex.RUnlock() return len(fake.addArgsForCall) } -func (fake *FakeDeniedListService) AddCalls(stub func(context.Context, refs.FeedRef) error) { +func (fake *FakeDeniedKeysService) AddCalls(stub func(context.Context, refs.FeedRef, string) error) { fake.addMutex.Lock() defer fake.addMutex.Unlock() fake.AddStub = stub } -func (fake *FakeDeniedListService) AddArgsForCall(i int) (context.Context, refs.FeedRef) { +func (fake *FakeDeniedKeysService) AddArgsForCall(i int) (context.Context, refs.FeedRef, string) { fake.addMutex.RLock() defer fake.addMutex.RUnlock() argsForCall := fake.addArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 } -func (fake *FakeDeniedListService) AddReturns(result1 error) { +func (fake *FakeDeniedKeysService) AddReturns(result1 error) { fake.addMutex.Lock() defer fake.addMutex.Unlock() fake.AddStub = nil @@ -149,7 +151,7 @@ func (fake *FakeDeniedListService) AddReturns(result1 error) { }{result1} } -func (fake *FakeDeniedListService) AddReturnsOnCall(i int, result1 error) { +func (fake *FakeDeniedKeysService) AddReturnsOnCall(i int, result1 error) { fake.addMutex.Lock() defer fake.addMutex.Unlock() fake.AddStub = nil @@ -163,7 +165,7 @@ func (fake *FakeDeniedListService) AddReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeDeniedListService) GetByID(arg1 context.Context, arg2 int64) (roomdb.ListEntry, error) { +func (fake *FakeDeniedKeysService) GetByID(arg1 context.Context, arg2 int64) (roomdb.ListEntry, error) { fake.getByIDMutex.Lock() ret, specificReturn := fake.getByIDReturnsOnCall[len(fake.getByIDArgsForCall)] fake.getByIDArgsForCall = append(fake.getByIDArgsForCall, struct { @@ -183,26 +185,26 @@ func (fake *FakeDeniedListService) GetByID(arg1 context.Context, arg2 int64) (ro return fakeReturns.result1, fakeReturns.result2 } -func (fake *FakeDeniedListService) GetByIDCallCount() int { +func (fake *FakeDeniedKeysService) GetByIDCallCount() int { fake.getByIDMutex.RLock() defer fake.getByIDMutex.RUnlock() return len(fake.getByIDArgsForCall) } -func (fake *FakeDeniedListService) GetByIDCalls(stub func(context.Context, int64) (roomdb.ListEntry, error)) { +func (fake *FakeDeniedKeysService) GetByIDCalls(stub func(context.Context, int64) (roomdb.ListEntry, error)) { fake.getByIDMutex.Lock() defer fake.getByIDMutex.Unlock() fake.GetByIDStub = stub } -func (fake *FakeDeniedListService) GetByIDArgsForCall(i int) (context.Context, int64) { +func (fake *FakeDeniedKeysService) GetByIDArgsForCall(i int) (context.Context, int64) { fake.getByIDMutex.RLock() defer fake.getByIDMutex.RUnlock() argsForCall := fake.getByIDArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeDeniedListService) GetByIDReturns(result1 roomdb.ListEntry, result2 error) { +func (fake *FakeDeniedKeysService) GetByIDReturns(result1 roomdb.ListEntry, result2 error) { fake.getByIDMutex.Lock() defer fake.getByIDMutex.Unlock() fake.GetByIDStub = nil @@ -212,7 +214,7 @@ func (fake *FakeDeniedListService) GetByIDReturns(result1 roomdb.ListEntry, resu }{result1, result2} } -func (fake *FakeDeniedListService) GetByIDReturnsOnCall(i int, result1 roomdb.ListEntry, result2 error) { +func (fake *FakeDeniedKeysService) GetByIDReturnsOnCall(i int, result1 roomdb.ListEntry, result2 error) { fake.getByIDMutex.Lock() defer fake.getByIDMutex.Unlock() fake.GetByIDStub = nil @@ -228,7 +230,7 @@ func (fake *FakeDeniedListService) GetByIDReturnsOnCall(i int, result1 roomdb.Li }{result1, result2} } -func (fake *FakeDeniedListService) HasFeed(arg1 context.Context, arg2 refs.FeedRef) bool { +func (fake *FakeDeniedKeysService) HasFeed(arg1 context.Context, arg2 refs.FeedRef) bool { fake.hasFeedMutex.Lock() ret, specificReturn := fake.hasFeedReturnsOnCall[len(fake.hasFeedArgsForCall)] fake.hasFeedArgsForCall = append(fake.hasFeedArgsForCall, struct { @@ -248,26 +250,26 @@ func (fake *FakeDeniedListService) HasFeed(arg1 context.Context, arg2 refs.FeedR return fakeReturns.result1 } -func (fake *FakeDeniedListService) HasFeedCallCount() int { +func (fake *FakeDeniedKeysService) HasFeedCallCount() int { fake.hasFeedMutex.RLock() defer fake.hasFeedMutex.RUnlock() return len(fake.hasFeedArgsForCall) } -func (fake *FakeDeniedListService) HasFeedCalls(stub func(context.Context, refs.FeedRef) bool) { +func (fake *FakeDeniedKeysService) HasFeedCalls(stub func(context.Context, refs.FeedRef) bool) { fake.hasFeedMutex.Lock() defer fake.hasFeedMutex.Unlock() fake.HasFeedStub = stub } -func (fake *FakeDeniedListService) HasFeedArgsForCall(i int) (context.Context, refs.FeedRef) { +func (fake *FakeDeniedKeysService) HasFeedArgsForCall(i int) (context.Context, refs.FeedRef) { fake.hasFeedMutex.RLock() defer fake.hasFeedMutex.RUnlock() argsForCall := fake.hasFeedArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeDeniedListService) HasFeedReturns(result1 bool) { +func (fake *FakeDeniedKeysService) HasFeedReturns(result1 bool) { fake.hasFeedMutex.Lock() defer fake.hasFeedMutex.Unlock() fake.HasFeedStub = nil @@ -276,7 +278,7 @@ func (fake *FakeDeniedListService) HasFeedReturns(result1 bool) { }{result1} } -func (fake *FakeDeniedListService) HasFeedReturnsOnCall(i int, result1 bool) { +func (fake *FakeDeniedKeysService) HasFeedReturnsOnCall(i int, result1 bool) { fake.hasFeedMutex.Lock() defer fake.hasFeedMutex.Unlock() fake.HasFeedStub = nil @@ -290,7 +292,7 @@ func (fake *FakeDeniedListService) HasFeedReturnsOnCall(i int, result1 bool) { }{result1} } -func (fake *FakeDeniedListService) HasID(arg1 context.Context, arg2 int64) bool { +func (fake *FakeDeniedKeysService) HasID(arg1 context.Context, arg2 int64) bool { fake.hasIDMutex.Lock() ret, specificReturn := fake.hasIDReturnsOnCall[len(fake.hasIDArgsForCall)] fake.hasIDArgsForCall = append(fake.hasIDArgsForCall, struct { @@ -310,26 +312,26 @@ func (fake *FakeDeniedListService) HasID(arg1 context.Context, arg2 int64) bool return fakeReturns.result1 } -func (fake *FakeDeniedListService) HasIDCallCount() int { +func (fake *FakeDeniedKeysService) HasIDCallCount() int { fake.hasIDMutex.RLock() defer fake.hasIDMutex.RUnlock() return len(fake.hasIDArgsForCall) } -func (fake *FakeDeniedListService) HasIDCalls(stub func(context.Context, int64) bool) { +func (fake *FakeDeniedKeysService) HasIDCalls(stub func(context.Context, int64) bool) { fake.hasIDMutex.Lock() defer fake.hasIDMutex.Unlock() fake.HasIDStub = stub } -func (fake *FakeDeniedListService) HasIDArgsForCall(i int) (context.Context, int64) { +func (fake *FakeDeniedKeysService) HasIDArgsForCall(i int) (context.Context, int64) { fake.hasIDMutex.RLock() defer fake.hasIDMutex.RUnlock() argsForCall := fake.hasIDArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeDeniedListService) HasIDReturns(result1 bool) { +func (fake *FakeDeniedKeysService) HasIDReturns(result1 bool) { fake.hasIDMutex.Lock() defer fake.hasIDMutex.Unlock() fake.HasIDStub = nil @@ -338,7 +340,7 @@ func (fake *FakeDeniedListService) HasIDReturns(result1 bool) { }{result1} } -func (fake *FakeDeniedListService) HasIDReturnsOnCall(i int, result1 bool) { +func (fake *FakeDeniedKeysService) HasIDReturnsOnCall(i int, result1 bool) { fake.hasIDMutex.Lock() defer fake.hasIDMutex.Unlock() fake.HasIDStub = nil @@ -352,7 +354,7 @@ func (fake *FakeDeniedListService) HasIDReturnsOnCall(i int, result1 bool) { }{result1} } -func (fake *FakeDeniedListService) List(arg1 context.Context) ([]roomdb.ListEntry, error) { +func (fake *FakeDeniedKeysService) List(arg1 context.Context) ([]roomdb.ListEntry, error) { fake.listMutex.Lock() ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] fake.listArgsForCall = append(fake.listArgsForCall, struct { @@ -371,26 +373,26 @@ func (fake *FakeDeniedListService) List(arg1 context.Context) ([]roomdb.ListEntr return fakeReturns.result1, fakeReturns.result2 } -func (fake *FakeDeniedListService) ListCallCount() int { +func (fake *FakeDeniedKeysService) ListCallCount() int { fake.listMutex.RLock() defer fake.listMutex.RUnlock() return len(fake.listArgsForCall) } -func (fake *FakeDeniedListService) ListCalls(stub func(context.Context) ([]roomdb.ListEntry, error)) { +func (fake *FakeDeniedKeysService) ListCalls(stub func(context.Context) ([]roomdb.ListEntry, error)) { fake.listMutex.Lock() defer fake.listMutex.Unlock() fake.ListStub = stub } -func (fake *FakeDeniedListService) ListArgsForCall(i int) context.Context { +func (fake *FakeDeniedKeysService) ListArgsForCall(i int) context.Context { fake.listMutex.RLock() defer fake.listMutex.RUnlock() argsForCall := fake.listArgsForCall[i] return argsForCall.arg1 } -func (fake *FakeDeniedListService) ListReturns(result1 []roomdb.ListEntry, result2 error) { +func (fake *FakeDeniedKeysService) ListReturns(result1 []roomdb.ListEntry, result2 error) { fake.listMutex.Lock() defer fake.listMutex.Unlock() fake.ListStub = nil @@ -400,7 +402,7 @@ func (fake *FakeDeniedListService) ListReturns(result1 []roomdb.ListEntry, resul }{result1, result2} } -func (fake *FakeDeniedListService) ListReturnsOnCall(i int, result1 []roomdb.ListEntry, result2 error) { +func (fake *FakeDeniedKeysService) ListReturnsOnCall(i int, result1 []roomdb.ListEntry, result2 error) { fake.listMutex.Lock() defer fake.listMutex.Unlock() fake.ListStub = nil @@ -416,7 +418,7 @@ func (fake *FakeDeniedListService) ListReturnsOnCall(i int, result1 []roomdb.Lis }{result1, result2} } -func (fake *FakeDeniedListService) RemoveFeed(arg1 context.Context, arg2 refs.FeedRef) error { +func (fake *FakeDeniedKeysService) RemoveFeed(arg1 context.Context, arg2 refs.FeedRef) error { fake.removeFeedMutex.Lock() ret, specificReturn := fake.removeFeedReturnsOnCall[len(fake.removeFeedArgsForCall)] fake.removeFeedArgsForCall = append(fake.removeFeedArgsForCall, struct { @@ -436,26 +438,26 @@ func (fake *FakeDeniedListService) RemoveFeed(arg1 context.Context, arg2 refs.Fe return fakeReturns.result1 } -func (fake *FakeDeniedListService) RemoveFeedCallCount() int { +func (fake *FakeDeniedKeysService) RemoveFeedCallCount() int { fake.removeFeedMutex.RLock() defer fake.removeFeedMutex.RUnlock() return len(fake.removeFeedArgsForCall) } -func (fake *FakeDeniedListService) RemoveFeedCalls(stub func(context.Context, refs.FeedRef) error) { +func (fake *FakeDeniedKeysService) RemoveFeedCalls(stub func(context.Context, refs.FeedRef) error) { fake.removeFeedMutex.Lock() defer fake.removeFeedMutex.Unlock() fake.RemoveFeedStub = stub } -func (fake *FakeDeniedListService) RemoveFeedArgsForCall(i int) (context.Context, refs.FeedRef) { +func (fake *FakeDeniedKeysService) RemoveFeedArgsForCall(i int) (context.Context, refs.FeedRef) { fake.removeFeedMutex.RLock() defer fake.removeFeedMutex.RUnlock() argsForCall := fake.removeFeedArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeDeniedListService) RemoveFeedReturns(result1 error) { +func (fake *FakeDeniedKeysService) RemoveFeedReturns(result1 error) { fake.removeFeedMutex.Lock() defer fake.removeFeedMutex.Unlock() fake.RemoveFeedStub = nil @@ -464,7 +466,7 @@ func (fake *FakeDeniedListService) RemoveFeedReturns(result1 error) { }{result1} } -func (fake *FakeDeniedListService) RemoveFeedReturnsOnCall(i int, result1 error) { +func (fake *FakeDeniedKeysService) RemoveFeedReturnsOnCall(i int, result1 error) { fake.removeFeedMutex.Lock() defer fake.removeFeedMutex.Unlock() fake.RemoveFeedStub = nil @@ -478,7 +480,7 @@ func (fake *FakeDeniedListService) RemoveFeedReturnsOnCall(i int, result1 error) }{result1} } -func (fake *FakeDeniedListService) RemoveID(arg1 context.Context, arg2 int64) error { +func (fake *FakeDeniedKeysService) RemoveID(arg1 context.Context, arg2 int64) error { fake.removeIDMutex.Lock() ret, specificReturn := fake.removeIDReturnsOnCall[len(fake.removeIDArgsForCall)] fake.removeIDArgsForCall = append(fake.removeIDArgsForCall, struct { @@ -498,26 +500,26 @@ func (fake *FakeDeniedListService) RemoveID(arg1 context.Context, arg2 int64) er return fakeReturns.result1 } -func (fake *FakeDeniedListService) RemoveIDCallCount() int { +func (fake *FakeDeniedKeysService) RemoveIDCallCount() int { fake.removeIDMutex.RLock() defer fake.removeIDMutex.RUnlock() return len(fake.removeIDArgsForCall) } -func (fake *FakeDeniedListService) RemoveIDCalls(stub func(context.Context, int64) error) { +func (fake *FakeDeniedKeysService) RemoveIDCalls(stub func(context.Context, int64) error) { fake.removeIDMutex.Lock() defer fake.removeIDMutex.Unlock() fake.RemoveIDStub = stub } -func (fake *FakeDeniedListService) RemoveIDArgsForCall(i int) (context.Context, int64) { +func (fake *FakeDeniedKeysService) RemoveIDArgsForCall(i int) (context.Context, int64) { fake.removeIDMutex.RLock() defer fake.removeIDMutex.RUnlock() argsForCall := fake.removeIDArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeDeniedListService) RemoveIDReturns(result1 error) { +func (fake *FakeDeniedKeysService) RemoveIDReturns(result1 error) { fake.removeIDMutex.Lock() defer fake.removeIDMutex.Unlock() fake.RemoveIDStub = nil @@ -526,7 +528,7 @@ func (fake *FakeDeniedListService) RemoveIDReturns(result1 error) { }{result1} } -func (fake *FakeDeniedListService) RemoveIDReturnsOnCall(i int, result1 error) { +func (fake *FakeDeniedKeysService) RemoveIDReturnsOnCall(i int, result1 error) { fake.removeIDMutex.Lock() defer fake.removeIDMutex.Unlock() fake.RemoveIDStub = nil @@ -540,7 +542,7 @@ func (fake *FakeDeniedListService) RemoveIDReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeDeniedListService) Invocations() map[string][][]interface{} { +func (fake *FakeDeniedKeysService) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() fake.addMutex.RLock() @@ -564,7 +566,7 @@ func (fake *FakeDeniedListService) Invocations() map[string][][]interface{} { return copiedInvocations } -func (fake *FakeDeniedListService) recordInvocation(key string, args []interface{}) { +func (fake *FakeDeniedKeysService) recordInvocation(key string, args []interface{}) { fake.invocationsMutex.Lock() defer fake.invocationsMutex.Unlock() if fake.invocations == nil { @@ -576,4 +578,4 @@ func (fake *FakeDeniedListService) recordInvocation(key string, args []interface fake.invocations[key] = append(fake.invocations[key], args) } -var _ roomdb.DeniedListService = new(FakeDeniedListService) +var _ roomdb.DeniedKeysService = new(FakeDeniedKeysService) diff --git a/roomdb/sqlite/denied.go b/roomdb/sqlite/denied.go index 868f34e..af10582 100644 --- a/roomdb/sqlite/denied.go +++ b/roomdb/sqlite/denied.go @@ -1,7 +1,5 @@ // SPDX-License-Identifier: MIT -// +build ignore - package sqlite import ( @@ -20,32 +18,25 @@ import ( ) // compiler assertion to ensure the struct fullfills the interface -var _ roomdb.DeniedListService = (*DeniedList)(nil) +var _ roomdb.DeniedKeysService = (*DeniedKeys)(nil) -// The DeniedList is backed by the members table -type DeniedList struct { +// The DeniedKeys is backed by the members table +type DeniedKeys struct { db *sql.DB } // Add adds the feed to the list. -func (al DeniedList) Add(ctx context.Context, a refs.FeedRef) error { - // single insert transaction but this makes it easier to re-use in invites.Consume - return transact(al.db, func(tx *sql.Tx) error { - return al.add(ctx, tx, a) - }) -} - -// this add is not exported and for internal use with transactions. -func (al DeniedList) add(ctx context.Context, tx *sql.Tx, a refs.FeedRef) error { +func (dk DeniedKeys) Add(ctx context.Context, a refs.FeedRef, comment string) error { // TODO: better valid if _, err := refs.ParseFeedRef(a.Ref()); err != nil { return err } - var entry models.Member + var entry models.DeniedKey entry.PubKey.FeedRef = a + entry.Comment = comment - err := entry.Insert(ctx, tx, boil.Whitelist("pub_key")) + err := entry.Insert(ctx, dk.db, boil.Whitelist("pub_key", "comment")) if err != nil { var sqlErr sqlite3.Error if errors.As(err, &sqlErr) && sqlErr.ExtendedCode == sqlite3.ErrConstraintUnique { @@ -59,8 +50,8 @@ func (al DeniedList) add(ctx context.Context, tx *sql.Tx, a refs.FeedRef) error } // HasFeed returns true if a feed is on the list. -func (al DeniedList) HasFeed(ctx context.Context, h refs.FeedRef) bool { - _, err := models.DeniedLists(qm.Where("pub_key = ?", h.Ref())).One(ctx, al.db) +func (dk DeniedKeys) HasFeed(ctx context.Context, h refs.FeedRef) bool { + _, err := models.DeniedKeys(qm.Where("pub_key = ?", h.Ref())).One(ctx, dk.db) if err != nil { return false } @@ -68,8 +59,8 @@ func (al DeniedList) HasFeed(ctx context.Context, h refs.FeedRef) bool { } // HasID returns true if a feed is on the list. -func (al DeniedList) HasID(ctx context.Context, id int64) bool { - _, err := models.FindDeniedList(ctx, al.db, id) +func (dk DeniedKeys) HasID(ctx context.Context, id int64) bool { + _, err := models.FindDeniedKey(ctx, dk.db, id) if err != nil { return false } @@ -77,43 +68,45 @@ func (al DeniedList) HasID(ctx context.Context, id int64) bool { } // GetByID returns the entry if a feed with that ID is on the list. -func (al DeniedList) GetByID(ctx context.Context, id int64) (roomdb.ListEntry, error) { - var le roomdb.ListEntry - entry, err := models.FindDeniedList(ctx, al.db, id) +func (dk DeniedKeys) GetByID(ctx context.Context, id int64) (roomdb.ListEntry, error) { + var entry roomdb.ListEntry + found, err := models.FindDeniedKey(ctx, dk.db, id) if err != nil { if errors.Is(err, sql.ErrNoRows) { - return le, roomdb.ErrNotFound + return entry, roomdb.ErrNotFound } - return le, err + return entry, err } - le.ID = entry.ID - le.PubKey = entry.PubKey.FeedRef - - return le, nil + entry.ID = found.ID + entry.PubKey = found.PubKey.FeedRef + entry.Comment = found.Comment + entry.CreatedAt = found.CreatedAt + return entry, nil } // List returns a list of all the feeds. -func (al DeniedList) List(ctx context.Context) (roomdb.ListEntries, error) { - all, err := models.DeniedLists().All(ctx, al.db) +func (dk DeniedKeys) List(ctx context.Context) ([]roomdb.ListEntry, error) { + all, err := models.DeniedKeys().All(ctx, dk.db) if err != nil { return nil, err } + n := len(all) - var asRefs = make(roomdb.ListEntries, len(all)) - for i, Denieded := range all { - asRefs[i] = roomdb.ListEntry{ - ID: Denieded.ID, - PubKey: Denieded.PubKey.FeedRef, - } + var lst = make([]roomdb.ListEntry, n) + for i, entry := range all { + lst[i].ID = entry.ID + lst[i].PubKey = entry.PubKey.FeedRef + lst[i].Comment = entry.Comment + lst[i].CreatedAt = entry.CreatedAt } - return asRefs, nil + return lst, nil } // RemoveFeed removes the feed from the list. -func (al DeniedList) RemoveFeed(ctx context.Context, r refs.FeedRef) error { - entry, err := models.DeniedLists(qm.Where("pub_key = ?", r.Ref())).One(ctx, al.db) +func (dk DeniedKeys) RemoveFeed(ctx context.Context, r refs.FeedRef) error { + entry, err := models.DeniedKeys(qm.Where("pub_key = ?", r.Ref())).One(ctx, dk.db) if err != nil { if errors.Is(err, sql.ErrNoRows) { return roomdb.ErrNotFound @@ -121,7 +114,7 @@ func (al DeniedList) RemoveFeed(ctx context.Context, r refs.FeedRef) error { return err } - _, err = entry.Delete(ctx, al.db) + _, err = entry.Delete(ctx, dk.db) if err != nil { return err } @@ -130,8 +123,8 @@ func (al DeniedList) RemoveFeed(ctx context.Context, r refs.FeedRef) error { } // RemoveID removes the feed from the list. -func (al DeniedList) RemoveID(ctx context.Context, id int64) error { - entry, err := models.FindDeniedList(ctx, al.db, id) +func (dk DeniedKeys) RemoveID(ctx context.Context, id int64) error { + entry, err := models.FindDeniedKey(ctx, dk.db, id) if err != nil { if errors.Is(err, sql.ErrNoRows) { return roomdb.ErrNotFound @@ -139,7 +132,7 @@ func (al DeniedList) RemoveID(ctx context.Context, id int64) error { return err } - _, err = entry.Delete(ctx, al.db) + _, err = entry.Delete(ctx, dk.db) if err != nil { return err } diff --git a/roomdb/sqlite/denied_test.go b/roomdb/sqlite/denied_test.go index c5f1098..553817c 100644 --- a/roomdb/sqlite/denied_test.go +++ b/roomdb/sqlite/denied_test.go @@ -1,4 +1,4 @@ -// +build ignore +// SPDX-License-Identifier: MIT package sqlite @@ -8,6 +8,7 @@ import ( "os" "path/filepath" "testing" + "time" "github.com/ssb-ngi-pointer/go-ssb-room/roomdb" @@ -17,7 +18,7 @@ import ( refs "go.mindeco.de/ssb-refs" ) -func TestDeniedList(t *testing.T) { +func TestDeniedKeys(t *testing.T) { r := require.New(t) ctx := context.Background() @@ -30,49 +31,54 @@ func TestDeniedList(t *testing.T) { require.NoError(t, err) tf := refs.FeedRef{ID: bytes.Repeat([]byte("fooo"), 8), Algo: "nope"} - err = db.DeniedList.Add(ctx, tf) + err = db.DeniedKeys.Add(ctx, tf, "wont work anyhow") r.Error(err) // looks ok at least - okFeed := refs.FeedRef{ID: bytes.Repeat([]byte("acab"), 8), Algo: refs.RefAlgoFeedSSB1} - err = db.DeniedList.Add(ctx, okFeed) + created := time.Now() + time.Sleep(time.Second / 2) + okFeed := refs.FeedRef{ID: bytes.Repeat([]byte("b44d"), 8), Algo: refs.RefAlgoFeedSSB1} + err = db.DeniedKeys.Add(ctx, okFeed, "be gone") r.NoError(err) // hack into the interface to get the concrete database/sql instance - sqlDB := db.DeniedList.(*DeniedList).db + sqlDB := db.DeniedKeys.db - count, err := models.DeniedLists().Count(ctx, sqlDB) + count, err := models.DeniedKeys().Count(ctx, sqlDB) r.NoError(err) r.EqualValues(count, 1) - lst, err := db.DeniedList.List(ctx) + lst, err := db.DeniedKeys.List(ctx) r.NoError(err) r.Len(lst, 1) + r.Equal(okFeed.Ref(), lst[0].PubKey.Ref()) + r.Equal("be gone", lst[0].Comment) + r.True(lst[0].CreatedAt.After(created)) - yes := db.DeniedList.HasFeed(ctx, okFeed) + yes := db.DeniedKeys.HasFeed(ctx, okFeed) r.True(yes) - yes = db.DeniedList.HasFeed(ctx, tf) + yes = db.DeniedKeys.HasFeed(ctx, tf) r.False(yes) - err = db.DeniedList.RemoveFeed(ctx, okFeed) + err = db.DeniedKeys.RemoveFeed(ctx, okFeed) r.NoError(err) - count, err = models.DeniedLists().Count(ctx, sqlDB) + count, err = models.DeniedKeys().Count(ctx, sqlDB) r.NoError(err) r.EqualValues(count, 0) - lst, err = db.DeniedList.List(ctx) + lst, err = db.DeniedKeys.List(ctx) r.NoError(err) r.Len(lst, 0) - yes = db.DeniedList.HasFeed(ctx, okFeed) + yes = db.DeniedKeys.HasFeed(ctx, okFeed) r.False(yes) r.NoError(db.Close()) } -func TestDeniedListUnique(t *testing.T) { +func TestDeniedKeysUnique(t *testing.T) { r := require.New(t) ctx := context.Background() @@ -84,21 +90,21 @@ func TestDeniedListUnique(t *testing.T) { db, err := Open(tr) require.NoError(t, err) - feedA := refs.FeedRef{ID: bytes.Repeat([]byte("1312"), 8), Algo: refs.RefAlgoFeedSSB1} - err = db.DeniedList.Add(ctx, feedA) + feedA := refs.FeedRef{ID: bytes.Repeat([]byte("b33f"), 8), Algo: refs.RefAlgoFeedSSB1} + err = db.DeniedKeys.Add(ctx, feedA, "test comment") r.NoError(err) - err = db.DeniedList.Add(ctx, feedA) + err = db.DeniedKeys.Add(ctx, feedA, "test comment") r.Error(err) - lst, err := db.DeniedList.List(ctx) + lst, err := db.DeniedKeys.List(ctx) r.NoError(err) r.Len(lst, 1) r.NoError(db.Close()) } -func TestDeniedListByID(t *testing.T) { +func TestDeniedKeysByID(t *testing.T) { r := require.New(t) ctx := context.Background() @@ -110,27 +116,27 @@ func TestDeniedListByID(t *testing.T) { db, err := Open(tr) require.NoError(t, err) - feedA := refs.FeedRef{ID: bytes.Repeat([]byte("1312"), 8), Algo: refs.RefAlgoFeedSSB1} - err = db.DeniedList.Add(ctx, feedA) + feedA := refs.FeedRef{ID: bytes.Repeat([]byte("b33f"), 8), Algo: refs.RefAlgoFeedSSB1} + err = db.DeniedKeys.Add(ctx, feedA, "nope") r.NoError(err) - lst, err := db.DeniedList.List(ctx) + lst, err := db.DeniedKeys.List(ctx) r.NoError(err) r.Len(lst, 1) - yes := db.DeniedList.HasID(ctx, lst[0].ID) + yes := db.DeniedKeys.HasID(ctx, lst[0].ID) r.True(yes) - yes = db.DeniedList.HasID(ctx, 666) + yes = db.DeniedKeys.HasID(ctx, 666) r.False(yes) - err = db.DeniedList.RemoveID(ctx, 666) + err = db.DeniedKeys.RemoveID(ctx, 666) r.Error(err) r.EqualError(err, roomdb.ErrNotFound.Error()) - err = db.DeniedList.RemoveID(ctx, lst[0].ID) + err = db.DeniedKeys.RemoveID(ctx, lst[0].ID) r.NoError(err) - yes = db.DeniedList.HasID(ctx, lst[0].ID) + yes = db.DeniedKeys.HasID(ctx, lst[0].ID) r.False(yes) } diff --git a/roomdb/sqlite/new.go b/roomdb/sqlite/new.go index 50ad0fd..015763e 100644 --- a/roomdb/sqlite/new.go +++ b/roomdb/sqlite/new.go @@ -37,12 +37,12 @@ type Database struct { Members Members Aliases Aliases + Invites Invites + + DeniedKeys DeniedKeys PinnedNotices PinnedNotices Notices Notices - - Invites Invites - // DeniedList Denied } // Open looks for a database file 'fname' @@ -99,18 +99,14 @@ func Open(r repo.Interface) (*Database, error) { admindb := &Database{ db: db, - // DeniedList: DeniedList{db}, + Aliases: Aliases{db}, AuthFallback: AuthFallback{db}, - PinnedNotices: PinnedNotices{db}, + DeniedKeys: DeniedKeys{db}, + Invites: Invites{db: db, members: ml}, Notices: Notices{db}, - - Members: ml, - - Invites: Invites{ - db: db, - members: ml, - }, + Members: ml, + PinnedNotices: PinnedNotices{db}, } return admindb, nil diff --git a/roomdb/types.go b/roomdb/types.go index 4eb8797..3b1303a 100644 --- a/roomdb/types.go +++ b/roomdb/types.go @@ -81,6 +81,9 @@ type Invite struct { type ListEntry struct { ID int64 PubKey refs.FeedRef + + CreatedAt time.Time + Comment string } // DBFeedRef wraps a feed reference and implements the SQL marshaling interfaces. diff --git a/web/handlers/http.go b/web/handlers/http.go index e79de4f..bd86fab 100644 --- a/web/handlers/http.go +++ b/web/handlers/http.go @@ -46,6 +46,7 @@ var HTMLTemplates = []string{ type Databases struct { Aliases roomdb.AliasesService AuthFallback roomdb.AuthFallbackService + DeniedList roomdb.DeniedListService Invites roomdb.InvitesService Notices roomdb.NoticesService Members roomdb.MembersService