golang/mikael/madon: comparison account.go

equal deleted inserted replaced

-:acaea3179f4d
+:23d3a518d0ad
 Copyright 2017 Mikael Berthe
 Licensed under the MIT license.  Please see the LICENSE file is this directory.
 */
-package gondole
+package madon
 import (
 	"fmt"
 	"strconv"
 // getSingleAccount returns an account entity
 // The operation 'op' can be "account", "verify_credentials", "follow",
 // "unfollow", "block", "unblock", "mute", "unmute",
 // "follow_requests/authorize" or // "follow_requests/reject".
 // The id is optional and depends on the operation.
-func (g *Client) getSingleAccount(op string, id int) (*Account, error) {
+func (mc *Client) getSingleAccount(op string, id int) (*Account, error) {
 	var endPoint string
 	method := rest.Get
 	strID := strconv.Itoa(id)
 	switch op {
 	default:
 		return nil, ErrInvalidParameter
 	}
 	var account Account
-	if err := g.apiCall(endPoint, method, nil, &account); err != nil {
+	if err := mc.apiCall(endPoint, method, nil, &account); err != nil {
 		return nil, err
 	}
 	return &account, nil
 }
 // getMultipleAccounts returns a list of account entities
 // The operation 'op' can be "followers", "following", "search", "blocks",
 // "mutes", "follow_requests".
 // The id is optional and depends on the operation.
-func (g *Client) getMultipleAccounts(op string, opts *getAccountsOptions) ([]Account, error) {
+func (mc *Client) getMultipleAccounts(op string, opts *getAccountsOptions) ([]Account, error) {
 	var endPoint string
 	switch op {
 	case "followers", "following":
 		if opts == nil || opts.ID < 1 {
 			params["limit"] = strconv.Itoa(opts.Limit)
 		}
 	}
 	var accounts []Account
-	if err := g.apiCall(endPoint, rest.Get, params, &accounts); err != nil {
+	if err := mc.apiCall(endPoint, rest.Get, params, &accounts); err != nil {
 		return nil, err
 	}
 	return accounts, nil
 }
 // GetAccount returns an account entity
 // The returned value can be nil if there is an error or if the
 // requested ID does not exist.
-func (g *Client) GetAccount(accountID int) (*Account, error) {
+func (mc *Client) GetAccount(accountID int) (*Account, error) {
-	account, err := g.getSingleAccount("account", accountID)
+	account, err := mc.getSingleAccount("account", accountID)
 	if err != nil {
 		return nil, err
 	}
 	if account != nil && account.ID == 0 {
 		return nil, ErrEntityNotFound
 	}
 	return account, nil
 }
 // GetCurrentAccount returns the current user account
-func (g *Client) GetCurrentAccount() (*Account, error) {
+func (mc *Client) GetCurrentAccount() (*Account, error) {
-	account, err := g.getSingleAccount("verify_credentials", 0)
+	account, err := mc.getSingleAccount("verify_credentials", 0)
 	if err != nil {
 		return nil, err
 	}
 	if account != nil && account.ID == 0 {
 		return nil, ErrEntityNotFound
 	}
 	return account, nil
 }
 // GetAccountFollowers returns the list of accounts following a given account
-func (g *Client) GetAccountFollowers(accountID int) ([]Account, error) {
+func (mc *Client) GetAccountFollowers(accountID int) ([]Account, error) {
 	o := &getAccountsOptions{ID: accountID}
-	return g.getMultipleAccounts("followers", o)
+	return mc.getMultipleAccounts("followers", o)
 }
 // GetAccountFollowing returns the list of accounts a given account is following
-func (g *Client) GetAccountFollowing(accountID int) ([]Account, error) {
+func (mc *Client) GetAccountFollowing(accountID int) ([]Account, error) {
 	o := &getAccountsOptions{ID: accountID}
-	return g.getMultipleAccounts("following", o)
+	return mc.getMultipleAccounts("following", o)
 }
 // FollowAccount follows an account
-func (g *Client) FollowAccount(accountID int) error {
+func (mc *Client) FollowAccount(accountID int) error {
-	account, err := g.getSingleAccount("follow", accountID)
+	account, err := mc.getSingleAccount("follow", accountID)
 	if err != nil {
 		return err
 	}
 	if account != nil && account.ID != accountID {
 		return ErrEntityNotFound
 	}
 	return nil
 }
 // UnfollowAccount unfollows an account
-func (g *Client) UnfollowAccount(accountID int) error {
+func (mc *Client) UnfollowAccount(accountID int) error {
-	account, err := g.getSingleAccount("unfollow", accountID)
+	account, err := mc.getSingleAccount("unfollow", accountID)
 	if err != nil {
 		return err
 	}
 	if account != nil && account.ID != accountID {
 		return ErrEntityNotFound
 	}
 	return nil
 }
 // FollowRemoteAccount follows a remote account
-// The parameter 'uri' is a URI (e.g. "username@domain").
+// The parameter 'uri' is a URI (e.mc. "username@domain").
-func (g *Client) FollowRemoteAccount(uri string) (*Account, error) {
+func (mc *Client) FollowRemoteAccount(uri string) (*Account, error) {
 	if uri == "" {
 		return nil, ErrInvalidID
 	}
 	params := make(apiCallParams)
 	params["uri"] = uri
 	var account Account
-	if err := g.apiCall("follows", rest.Post, params, &account); err != nil {
+	if err := mc.apiCall("follows", rest.Post, params, &account); err != nil {
 		return nil, err
 	}
 	if account.ID == 0 {
 		return nil, ErrEntityNotFound
 	}
 	return &account, nil
 }
 // BlockAccount blocks an account
-func (g *Client) BlockAccount(accountID int) error {
+func (mc *Client) BlockAccount(accountID int) error {
-	account, err := g.getSingleAccount("block", accountID)
+	account, err := mc.getSingleAccount("block", accountID)
 	if err != nil {
 		return err
 	}
 	if account != nil && account.ID != accountID {
 		return ErrEntityNotFound
 	}
 	return nil
 }
 // UnblockAccount unblocks an account
-func (g *Client) UnblockAccount(accountID int) error {
+func (mc *Client) UnblockAccount(accountID int) error {
-	account, err := g.getSingleAccount("unblock", accountID)
+	account, err := mc.getSingleAccount("unblock", accountID)
 	if err != nil {
 		return err
 	}
 	if account != nil && account.ID != accountID {
 		return ErrEntityNotFound
 	}
 	return nil
 }
 // MuteAccount mutes an account
-func (g *Client) MuteAccount(accountID int) error {
+func (mc *Client) MuteAccount(accountID int) error {
-	account, err := g.getSingleAccount("mute", accountID)
+	account, err := mc.getSingleAccount("mute", accountID)
 	if err != nil {
 		return err
 	}
 	if account != nil && account.ID != accountID {
 		return ErrEntityNotFound
 	}
 	return nil
 }
 // UnmuteAccount unmutes an account
-func (g *Client) UnmuteAccount(accountID int) error {
+func (mc *Client) UnmuteAccount(accountID int) error {
-	account, err := g.getSingleAccount("unmute", accountID)
+	account, err := mc.getSingleAccount("unmute", accountID)
 	if err != nil {
 		return err
 	}
 	if account != nil && account.ID != accountID {
 		return ErrEntityNotFound
 	return nil
 }
 // SearchAccounts returns a list of accounts matching the query string
 // The limit parameter is optional (can be 0).
-func (g *Client) SearchAccounts(query string, limit int) ([]Account, error) {
+func (mc *Client) SearchAccounts(query string, limit int) ([]Account, error) {
 	o := &getAccountsOptions{Q: query, Limit: limit}
-	return g.getMultipleAccounts("search", o)
+	return mc.getMultipleAccounts("search", o)
 }
 // GetBlockedAccounts returns the list of blocked accounts
-func (g *Client) GetBlockedAccounts() ([]Account, error) {
+func (mc *Client) GetBlockedAccounts() ([]Account, error) {
-	return g.getMultipleAccounts("blocks", nil)
+	return mc.getMultipleAccounts("blocks", nil)
 }
 // GetMutedAccounts returns the list of muted accounts
-func (g *Client) GetMutedAccounts() ([]Account, error) {
+func (mc *Client) GetMutedAccounts() ([]Account, error) {
-	return g.getMultipleAccounts("mutes", nil)
+	return mc.getMultipleAccounts("mutes", nil)
 }
 // GetAccountFollowRequests returns the list of follow requests accounts
-func (g *Client) GetAccountFollowRequests() ([]Account, error) {
+func (mc *Client) GetAccountFollowRequests() ([]Account, error) {
-	return g.getMultipleAccounts("follow_requests", nil)
+	return mc.getMultipleAccounts("follow_requests", nil)
 }
 // GetAccountRelationships returns a list of relationship entities for the given accounts
-func (g *Client) GetAccountRelationships(accountIDs []int) ([]Relationship, error) {
+func (mc *Client) GetAccountRelationships(accountIDs []int) ([]Relationship, error) {
 	if len(accountIDs) < 1 {
 		return nil, ErrInvalidID
 	}
 	params := make(apiCallParams)
 		qID := fmt.Sprintf("id[%d]", i+1)
 		params[qID] = strconv.Itoa(id)
 	}
 	var rl []Relationship
-	if err := g.apiCall("accounts/relationships", rest.Get, params, &rl); err != nil {
+	if err := mc.apiCall("accounts/relationships", rest.Get, params, &rl); err != nil {
 		return nil, err
 	}
 	return rl, nil
 }
 // GetAccountStatuses returns a list of status entities for the given account
 // If onlyMedia is true, returns only statuses that have media attachments.
 // If excludeReplies is true, skip statuses that reply to other statuses.
-func (g *Client) GetAccountStatuses(accountID int, onlyMedia, excludeReplies bool) ([]Status, error) {
+func (mc *Client) GetAccountStatuses(accountID int, onlyMedia, excludeReplies bool) ([]Status, error) {
 	if accountID < 1 {
 		return nil, ErrInvalidID
 	}
 	endPoint := "accounts/" + strconv.Itoa(accountID) + "/" + "statuses"
 	if excludeReplies {
 		params["exclude_replies"] = "true"
 	}
 	var sl []Status
-	if err := g.apiCall(endPoint, rest.Get, params, &sl); err != nil {
+	if err := mc.apiCall(endPoint, rest.Get, params, &sl); err != nil {
 		return nil, err
 	}
 	return sl, nil
 }
 // FollowRequestAuthorize authorizes or rejects an account follow-request
-func (g *Client) FollowRequestAuthorize(accountID int, authorize bool) error {
+func (mc *Client) FollowRequestAuthorize(accountID int, authorize bool) error {
 	endPoint := "follow_requests/reject"
 	if authorize {
 		endPoint = "follow_requests/authorize"
 	}
-	_, err := g.getSingleAccount(endPoint, accountID)
+	_, err := mc.getSingleAccount(endPoint, accountID)
 	return err
 }

changeset 138	23d3a518d0ad
parent 134	588edbc9e14b
child 143	9ce9b39c851c