move stuff around + further work on domain blocks

internal/api/client/admin/domainblock.go

@@ -57,3 +57,8 @@ func (m *Module) DomainBlocksPOSTHandler(c *gin.Context) {
 
 	c.JSON(http.StatusOK, domainBlock)
 }
+
+func validateCreateDomainBlock(form *model.DomainBlockCreateRequest) error {
+	// TODO: add some validation here later if necessary
+	return nil
+}

internal/api/model/domainblock.go

@@ -20,6 +20,7 @@ package model
 
 // DomainBlock represents a block on one domain
 type DomainBlock struct {
+	ID             string `json:"id"`
 	Domain         string `json:"domain"`
 	Obfuscate      bool   `json:"obfuscate"`
 	PrivateComment string `json:"private_comment"`

internal/gtsmodel/domainblock.go

@@ -25,7 +25,7 @@ type DomainBlock struct {
 	// ID of this block in the database
 	ID string `pg:"type:CHAR(26),pk,notnull,unique"`
 	// blocked domain
-	Domain string `pg:",notnull"`
+	Domain string `pg:",pk,notnull,unique"`
 	// When was this block created
 	CreatedAt time.Time `pg:"type:timestamp,notnull,default:now()"`
 	// When was this block updated

internal/gtsmodel/instance.go

@@ -7,7 +7,7 @@ type Instance struct {
 	// ID of this instance in the database
 	ID string `pg:"type:CHAR(26),pk,notnull,unique"`
 	// Instance domain eg example.org
-	Domain string `pg:",notnull,unique"`
+	Domain string `pg:",pk,notnull,unique"`
 	// Title of this instance as it would like to be displayed.
 	Title string
 	// base URI of this instance eg https://example.org

internal/processing/admin.go

@@ -19,55 +19,15 @@
 package processing
 
 import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-
 	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
-	"github.com/superseriousbusiness/gotosocial/internal/id"
+	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/oauth"
 )
 
 func (p *processor) AdminEmojiCreate(authed *oauth.Auth, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error) {
-	if !authed.User.Admin {
+	return p.adminProcessor.EmojiCreate(authed.Account, authed.User, form)
-		return nil, fmt.Errorf("user %s not an admin", authed.User.ID)
+}
-	}
+
-
+func (p *processor) AdminDomainBlockCreate(authed *oauth.Auth, form *apimodel.DomainBlockCreateRequest) (*apimodel.DomainBlock, gtserror.WithCode) {
-	// open the emoji and extract the bytes from it
+	return p.adminProcessor.DomainBlockCreate(authed.Account, form)
-	f, err := form.Image.Open()
-	if err != nil {
-		return nil, fmt.Errorf("error opening emoji: %s", err)
-	}
-	buf := new(bytes.Buffer)
-	size, err := io.Copy(buf, f)
-	if err != nil {
-		return nil, fmt.Errorf("error reading emoji: %s", err)
-	}
-	if size == 0 {
-		return nil, errors.New("could not read provided emoji: size 0 bytes")
-	}
-
-	// allow the mediaHandler to work its magic of processing the emoji bytes, and putting them in whatever storage backend we're using
-	emoji, err := p.mediaHandler.ProcessLocalEmoji(buf.Bytes(), form.Shortcode)
-	if err != nil {
-		return nil, fmt.Errorf("error reading emoji: %s", err)
-	}
-
-	emojiID, err := id.NewULID()
-	if err != nil {
-		return nil, err
-	}
-	emoji.ID = emojiID
-
-	mastoEmoji, err := p.tc.EmojiToMasto(emoji)
-	if err != nil {
-		return nil, fmt.Errorf("error converting emoji to mastotype: %s", err)
-	}
-
-	if err := p.db.Put(emoji); err != nil {
-		return nil, fmt.Errorf("database error while processing emoji: %s", err)
-	}
-
-	return &mastoEmoji, nil
 }

internal/processing/admin/admin.go

@@ -0,0 +1,55 @@
+/*
+   GoToSocial
+   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+   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 (
+	"github.com/sirupsen/logrus"
+	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/media"
+	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
+)
+
+// Processor wraps a bunch of functions for processing admin actions.
+type Processor interface {
+	DomainBlockCreate(account *gtsmodel.Account, form *apimodel.DomainBlockCreateRequest) (*apimodel.DomainBlock, gtserror.WithCode)
+	EmojiCreate(account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error)
+}
+
+type processor struct {
+	tc            typeutils.TypeConverter
+	config        *config.Config
+	mediaHandler  media.Handler
+	db            db.DB
+	log           *logrus.Logger
+}
+
+// New returns a new admin processor.
+func New(db db.DB, tc typeutils.TypeConverter, mediaHandler media.Handler, config *config.Config, log *logrus.Logger) Processor {
+	return &processor{
+		tc:            tc,
+		config:        config,
+		mediaHandler:  mediaHandler,
+		db:            db,
+		log:           log,
+	}
+}

internal/processing/admin/domainblock.go

@@ -0,0 +1,114 @@
+/*
+   GoToSocial
+   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+   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 (
+	"fmt"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	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"
+)
+
+func (p *processor) DomainBlockCreate(account *gtsmodel.Account, form *apimodel.DomainBlockCreateRequest) (*apimodel.DomainBlock, gtserror.WithCode) {
+	// first check if we already have a block -- if err == nil we already had a block so we can skip a whole lot of work
+	domainBlock := &gtsmodel.DomainBlock{}
+	err := p.db.GetWhere([]db.Where{{Key: "domain", Value: form.Domain, CaseInsensitive: true}}, domainBlock)
+	if err != nil {
+		if _, ok := err.(db.ErrNoEntries); ok {
+			// something went wrong in the DB
+			return nil, gtserror.NewErrorInternalError(fmt.Errorf("DomainBlockCreate: db error checking for existence of domain block %s: %s", form.Domain, err))
+		}
+
+		// there's no block for this domain yet so create one
+		// note: we take a new ulid from timestamp here in case we need to sort blocks
+		blockID, err := id.NewULID()
+		if err != nil {
+			return nil, gtserror.NewErrorInternalError(fmt.Errorf("DomainBlockCreate: error creating id for new domain block %s: %s", form.Domain, err))
+		}
+
+		domainBlock = &gtsmodel.DomainBlock{
+			ID:                 blockID,
+			Domain:             form.Domain,
+			CreatedByAccountID: account.ID,
+			PrivateComment:     form.PrivateComment,
+			PublicComment:      form.PublicComment,
+			Obfuscate:          form.Obfuscate,
+		}
+
+		// put the new block in the database
+		if err := p.db.Put(domainBlock); err != nil {
+			if _, ok := err.(db.ErrAlreadyExists); !ok {
+				// there's a real error creating the block
+				return nil, gtserror.NewErrorInternalError(fmt.Errorf("DomainBlockCreate: db error putting new domain block %s: %s", form.Domain, err))
+			}
+		}
+
+		// process the side effects of the domain block asynchronously since it might take a little while
+		go p.domainBlockProcessSideEffects(domainBlock) // TODO: add this to a queuing system so it can retry/resume
+	}
+
+	mastoDomainBlock, err := p.tc.DomainBlockToMasto(domainBlock)
+	if err != nil {
+		return nil, gtserror.NewErrorInternalError(fmt.Errorf("DomainBlockCreate: error converting domain block to frontend/masto representation %s: %s", form.Domain, err))
+	}
+
+	return mastoDomainBlock, nil
+}
+
+func (p *processor) domainBlockProcessSideEffects(block *gtsmodel.DomainBlock) {
+	l := p.log.WithFields(logrus.Fields{
+		"func": "domainBlockProcessSideEffects",
+		"domain": block.Domain,
+	})
+
+	l.Debug("processing domain block side effects")
+
+	// if we have an instance entry for this domain, update it with the new block ID and clear all fields
+	instance := &gtsmodel.Instance{}
+	if err := p.db.GetWhere([]db.Where{{Key: "domain", Value: block.Domain, CaseInsensitive: true}}, instance); err == nil {
+		instance.Title = ""
+		instance.UpdatedAt = time.Now()
+		instance.SuspendedAt = time.Now()
+		instance.DomainBlockID = block.ID
+		instance.ShortDescription = ""
+		instance.Description = ""
+		instance.Terms = ""
+		instance.ContactEmail = ""
+		instance.ContactAccountUsername = ""
+		instance.ContactAccountID = ""
+		instance.Version = ""
+		if err := p.db.UpdateByID(instance.ID, instance); err != nil {
+			l.Errorf("domainBlockProcessSideEffects: db error updating instance: %s", err)
+		}
+		l.Debug("instance entry updated")
+	}
+
+	// if we have an instance account for this instance, delete it
+	if err := p.db.DeleteWhere([]db.Where{{Key: "username", Value: block.Domain, CaseInsensitive: true}}, &gtsmodel.Account{}); err != nil {
+		l.Errorf("domainBlockProcessSideEffects: db error removing instance account: %s", err)
+	}
+
+	aaaaaaaaa
+	// TODO: delete accounts through the normal account deletion system (which should also delete media + posts + remove posts from timelines)
+}

internal/processing/admin/emoji.go

@@ -0,0 +1,73 @@
+/*
+   GoToSocial
+   Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+   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 (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+
+	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+	"github.com/superseriousbusiness/gotosocial/internal/id"
+)
+
+func (p *processor) EmojiCreate(account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error) {
+	if user.Admin {
+		return nil, fmt.Errorf("user %s not an admin", user.ID)
+	}
+
+	// open the emoji and extract the bytes from it
+	f, err := form.Image.Open()
+	if err != nil {
+		return nil, fmt.Errorf("error opening emoji: %s", err)
+	}
+	buf := new(bytes.Buffer)
+	size, err := io.Copy(buf, f)
+	if err != nil {
+		return nil, fmt.Errorf("error reading emoji: %s", err)
+	}
+	if size == 0 {
+		return nil, errors.New("could not read provided emoji: size 0 bytes")
+	}
+
+	// allow the mediaHandler to work its magic of processing the emoji bytes, and putting them in whatever storage backend we're using
+	emoji, err := p.mediaHandler.ProcessLocalEmoji(buf.Bytes(), form.Shortcode)
+	if err != nil {
+		return nil, fmt.Errorf("error reading emoji: %s", err)
+	}
+
+	emojiID, err := id.NewULID()
+	if err != nil {
+		return nil, err
+	}
+	emoji.ID = emojiID
+
+	mastoEmoji, err := p.tc.EmojiToMasto(emoji)
+	if err != nil {
+		return nil, fmt.Errorf("error converting emoji to mastotype: %s", err)
+	}
+
+	if err := p.db.Put(emoji); err != nil {
+		return nil, fmt.Errorf("database error while processing emoji: %s", err)
+	}
+
+	return &mastoEmoji, nil
+}

internal/processing/processor.go

@@ -32,8 +32,9 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 	"github.com/superseriousbusiness/gotosocial/internal/media"
 	"github.com/superseriousbusiness/gotosocial/internal/oauth"
-	"github.com/superseriousbusiness/gotosocial/internal/processing/synchronous/status"
+	"github.com/superseriousbusiness/gotosocial/internal/processing/admin"
-	"github.com/superseriousbusiness/gotosocial/internal/processing/synchronous/streaming"
+	"github.com/superseriousbusiness/gotosocial/internal/processing/status"
+	"github.com/superseriousbusiness/gotosocial/internal/processing/streaming"
 	"github.com/superseriousbusiness/gotosocial/internal/timeline"
 	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
 	"github.com/superseriousbusiness/gotosocial/internal/visibility"
@@ -81,6 +82,8 @@ type Processor interface {
 
 	// AdminEmojiCreate handles the creation of a new instance emoji by an admin, using the given form.
 	AdminEmojiCreate(authed *oauth.Auth, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error)
+	// AdminDomainBlockCreate handles the creation of a new domain block by an admin, using the given form.
+	AdminDomainBlockCreate(authed *oauth.Auth, form *apimodel.DomainBlockCreateRequest) (*apimodel.DomainBlock, gtserror.WithCode)
 
 	// AppCreate processes the creation of a new API application
 	AppCreate(authed *oauth.Auth, form *apimodel.ApplicationCreateRequest) (*apimodel.Application, error)
@@ -210,6 +213,7 @@ type processor struct {
 		SUB-PROCESSORS
 	*/
 
+	adminProcessor     admin.Processor
 	statusProcessor    status.Processor
 	streamingProcessor streaming.Processor
 }
@@ -222,6 +226,7 @@ func NewProcessor(config *config.Config, tc typeutils.TypeConverter, federator f
 
 	statusProcessor := status.New(db, tc, config, fromClientAPI, log)
 	streamingProcessor := streaming.New(db, tc, oauthServer, config, log)
+	adminProcessor := admin.New(db, tc, mediaHandler, config, log)
 
 	return &processor{
 		fromClientAPI:   fromClientAPI,
@@ -238,6 +243,7 @@ func NewProcessor(config *config.Config, tc typeutils.TypeConverter, federator f
 		db:              db,
 		filter:          visibility.NewFilter(db, log),
 
+		adminProcessor:     adminProcessor,
 		statusProcessor:    statusProcessor,
 		streamingProcessor: streamingProcessor,
 	}

internal/typeutils/converter.go

@@ -76,6 +76,8 @@ type TypeConverter interface {
 	RelationshipToMasto(r *gtsmodel.Relationship) (*model.Relationship, error)
 	// NotificationToMasto converts a gts notification into a mastodon notification
 	NotificationToMasto(n *gtsmodel.Notification) (*model.Notification, error)
+	// DomainBlockTomasto converts a gts model domin block into a mastodon domain block, for serving at /api/v1/admin/domain_blocks
+	DomainBlockToMasto(b *gtsmodel.DomainBlock) (*model.DomainBlock, error)
 
 	/*
 		FRONTEND (mastodon) MODEL TO INTERNAL (gts) MODEL

internal/typeutils/internaltofrontend.go

@@ -644,3 +644,16 @@ func (c *converter) NotificationToMasto(n *gtsmodel.Notification) (*model.Notifi
 		Status:    mastoStatus,
 	}, nil
 }
+
+func (c *converter) DomainBlockToMasto(b *gtsmodel.DomainBlock) (*model.DomainBlock, error) {
+	return &model.DomainBlock{
+		ID:             b.ID,
+		Domain:         b.Domain,
+		Obfuscate:      b.Obfuscate,
+		PrivateComment: b.PrivateComment,
+		PublicComment:  b.PublicComment,
+		SubscriptionID: b.SubscriptionID,
+		CreatedBy:      b.CreatedByAccountID,
+		CreatedAt:      b.CreatedAt.Format(time.RFC3339),
+	}, nil
+}