start adding client support for making status edits and viewing history

internal/processing/status/common.go

@@ -0,0 +1,305 @@
+package status
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
+	"github.com/superseriousbusiness/gotosocial/internal/config"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+	"github.com/superseriousbusiness/gotosocial/internal/id"
+	"github.com/superseriousbusiness/gotosocial/internal/text"
+	"github.com/superseriousbusiness/gotosocial/internal/util/xslices"
+	"github.com/superseriousbusiness/gotosocial/internal/validate"
+)
+
+func validateStatusContent(
+	status string,
+	spoiler string,
+	mediaIDs []string,
+	poll *apimodel.PollRequest,
+) gtserror.WithCode {
+	totalChars := len([]rune(status)) +
+		len([]rune(spoiler))
+
+	if totalChars == 0 && len(mediaIDs) == 0 && poll == nil {
+		const text = "status contains no text, media or poll"
+		return gtserror.NewErrorBadRequest(errors.New(text), text)
+	}
+
+	if max := config.GetStatusesMaxChars(); totalChars > max {
+		text := fmt.Sprintf("text with spoiler exceed max chars (%d)", max)
+		return gtserror.NewErrorBadRequest(errors.New(text), text)
+	}
+
+	if max := config.GetStatusesMediaMaxFiles(); len(mediaIDs) > max {
+		text := fmt.Sprintf("media files exceed max count (%d)", max)
+		return gtserror.NewErrorBadRequest(errors.New(text), text)
+	}
+
+	if poll != nil {
+		switch max := config.GetStatusesPollMaxOptions(); {
+		case len(poll.Options) == 0:
+			const text = "poll cannot have no options"
+			return gtserror.NewErrorBadRequest(errors.New(text), text)
+
+		case len(poll.Options) > max:
+			text := fmt.Sprintf("poll options exceed max count (%d)", max)
+			return gtserror.NewErrorBadRequest(errors.New(text), text)
+		}
+
+		max := config.GetStatusesPollOptionMaxChars()
+		for i, option := range poll.Options {
+			switch l := len([]rune(option)); {
+			case l == 0:
+				const text = "poll option cannot be empty"
+				return gtserror.NewErrorBadRequest(errors.New(text), text)
+
+			case l > max:
+				text := fmt.Sprintf("poll option %d exceed max chars (%d)", i, max)
+				return gtserror.NewErrorBadRequest(errors.New(text), text)
+			}
+		}
+	}
+
+	return nil
+}
+
+type statusContent struct {
+	Content        string
+	ContentWarning string
+	PollOptions    []string
+	Language       string
+	MentionIDs     []string
+	Mentions       []*gtsmodel.Mention
+	EmojiIDs       []string
+	Emojis         []*gtsmodel.Emoji
+	TagIDs         []string
+	Tags           []*gtsmodel.Tag
+}
+
+func (p *Processor) processContent(
+	ctx context.Context,
+	author *gtsmodel.Account,
+	statusID string,
+	contentType string,
+	content string,
+	contentWarning string,
+	language string,
+	poll *apimodel.PollRequest,
+) (
+	*statusContent,
+	gtserror.WithCode,
+) {
+	if language == "" {
+		// Ensure we have a status language.
+		language = author.Settings.Language
+		if language == "" {
+			const text = "account default language unset"
+			return nil, gtserror.NewErrorInternalError(
+				errors.New(text),
+			)
+		}
+	}
+
+	var err error
+
+	// Validate + normalize determined language.
+	language, err = validate.Language(language)
+	if err != nil {
+		text := fmt.Sprintf("invalid language tag: %v", err)
+		return nil, gtserror.NewErrorBadRequest(
+			errors.New(text),
+			text,
+		)
+	}
+
+	// format is the currently set text formatting
+	// function, according to the provided content-type.
+	var format text.FormatFunc
+
+	if contentType == "" {
+		// If content type wasn't specified, use
+		// the author's preferred content-type.
+		contentType = author.Settings.StatusContentType
+	}
+
+	switch contentType {
+
+	// Format status according to text/plain.
+	case "", string(apimodel.StatusContentTypePlain):
+		format = p.formatter.FromPlain
+
+	// Format status according to text/markdown.
+	case string(apimodel.StatusContentTypeMarkdown):
+		format = p.formatter.FromMarkdown
+
+	// Unknown.
+	default:
+		const text = "invalid status format"
+		return nil, gtserror.NewErrorBadRequest(
+			errors.New(text),
+			text,
+		)
+	}
+
+	// Allocate a structure to hold the
+	// majority of formatted content without
+	// needing to alloc a whole gtsmodel.Status{}.
+	var status statusContent
+	status.Language = language
+
+	// formatInput is a shorthand function to format the given input string with the
+	// currently set 'formatFunc', passing in all required args and returning result.
+	formatInput := func(formatFunc text.FormatFunc, input string) *text.FormatResult {
+		return formatFunc(ctx, p.parseMention, author.ID, statusID, input)
+	}
+
+	// Sanitize input status text and format.
+	contentRes := formatInput(format, content)
+
+	// Gather results of formatted.
+	status.Content = contentRes.HTML
+	status.Mentions = contentRes.Mentions
+	status.Emojis = contentRes.Emojis
+	status.Tags = contentRes.Tags
+
+	// From here-on-out just use emoji-only
+	// plain-text formatting as the FormatFunc.
+	format = p.formatter.FromPlainEmojiOnly
+
+	// Sanitize content warning and format.
+	warning := text.SanitizeToPlaintext(contentWarning)
+	warningRes := formatInput(format, warning)
+
+	// Gather results of the formatted.
+	status.ContentWarning = warningRes.HTML
+	status.Emojis = append(status.Emojis, warningRes.Emojis...)
+
+	if poll != nil {
+		// Pre-allocate slice of poll options of expected length.
+		status.PollOptions = make([]string, len(poll.Options))
+		for i, option := range poll.Options {
+
+			// Sanitize each poll option and format.
+			option = text.SanitizeToPlaintext(option)
+			optionRes := formatInput(format, option)
+
+			// Gather results of the formatted.
+			status.PollOptions[i] = optionRes.HTML
+			status.Emojis = append(status.Emojis, optionRes.Emojis...)
+		}
+
+		// Also update options on the form.
+		poll.Options = status.PollOptions
+	}
+
+	// Gather up the IDs of mentions from parsed content.
+	status.MentionIDs = xslices.Gather(nil, status.Mentions,
+		func(m *gtsmodel.Mention) string {
+			return m.ID
+		},
+	)
+
+	// Gather up the IDs of tags from parsed content.
+	status.TagIDs = xslices.Gather(nil, status.Tags,
+		func(t *gtsmodel.Tag) string {
+			return t.ID
+		},
+	)
+
+	// Gather up the IDs of emojis in updated content.
+	status.EmojiIDs = xslices.Gather(nil, status.Emojis,
+		func(e *gtsmodel.Emoji) string {
+			return e.ID
+		},
+	)
+
+	return &status, nil
+}
+
+func (p *Processor) processMedia(
+	ctx context.Context,
+	authorID string,
+	statusID string,
+	mediaIDs []string,
+) (
+	[]*gtsmodel.MediaAttachment,
+	gtserror.WithCode,
+) {
+	// No media provided!
+	if len(mediaIDs) == 0 {
+		return nil, nil
+	}
+
+	// Pre-allocate slice of media attachments of expected length.
+	attachments := make([]*gtsmodel.MediaAttachment, len(mediaIDs))
+	for i, id := range mediaIDs {
+
+		// Look for media attachment by ID in database.
+		media, err := p.state.DB.GetAttachmentByID(ctx, id)
+		if err != nil && !errors.Is(err, db.ErrNoEntries) {
+			err := gtserror.Newf("error getting media from db: %w", err)
+			return nil, gtserror.NewErrorInternalError(err)
+		}
+
+		// Check media exists and is owned by author
+		// (this masks finding out media ownership info).
+		if media == nil || media.AccountID != authorID {
+			text := fmt.Sprintf("media not found: %s", id)
+			return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
+		}
+
+		// Check media isn't already attached to another status.
+		if (media.StatusID != "" && media.StatusID != statusID) ||
+			(media.ScheduledStatusID != "" && media.ScheduledStatusID != statusID) {
+			text := fmt.Sprintf("media already attached to status: %s", id)
+			return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
+		}
+
+		// Set media at index.
+		attachments[i] = media
+	}
+
+	return attachments, nil
+}
+
+func (p *Processor) processPoll(
+	ctx context.Context,
+	statusID string,
+	form *apimodel.PollRequest,
+	now time.Time, // used for expiry time
+) (
+	*gtsmodel.Poll,
+	gtserror.WithCode,
+) {
+	var expiresAt time.Time
+
+	// Set an expiry time if one given.
+	if in := form.ExpiresIn; in > 0 {
+		expiresIn := time.Duration(in)
+		expiresAt = now.Add(expiresIn * time.Second)
+	}
+
+	// Create new poll model.
+	poll := &gtsmodel.Poll{
+		ID:         id.NewULIDFromTime(now),
+		Multiple:   &form.Multiple,
+		HideCounts: &form.HideTotals,
+		Options:    form.Options,
+		StatusID:   statusID,
+		ExpiresAt:  expiresAt,
+	}
+
+	// Insert the newly created poll model in the database.
+	if err := p.state.DB.PutPoll(ctx, poll); err != nil {
+		err := gtserror.Newf("error inserting poll in db: %w", err)
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	return poll, nil
+}

internal/processing/status/create.go

@@ -19,29 +19,22 @@ package status
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"time"
 
 	"github.com/superseriousbusiness/gotosocial/internal/ap"
 	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
-	"github.com/superseriousbusiness/gotosocial/internal/config"
-	"github.com/superseriousbusiness/gotosocial/internal/db"
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 	"github.com/superseriousbusiness/gotosocial/internal/id"
 	"github.com/superseriousbusiness/gotosocial/internal/log"
 	"github.com/superseriousbusiness/gotosocial/internal/messages"
-	"github.com/superseriousbusiness/gotosocial/internal/text"
 	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
 	"github.com/superseriousbusiness/gotosocial/internal/uris"
 	"github.com/superseriousbusiness/gotosocial/internal/util"
-	"github.com/superseriousbusiness/gotosocial/internal/util/xslices"
 )
 
 // Create processes the given form to create a new status, returning the api model representation of that status if it's OK.
