mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-11-30 15:42:46 +00:00
634 lines
18 KiB
Go
634 lines
18 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 admin
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"strings"
|
|
|
|
"codeberg.org/gruf/go-bytesize"
|
|
"codeberg.org/gruf/go-iotools"
|
|
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/media"
|
|
"github.com/superseriousbusiness/gotosocial/internal/util"
|
|
)
|
|
|
|
// EmojiCreate creates a custom emoji on this instance.
|
|
func (p *Processor) EmojiCreate(
|
|
ctx context.Context,
|
|
account *gtsmodel.Account,
|
|
form *apimodel.EmojiCreateRequest,
|
|
) (*apimodel.Emoji, gtserror.WithCode) {
|
|
|
|
// Get maximum supported local emoji size.
|
|
maxsz := int64(config.GetMediaEmojiLocalMaxSize()) // #nosec G115 -- Already validated.
|
|
|
|
// Ensure media within size bounds.
|
|
if form.Image.Size > maxsz {
|
|
text := fmt.Sprintf("emoji exceeds configured max size: %d", maxsz)
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Open multipart file reader.
|
|
mpfile, err := form.Image.Open()
|
|
if err != nil {
|
|
err := gtserror.Newf("error opening multipart file: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Wrap the multipart file reader to ensure is limited to max.
|
|
rc, _, _ := iotools.UpdateReadCloserLimit(mpfile, maxsz)
|
|
data := func(context.Context) (io.ReadCloser, error) {
|
|
return rc, nil
|
|
}
|
|
|
|
// Attempt to create the new local emoji.
|
|
emoji, errWithCode := p.createEmoji(ctx,
|
|
form.Shortcode,
|
|
form.CategoryName,
|
|
data,
|
|
)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
|
|
apiEmoji, err := p.converter.EmojiToAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return &apiEmoji, nil
|
|
}
|
|
|
|
// EmojisGet returns an admin view of custom
|
|
// emojis, filtered with the given parameters.
|
|
func (p *Processor) EmojisGet(
|
|
ctx context.Context,
|
|
account *gtsmodel.Account,
|
|
domain string,
|
|
includeDisabled bool,
|
|
includeEnabled bool,
|
|
shortcode string,
|
|
maxShortcodeDomain string,
|
|
minShortcodeDomain string,
|
|
limit int,
|
|
) (*apimodel.PageableResponse, gtserror.WithCode) {
|
|
emojis, err := p.state.DB.GetEmojisBy(ctx,
|
|
domain,
|
|
includeDisabled,
|
|
includeEnabled,
|
|
shortcode,
|
|
maxShortcodeDomain,
|
|
minShortcodeDomain,
|
|
limit,
|
|
)
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("db error: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
count := len(emojis)
|
|
if count == 0 {
|
|
return util.EmptyPageableResponse(), nil
|
|
}
|
|
|
|
items := make([]interface{}, 0, count)
|
|
for _, emoji := range emojis {
|
|
adminEmoji, err := p.converter.EmojiToAdminAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji to admin model emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
items = append(items, adminEmoji)
|
|
}
|
|
|
|
return util.PackagePageableResponse(util.PageableResponseParams{
|
|
Items: items,
|
|
Path: "api/v1/admin/custom_emojis",
|
|
NextMaxIDKey: "max_shortcode_domain",
|
|
NextMaxIDValue: emojis[count-1].ShortcodeDomain(),
|
|
PrevMinIDKey: "min_shortcode_domain",
|
|
PrevMinIDValue: emojis[0].ShortcodeDomain(),
|
|
Limit: limit,
|
|
ExtraQueryParams: []string{
|
|
emojisGetFilterParams(
|
|
shortcode,
|
|
domain,
|
|
includeDisabled,
|
|
includeEnabled,
|
|
),
|
|
},
|
|
})
|
|
}
|
|
|
|
// EmojiGet returns the admin view of
|
|
// one custom emoji with the given id.
|
|
func (p *Processor) EmojiGet(
|
|
ctx context.Context,
|
|
account *gtsmodel.Account,
|
|
id string,
|
|
) (*apimodel.AdminEmoji, gtserror.WithCode) {
|
|
emoji, err := p.state.DB.GetEmojiByID(ctx, id)
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("db error: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
if emoji == nil {
|
|
err := gtserror.Newf("no emoji with id %s found in the db", id)
|
|
return nil, gtserror.NewErrorNotFound(err)
|
|
}
|
|
|
|
adminEmoji, err := p.converter.EmojiToAdminAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji to admin api emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return adminEmoji, nil
|
|
}
|
|
|
|
// EmojiDelete deletes one *local* emoji
|
|
// from the database, with the given id.
|
|
func (p *Processor) EmojiDelete(
|
|
ctx context.Context,
|
|
id string,
|
|
) (*apimodel.AdminEmoji, gtserror.WithCode) {
|
|
emoji, err := p.state.DB.GetEmojiByID(ctx, id)
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("db error: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
if emoji == nil {
|
|
err := gtserror.Newf("no emoji with id %s found in the db", id)
|
|
return nil, gtserror.NewErrorNotFound(err)
|
|
}
|
|
|
|
if !emoji.IsLocal() {
|
|
err := fmt.Errorf("emoji with id %s was not a local emoji, will not delete", id)
|
|
return nil, gtserror.NewErrorBadRequest(err, err.Error())
|
|
}
|
|
|
|
// Convert to admin emoji before deletion,
|
|
// so we can return the deleted emoji.
|
|
adminEmoji, err := p.converter.EmojiToAdminAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji to admin api emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
if err := p.state.DB.DeleteEmojiByID(ctx, id); err != nil {
|
|
err := gtserror.Newf("db error deleting emoji %s: %w", id, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return adminEmoji, nil
|
|
}
|
|
|
|
// EmojiUpdate updates one emoji with the
|
|
// given id, using the provided form parameters.
|
|
func (p *Processor) EmojiUpdate(
|
|
ctx context.Context,
|
|
emojiID string,
|
|
form *apimodel.EmojiUpdateRequest,
|
|
) (*apimodel.AdminEmoji, gtserror.WithCode) {
|
|
|
|
// Get the emoji with given ID from the database.
|
|
emoji, err := p.state.DB.GetEmojiByID(ctx, emojiID)
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("error fetching emoji from db: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Check found.
|
|
if emoji == nil {
|
|
const text = "emoji not found"
|
|
return nil, gtserror.NewErrorNotFound(errors.New(text), text)
|
|
}
|
|
|
|
switch form.Type {
|
|
|
|
case apimodel.EmojiUpdateCopy:
|
|
return p.emojiUpdateCopy(ctx, emoji, form.Shortcode, form.CategoryName)
|
|
|
|
case apimodel.EmojiUpdateDisable:
|
|
return p.emojiUpdateDisable(ctx, emoji)
|
|
|
|
case apimodel.EmojiUpdateModify:
|
|
return p.emojiUpdateModify(ctx, emoji, form.Image, form.CategoryName)
|
|
|
|
default:
|
|
const text = "unrecognized emoji update action type"
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
}
|
|
|
|
// EmojiCategoriesGet returns all custom emoji
|
|
// categories that exist on this instance.
|
|
func (p *Processor) EmojiCategoriesGet(
|
|
ctx context.Context,
|
|
) ([]*apimodel.EmojiCategory, gtserror.WithCode) {
|
|
categories, err := p.state.DB.GetEmojiCategories(ctx)
|
|
if err != nil {
|
|
err := gtserror.Newf("db error getting emoji categories: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
apiCategories := make([]*apimodel.EmojiCategory, 0, len(categories))
|
|
for _, category := range categories {
|
|
apiCategory, err := p.converter.EmojiCategoryToAPIEmojiCategory(ctx, category)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji category to api emoji category: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
apiCategories = append(apiCategories, apiCategory)
|
|
}
|
|
|
|
return apiCategories, nil
|
|
}
|
|
|
|
// emojiUpdateCopy copies and stores the given
|
|
// *remote* emoji as a *local* emoji, preserving
|
|
// the same image, and using the provided shortcode.
|
|
//
|
|
// The provided emoji model must correspond to an
|
|
// emoji already stored in the database + storage.
|
|
func (p *Processor) emojiUpdateCopy(
|
|
ctx context.Context,
|
|
target *gtsmodel.Emoji,
|
|
shortcode *string,
|
|
categoryName *string,
|
|
) (*apimodel.AdminEmoji, gtserror.WithCode) {
|
|
if target.IsLocal() {
|
|
const text = "target emoji is not remote; cannot copy to local"
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Ensure target emoji is locally cached.
|
|
target, err := p.federator.RecacheEmoji(ctx,
|
|
target,
|
|
)
|
|
if err != nil {
|
|
err := gtserror.Newf("error recaching emoji %s: %w", target.ImageRemoteURL, err)
|
|
return nil, gtserror.NewErrorNotFound(err)
|
|
}
|
|
|
|
// Get maximum supported local emoji size.
|
|
maxsz := config.GetMediaEmojiLocalMaxSize()
|
|
|
|
// Ensure target emoji image within size bounds.
|
|
if bytesize.Size(target.ImageFileSize) > maxsz {
|
|
text := fmt.Sprintf("emoji exceeds configured max size: %s", maxsz)
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Data function for copying just streams media
|
|
// out of storage into an additional location.
|
|
//
|
|
// This means that data for the copy persists even
|
|
// if the remote copied emoji gets deleted at some point.
|
|
data := func(ctx context.Context) (io.ReadCloser, error) {
|
|
rc, err := p.state.Storage.GetStream(ctx, target.ImagePath)
|
|
return rc, err
|
|
}
|
|
|
|
// Attempt to create the new local emoji.
|
|
emoji, errWithCode := p.createEmoji(ctx,
|
|
util.PtrOrZero(shortcode),
|
|
util.PtrOrZero(categoryName),
|
|
data,
|
|
)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
|
|
apiEmoji, err := p.converter.EmojiToAdminAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return apiEmoji, nil
|
|
}
|
|
|
|
// emojiUpdateDisable marks the given *remote*
|
|
// emoji as disabled by setting disabled = true.
|
|
//
|
|
// The provided emoji model must correspond to an
|
|
// emoji already stored in the database + storage.
|
|
func (p *Processor) emojiUpdateDisable(
|
|
ctx context.Context,
|
|
emoji *gtsmodel.Emoji,
|
|
) (*apimodel.AdminEmoji, gtserror.WithCode) {
|
|
if emoji.IsLocal() {
|
|
err := fmt.Errorf("emoji %s is not a remote emoji, cannot disable it via this endpoint", emoji.ID)
|
|
return nil, gtserror.NewErrorBadRequest(err, err.Error())
|
|
}
|
|
|
|
// Only bother with a db call
|
|
// if emoji not already disabled.
|
|
if !*emoji.Disabled {
|
|
emoji.Disabled = util.Ptr(true)
|
|
if err := p.state.DB.UpdateEmoji(ctx, emoji, "disabled"); err != nil {
|
|
err := gtserror.Newf("db error updating emoji %s: %w", emoji.ID, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
}
|
|
|
|
adminEmoji, err := p.converter.EmojiToAdminAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return adminEmoji, nil
|
|
}
|
|
|
|
// emojiUpdateModify modifies the given *local* emoji.
|
|
//
|
|
// Either one of image or category must be non-nil,
|
|
// otherwise there's nothing to modify. If category
|
|
// is non-nil and dereferences to an empty string,
|
|
// category will be cleared.
|
|
//
|
|
// The provided emoji model must correspond to an
|
|
// emoji already stored in the database + storage.
|
|
func (p *Processor) emojiUpdateModify(
|
|
ctx context.Context,
|
|
emoji *gtsmodel.Emoji,
|
|
image *multipart.FileHeader,
|
|
categoryName *string,
|
|
) (*apimodel.AdminEmoji, gtserror.WithCode) {
|
|
if !emoji.IsLocal() {
|
|
const text = "cannot modify remote emoji"
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Ensure there's actually something to update.
|
|
if image == nil && categoryName == nil {
|
|
const text = "no changes were provided"
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Check if we need to
|
|
// set a new category ID.
|
|
var newCategoryID *string
|
|
switch {
|
|
case categoryName == nil:
|
|
// No changes.
|
|
|
|
case *categoryName == "":
|
|
// Emoji category was unset.
|
|
newCategoryID = util.Ptr("")
|
|
emoji.CategoryID = ""
|
|
emoji.Category = nil
|
|
|
|
case *categoryName != "":
|
|
// A category was provided, get or create relevant emoji category.
|
|
category, errWithCode := p.mustGetEmojiCategory(ctx, *categoryName)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
|
|
// Update emoji category if
|
|
// it's different from before.
|
|
if category.ID != emoji.CategoryID {
|
|
newCategoryID = &category.ID
|
|
emoji.CategoryID = category.ID
|
|
emoji.Category = category
|
|
}
|
|
}
|
|
|
|
// Check whether any image changes were requested.
|
|
imageUpdated := (image != nil && image.Size > 0)
|
|
|
|
if !imageUpdated && newCategoryID != nil {
|
|
// Only updating category; only a single database update required.
|
|
if err := p.state.DB.UpdateEmoji(ctx, emoji, "category_id"); err != nil {
|
|
err := gtserror.Newf("error updating emoji in db: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
} else if imageUpdated {
|
|
var err error
|
|
|
|
// Updating image and maybe categoryID.
|
|
// We can do both at the same time :)
|
|
|
|
// Get maximum supported local emoji size.
|
|
maxsz := int64(config.GetMediaEmojiLocalMaxSize()) // #nosec G115 -- Already validated.
|
|
|
|
// Ensure media within size bounds.
|
|
if image.Size > maxsz {
|
|
text := fmt.Sprintf("emoji exceeds configured max size: %d", maxsz)
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Open multipart file reader.
|
|
mpfile, err := image.Open()
|
|
if err != nil {
|
|
err := gtserror.Newf("error opening multipart file: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Wrap the multipart file reader to ensure is limited to max.
|
|
rc, _, _ := iotools.UpdateReadCloserLimit(mpfile, maxsz)
|
|
data := func(context.Context) (io.ReadCloser, error) {
|
|
return rc, nil
|
|
}
|
|
|
|
// Include category ID
|
|
// update if necessary.
|
|
ai := media.AdditionalEmojiInfo{}
|
|
ai.CategoryID = newCategoryID
|
|
|
|
// Prepare emoji model for update+recache from new data.
|
|
processing, err := p.media.UpdateEmoji(ctx, emoji, data, ai)
|
|
if err != nil {
|
|
err := gtserror.Newf("error preparing recache: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
// Load to trigger update + write.
|
|
emoji, err = processing.Load(ctx)
|
|
if err != nil {
|
|
err := gtserror.Newf("error processing emoji %s: %w", emoji.Shortcode, err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
}
|
|
|
|
adminEmoji, err := p.converter.EmojiToAdminAPIEmoji(ctx, emoji)
|
|
if err != nil {
|
|
err := gtserror.Newf("error converting emoji: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return adminEmoji, nil
|
|
}
|
|
|
|
// createEmoji will create a new local emoji
|
|
// with the given shortcode, attached category
|
|
// name (if any) and data source function.
|
|
func (p *Processor) createEmoji(
|
|
ctx context.Context,
|
|
shortcode string,
|
|
categoryName string,
|
|
data media.DataFunc,
|
|
) (
|
|
*gtsmodel.Emoji,
|
|
gtserror.WithCode,
|
|
) {
|
|
// Validate shortcode.
|
|
if shortcode == "" {
|
|
const text = "empty shortcode name"
|
|
return nil, gtserror.NewErrorBadRequest(errors.New(text), text)
|
|
}
|
|
|
|
// Look for an existing local emoji with shortcode to ensure this is new.
|
|
existing, err := p.state.DB.GetEmojiByShortcodeDomain(ctx, shortcode, "")
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("error fetching emoji from db: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
} else if existing != nil {
|
|
const text = "emoji with shortcode already exists"
|
|
return nil, gtserror.NewErrorConflict(errors.New(text), text)
|
|
}
|
|
|
|
var categoryID *string
|
|
|
|
if categoryName != "" {
|
|
// A category was provided, get / create relevant emoji category.
|
|
category, errWithCode := p.mustGetEmojiCategory(ctx, categoryName)
|
|
if errWithCode != nil {
|
|
return nil, errWithCode
|
|
}
|
|
|
|
// Set category ID for emoji.
|
|
categoryID = &category.ID
|
|
}
|
|
|
|
// Store to instance storage.
|
|
return p.c.StoreLocalEmoji(
|
|
ctx,
|
|
shortcode,
|
|
data,
|
|
media.AdditionalEmojiInfo{
|
|
CategoryID: categoryID,
|
|
},
|
|
)
|
|
}
|
|
|
|
// mustGetEmojiCategory either gets an existing
|
|
// category with the given name from the database,
|
|
// or, if the category doesn't yet exist, it creates
|
|
// the category and then returns it.
|
|
func (p *Processor) mustGetEmojiCategory(
|
|
ctx context.Context,
|
|
name string,
|
|
) (
|
|
*gtsmodel.EmojiCategory,
|
|
gtserror.WithCode,
|
|
) {
|
|
// Look for an existing emoji category with name.
|
|
category, err := p.state.DB.GetEmojiCategoryByName(ctx, name)
|
|
if err != nil && !errors.Is(err, db.ErrNoEntries) {
|
|
err := gtserror.Newf("error fetching emoji category from db: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
if category != nil {
|
|
// We had it already.
|
|
return category, nil
|
|
}
|
|
|
|
// Create new ID.
|
|
id := id.NewULID()
|
|
|
|
// Prepare new category for insertion.
|
|
category = >smodel.EmojiCategory{
|
|
ID: id,
|
|
Name: name,
|
|
}
|
|
|
|
// Insert new category into the database.
|
|
err = p.state.DB.PutEmojiCategory(ctx, category)
|
|
if err != nil {
|
|
err := gtserror.Newf("error inserting emoji category into db: %w", err)
|
|
return nil, gtserror.NewErrorInternalError(err)
|
|
}
|
|
|
|
return category, nil
|
|
}
|
|
|
|
// emojisGetFilterParams builds extra
|
|
// query parameters to return as part
|
|
// of an Emojis pageable response.
|
|
//
|
|
// The returned string will look like:
|
|
//
|
|
// "filter=domain:all,enabled,shortcode:example"
|
|
func emojisGetFilterParams(
|
|
shortcode string,
|
|
domain string,
|
|
includeDisabled bool,
|
|
includeEnabled bool,
|
|
) string {
|
|
var filterBuilder strings.Builder
|
|
filterBuilder.WriteString("filter=")
|
|
|
|
switch domain {
|
|
case "", "local":
|
|
// Local emojis only.
|
|
filterBuilder.WriteString("domain:local")
|
|
|
|
case db.EmojiAllDomains:
|
|
// Local or remote.
|
|
filterBuilder.WriteString("domain:all")
|
|
|
|
default:
|
|
// Specific domain only.
|
|
filterBuilder.WriteString("domain:" + domain)
|
|
}
|
|
|
|
if includeDisabled != includeEnabled {
|
|
if includeDisabled {
|
|
filterBuilder.WriteString(",disabled")
|
|
}
|
|
if includeEnabled {
|
|
filterBuilder.WriteString(",enabled")
|
|
}
|
|
}
|
|
|
|
if shortcode != "" {
|
|
// Specific shortcode only.
|
|
filterBuilder.WriteString(",shortcode:" + shortcode)
|
|
}
|
|
|
|
return filterBuilder.String()
|
|
}
|