localhost_frssoft/ bloat
1
0
Fork 0
mirror of https://gitea.phreedom.club/localhost_frssoft/bloat.git synced 2024-11-14 00:39:22 +02:00
Code Issues Packages Projects Releases Wiki Activity

Refactor things 

- Remove separate auth/logging and merge them into transport.go
- Add helper function for http handlers
This commit is contained in:
r 2020-11-22 17:29:58 +00:00
parent 37b1c75045
commit fa27d9c6eb
11 changed files with 547 additions and 1664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
config/config.go
View File

@ -101,7 +101,7 @@ func Parse(r io.Reader) (c *config, err error) {
case "log_file": case "log_file":
c.LogFile = val c.LogFile = val
default: default:
return nil, errors.New("invliad config key " + key) return nil, errors.New("invalid config key " + key)
} }
} }

9
main.go
View File

@ -12,7 +12,6 @@ import (
"time" "time"
"bloat/config" "bloat/config"
"bloat/kv"
"bloat/renderer" "bloat/renderer"
"bloat/repo" "bloat/repo"
"bloat/service" "bloat/service"
@ -76,13 +75,13 @@ func main() {
} }
sessionDBPath := filepath.Join(config.DatabasePath, "session") sessionDBPath := filepath.Join(config.DatabasePath, "session")
sessionDB, err := kv.NewDatabse(sessionDBPath) sessionDB, err := util.NewDatabse(sessionDBPath)
if err != nil { if err != nil {
errExit(err) errExit(err)
} }
appDBPath := filepath.Join(config.DatabasePath, "app") appDBPath := filepath.Join(config.DatabasePath, "app")
appDB, err := kv.NewDatabse(appDBPath) appDB, err := util.NewDatabse(appDBPath)
if err != nil { if err != nil {
errExit(err) errExit(err)
} }
@ -114,9 +113,7 @@ func main() {
s := service.NewService(config.ClientName, config.ClientScope, s := service.NewService(config.ClientName, config.ClientScope,
config.ClientWebsite, customCSS, config.PostFormats, renderer, config.ClientWebsite, customCSS, config.PostFormats, renderer,
sessionRepo, appRepo, config.SingleInstance) sessionRepo, appRepo, config.SingleInstance)
s = service.NewAuthService(sessionRepo, appRepo, s) handler := service.NewHandler(s, logger, config.StaticDirectory)
s = service.NewLoggingService(logger, s)
handler := service.NewHandler(s, config.StaticDirectory)
logger.Println("listening on", config.ListenAddress) logger.Println("listening on", config.ListenAddress)
err = http.ListenAndServe(config.ListenAddress, handler) err = http.ListenAndServe(config.ListenAddress, handler)

19
model/client.go
View File

@ -1,19 +0,0 @@
package model
import (
"io"
"bloat/mastodon"
)
type ClientCtx struct {
SessionID string
CSRFToken string
}
type Client struct {
*mastodon.Client
Writer io.Writer
Ctx ClientCtx
Session Session
}

1
model/post.go
View File

@ -10,7 +10,6 @@ type PostContext struct {
DefaultFormat string DefaultFormat string
ReplyContext *ReplyContext ReplyContext *ReplyContext
Formats []PostFormat Formats []PostFormat
DarkMode bool
} }
type ReplyContext struct { type ReplyContext struct {

6
repo/appRepo.go
View File

@ -3,15 +3,15 @@ package repo
import ( import (
"encoding/json" "encoding/json"
"bloat/kv" "bloat/util"
"bloat/model" "bloat/model"
) )
type appRepo struct { type appRepo struct {
db *kv.Database db *util.Database
} }
func NewAppRepo(db *kv.Database) *appRepo { func NewAppRepo(db *util.Database) *appRepo {
return &appRepo{ return &appRepo{
db: db, db: db,
} }

6
repo/sessionRepo.go
View File

@ -3,15 +3,15 @@ package repo
import ( import (
"encoding/json" "encoding/json"
"bloat/kv" "bloat/util"
"bloat/model" "bloat/model"
) )
type sessionRepo struct { type sessionRepo struct {
db *kv.Database db *util.Database
} }
func NewSessionRepo(db *kv.Database) *sessionRepo { func NewSessionRepo(db *util.Database) *sessionRepo {
return &sessionRepo{ return &sessionRepo{
db: db, db: db,
} }

480
service/auth.go
View File

@ -1,480 +0,0 @@
package service
import (
"errors"
"mime/multipart"
"bloat/mastodon"
"bloat/model"
)
var (
errInvalidSession = errors.New("invalid session")
errInvalidAccessToken = errors.New("invalid access token")
errInvalidCSRFToken = errors.New("invalid csrf token")
)
type as struct {
sessionRepo model.SessionRepo
appRepo model.AppRepo
Service
}
func NewAuthService(sessionRepo model.SessionRepo, appRepo model.AppRepo, s Service) Service {
return &as{sessionRepo, appRepo, s}
}
func (s *as) initClient(c *model.Client) (err error) {
if len(c.Ctx.SessionID) < 1 {
return errInvalidSession
}
session, err := s.sessionRepo.Get(c.Ctx.SessionID)
if err != nil {
return errInvalidSession
}
app, err := s.appRepo.Get(session.InstanceDomain)
if err != nil {
return
}
mc := mastodon.NewClient(&mastodon.Config{
Server: app.InstanceURL,
ClientID: app.ClientID,
ClientSecret: app.ClientSecret,
AccessToken: session.AccessToken,
})
c.Client = mc
c.Session = session
return nil
}
func (s *as) authenticateClient(c *model.Client) (err error) {
err = s.initClient(c)
if err != nil {
return
}
if len(c.Session.AccessToken) < 1 {
return errInvalidAccessToken
}
return nil
}
func checkCSRF(c *model.Client) (err error) {
if c.Ctx.CSRFToken != c.Session.CSRFToken {
return errInvalidCSRFToken
}
return nil
}
func (s *as) ServeErrorPage(c *model.Client, err error) {
s.authenticateClient(c)
s.Service.ServeErrorPage(c, err)
}
func (s *as) ServeSigninPage(c *model.Client) (err error) {
return s.Service.ServeSigninPage(c)
}
func (s *as) ServeRootPage(c *model.Client) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeRootPage(c)
}
func (s *as) ServeNavPage(c *model.Client) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeNavPage(c)
}
func (s *as) ServeTimelinePage(c *model.Client, tType string,
maxID string, minID string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeTimelinePage(c, tType, maxID, minID)
}
func (s *as) ServeThreadPage(c *model.Client, id string, reply bool) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeThreadPage(c, id, reply)
}
func (s *as) ServeLikedByPage(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeLikedByPage(c, id)
}
func (s *as) ServeRetweetedByPage(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeRetweetedByPage(c, id)
}
func (s *as) ServeNotificationPage(c *model.Client,
maxID string, minID string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeNotificationPage(c, maxID, minID)
}
func (s *as) ServeUserPage(c *model.Client, id string,
pageType string, maxID string, minID string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeUserPage(c, id, pageType, maxID, minID)
}
func (s *as) ServeAboutPage(c *model.Client) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeAboutPage(c)
}
func (s *as) ServeEmojiPage(c *model.Client) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeEmojiPage(c)
}
func (s *as) ServeSearchPage(c *model.Client, q string,
qType string, offset int) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeSearchPage(c, q, qType, offset)
}
func (s *as) ServeUserSearchPage(c *model.Client,
id string, q string, offset int) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeUserSearchPage(c, id, q, offset)
}
func (s *as) ServeSettingsPage(c *model.Client) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
return s.Service.ServeSettingsPage(c)
}
func (s *as) NewSession(instance string) (redirectUrl string,
sessionID string, err error) {
return s.Service.NewSession(instance)
}
func (s *as) Signin(c *model.Client, sessionID string,
code string) (token string, userID string, err error) {
err = s.authenticateClient(c)
if err != nil && err != errInvalidAccessToken {
return
}
token, userID, err = s.Service.Signin(c, c.Session.ID, code)
if err != nil {
return
}
c.Session.AccessToken = token
c.Session.UserID = userID
err = s.sessionRepo.Add(c.Session)
if err != nil {
return
}
return
}
func (s *as) Signout(c *model.Client) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
s.Service.Signout(c)
return
}
func (s *as) Post(c *model.Client, content string,
replyToID string, format string, visibility string, isNSFW bool,
files []*multipart.FileHeader) (id string, err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Post(c, content, replyToID, format, visibility, isNSFW, files)
}
func (s *as) Like(c *model.Client, id string) (count int64, err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Like(c, id)
}
func (s *as) UnLike(c *model.Client, id string) (count int64, err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnLike(c, id)
}
func (s *as) Retweet(c *model.Client, id string) (count int64, err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Retweet(c, id)
}
func (s *as) UnRetweet(c *model.Client, id string) (count int64, err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnRetweet(c, id)
}
func (s *as) Vote(c *model.Client, id string,
choices []string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Vote(c, id, choices)
}
func (s *as) Follow(c *model.Client, id string, reblogs *bool) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Follow(c, id, reblogs)
}
func (s *as) UnFollow(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnFollow(c, id)
}
func (s *as) Mute(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Mute(c, id)
}
func (s *as) UnMute(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnMute(c, id)
}
func (s *as) Block(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Block(c, id)
}
func (s *as) UnBlock(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnBlock(c, id)
}
func (s *as) Subscribe(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Subscribe(c, id)
}
func (s *as) UnSubscribe(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnSubscribe(c, id)
}
func (s *as) SaveSettings(c *model.Client, settings *model.Settings) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.SaveSettings(c, settings)
}
func (s *as) MuteConversation(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.MuteConversation(c, id)
}
func (s *as) UnMuteConversation(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnMuteConversation(c, id)
}
func (s *as) Delete(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Delete(c, id)
}
func (s *as) ReadNotifications(c *model.Client, maxID string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.ReadNotifications(c, maxID)
}
func (s *as) Bookmark(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.Bookmark(c, id)
}
func (s *as) UnBookmark(c *model.Client, id string) (err error) {
err = s.authenticateClient(c)
if err != nil {
return
}
err = checkCSRF(c)
if err != nil {
return
}
return s.Service.UnBookmark(c, id)
}

