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..5df45b993 100644 --- a/internal/api/client/notification/notification.go +++ b/internal/api/client/notification/notification.go @@ -41,6 +41,8 @@ const ( MaxIDKey = "max_id" // LimitKey is for specifying maximum number of notifications to return. LimitKey = "limit" + // SinceIDKey + 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..7e4da021e 100644 --- a/internal/api/client/status/status.go +++ b/internal/api/client/status/status.go @@ -98,6 +98,8 @@ func (m *Module) Route(r router.Router) error { r.AttachHandler(http.MethodPost, ReblogPath, m.StatusBoostPOSTHandler) + r.AttachHandler(http.MethodGet, ContextPath, m.StatusContextGETHandler) + r.AttachHandler(http.MethodGet, BasePathWithID, m.muxHandler) return nil } diff --git a/internal/api/client/status/statuscontext.go b/internal/api/client/status/statuscontext.go new file mode 100644 index 000000000..9087eb67c --- /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 @@ import ( // 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 @@ package timeline along with this program. If not, see . */ +package timeline + import ( "net/http" @@ -33,6 +33,8 @@ const ( 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 @@ import ( "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 @@ var Start cliactions.GTSAction = func(ctx context.Context, c *config.Config, log 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 @@ var Start cliactions.GTSAction = func(ctx context.Context, c *config.Config, log timelineModule, notificationModule, searchModule, + filtersModule, + emojiModule, + listsModule, } for _, m := range apis { diff --git a/internal/db/db.go b/internal/db/db.go index 31a8ba5d9..c7a3df683 100644 --- a/internal/db/db.go +++ b/internal/db/db.go @@ -257,8 +257,12 @@ type DB interface { // 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..91e5b1ac0 100644 --- a/internal/db/pg/pg.go +++ b/internal/db/pg/pg.go @@ -1133,6 +1133,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 +1159,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 +1218,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/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 @@ import ( "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..f54fb45ee 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) @@ -126,9 +126,13 @@ type Processor interface { 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..edaf70cd4 100644 --- a/internal/processing/status.go +++ b/internal/processing/status.go @@ -479,3 +479,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 @@ import ( ) 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{}