add some logging, fix some bugs

internal/db/pg/pg.go

@@ -963,7 +963,7 @@ func (ps *postgresService) PullRelevantAccountsFromStatus(targetStatus *gtsmodel
 	if targetStatus.InReplyToAccountID != "" {
 		repliedToAccount := &gtsmodel.Account{}
 		if err := ps.conn.Model(repliedToAccount).Where("id = ?", targetStatus.InReplyToAccountID).Select(); err != nil {
-			return accounts, err
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting repliedToAcount with id %s: %s", targetStatus.InReplyToAccountID, err)
 		}
 		accounts.ReplyToAccount = repliedToAccount
 	}
@@ -973,11 +973,11 @@ func (ps *postgresService) PullRelevantAccountsFromStatus(targetStatus *gtsmodel
 		// retrieve the boosted status first
 		boostedStatus := &gtsmodel.Status{}
 		if err := ps.conn.Model(boostedStatus).Where("id = ?", targetStatus.BoostOfID).Select(); err != nil {
-			return accounts, err
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedStatus with id %s: %s", targetStatus.BoostOfID, err)
 		}
 		boostedAccount := &gtsmodel.Account{}
 		if err := ps.conn.Model(boostedAccount).Where("id = ?", boostedStatus.AccountID).Select(); err != nil {
-			return accounts, err
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedAccount with id %s: %s", boostedStatus.AccountID, err)
 		}
 		accounts.BoostedAccount = boostedAccount
 
@@ -985,7 +985,7 @@ func (ps *postgresService) PullRelevantAccountsFromStatus(targetStatus *gtsmodel
 		if boostedStatus.InReplyToAccountID != "" {
 			boostedStatusRepliedToAccount := &gtsmodel.Account{}
 			if err := ps.conn.Model(boostedStatusRepliedToAccount).Where("id = ?", boostedStatus.InReplyToAccountID).Select(); err != nil {
-				return accounts, err
+				return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedStatusRepliedToAccount with id %s: %s", boostedStatus.InReplyToAccountID, err)
 			}
 			accounts.BoostedReplyToAccount = boostedStatusRepliedToAccount
 		}
@@ -996,12 +996,12 @@ func (ps *postgresService) PullRelevantAccountsFromStatus(targetStatus *gtsmodel
 
 		mention := &gtsmodel.Mention{}
 		if err := ps.conn.Model(mention).Where("id = ?", mentionID).Select(); err != nil {
-			return accounts, fmt.Errorf("error getting mention with id %s: %s", mentionID, err)
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting mention with id %s: %s", mentionID, err)
 		}
 
 		mentionedAccount := &gtsmodel.Account{}
 		if err := ps.conn.Model(mentionedAccount).Where("id = ?", mention.TargetAccountID).Select(); err != nil {
-			return accounts, fmt.Errorf("error getting mentioned account: %s", err)
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting mentioned account: %s", err)
 		}
 		accounts.MentionedAccounts = append(accounts.MentionedAccounts, mentionedAccount)
 	}

internal/gtsmodel/account.go

@@ -76,13 +76,13 @@ type Account struct {
 	*/
 
 	// Does this account need an approval for new followers?
-	Locked bool
+	Locked bool `pg:",default:false"`
 	// Should this account be shown in the instance's profile directory?
-	Discoverable bool
+	Discoverable bool `pg:",default:false"`
 	// Default post privacy for this account
-	Privacy Visibility
+	Privacy Visibility `pg:",default:'public'"`
 	// Set posts from this account to sensitive by default?
-	Sensitive bool
+	Sensitive bool `pg:",default:false"`
 	// What language does this account post in?
 	Language string `pg:",default:'en'"`
 

internal/message/accountprocess.go

@@ -454,13 +454,9 @@ func (p *processor) AccountFollowCreate(authed *oauth.Auth, form *apimodel.Accou
 	p.fromClientAPI <- gtsmodel.FromClientAPI{
 		APObjectType:   gtsmodel.ActivityStreamsFollow,
 		APActivityType: gtsmodel.ActivityStreamsCreate,
-		GTSModel: &gtsmodel.Follow{
-			AccountID:       authed.Account.ID,
-			TargetAccountID: form.TargetAccountID,
-			URI:             fr.URI,
-		},
-		OriginAccount: authed.Account,
-		TargetAccount: targetAcct,
+		GTSModel:       fr,
+		OriginAccount:  authed.Account,
+		TargetAccount:  targetAcct,
 	}
 
 	// return whatever relationship results from this

internal/message/fromfederatorprocess.go

@@ -87,7 +87,7 @@ func (p *processor) processFromFederator(federatorMsg gtsmodel.FromFederator) er
 			// CREATE A FOLLOW REQUEST
 			incomingFollowRequest, ok := federatorMsg.GTSModel.(*gtsmodel.FollowRequest)
 			if !ok {
-				return errors.New("like was not parseable as *gtsmodel.FollowRequest")
+				return errors.New("incomingFollowRequest was not parseable as *gtsmodel.FollowRequest")
 			}
 
 			if err := p.notifyFollowRequest(incomingFollowRequest, federatorMsg.ReceivingAccount); err != nil {

internal/message/timelineprocess.go

@@ -18,17 +18,17 @@ func (p *processor) HomeTimelineGet(authed *oauth.Auth, maxID string, sinceID st
 	for _, s := range statuses {
 		targetAccount := &gtsmodel.Account{}
 		if err := p.db.GetByID(s.AccountID, targetAccount); err != nil {
-			return nil, NewErrorInternalError(fmt.Errorf("error getting status author: %s", err))
+			return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error getting status author: %s", err))
 		}
 
 		relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(s)
 		if err != nil {
-			return nil, NewErrorInternalError(fmt.Errorf("error getting relevant statuses: %s", err))
+			return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error getting relevant statuses for status with id %s and uri %s: %s", s.ID, s.URI, err))
 		}
 
 		visible, err := p.db.StatusVisible(s, targetAccount, authed.Account, relevantAccounts)
 		if err != nil {
-			return nil, NewErrorInternalError(fmt.Errorf("error checking status visibility: %s", err))
+			return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error checking status visibility: %s", err))
 		}
 		if !visible {
 			continue
@@ -38,16 +38,16 @@ func (p *processor) HomeTimelineGet(authed *oauth.Auth, maxID string, sinceID st
 		if s.BoostOfID != "" {
 			bs := &gtsmodel.Status{}
 			if err := p.db.GetByID(s.BoostOfID, bs); err != nil {
-				return nil, NewErrorInternalError(fmt.Errorf("error getting boosted status: %s", err))
+				return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error getting boosted status: %s", err))
 			}
 			boostedRelevantAccounts, err := p.db.PullRelevantAccountsFromStatus(bs)
 			if err != nil {
-				return nil, NewErrorInternalError(fmt.Errorf("error getting relevant accounts from boosted status: %s", err))
+				return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error getting relevant accounts from boosted status: %s", err))
 			}
 
 			boostedVisible, err := p.db.StatusVisible(bs, relevantAccounts.BoostedAccount, authed.Account, boostedRelevantAccounts)
 			if err != nil {
-				return nil, NewErrorInternalError(fmt.Errorf("error checking boosted status visibility: %s", err))
+				return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error checking boosted status visibility: %s", err))
 			}
 
 			if boostedVisible {
@@ -57,7 +57,7 @@ func (p *processor) HomeTimelineGet(authed *oauth.Auth, maxID string, sinceID st
 
 		apiStatus, err := p.tc.StatusToMasto(s, targetAccount, authed.Account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostedStatus)
 		if err != nil {
-			return nil, NewErrorInternalError(fmt.Errorf("error converting status to masto: %s", err))
+			return nil, NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error converting status to masto: %s", err))
 		}
 
 		apiStatuses = append(apiStatuses, *apiStatus)