341
service/logging.go
View File

@ -1,341 +0,0 @@
package service
import (
"log"
"mime/multipart"
"time"
"bloat/model"
)
type ls struct {
logger *log.Logger
Service
}
func NewLoggingService(logger *log.Logger, s Service) Service {
return &ls{logger, s}
}
func (s *ls) ServeErrorPage(c *model.Client, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, err=%v, took=%v\n",
"ServeErrorPage", err, time.Since(begin))
}(time.Now())
s.Service.ServeErrorPage(c, err)
}
func (s *ls) ServeSigninPage(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeSigninPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeSigninPage(c)
}
func (s *ls) ServeRootPage(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeRootPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeRootPage(c)
}
func (s *ls) ServeNavPage(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeNavPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeNavPage(c)
}
func (s *ls) ServeTimelinePage(c *model.Client, tType string,
maxID string, minID string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, type=%v, took=%v, err=%v\n",
"ServeTimelinePage", tType, time.Since(begin), err)
}(time.Now())
return s.Service.ServeTimelinePage(c, tType, maxID, minID)
}
func (s *ls) ServeThreadPage(c *model.Client, id string,
reply bool) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"ServeThreadPage", id, time.Since(begin), err)
}(time.Now())
return s.Service.ServeThreadPage(c, id, reply)
}
func (s *ls) ServeLikedByPage(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"ServeLikedByPage", id, time.Since(begin), err)
}(time.Now())
return s.Service.ServeLikedByPage(c, id)
}
func (s *ls) ServeRetweetedByPage(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"ServeRetweetedByPage", id, time.Since(begin), err)
}(time.Now())
return s.Service.ServeRetweetedByPage(c, id)
}
func (s *ls) ServeNotificationPage(c *model.Client,
maxID string, minID string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeNotificationPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeNotificationPage(c, maxID, minID)
}
func (s *ls) ServeUserPage(c *model.Client, id string,
pageType string, maxID string, minID string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, type=%v, took=%v, err=%v\n",
"ServeUserPage", id, pageType, time.Since(begin), err)
}(time.Now())
return s.Service.ServeUserPage(c, id, pageType, maxID, minID)
}
func (s *ls) ServeAboutPage(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeAboutPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeAboutPage(c)
}
func (s *ls) ServeEmojiPage(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeEmojiPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeEmojiPage(c)
}
func (s *ls) ServeSearchPage(c *model.Client, q string,
qType string, offset int) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeSearchPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeSearchPage(c, q, qType, offset)
}
func (s *ls) ServeUserSearchPage(c *model.Client,
id string, q string, offset int) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeUserSearchPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeUserSearchPage(c, id, q, offset)
}
func (s *ls) ServeSettingsPage(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"ServeSettingsPage", time.Since(begin), err)
}(time.Now())
return s.Service.ServeSettingsPage(c)
}
func (s *ls) NewSession(instance string) (redirectUrl string,
sessionID string, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, instance=%v, took=%v, err=%v\n",
"NewSession", instance, time.Since(begin), err)
}(time.Now())
return s.Service.NewSession(instance)
}
func (s *ls) Signin(c *model.Client, sessionID string,
code string) (token string, userID string, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, session_id=%v, took=%v, err=%v\n",
"Signin", sessionID, time.Since(begin), err)
}(time.Now())
return s.Service.Signin(c, sessionID, code)
}
func (s *ls) Signout(c *model.Client) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"Signout", time.Since(begin), err)
}(time.Now())
return s.Service.Signout(c)
}
func (s *ls) Post(c *model.Client, content string,
replyToID string, format string, visibility string, isNSFW bool,
files []*multipart.FileHeader) (id string, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"Post", time.Since(begin), err)
}(time.Now())
return s.Service.Post(c, content, replyToID, format,
visibility, isNSFW, files)
}
func (s *ls) Like(c *model.Client, id string) (count int64, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Like", id, time.Since(begin), err)
}(time.Now())
return s.Service.Like(c, id)
}
func (s *ls) UnLike(c *model.Client, id string) (count int64, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnLike", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnLike(c, id)
}
func (s *ls) Retweet(c *model.Client, id string) (count int64, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Retweet", id, time.Since(begin), err)
}(time.Now())
return s.Service.Retweet(c, id)
}
func (s *ls) UnRetweet(c *model.Client, id string) (count int64, err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnRetweet", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnRetweet(c, id)
}
func (s *ls) Vote(c *model.Client, id string, choices []string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Vote", id, time.Since(begin), err)
}(time.Now())
return s.Service.Vote(c, id, choices)
}
func (s *ls) Follow(c *model.Client, id string, reblogs *bool) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Follow", id, time.Since(begin), err)
}(time.Now())
return s.Service.Follow(c, id, reblogs)
}
func (s *ls) UnFollow(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnFollow", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnFollow(c, id)
}
func (s *ls) Mute(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Mute", id, time.Since(begin), err)
}(time.Now())
return s.Service.Mute(c, id)
}
func (s *ls) UnMute(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnMute", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnMute(c, id)
}
func (s *ls) Block(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Block", id, time.Since(begin), err)
}(time.Now())
return s.Service.Block(c, id)
}
func (s *ls) UnBlock(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnBlock", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnBlock(c, id)
}
func (s *ls) Subscribe(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Subscribe", id, time.Since(begin), err)
}(time.Now())
return s.Service.Subscribe(c, id)
}
func (s *ls) UnSubscribe(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnSubscribe", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnSubscribe(c, id)
}
func (s *ls) SaveSettings(c *model.Client, settings *model.Settings) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, took=%v, err=%v\n",
"SaveSettings", time.Since(begin), err)
}(time.Now())
return s.Service.SaveSettings(c, settings)
}
func (s *ls) MuteConversation(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"MuteConversation", id, time.Since(begin), err)
}(time.Now())
return s.Service.MuteConversation(c, id)
}
func (s *ls) UnMuteConversation(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnMuteConversation", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnMuteConversation(c, id)
}
func (s *ls) Delete(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Delete", id, time.Since(begin), err)
}(time.Now())
return s.Service.Delete(c, id)
}
func (s *ls) ReadNotifications(c *model.Client, maxID string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, max_id=%v, took=%v, err=%v\n",
"ReadNotifications", maxID, time.Since(begin), err)
}(time.Now())
return s.Service.ReadNotifications(c, maxID)
}
func (s *ls) Bookmark(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"Bookmark", id, time.Since(begin), err)
}(time.Now())
return s.Service.Bookmark(c, id)
}
func (s *ls) UnBookmark(c *model.Client, id string) (err error) {
defer func(begin time.Time) {
s.logger.Printf("method=%v, id=%v, took=%v, err=%v\n",
"UnBookmark", id, time.Since(begin), err)
}(time.Now())
return s.Service.UnBookmark(c, id)
}

