440 lines
14 KiB
Go
440 lines
14 KiB
Go
// GoToSocial
|
|
// Copyright (C) GoToSocial Authors admin@gotosocial.org
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package fedi
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"github.com/superseriousbusiness/activity/streams/vocab"
|
|
"github.com/superseriousbusiness/gotosocial/internal/ap"
|
|
"github.com/superseriousbusiness/gotosocial/internal/db"
|
|
"github.com/superseriousbusiness/gotosocial/internal/gtserror"
|
|
"github.com/superseriousbusiness/gotosocial/internal/log"
|
|
"github.com/superseriousbusiness/gotosocial/internal/paging"
|
|
"github.com/superseriousbusiness/gotosocial/internal/typeutils"
|
|
"github.com/superseriousbusiness/gotosocial/internal/util"
|
|
)
|
|
|
|
// InboxPost handles POST requests to a user's inbox for new activitypub messages.
|
|
//
|
|
// InboxPost returns true if the request was handled as an ActivityPub POST to an actor's inbox.
|
|
// If false, the request was not an ActivityPub request and may still be handled by the caller in another way, such as serving a web page.
|
|
//
|
|
// If the error is nil, then the ResponseWriter's headers and response has already been written. If a non-nil error is returned, then no response has been written.
|
|
//
|
|
// If the Actor was constructed with the Federated Protocol enabled, side effects will occur.
|
|
//
|
|
// If the Federated Protocol is not enabled, writes the http.StatusMethodNotAllowed status code in the response. No side effects occur.
|
|
func (p *Processor) InboxPost(ctx context.Context, w http.ResponseWriter, r *http.Request) (bool, error) {
|
|
return p.federator.FederatingActor().PostInbox(ctx, w, r)
|
|
}
|
|
|
|
// OutboxGet returns the serialized ActivityPub
|
|
// collection of a local account's outbox, which
|
|
// contains links to PUBLIC posts by this account.
|
|
func (p *Processor) OutboxGet(
|
|
ctx context.Context,
|
|
requestedUser string,
|
|
page *paging.Page,
|
|
) (interface{}, gtserror.WithCode) {
|
|
// Authenticate incoming request, getting related accounts.
|
|
auth, errWithCode := p.authenticate(ctx, requestedUser)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
receivingAcct := auth.receivingAcct
|
|
|
|
// Parse the collection ID object from account's followers URI.
|
|
collectionID, err := url.Parse(receivingAcct.OutboxURI)
|
|
if err != nil {
|
|
err := gtserror.Newf("error parsing account outbox uri %s: %w", receivingAcct.OutboxURI, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Ensure we have stats for this account.
|
|
if receivingAcct.Stats == nil {
|
|
if err := p.state.DB.PopulateAccountStats(ctx, receivingAcct); err != nil {
|
|
err := gtserror.Newf("error getting stats for account %s: %w", receivingAcct.ID, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
}
|
|
|
|
var obj vocab.Type
|
|
|
|
// Start the AS collection params.
|
|
var params ap.CollectionParams
|
|
params.ID = collectionID
|
|
|
|
switch {
|
|
|
|
case *receivingAcct.Settings.HideCollections ||
|
|
receivingAcct.IsInstance():
|
|
// If account that hides collections, or instance
|
|
// account (ie., can't post / have relationships),
|
|
// just return barest stub of collection.
|
|
obj = ap.NewASOrderedCollection(params)
|
|
|
|
case page == nil || auth.handshakingURI != nil:
|
|
// If paging disabled, or we're currently handshaking
|
|
// the requester, just return collection that links
|
|
// to first page (i.e. path below), with no items.
|
|
params.Total = util.Ptr(*receivingAcct.Stats.StatusesCount)
|
|
params.First = new(paging.Page)
|
|
params.Query = make(url.Values, 1)
|
|
params.Query.Set("limit", "40") // enables paging
|
|
obj = ap.NewASOrderedCollection(params)
|
|
|
|
default:
|
|
// Paging enabled.
|
|
// Get page of full public statuses.
|
|
statuses, err := p.state.DB.GetAccountStatuses(
|
|
ctx,
|
|
receivingAcct.ID,
|
|
page.GetLimit(), // limit
|
|
true, // excludeReplies
|
|
true, // excludeReblogs
|
|
page.GetMax(), // maxID
|
|
page.GetMin(), // minID
|
|
false, // mediaOnly
|
|
true, // publicOnly
|
|
)
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("error getting statuses: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// page ID values.
|
|
var lo, hi string
|
|
|
|
if len(statuses) > 0 {
|
|
// Get the lowest and highest
|
|
// ID values, used for paging.
|
|
lo = statuses[len(statuses)-1].ID
|
|
hi = statuses[0].ID
|
|
}
|
|
|
|
// Start building AS collection page params.
|
|
params.Total = util.Ptr(*receivingAcct.Stats.StatusesCount)
|
|
var pageParams ap.CollectionPageParams
|
|
pageParams.CollectionParams = params
|
|
|
|
// Current page details.
|
|
pageParams.Current = page
|
|
pageParams.Count = len(statuses)
|
|
|
|
// Set linked next/prev parameters.
|
|
pageParams.Next = page.Next(lo, hi)
|
|
pageParams.Prev = page.Prev(lo, hi)
|
|
|
|
// Set the collection item property builder function.
|
|
pageParams.Append = func(i int, itemsProp ap.ItemsPropertyBuilder) {
|
|
// Get status at index.
|
|
status := statuses[i]
|
|
|
|
// Derive statusable from status.
|
|
statusable, err := p.converter.StatusToAS(ctx, status)
|
|
if err != nil {
|
|
log.Errorf(ctx, "error converting %s to statusable: %v", status.URI, err)
|
|
return
|
|
}
|
|
|
|
// Derive create from statusable, using the IRI only.
|
|
create := typeutils.WrapStatusableInCreate(statusable, true)
|
|
|
|
// Add to item property.
|
|
itemsProp.AppendActivityStreamsCreate(create)
|
|
}
|
|
|
|
// Build AS collection page object from params.
|
|
obj = ap.NewASOrderedCollectionPage(pageParams)
|
|
}
|
|
|
|
// Serialize the prepared object.
|
|
data, err := ap.Serialize(obj)
|
|
if err != nil {
|
|
err := gtserror.Newf("error serializing: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// FollowersGet returns the serialized ActivityPub
|
|
// collection of a local account's followers collection,
|
|
// which contains links to accounts following this account.
|
|
func (p *Processor) FollowersGet(
|
|
ctx context.Context,
|
|
requestedUser string,
|
|
page *paging.Page,
|
|
) (interface{}, gtserror.WithCode) {
|
|
// Authenticate incoming request, getting related accounts.
|
|
auth, errWithCode := p.authenticate(ctx, requestedUser)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
receivingAcct := auth.receivingAcct
|
|
|
|
// Parse the collection ID object from account's followers URI.
|
|
collectionID, err := url.Parse(receivingAcct.FollowersURI)
|
|
if err != nil {
|
|
err := gtserror.Newf("error parsing account followers uri %s: %w", receivingAcct.FollowersURI, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Ensure we have stats for this account.
|
|
if receivingAcct.Stats == nil {
|
|
if err := p.state.DB.PopulateAccountStats(ctx, receivingAcct); err != nil {
|
|
err := gtserror.Newf("error getting stats for account %s: %w", receivingAcct.ID, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
}
|
|
|
|
var obj vocab.Type
|
|
|
|
// Start the AS collection params.
|
|
var params ap.CollectionParams
|
|
params.ID = collectionID
|
|
|
|
switch {
|
|
|
|
case receivingAcct.IsInstance() ||
|
|
*receivingAcct.Settings.HideCollections:
|
|
// If account that hides collections, or instance
|
|
// account (ie., can't post / have relationships),
|
|
// just return barest stub of collection.
|
|
obj = ap.NewASOrderedCollection(params)
|
|
|
|
case page == nil || auth.handshakingURI != nil:
|
|
// If paging disabled, or we're currently handshaking
|
|
// the requester, just return collection that links
|
|
// to first page (i.e. path below), with no items.
|
|
params.Total = util.Ptr(*receivingAcct.Stats.FollowersCount)
|
|
params.First = new(paging.Page)
|
|
params.Query = make(url.Values, 1)
|
|
params.Query.Set("limit", "40") // enables paging
|
|
obj = ap.NewASOrderedCollection(params)
|
|
|
|
default:
|
|
// Paging enabled.
|
|
// Get page of full follower objects with attached accounts.
|
|
followers, err := p.state.DB.GetAccountFollowers(ctx, receivingAcct.ID, page)
|
|
if err != nil {
|
|
err := gtserror.Newf("error getting followers: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// page ID values.
|
|
var lo, hi string
|
|
|
|
if len(followers) > 0 {
|
|
// Get the lowest and highest
|
|
// ID values, used for paging.
|
|
lo = followers[len(followers)-1].ID
|
|
hi = followers[0].ID
|
|
}
|
|
|
|
// Start building AS collection page params.
|
|
params.Total = util.Ptr(*receivingAcct.Stats.FollowersCount)
|
|
var pageParams ap.CollectionPageParams
|
|
pageParams.CollectionParams = params
|
|
|
|
// Current page details.
|
|
pageParams.Current = page
|
|
pageParams.Count = len(followers)
|
|
|
|
// Set linked next/prev parameters.
|
|
pageParams.Next = page.Next(lo, hi)
|
|
pageParams.Prev = page.Prev(lo, hi)
|
|
|
|
// Set the collection item property builder function.
|
|
pageParams.Append = func(i int, itemsProp ap.ItemsPropertyBuilder) {
|
|
// Get follower URI at index.
|
|
follow := followers[i]
|
|
accURI := follow.Account.URI
|
|
|
|
// Parse URL object from URI.
|
|
iri, err := url.Parse(accURI)
|
|
if err != nil {
|
|
log.Errorf(ctx, "error parsing account uri %s: %v", accURI, err)
|
|
return
|
|
}
|
|
|
|
// Add to item property.
|
|
itemsProp.AppendIRI(iri)
|
|
}
|
|
|
|
// Build AS collection page object from params.
|
|
obj = ap.NewASOrderedCollectionPage(pageParams)
|
|
}
|
|
|
|
// Serialize the prepared object.
|
|
data, err := ap.Serialize(obj)
|
|
if err != nil {
|
|
err := gtserror.Newf("error serializing: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// FollowingGet returns the serialized ActivityPub
|
|
// collection of a local account's following collection,
|
|
// which contains links to accounts followed by this account.
|
|
func (p *Processor) FollowingGet(ctx context.Context, requestedUser string, page *paging.Page) (interface{}, gtserror.WithCode) {
|
|
// Authenticate incoming request, getting related accounts.
|
|
auth, errWithCode := p.authenticate(ctx, requestedUser)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
receivingAcct := auth.receivingAcct
|
|
|
|
// Parse collection ID from account's following URI.
|
|
collectionID, err := url.Parse(receivingAcct.FollowingURI)
|
|
if err != nil {
|
|
err := gtserror.Newf("error parsing account following uri %s: %w", receivingAcct.FollowingURI, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Ensure we have stats for this account.
|
|
if receivingAcct.Stats == nil {
|
|
if err := p.state.DB.PopulateAccountStats(ctx, receivingAcct); err != nil {
|
|
err := gtserror.Newf("error getting stats for account %s: %w", receivingAcct.ID, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
}
|
|
|
|
var obj vocab.Type
|
|
|
|
// Start AS collection params.
|
|
var params ap.CollectionParams
|
|
params.ID = collectionID
|
|
|
|
switch {
|
|
case receivingAcct.IsInstance() ||
|
|
*receivingAcct.Settings.HideCollections:
|
|
// If account that hides collections, or instance
|
|
// account (ie., can't post / have relationships),
|
|
// just return barest stub of collection.
|
|
obj = ap.NewASOrderedCollection(params)
|
|
|
|
case page == nil || auth.handshakingURI != nil:
|
|
// If paging disabled, or we're currently handshaking
|
|
// the requester, just return collection that links
|
|
// to first page (i.e. path below), with no items.
|
|
params.Total = util.Ptr(*receivingAcct.Stats.FollowingCount)
|
|
params.First = new(paging.Page)
|
|
params.Query = make(url.Values, 1)
|
|
params.Query.Set("limit", "40") // enables paging
|
|
obj = ap.NewASOrderedCollection(params)
|
|
|
|
default:
|
|
// Paging enabled.
|
|
// Get page of full follower objects with attached accounts.
|
|
follows, err := p.state.DB.GetAccountFollows(ctx, receivingAcct.ID, page)
|
|
if err != nil {
|
|
err := gtserror.Newf("error getting follows: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// page ID values.
|
|
var lo, hi string
|
|
|
|
if len(follows) > 0 {
|
|
// Get the lowest and highest
|
|
// ID values, used for paging.
|
|
lo = follows[len(follows)-1].ID
|
|
hi = follows[0].ID
|
|
}
|
|
|
|
// Start AS collection page params.
|
|
params.Total = util.Ptr(*receivingAcct.Stats.FollowingCount)
|
|
var pageParams ap.CollectionPageParams
|
|
pageParams.CollectionParams = params
|
|
|
|
// Current page details.
|
|
pageParams.Current = page
|
|
pageParams.Count = len(follows)
|
|
|
|
// Set linked next/prev parameters.
|
|
pageParams.Next = page.Next(lo, hi)
|
|
pageParams.Prev = page.Prev(lo, hi)
|
|
|
|
// Set the collection item property builder function.
|
|
pageParams.Append = func(i int, itemsProp ap.ItemsPropertyBuilder) {
|
|
// Get followed URI at index.
|
|
follow := follows[i]
|
|
accURI := follow.TargetAccount.URI
|
|
|
|
// Parse URL object from URI.
|
|
iri, err := url.Parse(accURI)
|
|
if err != nil {
|
|
log.Errorf(ctx, "error parsing account uri %s: %v", accURI, err)
|
|
return
|
|
}
|
|
|
|
// Add to item property.
|
|
itemsProp.AppendIRI(iri)
|
|
}
|
|
|
|
// Build AS collection page object from params.
|
|
obj = ap.NewASOrderedCollectionPage(pageParams)
|
|
}
|
|
|
|
// Serialize the prepared object.
|
|
data, err := ap.Serialize(obj)
|
|
if err != nil {
|
|
err := gtserror.Newf("error serializing: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// FeaturedCollectionGet returns an ordered collection of the requested username's Pinned posts.
|
|
// The returned collection have an `items` property which contains an ordered list of status URIs.
|
|
func (p *Processor) FeaturedCollectionGet(ctx context.Context, requestedUser string) (interface{}, gtserror.WithCode) {
|
|
// Authenticate incoming request, getting related accounts.
|
|
auth, errWithCode := p.authenticate(ctx, requestedUser)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
receivingAcct := auth.receivingAcct
|
|
|
|
statuses, err := p.state.DB.GetAccountPinnedStatuses(ctx, receivingAcct.ID)
|
|
if err != nil {
|
|
if !errors.Is(err, db.ErrNoEntries) {
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
}
|
|
|
|
collection, err := p.converter.StatusesToASFeaturedCollection(ctx, receivingAcct.FeaturedCollectionURI, statuses)
|
|
if err != nil {
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
data, err := ap.Serialize(collection)
|
|
if err != nil {
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|