From 3e19f480e63085d48ea4242f46b57105edaa640f Mon Sep 17 00:00:00 2001 From: tobi <31960611+tsmethurst@users.noreply.github.com> Date: Sat, 24 Jun 2023 09:32:10 +0200 Subject: [PATCH] [bugfix] Ensure `InReplyToID` set properly, update dereference ancestors func (#1921) --- .../federation/dereferencing/dereferencer.go | 6 + internal/federation/dereferencing/status.go | 19 +- internal/federation/dereferencing/thread.go | 208 +++++++++++++----- internal/processing/fromfederator.go | 120 +++++++--- internal/typeutils/astointernal.go | 171 ++++++++------ 5 files changed, 362 insertions(+), 162 deletions(-) diff --git a/internal/federation/dereferencing/dereferencer.go b/internal/federation/dereferencing/dereferencer.go index 2902ebcbc..170fb6119 100644 --- a/internal/federation/dereferencing/dereferencer.go +++ b/internal/federation/dereferencing/dereferencer.go @@ -66,6 +66,12 @@ type Dereferencer interface { // This is a more optimized form of manually enqueueing .UpdateStatus() to the federation worker, since it only enqueues update if necessary. RefreshStatusAsync(ctx context.Context, requestUser string, status *gtsmodel.Status, apubStatus ap.Statusable, force bool) + // DereferenceStatusAncestors iterates upwards from the given status, using InReplyToURI, to ensure that as many parent statuses as possible are dereferenced. + DereferenceStatusAncestors(ctx context.Context, requestUser string, status *gtsmodel.Status) error + + // DereferenceStatusDescendents iterates downwards from the given status, using its replies, to ensure that as many children statuses as possible are dereferenced. + DereferenceStatusDescendants(ctx context.Context, requestUser string, statusIRI *url.URL, parent ap.Statusable) error + GetRemoteInstance(ctx context.Context, username string, remoteInstanceURI *url.URL) (*gtsmodel.Instance, error) DereferenceAnnounce(ctx context.Context, announce *gtsmodel.Status, requestingUsername string) error diff --git a/internal/federation/dereferencing/status.go b/internal/federation/dereferencing/status.go index 75adfdd6f..4525f64a9 100644 --- a/internal/federation/dereferencing/status.go +++ b/internal/federation/dereferencing/status.go @@ -104,7 +104,7 @@ func (d *deref) getStatusByURI(ctx context.Context, requestUser string, uri *url } if status == nil { - // Ensure that this is isn't a search for a local status. + // Ensure that this isn't a search for a local status. if uri.Host == config.GetHost() || uri.Host == config.GetAccountDomain() { return nil, nil, gtserror.SetUnretrievable(err) // this will be db.ErrNoEntries } @@ -149,7 +149,7 @@ func (d *deref) getStatusByURI(ctx context.Context, requestUser string, uri *url // RefreshStatus: implements Dereferencer{}.RefreshStatus(). func (d *deref) RefreshStatus(ctx context.Context, requestUser string, status *gtsmodel.Status, apubStatus ap.Statusable, force bool) (*gtsmodel.Status, ap.Statusable, error) { // Check whether needs update. - if statusUpToDate(status) { + if !force && statusUpToDate(status) { return status, nil, nil } @@ -205,8 +205,16 @@ func (d *deref) RefreshStatusAsync(ctx context.Context, requestUser string, stat }) } -// enrichStatus will enrich the given status, whether a new barebones model, or existing model from the database. It handles necessary dereferencing etc. -func (d *deref) enrichStatus(ctx context.Context, requestUser string, uri *url.URL, status *gtsmodel.Status, apubStatus ap.Statusable) (*gtsmodel.Status, ap.Statusable, error) { +// enrichStatus will enrich the given status, whether a new +// barebones model, or existing model from the database. +// It handles necessary dereferencing, database updates, etc. +func (d *deref) enrichStatus( + ctx context.Context, + requestUser string, + uri *url.URL, + status *gtsmodel.Status, + apubStatus ap.Statusable, +) (*gtsmodel.Status, ap.Statusable, error) { // Pre-fetch a transport for requesting username, used by later dereferencing. tsport, err := d.transportController.NewTransportForUsername(ctx, requestUser) if err != nil { @@ -217,7 +225,8 @@ func (d *deref) enrichStatus(ctx context.Context, requestUser string, uri *url.U if blocked, err := d.state.DB.IsDomainBlocked(ctx, uri.Host); err != nil { return nil, nil, gtserror.Newf("error checking blocked domain: %w", err) } else if blocked { - return nil, nil, gtserror.Newf("%s is blocked", uri.Host) + err = gtserror.Newf("%s is blocked", uri.Host) + return nil, nil, gtserror.SetUnretrievable(err) } if apubStatus == nil { diff --git a/internal/federation/dereferencing/thread.go b/internal/federation/dereferencing/thread.go index a12e537bc..a81849e54 100644 --- a/internal/federation/dereferencing/thread.go +++ b/internal/federation/dereferencing/thread.go @@ -19,6 +19,8 @@ package dereferencing import ( "context" + "errors" + "net/http" "net/url" "codeberg.org/gruf/go-kv" @@ -26,96 +28,184 @@ import ( "github.com/superseriousbusiness/activity/streams/vocab" "github.com/superseriousbusiness/gotosocial/internal/ap" "github.com/superseriousbusiness/gotosocial/internal/config" + "github.com/superseriousbusiness/gotosocial/internal/db" + "github.com/superseriousbusiness/gotosocial/internal/gtscontext" "github.com/superseriousbusiness/gotosocial/internal/gtserror" "github.com/superseriousbusiness/gotosocial/internal/gtsmodel" "github.com/superseriousbusiness/gotosocial/internal/log" - "github.com/superseriousbusiness/gotosocial/internal/uris" ) // maxIter defines how many iterations of descendants or // ancesters we are willing to follow before returning error. const maxIter = 1000 -// dereferenceThread will dereference statuses both above and below the given status in a thread, it returns no error and is intended to be called asychronously. func (d *deref) dereferenceThread(ctx context.Context, username string, statusIRI *url.URL, status *gtsmodel.Status, statusable ap.Statusable) { // Ensure that ancestors have been fully dereferenced - if err := d.dereferenceStatusAncestors(ctx, username, status); err != nil { - log.Error(ctx, err) // log entry and error will include caller prefixes + if err := d.DereferenceStatusAncestors(ctx, username, status); err != nil { + log.Error(ctx, err) } // Ensure that descendants have been fully dereferenced - if err := d.dereferenceStatusDescendants(ctx, username, statusIRI, statusable); err != nil { - log.Error(ctx, err) // log entry and error will include caller prefixes + if err := d.DereferenceStatusDescendants(ctx, username, statusIRI, statusable); err != nil { + log.Error(ctx, err) } } -// dereferenceAncestors has the goal of reaching the oldest ancestor of a given status, and stashing all statuses along the way. -func (d *deref) dereferenceStatusAncestors(ctx context.Context, username string, status *gtsmodel.Status) error { - // Take ref to original - ogIRI := status.URI - - // Start log entry with fields - l := log.WithContext(ctx). - WithFields(kv.Fields{ - {"username", username}, - {"statusIRI", ogIRI}, - }...) - - // Log function start - l.Trace("beginning") +func (d *deref) DereferenceStatusAncestors( + ctx context.Context, + username string, + status *gtsmodel.Status, +) error { + // Mark given status as the one + // we're currently working on. + var current = status for i := 0; i < maxIter; i++ { - if status.InReplyToURI == "" { - // status doesn't reply to anything + if current.InReplyToURI == "" { + // Status has no parent, we've + // reached the top of the chain. return nil } - // Parse this status's replied IRI - replyIRI, err := url.Parse(status.InReplyToURI) - if err != nil { - return gtserror.Newf("invalid status InReplyToURI %q: %w", status.InReplyToURI, err) + l := log. + WithContext(ctx). + WithFields(kv.Fields{ + {"username", username}, + {"originalStatusIRI", status.URI}, + {"currentStatusURI", current.URI}, + {"currentInReplyToURI", current.InReplyToURI}, + }...) + + if current.InReplyToID != "" { + // We already have an InReplyToID set. This means + // the status's parent has, at some point, been + // inserted into the database, either because it + // is a status from our instance, or a status from + // remote that we've dereferenced before, or found + // out about in some other way. + // + // Working on this assumption, check if the parent + // status exists, either as a copy pinned on the + // current status, or in the database. + + if current.InReplyTo != nil { + // We have the parent already, and the child + // doesn't need to be updated; keep iterating + // from this parent upwards. + current = current.InReplyTo + continue + } + + // Parent isn't pinned to this status (yet), see + // if we can get it from the db (we should be + // able to, since it has an ID already). + parent, err := d.state.DB.GetStatusByID( + gtscontext.SetBarebones(ctx), + current.InReplyToID, + ) + if err != nil && !errors.Is(err, db.ErrNoEntries) { + // Real db error, stop. + return gtserror.Newf("db error getting status %s: %w", current.InReplyToID, err) + } + + if parent != nil { + // We got the parent from the db, and the child + // doesn't need to be updated; keep iterating + // from this parent upwards. + current.InReplyTo = parent + current = parent + continue + } + + // If we arrive here, we know this child *did* have + // a parent at some point, but it no longer exists in + // the database, presumably because it's been deleted + // by another action. + // + // TODO: clean this up in a nightly task. + l.Warnf("current status has been orphaned (parent %s no longer exists in database)", current.InReplyToID) + return nil // Cannot iterate further. } - if replyIRI.Host == config.GetHost() { - l.Tracef("following local status ancestors: %s", status.InReplyToURI) + // If we reach this point, we know the status has + // an InReplyToURI set, but it doesn't yet have an + // InReplyToID, which means that the parent status + // has not yet been dereferenced. + inReplyToURI, err := url.Parse(current.InReplyToURI) + if err != nil || inReplyToURI == nil { + // Parent URI is not something we can handle. + l.Debug("current status has been orphaned (invalid InReplyToURI)") + return nil //nolint:nilerr + } - // This is our status, extract ID from path - _, id, err := uris.ParseStatusesPath(replyIRI) - if err != nil { - return gtserror.Newf("invalid local status IRI %q: %w", status.InReplyToURI, err) + // Parent URI is valid, try to get it. + // getStatusByURI guards against the following conditions: + // + // - remote domain is blocked (will return unretrievable) + // - domain is local (will try to return something, or + // return unretrievable). + parent, _, err := d.getStatusByURI(ctx, username, inReplyToURI) + if err == nil { + // We successfully fetched the parent. + // Update current status with new info. + current.InReplyToID = parent.ID + current.InReplyToAccountID = parent.AccountID + if err := d.state.DB.UpdateStatus( + ctx, current, + "in_reply_to_id", + "in_reply_to_account_id", + ); err != nil { + return gtserror.Newf("db error updating status %s: %w", current.ID, err) } - // Fetch this status from the database - localStatus, err := d.state.DB.GetStatusByID(ctx, id) - if err != nil { - return gtserror.Newf("error fetching local status %q: %w", id, err) + // Mark parent as next status to + // work on, and keep iterating. + current = parent + continue + } + + // We could not fetch the parent, check if we can do anything + // useful with the error. For example, HTTP status code returned + // from remote may indicate that the parent has been deleted. + switch code := gtserror.StatusCode(err); { + case code == http.StatusGone || code == http.StatusNotFound: + // 410 means the status has definitely been deleted. + // 404 means the status has *probably* been deleted. + // Update this status to reflect that, then bail. + l.Debugf("current status has been orphaned (call to parent returned code %d)", code) + + current.InReplyToURI = "" + if err := d.state.DB.UpdateStatus( + ctx, current, + "in_reply_to_uri", + ); err != nil { + return gtserror.Newf("db error updating status %s: %w", current.ID, err) } + return nil - // Set the fetched status - status = localStatus + case code != 0: + // We had a code, but not one indicating deletion, + // log the code but don't return error or update the + // status; we can try again later. + l.Warnf("cannot dereference parent (%q)", err) + return nil - } else { - l.Tracef("following remote status ancestors: %s", status.InReplyToURI) + case gtserror.Unretrievable(err): + // Not retrievable for some other reason, so just + // bail; we can try again later if necessary. + l.Debugf("parent unretrievable (%q)", err) + return nil - // Fetch the remote status found at this IRI - remoteStatus, _, err := d.getStatusByURI( - ctx, - username, - replyIRI, - ) - if err != nil { - return gtserror.Newf("error fetching remote status %q: %w", status.InReplyToURI, err) - } - - // Set the fetched status - status = remoteStatus + default: + // Some other error that stops us in our tracks. + return gtserror.Newf("error dereferencing parent %s: %w", current.InReplyToURI, err) } } - return gtserror.Newf("reached %d ancestor iterations for %q", maxIter, ogIRI) + return gtserror.Newf("reached %d ancestor iterations for %q", maxIter, status.URI) } -func (d *deref) dereferenceStatusDescendants(ctx context.Context, username string, statusIRI *url.URL, parent ap.Statusable) error { +func (d *deref) DereferenceStatusDescendants(ctx context.Context, username string, statusIRI *url.URL, parent ap.Statusable) error { // Take ref to original ogIRI := statusIRI @@ -256,9 +346,17 @@ stackLoop: } // Dereference the remote status and store in the database. + // getStatusByURI guards against the following conditions: + // + // - remote domain is blocked (will return unretrievable) + // - domain is local (will try to return something, or + // return unretrievable). _, statusable, err := d.getStatusByURI(ctx, username, itemIRI) if err != nil { - l.Errorf("error dereferencing remote status %s: %v", itemIRI, err) + if !gtserror.Unretrievable(err) { + l.Errorf("error dereferencing remote status %s: %v", itemIRI, err) + } + continue itemLoop } diff --git a/internal/processing/fromfederator.go b/internal/processing/fromfederator.go index f165b2835..335b1a102 100644 --- a/internal/processing/fromfederator.go +++ b/internal/processing/fromfederator.go @@ -107,53 +107,32 @@ func (p *Processor) ProcessFromFederator(ctx context.Context, federatorMsg messa return nil } -// processCreateStatusFromFederator handles Activity Create and Object Note +// processCreateStatusFromFederator handles Activity Create and Object Note. func (p *Processor) processCreateStatusFromFederator(ctx context.Context, federatorMsg messages.FromFederator) error { - // check for either an IRI that we still need to dereference, OR an already dereferenced - // and converted status pinned to the message. + // Check the federatorMsg for either an already + // dereferenced and converted status pinned to + // the message, or an AP IRI that we need to deref. var ( status *gtsmodel.Status err error ) if federatorMsg.GTSModel != nil { - var ok bool - - // there's a gts model already pinned to the message, it should be a status - if status, ok = federatorMsg.GTSModel.(*gtsmodel.Status); !ok { - return gtserror.New("Note was not parseable as *gtsmodel.Status") - } - - // Since this was a create originating AP object - // statusable may have been set on message (no problem if not). - statusable, _ := federatorMsg.APObjectModel.(ap.Statusable) - - // Call refresh on status to deref if necessary etc. - status, _, err = p.federator.RefreshStatus(ctx, - federatorMsg.ReceivingAccount.Username, - status, - statusable, - false, - ) - if err != nil { - return err - } + // Model is set, use that. + status, err = p.statusFromGTSModel(ctx, federatorMsg) } else { - // no model pinned, we need to dereference based on the IRI - if federatorMsg.APIri == nil { - return gtserror.New("status was not pinned to federatorMsg, and neither was an IRI for us to dereference") - } + // Model is not set, use IRI. + status, err = p.statusFromAPIRI(ctx, federatorMsg) + } - status, _, err = p.federator.GetStatusByURI(ctx, federatorMsg.ReceivingAccount.Username, federatorMsg.APIri) - if err != nil { - return err - } + if err != nil { + return gtserror.Newf("error extracting status from federatorMsg: %w", err) } if status.Account == nil || status.Account.IsRemote() { // Either no account attached yet, or a remote account. // Both situations we need to parse account URI to fetch it. - remoteAccURI, err := url.Parse(status.AccountURI) + accountURI, err := url.Parse(status.AccountURI) if err != nil { return err } @@ -161,13 +140,22 @@ func (p *Processor) processCreateStatusFromFederator(ctx context.Context, federa // Ensure that account for this status has been deref'd. status.Account, _, err = p.federator.GetAccountByURI(ctx, federatorMsg.ReceivingAccount.Username, - remoteAccURI, + accountURI, ) if err != nil { return err } } + // Ensure status ancestors dereferenced. We need at least the + // immediate parent (if present) to ascertain timelineability. + if err := p.federator.DereferenceStatusAncestors(ctx, + federatorMsg.ReceivingAccount.Username, + status, + ); err != nil { + return err + } + if status.InReplyToID != "" { // Interaction counts changed on the replied status; // uncache the prepared version from all timelines. @@ -181,6 +169,58 @@ func (p *Processor) processCreateStatusFromFederator(ctx context.Context, federa return nil } +func (p *Processor) statusFromGTSModel(ctx context.Context, federatorMsg messages.FromFederator) (*gtsmodel.Status, error) { + // There should be a status pinned to the federatorMsg + // (we've already checked to ensure this is not nil). + status, ok := federatorMsg.GTSModel.(*gtsmodel.Status) + if !ok { + err := gtserror.New("Note was not parseable as *gtsmodel.Status") + return nil, err + } + + // AP statusable representation may have also + // been set on message (no problem if not). + statusable, _ := federatorMsg.APObjectModel.(ap.Statusable) + + // Call refresh on status to update + // it (deref remote) if necessary. + var err error + status, _, err = p.federator.RefreshStatus( + ctx, + federatorMsg.ReceivingAccount.Username, + status, + statusable, + false, + ) + if err != nil { + return nil, gtserror.Newf("%w", err) + } + + return status, nil +} + +func (p *Processor) statusFromAPIRI(ctx context.Context, federatorMsg messages.FromFederator) (*gtsmodel.Status, error) { + // There should be a status IRI pinned to + // the federatorMsg for us to dereference. + if federatorMsg.APIri == nil { + err := gtserror.New("status was not pinned to federatorMsg, and neither was an IRI for us to dereference") + return nil, err + } + + // Get the status + ensure we have + // the most up-to-date version. + status, _, err := p.federator.GetStatusByURI( + ctx, + federatorMsg.ReceivingAccount.Username, + federatorMsg.APIri, + ) + if err != nil { + return nil, gtserror.Newf("%w", err) + } + + return status, nil +} + // processCreateFaveFromFederator handles Activity Create with Object Like. func (p *Processor) processCreateFaveFromFederator(ctx context.Context, federatorMsg messages.FromFederator) error { statusFave, ok := federatorMsg.GTSModel.(*gtsmodel.StatusFave) @@ -278,11 +318,21 @@ func (p *Processor) processCreateAnnounceFromFederator(ctx context.Context, fede } status.ID = statusID - // Store, timeline, and notify. + // Store the boost wrapper status. if err := p.state.DB.PutStatus(ctx, status); err != nil { return gtserror.Newf("db error inserting status: %w", err) } + // Ensure boosted status ancestors dereferenced. We need at least + // the immediate parent (if present) to ascertain timelineability. + if err := p.federator.DereferenceStatusAncestors(ctx, + federatorMsg.ReceivingAccount.Username, + status.BoostOf, + ); err != nil { + return err + } + + // Timeline and notify the announce. if err := p.timelineAndNotifyStatus(ctx, status); err != nil { return gtserror.Newf("error timelining status: %w", err) } diff --git a/internal/typeutils/astointernal.go b/internal/typeutils/astointernal.go index 62b2c138a..9b2552131 100644 --- a/internal/typeutils/astointernal.go +++ b/internal/typeutils/astointernal.go @@ -245,134 +245,171 @@ func (c *converter) extractAttachments(i ap.WithAttachment) []*gtsmodel.MediaAtt } func (c *converter) ASStatusToStatus(ctx context.Context, statusable ap.Statusable) (*gtsmodel.Status, error) { - status := >smodel.Status{} + status := new(gtsmodel.Status) - // uri at which this status is reachable - uriProp := statusable.GetJSONLDId() - if uriProp == nil || !uriProp.IsIRI() { - return nil, errors.New("no id property found, or id was not an iri") + // status.URI + // + // ActivityPub ID/URI of this status. + idProp := statusable.GetJSONLDId() + if idProp == nil || !idProp.IsIRI() { + return nil, gtserror.New("no id property found, or id was not an iri") } - status.URI = uriProp.GetIRI().String() + status.URI = idProp.GetIRI().String() l := log.WithContext(ctx). WithField("statusURI", status.URI) - // web url for viewing this status + // status.URL + // + // Web URL of this status (optional). if statusURL, err := ap.ExtractURL(statusable); err == nil { status.URL = statusURL.String() } else { - // if no URL was set, just take the URI - status.URL = status.URI + status.URL = status.URI // Fall back to the URI. } - // the html-formatted content of this status + // status.Content + // + // The (html-formatted) content of this status. status.Content = ap.ExtractContent(statusable) - // attachments to dereference and fetch later on (we don't do that here) + // status.Attachments + // + // Media attachments for later dereferencing. status.Attachments = c.extractAttachments(statusable) - // hashtags to dereference later on + // status.Hashtags + // + // Hashtags for later dereferencing. if hashtags, err := ap.ExtractHashtags(statusable); err != nil { - l.Infof("ASStatusToStatus: error extracting status hashtags: %s", err) + l.Infof("error extracting hashtags: %q", err) } else { status.Tags = hashtags } - // emojis to dereference and fetch later on + // status.Emojis + // + // Custom emojis for later dereferencing. if emojis, err := ap.ExtractEmojis(statusable); err != nil { - l.Infof("ASStatusToStatus: error extracting status emojis: %s", err) + l.Infof("error extracting emojis: %q", err) } else { status.Emojis = emojis } - // mentions to dereference later on + // status.Mentions + // + // Mentions of other accounts for later dereferencing. if mentions, err := ap.ExtractMentions(statusable); err != nil { - l.Infof("ASStatusToStatus: error extracting status mentions: %s", err) + l.Infof("error extracting mentions: %q", err) } else { status.Mentions = mentions } - // cw string for this status - // prefer Summary, fall back to Name + // status.ContentWarning + // + // Topic or content warning for this status; + // prefer Summary, fall back to Name. if summary := ap.ExtractSummary(statusable); summary != "" { status.ContentWarning = summary } else { status.ContentWarning = ap.ExtractName(statusable) } - // when was this status created? + // status.Published + // + // Publication time of this status. Thanks to + // db defaults, will fall back to now if not set. published, err := ap.ExtractPublished(statusable) if err != nil { - l.Infof("ASStatusToStatus: error extracting status published: %s", err) + l.Infof("error extracting published: %q", err) } else { status.CreatedAt = published status.UpdatedAt = published } - // which account posted this status? - // if we don't know the account yet we can dereference it later + // status.AccountURI + // status.AccountID + // status.Account + // + // Account that created the status. Assume we have + // this in the db by the time this function is called, + // error if we don't. attributedTo, err := ap.ExtractAttributedToURI(statusable) if err != nil { - return nil, errors.New("ASStatusToStatus: attributedTo was empty") + return nil, gtserror.Newf("%w", err) } - status.AccountURI = attributedTo.String() + accountURI := attributedTo.String() - statusOwner, err := c.db.GetAccountByURI(ctx, attributedTo.String()) + account, err := c.db.GetAccountByURI(ctx, accountURI) if err != nil { - return nil, fmt.Errorf("ASStatusToStatus: couldn't get status owner from db: %s", err) + err = gtserror.Newf("db error getting status author account %s: %w", accountURI, err) + return nil, err } - status.AccountID = statusOwner.ID - status.AccountURI = statusOwner.URI - status.Account = statusOwner + status.AccountURI = accountURI + status.AccountID = account.ID + status.Account = account - // check if there's a post that this is a reply to - inReplyToURI := ap.ExtractInReplyToURI(statusable) - if inReplyToURI != nil { - // something is set so we can at least set this field on the - // status and dereference using this later if we need to - status.InReplyToURI = inReplyToURI.String() + // status.InReplyToURI + // status.InReplyToID + // status.InReplyTo + // status.InReplyToAccountID + // status.InReplyToAccount + // + // Status that this status replies to, if applicable. + // If we don't have this status in the database, we + // just set the URI and assume we can deref it later. + if uri := ap.ExtractInReplyToURI(statusable); uri != nil { + inReplyToURI := uri.String() + status.InReplyToURI = inReplyToURI - // now we can check if we have the replied-to status in our db already - if inReplyToStatus, err := c.db.GetStatusByURI(ctx, inReplyToURI.String()); err == nil { - // we have the status in our database already - // so we can set these fields here and now... - status.InReplyToID = inReplyToStatus.ID - status.InReplyToAccountID = inReplyToStatus.AccountID - status.InReplyTo = inReplyToStatus - if status.InReplyToAccount == nil { - if inReplyToAccount, err := c.db.GetAccountByID(ctx, inReplyToStatus.AccountID); err == nil { - status.InReplyToAccount = inReplyToAccount - } - } + // Check if we already have the replied-to status. + inReplyTo, err := c.db.GetStatusByURI(ctx, inReplyToURI) + if err != nil && !errors.Is(err, db.ErrNoEntries) { + // Real database error. + err = gtserror.Newf("db error getting replied-to status %s: %w", inReplyToURI, err) + return nil, err + } + + if inReplyTo != nil { + // We have it in the DB! Set + // appropriate fields here and now. + status.InReplyToID = inReplyTo.ID + status.InReplyTo = inReplyTo + status.InReplyToAccountID = inReplyTo.AccountID + status.InReplyToAccount = inReplyTo.Account } } - // visibility entry for this status - visibility, err := ap.ExtractVisibility(statusable, status.Account.FollowersURI) + // status.Visibility + visibility, err := ap.ExtractVisibility( + statusable, + status.Account.FollowersURI, + ) if err != nil { - return nil, fmt.Errorf("ASStatusToStatus: error extracting visibility: %s", err) + err = gtserror.Newf("error extracting visibility: %w", err) + return nil, err } status.Visibility = visibility - // advanced visibility for this status - // TODO: a lot of work to be done here -- a new type needs to be created for this in go-fed/activity using ASTOOL - // for now we just set everything to true - federated := true - boostable := true - replyable := true - likeable := true + // Advanced visibility toggles for this status. + // + // TODO: a lot of work to be done here -- a new type + // needs to be created for this in go-fed/activity. + // Until this is implemented, assume all true. + var trueBool = func() *bool { b := true; return &b } + status.Federated = trueBool() + status.Boostable = trueBool() + status.Replyable = trueBool() + status.Likeable = trueBool() - status.Federated = &federated - status.Boostable = &boostable - status.Replyable = &replyable - status.Likeable = &likeable - - // sensitive - sensitive := ap.ExtractSensitive(statusable) - status.Sensitive = &sensitive + // status.Sensitive + status.Sensitive = func() *bool { + s := ap.ExtractSensitive(statusable) + return &s + }() // language - // we might be able to extract this from the contentMap field + // TODO: we might be able to extract this from the contentMap field // ActivityStreamsType status.ActivityStreamsType = statusable.GetTypeName()