localhost_frssoft/bloat
1
0
Fork 0
mirror of https://git.phreedom.club/localhost_frssoft/bloat.git synced 2024-11-25 13:21:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor

Browse source
This commit is contained in:
r 2021-03-20 05:12:48 +00:00
parent 6ddcb16694
commit 6c5de76562
5 changed files with 369 additions and 433 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
main.go
View file

@ -4,12 +4,10 @@ import (
"errors" "errors"
"fmt" "fmt"
"log" "log"
"net"
"net/http" "net/http"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"time"
"bloat/config" "bloat/config"
"bloat/renderer" "bloat/renderer"
@ -27,20 +25,6 @@ func errExit(err error) {
os.Exit(1) os.Exit(1)
} }
func setupHttp() {
tr := http.DefaultTransport.(*http.Transport)
tr.MaxIdleConnsPerHost = 30
tr.MaxIdleConns = 300
tr.ForceAttemptHTTP2 = false
tr.DialContext = (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 3 * time.Minute,
DualStack: true,
}).DialContext
client := http.DefaultClient
client.Transport = tr
}
func main() { func main() {
opts, _, err := util.Getopts(os.Args, "f:") opts, _, err := util.Getopts(os.Args, "f:")
if err != nil { if err != nil {
@ -108,11 +92,9 @@ func main() {
logger = log.New(lf, "", log.LstdFlags) logger = log.New(lf, "", log.LstdFlags)
} }
setupHttp()
s := service.NewService(config.ClientName, config.ClientScope, s := service.NewService(config.ClientName, config.ClientScope,
config.ClientWebsite, customCSS, config.PostFormats, renderer, config.ClientWebsite, customCSS, config.SingleInstance,
sessionRepo, appRepo, config.SingleInstance) config.PostFormats, renderer, sessionRepo, appRepo)
handler := service.NewHandler(s, logger, config.StaticDirectory) handler := service.NewHandler(s, logger, config.StaticDirectory)
logger.Println("listening on", config.ListenAddress) logger.Println("listening on", config.ListenAddress)

12
renderer/model.go
View file

@ -17,12 +17,6 @@ type Context struct {
Referrer string Referrer string
} }
type NavData struct {
CommonData *CommonData
User *mastodon.Account
PostContext model.PostContext
}
type CommonData struct { type CommonData struct {
Title string Title string
CustomCSS string CustomCSS string
@ -32,6 +26,12 @@ type CommonData struct {
Target string Target string
} }
type NavData struct {
CommonData *CommonData
User *mastodon.Account
PostContext model.PostContext
}
type ErrorData struct { type ErrorData struct {
*CommonData *CommonData
Error string Error string

465
service/service.go
View file

@ -1,7 +1,6 @@
package service package service
import ( import (
"context"
"errors" "errors"
"fmt" "fmt"
"html/template" "html/template"
@ -16,146 +15,145 @@ import (
) )
var ( var (
ctx = context.Background() errInvalidArgument = errors.New("invalid argument")
errInvalidArgument = errors.New("invalid argument") errInvalidSession = errors.New("invalid session")
errInvalidCSRFToken = errors.New("invalid csrf token")
) )
type service struct { type service struct {
clientName string cname string
clientScope string cscope string
clientWebsite string cwebsite string
customCSS string css string
postFormats []model.PostFormat instance string
renderer renderer.Renderer postFormats []model.PostFormat
sessionRepo model.SessionRepo renderer renderer.Renderer
appRepo model.AppRepo sessionRepo model.SessionRepo
singleInstance string appRepo model.AppRepo
} }
func NewService(clientName string, func NewService(cname string, cscope string, cwebsite string,
clientScope string, css string, instance string, postFormats []model.PostFormat,
clientWebsite string, renderer renderer.Renderer, sessionRepo model.SessionRepo,
customCSS string, appRepo model.AppRepo) *service {
postFormats []model.PostFormat,
renderer renderer.Renderer,
sessionRepo model.SessionRepo,
appRepo model.AppRepo,
singleInstance string,
) *service {
return &service{ return &service{
clientName: clientName, cname: cname,
clientScope: clientScope, cscope: cscope,
clientWebsite: clientWebsite, cwebsite: cwebsite,
customCSS: customCSS, css: css,
postFormats: postFormats, instance: instance,
renderer: renderer, postFormats: postFormats,
sessionRepo: sessionRepo, renderer: renderer,
appRepo: appRepo, sessionRepo: sessionRepo,
singleInstance: singleInstance, appRepo: appRepo,
} }
} }
func getRendererContext(c *client) *renderer.Context { func (s *service) authenticate(c *client, sid string, csrf string, ref string, t int) (err error) {
var settings model.Settings var sett *model.Settings
var session model.Session defer func() {
var referrer string if sett == nil {
if c != nil { sett = model.NewSettings()
settings = c.Session.Settings }
session = c.Session c.rctx = &renderer.Context{
referrer = c.url() HideAttachments: sett.HideAttachments,
} else { MaskNSFW: sett.MaskNSFW,
settings = *model.NewSettings() ThreadInNewTab: sett.ThreadInNewTab,
} FluorideMode: sett.FluorideMode,
return &renderer.Context{ DarkMode: sett.DarkMode,
HideAttachments: settings.HideAttachments, CSRFToken: c.s.CSRFToken,
MaskNSFW: settings.MaskNSFW, UserID: c.s.UserID,
ThreadInNewTab: settings.ThreadInNewTab, AntiDopamineMode: sett.AntiDopamineMode,
FluorideMode: settings.FluorideMode, Referrer: ref,
DarkMode: settings.DarkMode, }
CSRFToken: session.CSRFToken, }()
UserID: session.UserID, if t < SESSION {
AntiDopamineMode: settings.AntiDopamineMode,
Referrer: referrer,
}
}
func addToReplyMap(m map[string][]mastodon.ReplyInfo, key interface{},
val string, number int) {
if key == nil {
return return
} }
keyStr, ok := key.(string) if len(sid) < 1 {
if !ok { return errInvalidSession
return
} }
_, ok = m[keyStr] c.s, err = s.sessionRepo.Get(sid)
if !ok { if err != nil {
m[keyStr] = []mastodon.ReplyInfo{} return errInvalidSession
} }
m[keyStr] = append(m[keyStr], mastodon.ReplyInfo{val, number}) sett = &c.s.Settings
} app, err := s.appRepo.Get(c.s.InstanceDomain)
if err != nil {
func (s *service) getCommonData(c *client, title string) (data *renderer.CommonData) { return err
data = &renderer.CommonData{
Title: title + " - " + s.clientName,
CustomCSS: s.customCSS,
} }
if c != nil && c.Session.IsLoggedIn() { c.Client = mastodon.NewClient(&mastodon.Config{
data.CSRFToken = c.Session.CSRFToken Server: app.InstanceURL,
ClientID: app.ClientID,
ClientSecret: app.ClientSecret,
AccessToken: c.s.AccessToken,
})
if t >= CSRF && (len(csrf) < 1 || csrf != c.s.CSRFToken) {
return errInvalidCSRFToken
} }
return return
} }
func (s *service) ErrorPage(c *client, err error) { func (s *service) cdata(c *client, title string, count int, rinterval int,
target string) (data *renderer.CommonData) {
data = &renderer.CommonData{
Title: title + " - " + s.cname,
CustomCSS: s.css,
Count: count,
RefreshInterval: rinterval,
Target: target,
}
if c != nil && c.s.IsLoggedIn() {
data.CSRFToken = c.s.CSRFToken
}
return
}
func (s *service) ErrorPage(c *client, err error) error {
var errStr string var errStr string
if err != nil { if err != nil {
errStr = err.Error() errStr = err.Error()
} }
commonData := s.getCommonData(nil, "error") cdata := s.cdata(nil, "error", 0, 0, "")
data := &renderer.ErrorData{ data := &renderer.ErrorData{
CommonData: commonData, CommonData: cdata,
Error: errStr, Error: errStr,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.ErrorPage, data)
s.renderer.Render(rCtx, c, renderer.ErrorPage, data)
} }
func (s *service) SigninPage(c *client) (err error) { func (s *service) SigninPage(c *client) (err error) {
commonData := s.getCommonData(nil, "signin") cdata := s.cdata(nil, "signin", 0, 0, "")
data := &renderer.SigninData{ data := &renderer.SigninData{
CommonData: commonData, CommonData: cdata,
} }
rCtx := getRendererContext(nil) return s.renderer.Render(c.rctx, c.w, renderer.SigninPage, data)
return s.renderer.Render(rCtx, c, renderer.SigninPage, data)
} }
func (s *service) RootPage(c *client) (err error) { func (s *service) RootPage(c *client) (err error) {
data := &renderer.RootData{ data := &renderer.RootData{
Title: s.clientName, Title: s.cname,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.RootPage, data)
return s.renderer.Render(rCtx, c, renderer.RootPage, data)
} }
func (s *service) NavPage(c *client) (err error) { func (s *service) NavPage(c *client) (err error) {
u, err := c.GetAccountCurrentUser(ctx) u, err := c.GetAccountCurrentUser(c.ctx)
if err != nil { if err != nil {
return return
} }
postContext := model.PostContext{ pctx := model.PostContext{
DefaultVisibility: c.Session.Settings.DefaultVisibility, DefaultVisibility: c.s.Settings.DefaultVisibility,
DefaultFormat: c.Session.Settings.DefaultFormat, DefaultFormat: c.s.Settings.DefaultFormat,
Formats: s.postFormats, Formats: s.postFormats,
} }
commonData := s.getCommonData(c, "nav") cdata := s.cdata(c, "nav", 0, 0, "main")
commonData.Target = "main"
data := &renderer.NavData{ data := &renderer.NavData{
User: u, User: u,
CommonData: commonData, CommonData: cdata,
PostContext: postContext, PostContext: pctx,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.NavPage, data)
return s.renderer.Render(rCtx, c, renderer.NavPage, data)
} }
func (s *service) TimelinePage(c *client, tType string, instance string, func (s *service) TimelinePage(c *client, tType string, instance string,
@ -173,21 +171,21 @@ func (s *service) TimelinePage(c *client, tType string, instance string,
default: default:
return errInvalidArgument return errInvalidArgument
case "home": case "home":
statuses, err = c.GetTimelineHome(ctx, &pg) statuses, err = c.GetTimelineHome(c.ctx, &pg)
title = "Timeline" title = "Timeline"
case "direct": case "direct":
statuses, err = c.GetTimelineDirect(ctx, &pg) statuses, err = c.GetTimelineDirect(c.ctx, &pg)
title = "Direct Timeline" title = "Direct Timeline"
case "local": case "local":
statuses, err = c.GetTimelinePublic(ctx, true, "", &pg) statuses, err = c.GetTimelinePublic(c.ctx, true, "", &pg)
title = "Local Timeline" title = "Local Timeline"
case "remote": case "remote":
if len(instance) > 0 { if len(instance) > 0 {
statuses, err = c.GetTimelinePublic(ctx, false, instance, &pg) statuses, err = c.GetTimelinePublic(c.ctx, false, instance, &pg)
} }
title = "Remote Timeline" title = "Remote Timeline"
case "twkn": case "twkn":
statuses, err = c.GetTimelinePublic(ctx, false, "", &pg) statuses, err = c.GetTimelinePublic(c.ctx, false, "", &pg)
title = "The Whole Known Network" title = "The Whole Known Network"
} }
if err != nil { if err != nil {
@ -218,7 +216,7 @@ func (s *service) TimelinePage(c *client, tType string, instance string,
nextLink = "/timeline/" + tType + "?" + v.Encode() nextLink = "/timeline/" + tType + "?" + v.Encode()
} }
commonData := s.getCommonData(c, tType+" timeline ") cdata := s.cdata(c, tType+" timeline ", 0, 0, "")
data := &renderer.TimelineData{ data := &renderer.TimelineData{
Title: title, Title: title,
Type: tType, Type: tType,
@ -226,17 +224,31 @@ func (s *service) TimelinePage(c *client, tType string, instance string,
Statuses: statuses, Statuses: statuses,
NextLink: nextLink, NextLink: nextLink,
PrevLink: prevLink, PrevLink: prevLink,
CommonData: commonData, CommonData: cdata,
} }
return s.renderer.Render(c.rctx, c.w, renderer.TimelinePage, data)
}
rCtx := getRendererContext(c) func addToReplyMap(m map[string][]mastodon.ReplyInfo, key interface{},
return s.renderer.Render(rCtx, c, renderer.TimelinePage, data) 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})
} }
func (s *service) ThreadPage(c *client, id string, reply bool) (err error) { func (s *service) ThreadPage(c *client, id string, reply bool) (err error) {
var postContext model.PostContext var pctx model.PostContext
status, err := c.GetStatus(ctx, id) status, err := c.GetStatus(c.ctx, id)
if err != nil { if err != nil {
return return
} }
@ -244,26 +256,26 @@ func (s *service) ThreadPage(c *client, id string, reply bool) (err error) {
if reply { if reply {
var content string var content string
var visibility string var visibility string
if c.Session.UserID != status.Account.ID { if c.s.UserID != status.Account.ID {
content += "@" + status.Account.Acct + " " content += "@" + status.Account.Acct + " "
} }
for i := range status.Mentions { for i := range status.Mentions {
if status.Mentions[i].ID != c.Session.UserID && if status.Mentions[i].ID != c.s.UserID &&
status.Mentions[i].ID != status.Account.ID { status.Mentions[i].ID != status.Account.ID {
content += "@" + status.Mentions[i].Acct + " " content += "@" + status.Mentions[i].Acct + " "
} }
} }
isDirect := status.Visibility == "direct" isDirect := status.Visibility == "direct"
if isDirect || c.Session.Settings.CopyScope { if isDirect || c.s.Settings.CopyScope {
visibility = status.Visibility visibility = status.Visibility
} else { } else {
visibility = c.Session.Settings.DefaultVisibility visibility = c.s.Settings.DefaultVisibility
} }
postContext = model.PostContext{ pctx = model.PostContext{
DefaultVisibility: visibility, DefaultVisibility: visibility,
DefaultFormat: c.Session.Settings.DefaultFormat, DefaultFormat: c.s.Settings.DefaultFormat,
Formats: s.postFormats, Formats: s.postFormats,
ReplyContext: &model.ReplyContext{ ReplyContext: &model.ReplyContext{
InReplyToID: id, InReplyToID: id,
@ -274,7 +286,7 @@ func (s *service) ThreadPage(c *client, id string, reply bool) (err error) {
} }
} }
context, err := c.GetStatusContext(ctx, id) context, err := c.GetStatusContext(c.ctx, id)
if err != nil { if err != nil {
return return
} }
@ -293,44 +305,40 @@ func (s *service) ThreadPage(c *client, id string, reply bool) (err error) {
addToReplyMap(replies, statuses[i].InReplyToID, statuses[i].ID, i+1) addToReplyMap(replies, statuses[i].InReplyToID, statuses[i].ID, i+1)
} }
commonData := s.getCommonData(c, "post by "+status.Account.DisplayName) cdata := s.cdata(c, "post by "+status.Account.DisplayName, 0, 0, "")
data := &renderer.ThreadData{ data := &renderer.ThreadData{
Statuses: statuses, Statuses: statuses,
PostContext: postContext, PostContext: pctx,
ReplyMap: replies, ReplyMap: replies,
CommonData: commonData, CommonData: cdata,
} }
return s.renderer.Render(c.rctx, c.w, renderer.ThreadPage, data)
rCtx := getRendererContext(c)
return s.renderer.Render(rCtx, c, renderer.ThreadPage, data)
} }
func (s *service) LikedByPage(c *client, id string) (err error) { func (s *service) LikedByPage(c *client, id string) (err error) {
likers, err := c.GetFavouritedBy(ctx, id, nil) likers, err := c.GetFavouritedBy(c.ctx, id, nil)
if err != nil { if err != nil {
return return
} }
commonData := s.getCommonData(c, "likes") cdata := s.cdata(c, "likes", 0, 0, "")
data := &renderer.LikedByData{ data := &renderer.LikedByData{
CommonData: commonData, CommonData: cdata,
Users: likers, Users: likers,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.LikedByPage, data)
return s.renderer.Render(rCtx, c, renderer.LikedByPage, data)
} }
func (s *service) RetweetedByPage(c *client, id string) (err error) { func (s *service) RetweetedByPage(c *client, id string) (err error) {
retweeters, err := c.GetRebloggedBy(ctx, id, nil) retweeters, err := c.GetRebloggedBy(c.ctx, id, nil)
if err != nil { if err != nil {
return return
} }
commonData := s.getCommonData(c, "retweets") cdata := s.cdata(c, "retweets", 0, 0, "")
data := &renderer.RetweetedByData{ data := &renderer.RetweetedByData{
CommonData: commonData, CommonData: cdata,
Users: retweeters, Users: retweeters,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.RetweetedByPage, data)
return s.renderer.Render(rCtx, c, renderer.RetweetedByPage, data)
} }
func (s *service) NotificationPage(c *client, maxID string, func (s *service) NotificationPage(c *client, maxID string,
@ -346,11 +354,11 @@ func (s *service) NotificationPage(c *client, maxID string,
Limit: 20, Limit: 20,
} }
if c.Session.Settings.AntiDopamineMode { if c.s.Settings.AntiDopamineMode {
excludes = []string{"follow", "favourite", "reblog"} excludes = []string{"follow", "favourite", "reblog"}
} }
notifications, err := c.GetNotifications(ctx, &pg, excludes) notifications, err := c.GetNotifications(c.ctx, &pg, excludes)
if err != nil { if err != nil {
return return
} }
@ -368,19 +376,16 @@ func (s *service) NotificationPage(c *client, maxID string,
nextLink = "/notifications?max_id=" + pg.MaxID nextLink = "/notifications?max_id=" + pg.MaxID
} }
commonData := s.getCommonData(c, "notifications") cdata := s.cdata(c, "notifications", unreadCount,
commonData.RefreshInterval = c.Session.Settings.NotificationInterval c.s.Settings.NotificationInterval, "main")
commonData.Target = "main"
commonData.Count = unreadCount
data := &renderer.NotificationData{ data := &renderer.NotificationData{
Notifications: notifications, Notifications: notifications,
UnreadCount: unreadCount, UnreadCount: unreadCount,
ReadID: readID, ReadID: readID,
NextLink: nextLink, NextLink: nextLink,
CommonData: commonData, CommonData: cdata,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.NotificationPage, data)
return s.renderer.Render(rCtx, c, renderer.NotificationPage, data)
} }
func (s *service) UserPage(c *client, id string, pageType string, func (s *service) UserPage(c *client, id string, pageType string,
@ -395,15 +400,15 @@ func (s *service) UserPage(c *client, id string, pageType string,
Limit: 20, Limit: 20,
} }
user, err := c.GetAccount(ctx, id) user, err := c.GetAccount(c.ctx, id)
if err != nil { if err != nil {
return return
} }
isCurrent := c.Session.UserID == user.ID isCurrent := c.s.UserID == user.ID
switch pageType { switch pageType {
case "": case "":
statuses, err = c.GetAccountStatuses(ctx, id, false, &pg) statuses, err = c.GetAccountStatuses(c.ctx, id, false, &pg)
if err != nil { if err != nil {
return return
} }
@ -412,7 +417,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
pg.MaxID) pg.MaxID)
} }
case "following": case "following":
users, err = c.GetAccountFollowing(ctx, id, &pg) users, err = c.GetAccountFollowing(c.ctx, id, &pg)
if err != nil { if err != nil {
return return
} }
@ -421,7 +426,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
id, pg.MaxID) id, pg.MaxID)
} }
case "followers": case "followers":
users, err = c.GetAccountFollowers(ctx, id, &pg) users, err = c.GetAccountFollowers(c.ctx, id, &pg)
if err != nil { if err != nil {
return return
} }
@ -430,7 +435,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
id, pg.MaxID) id, pg.MaxID)
} }
case "media": case "media":
statuses, err = c.GetAccountStatuses(ctx, id, true, &pg) statuses, err = c.GetAccountStatuses(c.ctx, id, true, &pg)
if err != nil { if err != nil {
return return
} }
@ -442,7 +447,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
if !isCurrent { if !isCurrent {
return errInvalidArgument return errInvalidArgument
} }
statuses, err = c.GetBookmarks(ctx, &pg) statuses, err = c.GetBookmarks(c.ctx, &pg)
if err != nil { if err != nil {
return return
} }
@ -454,7 +459,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
if !isCurrent { if !isCurrent {
return errInvalidArgument return errInvalidArgument
} }
users, err = c.GetMutes(ctx, &pg) users, err = c.GetMutes(c.ctx, &pg)
if err != nil { if err != nil {
return return
} }
@ -466,7 +471,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
if !isCurrent { if !isCurrent {
return errInvalidArgument return errInvalidArgument
} }
users, err = c.GetBlocks(ctx, &pg) users, err = c.GetBlocks(c.ctx, &pg)
if err != nil { if err != nil {
return return
} }
@ -478,7 +483,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
if !isCurrent { if !isCurrent {
return errInvalidArgument return errInvalidArgument
} }
statuses, err = c.GetFavourites(ctx, &pg) statuses, err = c.GetFavourites(c.ctx, &pg)
if err != nil { if err != nil {
return return
} }
@ -490,7 +495,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
if !isCurrent { if !isCurrent {
return errInvalidArgument return errInvalidArgument
} }
users, err = c.GetFollowRequests(ctx, &pg) users, err = c.GetFollowRequests(c.ctx, &pg)
if err != nil { if err != nil {
return return
} }
@ -508,7 +513,7 @@ func (s *service) UserPage(c *client, id string, pageType string,
} }
} }
commonData := s.getCommonData(c, user.DisplayName+" @"+user.Acct) cdata := s.cdata(c, user.DisplayName+" @"+user.Acct, 0, 0, "")
data := &renderer.UserData{ data := &renderer.UserData{
User: user, User: user,
IsCurrent: isCurrent, IsCurrent: isCurrent,
@ -516,10 +521,9 @@ func (s *service) UserPage(c *client, id string, pageType string,
Users: users, Users: users,
Statuses: statuses, Statuses: statuses,
NextLink: nextLink, NextLink: nextLink,
CommonData: commonData, CommonData: cdata,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.UserPage, data)
return s.renderer.Render(rCtx, c, renderer.UserPage, data)
} }
func (s *service) UserSearchPage(c *client, func (s *service) UserSearchPage(c *client,
@ -528,14 +532,14 @@ func (s *service) UserSearchPage(c *client,
var nextLink string var nextLink string
var title = "search" var title = "search"
user, err := c.GetAccount(ctx, id) user, err := c.GetAccount(c.ctx, id)
if err != nil { if err != nil {
return return
} }
var results *mastodon.Results var results *mastodon.Results
if len(q) > 0 { if len(q) > 0 {
results, err = c.Search(ctx, q, "statuses", 20, true, offset, id) results, err = c.Search(c.ctx, q, "statuses", 20, true, offset, id)
if err != nil { if err != nil {
return err return err
} }
@ -554,39 +558,36 @@ func (s *service) UserSearchPage(c *client,
title += " \"" + qq + "\"" title += " \"" + qq + "\""
} }
commonData := s.getCommonData(c, title) cdata := s.cdata(c, title, 0, 0, "")
data := &renderer.UserSearchData{ data := &renderer.UserSearchData{
CommonData: commonData, CommonData: cdata,
User: user, User: user,
Q: qq, Q: qq,
Statuses: results.Statuses, Statuses: results.Statuses,
NextLink: nextLink, NextLink: nextLink,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.UserSearchPage, data)
return s.renderer.Render(rCtx, c, renderer.UserSearchPage, data)
} }
func (s *service) AboutPage(c *client) (err error) { func (s *service) AboutPage(c *client) (err error) {
commonData := s.getCommonData(c, "about") cdata := s.cdata(c, "about", 0, 0, "")
data := &renderer.AboutData{ data := &renderer.AboutData{
CommonData: commonData, CommonData: cdata,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.AboutPage, data)
return s.renderer.Render(rCtx, c, renderer.AboutPage, data)
} }
func (s *service) EmojiPage(c *client) (err error) { func (s *service) EmojiPage(c *client) (err error) {
emojis, err := c.GetInstanceEmojis(ctx) emojis, err := c.GetInstanceEmojis(c.ctx)
if err != nil { if err != nil {
return return
} }
commonData := s.getCommonData(c, "emojis") cdata := s.cdata(c, "emojis", 0, 0, "")
data := &renderer.EmojiData{ data := &renderer.EmojiData{
Emojis: emojis, Emojis: emojis,
CommonData: commonData, CommonData: cdata,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.EmojiPage, data)
return s.renderer.Render(rCtx, c, renderer.EmojiPage, data)
} }
func (s *service) SearchPage(c *client, func (s *service) SearchPage(c *client,
@ -597,7 +598,7 @@ func (s *service) SearchPage(c *client,
var results *mastodon.Results var results *mastodon.Results
if len(q) > 0 { if len(q) > 0 {
results, err = c.Search(ctx, q, qType, 20, true, offset, "") results, err = c.Search(c.ctx, q, qType, 20, true, offset, "")
if err != nil { if err != nil {
return err return err
} }
@ -617,55 +618,50 @@ func (s *service) SearchPage(c *client,
title += " \"" + qq + "\"" title += " \"" + qq + "\""
} }
commonData := s.getCommonData(c, title) cdata := s.cdata(c, title, 0, 0, "")
data := &renderer.SearchData{ data := &renderer.SearchData{
CommonData: commonData, CommonData: cdata,
Q: qq, Q: qq,
Type: qType, Type: qType,
Users: results.Accounts, Users: results.Accounts,
Statuses: results.Statuses, Statuses: results.Statuses,
NextLink: nextLink, NextLink: nextLink,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.SearchPage, data)
return s.renderer.Render(rCtx, c, renderer.SearchPage, data)
} }
func (s *service) SettingsPage(c *client) (err error) { func (s *service) SettingsPage(c *client) (err error) {
commonData := s.getCommonData(c, "settings") cdata := s.cdata(c, "settings", 0, 0, "")
data := &renderer.SettingsData{ data := &renderer.SettingsData{
CommonData: commonData, CommonData: cdata,
Settings: &c.Session.Settings, Settings: &c.s.Settings,
PostFormats: s.postFormats, PostFormats: s.postFormats,
} }
rCtx := getRendererContext(c) return s.renderer.Render(c.rctx, c.w, renderer.SettingsPage, data)
return s.renderer.Render(rCtx, c, renderer.SettingsPage, data)
} }
func (svc *service) FiltersPage(c *client) (err error) { func (svc *service) FiltersPage(c *client) (err error) {
filters, err := c.GetFilters(ctx) filters, err := c.GetFilters(c.ctx)
if err != nil { if err != nil {
return return
} }
cdata := svc.cdata(c, "filters", 0, 0, "")
commonData := svc.getCommonData(c, "filters")
data := &renderer.FiltersData{ data := &renderer.FiltersData{
CommonData: commonData, CommonData: cdata,
Filters: filters, Filters: filters,
} }
return svc.renderer.Render(c.rctx, c.w, renderer.FiltersPage, data)
rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c, renderer.FiltersPage, data)
} }
func (s *service) SingleInstance() (instance string, ok bool) { func (s *service) SingleInstance() (instance string, ok bool) {
if len(s.singleInstance) > 0 { if len(s.instance) > 0 {
instance = s.singleInstance instance = s.instance
ok = true ok = true
} }
return return
} }
func (s *service) NewSession(instance string) (rurl string, sid string, err error) { func (s *service) NewSession(c *client, instance string) (rurl string, sid string, err error) {
var instanceURL string var instanceURL string
if strings.HasPrefix(instance, "https://") { if strings.HasPrefix(instance, "https://") {
instanceURL = instance instanceURL = instance
@ -678,18 +674,18 @@ func (s *service) NewSession(instance string) (rurl string, sid string, err erro
if err != nil { if err != nil {
return return
} }
csrfToken, err := util.NewCSRFToken() csrf, err := util.NewCSRFToken()
if err != nil { if err != nil {
return return
} }
session := model.Session{ sess := model.Session{
ID: sid, ID: sid,
InstanceDomain: instance, InstanceDomain: instance,
CSRFToken: csrfToken, CSRFToken: csrf,
Settings: *model.NewSettings(), Settings: *model.NewSettings(),
} }
err = s.sessionRepo.Add(session) err = s.sessionRepo.Add(sess)
if err != nil { if err != nil {
return return
} }
@ -699,12 +695,12 @@ func (s *service) NewSession(instance string) (rurl string, sid string, err erro
if err != model.ErrAppNotFound { if err != model.ErrAppNotFound {
return return
} }
mastoApp, err := mastodon.RegisterApp(ctx, &mastodon.AppConfig{ mastoApp, err := mastodon.RegisterApp(c.ctx, &mastodon.AppConfig{
Server: instanceURL, Server: instanceURL,
ClientName: s.clientName, ClientName: s.cname,
Scopes: s.clientScope, Scopes: s.cscope,
Website: s.clientWebsite, Website: s.cwebsite,
RedirectURIs: s.clientWebsite + "/oauth_callback", RedirectURIs: s.cwebsite + "/oauth_callback",
}) })
if err != nil { if err != nil {
return "", "", err return "", "", err
@ -730,36 +726,33 @@ func (s *service) NewSession(instance string) (rurl string, sid string, err erro
q.Set("scope", "read write follow") q.Set("scope", "read write follow")
q.Set("client_id", app.ClientID) q.Set("client_id", app.ClientID)
q.Set("response_type", "code") q.Set("response_type", "code")
q.Set("redirect_uri", s.clientWebsite+"/oauth_callback") q.Set("redirect_uri", s.cwebsite+"/oauth_callback")
u.RawQuery = q.Encode() u.RawQuery = q.Encode()
rurl = instanceURL + u.String() rurl = instanceURL + u.String()
return return
} }
func (s *service) Signin(c *client, code string) (token string, func (s *service) Signin(c *client, code string) (err error) {
userID string, err error) {
if len(code) < 1 { if len(code) < 1 {
err = errInvalidArgument err = errInvalidArgument
return return
} }
err = c.AuthenticateToken(ctx, code, s.clientWebsite+"/oauth_callback") err = c.AuthenticateToken(c.ctx, code, s.cwebsite+"/oauth_callback")
if err != nil { if err != nil {
return return
} }
token = c.GetAccessToken(ctx) u, err := c.GetAccountCurrentUser(c.ctx)
u, err := c.GetAccountCurrentUser(ctx)
if err != nil { if err != nil {
return return
} }
userID = u.ID c.s.AccessToken = c.GetAccessToken(c.ctx)
return c.s.UserID = u.ID
return s.sessionRepo.Add(c.s)
} }
func (s *service) Signout(c *client) (err error) { func (s *service) Signout(c *client) (err error) {
s.sessionRepo.Remove(c.Session.ID) s.sessionRepo.Remove(c.s.ID)
return return
} }
@ -769,7 +762,7 @@ func (s *service) Post(c *client, content string, replyToID string,
var mediaIDs []string var mediaIDs []string
for _, f := range files { for _, f := range files {
a, err := c.UploadMediaFromMultipartFileHeader(ctx, f) a, err := c.UploadMediaFromMultipartFileHeader(c.ctx, f)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -784,7 +777,7 @@ func (s *service) Post(c *client, content string, replyToID string,
Visibility: visibility, Visibility: visibility,
Sensitive: isNSFW, Sensitive: isNSFW,
} }
st, err := c.PostStatus(ctx, tweet) st, err := c.PostStatus(c.ctx, tweet)
if err != nil { if err != nil {
return return
} }
@ -792,7 +785,7 @@ func (s *service) Post(c *client, content string, replyToID string,
} }
func (s *service) Like(c *client, id string) (count int64, err error) { func (s *service) Like(c *client, id string) (count int64, err error) {
st, err := c.Favourite(ctx, id) st, err := c.Favourite(c.ctx, id)
if err != nil { if err != nil {
return return
} }
@ -801,7 +794,7 @@ func (s *service) Like(c *client, id string) (count int64, err error) {
} }
func (s *service) UnLike(c *client, id string) (count int64, err error) { func (s *service) UnLike(c *client, id string) (count int64, err error) {
st, err := c.Unfavourite(ctx, id) st, err := c.Unfavourite(c.ctx, id)
if err != nil { if err != nil {
return return
} }
@ -810,7 +803,7 @@ func (s *service) UnLike(c *client, id string) (count int64, err error) {
} }
func (s *service) Retweet(c *client, id string) (count int64, err error) { func (s *service) Retweet(c *client, id string) (count int64, err error) {
st, err := c.Reblog(ctx, id) st, err := c.Reblog(c.ctx, id)
if err != nil { if err != nil {
return return
} }
@ -822,7 +815,7 @@ func (s *service) Retweet(c *client, id string) (count int64, err error) {
func (s *service) UnRetweet(c *client, id string) ( func (s *service) UnRetweet(c *client, id string) (
count int64, err error) { count int64, err error) {
st, err := c.Unreblog(ctx, id) st, err := c.Unreblog(c.ctx, id)
if err != nil { if err != nil {
return return
} }
@ -831,55 +824,55 @@ func (s *service) UnRetweet(c *client, id string) (
} }
func (s *service) Vote(c *client, id string, choices []string) (err error) { func (s *service) Vote(c *client, id string, choices []string) (err error) {
_, err = c.Vote(ctx, id, choices) _, err = c.Vote(c.ctx, id, choices)
return return
} }
func (s *service) Follow(c *client, id string, reblogs *bool) (err error) { func (s *service) Follow(c *client, id string, reblogs *bool) (err error) {
_, err = c.AccountFollow(ctx, id, reblogs) _, err = c.AccountFollow(c.ctx, id, reblogs)
return return
} }
func (s *service) UnFollow(c *client, id string) (err error) { func (s *service) UnFollow(c *client, id string) (err error) {
_, err = c.AccountUnfollow(ctx, id) _, err = c.AccountUnfollow(c.ctx, id)
return return
} }
func (s *service) Accept(c *client, id string) (err error) { func (s *service) Accept(c *client, id string) (err error) {
return c.FollowRequestAuthorize(ctx, id) return c.FollowRequestAuthorize(c.ctx, id)
} }
func (s *service) Reject(c *client, id string) (err error) { func (s *service) Reject(c *client, id string) (err error) {
return c.FollowRequestReject(ctx, id) return c.FollowRequestReject(c.ctx, id)
} }
func (s *service) Mute(c *client, id string) (err error) { func (s *service) Mute(c *client, id string) (err error) {
_, err = c.AccountMute(ctx, id) _, err = c.AccountMute(c.ctx, id)
return return
} }
func (s *service) UnMute(c *client, id string) (err error) { func (s *service) UnMute(c *client, id string) (err error) {
_, err = c.AccountUnmute(ctx, id) _, err = c.AccountUnmute(c.ctx, id)
return return
} }
func (s *service) Block(c *client, id string) (err error) { func (s *service) Block(c *client, id string) (err error) {
_, err = c.AccountBlock(ctx, id) _, err = c.AccountBlock(c.ctx, id)
return return
} }
func (s *service) UnBlock(c *client, id string) (err error) { func (s *service) UnBlock(c *client, id string) (err error) {
_, err = c.AccountUnblock(ctx, id) _, err = c.AccountUnblock(c.ctx, id)
return return
} }
func (s *service) Subscribe(c *client, id string) (err error) { func (s *service) Subscribe(c *client, id string) (err error) {
_, err = c.Subscribe(ctx, id) _, err = c.Subscribe(c.ctx, id)
return return
} }
func (s *service) UnSubscribe(c *client, id string) (err error) { func (s *service) UnSubscribe(c *client, id string) (err error) {
_, err = c.UnSubscribe(ctx, id) _, err = c.UnSubscribe(c.ctx, id)
return return
} }
@ -889,47 +882,47 @@ func (s *service) SaveSettings(c *client, settings *model.Settings) (err error)
default: default:
return errInvalidArgument return errInvalidArgument
} }
session, err := s.sessionRepo.Get(c.Session.ID) sess, err := s.sessionRepo.Get(c.s.ID)
if err != nil { if err != nil {
return return
} }
session.Settings = *settings sess.Settings = *settings
return s.sessionRepo.Add(session) return s.sessionRepo.Add(sess)
} }
func (s *service) MuteConversation(c *client, id string) (err error) { func (s *service) MuteConversation(c *client, id string) (err error) {
_, err = c.MuteConversation(ctx, id) _, err = c.MuteConversation(c.ctx, id)
return return
} }
func (s *service) UnMuteConversation(c *client, id string) (err error) { func (s *service) UnMuteConversation(c *client, id string) (err error) {
_, err = c.UnmuteConversation(ctx, id) _, err = c.UnmuteConversation(c.ctx, id)
return return
} }
func (s *service) Delete(c *client, id string) (err error) { func (s *service) Delete(c *client, id string) (err error) {
return c.DeleteStatus(ctx, id) return c.DeleteStatus(c.ctx, id)
} }
func (s *service) ReadNotifications(c *client, maxID string) (err error) { func (s *service) ReadNotifications(c *client, maxID string) (err error) {
return c.ReadNotifications(ctx, maxID) return c.ReadNotifications(c.ctx, maxID)
} }
func (s *service) Bookmark(c *client, id string) (err error) { func (s *service) Bookmark(c *client, id string) (err error) {
_, err = c.Bookmark(ctx, id) _, err = c.Bookmark(c.ctx, id)
return return
} }
func (s *service) UnBookmark(c *client, id string) (err error) { func (s *service) UnBookmark(c *client, id string) (err error) {
_, err = c.Unbookmark(ctx, id) _, err = c.Unbookmark(c.ctx, id)
return return
} }
func (svc *service) Filter(c *client, phrase string, wholeWord bool) (err error) { func (svc *service) Filter(c *client, phrase string, wholeWord bool) (err error) {
fctx := []string{"home", "notifications", "public", "thread"} fctx := []string{"home", "notifications", "public", "thread"}
return c.AddFilter(ctx, phrase, fctx, true, wholeWord, nil) return c.AddFilter(c.ctx, phrase, fctx, true, wholeWord, nil)
} }
func (svc *service) UnFilter(c *client, id string) (err error) { func (svc *service) UnFilter(c *client, id string) (err error) {
return c.RemoveFilter(ctx, id) return c.RemoveFilter(c.ctx, id)
} }

301
service/transport.go
View file

@ -1,8 +1,8 @@
package service package service
import ( import (
"context"
"encoding/json" "encoding/json"
"errors"
"log" "log"
"net/http" "net/http"
"strconv" "strconv"
@ -10,44 +10,34 @@ import (
"bloat/mastodon" "bloat/mastodon"
"bloat/model" "bloat/model"
"bloat/renderer"
"github.com/gorilla/mux" "github.com/gorilla/mux"
) )
var (
errInvalidSession = errors.New("invalid session")
errInvalidCSRFToken = errors.New("invalid csrf token")
)
const ( const (
sessionExp = 365 * 24 * time.Hour sessionExp = 365 * 24 * time.Hour
) )
type respType int
const ( const (
HTML respType = iota HTML int = iota
JSON JSON
) )
type authType int
const ( const (
NOAUTH authType = iota NOAUTH int = iota
SESSION SESSION
CSRF CSRF
) )
type client struct { type client struct {
*mastodon.Client *mastodon.Client
http.ResponseWriter w http.ResponseWriter
Req *http.Request r *http.Request
CSRFToken string s model.Session
Session model.Session csrf string
} ctx context.Context
rctx *renderer.Context
func (c *client) url() string {
return c.Req.URL.RequestURI()
} }
func setSessionCookie(w http.ResponseWriter, sid string, exp time.Duration) { func setSessionCookie(w http.ResponseWriter, sid string, exp time.Duration) {
@ -59,66 +49,50 @@ func setSessionCookie(w http.ResponseWriter, sid string, exp time.Duration) {
} }
func writeJson(c *client, data interface{}) error { func writeJson(c *client, data interface{}) error {
return json.NewEncoder(c).Encode(map[string]interface{}{ return json.NewEncoder(c.w).Encode(map[string]interface{}{
"data": data, "data": data,
}) })
} }
func redirect(c *client, url string) { func redirect(c *client, url string) {
c.Header().Add("Location", url) c.w.Header().Add("Location", url)
c.WriteHeader(http.StatusFound) c.w.WriteHeader(http.StatusFound)
} }
func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler { func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
r := mux.NewRouter() r := mux.NewRouter()
writeError := func(c *client, err error, t respType) { writeError := func(c *client, err error, t int) {
switch t { switch t {
case HTML: case HTML:
c.WriteHeader(http.StatusInternalServerError) c.w.WriteHeader(http.StatusInternalServerError)
s.ErrorPage(c, err) s.ErrorPage(c, err)
case JSON: case JSON:
c.WriteHeader(http.StatusInternalServerError) c.w.WriteHeader(http.StatusInternalServerError)
json.NewEncoder(c).Encode(map[string]string{ json.NewEncoder(c.w).Encode(map[string]string{
"error": err.Error(), "error": err.Error(),
}) })
} }
} }
authenticate := func(c *client, t authType) error { authenticate := func(c *client, t int) error {
if t >= SESSION { var sid string
cookie, err := c.Req.Cookie("session_id") if cookie, _ := c.r.Cookie("session_id"); cookie != nil {
if err != nil || len(cookie.Value) < 1 { sid = cookie.Value
return errInvalidSession
}
c.Session, err = s.sessionRepo.Get(cookie.Value)
if err != nil {
return errInvalidSession
}
app, err := s.appRepo.Get(c.Session.InstanceDomain)
if err != nil {
return err
}
c.Client = mastodon.NewClient(&mastodon.Config{
Server: app.InstanceURL,
ClientID: app.ClientID,
ClientSecret: app.ClientSecret,
AccessToken: c.Session.AccessToken,
})
} }
if t >= CSRF { csrf := c.r.FormValue("csrf_token")
c.CSRFToken = c.Req.FormValue("csrf_token") ref := c.r.URL.RequestURI()
if len(c.CSRFToken) < 1 || c.CSRFToken != c.Session.CSRFToken { return s.authenticate(c, sid, csrf, ref, t)
return errInvalidCSRFToken
}
}
return nil
} }
handle := func(f func(c *client) error, at authType, rt respType) http.HandlerFunc { handle := func(f func(c *client) error, at int, rt int) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) { return func(w http.ResponseWriter, req *http.Request) {
var err error var err error
c := &client{Req: req, ResponseWriter: w} c := &client{
ctx: req.Context(),
w: w,
r: req,
}
defer func(begin time.Time) { defer func(begin time.Time) {
logger.Printf("path=%s, err=%v, took=%v\n", logger.Printf("path=%s, err=%v, took=%v\n",
@ -132,7 +106,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
case JSON: case JSON:
ct = "application/json" ct = "application/json"
} }
c.Header().Add("Content-Type", ct) c.w.Header().Add("Content-Type", ct)
err = authenticate(c, at) err = authenticate(c, at)
if err != nil { if err != nil {
@ -149,12 +123,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
} }
rootPage := handle(func(c *client) error { rootPage := handle(func(c *client) error {
sid, _ := c.Req.Cookie("session_id") err := authenticate(c, SESSION)
if sid == nil || len(sid.Value) < 0 {
redirect(c, "/signin")
return nil
}
session, err := s.sessionRepo.Get(sid.Value)
if err != nil { if err != nil {
if err == errInvalidSession { if err == errInvalidSession {
redirect(c, "/signin") redirect(c, "/signin")
@ -162,7 +131,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
} }
return err return err
} }
if len(session.AccessToken) < 1 { if !c.s.IsLoggedIn() {
redirect(c, "/signin") redirect(c, "/signin")
return nil return nil
} }
@ -178,18 +147,18 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if !ok { if !ok {
return s.SigninPage(c) return s.SigninPage(c)
} }
url, sid, err := s.NewSession(instance) url, sid, err := s.NewSession(c, instance)
if err != nil { if err != nil {
return err return err
} }
setSessionCookie(c, sid, sessionExp) setSessionCookie(c.w, sid, sessionExp)
redirect(c, url) redirect(c, url)
return nil return nil
}, NOAUTH, HTML) }, NOAUTH, HTML)
timelinePage := handle(func(c *client) error { timelinePage := handle(func(c *client) error {
tType, _ := mux.Vars(c.Req)["type"] tType, _ := mux.Vars(c.r)["type"]
q := c.Req.URL.Query() q := c.r.URL.Query()
instance := q.Get("instance") instance := q.Get("instance")
maxID := q.Get("max_id") maxID := q.Get("max_id")
minID := q.Get("min_id") minID := q.Get("min_id")
@ -202,41 +171,41 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, SESSION, HTML) }, SESSION, HTML)
threadPage := handle(func(c *client) error { threadPage := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
q := c.Req.URL.Query() q := c.r.URL.Query()
reply := q.Get("reply") reply := q.Get("reply")
return s.ThreadPage(c, id, len(reply) > 1) return s.ThreadPage(c, id, len(reply) > 1)
}, SESSION, HTML) }, SESSION, HTML)
likedByPage := handle(func(c *client) error { likedByPage := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
return s.LikedByPage(c, id) return s.LikedByPage(c, id)
}, SESSION, HTML) }, SESSION, HTML)
retweetedByPage := handle(func(c *client) error { retweetedByPage := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
return s.RetweetedByPage(c, id) return s.RetweetedByPage(c, id)
}, SESSION, HTML) }, SESSION, HTML)
notificationsPage := handle(func(c *client) error { notificationsPage := handle(func(c *client) error {
q := c.Req.URL.Query() q := c.r.URL.Query()
maxID := q.Get("max_id") maxID := q.Get("max_id")
minID := q.Get("min_id") minID := q.Get("min_id")
return s.NotificationPage(c, maxID, minID) return s.NotificationPage(c, maxID, minID)
}, SESSION, HTML) }, SESSION, HTML)
userPage := handle(func(c *client) error { userPage := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
pageType, _ := mux.Vars(c.Req)["type"] pageType, _ := mux.Vars(c.r)["type"]
q := c.Req.URL.Query() q := c.r.URL.Query()
maxID := q.Get("max_id") maxID := q.Get("max_id")
minID := q.Get("min_id") minID := q.Get("min_id")
return s.UserPage(c, id, pageType, maxID, minID) return s.UserPage(c, id, pageType, maxID, minID)
}, SESSION, HTML) }, SESSION, HTML)
userSearchPage := handle(func(c *client) error { userSearchPage := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
q := c.Req.URL.Query() q := c.r.URL.Query()
sq := q.Get("q") sq := q.Get("q")
offset, _ := strconv.Atoi(q.Get("offset")) offset, _ := strconv.Atoi(q.Get("offset"))
return s.UserSearchPage(c, id, sq, offset) return s.UserSearchPage(c, id, sq, offset)
@ -251,7 +220,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, SESSION, HTML) }, SESSION, HTML)
searchPage := handle(func(c *client) error { searchPage := handle(func(c *client) error {
q := c.Req.URL.Query() q := c.r.URL.Query()
sq := q.Get("q") sq := q.Get("q")
qType := q.Get("type") qType := q.Get("type")
offset, _ := strconv.Atoi(q.Get("offset")) offset, _ := strconv.Atoi(q.Get("offset"))
@ -267,49 +236,41 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, SESSION, HTML) }, SESSION, HTML)
signin := handle(func(c *client) error { signin := handle(func(c *client) error {
instance := c.Req.FormValue("instance") instance := c.r.FormValue("instance")
url, sid, err := s.NewSession(instance) url, sid, err := s.NewSession(c, instance)
if err != nil { if err != nil {
return err return err
} }
setSessionCookie(c, sid, sessionExp) setSessionCookie(c.w, sid, sessionExp)
redirect(c, url) redirect(c, url)
return nil return nil
}, NOAUTH, HTML) }, NOAUTH, HTML)
oauthCallback := handle(func(c *client) error { oauthCallback := handle(func(c *client) error {
q := c.Req.URL.Query() q := c.r.URL.Query()
token := q.Get("code") token := q.Get("code")
token, userID, err := s.Signin(c, token) err := s.Signin(c, token)
if err != nil { if err != nil {
return err return err
} }
c.Session.AccessToken = token
c.Session.UserID = userID
err = s.sessionRepo.Add(c.Session)
if err != nil {
return err
}
redirect(c, "/") redirect(c, "/")
return nil return nil
}, SESSION, HTML) }, SESSION, HTML)
post := handle(func(c *client) error { post := handle(func(c *client) error {
content := c.Req.FormValue("content") content := c.r.FormValue("content")
replyToID := c.Req.FormValue("reply_to_id") replyToID := c.r.FormValue("reply_to_id")
format := c.Req.FormValue("format") format := c.r.FormValue("format")
visibility := c.Req.FormValue("visibility") visibility := c.r.FormValue("visibility")
isNSFW := c.Req.FormValue("is_nsfw") == "on" isNSFW := c.r.FormValue("is_nsfw") == "true"
files := c.Req.MultipartForm.File["attachments"] files := c.r.MultipartForm.File["attachments"]
id, err := s.Post(c, content, replyToID, format, visibility, isNSFW, files) id, err := s.Post(c, content, replyToID, format, visibility, isNSFW, files)
if err != nil { if err != nil {
return err return err
} }
location := c.Req.FormValue("referrer") location := c.r.FormValue("referrer")
if len(replyToID) > 0 { if len(replyToID) > 0 {
location = "/thread/" + replyToID + "#status-" + id location = "/thread/" + replyToID + "#status-" + id
} }
@ -318,8 +279,8 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, CSRF, HTML) }, CSRF, HTML)
like := handle(func(c *client) error { like := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
rid := c.Req.FormValue("retweeted_by_id") rid := c.r.FormValue("retweeted_by_id")
_, err := s.Like(c, id) _, err := s.Like(c, id)
if err != nil { if err != nil {
return err return err
@ -327,13 +288,13 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if len(rid) > 0 { if len(rid) > 0 {
id = rid id = rid
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+id) redirect(c, c.r.FormValue("referrer")+"#status-"+id)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unlike := handle(func(c *client) error { unlike := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
rid := c.Req.FormValue("retweeted_by_id") rid := c.r.FormValue("retweeted_by_id")
_, err := s.UnLike(c, id) _, err := s.UnLike(c, id)
if err != nil { if err != nil {
return err return err
@ -341,13 +302,13 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if len(rid) > 0 { if len(rid) > 0 {
id = rid id = rid
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+id) redirect(c, c.r.FormValue("referrer")+"#status-"+id)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
retweet := handle(func(c *client) error { retweet := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
rid := c.Req.FormValue("retweeted_by_id") rid := c.r.FormValue("retweeted_by_id")
_, err := s.Retweet(c, id) _, err := s.Retweet(c, id)
if err != nil { if err != nil {
return err return err
@ -355,13 +316,13 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if len(rid) > 0 { if len(rid) > 0 {
id = rid id = rid
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+id) redirect(c, c.r.FormValue("referrer")+"#status-"+id)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unretweet := handle(func(c *client) error { unretweet := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
rid := c.Req.FormValue("retweeted_by_id") rid := c.r.FormValue("retweeted_by_id")
_, err := s.UnRetweet(c, id) _, err := s.UnRetweet(c, id)
if err != nil { if err != nil {
return err return err
@ -369,25 +330,25 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if len(rid) > 0 { if len(rid) > 0 {
id = rid id = rid
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+id) redirect(c, c.r.FormValue("referrer")+"#status-"+id)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
vote := handle(func(c *client) error { vote := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
statusID := c.Req.FormValue("status_id") statusID := c.r.FormValue("status_id")
choices, _ := c.Req.PostForm["choices"] choices, _ := c.r.PostForm["choices"]
err := s.Vote(c, id, choices) err := s.Vote(c, id, choices)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+statusID) redirect(c, c.r.FormValue("referrer")+"#status-"+statusID)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
follow := handle(func(c *client) error { follow := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
q := c.Req.URL.Query() q := c.r.URL.Query()
var reblogs *bool var reblogs *bool
if r, ok := q["reblogs"]; ok && len(r) > 0 { if r, ok := q["reblogs"]; ok && len(r) > 0 {
reblogs = new(bool) reblogs = new(bool)
@ -397,111 +358,111 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unfollow := handle(func(c *client) error { unfollow := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.UnFollow(c, id) err := s.UnFollow(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
accept := handle(func(c *client) error { accept := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.Accept(c, id) err := s.Accept(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
reject := handle(func(c *client) error { reject := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.Reject(c, id) err := s.Reject(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
mute := handle(func(c *client) error { mute := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.Mute(c, id) err := s.Mute(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unMute := handle(func(c *client) error { unMute := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.UnMute(c, id) err := s.UnMute(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
block := handle(func(c *client) error { block := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.Block(c, id) err := s.Block(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unBlock := handle(func(c *client) error { unBlock := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.UnBlock(c, id) err := s.UnBlock(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
subscribe := handle(func(c *client) error { subscribe := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.Subscribe(c, id) err := s.Subscribe(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unSubscribe := handle(func(c *client) error { unSubscribe := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.UnSubscribe(c, id) err := s.UnSubscribe(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
settings := handle(func(c *client) error { settings := handle(func(c *client) error {
visibility := c.Req.FormValue("visibility") visibility := c.r.FormValue("visibility")
format := c.Req.FormValue("format") format := c.r.FormValue("format")
copyScope := c.Req.FormValue("copy_scope") == "true" copyScope := c.r.FormValue("copy_scope") == "true"
threadInNewTab := c.Req.FormValue("thread_in_new_tab") == "true" threadInNewTab := c.r.FormValue("thread_in_new_tab") == "true"
hideAttachments := c.Req.FormValue("hide_attachments") == "true" hideAttachments := c.r.FormValue("hide_attachments") == "true"
maskNSFW := c.Req.FormValue("mask_nsfw") == "true" maskNSFW := c.r.FormValue("mask_nsfw") == "true"
ni, _ := strconv.Atoi(c.Req.FormValue("notification_interval")) ni, _ := strconv.Atoi(c.r.FormValue("notification_interval"))
fluorideMode := c.Req.FormValue("fluoride_mode") == "true" fluorideMode := c.r.FormValue("fluoride_mode") == "true"
darkMode := c.Req.FormValue("dark_mode") == "true" darkMode := c.r.FormValue("dark_mode") == "true"
antiDopamineMode := c.Req.FormValue("anti_dopamine_mode") == "true" antiDopamineMode := c.r.FormValue("anti_dopamine_mode") == "true"
settings := &model.Settings{ settings := &model.Settings{
DefaultVisibility: visibility, DefaultVisibility: visibility,
@ -525,49 +486,49 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, CSRF, HTML) }, CSRF, HTML)
muteConversation := handle(func(c *client) error { muteConversation := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.MuteConversation(c, id) err := s.MuteConversation(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unMuteConversation := handle(func(c *client) error { unMuteConversation := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.UnMuteConversation(c, id) err := s.UnMuteConversation(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
delete := handle(func(c *client) error { delete := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.Delete(c, id) err := s.Delete(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
readNotifications := handle(func(c *client) error { readNotifications := handle(func(c *client) error {
q := c.Req.URL.Query() q := c.r.URL.Query()
maxID := q.Get("max_id") maxID := q.Get("max_id")
err := s.ReadNotifications(c, maxID) err := s.ReadNotifications(c, maxID)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
bookmark := handle(func(c *client) error { bookmark := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
rid := c.Req.FormValue("retweeted_by_id") rid := c.r.FormValue("retweeted_by_id")
err := s.Bookmark(c, id) err := s.Bookmark(c, id)
if err != nil { if err != nil {
return err return err
@ -575,13 +536,13 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if len(rid) > 0 { if len(rid) > 0 {
id = rid id = rid
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+id) redirect(c, c.r.FormValue("referrer")+"#status-"+id)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unBookmark := handle(func(c *client) error { unBookmark := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
rid := c.Req.FormValue("retweeted_by_id") rid := c.r.FormValue("retweeted_by_id")
err := s.UnBookmark(c, id) err := s.UnBookmark(c, id)
if err != nil { if err != nil {
return err return err
@ -589,40 +550,40 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
if len(rid) > 0 { if len(rid) > 0 {
id = rid id = rid
} }
redirect(c, c.Req.FormValue("referrer")+"#status-"+id) redirect(c, c.r.FormValue("referrer")+"#status-"+id)
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
filter := handle(func(c *client) error { filter := handle(func(c *client) error {
phrase := c.Req.FormValue("phrase") phrase := c.r.FormValue("phrase")
wholeWord := c.Req.FormValue("whole_word") == "true" wholeWord := c.r.FormValue("whole_word") == "true"
err := s.Filter(c, phrase, wholeWord) err := s.Filter(c, phrase, wholeWord)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
unFilter := handle(func(c *client) error { unFilter := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
err := s.UnFilter(c, id) err := s.UnFilter(c, id)
if err != nil { if err != nil {
return err return err
} }
redirect(c, c.Req.FormValue("referrer")) redirect(c, c.r.FormValue("referrer"))
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
signout := handle(func(c *client) error { signout := handle(func(c *client) error {
s.Signout(c) s.Signout(c)
setSessionCookie(c, "", 0) setSessionCookie(c.w, "", 0)
redirect(c, "/") redirect(c, "/")
return nil return nil
}, CSRF, HTML) }, CSRF, HTML)
fLike := handle(func(c *client) error { fLike := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
count, err := s.Like(c, id) count, err := s.Like(c, id)
if err != nil { if err != nil {
return err return err
@ -631,7 +592,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, CSRF, JSON) }, CSRF, JSON)
fUnlike := handle(func(c *client) error { fUnlike := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
count, err := s.UnLike(c, id) count, err := s.UnLike(c, id)
if err != nil { if err != nil {
return err return err
@ -640,7 +601,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, CSRF, JSON) }, CSRF, JSON)
fRetweet := handle(func(c *client) error { fRetweet := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
count, err := s.Retweet(c, id) count, err := s.Retweet(c, id)
if err != nil { if err != nil {
return err return err
@ -649,7 +610,7 @@ func NewHandler(s *service, logger *log.Logger, staticDir string) http.Handler {
}, CSRF, JSON) }, CSRF, JSON)
fUnretweet := handle(func(c *client) error { fUnretweet := handle(func(c *client) error {
id, _ := mux.Vars(c.Req)["id"] id, _ := mux.Vars(c.r)["id"]
count, err := s.UnRetweet(c, id) count, err := s.UnRetweet(c, id)
if err != nil { if err != nil {
return err return err

2
templates/postform.tmpl
View file

@ -34,7 +34,7 @@
</select> </select>
</span> </span>
<span class="post-form-field"> <span class="post-form-field">
<input type="checkbox" id="nsfw-checkbox" name="is_nsfw" value="on" accesskey="N" title="NSFW (N)"> <input type="checkbox" id="nsfw-checkbox" name="is_nsfw" value="true" accesskey="N" title="NSFW (N)">
<label for="nsfw-checkbox"> NSFW </label> <label for="nsfw-checkbox"> NSFW </label>
</span> </span>
</div> </div>