bloat/service/service.go

1207 lines
28 KiB
Go
Raw Normal View History

2019-12-13 20:08:26 +02:00
package service
import (
"crypto/sha256"
"encoding/base64"
2019-12-13 20:08:26 +02:00
"errors"
2019-12-25 06:39:34 +02:00
"fmt"
2020-10-19 09:51:23 +03:00
"mime/multipart"
2019-12-13 20:08:26 +02:00
"net/url"
"strings"
2020-02-01 13:31:44 +02:00
"bloat/mastodon"
2020-01-01 17:58:27 +02:00
"bloat/model"
"bloat/renderer"
"bloat/util"
"github.com/enescakir/emoji"
2019-12-13 20:08:26 +02:00
)
var (
2021-03-20 07:12:48 +02:00
errInvalidArgument = errors.New("invalid argument")
errInvalidSession = errors.New("invalid session")
errInvalidCSRFToken = errors.New("invalid csrf token")
2019-12-13 20:08:26 +02:00
)
type service struct {
2021-03-20 07:12:48 +02:00
cname string
cscope string
cwebsite string
css string
instance string
postFormats []model.PostFormat
renderer renderer.Renderer
}
func NewService(cname string, cscope string, cwebsite string,
css string, instance string, postFormats []model.PostFormat,
renderer renderer.Renderer) *service {
2019-12-13 20:08:26 +02:00
return &service{
2021-03-20 07:12:48 +02:00
cname: cname,
cscope: cscope,
cwebsite: cwebsite,
css: css,
instance: instance,
postFormats: postFormats,
renderer: renderer,
}
}
func (s *service) cdata(c *client, title string, count int, rinterval int,
target string) (data *renderer.CommonData) {
2020-02-19 00:15:37 +02:00
data = &renderer.CommonData{
2021-03-20 07:12:48 +02:00
Title: title + " - " + s.cname,
CustomCSS: s.css,
Count: count,
RefreshInterval: rinterval,
Target: target,
2019-12-13 20:08:26 +02:00
}
2021-03-20 07:12:48 +02:00
if c != nil && c.s.IsLoggedIn() {
data.CSRFToken = c.s.CSRFToken
2019-12-13 20:08:26 +02:00
}
2020-01-28 19:51:00 +02:00
return
2019-12-13 20:08:26 +02:00
}
func (s *service) ErrorPage(c *client, err error, retry bool) error {
2019-12-26 11:11:24 +02:00
var errStr string
var sessionErr bool
2019-12-26 11:11:24 +02:00
if err != nil {
errStr = err.Error()
if me, ok := err.(mastodon.Error); ok && me.IsAuthError() ||
err == errInvalidSession || err == errInvalidCSRFToken {
sessionErr = true
}
2019-12-26 11:11:24 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(nil, "error", 0, 0, "")
2019-12-26 11:11:24 +02:00
data := &renderer.ErrorData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
Err: errStr,
Retry: retry,
SessionErr: sessionErr,
2019-12-26 11:11:24 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.ErrorPage, data)
2019-12-13 20:08:26 +02:00
}
func (s *service) SigninPage(c *client) (err error) {
2021-03-20 07:12:48 +02:00
cdata := s.cdata(nil, "signin", 0, 0, "")
2019-12-26 11:11:24 +02:00
data := &renderer.SigninData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-26 11:11:24 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.SigninPage, data)
2019-12-13 20:08:26 +02:00
}
func (s *service) RootPage(c *client) (err error) {
2020-02-19 00:15:37 +02:00
data := &renderer.RootData{
2021-03-20 07:12:48 +02:00
Title: s.cname,
2020-02-19 00:15:37 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.RootPage, data)
2020-02-19 00:15:37 +02:00
}
func (s *service) NavPage(c *client) (err error) {
2021-03-20 07:12:48 +02:00
u, err := c.GetAccountCurrentUser(c.ctx)
2020-02-19 00:15:37 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
pctx := model.PostContext{
DefaultVisibility: c.s.Settings.DefaultVisibility,
DefaultFormat: c.s.Settings.DefaultFormat,
Formats: s.postFormats,
2020-02-19 00:15:37 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "nav", 0, 0, "main")
2020-02-19 00:15:37 +02:00
data := &renderer.NavData{
User: u,
2021-03-20 07:12:48 +02:00
CommonData: cdata,
PostContext: pctx,
2020-02-19 00:15:37 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.NavPage, data)
2020-02-19 00:15:37 +02:00
}
2022-02-11 13:18:02 +02:00
func (s *service) TimelinePage(c *client, tType, instance, listId, maxID,
minID string, tag string) (err error) {
2019-12-13 20:08:26 +02:00
2020-01-28 19:51:00 +02:00
var nextLink, prevLink, title string
var statuses []*mastodon.Status
var reactions []*mastodon.ReactionsPleroma
2019-12-13 20:08:26 +02:00
var pg = mastodon.Pagination{
2019-12-15 08:55:13 +02:00
MaxID: maxID,
MinID: minID,
Limit: 20,
2019-12-13 20:08:26 +02:00
}
2020-01-28 19:51:00 +02:00
switch tType {
2019-12-25 06:30:21 +02:00
default:
2020-01-28 19:51:00 +02:00
return errInvalidArgument
2019-12-25 06:30:21 +02:00
case "home":
2021-03-20 07:12:48 +02:00
statuses, err = c.GetTimelineHome(c.ctx, &pg)
2022-02-11 13:18:02 +02:00
if err != nil {
return err
}
2019-12-25 06:30:21 +02:00
title = "Timeline"
2020-01-28 22:56:15 +02:00
case "direct":
2021-03-20 07:12:48 +02:00
statuses, err = c.GetTimelineDirect(c.ctx, &pg)
2022-02-11 13:18:02 +02:00
if err != nil {
return err
}
2020-07-28 16:36:57 +03:00
title = "Direct Timeline"
2019-12-25 06:30:21 +02:00
case "local":
2021-03-20 07:12:48 +02:00
statuses, err = c.GetTimelinePublic(c.ctx, true, "", &pg)
2022-02-11 13:18:02 +02:00
if err != nil {
return err
}
2019-12-25 06:30:21 +02:00
title = "Local Timeline"
2021-01-23 10:44:05 +02:00
case "remote":
if len(instance) > 0 {
2023-10-12 15:15:07 +03:00
statuses, err = c.GetTimelinePublic(c.ctx, true, instance, &pg)
2022-02-11 13:18:02 +02:00
if err != nil {
return err
}
2021-01-23 10:44:05 +02:00
}
title = "Remote Timeline"
2023-10-12 15:15:07 +03:00
case "tremote":
if len(instance) > 0 {
statuses, err = c.TrueRemoteTimeline(c.ctx, instance, &pg)
if err != nil {
return err
}
}
title = "True Remote Timeline"
2019-12-25 06:30:21 +02:00
case "twkn":
2021-03-20 07:12:48 +02:00
statuses, err = c.GetTimelinePublic(c.ctx, false, "", &pg)
2022-02-11 13:18:02 +02:00
if err != nil {
return err
}
2019-12-25 06:30:21 +02:00
title = "The Whole Known Network"
case "tag":
if len(tag) > 0 {
statuses, err = c.GetTimelineHashtag(c.ctx, tag, false, &pg)
if err != nil {
return err
}
}
title = "Tag timeline"
2022-02-11 13:18:02 +02:00
case "list":
statuses, err = c.GetTimelineList(c.ctx, listId, &pg)
if err != nil {
return err
}
list, err := c.GetList(c.ctx, listId)
if err != nil {
return err
}
title = "List Timeline - " + list.Title
2019-12-13 20:08:26 +02:00
}
2019-12-29 13:32:24 +02:00
for i := range statuses {
2019-12-31 13:00:21 +02:00
if statuses[i].Reblog != nil {
statuses[i].Reblog.RetweetedByID = statuses[i].ID
2019-12-31 13:00:21 +02:00
}
if statuses[i].Pleroma.Reactions == nil && statuses[i].Account.Pleroma != nil {
if statuses[i].Reblog != nil {
reactions, err = c.GetReactedBy(c.ctx, statuses[i].Reblog.ID)
} else {
reactions, err = c.GetReactedBy(c.ctx, statuses[i].ID)
}
if err != nil {
return err
}
statuses[i].Pleroma.Reactions = reactions
}
2019-12-29 13:32:24 +02:00
}
2021-01-23 09:02:12 +02:00
if (len(maxID) > 0 || len(minID) > 0) && len(statuses) > 0 {
2021-01-23 10:44:05 +02:00
v := make(url.Values)
v.Set("min_id", statuses[0].ID)
if len(instance) > 0 {
v.Set("instance", instance)
}
if len(tag) > 0 {
v.Set("tag", tag)
}
2022-02-11 13:18:02 +02:00
if len(listId) > 0 {
v.Set("list", listId)
}
2021-01-23 10:44:05 +02:00
prevLink = "/timeline/" + tType + "?" + v.Encode()
2019-12-15 08:55:13 +02:00
}
2020-01-28 19:51:00 +02:00
2021-01-23 09:02:12 +02:00
if len(minID) > 0 || (len(pg.MaxID) > 0 && len(statuses) == 20) {
2021-01-23 10:44:05 +02:00
v := make(url.Values)
v.Set("max_id", pg.MaxID)
if len(instance) > 0 {
v.Set("instance", instance)
}
if len(tag) > 0 {
v.Set("tag", tag)
}
2022-02-11 13:18:02 +02:00
if len(listId) > 0 {
v.Set("list", listId)
}
2021-01-23 10:44:05 +02:00
nextLink = "/timeline/" + tType + "?" + v.Encode()
2019-12-13 20:08:26 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, tType+" timeline ", 0, 0, "")
2019-12-25 16:13:59 +02:00
data := &renderer.TimelineData{
2020-02-19 00:15:37 +02:00
Title: title,
2021-01-23 10:44:05 +02:00
Type: tType,
Instance: instance,
2020-02-19 00:15:37 +02:00
Statuses: statuses,
NextLink: nextLink,
PrevLink: prevLink,
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-25 16:13:59 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.TimelinePage, data)
}
2020-01-28 19:51:00 +02:00
2021-03-20 07:12:48 +02:00
func addToReplyMap(m map[string][]mastodon.ReplyInfo, key interface{},
val string, number int) {
if key == nil {
return
}
keyStr, ok := key.(string)
if !ok {
return
}
_, ok = m[keyStr]
if !ok {
m[keyStr] = []mastodon.ReplyInfo{}
}
m[keyStr] = append(m[keyStr], mastodon.ReplyInfo{val, number})
2020-01-28 19:51:00 +02:00
}
2019-12-25 16:13:59 +02:00
2022-02-11 13:18:02 +02:00
func (s *service) ListsPage(c *client) (err error) {
lists, err := c.GetLists(c.ctx)
if err != nil {
return
}
cdata := s.cdata(c, "Lists", 0, 0, "")
data := renderer.ListsData{
Lists: lists,
CommonData: cdata,
}
return s.renderer.Render(c.rctx, c.w, renderer.ListsPage, data)
}
func (s *service) AddList(c *client, title string) (err error) {
_, err = c.CreateList(c.ctx, title)
return err
}
func (s *service) RemoveList(c *client, id string) (err error) {
return c.DeleteList(c.ctx, id)
}
func (s *service) RenameList(c *client, id, title string) (err error) {
_, err = c.RenameList(c.ctx, id, title)
return err
}
func (s *service) ListPage(c *client, id string, q string) (err error) {
list, err := c.GetList(c.ctx, id)
if err != nil {
return
}
accounts, err := c.GetListAccounts(c.ctx, id)
if err != nil {
return
}
var searchAccounts []*mastodon.Account
if len(q) > 0 {
result, err := c.Search(c.ctx, q, "accounts", 20, true, 0, id, true)
if err != nil {
return err
}
searchAccounts = result.Accounts
}
cdata := s.cdata(c, "List "+list.Title, 0, 0, "")
data := renderer.ListData{
List: list,
Accounts: accounts,
Q: q,
SearchAccounts: searchAccounts,
CommonData: cdata,
}
return s.renderer.Render(c.rctx, c.w, renderer.ListPage, data)
}
func (s *service) ListAddUser(c *client, id string, uid string) (err error) {
return c.AddToList(c.ctx, id, uid)
}
func (s *service) ListRemoveUser(c *client, id string, uid string) (err error) {
return c.RemoveFromList(c.ctx, id, uid)
}
func (s *service) ThreadPage(c *client, id string, reply bool) (err error) {
2021-03-20 07:12:48 +02:00
var pctx model.PostContext
2019-12-13 20:08:26 +02:00
2021-03-20 07:12:48 +02:00
status, err := c.GetStatus(c.ctx, id)
2019-12-13 20:08:26 +02:00
if err != nil {
return
}
if reply {
var spoilerText string
var content string
2020-01-28 19:51:00 +02:00
var visibility string
spoilerText = status.SpoilerText
2021-03-20 07:12:48 +02:00
if c.s.UserID != status.Account.ID {
2019-12-14 19:47:14 +02:00
content += "@" + status.Account.Acct + " "
}
2019-12-19 00:14:02 +02:00
for i := range status.Mentions {
2021-03-20 07:12:48 +02:00
if status.Mentions[i].ID != c.s.UserID &&
2020-01-28 19:51:00 +02:00
status.Mentions[i].ID != status.Account.ID {
2019-12-19 00:14:02 +02:00
content += "@" + status.Mentions[i].Acct + " "
2019-12-14 19:47:14 +02:00
}
}
2020-07-28 16:36:57 +03:00
isDirect := status.Visibility == "direct"
2021-03-20 07:12:48 +02:00
if isDirect || c.s.Settings.CopyScope {
visibility = status.Visibility
2019-12-27 10:06:43 +02:00
} else {
2021-03-20 07:12:48 +02:00
visibility = c.s.Settings.DefaultVisibility
}
2023-11-10 01:34:00 +02:00
replyLanguage := status.Language
2021-03-20 07:12:48 +02:00
pctx = model.PostContext{
2019-12-27 10:06:43 +02:00
DefaultVisibility: visibility,
2021-03-20 07:12:48 +02:00
DefaultFormat: c.s.Settings.DefaultFormat,
Formats: s.postFormats,
ReplyContext: &model.ReplyContext{
InReplyToID: id,
InReplyToName: status.Account.Acct,
ReplySpoiler: spoilerText,
ReplyContent: content,
ForceVisibility: isDirect,
2023-11-10 01:34:00 +02:00
ReplyLanguage: replyLanguage,
},
}
}
2021-03-20 07:12:48 +02:00
context, err := c.GetStatusContext(c.ctx, id)
2019-12-19 00:14:02 +02:00
if err != nil {
return
}
statuses := append(append(context.Ancestors, status), context.Descendants...)
2020-01-28 19:51:00 +02:00
replies := make(map[string][]mastodon.ReplyInfo)
2020-06-05 09:27:59 +03:00
idNumbers := make(map[string]int)
2019-12-19 00:14:02 +02:00
for i := range statuses {
statuses[i].ShowReplies = true
2020-06-05 09:27:59 +03:00
statuses[i].IDNumbers = idNumbers
idNumbers[statuses[i].ID] = i + 1
statuses[i].IDReplies = replies
addToReplyMap(replies, statuses[i].InReplyToID, statuses[i].ID, i+1)
2019-12-19 00:14:02 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "post by "+status.Account.DisplayName, 0, 0, "")
2019-12-25 16:13:59 +02:00
data := &renderer.ThreadData{
Statuses: statuses,
2021-03-20 07:12:48 +02:00
PostContext: pctx,
2020-01-28 19:51:00 +02:00
ReplyMap: replies,
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-25 16:13:59 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.ThreadPage, data)
2019-12-13 20:08:26 +02:00
}
2021-09-05 20:17:59 +03:00
func (s *service) QuickReplyPage(c *client, id string) (err error) {
status, err := c.GetStatus(c.ctx, id)
if err != nil {
return
}
var ancestor *mastodon.Status
if status.InReplyToID != nil {
ancestor, err = c.GetStatus(c.ctx, status.InReplyToID.(string))
if err != nil {
return
}
}
var content string
if c.s.UserID != status.Account.ID {
content += "@" + status.Account.Acct + " "
}
for i := range status.Mentions {
if status.Mentions[i].ID != c.s.UserID &&
status.Mentions[i].ID != status.Account.ID {
content += "@" + status.Mentions[i].Acct + " "
}
}
var visibility string
isDirect := status.Visibility == "direct"
if isDirect || c.s.Settings.CopyScope {
visibility = status.Visibility
} else {
visibility = c.s.Settings.DefaultVisibility
}
pctx := model.PostContext{
DefaultVisibility: visibility,
DefaultFormat: c.s.Settings.DefaultFormat,
Formats: s.postFormats,
ReplyContext: &model.ReplyContext{
InReplyToID: id,
InReplyToName: status.Account.Acct,
QuickReply: true,
ReplyContent: content,
ForceVisibility: isDirect,
},
}
cdata := s.cdata(c, "post by "+status.Account.DisplayName, 0, 0, "")
data := &renderer.QuickReplyData{
Ancestor: ancestor,
Status: status,
PostContext: pctx,
CommonData: cdata,
}
return s.renderer.Render(c.rctx, c.w, renderer.QuickReplyPage, data)
}
func (s *service) LikedByPage(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
likers, err := c.GetFavouritedBy(c.ctx, id, nil)
2020-01-28 19:51:00 +02:00
if err != nil {
return
2019-12-15 19:37:58 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "likes", 0, 0, "")
2020-01-28 19:51:00 +02:00
data := &renderer.LikedByData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2020-01-28 19:51:00 +02:00
Users: likers,
2019-12-15 19:37:58 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.LikedByPage, data)
2020-01-28 19:51:00 +02:00
}
2019-12-15 19:37:58 +02:00
2022-10-19 17:33:43 +03:00
func (s *service) ReactedByPage(c *client, id string) (err error) {
reactions, err := c.GetReactedBy(c.ctx, id)
if err != nil {
return
}
cdata := s.cdata(c, "reactions", 0, 0, "")
data := &renderer.ReactedByData{
CommonData: cdata,
ID: id,
2022-10-19 17:33:43 +03:00
Reactions: reactions,
ReactionEmojis: emoji.Map(),
2022-10-19 17:33:43 +03:00
}
return s.renderer.Render(c.rctx, c.w, renderer.ReactedByPage, data)
}
func (s *service) RetweetedByPage(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
retweeters, err := c.GetRebloggedBy(c.ctx, id, nil)
2019-12-15 19:37:58 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "retweets", 0, 0, "")
2020-01-28 19:51:00 +02:00
data := &renderer.RetweetedByData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2020-01-28 19:51:00 +02:00
Users: retweeters,
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.RetweetedByPage, data)
2019-12-15 19:37:58 +02:00
}
func (s *service) NotificationPage(c *client, maxID string,
2020-05-24 07:38:34 +03:00
minID string) (err error) {
2020-01-28 19:51:00 +02:00
var nextLink string
var unreadCount int
2020-02-19 00:15:37 +02:00
var readID string
var includes, excludes []string
2020-01-28 19:51:00 +02:00
var pg = mastodon.Pagination{
MaxID: maxID,
MinID: minID,
Limit: 20,
2019-12-26 11:11:24 +02:00
}
if c.s.Settings.HideUnsupportedNotifs {
// Explicitly include the supported types.
// For now, only Pleroma supports this option, Mastadon
// will simply ignore the unknown params.
includes = []string{"follow", "follow_request", "mention", "reblog", "favourite"}
}
2021-03-20 07:12:48 +02:00
if c.s.Settings.AntiDopamineMode {
excludes = append(excludes, "follow", "favourite", "reblog")
2020-09-02 20:50:48 +03:00
}
notifications, err := c.GetNotifications(c.ctx, &pg, includes, excludes)
2019-12-26 11:11:24 +02:00
if err != nil {
return
}
2020-01-28 19:51:00 +02:00
for i := range notifications {
if notifications[i].Pleroma != nil && !notifications[i].Pleroma.IsSeen {
unreadCount++
}
2019-12-26 11:11:24 +02:00
}
2020-01-28 19:51:00 +02:00
if unreadCount > 0 {
2020-02-19 00:15:37 +02:00
readID = notifications[0].ID
2019-12-26 11:11:24 +02:00
}
2020-02-19 00:15:37 +02:00
if len(notifications) == 20 && len(pg.MaxID) > 0 {
2020-01-28 19:51:00 +02:00
nextLink = "/notifications?max_id=" + pg.MaxID
2019-12-26 11:11:24 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "notifications", unreadCount,
c.s.Settings.NotificationInterval, "main")
2020-01-28 19:51:00 +02:00
data := &renderer.NotificationData{
Notifications: notifications,
2020-02-19 00:15:37 +02:00
UnreadCount: unreadCount,
ReadID: readID,
2020-01-28 19:51:00 +02:00
NextLink: nextLink,
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-26 11:11:24 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.NotificationPage, data)
2019-12-26 11:11:24 +02:00
}
2019-12-26 21:18:09 +02:00
func (s *service) UserPage(c *client, id string, pageType string,
2020-05-24 07:38:34 +03:00
maxID string, minID string) (err error) {
2020-01-28 19:51:00 +02:00
2019-12-29 05:43:57 +02:00
var nextLink string
var statuses []*mastodon.Status
var users []*mastodon.Account
2019-12-29 05:43:57 +02:00
var pg = mastodon.Pagination{
MaxID: maxID,
MinID: minID,
Limit: 20,
}
2021-03-20 07:12:48 +02:00
user, err := c.GetAccount(c.ctx, id)
2019-12-29 05:43:57 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
isCurrent := c.s.UserID == user.ID
2019-12-29 05:43:57 +02:00
switch pageType {
case "":
2022-10-26 00:44:22 +03:00
statuses, err = c.GetAccountStatuses(c.ctx, id, false, false, &pg)
if err != nil {
return
}
if len(statuses) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s?max_id=%s", id,
pg.MaxID)
}
case "following":
2021-03-20 07:12:48 +02:00
users, err = c.GetAccountFollowing(c.ctx, id, &pg)
if err != nil {
return
}
if len(users) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/following?max_id=%s",
id, pg.MaxID)
}
case "followers":
2021-03-20 07:12:48 +02:00
users, err = c.GetAccountFollowers(c.ctx, id, &pg)
if err != nil {
return
}
if len(users) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/followers?max_id=%s",
id, pg.MaxID)
}
case "media":
2022-10-26 00:44:22 +03:00
statuses, err = c.GetAccountStatuses(c.ctx, id, true, false, &pg)
if err != nil {
return
}
if len(statuses) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/media?max_id=%s",
id, pg.MaxID)
}
2022-10-26 00:44:22 +03:00
case "pinned":
statuses, err = c.GetAccountStatuses(c.ctx, id, false, true, &pg)
if err != nil {
return
}
if len(statuses) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/pinned?max_id=%s",
id, pg.MaxID)
}
case "bookmarks":
if !isCurrent {
return errInvalidArgument
}
2021-03-20 07:12:48 +02:00
statuses, err = c.GetBookmarks(c.ctx, &pg)
if err != nil {
return
}
if len(statuses) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/bookmarks?max_id=%s",
id, pg.MaxID)
}
2020-09-27 12:44:52 +03:00
case "mutes":
if !isCurrent {
return errInvalidArgument
}
2021-03-20 07:12:48 +02:00
users, err = c.GetMutes(c.ctx, &pg)
2020-09-27 12:44:52 +03:00
if err != nil {
return
}
if len(users) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/mutes?max_id=%s",
id, pg.MaxID)
}
2020-09-27 12:50:04 +03:00
case "blocks":
if !isCurrent {
return errInvalidArgument
}
2021-03-20 07:12:48 +02:00
users, err = c.GetBlocks(c.ctx, &pg)
2020-09-27 12:50:04 +03:00
if err != nil {
return
}
if len(users) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/blocks?max_id=%s",
id, pg.MaxID)
}
2020-09-27 13:04:56 +03:00
case "likes":
if !isCurrent {
return errInvalidArgument
}
2021-03-20 07:12:48 +02:00
statuses, err = c.GetFavourites(c.ctx, &pg)
2020-09-27 13:04:56 +03:00
if err != nil {
return
}
if len(statuses) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/likes?max_id=%s",
id, pg.MaxID)
}
2021-01-16 11:10:02 +02:00
case "requests":
if !isCurrent {
return errInvalidArgument
}
2021-03-20 07:12:48 +02:00
users, err = c.GetFollowRequests(c.ctx, &pg)
2021-01-16 11:10:02 +02:00
if err != nil {
return
}
if len(users) == 20 && len(pg.MaxID) > 0 {
nextLink = fmt.Sprintf("/user/%s/requests?max_id=%s",
id, pg.MaxID)
}
default:
return errInvalidArgument
2019-12-29 05:43:57 +02:00
}
2020-10-19 13:01:59 +03:00
for i := range statuses {
if statuses[i].Reblog != nil {
statuses[i].Reblog.RetweetedByID = statuses[i].ID
}
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, user.DisplayName+" @"+user.Acct, 0, 0, "")
2020-01-28 19:51:00 +02:00
data := &renderer.UserData{
User: user,
IsCurrent: isCurrent,
Type: pageType,
Users: users,
2020-01-28 19:51:00 +02:00
Statuses: statuses,
2019-12-29 05:43:57 +02:00
NextLink: nextLink,
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-29 05:43:57 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.UserPage, data)
2020-01-28 19:51:00 +02:00
}
2019-12-29 05:43:57 +02:00
func (s *service) UserSearchPage(c *client,
2020-01-30 17:32:37 +02:00
id string, q string, offset int) (err error) {
var nextLink string
var title = "search"
2021-03-20 07:12:48 +02:00
user, err := c.GetAccount(c.ctx, id)
2020-01-30 17:32:37 +02:00
if err != nil {
return
}
2020-10-19 09:05:59 +03:00
var results *mastodon.Results
if len(q) > 0 {
2022-02-11 13:18:02 +02:00
results, err = c.Search(c.ctx, q, "statuses", 20, true, offset, id, false)
2020-10-19 09:05:59 +03:00
if err != nil {
return err
}
} else {
results = &mastodon.Results{}
2020-01-30 17:32:37 +02:00
}
if len(results.Statuses) == 20 {
offset += 20
nextLink = fmt.Sprintf("/usersearch/%s?q=%s&offset=%d", id,
2022-03-30 18:52:30 +03:00
q, offset)
2020-01-30 17:32:37 +02:00
}
if len(q) > 0 {
2021-04-23 13:19:09 +03:00
title += " \"" + q + "\""
2020-01-30 17:32:37 +02:00
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, title, 0, 0, "")
2020-01-30 17:32:37 +02:00
data := &renderer.UserSearchData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2020-01-30 17:32:37 +02:00
User: user,
2021-04-23 13:19:09 +03:00
Q: q,
2020-01-30 17:32:37 +02:00
Statuses: results.Statuses,
NextLink: nextLink,
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.UserSearchPage, data)
2020-01-30 17:32:37 +02:00
}
2022-12-17 10:26:51 +02:00
func (s *service) MutePage(c *client, id string) (err error) {
user, err := c.GetAccount(c.ctx, id)
if err != nil {
return
}
cdata := s.cdata(c, "Mute "+user.DisplayName+" @"+user.Acct, 0, 0, "")
2022-12-17 10:26:51 +02:00
data := &renderer.UserData{
User: user,
CommonData: cdata,
}
return s.renderer.Render(c.rctx, c.w, renderer.MutePage, data)
}
func (s *service) AboutPage(c *client) (err error) {
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "about", 0, 0, "")
2020-01-28 19:51:00 +02:00
data := &renderer.AboutData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-29 05:43:57 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.AboutPage, data)
2020-01-28 19:51:00 +02:00
}
2022-10-12 13:34:41 +03:00
func (s *service) AboutInstance(c *client) (err error) {
cdata := s.cdata(c, "about", 0, 0, "")
instance, err := c.GetInstance(c.ctx)
if err != nil {
return
}
2022-10-13 01:41:34 +03:00
peers, err := c.GetInstancePeers(c.ctx)
if err != nil {
return
}
2022-10-12 13:34:41 +03:00
data := &renderer.AboutInstanceData{
CommonData: cdata,
Instance: instance,
2022-10-13 01:41:34 +03:00
Peers: peers,
2022-10-12 13:34:41 +03:00
}
return s.renderer.Render(c.rctx, c.w, renderer.AboutInstance, data)
}
func (s *service) EmojiPage(c *client) (err error) {
2021-03-20 07:12:48 +02:00
emojis, err := c.GetInstanceEmojis(c.ctx)
2019-12-29 05:43:57 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "emojis", 0, 0, "")
2020-01-28 19:51:00 +02:00
data := &renderer.EmojiData{
Emojis: emojis,
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2019-12-29 05:43:57 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.EmojiPage, data)
2019-12-29 05:43:57 +02:00
}
func (s *service) SearchPage(c *client,
2020-01-28 19:51:00 +02:00
q string, qType string, offset int) (err error) {
2019-12-26 21:18:09 +02:00
var nextLink string
2020-01-28 19:51:00 +02:00
var title = "search"
2019-12-26 21:18:09 +02:00
2020-10-19 09:05:59 +03:00
var results *mastodon.Results
if len(q) > 0 {
2022-02-11 13:18:02 +02:00
results, err = c.Search(c.ctx, q, qType, 20, true, offset, "", false)
2020-10-19 09:05:59 +03:00
if err != nil {
return err
}
} else {
results = &mastodon.Results{}
2019-12-26 21:18:09 +02:00
}
2020-01-28 19:51:00 +02:00
if (qType == "accounts" && len(results.Accounts) == 20) ||
(qType == "statuses" && len(results.Statuses) == 20) {
2019-12-26 21:18:09 +02:00
offset += 20
nextLink = fmt.Sprintf("/search?q=%s&type=%s&offset=%d",
2022-03-30 18:52:30 +03:00
q, qType, offset)
2019-12-26 21:18:09 +02:00
}
2020-01-10 05:53:02 +02:00
if len(q) > 0 {
2021-04-23 13:19:09 +03:00
title += " \"" + q + "\""
2020-01-10 05:53:02 +02:00
}
2020-01-28 19:51:00 +02:00
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, title, 0, 0, "")
2019-12-26 21:18:09 +02:00
data := &renderer.SearchData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2021-04-23 13:19:09 +03:00
Q: q,
2019-12-26 21:18:09 +02:00
Type: qType,
Users: results.Accounts,
Statuses: results.Statuses,
NextLink: nextLink,
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.SearchPage, data)
2019-12-26 21:18:09 +02:00
}
func (s *service) SettingsPage(c *client) (err error) {
2021-03-20 07:12:48 +02:00
cdata := s.cdata(c, "settings", 0, 0, "")
2019-12-27 10:06:43 +02:00
data := &renderer.SettingsData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
Settings: &c.s.Settings,
PostFormats: s.postFormats,
2019-12-27 10:06:43 +02:00
}
2021-03-20 07:12:48 +02:00
return s.renderer.Render(c.rctx, c.w, renderer.SettingsPage, data)
2020-01-28 19:51:00 +02:00
}
2019-12-27 10:06:43 +02:00
2021-01-30 18:51:09 +02:00
func (svc *service) FiltersPage(c *client) (err error) {
2021-03-20 07:12:48 +02:00
filters, err := c.GetFilters(c.ctx)
2021-01-30 18:51:09 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
cdata := svc.cdata(c, "filters", 0, 0, "")
2021-01-30 18:51:09 +02:00
data := &renderer.FiltersData{
2021-03-20 07:12:48 +02:00
CommonData: cdata,
2021-01-30 18:51:09 +02:00
Filters: filters,
}
2021-03-20 07:12:48 +02:00
return svc.renderer.Render(c.rctx, c.w, renderer.FiltersPage, data)
2021-01-30 18:51:09 +02:00
}
2023-10-01 16:04:07 +03:00
func (svc *service) ProfilePage(c *client) (err error) {
u, err := c.GetAccountCurrentUser(c.ctx)
if err != nil {
return
}
// Some instances allow more than 4 fields, but make sure that there are
// at least 4 fields in the slice because the template depends on it.
if u.Source.Fields == nil {
u.Source.Fields = new([]mastodon.Field)
}
for len(*u.Source.Fields) < 4 {
*u.Source.Fields = append(*u.Source.Fields, mastodon.Field{})
}
cdata := svc.cdata(c, "edit profile", 0, 0, "")
data := &renderer.ProfileData{
CommonData: cdata,
User: u,
}
return svc.renderer.Render(c.rctx, c.w, renderer.ProfilePage, data)
}
func (s *service) ProfileUpdate(c *client, name, bio string, avatar, banner *multipart.FileHeader,
fields []mastodon.Field, locked bool) (err error) {
// Need to pass empty data to clear fields
if len(fields) == 0 {
fields = append(fields, mastodon.Field{})
}
p := &mastodon.Profile{
DisplayName: &name,
Note: &bio,
Avatar: avatar,
Header: banner,
Fields: &fields,
Locked: &locked,
}
_, err = c.AccountUpdate(c.ctx, p)
return err
}
func (s *service) ProfileDelAvatar(c *client) (err error) {
_, err = c.AccountDeleteAvatar(c.ctx)
return
}
func (s *service) ProfileDelBanner(c *client) (err error) {
_, err = c.AccountDeleteHeader(c.ctx)
return err
}
func (s *service) SingleInstance() (instance string, ok bool) {
2021-03-20 07:12:48 +02:00
if len(s.instance) > 0 {
instance = s.instance
2020-04-19 11:18:36 +03:00
ok = true
}
return
}
func (s *service) NewSession(c *client, instance string) (rurl string, sess *model.Session, err error) {
2020-01-28 19:51:00 +02:00
var instanceURL string
if strings.HasPrefix(instance, "https://") {
instanceURL = instance
instance = strings.TrimPrefix(instance, "https://")
} else {
instanceURL = "https://" + instance
}
2021-03-20 07:12:48 +02:00
csrf, err := util.NewCSRFToken()
2019-12-27 10:06:43 +02:00
if err != nil {
return
}
app, err := mastodon.RegisterApp(c.ctx, &mastodon.AppConfig{
Server: instanceURL,
ClientName: s.cname,
Scopes: s.cscope,
Website: s.cwebsite,
RedirectURIs: s.cwebsite + "/oauth_callback",
})
2019-12-27 10:06:43 +02:00
if err != nil {
return
}
2023-10-07 12:19:56 +03:00
rurl = app.AuthURI
sess = &model.Session{
Instance: instance,
ClientID: app.ClientID,
ClientSecret: app.ClientSecret,
CSRFToken: csrf,
Settings: *model.NewSettings(),
2019-12-25 16:13:59 +02:00
}
2019-12-13 20:08:26 +02:00
return
}
2021-03-20 07:12:48 +02:00
func (s *service) Signin(c *client, code string) (err error) {
2020-01-28 19:51:00 +02:00
if len(code) < 1 {
err = errInvalidArgument
2020-01-08 20:16:06 +02:00
return
}
2021-03-20 07:12:48 +02:00
err = c.AuthenticateToken(c.ctx, code, s.cwebsite+"/oauth_callback")
2020-01-08 20:16:06 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
u, err := c.GetAccountCurrentUser(c.ctx)
2020-02-02 10:30:40 +02:00
if err != nil {
return
}
2021-03-20 07:12:48 +02:00
c.s.AccessToken = c.GetAccessToken(c.ctx)
c.s.UserID = u.ID
return c.setSession(c.s)
2020-03-04 17:59:59 +02:00
}
2023-10-02 09:44:26 +03:00
func (s *service) Signout(c *client) (err error) {
return c.RevokeToken(c.ctx)
}
func (s *service) Post(c *client, content string, replyToID string,
format string, visibility string, isNSFW bool, spoilerText string,
files []*multipart.FileHeader, edit string, language string, expiresIn int, scheduledAt string,
pollOptions []string, pollExpiresIn int, pollHideTotals bool, pollMultiple bool,
mediaDescription []string) (id string, err error) {
2020-01-28 19:51:00 +02:00
var mediaIDs []string
for idx, f := range files {
a, err := c.UploadMediaFromMultipartFileHeader(c.ctx, f, mediaDescription[idx])
2019-12-14 22:19:02 +02:00
if err != nil {
return "", err
}
2020-01-28 19:51:00 +02:00
mediaIDs = append(mediaIDs, a.ID)
2019-12-14 22:19:02 +02:00
}
2023-11-09 22:14:42 +02:00
expiresIn = expiresIn * 3600
pollTweet := mastodon.TootPoll{
ExpiresIn: pollExpiresIn,
Options: pollOptions,
Multiple: pollMultiple,
HideTotals: pollHideTotals,
}
2019-12-13 20:08:26 +02:00
tweet := &mastodon.Toot{
SpoilerText: spoilerText,
2019-12-13 20:08:26 +02:00
Status: content,
InReplyToID: replyToID,
2020-01-28 19:51:00 +02:00
MediaIDs: mediaIDs,
2019-12-26 13:25:29 +02:00
ContentType: format,
Visibility: visibility,
2019-12-22 18:27:49 +02:00
Sensitive: isNSFW,
Edit: edit,
2023-11-09 22:14:42 +02:00
Language: language,
ExpiresIn: expiresIn, // pleroma compatible
2023-11-10 00:27:22 +02:00
ScheduledAt: scheduledAt,
Poll: pollTweet,
2019-12-13 20:08:26 +02:00
}
2023-11-09 22:14:42 +02:00
2021-03-20 07:12:48 +02:00
st, err := c.PostStatus(c.ctx, tweet)
if err != nil {
return
}
return st.ID, nil
2019-12-13 20:08:26 +02:00
}
2019-12-19 00:14:02 +02:00
func (s *service) Like(c *client, id string) (count int64, err error) {
2021-03-20 07:12:48 +02:00
st, err := c.Favourite(c.ctx, id)
2020-01-28 19:51:00 +02:00
if err != nil {
return
}
count = st.FavouritesCount
return
}
func (s *service) UnLike(c *client, id string) (count int64, err error) {
2021-03-20 07:12:48 +02:00
st, err := c.Unfavourite(c.ctx, id)
2020-01-28 19:51:00 +02:00
if err != nil {
return
}
count = st.FavouritesCount
return
}
func (s *service) PutReact(c *client, id string, emoji string) (count int64, err error) {
st, err := c.PutReaction(c.ctx, id, emoji)
if err != nil {
return
}
count = st.FavouritesCount
return
}
func (s *service) UnReact(c *client, id string, emoji string) (count int64, err error) {
st, err := c.UnReaction(c.ctx, id, emoji)
if err != nil {
return
}
count = st.FavouritesCount
return
}
func (s *service) Retweet(c *client, id string, visibility string) (count int64, err error) {
st, err := c.Reblog(c.ctx, id, visibility)
2020-01-28 19:51:00 +02:00
if err != nil {
2019-12-19 00:14:02 +02:00
return
}
if st.Reblog != nil {
count = st.Reblog.ReblogsCount
2020-01-28 19:51:00 +02:00
}
return
}
2019-12-21 13:13:21 +02:00
func (s *service) UnRetweet(c *client, id string) (
2020-01-28 19:51:00 +02:00
count int64, err error) {
2021-03-20 07:12:48 +02:00
st, err := c.Unreblog(c.ctx, id)
2020-01-28 19:51:00 +02:00
if err != nil {
2019-12-19 00:14:02 +02:00
return
}
count = st.ReblogsCount
2020-01-28 19:51:00 +02:00
return
}
func (s *service) Vote(c *client, id string, choices []string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.Vote(c.ctx, id, choices)
return
}
func (s *service) Follow(c *client, id string, reblogs *bool) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.AccountFollow(c.ctx, id, reblogs)
2020-01-28 19:51:00 +02:00
return
}
func (s *service) UnFollow(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.AccountUnfollow(c.ctx, id)
2020-01-28 19:51:00 +02:00
return
}
2021-01-16 11:10:02 +02:00
func (s *service) Accept(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
return c.FollowRequestAuthorize(c.ctx, id)
2021-01-16 11:10:02 +02:00
}
func (s *service) Reject(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
return c.FollowRequestReject(c.ctx, id)
2021-01-16 11:10:02 +02:00
}
2022-12-17 10:26:51 +02:00
func (s *service) Mute(c *client, id string, notifications bool, duration int) (err error) {
_, err = c.AccountMute(c.ctx, id, notifications, duration)
2020-02-08 12:49:06 +02:00
return
}
func (s *service) UnMute(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.AccountUnmute(c.ctx, id)
2020-02-08 12:49:06 +02:00
return
}
func (s *service) Block(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.AccountBlock(c.ctx, id)
2020-02-08 12:49:06 +02:00
return
}
func (s *service) UnBlock(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.AccountUnblock(c.ctx, id)
2020-02-08 12:49:06 +02:00
return
}
func (s *service) Subscribe(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.Subscribe(c.ctx, id)
2020-04-17 20:19:11 +03:00
return
}
func (s *service) UnSubscribe(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.UnSubscribe(c.ctx, id)
2020-04-17 20:19:11 +03:00
return
}
func (s *service) SaveSettings(c *client, settings *model.Settings) (err error) {
switch settings.NotificationInterval {
case 0, 30, 60, 120, 300, 600:
default:
return errInvalidArgument
}
if len(settings.CSS) > 0 {
if len(settings.CSS) > 1<<20 {
return errInvalidArgument
}
// For some reason, browsers convert CRLF to LF before calculating
// the hash of the inline resources.
2023-10-22 14:11:21 +03:00
settings.CSS = strings.Replace(settings.CSS, "\x0d\x0a", "\x0a", -1)
h := sha256.Sum256([]byte(settings.CSS))
settings.CSSHash = base64.StdEncoding.EncodeToString(h[:])
} else {
settings.CSSHash = ""
2021-04-03 12:22:43 +03:00
}
c.s.Settings = *settings
return c.setSession(c.s)
2019-12-19 00:14:02 +02:00
}
2020-02-02 09:24:06 +02:00
func (s *service) UserSave(c *client, usersettings mastodon.Profile) (err error) {
_, err = c.AccountUpdate(c.ctx, &usersettings)
return
}
func (s *service) MuteConversation(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.MuteConversation(c.ctx, id)
2020-02-02 09:24:06 +02:00
return
}
func (s *service) UnMuteConversation(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.UnmuteConversation(c.ctx, id)
2020-02-02 09:24:06 +02:00
return
}
2020-02-02 10:30:40 +02:00
func (s *service) Pin(c *client, id string) (err error) {
return c.Pin(c.ctx, id)
}
func (s *service) UnPin(c *client, id string) (err error) {
return c.UnPin(c.ctx, id)
}
func (s *service) Delete(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
return c.DeleteStatus(c.ctx, id)
2020-02-02 10:30:40 +02:00
}
2020-02-19 00:15:37 +02:00
func (s *service) ReadNotifications(c *client, maxID string) (err error) {
2021-03-20 07:12:48 +02:00
return c.ReadNotifications(c.ctx, maxID)
2020-02-19 00:15:37 +02:00
}
func (s *service) Bookmark(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.Bookmark(c.ctx, id)
return
}
func (s *service) UnBookmark(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
_, err = c.Unbookmark(c.ctx, id)
return
}
2021-01-30 18:51:09 +02:00
func (svc *service) Filter(c *client, phrase string, wholeWord bool) (err error) {
fctx := []string{"home", "notifications", "public", "thread"}
2021-03-20 07:12:48 +02:00
return c.AddFilter(c.ctx, phrase, fctx, true, wholeWord, nil)
2021-01-30 18:51:09 +02:00
}
func (svc *service) UnFilter(c *client, id string) (err error) {
2021-03-20 07:12:48 +02:00
return c.RemoveFilter(c.ctx, id)
2021-01-30 18:51:09 +02:00
}