diff --git a/PROGRESS.md b/PROGRESS.md index 94354472b..4ccf1e99f 100644 --- a/PROGRESS.md +++ b/PROGRESS.md @@ -73,7 +73,7 @@ * [x] /api/v1/statuses/:id GET (View an existing status) * [x] /api/v1/statuses/:id DELETE (Delete a status) * [ ] /api/v1/statuses/:id/context GET (View statuses above and below status ID) - * [ ] /api/v1/statuses/:id/reblogged_by GET (See who has reblogged a status) + * [x] /api/v1/statuses/:id/reblogged_by GET (See who has reblogged a status) * [x] /api/v1/statuses/:id/favourited_by GET (See who has faved a status) * [x] /api/v1/statuses/:id/favourite POST (Fave a status) * [x] /api/v1/statuses/:id/unfavourite POST (Unfave a status) @@ -98,7 +98,7 @@ * [ ] /api/v1/scheduled_statuses/:id PUT (Schedule a status) * [ ] /api/v1/scheduled_statuses/:id DELETE (Cancel a scheduled status) * [ ] Timelines - * [ ] /api/v1/timelines/public GET (See the public/federated timeline) + * [x] /api/v1/timelines/public GET (See the public/federated timeline) * [ ] /api/v1/timelines/tag/:hashtag GET (Get public statuses that use hashtag) * [x] /api/v1/timelines/home GET (View statuses from followed users) * [ ] /api/v1/timelines/list/:list_id GET (Get statuses in given list) diff --git a/internal/api/client/emoji/emoji.go b/internal/api/client/emoji/emoji.go new file mode 100644 index 000000000..f30816176 --- /dev/null +++ b/internal/api/client/emoji/emoji.go @@ -0,0 +1,56 @@ +/* + 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 . +*/ + +package emoji + +import ( + "net/http" + + "github.com/sirupsen/logrus" + "github.com/superseriousbusiness/gotosocial/internal/api" + "github.com/superseriousbusiness/gotosocial/internal/config" + "github.com/superseriousbusiness/gotosocial/internal/processing" + "github.com/superseriousbusiness/gotosocial/internal/router" +) + +const ( + // BasePath is the base path for serving the emoji API + BasePath = "/api/v1/custom_emojis" +) + +// Module implements the ClientAPIModule interface for everything related to emoji +type Module struct { + config *config.Config + processor processing.Processor + log *logrus.Logger +} + +// New returns a new emoji module +func New(config *config.Config, processor processing.Processor, log *logrus.Logger) api.ClientModule { + return &Module{ + config: config, + processor: processor, + log: log, + } +} + +// Route attaches all routes from this module to the given router +func (m *Module) Route(r router.Router) error { + r.AttachHandler(http.MethodGet, BasePath, m.EmojisGETHandler) + return nil +} diff --git a/internal/api/client/emoji/emojisget.go b/internal/api/client/emoji/emojisget.go new file mode 100644 index 000000000..e4efb8825 --- /dev/null +++ b/internal/api/client/emoji/emojisget.go @@ -0,0 +1,8 @@ +package emoji + +import "github.com/gin-gonic/gin" + +// EmojisGETHandler returns a list of custom emojis enabled on the instance +func (m *Module) EmojisGETHandler(c *gin.Context) { + +} diff --git a/internal/api/client/filter/filter.go b/internal/api/client/filter/filter.go new file mode 100644 index 000000000..1a8421d26 --- /dev/null +++ b/internal/api/client/filter/filter.go @@ -0,0 +1,56 @@ +/* + 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 . +*/ + +package filter + +import ( + "net/http" + + "github.com/sirupsen/logrus" + "github.com/superseriousbusiness/gotosocial/internal/api" + "github.com/superseriousbusiness/gotosocial/internal/config" + "github.com/superseriousbusiness/gotosocial/internal/processing" + "github.com/superseriousbusiness/gotosocial/internal/router" +) + +const ( + // BasePath is the base path for serving the filter API + BasePath = "/api/v1/filters" +) + +// Module implements the ClientAPIModule interface for every related to filters +type Module struct { + config *config.Config + processor processing.Processor + log *logrus.Logger +} + +// New returns a new filter module +func New(config *config.Config, processor processing.Processor, log *logrus.Logger) api.ClientModule { + return &Module{ + config: config, + processor: processor, + log: log, + } +} + +// Route attaches all routes from this module to the given router +func (m *Module) Route(r router.Router) error { + r.AttachHandler(http.MethodGet, BasePath, m.FiltersGETHandler) + return nil +} diff --git a/internal/api/client/filter/filtersget.go b/internal/api/client/filter/filtersget.go new file mode 100644 index 000000000..ad9783eb2 --- /dev/null +++ b/internal/api/client/filter/filtersget.go @@ -0,0 +1,8 @@ +package filter + +import "github.com/gin-gonic/gin" + +// FiltersGETHandler returns a list of filters set by/for the authed account +func (m *Module) FiltersGETHandler(c *gin.Context) { + +} diff --git a/internal/api/client/list/list.go b/internal/api/client/list/list.go new file mode 100644 index 000000000..4f800a46e --- /dev/null +++ b/internal/api/client/list/list.go @@ -0,0 +1,56 @@ +/* + 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 . +*/ + +package list + +import ( + "net/http" + + "github.com/sirupsen/logrus" + "github.com/superseriousbusiness/gotosocial/internal/api" + "github.com/superseriousbusiness/gotosocial/internal/config" + "github.com/superseriousbusiness/gotosocial/internal/processing" + "github.com/superseriousbusiness/gotosocial/internal/router" +) + +const ( + // BasePath is the base path for serving the lists API + BasePath = "/api/v1/lists" +) + +// Module implements the ClientAPIModule interface for everything related to lists +type Module struct { + config *config.Config + processor processing.Processor + log *logrus.Logger +} + +// New returns a new list module +func New(config *config.Config, processor processing.Processor, log *logrus.Logger) api.ClientModule { + return &Module{ + config: config, + processor: processor, + log: log, + } +} + +// Route attaches all routes from this module to the given router +func (m *Module) Route(r router.Router) error { + r.AttachHandler(http.MethodGet, BasePath, m.ListsGETHandler) + return nil +} diff --git a/internal/api/client/list/listsgets.go b/internal/api/client/list/listsgets.go new file mode 100644 index 000000000..fd695454b --- /dev/null +++ b/internal/api/client/list/listsgets.go @@ -0,0 +1,8 @@ +package list + +import "github.com/gin-gonic/gin" + +// ListsGETHandler returns a list of lists created by/for the authed account +func (m *Module) ListsGETHandler(c *gin.Context) { + +} diff --git a/internal/api/client/notification/notification.go b/internal/api/client/notification/notification.go index 799d0a5e3..758fe505c 100644 --- a/internal/api/client/notification/notification.go +++ b/internal/api/client/notification/notification.go @@ -41,6 +41,8 @@ MaxIDKey = "max_id" // LimitKey is for specifying maximum number of notifications to return. LimitKey = "limit" + // SinceIDKey is for specifying the minimum notification ID to return. + SinceIDKey = "since_id" ) // Module implements the ClientAPIModule interface for every related to posting/deleting/interacting with notifications diff --git a/internal/api/client/notification/notificationsget.go b/internal/api/client/notification/notificationsget.go index a2d049384..a30674750 100644 --- a/internal/api/client/notification/notificationsget.go +++ b/internal/api/client/notification/notificationsget.go @@ -62,7 +62,13 @@ func (m *Module) NotificationsGETHandler(c *gin.Context) { maxID = maxIDString } - notifs, errWithCode := m.processor.NotificationsGet(authed, limit, maxID) + sinceID := "" + sinceIDString := c.Query(SinceIDKey) + if sinceIDString != "" { + sinceID = sinceIDString + } + + notifs, errWithCode := m.processor.NotificationsGet(authed, limit, maxID, sinceID) if errWithCode != nil { l.Debugf("error processing notifications get: %s", errWithCode.Error()) c.JSON(errWithCode.Code(), gin.H{"error": errWithCode.Safe()}) diff --git a/internal/api/client/status/status.go b/internal/api/client/status/status.go index e71764eb1..c5959edb0 100644 --- a/internal/api/client/status/status.go +++ b/internal/api/client/status/status.go @@ -95,8 +95,12 @@ func (m *Module) Route(r router.Router) error { r.AttachHandler(http.MethodPost, FavouritePath, m.StatusFavePOSTHandler) r.AttachHandler(http.MethodPost, UnfavouritePath, m.StatusUnfavePOSTHandler) + r.AttachHandler(http.MethodGet, FavouritedPath, m.StatusFavedByGETHandler) r.AttachHandler(http.MethodPost, ReblogPath, m.StatusBoostPOSTHandler) + r.AttachHandler(http.MethodGet, RebloggedPath, m.StatusBoostedByGETHandler) + + r.AttachHandler(http.MethodGet, ContextPath, m.StatusContextGETHandler) r.AttachHandler(http.MethodGet, BasePathWithID, m.muxHandler) return nil diff --git a/internal/api/client/status/statusboosted_by.go b/internal/api/client/status/statusboosted_by.go new file mode 100644 index 000000000..debcc1b22 --- /dev/null +++ b/internal/api/client/status/statusboosted_by.go @@ -0,0 +1,60 @@ +/* + 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 . +*/ + +package status + +import ( + "net/http" + + "github.com/gin-gonic/gin" + "github.com/sirupsen/logrus" + "github.com/superseriousbusiness/gotosocial/internal/oauth" +) + +// StatusBoostedByGETHandler is for serving a list of accounts that have boosted/reblogged a given status +func (m *Module) StatusBoostedByGETHandler(c *gin.Context) { + l := m.log.WithFields(logrus.Fields{ + "func": "StatusBoostedByGETHandler", + "request_uri": c.Request.RequestURI, + "user_agent": c.Request.UserAgent(), + "origin_ip": c.ClientIP(), + }) + l.Debugf("entering function") + + authed, err := oauth.Authed(c, true, true, true, true) // we don't really need an app here but we want everything else + if err != nil { + l.Errorf("error authing status boosted by request: %s", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "not authed"}) + return + } + + targetStatusID := c.Param(IDKey) + if targetStatusID == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "no status id provided"}) + return + } + + mastoAccounts, err := m.processor.StatusBoostedBy(authed, targetStatusID) + if err != nil { + l.Debugf("error processing status boosted by request: %s", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "bad request"}) + return + } + + c.JSON(http.StatusOK, mastoAccounts) +} diff --git a/internal/api/client/status/statuscontext.go b/internal/api/client/status/statuscontext.go new file mode 100644 index 000000000..83071f4a0 --- /dev/null +++ b/internal/api/client/status/statuscontext.go @@ -0,0 +1,60 @@ +/* + 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 . +*/ + +package status + +import ( + "net/http" + + "github.com/gin-gonic/gin" + "github.com/sirupsen/logrus" + "github.com/superseriousbusiness/gotosocial/internal/oauth" +) + +// StatusContextGETHandler returns the context around the given status ID. +func (m *Module) StatusContextGETHandler(c *gin.Context) { + l := m.log.WithFields(logrus.Fields{ + "func": "StatusContextGETHandler", + "request_uri": c.Request.RequestURI, + "user_agent": c.Request.UserAgent(), + "origin_ip": c.ClientIP(), + }) + l.Debugf("entering function") + + authed, err := oauth.Authed(c, true, true, true, true) + if err != nil { + l.Errorf("error authing status context request: %s", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "not authed"}) + return + } + + targetStatusID := c.Param(IDKey) + if targetStatusID == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "no status id provided"}) + return + } + + statusContext, errWithCode := m.processor.StatusGetContext(authed, targetStatusID) + if errWithCode != nil { + l.Debugf("error getting status context: %s", errWithCode.Error()) + c.JSON(errWithCode.Code(), gin.H{"error": errWithCode.Safe()}) + return + } + + c.JSON(http.StatusOK, statusContext) +} diff --git a/internal/api/client/timeline/home.go b/internal/api/client/timeline/home.go index c1f9ae5d2..977a464a0 100644 --- a/internal/api/client/timeline/home.go +++ b/internal/api/client/timeline/home.go @@ -36,7 +36,7 @@ // limit -- show only limit number of statuses // local -- Return only local statuses? func (m *Module) HomeTimelineGETHandler(c *gin.Context) { - l := m.log.WithField("func", "AccountStatusesGETHandler") + l := m.log.WithField("func", "HomeTimelineGETHandler") authed, err := oauth.Authed(c, true, true, true, true) if err != nil { diff --git a/internal/api/client/timeline/public.go b/internal/api/client/timeline/public.go new file mode 100644 index 000000000..f4b233064 --- /dev/null +++ b/internal/api/client/timeline/public.go @@ -0,0 +1,92 @@ +/* + 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 . +*/ + +package timeline + +import ( + "net/http" + "strconv" + + "github.com/gin-gonic/gin" + "github.com/superseriousbusiness/gotosocial/internal/oauth" +) + +// PublicTimelineGETHandler handles PUBLIC timeline requests. +// This includes requests to local, which are actually just public +// requests with a filter. +func (m *Module) PublicTimelineGETHandler(c *gin.Context) { + l := m.log.WithField("func", "PublicTimelineGETHandler") + + authed, err := oauth.Authed(c, true, true, true, true) + if err != nil { + l.Debugf("error authing: %s", err) + c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"}) + return + } + + maxID := "" + maxIDString := c.Query(MaxIDKey) + if maxIDString != "" { + maxID = maxIDString + } + + sinceID := "" + sinceIDString := c.Query(SinceIDKey) + if sinceIDString != "" { + sinceID = sinceIDString + } + + minID := "" + minIDString := c.Query(MinIDKey) + if minIDString != "" { + minID = minIDString + } + + limit := 20 + limitString := c.Query(LimitKey) + if limitString != "" { + i, err := strconv.ParseInt(limitString, 10, 64) + if err != nil { + l.Debugf("error parsing limit string: %s", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "couldn't parse limit query param"}) + return + } + limit = int(i) + } + + local := false + localString := c.Query(LocalKey) + if localString != "" { + i, err := strconv.ParseBool(localString) + if err != nil { + l.Debugf("error parsing local string: %s", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "couldn't parse local query param"}) + return + } + local = i + } + + statuses, errWithCode := m.processor.PublicTimelineGet(authed, maxID, sinceID, minID, limit, local) + if errWithCode != nil { + l.Debugf("error from processor account statuses get: %s", errWithCode) + c.JSON(errWithCode.Code(), gin.H{"error": errWithCode.Safe()}) + return + } + + c.JSON(http.StatusOK, statuses) +} diff --git a/internal/api/client/timeline/timeline.go b/internal/api/client/timeline/timeline.go index f563d6b7d..72c9357b1 100644 --- a/internal/api/client/timeline/timeline.go +++ b/internal/api/client/timeline/timeline.go @@ -1,5 +1,3 @@ -package timeline - /* GoToSocial Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org @@ -18,6 +16,8 @@ along with this program. If not, see . */ +package timeline + import ( "net/http" @@ -33,6 +33,8 @@ BasePath = "/api/v1/timelines" // HomeTimeline is the path for the home timeline HomeTimeline = BasePath + "/home" + // PublicTimeline is the path for the public (and public local) timeline + PublicTimeline = BasePath + "/public" // MaxIDKey is the url query for setting a max status ID to return MaxIDKey = "max_id" // SinceIDKey is the url query for returning results newer than the given ID @@ -64,5 +66,6 @@ func New(config *config.Config, processor processing.Processor, log *logrus.Logg // Route attaches all routes from this module to the given router func (m *Module) Route(r router.Router) error { r.AttachHandler(http.MethodGet, HomeTimeline, m.HomeTimelineGETHandler) + r.AttachHandler(http.MethodGet, PublicTimeline, m.PublicTimelineGETHandler) return nil } diff --git a/internal/cliactions/server/server.go b/internal/cliactions/server/server.go index 75337009a..bfb2751ce 100644 --- a/internal/cliactions/server/server.go +++ b/internal/cliactions/server/server.go @@ -14,9 +14,12 @@ "github.com/superseriousbusiness/gotosocial/internal/api/client/admin" "github.com/superseriousbusiness/gotosocial/internal/api/client/app" "github.com/superseriousbusiness/gotosocial/internal/api/client/auth" + "github.com/superseriousbusiness/gotosocial/internal/api/client/emoji" "github.com/superseriousbusiness/gotosocial/internal/api/client/fileserver" + "github.com/superseriousbusiness/gotosocial/internal/api/client/filter" "github.com/superseriousbusiness/gotosocial/internal/api/client/followrequest" "github.com/superseriousbusiness/gotosocial/internal/api/client/instance" + "github.com/superseriousbusiness/gotosocial/internal/api/client/list" mediaModule "github.com/superseriousbusiness/gotosocial/internal/api/client/media" "github.com/superseriousbusiness/gotosocial/internal/api/client/notification" "github.com/superseriousbusiness/gotosocial/internal/api/client/search" @@ -107,6 +110,9 @@ timelineModule := timeline.New(c, processor, log) notificationModule := notification.New(c, processor, log) searchModule := search.New(c, processor, log) + filtersModule := filter.New(c, processor, log) + emojiModule := emoji.New(c, processor, log) + listsModule := list.New(c, processor, log) mm := mediaModule.New(c, processor, log) fileServerModule := fileserver.New(c, processor, log) adminModule := admin.New(c, processor, log) @@ -132,6 +138,9 @@ timelineModule, notificationModule, searchModule, + filtersModule, + emojiModule, + listsModule, } for _, m := range apis { diff --git a/internal/db/db.go b/internal/db/db.go index 31a8ba5d9..1774420c6 100644 --- a/internal/db/db.go +++ b/internal/db/db.go @@ -253,12 +253,20 @@ type DB interface { // This slice will be unfiltered, not taking account of blocks and whatnot, so filter it before serving it back to a user. WhoFavedStatus(status *gtsmodel.Status) ([]*gtsmodel.Account, error) + // WhoBoostedStatus returns a slice of accounts who boosted the given status. + // This slice will be unfiltered, not taking account of blocks and whatnot, so filter it before serving it back to a user. + WhoBoostedStatus(status *gtsmodel.Status) ([]*gtsmodel.Account, error) + // GetHomeTimelineForAccount fetches the account's HOME timeline -- ie., posts and replies from people they *follow*. // It will use the given filters and try to return as many statuses up to the limit as possible. GetHomeTimelineForAccount(accountID string, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error) + // GetPublicTimelineForAccount fetches the account's PUBLIC timline -- ie., posts and replies that are public. + // It will use the given filters and try to return as many statuses as possible up to the limit. + GetPublicTimelineForAccount(accountID string, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error) + // GetNotificationsForAccount returns a list of notifications that pertain to the given accountID. - GetNotificationsForAccount(accountID string, limit int, maxID string) ([]*gtsmodel.Notification, error) + GetNotificationsForAccount(accountID string, limit int, maxID string, sinceID string) ([]*gtsmodel.Notification, error) /* USEFUL CONVERSION FUNCTIONS diff --git a/internal/db/pg/pg.go b/internal/db/pg/pg.go index f352404aa..c2bb7032b 100644 --- a/internal/db/pg/pg.go +++ b/internal/db/pg/pg.go @@ -1115,11 +1115,36 @@ func (ps *postgresService) WhoFavedStatus(status *gtsmodel.Status) ([]*gtsmodel. return accounts, nil } +func (ps *postgresService) WhoBoostedStatus(status *gtsmodel.Status) ([]*gtsmodel.Account, error) { + accounts := []*gtsmodel.Account{} + + boosts := []*gtsmodel.Status{} + if err := ps.conn.Model(&boosts).Where("boost_of_id = ?", status.ID).Select(); err != nil { + if err == pg.ErrNoRows { + return accounts, nil // no rows just means nobody has boosted this status, so that's fine + } + return nil, err // an actual error has occurred + } + + for _, f := range boosts { + acc := >smodel.Account{} + if err := ps.conn.Model(acc).Where("id = ?", f.AccountID).Select(); err != nil { + if err == pg.ErrNoRows { + continue // the account doesn't exist for some reason??? but this isn't the place to worry about that so just skip it + } + return nil, err // an actual error has occurred + } + accounts = append(accounts, acc) + } + return accounts, nil +} + func (ps *postgresService) GetHomeTimelineForAccount(accountID string, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error) { statuses := []*gtsmodel.Status{} - q := ps.conn.Model(&statuses). - ColumnExpr("status.*"). + q := ps.conn.Model(&statuses) + + q = q.ColumnExpr("status.*"). Join("JOIN follows AS f ON f.target_account_id = status.account_id"). Where("f.account_id = ?", accountID). Limit(limit). @@ -1133,6 +1158,22 @@ func (ps *postgresService) GetHomeTimelineForAccount(accountID string, maxID str q = q.Where("status.created_at < ?", s.CreatedAt) } + if minID != "" { + s := >smodel.Status{} + if err := ps.conn.Model(s).Where("id = ?", minID).Select(); err != nil { + return nil, err + } + q = q.Where("status.created_at > ?", s.CreatedAt) + } + + if sinceID != "" { + s := >smodel.Status{} + if err := ps.conn.Model(s).Where("id = ?", sinceID).Select(); err != nil { + return nil, err + } + q = q.Where("status.created_at > ?", s.CreatedAt) + } + err := q.Select() if err != nil { if err != pg.ErrNoRows { @@ -1143,7 +1184,53 @@ func (ps *postgresService) GetHomeTimelineForAccount(accountID string, maxID str return statuses, nil } -func (ps *postgresService) GetNotificationsForAccount(accountID string, limit int, maxID string) ([]*gtsmodel.Notification, error) { +func (ps *postgresService) GetPublicTimelineForAccount(accountID string, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error) { + statuses := []*gtsmodel.Status{} + + q := ps.conn.Model(&statuses). + Where("visibility = ?", gtsmodel.VisibilityPublic). + Limit(limit). + Order("created_at DESC") + + if maxID != "" { + s := >smodel.Status{} + if err := ps.conn.Model(s).Where("id = ?", maxID).Select(); err != nil { + return nil, err + } + q = q.Where("created_at < ?", s.CreatedAt) + } + + if minID != "" { + s := >smodel.Status{} + if err := ps.conn.Model(s).Where("id = ?", minID).Select(); err != nil { + return nil, err + } + q = q.Where("created_at > ?", s.CreatedAt) + } + + if sinceID != "" { + s := >smodel.Status{} + if err := ps.conn.Model(s).Where("id = ?", sinceID).Select(); err != nil { + return nil, err + } + q = q.Where("created_at > ?", s.CreatedAt) + } + + if local { + q = q.Where("local = ?", local) + } + + err := q.Select() + if err != nil { + if err != pg.ErrNoRows { + return nil, err + } + } + + return statuses, nil +} + +func (ps *postgresService) GetNotificationsForAccount(accountID string, limit int, maxID string, sinceID string) ([]*gtsmodel.Notification, error) { notifications := []*gtsmodel.Notification{} q := ps.conn.Model(¬ifications).Where("target_account_id = ?", accountID) @@ -1156,6 +1243,14 @@ func (ps *postgresService) GetNotificationsForAccount(accountID string, limit in q = q.Where("created_at < ?", n.CreatedAt) } + if sinceID != "" { + n := >smodel.Notification{} + if err := ps.conn.Model(n).Where("id = ?", sinceID).Select(); err != nil { + return nil, err + } + q = q.Where("created_at > ?", n.CreatedAt) + } + if limit != 0 { q = q.Limit(limit) } diff --git a/internal/processing/fromcommon.go b/internal/processing/fromcommon.go index cb38d4bb4..bdb2a599b 100644 --- a/internal/processing/fromcommon.go +++ b/internal/processing/fromcommon.go @@ -160,5 +160,54 @@ func (p *processor) notifyFave(fave *gtsmodel.StatusFave, receivingAccount *gtsm } func (p *processor) notifyAnnounce(status *gtsmodel.Status) error { + if status.BoostOfID == "" { + // not a boost, nothing to do + return nil + } + + boostedStatus := >smodel.Status{} + if err := p.db.GetByID(status.BoostOfID, boostedStatus); err != nil { + return fmt.Errorf("notifyAnnounce: error getting status with id %s: %s", status.BoostOfID, err) + } + + boostedAcct := >smodel.Account{} + if err := p.db.GetByID(boostedStatus.AccountID, boostedAcct); err != nil { + return fmt.Errorf("notifyAnnounce: error getting account with id %s: %s", boostedStatus.AccountID, err) + } + + if boostedAcct.Domain != "" { + // remote account, nothing to do + return nil + } + + if boostedStatus.AccountID == status.AccountID { + // it's a self boost, nothing to do + return nil + } + + // make sure a notif doesn't already exist for this announce + err := p.db.GetWhere([]db.Where{ + {Key: "notification_type", Value: gtsmodel.NotificationReblog}, + {Key: "target_account_id", Value: boostedAcct.ID}, + {Key: "origin_account_id", Value: status.AccountID}, + {Key: "status_id", Value: status.ID}, + }, >smodel.Notification{}) + if err == nil { + // notification exists already so just bail + return nil + } + + // now create the new reblog notification + notif := >smodel.Notification{ + NotificationType: gtsmodel.NotificationReblog, + TargetAccountID: boostedAcct.ID, + OriginAccountID: status.AccountID, + StatusID: status.ID, + } + + if err := p.db.Put(notif); err != nil { + return fmt.Errorf("notifyAnnounce: error putting notification in database: %s", err) + } + return nil } diff --git a/internal/processing/notification.go b/internal/processing/notification.go index 36cd81b91..44e3885b5 100644 --- a/internal/processing/notification.go +++ b/internal/processing/notification.go @@ -23,10 +23,10 @@ "github.com/superseriousbusiness/gotosocial/internal/oauth" ) -func (p *processor) NotificationsGet(authed *oauth.Auth, limit int, maxID string) ([]*apimodel.Notification, ErrorWithCode) { +func (p *processor) NotificationsGet(authed *oauth.Auth, limit int, maxID string, sinceID string) ([]*apimodel.Notification, ErrorWithCode) { l := p.log.WithField("func", "NotificationsGet") - notifs, err := p.db.GetNotificationsForAccount(authed.Account.ID, limit, maxID) + notifs, err := p.db.GetNotificationsForAccount(authed.Account.ID, limit, maxID, sinceID) if err != nil { return nil, NewErrorInternalError(err) } diff --git a/internal/processing/processor.go b/internal/processing/processor.go index 58b64afab..b31c37be3 100644 --- a/internal/processing/processor.go +++ b/internal/processing/processor.go @@ -107,7 +107,7 @@ type Processor interface { MediaUpdate(authed *oauth.Auth, attachmentID string, form *apimodel.AttachmentUpdateRequest) (*apimodel.Attachment, ErrorWithCode) // NotificationsGet - NotificationsGet(authed *oauth.Auth, limit int, maxID string) ([]*apimodel.Notification, ErrorWithCode) + NotificationsGet(authed *oauth.Auth, limit int, maxID string, sinceID string) ([]*apimodel.Notification, ErrorWithCode) // SearchGet performs a search with the given params, resolving/dereferencing remotely as desired SearchGet(authed *oauth.Auth, searchQuery *apimodel.SearchQuery) (*apimodel.SearchResult, ErrorWithCode) @@ -120,15 +120,21 @@ type Processor interface { StatusFave(authed *oauth.Auth, targetStatusID string) (*apimodel.Status, error) // StatusBoost processes the boost/reblog of a given status, returning the newly-created boost if all is well. StatusBoost(authed *oauth.Auth, targetStatusID string) (*apimodel.Status, ErrorWithCode) + // StatusBoostedBy returns a slice of accounts that have boosted the given status, filtered according to privacy settings. + StatusBoostedBy(authed *oauth.Auth, targetStatusID string) ([]*apimodel.Account, ErrorWithCode) // StatusFavedBy returns a slice of accounts that have liked the given status, filtered according to privacy settings. StatusFavedBy(authed *oauth.Auth, targetStatusID string) ([]*apimodel.Account, error) // StatusGet gets the given status, taking account of privacy settings and blocks etc. StatusGet(authed *oauth.Auth, targetStatusID string) (*apimodel.Status, error) // StatusUnfave processes the unfaving of a given status, returning the updated status if the fave goes through. StatusUnfave(authed *oauth.Auth, targetStatusID string) (*apimodel.Status, error) + // StatusGetContext returns the context (previous and following posts) from the given status ID + StatusGetContext(authed *oauth.Auth, targetStatusID string) (*apimodel.Context, ErrorWithCode) // HomeTimelineGet returns statuses from the home timeline, with the given filters/parameters. HomeTimelineGet(authed *oauth.Auth, maxID string, sinceID string, minID string, limit int, local bool) ([]apimodel.Status, ErrorWithCode) + // PublicTimelineGet returns statuses from the public/local timeline, with the given filters/parameters. + PublicTimelineGet(authed *oauth.Auth, maxID string, sinceID string, minID string, limit int, local bool) ([]apimodel.Status, ErrorWithCode) /* FEDERATION API-FACING PROCESSING FUNCTIONS diff --git a/internal/processing/status.go b/internal/processing/status.go index 7530f386a..897972839 100644 --- a/internal/processing/status.go +++ b/internal/processing/status.go @@ -309,6 +309,70 @@ func (p *processor) StatusBoost(authed *oauth.Auth, targetStatusID string) (*api return mastoStatus, nil } +func (p *processor) StatusBoostedBy(authed *oauth.Auth, targetStatusID string) ([]*apimodel.Account, ErrorWithCode) { + l := p.log.WithField("func", "StatusBoostedBy") + + l.Tracef("going to search for target status %s", targetStatusID) + targetStatus := >smodel.Status{} + if err := p.db.GetByID(targetStatusID, targetStatus); err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error fetching status %s: %s", targetStatusID, err)) + } + + l.Tracef("going to search for target account %s", targetStatus.AccountID) + targetAccount := >smodel.Account{} + if err := p.db.GetByID(targetStatus.AccountID, targetAccount); err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error fetching target account %s: %s", targetStatus.AccountID, err)) + } + + l.Trace("going to get relevant accounts") + relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus) + if err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error fetching related accounts for status %s: %s", targetStatusID, err)) + } + + l.Trace("going to see if status is visible") + visible, err := p.db.StatusVisible(targetStatus, targetAccount, authed.Account, relevantAccounts) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that + if err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error seeing if status %s is visible: %s", targetStatus.ID, err)) + } + + if !visible { + return nil, NewErrorNotFound(errors.New("StatusBoostedBy: status is not visible")) + } + + // get ALL accounts that faved a status -- doesn't take account of blocks and mutes and stuff + favingAccounts, err := p.db.WhoBoostedStatus(targetStatus) + if err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error seeing who boosted status: %s", err)) + } + + // filter the list so the user doesn't see accounts they blocked or which blocked them + filteredAccounts := []*gtsmodel.Account{} + for _, acc := range favingAccounts { + blocked, err := p.db.Blocked(authed.Account.ID, acc.ID) + if err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error checking blocks: %s", err)) + } + if !blocked { + filteredAccounts = append(filteredAccounts, acc) + } + } + + // TODO: filter other things here? suspended? muted? silenced? + + // now we can return the masto representation of those accounts + mastoAccounts := []*apimodel.Account{} + for _, acc := range filteredAccounts { + mastoAccount, err := p.tc.AccountToMastoPublic(acc) + if err != nil { + return nil, NewErrorNotFound(fmt.Errorf("StatusFavedBy: error converting account to api model: %s", err)) + } + mastoAccounts = append(mastoAccounts, mastoAccount) + } + + return mastoAccounts, nil +} + func (p *processor) StatusFavedBy(authed *oauth.Auth, targetStatusID string) ([]*apimodel.Account, error) { l := p.log.WithField("func", "StatusFavedBy") @@ -479,3 +543,7 @@ func (p *processor) StatusUnfave(authed *oauth.Auth, targetStatusID string) (*ap return mastoStatus, nil } + +func (p *processor) StatusGetContext(authed *oauth.Auth, targetStatusID string) (*apimodel.Context, ErrorWithCode) { + return &apimodel.Context{}, nil +} diff --git a/internal/processing/timeline.go b/internal/processing/timeline.go index b7c8e5dc7..7de2d63a9 100644 --- a/internal/processing/timeline.go +++ b/internal/processing/timeline.go @@ -28,13 +28,36 @@ ) func (p *processor) HomeTimelineGet(authed *oauth.Auth, maxID string, sinceID string, minID string, limit int, local bool) ([]apimodel.Status, ErrorWithCode) { - l := p.log.WithField("func", "HomeTimelineGet") - statuses, err := p.db.GetHomeTimelineForAccount(authed.Account.ID, maxID, sinceID, minID, limit, local) if err != nil { return nil, NewErrorInternalError(err) } + s, err := p.filterStatuses(authed, statuses) + if err != nil { + return nil, NewErrorInternalError(err) + } + + return s, nil +} + +func (p *processor) PublicTimelineGet(authed *oauth.Auth, maxID string, sinceID string, minID string, limit int, local bool) ([]apimodel.Status, ErrorWithCode) { + statuses, err := p.db.GetPublicTimelineForAccount(authed.Account.ID, maxID, sinceID, minID, limit, local) + if err != nil { + return nil, NewErrorInternalError(err) + } + + s, err := p.filterStatuses(authed, statuses) + if err != nil { + return nil, NewErrorInternalError(err) + } + + return s, nil +} + +func (p *processor) filterStatuses(authed *oauth.Auth, statuses []*gtsmodel.Status) ([]apimodel.Status, error) { + l := p.log.WithField("func", "filterStatuses") + apiStatuses := []apimodel.Status{} for _, s := range statuses { targetAccount := >smodel.Account{}