313
service/service.go
View File

@ -20,53 +20,6 @@ var (
errInvalidArgument = errors.New("invalid argument") errInvalidArgument = errors.New("invalid argument")
) )
type Service interface {
ServeErrorPage(c *model.Client, err error)
ServeSigninPage(c *model.Client) (err error)
ServeRootPage(c *model.Client) (err error)
ServeNavPage(c *model.Client) (err error)
ServeTimelinePage(c *model.Client, tType string, maxID string,
minID string) (err error)
ServeThreadPage(c *model.Client, id string, reply bool) (err error)
ServeLikedByPage(c *model.Client, id string) (err error)
ServeRetweetedByPage(c *model.Client, id string) (err error)
ServeNotificationPage(c *model.Client, maxID string, minID string) (err error)
ServeUserPage(c *model.Client, id string, pageType string, maxID string,
minID string) (err error)
ServeAboutPage(c *model.Client) (err error)
ServeEmojiPage(c *model.Client) (err error)
ServeSearchPage(c *model.Client, q string, qType string, offset int) (err error)
ServeUserSearchPage(c *model.Client, id string, q string, offset int) (err error)
ServeSettingsPage(c *model.Client) (err error)
SingleInstance() (instance string, ok bool)
NewSession(instance string) (redirectUrl string, sessionID string, err error)
Signin(c *model.Client, sessionID string, code string) (token string,
userID string, err error)
Signout(c *model.Client) (err error)
Post(c *model.Client, content string, replyToID string, format string, visibility string,
isNSFW bool, files []*multipart.FileHeader) (id string, err error)
Like(c *model.Client, id string) (count int64, err error)
UnLike(c *model.Client, id string) (count int64, err error)
Retweet(c *model.Client, id string) (count int64, err error)
UnRetweet(c *model.Client, id string) (count int64, err error)
Vote(c *model.Client, id string, choices []string) (err error)
Follow(c *model.Client, id string, reblogs *bool) (err error)
UnFollow(c *model.Client, id string) (err error)
Mute(c *model.Client, id string) (err error)
UnMute(c *model.Client, id string) (err error)
Block(c *model.Client, id string) (err error)
UnBlock(c *model.Client, id string) (err error)
Subscribe(c *model.Client, id string) (err error)
UnSubscribe(c *model.Client, id string) (err error)
SaveSettings(c *model.Client, settings *model.Settings) (err error)
MuteConversation(c *model.Client, id string) (err error)
UnMuteConversation(c *model.Client, id string) (err error)
Delete(c *model.Client, id string) (err error)
ReadNotifications(c *model.Client, maxID string) (err error)
Bookmark(c *model.Client, id string) (err error)
UnBookmark(c *model.Client, id string) (err error)
}
type service struct { type service struct {
clientName string clientName string
clientScope string clientScope string
@ -88,7 +41,7 @@ func NewService(clientName string,
sessionRepo model.SessionRepo, sessionRepo model.SessionRepo,
appRepo model.AppRepo, appRepo model.AppRepo,
singleInstance string, singleInstance string,
) Service { ) *service {
return &service{ return &service{
clientName: clientName, clientName: clientName,
clientScope: clientScope, clientScope: clientScope,
@ -102,7 +55,7 @@ func NewService(clientName string,
} }
} }
func getRendererContext(c *model.Client) *renderer.Context { func getRendererContext(c *client) *renderer.Context {
var settings model.Settings var settings model.Settings
var session model.Session var session model.Session
if c != nil { if c != nil {
@ -128,26 +81,21 @@ func addToReplyMap(m map[string][]mastodon.ReplyInfo, key interface{},
if key == nil { if key == nil {
return return
} }
keyStr, ok := key.(string) keyStr, ok := key.(string)
if !ok { if !ok {
return return
} }
_, ok = m[keyStr] _, ok = m[keyStr]
if !ok { if !ok {
m[keyStr] = []mastodon.ReplyInfo{} m[keyStr] = []mastodon.ReplyInfo{}
} }
m[keyStr] = append(m[keyStr], mastodon.ReplyInfo{val, number}) m[keyStr] = append(m[keyStr], mastodon.ReplyInfo{val, number})
} }
func (svc *service) getCommonData(c *model.Client, func (s *service) getCommonData(c *client, title string) (data *renderer.CommonData) {
title string) (data *renderer.CommonData) {
data = &renderer.CommonData{ data = &renderer.CommonData{
Title: title + " - " + svc.clientName, Title: title + " - " + s.clientName,
CustomCSS: svc.customCSS, CustomCSS: s.customCSS,
} }
if c != nil && c.Session.IsLoggedIn() { if c != nil && c.Session.IsLoggedIn() {
data.CSRFToken = c.Session.CSRFToken data.CSRFToken = c.Session.CSRFToken
@ -155,66 +103,59 @@ func (svc *service) getCommonData(c *model.Client,
return return
} }
func (svc *service) ServeErrorPage(c *model.Client, err error) { func (s *service) ErrorPage(c *client, err error) {
var errStr string var errStr string
if err != nil { if err != nil {
errStr = err.Error() errStr = err.Error()
} }
commonData := s.getCommonData(nil, "error")
commonData := svc.getCommonData(nil, "error")
data := &renderer.ErrorData{ data := &renderer.ErrorData{
CommonData: commonData, CommonData: commonData,
Error: errStr, Error: errStr,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
svc.renderer.Render(rCtx, c.Writer, renderer.ErrorPage, data) s.renderer.Render(rCtx, c, renderer.ErrorPage, data)
} }
func (svc *service) ServeSigninPage(c *model.Client) (err error) { func (s *service) SigninPage(c *client) (err error) {
commonData := svc.getCommonData(nil, "signin") commonData := s.getCommonData(nil, "signin")
data := &renderer.SigninData{ data := &renderer.SigninData{
CommonData: commonData, CommonData: commonData,
} }
rCtx := getRendererContext(nil) rCtx := getRendererContext(nil)
return svc.renderer.Render(rCtx, c.Writer, renderer.SigninPage, data) return s.renderer.Render(rCtx, c, renderer.SigninPage, data)
} }
func (svc *service) ServeRootPage(c *model.Client) (err error) { func (s *service) RootPage(c *client) (err error) {
data := &renderer.RootData{ data := &renderer.RootData{
Title: svc.clientName, Title: s.clientName,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.RootPage, data) return s.renderer.Render(rCtx, c, renderer.RootPage, data)
} }
func (svc *service) ServeNavPage(c *model.Client) (err error) { func (s *service) NavPage(c *client) (err error) {
u, err := c.GetAccountCurrentUser(ctx) u, err := c.GetAccountCurrentUser(ctx)
if err != nil { if err != nil {
return return
} }
postContext := model.PostContext{ postContext := model.PostContext{
DefaultVisibility: c.Session.Settings.DefaultVisibility, DefaultVisibility: c.Session.Settings.DefaultVisibility,
DefaultFormat: c.Session.Settings.DefaultFormat, DefaultFormat: c.Session.Settings.DefaultFormat,
Formats: svc.postFormats, Formats: s.postFormats,
} }
commonData := s.getCommonData(c, "nav")
commonData := svc.getCommonData(c, "Nav")
commonData.Target = "main" commonData.Target = "main"
data := &renderer.NavData{ data := &renderer.NavData{
User: u, User: u,
CommonData: commonData, CommonData: commonData,
PostContext: postContext, PostContext: postContext,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.NavPage, data) return s.renderer.Render(rCtx, c, renderer.NavPage, data)
} }
func (svc *service) ServeTimelinePage(c *model.Client, tType string, func (s *service) TimelinePage(c *client, tType string,
maxID string, minID string) (err error) { maxID string, minID string) (err error) {
var nextLink, prevLink, title string var nextLink, prevLink, title string
@ -279,7 +220,7 @@ func (svc *service) ServeTimelinePage(c *model.Client, tType string,
nextLink = fmt.Sprintf("/timeline/%s?max_id=%s", tType, pg.MaxID) nextLink = fmt.Sprintf("/timeline/%s?max_id=%s", tType, pg.MaxID)
} }
commonData := svc.getCommonData(c, tType+" timeline ") commonData := s.getCommonData(c, tType+" timeline ")
data := &renderer.TimelineData{ data := &renderer.TimelineData{
Title: title, Title: title,
Statuses: statuses, Statuses: statuses,
@ -289,10 +230,10 @@ func (svc *service) ServeTimelinePage(c *model.Client, tType string,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.TimelinePage, data) return s.renderer.Render(rCtx, c, renderer.TimelinePage, data)
} }
func (svc *service) ServeThreadPage(c *model.Client, id string, reply bool) (err error) { func (s *service) ThreadPage(c *client, id string, reply bool) (err error) {
var postContext model.PostContext var postContext model.PostContext
status, err := c.GetStatus(ctx, id) status, err := c.GetStatus(ctx, id)
@ -323,14 +264,13 @@ func (svc *service) ServeThreadPage(c *model.Client, id string, reply bool) (err
postContext = model.PostContext{ postContext = model.PostContext{
DefaultVisibility: visibility, DefaultVisibility: visibility,
DefaultFormat: c.Session.Settings.DefaultFormat, DefaultFormat: c.Session.Settings.DefaultFormat,
Formats: svc.postFormats, Formats: s.postFormats,
ReplyContext: &model.ReplyContext{ ReplyContext: &model.ReplyContext{
InReplyToID: id, InReplyToID: id,
InReplyToName: status.Account.Acct, InReplyToName: status.Account.Acct,
ReplyContent: content, ReplyContent: content,
ForceVisibility: isDirect, ForceVisibility: isDirect,
}, },
DarkMode: c.Session.Settings.DarkMode,
} }
} }
@ -353,7 +293,7 @@ func (svc *service) ServeThreadPage(c *model.Client, id string, reply bool) (err
addToReplyMap(replies, statuses[i].InReplyToID, statuses[i].ID, i+1) addToReplyMap(replies, statuses[i].InReplyToID, statuses[i].ID, i+1)
} }
commonData := svc.getCommonData(c, "post by "+status.Account.DisplayName) commonData := s.getCommonData(c, "post by "+status.Account.DisplayName)
data := &renderer.ThreadData{ data := &renderer.ThreadData{
Statuses: statuses, Statuses: statuses,
PostContext: postContext, PostContext: postContext,
@ -362,42 +302,38 @@ func (svc *service) ServeThreadPage(c *model.Client, id string, reply bool) (err
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.ThreadPage, data) return s.renderer.Render(rCtx, c, renderer.ThreadPage, data)
} }
func (svc *service) ServeLikedByPage(c *model.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(ctx, id, nil)
if err != nil { if err != nil {
return return
} }
commonData := s.getCommonData(c, "likes")
commonData := svc.getCommonData(c, "likes")
data := &renderer.LikedByData{ data := &renderer.LikedByData{
CommonData: commonData, CommonData: commonData,
Users: likers, Users: likers,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.LikedByPage, data) return s.renderer.Render(rCtx, c, renderer.LikedByPage, data)
} }
func (svc *service) ServeRetweetedByPage(c *model.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(ctx, id, nil)
if err != nil { if err != nil {
return return
} }
commonData := s.getCommonData(c, "retweets")
commonData := svc.getCommonData(c, "retweets")
data := &renderer.RetweetedByData{ data := &renderer.RetweetedByData{
CommonData: commonData, CommonData: commonData,
Users: retweeters, Users: retweeters,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.RetweetedByPage, data) return s.renderer.Render(rCtx, c, renderer.RetweetedByPage, data)
} }
func (svc *service) ServeNotificationPage(c *model.Client, maxID string, func (s *service) NotificationPage(c *client, maxID string,
minID string) (err error) { minID string) (err error) {
var nextLink string var nextLink string
@ -428,12 +364,11 @@ func (svc *service) ServeNotificationPage(c *model.Client, maxID string,
if unreadCount > 0 { if unreadCount > 0 {
readID = notifications[0].ID readID = notifications[0].ID
} }
if len(notifications) == 20 && len(pg.MaxID) > 0 { if len(notifications) == 20 && len(pg.MaxID) > 0 {
nextLink = "/notifications?max_id=" + pg.MaxID nextLink = "/notifications?max_id=" + pg.MaxID
} }
commonData := svc.getCommonData(c, "notifications") commonData := s.getCommonData(c, "notifications")
commonData.RefreshInterval = c.Session.Settings.NotificationInterval commonData.RefreshInterval = c.Session.Settings.NotificationInterval
commonData.Target = "main" commonData.Target = "main"
commonData.Count = unreadCount commonData.Count = unreadCount
@ -445,10 +380,10 @@ func (svc *service) ServeNotificationPage(c *model.Client, maxID string,
CommonData: commonData, CommonData: commonData,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.NotificationPage, data) return s.renderer.Render(rCtx, c, renderer.NotificationPage, data)
} }
func (svc *service) ServeUserPage(c *model.Client, id string, pageType string, func (s *service) UserPage(c *client, id string, pageType string,
maxID string, minID string) (err error) { maxID string, minID string) (err error) {
var nextLink string var nextLink string
@ -561,7 +496,7 @@ func (svc *service) ServeUserPage(c *model.Client, id string, pageType string,
} }
} }
commonData := svc.getCommonData(c, user.DisplayName) commonData := s.getCommonData(c, user.DisplayName)
data := &renderer.UserData{ data := &renderer.UserData{
User: user, User: user,
IsCurrent: isCurrent, IsCurrent: isCurrent,
@ -572,10 +507,10 @@ func (svc *service) ServeUserPage(c *model.Client, id string, pageType string,
CommonData: commonData, CommonData: commonData,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.UserPage, data) return s.renderer.Render(rCtx, c, renderer.UserPage, data)
} }
func (svc *service) ServeUserSearchPage(c *model.Client, func (s *service) UserSearchPage(c *client,
id string, q string, offset int) (err error) { id string, q string, offset int) (err error) {
var nextLink string var nextLink string
@ -598,7 +533,8 @@ func (svc *service) ServeUserSearchPage(c *model.Client,
if len(results.Statuses) == 20 { if len(results.Statuses) == 20 {
offset += 20 offset += 20
nextLink = fmt.Sprintf("/usersearch/%s?q=%s&offset=%d", id, url.QueryEscape(q), offset) nextLink = fmt.Sprintf("/usersearch/%s?q=%s&offset=%d", id,
url.QueryEscape(q), offset)
} }
qq := template.HTMLEscapeString(q) qq := template.HTMLEscapeString(q)
@ -606,7 +542,7 @@ func (svc *service) ServeUserSearchPage(c *model.Client,
title += " \"" + qq + "\"" title += " \"" + qq + "\""
} }
commonData := svc.getCommonData(c, title) commonData := s.getCommonData(c, title)
data := &renderer.UserSearchData{ data := &renderer.UserSearchData{
CommonData: commonData, CommonData: commonData,
User: user, User: user,
@ -614,38 +550,34 @@ func (svc *service) ServeUserSearchPage(c *model.Client,
Statuses: results.Statuses, Statuses: results.Statuses,
NextLink: nextLink, NextLink: nextLink,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.UserSearchPage, data) return s.renderer.Render(rCtx, c, renderer.UserSearchPage, data)
} }
func (svc *service) ServeAboutPage(c *model.Client) (err error) { func (s *service) AboutPage(c *client) (err error) {
commonData := svc.getCommonData(c, "about") commonData := s.getCommonData(c, "about")
data := &renderer.AboutData{ data := &renderer.AboutData{
CommonData: commonData, CommonData: commonData,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.AboutPage, data) return s.renderer.Render(rCtx, c, renderer.AboutPage, data)
} }
func (svc *service) ServeEmojiPage(c *model.Client) (err error) { func (s *service) EmojiPage(c *client) (err error) {
emojis, err := c.GetInstanceEmojis(ctx) emojis, err := c.GetInstanceEmojis(ctx)
if err != nil { if err != nil {
return return
} }
commonData := s.getCommonData(c, "emojis")
commonData := svc.getCommonData(c, "emojis")
data := &renderer.EmojiData{ data := &renderer.EmojiData{
Emojis: emojis, Emojis: emojis,
CommonData: commonData, CommonData: commonData,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.EmojiPage, data) return s.renderer.Render(rCtx, c, renderer.EmojiPage, data)
} }
func (svc *service) ServeSearchPage(c *model.Client, func (s *service) SearchPage(c *client,
q string, qType string, offset int) (err error) { q string, qType string, offset int) (err error) {
var nextLink string var nextLink string
@ -664,7 +596,8 @@ func (svc *service) ServeSearchPage(c *model.Client,
if (qType == "accounts" && len(results.Accounts) == 20) || if (qType == "accounts" && len(results.Accounts) == 20) ||
(qType == "statuses" && len(results.Statuses) == 20) { (qType == "statuses" && len(results.Statuses) == 20) {
offset += 20 offset += 20
nextLink = fmt.Sprintf("/search?q=%s&type=%s&offset=%d", url.QueryEscape(q), qType, offset) nextLink = fmt.Sprintf("/search?q=%s&type=%s&offset=%d",
url.QueryEscape(q), qType, offset)
} }
qq := template.HTMLEscapeString(q) qq := template.HTMLEscapeString(q)
@ -672,7 +605,7 @@ func (svc *service) ServeSearchPage(c *model.Client,
title += " \"" + qq + "\"" title += " \"" + qq + "\""
} }
commonData := svc.getCommonData(c, title) commonData := s.getCommonData(c, title)
data := &renderer.SearchData{ data := &renderer.SearchData{
CommonData: commonData, CommonData: commonData,
Q: qq, Q: qq,
@ -681,34 +614,30 @@ func (svc *service) ServeSearchPage(c *model.Client,
Statuses: results.Statuses, Statuses: results.Statuses,
NextLink: nextLink, NextLink: nextLink,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.SearchPage, data) return s.renderer.Render(rCtx, c, renderer.SearchPage, data)
} }
func (svc *service) ServeSettingsPage(c *model.Client) (err error) { func (s *service) SettingsPage(c *client) (err error) {
commonData := svc.getCommonData(c, "settings") commonData := s.getCommonData(c, "settings")
data := &renderer.SettingsData{ data := &renderer.SettingsData{
CommonData: commonData, CommonData: commonData,
Settings: &c.Session.Settings, Settings: &c.Session.Settings,
PostFormats: svc.postFormats, PostFormats: s.postFormats,
} }
rCtx := getRendererContext(c) rCtx := getRendererContext(c)
return svc.renderer.Render(rCtx, c.Writer, renderer.SettingsPage, data) return s.renderer.Render(rCtx, c, renderer.SettingsPage, data)
} }
func (svc *service) SingleInstance() (instance string, ok bool) { func (s *service) SingleInstance() (instance string, ok bool) {
if len(svc.singleInstance) > 0 { if len(s.singleInstance) > 0 {
instance = svc.singleInstance instance = s.singleInstance
ok = true ok = true
} }
return return
} }
func (svc *service) NewSession(instance string) ( func (s *service) NewSession(instance string) (rurl string, sid string, err error) {
redirectUrl string, sessionID string, err error) {
var instanceURL string var instanceURL string
if strings.HasPrefix(instance, "https://") { if strings.HasPrefix(instance, "https://") {
instanceURL = instance instanceURL = instance
@ -717,53 +646,48 @@ func (svc *service) NewSession(instance string) (
instanceURL = "https://" + instance instanceURL = "https://" + instance
} }
sessionID, err = util.NewSessionID() sid, err = util.NewSessionID()
if err != nil { if err != nil {
return return
} }
csrfToken, err := util.NewCSRFToken() csrfToken, err := util.NewCSRFToken()
if err != nil { if err != nil {
return return
} }
session := model.Session{ session := model.Session{
ID: sessionID, ID: sid,
InstanceDomain: instance, InstanceDomain: instance,
CSRFToken: csrfToken, CSRFToken: csrfToken,
Settings: *model.NewSettings(), Settings: *model.NewSettings(),
} }
err = s.sessionRepo.Add(session)
err = svc.sessionRepo.Add(session)
if err != nil { if err != nil {
return return
} }
app, err := svc.appRepo.Get(instance) app, err := s.appRepo.Get(instance)
if err != nil { if err != nil {
if err != model.ErrAppNotFound { if err != model.ErrAppNotFound {
return return
} }
mastoApp, err := mastodon.RegisterApp(ctx, &mastodon.AppConfig{ mastoApp, err := mastodon.RegisterApp(ctx, &mastodon.AppConfig{
Server: instanceURL, Server: instanceURL,
ClientName: svc.clientName, ClientName: s.clientName,
Scopes: svc.clientScope, Scopes: s.clientScope,
Website: svc.clientWebsite, Website: s.clientWebsite,
RedirectURIs: svc.clientWebsite + "/oauth_callback", RedirectURIs: s.clientWebsite + "/oauth_callback",
}) })
if err != nil { if err != nil {
return "", "", err return "", "", err
} }
app = model.App{ app = model.App{
InstanceDomain: instance, InstanceDomain: instance,
InstanceURL: instanceURL, InstanceURL: instanceURL,
ClientID: mastoApp.ClientID, ClientID: mastoApp.ClientID,
ClientSecret: mastoApp.ClientSecret, ClientSecret: mastoApp.ClientSecret,
} }
err = s.appRepo.Add(app)
err = svc.appRepo.Add(app)
if err != nil { if err != nil {
return "", "", err return "", "", err
} }
@ -778,23 +702,21 @@ func (svc *service) NewSession(instance string) (
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", svc.clientWebsite+"/oauth_callback") q.Set("redirect_uri", s.clientWebsite+"/oauth_callback")
u.RawQuery = q.Encode() u.RawQuery = q.Encode()
redirectUrl = instanceURL + u.String() rurl = instanceURL + u.String()
return return
} }
func (svc *service) Signin(c *model.Client, sessionID string, func (s *service) Signin(c *client, code string) (token string,
code string) (token string, userID 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(ctx, code, svc.clientWebsite+"/oauth_callback")
if err != nil { if err != nil {
return return
} }
@ -805,17 +727,16 @@ func (svc *service) Signin(c *model.Client, sessionID string,
return return
} }
userID = u.ID userID = u.ID
return return
} }
func (svc *service) Signout(c *model.Client) (err error) { func (s *service) Signout(c *client) (err error) {
svc.sessionRepo.Remove(c.Session.ID) s.sessionRepo.Remove(c.Session.ID)
return return
} }
func (svc *service) Post(c *model.Client, content string, func (s *service) Post(c *client, content string, replyToID string,
replyToID string, format string, visibility string, isNSFW bool, format string, visibility string, isNSFW bool,
files []*multipart.FileHeader) (id string, err error) { files []*multipart.FileHeader) (id string, err error) {
var mediaIDs []string var mediaIDs []string
@ -835,141 +756,135 @@ func (svc *service) Post(c *model.Client, content string,
Visibility: visibility, Visibility: visibility,
Sensitive: isNSFW, Sensitive: isNSFW,
} }
st, err := c.PostStatus(ctx, tweet)
s, err := c.PostStatus(ctx, tweet)
if err != nil { if err != nil {
return return
} }
return st.ID, nil
return s.ID, nil
} }
func (svc *service) Like(c *model.Client, id string) (count int64, err error) { func (s *service) Like(c *client, id string) (count int64, err error) {
s, err := c.Favourite(ctx, id) st, err := c.Favourite(ctx, id)
if err != nil { if err != nil {
return return
} }
count = s.FavouritesCount count = st.FavouritesCount
return return
} }
func (svc *service) UnLike(c *model.Client, id string) (count int64, err error) { func (s *service) UnLike(c *client, id string) (count int64, err error) {
s, err := c.Unfavourite(ctx, id) st, err := c.Unfavourite(ctx, id)
if err != nil { if err != nil {
return return
} }
count = s.FavouritesCount count = st.FavouritesCount
return return
} }
func (svc *service) Retweet(c *model.Client, id string) (count int64, err error) { func (s *service) Retweet(c *client, id string) (count int64, err error) {
s, err := c.Reblog(ctx, id) st, err := c.Reblog(ctx, id)
if err != nil { if err != nil {
return return
} }
if s.Reblog != nil { if st.Reblog != nil {
count = s.Reblog.ReblogsCount count = st.Reblog.ReblogsCount
} }
return return
} }
func (svc *service) UnRetweet(c *model.Client, id string) ( func (s *service) UnRetweet(c *client, id string) (
count int64, err error) { count int64, err error) {
s, err := c.Unreblog(ctx, id) st, err := c.Unreblog(ctx, id)
if err != nil { if err != nil {
return return
} }
count = s.ReblogsCount count = st.ReblogsCount
return return
} }
func (svc *service) Vote(c *model.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(ctx, id, choices)
if err != nil {
return
}
return return
} }
func (svc *service) Follow(c *model.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(ctx, id, reblogs)
return return
} }
func (svc *service) UnFollow(c *model.Client, id string) (err error) { func (s *service) UnFollow(c *client, id string) (err error) {
_, err = c.AccountUnfollow(ctx, id) _, err = c.AccountUnfollow(ctx, id)
return return
} }
func (svc *service) Mute(c *model.Client, id string) (err error) { func (s *service) Mute(c *client, id string) (err error) {
_, err = c.AccountMute(ctx, id) _, err = c.AccountMute(ctx, id)
return return
} }
func (svc *service) UnMute(c *model.Client, id string) (err error) { func (s *service) UnMute(c *client, id string) (err error) {
_, err = c.AccountUnmute(ctx, id) _, err = c.AccountUnmute(ctx, id)
return return
} }
func (svc *service) Block(c *model.Client, id string) (err error) { func (s *service) Block(c *client, id string) (err error) {
_, err = c.AccountBlock(ctx, id) _, err = c.AccountBlock(ctx, id)
return return
} }
func (svc *service) UnBlock(c *model.Client, id string) (err error) { func (s *service) UnBlock(c *client, id string) (err error) {
_, err = c.AccountUnblock(ctx, id) _, err = c.AccountUnblock(ctx, id)
return return
} }
func (svc *service) Subscribe(c *model.Client, id string) (err error) { func (s *service) Subscribe(c *client, id string) (err error) {
_, err = c.Subscribe(ctx, id) _, err = c.Subscribe(ctx, id)
return return
} }
func (svc *service) UnSubscribe(c *model.Client, id string) (err error) { func (s *service) UnSubscribe(c *client, id string) (err error) {
_, err = c.UnSubscribe(ctx, id) _, err = c.UnSubscribe(ctx, id)
return return
} }
func (svc *service) SaveSettings(c *model.Client, s *model.Settings) (err error) { func (s *service) SaveSettings(c *client, settings *model.Settings) (err error) {
switch s.NotificationInterval { switch settings.NotificationInterval {
case 0, 30, 60, 120, 300, 600: case 0, 30, 60, 120, 300, 600:
default: default:
return errInvalidArgument return errInvalidArgument
} }
session, err := svc.sessionRepo.Get(c.Session.ID) session, err := s.sessionRepo.Get(c.Session.ID)
if err != nil { if err != nil {
return return
} }
session.Settings = *settings
session.Settings = *s return s.sessionRepo.Add(session)
return svc.sessionRepo.Add(session)
} }
func (svc *service) MuteConversation(c *model.Client, id string) (err error) { func (s *service) MuteConversation(c *client, id string) (err error) {
_, err = c.MuteConversation(ctx, id) _, err = c.MuteConversation(ctx, id)
return return
} }
func (svc *service) UnMuteConversation(c *model.Client, id string) (err error) { func (s *service) UnMuteConversation(c *client, id string) (err error) {
_, err = c.UnmuteConversation(ctx, id) _, err = c.UnmuteConversation(ctx, id)
return return
} }
func (svc *service) Delete(c *model.Client, id string) (err error) { func (s *service) Delete(c *client, id string) (err error) {
return c.DeleteStatus(ctx, id) return c.DeleteStatus(ctx, id)
} }
func (svc *service) ReadNotifications(c *model.Client, maxID string) (err error) { func (s *service) ReadNotifications(c *client, maxID string) (err error) {
return c.ReadNotifications(ctx, maxID) return c.ReadNotifications(ctx, maxID)
} }
func (svc *service) Bookmark(c *model.Client, id string) (err error) { func (s *service) Bookmark(c *client, id string) (err error) {
_, err = c.Bookmark(ctx, id) _, err = c.Bookmark(ctx, id)
return return
} }
func (svc *service) UnBookmark(c *model.Client, id string) (err error) { func (s *service) UnBookmark(c *client, id string) (err error) {
_, err = c.Unbookmark(ctx, id) _, err = c.Unbookmark(ctx, id)
return return
} }

1032
service/transport.go
View File

File diff suppressed because it is too large Load Diff

2
kv/kv.go → util/kv.go
View File

@ -1,4 +1,4 @@
package kv package util
import ( import (
"errors" "errors"