bloat/service/service.go

636 lines
15 KiB
Go
Raw Normal View History

2019-12-13 18:08:26 +00:00
package service
import (
"bytes"
"context"
"encoding/json"
"errors"
2019-12-25 04:39:34 +00:00
"fmt"
2019-12-13 18:08:26 +00:00
"io"
2019-12-14 20:19:02 +00:00
"mime/multipart"
2019-12-13 18:08:26 +00:00
"net/http"
"net/url"
"strings"
"mastodon"
"web/model"
"web/renderer"
"web/util"
)
var (
ErrInvalidArgument = errors.New("invalid argument")
ErrInvalidToken = errors.New("invalid token")
ErrInvalidClient = errors.New("invalid client")
2019-12-25 04:30:21 +00:00
ErrInvalidTimeline = errors.New("invalid timeline")
2019-12-13 18:08:26 +00:00
)
type Service interface {
ServeHomePage(ctx context.Context, client io.Writer) (err error)
GetAuthUrl(ctx context.Context, instance string) (url string, sessionID string, err error)
2019-12-21 11:13:21 +00:00
GetUserToken(ctx context.Context, sessionID string, c *model.Client, token string) (accessToken string, err error)
2019-12-13 18:08:26 +00:00
ServeErrorPage(ctx context.Context, client io.Writer, err error)
ServeSigninPage(ctx context.Context, client io.Writer) (err error)
2019-12-25 04:30:21 +00:00
ServeTimelinePage(ctx context.Context, client io.Writer, c *model.Client, timelineType string, maxID string, sinceID string, minID string) (err error)
2019-12-21 11:13:21 +00:00
ServeThreadPage(ctx context.Context, client io.Writer, c *model.Client, id string, reply bool) (err error)
ServeNotificationPage(ctx context.Context, client io.Writer, c *model.Client, maxID string, minID string) (err error)
ServeUserPage(ctx context.Context, client io.Writer, c *model.Client, id string, maxID string, minID string) (err error)
ServeAboutPage(ctx context.Context, client io.Writer, c *model.Client) (err error)
2019-12-22 18:10:42 +00:00
ServeEmojiPage(ctx context.Context, client io.Writer, c *model.Client) (err error)
2019-12-21 11:13:21 +00:00
Like(ctx context.Context, client io.Writer, c *model.Client, id string) (err error)
UnLike(ctx context.Context, client io.Writer, c *model.Client, id string) (err error)
Retweet(ctx context.Context, client io.Writer, c *model.Client, id string) (err error)
UnRetweet(ctx context.Context, client io.Writer, c *model.Client, id string) (err error)
2019-12-22 16:27:49 +00:00
PostTweet(ctx context.Context, client io.Writer, c *model.Client, content string, replyToID string, visibility string, isNSFW bool, files []*multipart.FileHeader) (id string, err error)
2019-12-21 11:13:21 +00:00
Follow(ctx context.Context, client io.Writer, c *model.Client, id string) (err error)
UnFollow(ctx context.Context, client io.Writer, c *model.Client, id string) (err error)
2019-12-13 18:08:26 +00:00
}
type service struct {
clientName string
clientScope string
clientWebsite string
customCSS string
2019-12-13 18:08:26 +00:00
renderer renderer.Renderer
sessionRepo model.SessionRepository
appRepo model.AppRepository
}
func NewService(clientName string, clientScope string, clientWebsite string,
customCSS string, renderer renderer.Renderer, sessionRepo model.SessionRepository,
2019-12-13 18:08:26 +00:00
appRepo model.AppRepository) Service {
return &service{
clientName: clientName,
clientScope: clientScope,
clientWebsite: clientWebsite,
customCSS: customCSS,
2019-12-13 18:08:26 +00:00
renderer: renderer,
sessionRepo: sessionRepo,
appRepo: appRepo,
}
}
func (svc *service) GetAuthUrl(ctx context.Context, instance string) (
redirectUrl string, sessionID string, err error) {
var instanceURL string
if strings.HasPrefix(instance, "https://") {
instanceURL = instance
instance = strings.TrimPrefix(instance, "https://")
} else {
instanceURL = "https://" + instance
2019-12-13 18:08:26 +00:00
}
sessionID = util.NewSessionId()
err = svc.sessionRepo.Add(model.Session{
ID: sessionID,
InstanceDomain: instance,
2019-12-13 18:08:26 +00:00
})
if err != nil {
return
}
app, err := svc.appRepo.Get(instance)
if err != nil {
if err != model.ErrAppNotFound {
return
}
var mastoApp *mastodon.Application
mastoApp, err = mastodon.RegisterApp(ctx, &mastodon.AppConfig{
Server: instanceURL,
2019-12-13 18:08:26 +00:00
ClientName: svc.clientName,
Scopes: svc.clientScope,
Website: svc.clientWebsite,
RedirectURIs: svc.clientWebsite + "/oauth_callback",
})
if err != nil {
return
}
app = model.App{
InstanceDomain: instance,
InstanceURL: instanceURL,
ClientID: mastoApp.ClientID,
ClientSecret: mastoApp.ClientSecret,
2019-12-13 18:08:26 +00:00
}
err = svc.appRepo.Add(app)
if err != nil {
return
}
}
2019-12-17 20:17:03 +00:00
u, err := url.Parse("/oauth/authorize")
2019-12-13 18:08:26 +00:00
if err != nil {
return
}
q := make(url.Values)
q.Set("scope", "read write follow")
q.Set("client_id", app.ClientID)
q.Set("response_type", "code")
q.Set("redirect_uri", svc.clientWebsite+"/oauth_callback")
u.RawQuery = q.Encode()
2019-12-17 20:17:03 +00:00
redirectUrl = instanceURL + u.String()
2019-12-13 18:08:26 +00:00
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) GetUserToken(ctx context.Context, sessionID string, c *model.Client,
2019-12-13 18:08:26 +00:00
code string) (token string, err error) {
if len(code) < 1 {
err = ErrInvalidArgument
return
}
session, err := svc.sessionRepo.Get(sessionID)
if err != nil {
return
}
app, err := svc.appRepo.Get(session.InstanceDomain)
2019-12-13 18:08:26 +00:00
if err != nil {
return
}
data := &bytes.Buffer{}
err = json.NewEncoder(data).Encode(map[string]string{
"client_id": app.ClientID,
"client_secret": app.ClientSecret,
"grant_type": "authorization_code",
"code": code,
"redirect_uri": svc.clientWebsite + "/oauth_callback",
})
if err != nil {
return
}
resp, err := http.Post(app.InstanceURL+"/oauth/token", "application/json", data)
if err != nil {
return
}
defer resp.Body.Close()
var res struct {
AccessToken string `json:"access_token"`
}
err = json.NewDecoder(resp.Body).Decode(&res)
if err != nil {
return
}
/*
err = c.AuthenticateToken(ctx, code, svc.clientWebsite+"/oauth_callback")
if err != nil {
return
}
err = svc.sessionRepo.Update(sessionID, c.GetAccessToken(ctx))
*/
return res.AccessToken, nil
}
func (svc *service) ServeHomePage(ctx context.Context, client io.Writer) (err error) {
err = svc.renderer.RenderHomePage(ctx, client)
if err != nil {
return
}
return
}
func (svc *service) ServeErrorPage(ctx context.Context, client io.Writer, err error) {
svc.renderer.RenderErrorPage(ctx, client, err)
}
func (svc *service) ServeSigninPage(ctx context.Context, client io.Writer) (err error) {
err = svc.renderer.RenderSigninPage(ctx, client)
if err != nil {
return
}
return
}
func (svc *service) ServeTimelinePage(ctx context.Context, client io.Writer,
2019-12-25 04:30:21 +00:00
c *model.Client, timelineType string, maxID string, sinceID string, minID string) (err error) {
2019-12-13 18:08:26 +00:00
var hasNext, hasPrev bool
var nextLink, prevLink string
var pg = mastodon.Pagination{
2019-12-15 06:55:13 +00:00
MaxID: maxID,
MinID: minID,
Limit: 20,
2019-12-13 18:08:26 +00:00
}
2019-12-25 04:30:21 +00:00
var statuses []*mastodon.Status
var title string
switch timelineType {
default:
return ErrInvalidTimeline
case "home":
statuses, err = c.GetTimelineHome(ctx, &pg)
title = "Timeline"
case "local":
statuses, err = c.GetTimelinePublic(ctx, true, &pg)
title = "Local Timeline"
case "twkn":
statuses, err = c.GetTimelinePublic(ctx, false, &pg)
title = "The Whole Known Network"
}
2019-12-13 18:08:26 +00:00
if err != nil {
return err
}
2019-12-15 06:55:13 +00:00
if len(maxID) > 0 && len(statuses) > 0 {
hasPrev = true
2019-12-25 04:39:34 +00:00
prevLink = fmt.Sprintf("/timeline/$s?min_id=%s", timelineType, statuses[0].ID)
2019-12-15 06:55:13 +00:00
}
if len(minID) > 0 && len(pg.MinID) > 0 {
newStatuses, err := c.GetTimelineHome(ctx, &mastodon.Pagination{MinID: pg.MinID, Limit: 20})
if err != nil {
return err
}
newStatusesLen := len(newStatuses)
if newStatusesLen == 20 {
hasPrev = true
2019-12-25 04:39:34 +00:00
prevLink = fmt.Sprintf("/timeline/%s?min_id=%s", timelineType, pg.MinID)
2019-12-15 06:55:13 +00:00
} else {
i := 20 - newStatusesLen - 1
if len(statuses) > i {
hasPrev = true
2019-12-25 04:39:34 +00:00
prevLink = fmt.Sprintf("/timeline/%s?min_id=%s", timelineType, statuses[i].ID)
2019-12-15 06:55:13 +00:00
}
}
}
2019-12-13 18:08:26 +00:00
if len(pg.MaxID) > 0 {
hasNext = true
2019-12-25 04:39:34 +00:00
nextLink = fmt.Sprintf("/timeline/%s?max_id=%s", timelineType, pg.MaxID)
2019-12-13 18:08:26 +00:00
}
postContext := model.PostContext{
DefaultVisibility: c.Session.Settings.DefaultVisibility,
}
commonData, err := svc.getCommonData(ctx, client, c)
2019-12-15 17:37:58 +00:00
if err != nil {
return
}
2019-12-25 14:13:59 +00:00
data := &renderer.TimelineData{
Title: title,
Statuses: statuses,
HasNext: hasNext,
NextLink: nextLink,
HasPrev: hasPrev,
PrevLink: prevLink,
PostContext: postContext,
CommonData: commonData,
2019-12-25 14:13:59 +00:00
}
2019-12-13 18:08:26 +00:00
err = svc.renderer.RenderTimelinePage(ctx, client, data)
if err != nil {
return
}
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) ServeThreadPage(ctx context.Context, client io.Writer, c *model.Client, id string, reply bool) (err error) {
2019-12-13 18:08:26 +00:00
status, err := c.GetStatus(ctx, id)
if err != nil {
return
}
2019-12-14 17:47:14 +00:00
u, err := c.GetAccountCurrentUser(ctx)
if err != nil {
return
}
var postContext model.PostContext
if reply {
var content string
2019-12-14 17:47:14 +00:00
if u.ID != status.Account.ID {
content += "@" + status.Account.Acct + " "
}
2019-12-18 22:14:02 +00:00
for i := range status.Mentions {
if status.Mentions[i].ID != u.ID && status.Mentions[i].ID != status.Account.ID {
content += "@" + status.Mentions[i].Acct + " "
2019-12-14 17:47:14 +00:00
}
}
s, err := c.GetStatus(ctx, id)
if err != nil {
return err
}
postContext = model.PostContext{
DefaultVisibility: s.Visibility,
ReplyContext: &model.ReplyContext{
InReplyToID: id,
InReplyToName: status.Account.Acct,
ReplyContent: content,
},
}
}
2019-12-18 22:14:02 +00:00
context, err := c.GetStatusContext(ctx, id)
if err != nil {
return
}
statuses := append(append(context.Ancestors, status), context.Descendants...)
replyMap := make(map[string][]mastodon.ReplyInfo)
for i := range statuses {
statuses[i].ShowReplies = true
statuses[i].ReplyMap = replyMap
addToReplyMap(replyMap, statuses[i].InReplyToID, statuses[i].ID, i+1)
}
commonData, err := svc.getCommonData(ctx, client, c)
2019-12-15 17:37:58 +00:00
if err != nil {
return
}
2019-12-25 14:13:59 +00:00
data := &renderer.ThreadData{
Statuses: statuses,
PostContext: postContext,
ReplyMap: replyMap,
CommonData: commonData,
2019-12-25 14:13:59 +00:00
}
2019-12-13 18:08:26 +00:00
err = svc.renderer.RenderThreadPage(ctx, client, data)
if err != nil {
return
}
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) ServeNotificationPage(ctx context.Context, client io.Writer, c *model.Client, maxID string, minID string) (err error) {
2019-12-15 17:37:58 +00:00
var hasNext bool
var nextLink string
var pg = mastodon.Pagination{
MaxID: maxID,
MinID: minID,
Limit: 20,
}
notifications, err := c.GetNotifications(ctx, &pg)
if err != nil {
return
}
var unreadCount int
for i := range notifications {
switch notifications[i].Type {
case "reblog", "favourite":
if notifications[i].Status != nil {
2019-12-18 22:14:02 +00:00
notifications[i].Status.HideAccountInfo = true
2019-12-15 17:37:58 +00:00
}
}
if notifications[i].Pleroma != nil && notifications[i].Pleroma.IsSeen {
unreadCount++
}
}
if unreadCount > 0 {
err := c.ReadNotifications(ctx, notifications[0].ID)
if err != nil {
return err
}
}
if len(pg.MaxID) > 0 {
hasNext = true
nextLink = "/notifications?max_id=" + pg.MaxID
}
commonData, err := svc.getCommonData(ctx, client, c)
2019-12-15 17:37:58 +00:00
if err != nil {
return
}
2019-12-25 14:13:59 +00:00
data := &renderer.NotificationData{
Notifications: notifications,
HasNext: hasNext,
NextLink: nextLink,
CommonData: commonData,
2019-12-25 14:13:59 +00:00
}
2019-12-15 17:37:58 +00:00
err = svc.renderer.RenderNotificationPage(ctx, client, data)
if err != nil {
return
}
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) ServeUserPage(ctx context.Context, client io.Writer, c *model.Client, id string, maxID string, minID string) (err error) {
user, err := c.GetAccount(ctx, id)
if err != nil {
return
}
var hasNext bool
var nextLink string
var pg = mastodon.Pagination{
MaxID: maxID,
MinID: minID,
Limit: 20,
}
statuses, err := c.GetAccountStatuses(ctx, id, &pg)
if err != nil {
return
}
if len(pg.MaxID) > 0 {
hasNext = true
nextLink = "/user/" + id + "?max_id=" + pg.MaxID
}
commonData, err := svc.getCommonData(ctx, client, c)
if err != nil {
return
}
2019-12-25 14:13:59 +00:00
data := &renderer.UserData{
User: user,
Statuses: statuses,
HasNext: hasNext,
NextLink: nextLink,
CommonData: commonData,
2019-12-25 14:13:59 +00:00
}
err = svc.renderer.RenderUserPage(ctx, client, data)
if err != nil {
return
}
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) ServeAboutPage(ctx context.Context, client io.Writer, c *model.Client) (err error) {
commonData, err := svc.getCommonData(ctx, client, c)
2019-12-21 05:48:48 +00:00
if err != nil {
return
}
2019-12-25 14:13:59 +00:00
data := &renderer.AboutData{
CommonData: commonData,
2019-12-25 14:13:59 +00:00
}
2019-12-21 05:48:48 +00:00
err = svc.renderer.RenderAboutPage(ctx, client, data)
if err != nil {
return
}
return
}
2019-12-22 18:10:42 +00:00
func (svc *service) ServeEmojiPage(ctx context.Context, client io.Writer, c *model.Client) (err error) {
commonData, err := svc.getCommonData(ctx, client, c)
2019-12-22 18:10:42 +00:00
if err != nil {
return
}
emojis, err := c.GetInstanceEmojis(ctx)
if err != nil {
return
}
2019-12-25 14:13:59 +00:00
data := &renderer.EmojiData{
Emojis: emojis,
CommonData: commonData,
2019-12-25 14:13:59 +00:00
}
2019-12-22 18:10:42 +00:00
err = svc.renderer.RenderEmojiPage(ctx, client, data)
if err != nil {
return
}
return
}
func (svc *service) getCommonData(ctx context.Context, client io.Writer, c *model.Client) (data *renderer.CommonData, err error) {
data = new(renderer.CommonData)
data.HeaderData = &renderer.HeaderData{
Title: "Web",
NotificationCount: 0,
CustomCSS: svc.customCSS,
2019-12-15 17:37:58 +00:00
}
if c != nil && c.Session.IsLoggedIn() {
notifications, err := c.GetNotifications(ctx, nil)
if err != nil {
return nil, err
2019-12-15 17:37:58 +00:00
}
var notificationCount int
for i := range notifications {
if notifications[i].Pleroma != nil && !notifications[i].Pleroma.IsSeen {
notificationCount++
}
}
u, err := c.GetAccountCurrentUser(ctx)
if err != nil {
return nil, err
}
data.NavbarData = &renderer.NavbarData{
User: u,
NotificationCount: notificationCount,
}
2019-12-24 14:55:05 +00:00
data.HeaderData.NotificationCount = notificationCount
2019-12-25 14:13:59 +00:00
}
2019-12-15 17:37:58 +00:00
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) Like(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
2019-12-13 18:08:26 +00:00
_, err = c.Favourite(ctx, id)
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) UnLike(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
2019-12-13 18:08:26 +00:00
_, err = c.Unfavourite(ctx, id)
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) Retweet(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
2019-12-13 18:08:26 +00:00
_, err = c.Reblog(ctx, id)
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) UnRetweet(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
2019-12-13 18:08:26 +00:00
_, err = c.Unreblog(ctx, id)
return
}
2019-12-22 16:27:49 +00:00
func (svc *service) PostTweet(ctx context.Context, client io.Writer, c *model.Client, content string, replyToID string, visibility string, isNSFW bool, files []*multipart.FileHeader) (id string, err error) {
2019-12-14 20:19:02 +00:00
var mediaIds []string
for _, f := range files {
a, err := c.UploadMediaFromMultipartFileHeader(ctx, f)
if err != nil {
return "", err
}
mediaIds = append(mediaIds, a.ID)
}
// save visibility if it's a non-reply post
if len(replyToID) < 1 && visibility != c.Session.Settings.DefaultVisibility {
c.Session.Settings.DefaultVisibility = visibility
svc.sessionRepo.Add(c.Session)
}
2019-12-13 18:08:26 +00:00
tweet := &mastodon.Toot{
Status: content,
InReplyToID: replyToID,
2019-12-14 20:19:02 +00:00
MediaIDs: mediaIds,
Visibility: visibility,
2019-12-22 16:27:49 +00:00
Sensitive: isNSFW,
2019-12-13 18:08:26 +00:00
}
s, err := c.PostStatus(ctx, tweet)
if err != nil {
return
}
return s.ID, nil
2019-12-13 18:08:26 +00:00
}
2019-12-18 22:14:02 +00:00
2019-12-21 11:13:21 +00:00
func (svc *service) Follow(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
_, err = c.AccountFollow(ctx, id)
return
}
2019-12-21 11:13:21 +00:00
func (svc *service) UnFollow(ctx context.Context, client io.Writer, c *model.Client, id string) (err error) {
_, err = c.AccountUnfollow(ctx, id)
return
}
2019-12-18 22:14:02 +00:00
func addToReplyMap(m map[string][]mastodon.ReplyInfo, key interface{}, val string, number int) {
if key == nil {
return
}
2019-12-21 11:13:21 +00:00
2019-12-18 22:14:02 +00:00
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})
}