[chore] Refactor account deleting/block logic, tidy up some other processing things (#1599)

* start refactoring account deletion

* update to use state.DB

* further messing about

* some more tidying up

* more tidying, cleaning, nice-making

* further adventures in refactoring and the woes of technical debt

* update fr accept/reject

* poking + prodding

* fix up deleting

* create fave uri

* don't log using requestingAccount.ID because it might be nil

* move getBookmarks function

* use exists query to check for status bookmark

* use deletenotifications func

* fiddle

* delete follow request notif

* split up some db functions

* Fix possible nil pointer panic

* fix more possible nil pointers

* fix license headers

* warn when follow missing (target) account

* return wrapped err when bookmark/fave models can't be retrieved

* simplify self account delete

* warn log likely race condition

* de-sillify status delete loop

* move error check due north

* warn when unfollowSideEffects has no target account

* warn when no boost account is found

* warn + dump follow when no account

* more warnings

* warn on fave account not set

* move for loop inside anonymous function

* fix funky logic

* don't remove mutual account items on block;
do make sure unfollow occurs in both directions!

1 files changed, 46 insertions, 66 deletions

diff --git a/internal/processing/account/relationships.go b/internal/processing/account/relationships.go
index 54a0b82ab..4afe36afe 100644
--- a/internal/processing/account/relationships.go
+++ b/internal/processing/account/relationships.go
@@ -26,98 +26,51 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/db"
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+	"github.com/superseriousbusiness/gotosocial/internal/log"
 )
 
 // FollowersGet fetches a list of the target account's followers.
 func (p *Processor) FollowersGet(ctx context.Context, requestingAccount *gtsmodel.Account, targetAccountID string) ([]apimodel.Account, gtserror.WithCode) {
 	if blocked, err := p.state.DB.IsBlocked(ctx, requestingAccount.ID, targetAccountID, true); err != nil {
+		err = fmt.Errorf("FollowersGet: db error checking block: %w", err)
 		return nil, gtserror.NewErrorInternalError(err)
 	} else if blocked {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("block exists between accounts"))
+		err = errors.New("FollowersGet: block exists between accounts")
+		return nil, gtserror.NewErrorNotFound(err)
 	}
 
-	accounts := []apimodel.Account{}
-	follows, err := p.state.DB.GetAccountFollowedBy(ctx, targetAccountID, false)
+	follows, err := p.state.DB.GetFollows(ctx, "", targetAccountID)
 	if err != nil {
-		if err == db.ErrNoEntries {
-			return accounts, nil
-		}
-		return nil, gtserror.NewErrorInternalError(err)
-	}
-
-	for _, f := range follows {
-		blocked, err := p.state.DB.IsBlocked(ctx, requestingAccount.ID, f.AccountID, true)
-		if err != nil {
-			return nil, gtserror.NewErrorInternalError(err)
-		}
-		if blocked {
-			continue
-		}
-
-		if f.Account == nil {
-			a, err := p.state.DB.GetAccountByID(ctx, f.AccountID)
-			if err != nil {
-				if err == db.ErrNoEntries {
-					continue
-				}
-				return nil, gtserror.NewErrorInternalError(err)
-			}
-			f.Account = a
-		}
-
-		account, err := p.tc.AccountToAPIAccountPublic(ctx, f.Account)
-		if err != nil {
+		if !errors.Is(err, db.ErrNoEntries) {
+			err = fmt.Errorf("FollowersGet: db error getting followers: %w", err)
 			return nil, gtserror.NewErrorInternalError(err)
 		}
-		accounts = append(accounts, *account)
+		return []apimodel.Account{}, nil
 	}
-	return accounts, nil
+
+	return p.accountsFromFollows(ctx, follows, requestingAccount.ID)
 }
 
 // FollowingGet fetches a list of the accounts that target account is following.
 func (p *Processor) FollowingGet(ctx context.Context, requestingAccount *gtsmodel.Account, targetAccountID string) ([]apimodel.Account, gtserror.WithCode) {
 	if blocked, err := p.state.DB.IsBlocked(ctx, requestingAccount.ID, targetAccountID, true); err != nil {
+		err = fmt.Errorf("FollowingGet: db error checking block: %w", err)
 		return nil, gtserror.NewErrorInternalError(err)
 	} else if blocked {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("block exists between accounts"))
+		err = errors.New("FollowingGet: block exists between accounts")
+		return nil, gtserror.NewErrorNotFound(err)
 	}
 
-	accounts := []apimodel.Account{}
-	follows, err := p.state.DB.GetAccountFollows(ctx, targetAccountID)
+	follows, err := p.state.DB.GetFollows(ctx, targetAccountID, "")
 	if err != nil {
-		if err == db.ErrNoEntries {
-			return accounts, nil
-		}
-		return nil, gtserror.NewErrorInternalError(err)
-	}
-
-	for _, f := range follows {
-		blocked, err := p.state.DB.IsBlocked(ctx, requestingAccount.ID, f.AccountID, true)
-		if err != nil {
-			return nil, gtserror.NewErrorInternalError(err)
-		}
-		if blocked {
-			continue
-		}
-
-		if f.TargetAccount == nil {
-			a, err := p.state.DB.GetAccountByID(ctx, f.TargetAccountID)
-			if err != nil {
-				if err == db.ErrNoEntries {
-					continue
-				}
-				return nil, gtserror.NewErrorInternalError(err)
-			}
-			f.TargetAccount = a
-		}
-
-		account, err := p.tc.AccountToAPIAccountPublic(ctx, f.TargetAccount)
-		if err != nil {
+		if !errors.Is(err, db.ErrNoEntries) {
+			err = fmt.Errorf("FollowingGet: db error getting followers: %w", err)
 			return nil, gtserror.NewErrorInternalError(err)
 		}
-		accounts = append(accounts, *account)
+		return []apimodel.Account{}, nil
 	}
-	return accounts, nil
+
+	return p.accountsFromFollows(ctx, follows, requestingAccount.ID)
 }
 
 // RelationshipGet returns a relationship model describing the relationship of the targetAccount to the Authed account.
@@ -138,3 +91,30 @@ func (p *Processor) RelationshipGet(ctx context.Context, requestingAccount *gtsm
 
 	return r, nil
 }
+
+func (p *Processor) accountsFromFollows(ctx context.Context, follows []*gtsmodel.Follow, requestingAccountID string) ([]apimodel.Account, gtserror.WithCode) {
+	accounts := make([]apimodel.Account, 0, len(follows))
+	for _, follow := range follows {
+		if follow.Account == nil {
+			// No account set for some reason; just skip.
+			log.WithContext(ctx).WithField("follow", follow).Warn("follow had no associated account")
+			continue
+		}
+
+		if blocked, err := p.state.DB.IsBlocked(ctx, requestingAccountID, follow.AccountID, true); err != nil {
+			err = fmt.Errorf("accountsFromFollows: db error checking block: %w", err)
+			return nil, gtserror.NewErrorInternalError(err)
+		} else if blocked {
+			continue
+		}
+
+		account, err := p.tc.AccountToAPIAccountPublic(ctx, follow.Account)
+		if err != nil {
+			err = fmt.Errorf("accountsFromFollows: error converting account to api account: %w", err)
+			return nil, gtserror.NewErrorInternalError(err)
+		}
+		accounts = append(accounts, *account)
+	}
+
+	return accounts, nil
+}