628 lines
19 KiB
Go
628 lines
19 KiB
Go
package mastodon
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/url"
|
|
"path/filepath"
|
|
"time"
|
|
"encoding/json"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type StatusPleroma struct {
|
|
InReplyToAccountAcct string `json:"in_reply_to_account_acct"`
|
|
Reactions []*ReactionsPleroma `json:"emoji_reactions"`
|
|
Quote *Status `json:"quote"` // Quoted statuses
|
|
}
|
|
|
|
type ReactionsPleroma struct {
|
|
Accounts []Account `json:"accounts"`
|
|
Count int `json:"count"`
|
|
Me bool `json:"me"`
|
|
Name string `json:"name"`
|
|
|
|
// For support akkoma reactions :)
|
|
Url *string `json:"url"`
|
|
}
|
|
|
|
type ReplyInfo struct {
|
|
ID string `json:"id"`
|
|
Number int `json:"number"`
|
|
}
|
|
|
|
type CreatedAt struct {
|
|
time.Time
|
|
}
|
|
|
|
type EditedAt struct{
|
|
time.Time
|
|
}
|
|
|
|
func (t *CreatedAt) UnmarshalJSON(d []byte) error {
|
|
// Special case to handle retweets from GNU Social
|
|
// which returns empty string ("") in created_at
|
|
if len(d) == 2 && string(d) == `""` {
|
|
return nil
|
|
}
|
|
return t.Time.UnmarshalJSON(d)
|
|
}
|
|
|
|
// 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 CreatedAt `json:"created_at"`
|
|
EditedAt *EditedAt `json:"edited_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"`
|
|
Application Application `json:"application"`
|
|
Language string `json:"language"`
|
|
Pinned interface{} `json:"pinned"`
|
|
Bookmarked bool `json:"bookmarked"`
|
|
Poll *Poll `json:"poll"`
|
|
|
|
// Custom fields
|
|
Pleroma StatusPleroma `json:"pleroma"`
|
|
ShowReplies bool `json:"show_replies"`
|
|
IDReplies map[string][]ReplyInfo `json:"id_replies"`
|
|
IDNumbers map[string]int `json:"id_numbers"`
|
|
RetweetedByID string `json:"retweeted_by_id"`
|
|
}
|
|
|
|
type MisskeyStatus struct {
|
|
ID string `json:"id"`
|
|
User AccountMisskey `json:"user"`
|
|
CreatedAt CreatedAt `json:"createdAt"`
|
|
Visibility string `json:"visibility"`
|
|
CW string `json:"cw"`
|
|
URL string `json:"url"`
|
|
Text string `json:"text"`
|
|
Files []Attachment `json:"files"`
|
|
RenoteCount int64 `json:"renoteCount"`
|
|
RepliesCount int64 `json:"repliesCount"`
|
|
Reactions map[string]int `json:"reactions"`
|
|
}
|
|
|
|
type AccountMisskey struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Username string `json:"username"`
|
|
AvatarURL string `json:"avatarUrl"`
|
|
IsBot bool `json:"isBot"`
|
|
}
|
|
|
|
// Context hold information for mastodon context.
|
|
type Context struct {
|
|
Ancestors []*Status `json:"ancestors"`
|
|
Descendants []*Status `json:"descendants"`
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// GetReactionBy returns the reactions list of the user who reacted the toot of id. (Pleroma)
|
|
func (c *Client) GetReactedBy(ctx context.Context, id string) ([]*ReactionsPleroma, error) {
|
|
var reactions []*ReactionsPleroma
|
|
err := c.doAPI(ctx, http.MethodGet, fmt.Sprintf("/api/v1/pleroma/statuses/%s/reactions", id), nil, &reactions, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return reactions, nil
|
|
}
|
|
|
|
// PutReaction is reaction on status with unicode emoji (Pleroma)
|
|
func (c *Client) PutReaction(ctx context.Context, id string, emoji string) (*Status, error) {
|
|
var status Status
|
|
err := c.doAPI(ctx, http.MethodPut, fmt.Sprintf("/api/v1/pleroma/statuses/%s/reactions/%s", id, emoji), nil, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// UnReaction is unreaction on status with unicode emoji (Pleroma)
|
|
func (c *Client) UnReaction(ctx context.Context, id string, emoji string) (*Status, error) {
|
|
var status Status
|
|
err := c.doAPI(ctx, http.MethodDelete, fmt.Sprintf("/api/v1/pleroma/statuses/%s/reactions/%s", id, emoji), nil, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// Reblog is reblog the toot of id and return status of reblog.
|
|
func (c *Client) Reblog(ctx context.Context, id string, visibility string) (*Status, error) {
|
|
var status Status
|
|
params := url.Values{}
|
|
params.Set("visibility", visibility)
|
|
err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/reblog", id), params, &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
|
|
}
|
|
|
|
// TrueRemoteTimeline get public timeline from remote Mastodon API compatible instance directly
|
|
func (c *Client) TrueRemoteTimeline(ctx context.Context, instance string, instance_type string, pg *Pagination) ([]*Status, error) {
|
|
var publicstatuses []*Status
|
|
var instanceParams []string
|
|
instanceParams = strings.Split(instance, ":")[1:]
|
|
instance = strings.Split(instance, ":")[0]
|
|
params := url.Values{}
|
|
params.Set("local", "true")
|
|
|
|
if pg != nil {
|
|
params = pg.setValues(params)
|
|
}
|
|
|
|
perform := url.URL{
|
|
Scheme: "https",
|
|
Host: instance,
|
|
RawQuery: params.Encode(),
|
|
}
|
|
withFiles := "false"
|
|
withReplies := "false"
|
|
for _, instanceParam := range instanceParams {
|
|
switch instanceParam {
|
|
case "withFiles":
|
|
withFiles = "true"
|
|
case "withReplies":
|
|
withReplies = "true"
|
|
default:
|
|
params.Set(instanceParam, "true")
|
|
}
|
|
}
|
|
|
|
var method string
|
|
var ContentType string
|
|
var bytesAttach []byte
|
|
switch instance_type {
|
|
case "misskey":
|
|
perform.Path = "api/notes/local-timeline"
|
|
perform.RawQuery = ""
|
|
method = http.MethodPost
|
|
ContentType = "application/json"
|
|
bytesAttach = []byte(fmt.Sprintf(
|
|
`{"limit":20,"withRenotes":false, "withReplies": %s, "withFiles": %s}`,
|
|
withReplies, withFiles))
|
|
if pg != nil {
|
|
if pg.MaxID != "" {
|
|
bytesAttach = []byte(fmt.Sprintf(
|
|
`{"limit": %s,"withRenotes": false,"untilId":"%s", "withReplies": %s, "withFiles": %s}`,
|
|
strconv.Itoa(int(pg.Limit)), pg.MaxID, withReplies, withFiles))
|
|
}
|
|
}
|
|
default:
|
|
perform.Path = "api/v1/timelines/public"
|
|
method = http.MethodGet
|
|
ContentType = "application/x-www-form-urlencoded"
|
|
bytesAttach = []byte("")
|
|
}
|
|
|
|
req, err := http.NewRequest(method, perform.String(), bytes.NewBuffer(bytesAttach))
|
|
req = req.WithContext(ctx)
|
|
req.Header.Set("Content-Type", ContentType)
|
|
req.Header.Set("User-Agent", "Bloat")
|
|
client := http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, parseAPIError("Can't get remote timeline for " + instance + ", try select another type instance. Error" , resp)
|
|
}
|
|
switch instance_type {
|
|
case "misskey":
|
|
var misskeyData []MisskeyStatus
|
|
err = json.NewDecoder(resp.Body).Decode(&misskeyData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, statusMisskey := range misskeyData {
|
|
var status Status
|
|
status.ID = statusMisskey.ID
|
|
status.Account.ID = statusMisskey.User.ID
|
|
status.Account.DisplayName = statusMisskey.User.Name
|
|
status.Account.Acct = statusMisskey.User.Username
|
|
status.Account.Username = statusMisskey.User.Username
|
|
status.Account.Avatar = statusMisskey.User.AvatarURL
|
|
status.CreatedAt = statusMisskey.CreatedAt
|
|
status.Visibility = statusMisskey.Visibility
|
|
status.Content = strings.Replace(statusMisskey.Text, "\n", "<br>", -1) + "<br><br>"
|
|
for reaction, count := range statusMisskey.Reactions { // woozyface
|
|
if reaction == "❤" {
|
|
status.FavouritesCount = int64(count)
|
|
continue
|
|
}
|
|
status.Content = status.Content + "[" + reaction + strconv.Itoa(count) + "]"
|
|
}
|
|
status.MediaAttachments = statusMisskey.Files
|
|
for idx, attach := range statusMisskey.Files {
|
|
status.MediaAttachments[idx].Type = strings.Split(attach.Type, "/")[0]
|
|
status.MediaAttachments[idx].Description = strings.Replace(attach.Comment, "\n", "<br>", -1)
|
|
status.MediaAttachments[idx].PreviewURL = attach.ThumbnailUrl
|
|
status.MediaAttachments[idx].RemoteURL = attach.URL
|
|
status.MediaAttachments[idx].TextURL = attach.URL
|
|
if status.Sensitive == false {
|
|
if attach.Sensitive { // mark status as NSFW if any attachment marked as NSFW
|
|
status.Sensitive = true
|
|
}
|
|
}
|
|
}
|
|
if statusMisskey.CW != "" {
|
|
status.Sensitive = true
|
|
status.SpoilerText = statusMisskey.CW
|
|
}
|
|
status.RepliesCount = statusMisskey.RepliesCount
|
|
status.ReblogsCount = statusMisskey.RenoteCount
|
|
status.Account.Bot = statusMisskey.User.IsBot
|
|
status.URL = "https://" + instance + "/notes/" + statusMisskey.ID
|
|
publicstatuses = append(publicstatuses, &status)
|
|
}
|
|
default:
|
|
err = json.NewDecoder(resp.Body).Decode(&publicstatuses)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return publicstatuses, nil
|
|
}
|
|
|
|
// GetTimelinePublic return statuses from public timeline.
|
|
func (c *Client) GetTimelinePublic(ctx context.Context, isLocal bool, instance string, pg *Pagination) ([]*Status, error) {
|
|
params := url.Values{}
|
|
if len(instance) > 0 {
|
|
params.Set("instance", instance)
|
|
} else if isLocal {
|
|
params.Set("local", "true")
|
|
}
|
|
|
|
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)
|
|
}
|
|
if toot.ContentType != "" {
|
|
params.Set("content_type", toot.ContentType)
|
|
}
|
|
if toot.Language != "" {
|
|
params.Set("language", toot.Language)
|
|
}
|
|
if toot.ExpiresIn >= 3600 {
|
|
params.Set("expires_in", fmt.Sprint(toot.ExpiresIn))
|
|
}
|
|
if toot.ScheduledAt != "" {
|
|
params.Set("scheduled_at", toot.ScheduledAt)
|
|
}
|
|
if len(toot.Poll.Options) > 2 {
|
|
for _, option := range toot.Poll.Options {
|
|
params.Add("poll[options][]", string(option))
|
|
}
|
|
params.Set("poll[expires_in]", strconv.Itoa(toot.Poll.ExpiresIn))
|
|
if toot.Poll.Multiple {
|
|
params.Set("poll[multiple]", "true")
|
|
}
|
|
if toot.Poll.HideTotals {
|
|
params.Set("poll[hide_totals]", "true")
|
|
}
|
|
|
|
}
|
|
var status Status
|
|
if toot.Edit != "" {
|
|
err := c.doAPI(ctx, http.MethodPut, fmt.Sprintf("/api/v1/statuses/%s", toot.Edit), params, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
err := c.doAPI(ctx, http.MethodPost, "/api/v1/statuses", params, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// Pin pin your status.
|
|
func (c *Client) Pin(ctx context.Context, id string) error {
|
|
return c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/pin", id), nil, nil, nil)
|
|
}
|
|
|
|
// UnPin unpin your status.
|
|
func (c *Client) UnPin(ctx context.Context, id string) error {
|
|
return c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/unpin", id), nil, nil, 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, qType string, limit int, resolve bool, offset int, accountID string, following bool) (*Results, error) {
|
|
var results Results
|
|
params := url.Values{}
|
|
params.Set("q", q)
|
|
params.Set("type", qType)
|
|
params.Set("limit", fmt.Sprint(limit))
|
|
params.Set("resolve", fmt.Sprint(resolve))
|
|
params.Set("offset", fmt.Sprint(offset))
|
|
params.Set("following", fmt.Sprint(following))
|
|
if len(accountID) > 0 {
|
|
params.Set("account_id", accountID)
|
|
}
|
|
err := c.doAPI(ctx, http.MethodGet, "/api/v2/search", params, &results, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &results, nil
|
|
}
|
|
|
|
func (c *Client) UploadMediaFromMultipartFileHeader(ctx context.Context, fh *multipart.FileHeader, descr string) (*Attachment, error) {
|
|
f, err := fh.Open()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
|
|
var buf bytes.Buffer
|
|
mw := multipart.NewWriter(&buf)
|
|
fname := filepath.Base(fh.Filename)
|
|
err = mw.WriteField("description", descr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
part, err := mw.CreateFormFile("file", fname)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_, err = io.Copy(part, f)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = mw.Close()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
params := &multipartRequest{Data: &buf, ContentType: mw.FormDataContentType()}
|
|
var attachment Attachment
|
|
err = c.doAPI(ctx, http.MethodPost, "/api/v1/media", params, &attachment, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &attachment, nil
|
|
}
|
|
|
|
// GetTimelineDirect return statuses from direct timeline.
|
|
func (c *Client) GetTimelineDirect(ctx context.Context, pg *Pagination) ([]*Status, error) {
|
|
params := url.Values{}
|
|
|
|
var statuses []*Status
|
|
err := c.doAPI(ctx, http.MethodGet, "/api/v1/timelines/direct", params, &statuses, pg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return statuses, nil
|
|
}
|
|
|
|
// MuteConversation mutes status specified by id.
|
|
func (c *Client) MuteConversation(ctx context.Context, id string) (*Status, error) {
|
|
var status Status
|
|
|
|
err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/mute", id), nil, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// UnmuteConversation unmutes status specified by id.
|
|
func (c *Client) UnmuteConversation(ctx context.Context, id string) (*Status, error) {
|
|
var status Status
|
|
|
|
err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/unmute", id), nil, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// Bookmark bookmarks status specified by id.
|
|
func (c *Client) Bookmark(ctx context.Context, id string) (*Status, error) {
|
|
var status Status
|
|
|
|
err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/bookmark", id), nil, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// Unbookmark bookmarks status specified by id.
|
|
func (c *Client) Unbookmark(ctx context.Context, id string) (*Status, error) {
|
|
var status Status
|
|
|
|
err := c.doAPI(ctx, http.MethodPost, fmt.Sprintf("/api/v1/statuses/%s/unbookmark", id), nil, &status, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|