diff options
Diffstat (limited to 'mastodon')
| -rw-r--r-- | mastodon/LICENSE | 21 | ||||
| -rw-r--r-- | mastodon/README.md | 142 | ||||
| -rw-r--r-- | mastodon/accounts.go | 314 | ||||
| -rw-r--r-- | mastodon/apps.go | 96 | ||||
| -rw-r--r-- | mastodon/go.mod | 8 | ||||
| -rw-r--r-- | mastodon/go.sum | 4 | ||||
| -rw-r--r-- | mastodon/helper.go | 55 | ||||
| -rw-r--r-- | mastodon/instance.go | 65 | ||||
| -rw-r--r-- | mastodon/lists.go | 107 | ||||
| -rw-r--r-- | mastodon/mastodon.go | 388 | ||||
| -rw-r--r-- | mastodon/notification.go | 42 | ||||
| -rw-r--r-- | mastodon/report.go | 39 | ||||
| -rw-r--r-- | mastodon/status.go | 297 | ||||
| -rw-r--r-- | mastodon/streaming.go | 166 | ||||
| -rw-r--r-- | mastodon/streaming_ws.go | 195 | ||||
| -rw-r--r-- | mastodon/unixtime.go | 20 |
16 files changed, 1959 insertions, 0 deletions
diff --git a/mastodon/LICENSE b/mastodon/LICENSE new file mode 100644 index 0000000..42066c7 --- /dev/null +++ b/mastodon/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Yasuhiro Matsumoto + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/mastodon/README.md b/mastodon/README.md new file mode 100644 index 0000000..9be937f --- /dev/null +++ b/mastodon/README.md @@ -0,0 +1,142 @@ +# go-mastodon + +[](https://travis-ci.org/mattn/go-mastodon) +[](https://coveralls.io/github/mattn/go-mastodon?branch=master) +[](http://godoc.org/github.com/mattn/go-mastodon) +[](https://goreportcard.com/report/github.com/mattn/go-mastodon) + +## Usage + +### Application + +```go +package main + +import ( + "context" + "fmt" + "log" + + "github.com/mattn/go-mastodon" +) + +func main() { + app, err := mastodon.RegisterApp(context.Background(), &mastodon.AppConfig{ + Server: "https://mstdn.jp", + ClientName: "client-name", + Scopes: "read write follow", + Website: "https://github.com/mattn/go-mastodon", + }) + if err != nil { + log.Fatal(err) + } + fmt.Printf("client-id : %s\n", app.ClientID) + fmt.Printf("client-secret: %s\n", app.ClientSecret) +} +``` + +### Client + +```go +package main + +import ( + "context" + "fmt" + "log" + + "github.com/mattn/go-mastodon" +) + +func main() { + c := mastodon.NewClient(&mastodon.Config{ + Server: "https://mstdn.jp", + ClientID: "client-id", + ClientSecret: "client-secret", + }) + err := c.Authenticate(context.Background(), "your-email", "your-password") + if err != nil { + log.Fatal(err) + } + timeline, err := c.GetTimelineHome(context.Background(), nil) + if err != nil { + log.Fatal(err) + } + for i := len(timeline) - 1; i >= 0; i-- { + fmt.Println(timeline[i]) + } +} +``` + +## Status of implementations + +* [x] GET /api/v1/accounts/:id +* [x] GET /api/v1/accounts/verify_credentials +* [x] PATCH /api/v1/accounts/update_credentials +* [x] GET /api/v1/accounts/:id/followers +* [x] GET /api/v1/accounts/:id/following +* [x] GET /api/v1/accounts/:id/statuses +* [x] POST /api/v1/accounts/:id/follow +* [x] POST /api/v1/accounts/:id/unfollow +* [x] GET /api/v1/accounts/:id/block +* [x] GET /api/v1/accounts/:id/unblock +* [x] GET /api/v1/accounts/:id/mute +* [x] GET /api/v1/accounts/:id/unmute +* [x] GET /api/v1/accounts/:id/lists +* [x] GET /api/v1/accounts/relationships +* [x] GET /api/v1/accounts/search +* [x] POST /api/v1/apps +* [x] GET /api/v1/blocks +* [x] GET /api/v1/favourites +* [x] GET /api/v1/follow_requests +* [x] POST /api/v1/follow_requests/:id/authorize +* [x] POST /api/v1/follow_requests/:id/reject +* [x] POST /api/v1/follows +* [x] GET /api/v1/instance +* [x] GET /api/v1/instance/activity +* [x] GET /api/v1/instance/peers +* [x] GET /api/v1/lists +* [x] GET /api/v1/lists/:id/accounts +* [x] GET /api/v1/lists/:id +* [x] POST /api/v1/lists +* [x] PUT /api/v1/lists/:id +* [x] DELETE /api/v1/lists/:id +* [x] POST /api/v1/lists/:id/accounts +* [x] DELETE /api/v1/lists/:id/accounts +* [x] POST /api/v1/media +* [x] GET /api/v1/mutes +* [x] GET /api/v1/notifications +* [x] GET /api/v1/notifications/:id +* [x] POST /api/v1/notifications/clear +* [x] GET /api/v1/reports +* [x] POST /api/v1/reports +* [x] GET /api/v1/search +* [x] GET /api/v1/statuses/:id +* [x] GET /api/v1/statuses/:id/context +* [x] GET /api/v1/statuses/:id/card +* [x] GET /api/v1/statuses/:id/reblogged_by +* [x] GET /api/v1/statuses/:id/favourited_by +* [x] POST /api/v1/statuses +* [x] DELETE /api/v1/statuses/:id +* [x] POST /api/v1/statuses/:id/reblog +* [x] POST /api/v1/statuses/:id/unreblog +* [x] POST /api/v1/statuses/:id/favourite +* [x] POST /api/v1/statuses/:id/unfavourite +* [x] GET /api/v1/timelines/home +* [x] GET /api/v1/timelines/public +* [x] GET /api/v1/timelines/tag/:hashtag +* [x] GET /api/v1/timelines/list/:id + +## Installation + +``` +$ go get github.com/mattn/go-mastodon +``` + +## License + +MIT + +## Author + +Yasuhiro Matsumoto (a.k.a. mattn) diff --git a/mastodon/accounts.go b/mastodon/accounts.go new file mode 100644 index 0000000..e6f5a6d --- /dev/null +++ b/mastodon/accounts.go @@ -0,0 +1,314 @@ +package mastodon + +import ( + "context" + "fmt" + "net/http" + "net/url" + "strconv" + "time" +) + +// Account hold information for mastodon account. +type Account struct { + ID string `json:"id"` + Username string `json:"username"` + Acct string `json:"acct"` + DisplayName string `json:"display_name"` + Locked bool `json:"locked"` + CreatedAt time.Time `json:"created_at"` + FollowersCount int64 `json:"followers_count"` + FollowingCount int64 `json:"following_count"` + StatusesCount int64 `json:"statuses_count"` + Note string `json:"note"` + URL string `json:"url"` + Avatar string `json:"avatar"` + AvatarStatic string `json:"avatar_static"` + Header string `json:"header"` + HeaderStatic string `json:"header_static"` + Emojis []Emoji `json:"emojis"` + Moved *Account `json:"moved"` + Fields []Field `json:"fields"` + Bot bool `json:"bot"` +} + +// Field is a Mastodon account profile field. +type Field struct { + Name string `json:"name"` + Value string `json:"value"` + VerifiedAt time.Time `json:"verified_at"` +} + +// AccountSource is a Mastodon account profile field. +type AccountSource struct { + Privacy *string `json:"privacy"` + Sensitive *bool `json:"sensitive"` + Language *string `json:"language"` + Note *string `json:"note"` + Fields *[]Field `json:"fields"` +} + +// GetAccount return Account. +func (c *Client) GetAccount(ctx context.Context, id string) (*Account, error) { + var account Account + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/accounts/%s", url.PathEscape(string(id))), nil, &account, nil) + if err != nil { + return nil, err + } + return &account, nil +} + +// GetAccountCurrentUser return Account of current user. +func (c *Client) GetAccountCurrentUser(ctx context.Context) (*Account, error) { + var account Account + err := c.doAPI(ctx, http.MethodGet, "/api/v1/accounts/verify_credentials", nil, &account, nil) + if err != nil { + return nil, err + } + return &account, nil +} + +// Profile is a struct for updating profiles. +type Profile struct { + // If it is nil it will not be updated. + // If it is empty, update it with empty. + DisplayName *string + Note *string + Locked *bool + Fields *[]Field + Source *AccountSource + + // Set the base64 encoded character string of the image. + Avatar string + Header string +} + +// AccountUpdate updates the information of the current user. +func (c *Client) AccountUpdate(ctx context.Context, profile *Profile) (*Account, error) { + params := url.Values{} + if profile.DisplayName != nil { + params.Set("display_name", *profile.DisplayName) + } + if profile.Note != nil { + params.Set("note", *profile.Note) + } + if profile.Locked != nil { + params.Set("locked", strconv.FormatBool(*profile.Locked)) + } + if profile.Fields != nil { + for idx, field := range *profile.Fields { + params.Set(fmt.Sprintf("fields_attributes[%d][name]", idx), field.Name) + params.Set(fmt.Sprintf("fields_attributes[%d][value]", idx), field.Value) + } + } + if profile.Source != nil { + if profile.Source.Privacy != nil { + params.Set("source[privacy]", *profile.Source.Privacy) + } + if profile.Source.Sensitive != nil { + params.Set("source[sensitive]", strconv.FormatBool(*profile.Source.Sensitive)) + } + if profile.Source.Language != nil { + params.Set("source[language]", *profile.Source.Language) + } + } + if profile.Avatar != "" { + params.Set("avatar", profile.Avatar) + } + if profile.Header != "" { + params.Set("header", profile.Header) + } + + var account Account + err := c.doAPI(ctx, http.MethodPatch, "/api/v1/accounts/update_credentials", params, &account, nil) + if err != nil { + return nil, err + } + return &account, nil +} + +// GetAccountStatuses return statuses by specified accuont. +func (c *Client) GetAccountStatuses(ctx context.Context, id string, pg *Pagination) ([]*Status, error) { + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/accounts/%s/statuses", url.PathEscape(string(id))), nil, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// GetAccountFollowers return followers list. +func (c *Client) GetAccountFollowers(ctx context.Context, id string, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/accounts/%s/followers", url.PathEscape(string(id))), nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} + +// GetAccountFollowing return following list. +func (c *Client) GetAccountFollowing(ctx context.Context, id string, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/accounts/%s/following", url.PathEscape(string(id))), nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} + +// GetBlocks return block list. +func (c *Client) GetBlocks(ctx context.Context, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, "/api/v1/blocks", nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} + +// Relationship hold information for relation-ship to the account. +type Relationship struct { + ID string `json:"id"` + Following bool `json:"following"` + FollowedBy bool `json:"followed_by"` + Blocking bool `json:"blocking"` + Muting bool `json:"muting"` + MutingNotifications bool `json:"muting_notifications"` + Requested bool `json:"requested"` + DomainBlocking bool `json:"domain_blocking"` + ShowingReblogs bool `json:"showing_reblogs"` + Endorsed bool `json:"endorsed"` +} + +// AccountFollow follow the account. +func (c *Client) AccountFollow(ctx context.Context, id string) (*Relationship, error) { + var relationship Relationship + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%s/follow", url.PathEscape(string(id))), nil, &relationship, nil) + if err != nil { + return nil, err + } + return &relationship, nil +} + +// AccountUnfollow unfollow the account. +func (c *Client) AccountUnfollow(ctx context.Context, id string) (*Relationship, error) { + var relationship Relationship + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%s/unfollow", url.PathEscape(string(id))), nil, &relationship, nil) + if err != nil { + return nil, err + } + return &relationship, nil +} + +// AccountBlock block the account. +func (c *Client) AccountBlock(ctx context.Context, id string) (*Relationship, error) { + var relationship Relationship + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%s/block", url.PathEscape(string(id))), nil, &relationship, nil) + if err != nil { + return nil, err + } + return &relationship, nil +} + +// AccountUnblock unblock the account. +func (c *Client) AccountUnblock(ctx context.Context, id string) (*Relationship, error) { + var relationship Relationship + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%s/unblock", url.PathEscape(string(id))), nil, &relationship, nil) + if err != nil { + return nil, err + } + return &relationship, nil +} + +// AccountMute mute the account. +func (c *Client) AccountMute(ctx context.Context, id string) (*Relationship, error) { + var relationship Relationship + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%s/mute", url.PathEscape(string(id))), nil, &relationship, nil) + if err != nil { + return nil, err + } + return &relationship, nil +} + +// AccountUnmute unmute the account. +func (c *Client) AccountUnmute(ctx context.Context, id string) (*Relationship, error) { + var relationship Relationship + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%s/unmute", url.PathEscape(string(id))), nil, &relationship, nil) + if err != nil { + return nil, err + } + return &relationship, nil +} + +// GetAccountRelationships return relationship for the account. +func (c *Client) GetAccountRelationships(ctx context.Context, ids []string) ([]*Relationship, error) { + params := url.Values{} + for _, id := range ids { + params.Add("id[]", id) + } + + var relationships []*Relationship + err := c.doAPI(ctx, http.MethodGet, "/api/v1/accounts/relationships", params, &relationships, nil) + if err != nil { + return nil, err + } + return relationships, nil +} + +// AccountsSearch search accounts by query. +func (c *Client) AccountsSearch(ctx context.Context, q string, limit int64) ([]*Account, error) { + params := url.Values{} + params.Set("q", q) + params.Set("limit", fmt.Sprint(limit)) + + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, "/api/v1/accounts/search", params, &accounts, nil) + if err != nil { + return nil, err + } + return accounts, nil +} + +// FollowRemoteUser send follow-request. +func (c *Client) FollowRemoteUser(ctx context.Context, uri string) (*Account, error) { + params := url.Values{} + params.Set("uri", uri) + + var account Account + err := c.doAPI(ctx, http.MethodPost, "/api/v1/follows", params, &account, nil) + if err != nil { + return nil, err + } + return &account, nil +} + +// GetFollowRequests return follow-requests. +func (c *Client) GetFollowRequests(ctx context.Context, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, "/api/v1/follow_requests", nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} + +// FollowRequestAuthorize is authorize the follow request of user with id. +func (c *Client) FollowRequestAuthorize(ctx context.Context, id string) error { + return c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/follow_requests/%s/authorize", url.PathEscape(string(id))), nil, nil, nil) +} + +// FollowRequestReject is rejects the follow request of user with id. +func (c *Client) FollowRequestReject(ctx context.Context, id string) error { + return c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/follow_requests/%s/reject", url.PathEscape(string(id))), nil, nil, nil) +} + +// GetMutes returns the list of users muted by the current user. +func (c *Client) GetMutes(ctx context.Context, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, "/api/v1/mutes", nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} diff --git a/mastodon/apps.go b/mastodon/apps.go new file mode 100644 index 0000000..5d925c3 --- /dev/null +++ b/mastodon/apps.go @@ -0,0 +1,96 @@ +package mastodon + +import ( + "context" + "encoding/json" + "net/http" + "net/url" + "path" + "strings" +) + +// AppConfig is a setting for registering applications. +type AppConfig struct { + http.Client + Server string + ClientName string + + // Where the user should be redirected after authorization (for no redirect, use urn:ietf:wg:oauth:2.0:oob) + RedirectURIs string + + // This can be a space-separated list of items listed on the /settings/applications/new page of any Mastodon + // instance. "read", "write", and "follow" are top-level scopes that include all the permissions of the more + // specific scopes like "read:favourites", "write:statuses", and "write:follows". + Scopes string + + // Optional. + Website string +} + +// Application is mastodon application. +type Application struct { + ID string `json:"id"` + RedirectURI string `json:"redirect_uri"` + ClientID string `json:"client_id"` + ClientSecret string `json:"client_secret"` + + // AuthURI is not part of the Mastodon API; it is generated by go-mastodon. + AuthURI string `json:"auth_uri,omitempty"` +} + +// RegisterApp returns the mastodon application. +func RegisterApp(ctx context.Context, appConfig *AppConfig) (*Application, error) { + params := url.Values{} + params.Set("client_name", appConfig.ClientName) + if appConfig.RedirectURIs == "" { + params.Set("redirect_uris", "urn:ietf:wg:oauth:2.0:oob") + } else { + params.Set("redirect_uris", appConfig.RedirectURIs) + } + params.Set("scopes", appConfig.Scopes) + params.Set("website", appConfig.Website) + + u, err := url.Parse(appConfig.Server) + if err != nil { + return nil, err + } + u.Path = path.Join(u.Path, "/api/v1/apps") + + req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(params.Encode())) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + resp, err := appConfig.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, parseAPIError("bad request", resp) + } + + var app Application + err = json.NewDecoder(resp.Body).Decode(&app) + if err != nil { + return nil, err + } + + u, err = url.Parse(appConfig.Server) + if err != nil { + return nil, err + } + u.Path = path.Join(u.Path, "/oauth/authorize") + u.RawQuery = url.Values{ + "scope": {appConfig.Scopes}, + "response_type": {"code"}, + "redirect_uri": {app.RedirectURI}, + "client_id": {app.ClientID}, + }.Encode() + + app.AuthURI = u.String() + + return &app, nil +} diff --git a/mastodon/go.mod b/mastodon/go.mod new file mode 100644 index 0000000..ea24109 --- /dev/null +++ b/mastodon/go.mod @@ -0,0 +1,8 @@ +module mastodon + +go 1.13 + +require ( + github.com/gorilla/websocket v1.4.1 + github.com/tomnomnom/linkheader v0.0.0-20180905144013-02ca5825eb80 +) diff --git a/mastodon/go.sum b/mastodon/go.sum new file mode 100644 index 0000000..3ec24b2 --- /dev/null +++ b/mastodon/go.sum @@ -0,0 +1,4 @@ +github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM= +github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/tomnomnom/linkheader v0.0.0-20180905144013-02ca5825eb80 h1:nrZ3ySNYwJbSpD6ce9duiP+QkD3JuLCcWkdaehUS/3Y= +github.com/tomnomnom/linkheader v0.0.0-20180905144013-02ca5825eb80/go.mod h1:iFyPdL66DjUD96XmzVL3ZntbzcflLnznH0fr99w5VqE= diff --git a/mastodon/helper.go b/mastodon/helper.go new file mode 100644 index 0000000..05af20f --- /dev/null +++ b/mastodon/helper.go @@ -0,0 +1,55 @@ +package mastodon + +import ( + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "net/http" + "os" +) + +// Base64EncodeFileName returns the base64 data URI format string of the file with the file name. +func Base64EncodeFileName(filename string) (string, error) { + file, err := os.Open(filename) + if err != nil { + return "", err + } + defer file.Close() + + return Base64Encode(file) +} + +// Base64Encode returns the base64 data URI format string of the file. +func Base64Encode(file *os.File) (string, error) { + fi, err := file.Stat() + if err != nil { + return "", err + } + + d := make([]byte, fi.Size()) + _, err = file.Read(d) + if err != nil { + return "", err + } + + return "data:" + http.DetectContentType(d) + + ";base64," + base64.StdEncoding.EncodeToString(d), nil +} + +// String is a helper function to get the pointer value of a string. +func String(v string) *string { return &v } + +func parseAPIError(prefix string, resp *http.Response) error { + errMsg := fmt.Sprintf("%s: %s", prefix, resp.Status) + var e struct { + Error string `json:"error"` + } + + json.NewDecoder(resp.Body).Decode(&e) + if e.Error != "" { + errMsg = fmt.Sprintf("%s: %s", errMsg, e.Error) + } + + return errors.New(errMsg) +} diff --git a/mastodon/instance.go b/mastodon/instance.go new file mode 100644 index 0000000..3217450 --- /dev/null +++ b/mastodon/instance.go @@ -0,0 +1,65 @@ +package mastodon + +import ( + "context" + "net/http" +) + +// Instance hold information for mastodon instance. +type Instance struct { + URI string `json:"uri"` + Title string `json:"title"` + Description string `json:"description"` + EMail string `json:"email"` + Version string `json:"version,omitempty"` + Thumbnail string `json:"thumbnail,omitempty"` + URLs map[string]string `json:"urls,omitempty"` + Stats *InstanceStats `json:"stats,omitempty"` + Languages []string `json:"languages"` + ContactAccount *Account `json:"account"` +} + +// InstanceStats hold information for mastodon instance stats. +type InstanceStats struct { + UserCount int64 `json:"user_count"` + StatusCount int64 `json:"status_count"` + DomainCount int64 `json:"domain_count"` +} + +// GetInstance return Instance. +func (c *Client) GetInstance(ctx context.Context) (*Instance, error) { + var instance Instance + err := c.doAPI(ctx, http.MethodGet, "/api/v1/instance", nil, &instance, nil) + if err != nil { + return nil, err + } + return &instance, nil +} + +// WeeklyActivity hold information for mastodon weekly activity. +type WeeklyActivity struct { + Week Unixtime `json:"week"` + Statuses int64 `json:"statuses,string"` + Logins int64 `json:"logins,string"` + Registrations int64 `json:"registrations,string"` +} + +// GetInstanceActivity return instance activity. +func (c *Client) GetInstanceActivity(ctx context.Context) ([]*WeeklyActivity, error) { + var activity []*WeeklyActivity + err := c.doAPI(ctx, http.MethodGet, "/api/v1/instance/activity", nil, &activity, nil) + if err != nil { + return nil, err + } + return activity, nil +} + +// GetInstancePeers return instance peers. +func (c *Client) GetInstancePeers(ctx context.Context) ([]string, error) { + var peers []string + err := c.doAPI(ctx, http.MethodGet, "/api/v1/instance/peers", nil, &peers, nil) + if err != nil { + return nil, err + } + return peers, nil +} diff --git a/mastodon/lists.go b/mastodon/lists.go new file mode 100644 index 0000000..d323b79 --- /dev/null +++ b/mastodon/lists.go @@ -0,0 +1,107 @@ +package mastodon + +import ( + "context" + "fmt" + "net/http" + "net/url" +) + +// List is metadata for a list of users. +type List struct { + ID string `json:"id"` + Title string `json:"title"` +} + +// GetLists returns all the lists on the current account. +func (c *Client) GetLists(ctx context.Context) ([]*List, error) { + var lists []*List + err := c.doAPI(ctx, http.MethodGet, "/api/v1/lists", nil, &lists, nil) + if err != nil { + return nil, err + } + return lists, nil +} + +// GetAccountLists returns the lists containing a given account. +func (c *Client) GetAccountLists(ctx context.Context, id string) ([]*List, error) { + var lists []*List + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/accounts/%s/lists", url.PathEscape(string(id))), nil, &lists, nil) + if err != nil { + return nil, err + } + return lists, nil +} + +// GetListAccounts returns the accounts in a given list. +func (c *Client) GetListAccounts(ctx context.Context, id string) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/lists/%s/accounts", url.PathEscape(string(id))), url.Values{"limit": {"0"}}, &accounts, nil) + if err != nil { + return nil, err + } + return accounts, nil +} + +// GetList retrieves a list by string. +func (c *Client) GetList(ctx context.Context, id string) (*List, error) { + var list List + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/lists/%s", url.PathEscape(string(id))), nil, &list, nil) + if err != nil { + return nil, err + } + return &list, nil +} + +// CreateList creates a new list with a given title. +func (c *Client) CreateList(ctx context.Context, title string) (*List, error) { + params := url.Values{} + params.Set("title", title) + + var list List + err := c.doAPI(ctx, http.MethodPost, "/api/v1/lists", params, &list, nil) + if err != nil { + return nil, err + } + return &list, nil +} + +// RenameList assigns a new title to a list. +func (c *Client) RenameList(ctx context.Context, id string, title string) (*List, error) { + params := url.Values{} + params.Set("title", title) + + var list List + err := c.doAPI(ctx, http.MethodPut, fmt.Sprintf("/api/v1/lists/%s", url.PathEscape(string(id))), params, &list, nil) + if err != nil { + return nil, err + } + return &list, nil +} + +// DeleteList removes a list. +func (c *Client) DeleteList(ctx context.Context, id string) error { + return c.doAPI(ctx, http.MethodDelete, fmt.Sprintf("/api/v1/lists/%s", url.PathEscape(string(id))), nil, nil, nil) +} + +// AddToList adds accounts to a list. +// +// Only accounts already followed by the user can be added to a list. +func (c *Client) AddToList(ctx context.Context, list string, accounts ...string) error { + params := url.Values{} + for _, acct := range accounts { + params.Add("account_ids", string(acct)) + } + + return c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/lists/%s/accounts", url.PathEscape(string(list))), params, nil, nil) +} + +// RemoveFromList removes accounts from a list. +func (c *Client) RemoveFromList(ctx context.Context, list string, accounts ...string) error { + params := url.Values{} + for _, acct := range accounts { + params.Add("account_ids", string(acct)) + } + + return c.doAPI(ctx, http.MethodDelete, fmt.Sprintf("/api/v1/lists/%s/accounts", url.PathEscape(string(list))), params, nil, nil) +} diff --git a/mastodon/mastodon.go b/mastodon/mastodon.go new file mode 100644 index 0000000..ff86d2b --- /dev/null +++ b/mastodon/mastodon.go @@ -0,0 +1,388 @@ +// Package mastodon provides functions and structs for accessing the mastodon API. +package mastodon + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "mime/multipart" + "net/http" + "net/url" + "os" + "path" + "path/filepath" + "strings" + "time" + + "github.com/tomnomnom/linkheader" +) + +// Config is a setting for access mastodon APIs. +type Config struct { + Server string + ClientID string + ClientSecret string + AccessToken string +} + +// Client is a API client for mastodon. +type Client struct { + http.Client + config *Config +} + +func (c *Client) doAPI(ctx context.Context, method string, uri string, params interface{}, res interface{}, pg *Pagination) error { + u, err := url.Parse(c.config.Server) + if err != nil { + return err + } + u.Path = path.Join(u.Path, uri) + + var req *http.Request + ct := "application/x-www-form-urlencoded" + if values, ok := params.(url.Values); ok { + var body io.Reader + if method == http.MethodGet { + if pg != nil { + values = pg.setValues(values) + } + u.RawQuery = values.Encode() + } else { + body = strings.NewReader(values.Encode()) + } + req, err = http.NewRequest(method, u.String(), body) + if err != nil { + return err + } + } else if file, ok := params.(string); ok { + f, err := os.Open(file) + if err != nil { + return err + } + defer f.Close() + + var buf bytes.Buffer + mw := multipart.NewWriter(&buf) + part, err := mw.CreateFormFile("file", filepath.Base(file)) + if err != nil { + return err + } + _, err = io.Copy(part, f) + if err != nil { + return err + } + err = mw.Close() + if err != nil { + return err + } + req, err = http.NewRequest(method, u.String(), &buf) + if err != nil { + return err + } + ct = mw.FormDataContentType() + } else if reader, ok := params.(io.Reader); ok { + var buf bytes.Buffer + mw := multipart.NewWriter(&buf) + part, err := mw.CreateFormFile("file", "upload") + if err != nil { + return err + } + _, err = io.Copy(part, reader) + if err != nil { + return err + } + err = mw.Close() + if err != nil { + return err + } + req, err = http.NewRequest(method, u.String(), &buf) + if err != nil { + return err + } + ct = mw.FormDataContentType() + } else { + if method == http.MethodGet && pg != nil { + u.RawQuery = pg.toValues().Encode() + } + req, err = http.NewRequest(method, u.String(), nil) + if err != nil { + return err + } + } + req = req.WithContext(ctx) + req.Header.Set("Authorization", "Bearer "+c.config.AccessToken) + if params != nil { + req.Header.Set("Content-Type", ct) + } + + var resp *http.Response + backoff := 1000 * time.Millisecond + for { + resp, err = c.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + + // handle status code 429, which indicates the server is throttling + // our requests. Do an exponential backoff and retry the request. + if resp.StatusCode == 429 { + if backoff > time.Hour { + break + } + backoff *= 2 + + select { + case <-time.After(backoff): + case <-ctx.Done(): + return ctx.Err() + } + continue + } + break + } + + if resp.StatusCode != http.StatusOK { + return parseAPIError("bad request", resp) + } else if res == nil { + return nil + } else if pg != nil { + if lh := resp.Header.Get("Link"); lh != "" { + pg2, err := newPagination(lh) + if err != nil { + return err + } + *pg = *pg2 + } + } + return json.NewDecoder(resp.Body).Decode(&res) +} + +// NewClient return new mastodon API client. +func NewClient(config *Config) *Client { + return &Client{ + Client: *http.DefaultClient, + config: config, + } +} + +// Authenticate get access-token to the API. +func (c *Client) Authenticate(ctx context.Context, username, password string) error { + params := url.Values{ + "client_id": {c.config.ClientID}, + "client_secret": {c.config.ClientSecret}, + "grant_type": {"password"}, + "username": {username}, + "password": {password}, + "scope": {"read write follow"}, + } + + return c.authenticate(ctx, params) +} + +// AuthenticateToken logs in using a grant token returned by Application.AuthURI. +// +// redirectURI should be the same as Application.RedirectURI. +func (c *Client) AuthenticateToken(ctx context.Context, authCode, redirectURI string) error { + params := url.Values{ + "client_id": {c.config.ClientID}, + "client_secret": {c.config.ClientSecret}, + "grant_type": {"authorization_code"}, + "code": {authCode}, + "redirect_uri": {redirectURI}, + } + + return c.authenticate(ctx, params) +} + +func (c *Client) authenticate(ctx context.Context, params url.Values) error { + u, err := url.Parse(c.config.Server) + if err != nil { + return err + } + u.Path = path.Join(u.Path, "/oauth/token") + + req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(params.Encode())) + if err != nil { + return err + } + req = req.WithContext(ctx) + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + resp, err := c.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return parseAPIError("bad authorization", resp) + } + + var res struct { + AccessToken string `json:"access_token"` + } + err = json.NewDecoder(resp.Body).Decode(&res) + if err != nil { + return err + } + c.config.AccessToken = res.AccessToken + return nil +} + +func (c *Client) GetAccessToken(ctx context.Context) string { + if c == nil || c.config == nil { + return "" + } + return c.config.AccessToken +} + +// Toot is struct to post status. +type Toot struct { + Status string `json:"status"` + InReplyToID string `json:"in_reply_to_id"` + MediaIDs []string `json:"media_ids"` + Sensitive bool `json:"sensitive"` + SpoilerText string `json:"spoiler_text"` + Visibility string `json:"visibility"` +} + +// Mention hold information for mention. +type Mention struct { + URL string `json:"url"` + Username string `json:"username"` + Acct string `json:"acct"` + ID string `json:"id"` +} + +// Tag hold information for tag. +type Tag struct { + Name string `json:"name"` + URL string `json:"url"` + History []History `json:"history"` +} + +// History hold information for history. +type History struct { + Day string `json:"day"` + Uses int64 `json:"uses"` + Accounts int64 `json:"accounts"` +} + +// Attachment hold information for attachment. +type Attachment struct { + ID string `json:"id"` + Type string `json:"type"` + URL string `json:"url"` + RemoteURL string `json:"remote_url"` + PreviewURL string `json:"preview_url"` + TextURL string `json:"text_url"` + Description string `json:"description"` + Meta AttachmentMeta `json:"meta"` +} + +// AttachmentMeta holds information for attachment metadata. +type AttachmentMeta struct { + Original AttachmentSize `json:"original"` + Small AttachmentSize `json:"small"` +} + +// AttachmentSize holds information for attatchment size. +type AttachmentSize struct { + Width int64 `json:"width"` + Height int64 `json:"height"` + Size string `json:"size"` + Aspect float64 `json:"aspect"` +} + +// Emoji hold information for CustomEmoji. +type Emoji struct { + ShortCode string `json:"shortcode"` + StaticURL string `json:"static_url"` + URL string `json:"url"` + VisibleInPicker bool `json:"visible_in_picker"` +} + +// Results hold information for search result. +type Results struct { + Accounts []*Account `json:"accounts"` + Statuses []*Status `json:"statuses"` + Hashtags []string `json:"hashtags"` +} + +// Pagination is a struct for specifying the get range. +type Pagination struct { + MaxID string + SinceID string + MinID string + Limit int64 +} + +func newPagination(rawlink string) (*Pagination, error) { + if rawlink == "" { + return nil, errors.New("empty link header") + } + + p := &Pagination{} + for _, link := range linkheader.Parse(rawlink) { + switch link.Rel { + case "next": + maxID, err := getPaginationID(link.URL, "max_id") + if err != nil { + return nil, err + } + p.MaxID = maxID + case "prev": + sinceID, err := getPaginationID(link.URL, "since_id") + if err != nil { + return nil, err + } + p.SinceID = sinceID + + minID, err := getPaginationID(link.URL, "min_id") + if err != nil { + return nil, err + } + p.MinID = minID + } + } + + return p, nil +} + +func getPaginationID(rawurl, key string) (string, error) { + u, err := url.Parse(rawurl) + if err != nil { + return "", err + } + + val := u.Query().Get(key) + if val == "" { + return "", nil + } + + return string(val), nil +} + +func (p *Pagination) toValues() url.Values { + return p.setValues(url.Values{}) +} + +func (p *Pagination) setValues(params url.Values) url.Values { + if p.MaxID != "" { + params.Set("max_id", string(p.MaxID)) + } + if p.SinceID != "" { + params.Set("since_id", string(p.SinceID)) + } + if p.MinID != "" { + params.Set("min_id", string(p.MinID)) + } + if p.Limit > 0 { + params.Set("limit", fmt.Sprint(p.Limit)) + } + + return params +} diff --git a/mastodon/notification.go b/mastodon/notification.go new file mode 100644 index 0000000..236fcbf --- /dev/null +++ b/mastodon/notification.go @@ -0,0 +1,42 @@ +package mastodon + +import ( + "context" + "fmt" + "net/http" + "time" +) + +// Notification hold information for mastodon notification. +type Notification struct { + ID string `json:"id"` + Type string `json:"type"` + CreatedAt time.Time `json:"created_at"` + Account Account `json:"account"` + Status *Status `json:"status"` +} + +// GetNotifications return notifications. +func (c *Client) GetNotifications(ctx context.Context, pg *Pagination) ([]*Notification, error) { + var notifications []*Notification + err := c.doAPI(ctx, http.MethodGet, "/api/v1/notifications", nil, ¬ifications, pg) + if err != nil { + return nil, err + } + return notifications, nil +} + +// GetNotification return notification. +func (c *Client) GetNotification(ctx context.Context, id string) (*Notification, error) { + var notification Notification + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/notifications/%v", id), nil, ¬ification, nil) + if err != nil { + return nil, err + } + return ¬ification, nil +} + +// ClearNotifications clear notifications. +func (c *Client) ClearNotifications(ctx context.Context) error { + return c.doAPI(ctx, http.MethodPost, "/api/v1/notifications/clear", nil, nil, nil) +} diff --git a/mastodon/report.go b/mastodon/report.go new file mode 100644 index 0000000..920614a --- /dev/null +++ b/mastodon/report.go @@ -0,0 +1,39 @@ +package mastodon + +import ( + "context" + "net/http" + "net/url" +) + +// Report hold information for mastodon report. +type Report struct { + ID int64 `json:"id"` + ActionTaken bool `json:"action_taken"` +} + +// GetReports return report of the current user. +func (c *Client) GetReports(ctx context.Context) ([]*Report, error) { + var reports []*Report + err := c.doAPI(ctx, http.MethodGet, "/api/v1/reports", nil, &reports, nil) + if err != nil { + return nil, err + } + return reports, nil +} + +// Report reports the report +func (c *Client) Report(ctx context.Context, accountID string, ids []string, comment string) (*Report, error) { + params := url.Values{} + params.Set("account_id", string(accountID)) + for _, id := range ids { + params.Add("status_ids[]", string(id)) + } + params.Set("comment", comment) + var report Report + err := c.doAPI(ctx, http.MethodPost, "/api/v1/reports", params, &report, nil) + if err != nil { + return nil, err + } + return &report, nil +} diff --git a/mastodon/status.go b/mastodon/status.go new file mode 100644 index 0000000..fd69914 --- /dev/null +++ b/mastodon/status.go @@ -0,0 +1,297 @@ +package mastodon + +import ( + "context" + "fmt" + "io" + "net/http" + "net/url" + "time" +) + +// Status is struct to hold status. +type Status struct { + ID string `json:"id"` + URI string `json:"uri"` + URL string `json:"url"` + Account Account `json:"account"` + InReplyToID interface{} `json:"in_reply_to_id"` + InReplyToAccountID interface{} `json:"in_reply_to_account_id"` + Reblog *Status `json:"reblog"` + Content string `json:"content"` + CreatedAt time.Time `json:"created_at"` + Emojis []Emoji `json:"emojis"` + RepliesCount int64 `json:"replies_count"` + ReblogsCount int64 `json:"reblogs_count"` + FavouritesCount int64 `json:"favourites_count"` + Reblogged interface{} `json:"reblogged"` + Favourited interface{} `json:"favourited"` + Muted interface{} `json:"muted"` + Sensitive bool `json:"sensitive"` + SpoilerText string `json:"spoiler_text"` + Visibility string `json:"visibility"` + MediaAttachments []Attachment `json:"media_attachments"` + Mentions []Mention `json:"mentions"` + Tags []Tag `json:"tags"` + Card *Card `json:"card"` + Application Application `json:"application"` + Language string `json:"language"` + Pinned interface{} `json:"pinned"` +} + +// Context hold information for mastodon context. +type Context struct { + Ancestors []*Status `json:"ancestors"` + Descendants []*Status `json:"descendants"` +} + +// Card hold information for mastodon card. +type Card struct { + URL string `json:"url"` + Title string `json:"title"` + Description string `json:"description"` + Image string `json:"image"` + Type string `json:"type"` + AuthorName string `json:"author_name"` + AuthorURL string `json:"author_url"` + ProviderName string `json:"provider_name"` + ProviderURL string `json:"provider_url"` + HTML string `json:"html"` + Width int64 `json:"width"` + Height int64 `json:"height"` +} + +// GetFavourites return the favorite list of the current user. +func (c *Client) GetFavourites(ctx context.Context, pg *Pagination) ([]*Status, error) { + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, "/api/v1/favourites", nil, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// GetStatus return status specified by id. +func (c *Client) GetStatus(ctx context.Context, id string) (*Status, error) { + var status Status + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/statuses/%s", id), nil, &status, nil) + if err != nil { + return nil, err + } + return &status, nil +} + +// GetStatusContext return status specified by id. +func (c *Client) GetStatusContext(ctx context.Context, id string) (*Context, error) { + var context Context + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/statuses/%s/context", id), nil, &context, nil) + if err != nil { + return nil, err + } + return &context, nil +} + +// GetStatusCard return status specified by id. +func (c *Client) GetStatusCard(ctx context.Context, id string) (*Card, error) { + var card Card + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/statuses/%s/card", id), nil, &card, nil) + if err != nil { + return nil, err + } + return &card, nil +} + +// GetRebloggedBy returns the account list of the user who reblogged the toot of id. +func (c *Client) GetRebloggedBy(ctx context.Context, id string, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/statuses/%s/reblogged_by", id), nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} + +// GetFavouritedBy returns the account list of the user who liked the toot of id. +func (c *Client) GetFavouritedBy(ctx context.Context, id string, pg *Pagination) ([]*Account, error) { + var accounts []*Account + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/statuses/%s/favourited_by", id), nil, &accounts, pg) + if err != nil { + return nil, err + } + return accounts, nil +} + +// Reblog is reblog the toot of id and return status of reblog. +func (c *Client) Reblog(ctx context.Context, id string) (*Status, error) { + var status Status + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/reblog", id), nil, &status, nil) + if err != nil { + return nil, err + } + return &status, nil +} + +// Unreblog is unreblog the toot of id and return status of the original toot. +func (c *Client) Unreblog(ctx context.Context, id string) (*Status, error) { + var status Status + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/unreblog", id), nil, &status, nil) + if err != nil { + return nil, err + } + return &status, nil +} + +// Favourite is favourite the toot of id and return status of the favourite toot. +func (c *Client) Favourite(ctx context.Context, id string) (*Status, error) { + var status Status + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/favourite", id), nil, &status, nil) + if err != nil { + return nil, err + } + return &status, nil +} + +// Unfavourite is unfavourite the toot of id and return status of the unfavourite toot. +func (c *Client) Unfavourite(ctx context.Context, id string) (*Status, error) { + var status Status + err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/unfavourite", id), nil, &status, nil) + if err != nil { + return nil, err + } + return &status, nil +} + +// GetTimelineHome return statuses from home timeline. +func (c *Client) GetTimelineHome(ctx context.Context, pg *Pagination) ([]*Status, error) { + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, "/api/v1/timelines/home", nil, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// GetTimelinePublic return statuses from public timeline. +func (c *Client) GetTimelinePublic(ctx context.Context, isLocal bool, pg *Pagination) ([]*Status, error) { + params := url.Values{} + if isLocal { + params.Set("local", "t") + } + + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, "/api/v1/timelines/public", params, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// GetTimelineHashtag return statuses from tagged timeline. +func (c *Client) GetTimelineHashtag(ctx context.Context, tag string, isLocal bool, pg *Pagination) ([]*Status, error) { + params := url.Values{} + if isLocal { + params.Set("local", "t") + } + + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/timelines/tag/%s", url.PathEscape(tag)), params, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// GetTimelineList return statuses from a list timeline. +func (c *Client) GetTimelineList(ctx context.Context, id string, pg *Pagination) ([]*Status, error) { + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/timelines/list/%s", url.PathEscape(string(id))), nil, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// GetTimelineMedia return statuses from media timeline. +// NOTE: This is an experimental feature of pawoo.net. +func (c *Client) GetTimelineMedia(ctx context.Context, isLocal bool, pg *Pagination) ([]*Status, error) { + params := url.Values{} + params.Set("media", "t") + if isLocal { + params.Set("local", "t") + } + + var statuses []*Status + err := c.doAPI(ctx, http.MethodGet, "/api/v1/timelines/public", params, &statuses, pg) + if err != nil { + return nil, err + } + return statuses, nil +} + +// PostStatus post the toot. +func (c *Client) PostStatus(ctx context.Context, toot *Toot) (*Status, error) { + params := url.Values{} + params.Set("status", toot.Status) + if toot.InReplyToID != "" { + params.Set("in_reply_to_id", string(toot.InReplyToID)) + } + if toot.MediaIDs != nil { + for _, media := range toot.MediaIDs { + params.Add("media_ids[]", string(media)) + } + } + if toot.Visibility != "" { + params.Set("visibility", fmt.Sprint(toot.Visibility)) + } + if toot.Sensitive { + params.Set("sensitive", "true") + } + if toot.SpoilerText != "" { + params.Set("spoiler_text", toot.SpoilerText) + } + + var status Status + err := c.doAPI(ctx, http.MethodPost, "/api/v1/statuses", params, &status, nil) + if err != nil { + return nil, err + } + return &status, nil +} + +// DeleteStatus delete the toot. +func (c *Client) DeleteStatus(ctx context.Context, id string) error { + return c.doAPI(ctx, http.MethodDelete, fmt.Sprintf("/api/v1/statuses/%s", id), nil, nil, nil) +} + +// Search search content with query. +func (c *Client) Search(ctx context.Context, q string, resolve bool) (*Results, error) { + params := url.Values{} + params.Set("q", q) + params.Set("resolve", fmt.Sprint(resolve)) + var results Results + err := c.doAPI(ctx, http.MethodGet, "/api/v1/search", params, &results, nil) + if err != nil { + return nil, err + } + return &results, nil +} + +// UploadMedia upload a media attachment from a file. +func (c *Client) UploadMedia(ctx context.Context, file string) (*Attachment, error) { + var attachment Attachment + err := c.doAPI(ctx, http.MethodPost, "/api/v1/media", file, &attachment, nil) + if err != nil { + return nil, err + } + return &attachment, nil +} + +// UploadMediaFromReader uploads a media attachment from a io.Reader. +func (c *Client) UploadMediaFromReader(ctx context.Context, reader io.Reader) (*Attachment, error) { + var attachment Attachment + err := c.doAPI(ctx, http.MethodPost, "/api/v1/media", reader, &attachment, nil) + if err != nil { + return nil, err + } + return &attachment, nil +} diff --git a/mastodon/streaming.go b/mastodon/streaming.go new file mode 100644 index 0000000..77ae284 --- /dev/null +++ b/mastodon/streaming.go @@ -0,0 +1,166 @@ +package mastodon + +import ( + "bufio" + "context" + "encoding/json" + "io" + "net/http" + "net/url" + "path" + "strings" +) + +// UpdateEvent is struct for passing status event to app. +type UpdateEvent struct { + Status *Status `json:"status"` +} + +func (e *UpdateEvent) event() {} + +// NotificationEvent is struct for passing notification event to app. +type NotificationEvent struct { + Notification *Notification `json:"notification"` +} + +func (e *NotificationEvent) event() {} + +// DeleteEvent is struct for passing deletion event to app. +type DeleteEvent struct{ ID string } + +func (e *DeleteEvent) event() {} + +// ErrorEvent is struct for passing errors to app. +type ErrorEvent struct{ err error } + +func (e *ErrorEvent) event() {} +func (e *ErrorEvent) Error() string { return e.err.Error() } + +// Event is interface passing events to app. +type Event interface { + event() +} + +func handleReader(q chan Event, r io.Reader) error { + var name string + s := bufio.NewScanner(r) + for s.Scan() { + line := s.Text() + token := strings.SplitN(line, ":", 2) + if len(token) != 2 { + continue + } + switch strings.TrimSpace(token[0]) { + case "event": + name = strings.TrimSpace(token[1]) + case "data": + var err error + switch name { + case "update": + var status Status + err = json.Unmarshal([]byte(token[1]), &status) + if err == nil { + q <- &UpdateEvent{&status} + } + case "notification": + var notification Notification + err = json.Unmarshal([]byte(token[1]), ¬ification) + if err == nil { + q <- &NotificationEvent{¬ification} + } + case "delete": + q <- &DeleteEvent{ID: string(strings.TrimSpace(token[1]))} + } + if err != nil { + q <- &ErrorEvent{err} + } + } + } + return s.Err() +} + +func (c *Client) streaming(ctx context.Context, p string, params url.Values) (chan Event, error) { + u, err := url.Parse(c.config.Server) + if err != nil { + return nil, err + } + u.Path = path.Join(u.Path, "/api/v1/streaming", p) + u.RawQuery = params.Encode() + + req, err := http.NewRequest(http.MethodGet, u.String(), nil) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + req.Header.Set("Authorization", "Bearer "+c.config.AccessToken) + + q := make(chan Event) + go func() { + defer close(q) + for { + select { + case <-ctx.Done(): + return + default: + } + + c.doStreaming(req, q) + } + }() + return q, nil +} + +func (c *Client) doStreaming(req *http.Request, q chan Event) { + resp, err := c.Do(req) + if err != nil { + q <- &ErrorEvent{err} + return + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + q <- &ErrorEvent{parseAPIError("bad request", resp)} + return + } + + err = handleReader(q, resp.Body) + if err != nil { + q <- &ErrorEvent{err} + } +} + +// StreamingUser return channel to read events on home. +func (c *Client) StreamingUser(ctx context.Context) (chan Event, error) { + return c.streaming(ctx, "user", nil) +} + +// StreamingPublic return channel to read events on public. +func (c *Client) StreamingPublic(ctx context.Context, isLocal bool) (chan Event, error) { + p := "public" + if isLocal { + p = path.Join(p, "local") + } + + return c.streaming(ctx, p, nil) +} + +// StreamingHashtag return channel to read events on tagged timeline. +func (c *Client) StreamingHashtag(ctx context.Context, tag string, isLocal bool) (chan Event, error) { + params := url.Values{} + params.Set("tag", tag) + + p := "hashtag" + if isLocal { + p = path.Join(p, "local") + } + + return c.streaming(ctx, p, params) +} + +// StreamingList return channel to read events on a list. +func (c *Client) StreamingList(ctx context.Context, id string) (chan Event, error) { + params := url.Values{} + params.Set("list", string(id)) + + return c.streaming(ctx, "list", params) +} diff --git a/mastodon/streaming_ws.go b/mastodon/streaming_ws.go new file mode 100644 index 0000000..838f65b --- /dev/null +++ b/mastodon/streaming_ws.go @@ -0,0 +1,195 @@ +package mastodon + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "path" + "strings" + + "github.com/gorilla/websocket" +) + +// WSClient is a WebSocket client. +type WSClient struct { + websocket.Dialer + client *Client +} + +// NewWSClient return WebSocket client. +func (c *Client) NewWSClient() *WSClient { return &WSClient{client: c} } + +// Stream is a struct of data that flows in streaming. +type Stream struct { + Event string `json:"event"` + Payload interface{} `json:"payload"` +} + +// StreamingWSUser return channel to read events on home using WebSocket. +func (c *WSClient) StreamingWSUser(ctx context.Context) (chan Event, error) { + return c.streamingWS(ctx, "user", "") +} + +// StreamingWSPublic return channel to read events on public using WebSocket. +func (c *WSClient) StreamingWSPublic(ctx context.Context, isLocal bool) (chan Event, error) { + s := "public" + if isLocal { + s += ":local" + } + + return c.streamingWS(ctx, s, "") +} + +// StreamingWSHashtag return channel to read events on tagged timeline using WebSocket. +func (c *WSClient) StreamingWSHashtag(ctx context.Context, tag string, isLocal bool) (chan Event, error) { + s := "hashtag" + if isLocal { + s += ":local" + } + + return c.streamingWS(ctx, s, tag) +} + +// StreamingWSList return channel to read events on a list using WebSocket. +func (c *WSClient) StreamingWSList(ctx context.Context, id string) (chan Event, error) { + return c.streamingWS(ctx, "list", string(id)) +} + +func (c *WSClient) streamingWS(ctx context.Context, stream, tag string) (chan Event, error) { + params := url.Values{} + params.Set("access_token", c.client.config.AccessToken) + params.Set("stream", stream) + if tag != "" { + params.Set("tag", tag) + } + + u, err := changeWebSocketScheme(c.client.config.Server) + if err != nil { + return nil, err + } + u.Path = path.Join(u.Path, "/api/v1/streaming") + u.RawQuery = params.Encode() + + q := make(chan Event) + go func() { + defer close(q) + for { + err := c.handleWS(ctx, u.String(), q) + if err != nil { + return + } + } + }() + + return q, nil +} + +func (c *WSClient) handleWS(ctx context.Context, rawurl string, q chan Event) error { + conn, err := c.dialRedirect(rawurl) + if err != nil { + q <- &ErrorEvent{err: err} + + // End. + return err + } + + // Close the WebSocket when the context is canceled. + go func() { + <-ctx.Done() + conn.Close() + }() + + for { + select { + case <-ctx.Done(): + q <- &ErrorEvent{err: ctx.Err()} + + // End. + return ctx.Err() + default: + } + + var s Stream + err := conn.ReadJSON(&s) + if err != nil { + q <- &ErrorEvent{err: err} + + // Reconnect. + break + } + + err = nil + switch s.Event { + case "update": + var status Status + err = json.Unmarshal([]byte(s.Payload.(string)), &status) + if err == nil { + q <- &UpdateEvent{Status: &status} + } + case "notification": + var notification Notification + err = json.Unmarshal([]byte(s.Payload.(string)), ¬ification) + if err == nil { + q <- &NotificationEvent{Notification: ¬ification} + } + case "delete": + if f, ok := s.Payload.(float64); ok { + q <- &DeleteEvent{ID: fmt.Sprint(int64(f))} + } else { + q <- &DeleteEvent{ID: strings.TrimSpace(s.Payload.(string))} + } + } + if err != nil { + q <- &ErrorEvent{err} + } + } + + return nil +} + +func (c *WSClient) dialRedirect(rawurl string) (conn *websocket.Conn, err error) { + for { + conn, rawurl, err = c.dial(rawurl) + if err != nil { + return nil, err + } else if conn != nil { + return conn, nil + } + } +} + +func (c *WSClient) dial(rawurl string) (*websocket.Conn, string, error) { + conn, resp, err := c.Dial(rawurl, nil) + if err != nil && err != websocket.ErrBadHandshake { + return nil, "", err + } + defer resp.Body.Close() + + if loc := resp.Header.Get("Location"); loc != "" { + u, err := changeWebSocketScheme(loc) + if err != nil { + return nil, "", err + } + + return nil, u.String(), nil + } + + return conn, "", err +} + +func changeWebSocketScheme(rawurl string) (*url.URL, error) { + u, err := url.Parse(rawurl) + if err != nil { + return nil, err + } + + switch u.Scheme { + case "http": + u.Scheme = "ws" + case "https": + u.Scheme = "wss" + } + + return u, nil +} diff --git a/mastodon/unixtime.go b/mastodon/unixtime.go new file mode 100644 index 0000000..a935a9e --- /dev/null +++ b/mastodon/unixtime.go @@ -0,0 +1,20 @@ +package mastodon + +import ( + "strconv" + "time" +) + +type Unixtime time.Time + +func (t *Unixtime) UnmarshalJSON(data []byte) error { + if len(data) > 0 && data[0] == '"' && data[len(data)-1] == '"' { + data = data[1 : len(data)-1] + } + ts, err := strconv.ParseInt(string(data), 10, 64) + if err != nil { + return err + } + *t = Unixtime(time.Unix(ts, 0)) + return nil +} |