-//
-// Precondition: the form's fields should have already been validated and normalized by the caller.
+// Note this also handles validation of incoming form field data.
 func (p *Processor) Create(
 	ctx context.Context,
 	requester *gtsmodel.Account,
@@ -51,6 +44,16 @@ func (p *Processor) Create(
 	*apimodel.Status,
 	gtserror.WithCode,
 ) {
+	// Validate incoming form status content.
+	if errWithCode := validateStatusContent(
+		form.Status,
+		form.SpoilerText,
+		form.MediaIDs,
+		form.Poll,
+	); errWithCode != nil {
+		return nil, errWithCode
+	}
+
 	// Ensure account populated; we'll need settings.
 	if err := p.state.DB.PopulateAccount(ctx, requester); err != nil {
 		log.Errorf(ctx, "error(s) populating account, will continue: %s", err)
@@ -59,6 +62,30 @@ func (p *Processor) Create(
 	// Generate new ID for status.
 	statusID := id.NewULID()
 
+	// Process incoming status content fields.
+	content, errWithCode := p.processContent(ctx,
+		requester,
+		statusID,
+		string(form.ContentType),
+		form.Status,
+		form.SpoilerText,
+		form.Language,
+		form.Poll,
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Process incoming status attachments.
+	media, errWithCode := p.processMedia(ctx,
+		requester.ID,
+		statusID,
+		form.MediaIDs,
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
 	// Generate necessary URIs for username, to build status URIs.
 	accountURIs := uris.GenerateURIsForAccount(requester.Username)
 
@@ -78,16 +105,36 @@ func (p *Processor) Create(
 		ActivityStreamsType:      ap.ObjectNote,
 		Sensitive:                &form.Sensitive,
 		CreatedWithApplicationID: application.ID,
-		Text:                     form.Status,
+
+		// Set validated language.
+		Language: content.Language,
+
+		// Set formatted status content.
+		Content:        content.Content,
+		ContentWarning: content.ContentWarning,
+		Text:           form.Status, // raw
+
+		// Set gathered mentions.
+		MentionIDs: content.MentionIDs,
+		Mentions:   content.Mentions,
+
+		// Set gathered emojis.
+		EmojiIDs: content.EmojiIDs,
+		Emojis:   content.Emojis,
+
+		// Set gathered tags.
+		TagIDs: content.TagIDs,
+		Tags:   content.Tags,
+
+		// Set gathered media.
+		AttachmentIDs: form.MediaIDs,
+		Attachments:   media,
 
 		// Assume not pending approval; this may
 		// change when permissivity is checked.
 		PendingApproval: util.Ptr(false),
 	}
 
-	// Process any attached poll.
-	p.processPoll(status, form.Poll)
-
 	// Check + attach in-reply-to status.
 	if errWithCode := p.processInReplyTo(ctx,
 		requester,
@@ -101,10 +148,6 @@ func (p *Processor) Create(
 		return nil, errWithCode
 	}
 
-	if errWithCode := p.processMediaIDs(ctx, form, requester.ID, status); errWithCode != nil {
-		return nil, errWithCode
-	}
-
 	if err := p.processVisibility(ctx, form, requester.Settings.Privacy, status); err != nil {
 		return nil, gtserror.NewErrorInternalError(err)
 	}
@@ -115,36 +158,49 @@ func (p *Processor) Create(
 		return nil, errWithCode
 	}
 
-	if err := processLanguage(form, requester.Settings.Language, status); err != nil {
-		return nil, gtserror.NewErrorInternalError(err)
+	if status.ContentWarning != "" && len(status.AttachmentIDs) > 0 {
+		// If a content-warning is set, and
+		// the status contains media, always
+		// set the status sensitive flag.
+		status.Sensitive = util.Ptr(true)
 	}
 
-	if err := p.processContent(ctx, p.parseMention, form, status); err != nil {
-		return nil, gtserror.NewErrorInternalError(err)
-	}
-
-	if status.Poll != nil {
-		// Try to insert the new status poll in the database.
-		if err := p.state.DB.PutPoll(ctx, status.Poll); err != nil {
-			err := gtserror.Newf("error inserting poll in db: %w", err)
-			return nil, gtserror.NewErrorInternalError(err)
+	if form.Poll != nil {
+		// Process poll, inserting into database.
+		poll, errWithCode := p.processPoll(ctx,
+			statusID,
+			form.Poll,
+			now,
+		)
+		if errWithCode != nil {
+			return nil, errWithCode
 		}
+
+		// Set poll and its ID
+		// on status before insert.
+		status.PollID = poll.ID
+		status.Poll = poll
+		poll.Status = status
+
+		// Update the status' ActivityPub type to Question.
+		status.ActivityStreamsType = ap.ActivityQuestion
 	}
 
-	// Insert this new status in the database.
+	// Insert this newly prepared status into the database.
 	if err := p.state.DB.PutStatus(ctx, status); err != nil {
+		err := gtserror.Newf("error inserting status in db: %w", err)
 		return nil, gtserror.NewErrorInternalError(err)
 	}
 
 	if status.Poll != nil && !status.Poll.ExpiresAt.IsZero() {
-		// Now that the status is inserted, and side effects queued,
-		// attempt to schedule an expiry handler for the status poll.
+		// Now that the status is inserted, attempt to
+		// schedule an expiry handler for the status poll.
 		if err := p.polls.ScheduleExpiry(ctx, status.Poll); err != nil {
 			log.Errorf(ctx, "error scheduling poll expiry: %v", err)
 		}
 	}
 
-	// send it back to the client API worker for async side-effects.
+	// Send it to the client API worker for async side-effects.
 	p.state.Workers.Client.Queue.Push(&messages.FromClientAPI{
 		APObjectType:   ap.ObjectNote,
 		APActivityType: ap.ActivityCreate,
@@ -172,43 +228,6 @@ func (p *Processor) Create(
 	return p.c.GetAPIStatus(ctx, requester, status)
 }
 
-func (p *Processor) processPoll(status *gtsmodel.Status, poll *apimodel.PollRequest) {
-	if poll == nil {
-		// No poll set.
-		// Nothing to do.
-		return
-	}
-
-	var expiresAt time.Time
-
-	// Now will have been set
-	// as the status creation.
-	now := status.CreatedAt
-
-	// Update the status AS type to "Question".
-	status.ActivityStreamsType = ap.ActivityQuestion
-
-	// Set an expiry time if one given.
-	if in := poll.ExpiresIn; in > 0 {
-		expiresIn := time.Duration(in)
-		expiresAt = now.Add(expiresIn * time.Second)
-	}
-
-	// Create new poll for status.
-	status.Poll = &gtsmodel.Poll{
-		ID:         id.NewULID(),
-		Multiple:   &poll.Multiple,
-		HideCounts: &poll.HideTotals,
-		Options:    poll.Options,
-		StatusID:   status.ID,
-		Status:     status,
-		ExpiresAt:  expiresAt,
-	}
-
-	// Set poll ID on the status.
-	status.PollID = status.Poll.ID
-}
-
 func (p *Processor) processInReplyTo(ctx context.Context, requester *gtsmodel.Account, status *gtsmodel.Status, inReplyToID string) gtserror.WithCode {
 	if inReplyToID == "" {
 		// Not a reply.
@@ -332,53 +351,6 @@ func (p *Processor) processThreadID(ctx context.Context, status *gtsmodel.Status
 	return nil
 }
 
-func (p *Processor) processMediaIDs(ctx context.Context, form *apimodel.StatusCreateRequest, thisAccountID string, status *gtsmodel.Status) gtserror.WithCode {
-	if form.MediaIDs == nil {
-		return nil
-	}
-
-	// Get minimum allowed char descriptions.
-	minChars := config.GetMediaDescriptionMinChars()
-
-	attachments := []*gtsmodel.MediaAttachment{}
-	attachmentIDs := []string{}
-
-	for _, mediaID := range form.MediaIDs {
-		attachment, err := p.state.DB.GetAttachmentByID(ctx, mediaID)
-		if err != nil && !errors.Is(err, db.ErrNoEntries) {
-			err := gtserror.Newf("error fetching media from db: %w", err)
-			return gtserror.NewErrorInternalError(err)
-		}
-
-		if attachment == nil {
-			text := fmt.Sprintf("media %s not found", mediaID)
-			return gtserror.NewErrorBadRequest(errors.New(text), text)
-		}
-
-		if attachment.AccountID != thisAccountID {
-			text := fmt.Sprintf("media %s does not belong to account", mediaID)
-			return gtserror.NewErrorBadRequest(errors.New(text), text)
-		}
-
-		if attachment.StatusID != "" || attachment.ScheduledStatusID != "" {
-			text := fmt.Sprintf("media %s already attached to status", mediaID)
-			return gtserror.NewErrorBadRequest(errors.New(text), text)
-		}
-
-		if length := len([]rune(attachment.Description)); length < minChars {
-			text := fmt.Sprintf("media %s description too short, at least %d required", mediaID, minChars)
-			return gtserror.NewErrorBadRequest(errors.New(text), text)
-		}
-
-		attachments = append(attachments, attachment)
-		attachmentIDs = append(attachmentIDs, attachment.ID)
-	}
-
-	status.Attachments = attachments
-	status.AttachmentIDs = attachmentIDs
-	return nil
-}
-
 func (p *Processor) processVisibility(
 	ctx context.Context,
 	form *apimodel.StatusCreateRequest,
@@ -474,99 +446,3 @@ func processInteractionPolicy(
 	// setting it explicitly to save space.
 	return nil
 }
-
-func processLanguage(form *apimodel.StatusCreateRequest, accountDefaultLanguage string, status *gtsmodel.Status) error {
-	if form.Language != "" {
-		status.Language = form.Language
-	} else {
-		status.Language = accountDefaultLanguage
-	}
-	if status.Language == "" {
-		return errors.New("no language given either in status create form or account default")
-	}
-	return nil
-}
-
-func (p *Processor) processContent(ctx context.Context, parseMention gtsmodel.ParseMentionFunc, form *apimodel.StatusCreateRequest, status *gtsmodel.Status) error {
-	if form.ContentType == "" {
-		// If content type wasn't specified, use the author's preferred content-type.
-		contentType := apimodel.StatusContentType(status.Account.Settings.StatusContentType)
-		form.ContentType = contentType
-	}
-
-	// format is the currently set text formatting
-	// function, according to the provided content-type.
-	var format text.FormatFunc
-
-	// formatInput is a shorthand function to format the given input string with the
-	// currently set 'formatFunc', passing in all required args and returning result.
-	formatInput := func(formatFunc text.FormatFunc, input string) *text.FormatResult {
-		return formatFunc(ctx, parseMention, status.AccountID, status.ID, input)
-	}
-
-	switch form.ContentType {
-	// None given / set,
-	// use default (plain).
-	case "":
-		fallthrough
-
-	// Format status according to text/plain.
-	case apimodel.StatusContentTypePlain:
-		format = p.formatter.FromPlain
-
-	// Format status according to text/markdown.
-	case apimodel.StatusContentTypeMarkdown:
-		format = p.formatter.FromMarkdown
-
-	// Unknown.
-	default:
-		return fmt.Errorf("invalid status format: %q", form.ContentType)
-	}
-
-	// Sanitize status text and format.
-	contentRes := formatInput(format, form.Status)
-
-	// Collect formatted results.
-	status.Content = contentRes.HTML
-	status.Mentions = append(status.Mentions, contentRes.Mentions...)
-	status.Emojis = append(status.Emojis, contentRes.Emojis...)
-	status.Tags = append(status.Tags, contentRes.Tags...)
-
-	// From here-on-out just use emoji-only
-	// plain-text formatting as the FormatFunc.
-	format = p.formatter.FromPlainEmojiOnly
-
-	// Sanitize content warning and format.
-	spoiler := text.SanitizeToPlaintext(form.SpoilerText)
-	warningRes := formatInput(format, spoiler)
-
-	// Collect formatted results.
-	status.ContentWarning = warningRes.HTML
-	status.Emojis = append(status.Emojis, warningRes.Emojis...)
-
-	if status.Poll != nil {
-		for i := range status.Poll.Options {
-			// Sanitize each option title name and format.
-			option := text.SanitizeToPlaintext(status.Poll.Options[i])
-			optionRes := formatInput(format, option)
-
-			// Collect each formatted result.
-			status.Poll.Options[i] = optionRes.HTML
-			status.Emojis = append(status.Emojis, optionRes.Emojis...)
-		}
-	}
-
-	// Gather all the database IDs from each of the gathered status mentions, tags, and emojis.
-	status.MentionIDs = xslices.Gather(nil, status.Mentions, func(mention *gtsmodel.Mention) string { return mention.ID })
-	status.TagIDs = xslices.Gather(nil, status.Tags, func(tag *gtsmodel.Tag) string { return tag.ID })
-	status.EmojiIDs = xslices.Gather(nil, status.Emojis, func(emoji *gtsmodel.Emoji) string { return emoji.ID })
-
-	if status.ContentWarning != "" && len(status.AttachmentIDs) > 0 {
-		// If a content-warning is set, and
-		// the status contains media, always
-		// set the status sensitive flag.
-		status.Sensitive = util.Ptr(true)
-	}
-
-	return nil
-}

internal/processing/status/edit.go

@@ -0,0 +1,572 @@
+// 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 status
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/superseriousbusiness/gotosocial/internal/ap"
+	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+	"github.com/superseriousbusiness/gotosocial/internal/id"
+	"github.com/superseriousbusiness/gotosocial/internal/log"
+	"github.com/superseriousbusiness/gotosocial/internal/messages"
+)
+
+// Edit ...
+func (p *Processor) Edit(
+	ctx context.Context,
+	requester *gtsmodel.Account,
+	statusID string,
+	form *apimodel.StatusEditRequest,
+) (
+	*apimodel.Status,
+	gtserror.WithCode,
+) {
+	// Fetch status and ensure it's owned by requesting account.
+	status, errWithCode := p.c.GetOwnStatus(ctx, requester, statusID)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Ensure this isn't a boost.
+	if status.BoostOfID != "" {
+		return nil, gtserror.NewErrorNotFound(
+			errors.New("status is a boost wrapper"),
+			"target status not found",
+		)
+	}
+
+	// Time of edit.
+	now := time.Now()
+
+	// Validate incoming form edit content.
+	if errWithCode := validateStatusContent(
+		form.Status,
+		form.SpoilerText,
+		form.MediaIDs,
+		form.Poll,
+	); errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Process incoming status edit content fields.
+	content, errWithCode := p.processContent(ctx,
+		requester,
+		statusID,
+		string(form.ContentType),
+		form.Status,
+		form.SpoilerText,
+		form.Language,
+		form.Poll,
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Process new status attachments to use.
+	media, errWithCode := p.processMedia(ctx,
+		requester.ID,
+		statusID,
+		form.MediaIDs,
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Process incoming edits of any attached media.
+	mediaEdited, errWithCode := p.processMediaEdits(ctx,
+		media,
+		form.MediaAttributes,
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Process incoming edits of any attached status poll.
+	poll, pollEdited, errWithCode := p.processPollEdit(ctx,
+		statusID,
+		status.Poll,
+		form.Poll,
+		now,
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	// Check if new status poll was set.
+	pollChanged := (poll != status.Poll)
+
+	// Determine whether there were any changes possibly
+	// causing a change to embedded mentions, tags, emojis.
+	contentChanged := (status.Content != content.Content)
+	warningChanged := (status.ContentWarning != content.ContentWarning)
+	languageChanged := (status.Language != content.Language)
+	anyContentChanged := contentChanged || warningChanged ||
+		pollEdited // encapsulates pollChanged too
+
+	// Check if status media attachments have changed.
+	mediaChanged := !slices.Equal(status.AttachmentIDs,
+		form.MediaIDs,
+	)
+
+	// Track status columns we
+	// need to update in database.
+	cols := make([]string, 2, 13)
+	cols[0] = "updated_at"
+	cols[1] = "edits"
+
+	if contentChanged {
+		// Update status text.
+		//
+		// Note we don't update these
+		// status fields right away so
+		// we can save current version.
+		cols = append(cols, "content")
+		cols = append(cols, "text")
+	}
+
+	if warningChanged {
+		// Update status content warning.
+		//
+		// Note we don't update these
+		// status fields right away so
+		// we can save current version.
+		cols = append(cols, "content_warning")
+	}
+
+	if languageChanged {
+		// Update status language pref.
+		//
+		// Note we don't update these
+		// status fields right away so
+		// we can save current version.
+		cols = append(cols, "language")
+	}
+
+	if *status.Sensitive != form.Sensitive {
+		// Update status sensitivity pref.
+		//
+		// Note we don't update these
+		// status fields right away so
+		// we can save current version.
+		cols = append(cols, "sensitive")
+	}
+
+	if mediaChanged {
+		// Updated status media attachments.
+		//
+		// Note we don't update these
+		// status fields right away so
+		// we can save current version.
+		cols = append(cols, "attachments")
+	}
+
+	if pollChanged {
+		// Updated attached status poll.
+		//
+		// Note we don't update these
+		// status fields right away so
+		// we can save current version.
+		cols = append(cols, "poll_id")
+
+		if status.Poll == nil || poll == nil {
+			// Went from with-poll to without-poll
+			// or vice-versa. This changes AP type.
+			cols = append(cols, "activity_streams_type")
+		}
+	}
+
+	if anyContentChanged {
+		if !slices.Equal(status.MentionIDs, content.MentionIDs) {
+			// Update attached status mentions.
+			cols = append(cols, "mentions")
+			status.MentionIDs = content.MentionIDs
+			status.Mentions = content.Mentions
+		}
+
+		if !slices.Equal(status.TagIDs, content.TagIDs) {
+			// Updated attached status tags.
+			cols = append(cols, "tags")
+			status.TagIDs = content.TagIDs
+			status.Tags = content.Tags
+		}
+
+		if !slices.Equal(status.EmojiIDs, content.EmojiIDs) {
+			// Update attached status emojis.
+			cols = append(cols, "emojis")
+			status.EmojiIDs = content.EmojiIDs
+			status.Emojis = content.Emojis
+		}
+	}
+
+	// If no status columns were updated, no media and
+	// no poll were edited, there's nothing to do!
+	if len(cols) == 2 && !mediaEdited && !pollEdited {
+		const text = "status was not changed"
+		return nil, gtserror.NewErrorUnprocessableEntity(
+			errors.New(text),
+			text,
+		)
+	}
+
+	// Create an edit to store a
+	// historical snapshot of status.
+	var edit gtsmodel.StatusEdit
+	edit.ID = id.NewULIDFromTime(now)
+	edit.Content = status.Content
+	edit.ContentWarning = status.ContentWarning
+	edit.Text = status.Text
+	edit.Language = status.Language
+	edit.Sensitive = status.Sensitive
+	edit.StatusID = status.ID
+	edit.CreatedAt = now
+
+	// Copy existing media and descriptions.
+	edit.AttachmentIDs = status.AttachmentIDs
+	if l := len(status.Attachments); l > 0 {
+		edit.AttachmentDescriptions = make([]string, l)
+		for i, attach := range status.Attachments {
+			edit.AttachmentDescriptions[i] = attach.Description
+		}
+	}
+
+	if status.Poll != nil {
+		// Poll only set if existed previously.
+		edit.PollOptions = status.Poll.Options
+
+		if pollChanged || !*status.Poll.HideCounts ||
+			!status.Poll.ClosedAt.IsZero() {
+			// If the counts are allowed to be
+			// shown, or poll has changed, then
+			// include poll vote counts in edit.
+			edit.PollVotes = status.Poll.Votes
+		}
+	}
+
+	// Insert this new edit of existing status into database.
+	if err := p.state.DB.PutStatusEdit(ctx, &edit); err != nil {
+		err := gtserror.Newf("error putting edit in database: %w", err)
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	// Add edit to list of edits on the status.
+	status.EditIDs = append(status.EditIDs, edit.ID)
+	status.Edits = append(status.Edits, &edit)
+
+	// Now historical status data is stored,
+	// update the other necessary status fields.
+	status.Content = content.Content
+	status.ContentWarning = content.ContentWarning
+	status.Text = form.Status
+	status.Language = content.Language
+	status.Sensitive = &form.Sensitive
+	status.AttachmentIDs = form.MediaIDs
+	status.Attachments = media
+	status.UpdatedAt = now
+
+	if poll != nil {
+		// Set relevent fields for latest with poll.
+		status.ActivityStreamsType = ap.ActivityQuestion
+		status.PollID = poll.ID
+		status.Poll = poll
+	} else {
+		// Set relevant fields for latest without poll.
+		status.ActivityStreamsType = ap.ObjectNote
+		status.PollID = ""
+		status.Poll = nil
+	}
+
+	// Finally update the existing status model in the database.
+	if err := p.state.DB.UpdateStatus(ctx, status, cols...); err != nil {
+		err := gtserror.Newf("error updating status in db: %w", err)
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	if pollChanged && status.Poll != nil && !status.Poll.ExpiresAt.IsZero() {
+		// Now the status is updated, attempt to schedule
+		// an expiry handler for the changed status poll.
+		if err := p.polls.ScheduleExpiry(ctx, status.Poll); err != nil {
+			log.Errorf(ctx, "error scheduling poll expiry: %v", err)
+		}
+	}
+
+	// Send it to the client API worker for async side-effects.
+	p.state.Workers.Client.Queue.Push(&messages.FromClientAPI{
+		APObjectType:   ap.ObjectNote,
+		APActivityType: ap.ActivityUpdate,
+		GTSModel:       status,
+		Origin:         requester,
+	})
+
+	// Return an API model of the updated status.
+	return p.c.GetAPIStatus(ctx, requester, status)
+}
+
+// HistoryGet gets edit history for the target status, taking account of privacy settings and blocks etc.
+func (p *Processor) HistoryGet(ctx context.Context, requester *gtsmodel.Account, targetStatusID string) ([]*apimodel.StatusEdit, gtserror.WithCode) {
+	target, errWithCode := p.c.GetVisibleTargetStatus(ctx,
+		requester,
+		targetStatusID,
+		nil, // default freshness
+	)
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	edits, err := p.converter.StatusToAPIEdits(ctx, target)
+	if err != nil {
+		err := gtserror.Newf("error converting status: %w", err)
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	return edits, nil
+}
+
+func (p *Processor) processMediaEdits(
+	ctx context.Context,
+	attachs []*gtsmodel.MediaAttachment,
+	attrs []apimodel.AttachmentAttributesRequest,
+) (
+	bool,
+	gtserror.WithCode,
+) {
+	var edited bool
+
+	for _, attr := range attrs {
+		// Search the media attachments slice for index of media with attr.ID.
+		i := slices.IndexFunc(attachs, func(m *gtsmodel.MediaAttachment) bool {
+			return m.ID == attr.ID
+		})
+		if i == -1 {
+			text := fmt.Sprintf("media not found: %s", attr.ID)
+			return false, gtserror.NewErrorBadRequest(errors.New(text), text)
+		}
+
+		// Get attach at index.
+		attach := attachs[i]
+
+		// Track which columns need
+		// updating in database query.
+		cols := make([]string, 0, 2)
+
+		// Check for description change.
+		if attr.Description != attach.Description {
+			attach.Description = attr.Description
+			cols = append(cols, "description")
+		}
+
+		if attr.Focus != "" {
+			// Parse provided media focus string request.
+			fx, fy, errWithCode := parseFocus(attr.Focus)
+			if errWithCode != nil {
+				return false, errWithCode
+			}
+
+			// Check for change in focus coords.
+			if attach.FileMeta.Focus.X != fx ||
+				attach.FileMeta.Focus.Y != fy {
+				attach.FileMeta.Focus.X = fx
+				attach.FileMeta.Focus.Y = fy
+				cols = append(cols, "focus_x", "focus_y")
+			}
+		}
+
+		if len(cols) > 0 {
+			// Media attachment was changed, update this in database.
+			err := p.state.DB.UpdateAttachment(ctx, attach, cols...)
+			if err != nil {
+				err := gtserror.Newf("error updating attachment in db: %w", err)
+				return false, gtserror.NewErrorInternalError(err)
+			}
+
+			// Set edited.
+			edited = true
+		}
+	}
+
+	return edited, nil
+}
+
+func (p *Processor) processPollEdit(
+	ctx context.Context,
+	statusID string,
+	original *gtsmodel.Poll,
+	form *apimodel.PollRequest,
+	now time.Time, // used for expiry time
+) (
+	*gtsmodel.Poll,
+	bool,
+	gtserror.WithCode,
+) {
+	if form == nil {
+		if original != nil {
+			// No poll was given but there's an existing poll,
+			// this indicates the original needs to be deleted.
+			if err := p.deletePoll(ctx, original); err != nil {
+				return nil, true, gtserror.NewErrorInternalError(err)
+			}
+
+			// Existing was deleted.
+			return nil, true, nil
+		}
+
+		// No change in poll.
+		return nil, false, nil
+	}
+
+	switch {
+	// No existing poll.
+	case original == nil:
+
+	// Any change that effects voting, i.e. options, allow multiple
+	// or re-opening a closed poll requires deleting the existing poll.
+	case !slices.Equal(form.Options, original.Options) ||
+		(form.Multiple != *original.Multiple) ||
+		(!original.ClosedAt.IsZero() && form.ExpiresIn != 0):
+		if err := p.deletePoll(ctx, original); err != nil {
+			return nil, true, gtserror.NewErrorInternalError(err)
+		}
+
+	// Any other changes only require a model
+	// update, and at-most a new expiry handler.
+	default:
+		var cols []string
+
+		// Check if the hide counts field changed.
+		if form.HideTotals != *original.HideCounts {
+			cols = append(cols, "hide_counts")
+			original.HideCounts = &form.HideTotals
+		}
+
+		var expiresAt time.Time
+
+		// Determine expiry time if given.
+		if in := form.ExpiresIn; in > 0 {
+			expiresIn := time.Duration(in)
+			expiresAt = now.Add(expiresIn * time.Second)
+		}
+
+		// Check for expiry time.
+		if !expiresAt.IsZero() {
+
+			if !original.ExpiresAt.IsZero() {
+				// Existing had expiry, cancel scheduled handler.
+				_ = p.state.Workers.Scheduler.Cancel(original.ID)
+			}
+
+			// Since expiry is given as a duration
+			// we always treat > 0 as a change as
+			// we can't know otherwise unfortunately.
+			cols = append(cols, "expires_at")
+			original.ExpiresAt = expiresAt
+		}
+
+		if len(cols) == 0 {
+			// Were no changes to poll.
+			return original, false, nil
+		}
+
+		// Update the original poll model in the database with these columns.
+		if err := p.state.DB.UpdatePoll(ctx, original, cols...); err != nil {
+			err := gtserror.Newf("error updating poll.expires_at in db: %w", err)
+			return nil, true, gtserror.NewErrorInternalError(err)
+		}
+
+		if !expiresAt.IsZero() {
+			// Updated poll has an expiry, schedule a new expiry handler.
+			if err := p.polls.ScheduleExpiry(ctx, original); err != nil {
+				log.Errorf(ctx, "error scheduling poll expiry: %v", err)
+			}
+		}
+
+		// Existing poll was updated.
+		return original, true, nil
+	}
+
+	// If we reached here then an entirely
+	// new status poll needs to be created.
+	poll, errWithCode := p.processPoll(ctx,
+		statusID,
+		form,
+		now,
+	)
+	return poll, true, errWithCode
+}
+
+func (p *Processor) deletePoll(ctx context.Context, poll *gtsmodel.Poll) error {
+	if !poll.ExpiresAt.IsZero() && !poll.ClosedAt.IsZero() {
+		// Poll has an expiry and has not yet closed,
+		// cancel any expiry handler before deletion.
+		_ = p.state.Workers.Scheduler.Cancel(poll.ID)
+	}
+
+	// Delete the given poll from the database.
+	err := p.state.DB.DeletePollByID(ctx, poll.ID)
+	if err != nil && !errors.Is(err, db.ErrNoEntries) {
+		return gtserror.Newf("error deleting poll from db: %w", err)
+	}
+
+	return nil
+}
+
+func parseFocus(focus string) (focusx, focusy float32, errWithCode gtserror.WithCode) {
+	if focus == "" {
+		return
+	}
+	spl := strings.Split(focus, ",")
+	if len(spl) != 2 {
+		const text = "missing comma separator"
+		errWithCode = gtserror.NewErrorBadRequest(
+			errors.New(text),
+			text,
+		)
+		return
+	}
+	xStr := spl[0]
+	yStr := spl[1]
+	fx, err := strconv.ParseFloat(xStr, 32)
+	if err != nil || fx > 1 || fx < -1 {
+		text := fmt.Sprintf("invalid x focus: %s", xStr)
+		errWithCode = gtserror.NewErrorBadRequest(
+			errors.New(text),
+			text,
+		)
+		return
+	}
+	fy, err := strconv.ParseFloat(yStr, 32)
+	if err != nil || fy > 1 || fy < -1 {
+		text := fmt.Sprintf("invalid y focus: %s", xStr)
+		errWithCode = gtserror.NewErrorBadRequest(
+			errors.New(text),
+			text,
+		)
+		return
+	}
+	focusx = float32(fx)
+	focusy = float32(fy)
+	return
+}

internal/processing/status/get.go

@@ -19,47 +19,16 @@ package status
 
 import (
 	"context"
+	"errors"
 
 	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
-	"github.com/superseriousbusiness/gotosocial/internal/util"
 )
 
-// HistoryGet gets edit history for the target status, taking account of privacy settings and blocks etc.
-// TODO: currently this just returns the latest version of the status.
-func (p *Processor) HistoryGet(ctx context.Context, requestingAccount *gtsmodel.Account, targetStatusID string) ([]*apimodel.StatusEdit, gtserror.WithCode) {
-	targetStatus, errWithCode := p.c.GetVisibleTargetStatus(ctx,
-		requestingAccount,
-		targetStatusID,
-		nil, // default freshness
-	)
-	if errWithCode != nil {
-		return nil, errWithCode
-	}
-
-	apiStatus, errWithCode := p.c.GetAPIStatus(ctx, requestingAccount, targetStatus)
-	if errWithCode != nil {
-		return nil, errWithCode
-	}
-
-	return []*apimodel.StatusEdit{
-		{
-			Content:          apiStatus.Content,
-			SpoilerText:      apiStatus.SpoilerText,
-			Sensitive:        apiStatus.Sensitive,
-			CreatedAt:        util.FormatISO8601(targetStatus.UpdatedAt),
-			Account:          apiStatus.Account,
-			Poll:             apiStatus.Poll,
-			MediaAttachments: apiStatus.MediaAttachments,
-			Emojis:           apiStatus.Emojis,
-		},
-	}, nil
-}
-
 // Get gets the given status, taking account of privacy settings and blocks etc.
 func (p *Processor) Get(ctx context.Context, requestingAccount *gtsmodel.Account, targetStatusID string) (*apimodel.Status, gtserror.WithCode) {
-	targetStatus, errWithCode := p.c.GetVisibleTargetStatus(ctx,
+	target, errWithCode := p.c.GetVisibleTargetStatus(ctx,
 		requestingAccount,
 		targetStatusID,
 		nil, // default freshness
@@ -67,44 +36,25 @@ func (p *Processor) Get(ctx context.Context, requestingAccount *gtsmodel.Account
 	if errWithCode != nil {
 		return nil, errWithCode
 	}
-	return p.c.GetAPIStatus(ctx, requestingAccount, targetStatus)
+	return p.c.GetAPIStatus(ctx, requestingAccount, target)
 }
 
 // SourceGet returns the *apimodel.StatusSource version of the targetStatusID.
 // Status must belong to the requester, and must not be a boost.
-func (p *Processor) SourceGet(ctx context.Context, requestingAccount *gtsmodel.Account, targetStatusID string) (*apimodel.StatusSource, gtserror.WithCode) {
-	targetStatus, errWithCode := p.c.GetVisibleTargetStatus(ctx,
-		requestingAccount,
-		targetStatusID,
-		nil, // default freshness
-	)
+func (p *Processor) SourceGet(ctx context.Context, requester *gtsmodel.Account, statusID string) (*apimodel.StatusSource, gtserror.WithCode) {
+	status, errWithCode := p.c.GetOwnStatus(ctx, requester, statusID)
 	if errWithCode != nil {
 		return nil, errWithCode
 	}
-
-	// Redirect to wrapped status if boost.
-	targetStatus, errWithCode = p.c.UnwrapIfBoost(
-		ctx,
-		requestingAccount,
-		targetStatus,
-	)
-	if errWithCode != nil {
-		return nil, errWithCode
-	}
-
-	if targetStatus.AccountID != requestingAccount.ID {
-		err := gtserror.Newf(
-			"status %s does not belong to account %s",
-			targetStatusID, requestingAccount.ID,
+	if status.BoostOfID != "" {
+		return nil, gtserror.NewErrorNotFound(
+			errors.New("status is a boost wrapper"),
+			"target status not found",
 		)
-		return nil, gtserror.NewErrorNotFound(err)
 	}
-
-	statusSource, err := p.converter.StatusToAPIStatusSource(ctx, targetStatus)
-	if err != nil {
-		err = gtserror.Newf("error converting status: %w", err)
-		return nil, gtserror.NewErrorInternalError(err)
-	}
-
-	return statusSource, nil
+	return &apimodel.StatusSource{
+		ID:          status.ID,
+		Text:        status.Text,
+		SpoilerText: status.ContentWarning,
+	}, nil
 }