stream

package module
v1.5.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 2, 2018 License: GPL-3.0 Imports: 19 Imported by: 0

README

stream-go2

stream-go2 is a Go client for Stream API.

You can sign up for a Stream account at getstream.io/get_started.

Build Status godoc codecov

Usage

Get the client:

$ go get gopkg.in/GetStream/stream-go2.v1

stream-go2 uses dep for managing dependencies (see Gopkg.toml and Gopkg.lock). You can get required dependencies simply by running:

$ dep ensure

Even better: at Stream we have developed vg, a powerful workspace manager for Go based on dep itself. If you use vg (and you should!) you can just:

$ vg init && vg ensure
Creating a Client
key := "YOUR_API_KEY"
secret := "YOUR_API_SECRET"

client, err := stream.NewClient(key, secret)
if err != nil {
    // ...
}

You can pass additional options when creating a client using the available ClientOption functions:

client, err := stream.NewClient(key, secret, 
    stream.WithAPIRegion("us-east"),
    stream.WithAPIVersion("1.0"),
    ...,
)

You can also create a client using environment variables:

client, err := stream.NewClientFromEnv()

Available environment variables:

  • STREAM_API_KEY
  • STREAM_API_SECRET
  • STREAM_API_REGION
  • STREAM_API_VERSION
Creating a Feed

Create a flat feed from slug and user ID:

flat := client.FlatFeed("user", "123")

Create an aggregated feed from slug and user ID:

aggr := client.AggregatedFeed("aggregated", "123")

Create a notification feed from slug and user ID:

notif := client.NotificationFeed("notification", "123")

Flat, aggregated, and notification feeds implement the Feed interface methods.

In the snippets below, feed indicates any kind of feed, while flat, aggregated, and notification are used to indicate that only that kind of feed has certain methods or can perform certain operations.

Retrieving activities
Flat feeds
resp, err := flat.GetActivities()
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
fmt.Println("Next:", resp.Next)
fmt.Println("Activities:")
for _, activity := range resp.Results {
    fmt.Println(activity)
}

You can retrieve flat feeds with custom ranking, using the dedicated method:

resp, err := flat.GetActivitiesWithRanking("popularity")
if err != nil {
    // ...
}
Aggregated feeds
resp, err := aggregated.GetActivities()
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
fmt.Println("Next:", resp.Next)
fmt.Println("Groups:")
for _, group := range resp.Results {
    fmt.Println("Group:", group.Name, "ID:", group.ID, "Verb:", group.Verb)
    fmt.Println("Activities:", group.ActivityCount, "Actors:", group.ActorCount)
    for _, activity := range group.Activities {
        // ...
    }
}
Notification feeds
resp, err := notification.GetActivities()
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
fmt.Println("Next:", resp.Next)
fmt.Println("Unseen:", resp.Unseen, "Unread:", resp.Unread)
fmt.Println("Groups:")
for _, group := range resp.Results {
    fmt.Println("Group:", group.Group, "ID:", group.ID, "Verb:", group.Verb)
    fmt.Println("Seen:", group.IsSeen, "Read:", group.IsRead)
    fmt.Println("Activities:", group.ActivityCount, "Actors:", group.ActorCount)
    for _, activity := range group.Activities {
        // ...
    }
}
Options

You can pass supported options and filters when retrieving activities:

resp, err := flat.GetActivities(
    stream.WithActivitiesIDGTE("f505b3fb-a212-11e7-..."),
    stream.WithActivitiesLimit(5), 
    ...,
)
Adding activities

Add a single activity:

resp, err := feed.AddActivity(stream.Activity{Actor: "bob", ...})
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
fmt.Println("Activity:", resp.Activity) // resp wraps the stream.Activity type

Add multiple activities:

a1 := stream.Activity{Actor: "bob", ...}
a2 := stream.Activity{Actor: "john", ...}
a3 := stream.Activity{Actor: "alice", ...}

resp, err := feed.AddActivities(a1, a2, a3)
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
fmt.Println("Activities:")
for _, activity := range resp.Activities {
    fmt.Println(activity)
}
Updating activities
err := feed.UpdateActivities(a1, a2, ...)
if err != nil {
    // ...
}
Removing activities

You can either remove activities by ID or ForeignID:

err := feed.RemoveActivityByID("f505b3fb-a212-11e7-...")
if err != nil {
    // ...
}

err := feed.RemoveActivityByForeignID("bob:123")
if err != nil {
    // ...
}
Following another feed
err := feed.Follow(anotherFeed)
if err != nil {
    // ...
}

Beware that it's possible to follow only flat feeds.

Options

You can pass options to the Follow method. For example:

err := feed.Follow(anotherFeed, 
    stream.WithFollowFeedActivityCopyLimit(15), 
    ...,
)
Retrieving followers and followings
Following

Get the feeds that a feed is following:

resp, err := feed.GetFollowing()
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
for _, followed := range resp.Results {
    fmt.Println(followed.FeedID, followed.TargetID)
}

You can pass options to GetFollowing:

resp, err := feed.GetFollowing(
    stream.WithFollowingLimit(5),
    ...,
)
Followers
resp, err := flat.GetFollowers()
if err != nil {
    // ...
}

fmt.Println("Duration:", resp.Duration)
for _, follower := range resp.Results {
    fmt.Println(follower.FeedID, follower.TargetID)
}

Note: this is only possible for FlatFeed types.

You can pass options to GetFollowers:

resp, err := feed.GetFollowing(
    stream.WithFollowersLimit(5),
    ...,
)
Unfollowing a feed
err := flat.Unfollow(anotherFeed)
if err != nil {
    // ...
}

You can pass options to Unfollow:

err := flat.Unfollow(anotherFeed,
    stream.WithUnfollowKeepHistory(true),
    ...,
)
Updating an activity's to targets

Remove all old targets and set new ones (replace):

newTargets := []stream.Feed{f1, f2}

err := feed.UpdateToTargets(activity, stream.WithToTargetsNew(newTargets...))
if err != nil {
    // ...
}

Add some targets and remove some others:

add := []stream.Feed{target1, target2}
remove := []stream.Feed{oldTarget1, oldTarget2}

err := feed.UpdateToTargets(
    activity, 
    stream.WithToTargetsAdd(add),
    stream.WithToTargetsRemove(remove),
)
if err != nil {
    // ...
}

Note: you can't mix stream.WithToTargetsNew with stream.WithToTargetsAdd or stream.WithToTargetsRemove.

Batch adding activities

You can add the same activities to multiple feeds at once with the (*Client).AddToMany method (docs):

err := client.AddToMany(activity,
    feed1, feed2, ...,
)
if err != nil {
    // ...
}
Batch creating follows

You can create multiple follow relationships at once with the (*Client).FollowMany method (docs):

relationships := []stream.FollowRelationship{
    stream.NewFollowRelationship(source, target),
    ...,
}

err := client.FollowMany(relationships)
if err != nil {
    // ...
}
Realtime tokens

You can get a token suitable for client-side real-time feed updates as:

// Read+Write token
token := feed.RealtimeToken(false)

// Read-only token
readonlyToken := feed.RealtimeToken(true)

License

stream-go2 is licensed under the GNU General Public License v3.0.

Permissions of this strong copyleft license are conditioned on making available complete source code of licensed works and modifications, which include larger works using a licensed work, under the same license. Copyright and license notices must be preserved. Contributors provide an express grant of patent rights.

See the LICENSE file.

We're hiring!

Would you like to work on cool projects like this?

We are currently hiring for talented Gophers in Amsterdam and Boulder, get in touch with us if you are interested! tommaso@getstream.io

Documentation

Index

Constants

View Source 
const (
	// TimeLayout is the default time parse layout for Stream API JSON time fields
	TimeLayout = "2006-01-02T15:04:05.999999"
)

Variables

View Source 
var (
	// ErrMissingNextPage is returned when trying to read the next page of a response
	// which has an empty "next" field.
	ErrMissingNextPage = fmt.Errorf("request missing next page")
	// ErrInvalidNextPage is returned when trying to read the next page of a response
	// which has an invalid "next" field.
	ErrInvalidNextPage = fmt.Errorf("invalid format for Next field")
)

Functions

This section is empty.

Types

type APIError 

type APIError struct {
	Code            int                      `json:"code,omitempty"`
	Detail          string                   `json:"detail,omitempty"`
	Duration        Duration                 `json:"duration,omitempty"`
	Exception       string                   `json:"exception,omitempty"`
	ExceptionFields map[string][]interface{} `json:"exception_fields,omitempty"`
	StatusCode      int                      `json:"status_code,omitempty"`
}

APIError is an error returned by Stream API when the request cannot be performed or errored server side.

func ToAPIError 

func ToAPIError(err error) (APIError, bool)

ToAPIError tries to cast the provided error to APIError type, returning the obtained APIError and whether the operation was successful.

func (APIError) Error 

func (e APIError) Error() string

type Activity 

type Activity struct {
	ID        string                 `json:"id,omitempty"`
	Actor     string                 `json:"actor,omitempty"`
	Verb      string                 `json:"verb,omitempty"`
	Object    string                 `json:"object,omitempty"`
	ForeignID string                 `json:"foreign_id,omitempty"`
	Target    string                 `json:"target,omitempty"`
	Time      Time                   `json:"time,omitempty"`
	Origin    string                 `json:"origin,omitempty"`
	To        []string               `json:"to,omitempty"`
	Score     float64                `json:"score,omitempty"`
	Extra     map[string]interface{} `json:"-"`
}

Activity is a Stream activity entity.

func (Activity) MarshalJSON 

func (a Activity) MarshalJSON() ([]byte, error)

MarshalJSON encodes the Activity to a valid JSON bytes slice. It's required because of the custom JSON fields and time formats.

func (*Activity) UnmarshalJSON 

func (a *Activity) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes the provided JSON payload into the Activity. It's required because of the custom JSON fields and time formats.

type ActivityGroup 

type ActivityGroup struct {
	Activities    []Activity `json:"activities,omitempty"`
	ActivityCount int        `json:"activity_count,omitempty"`
	ActorCount    int        `json:"actor_count,omitempty"`
	Group         string     `json:"group,omitempty"`
	ID            string     `json:"id,omitempty"`
	Verb          string     `json:"verb,omitempty"`
}

ActivityGroup is a group of Activity obtained from aggregated feeds.

type AddActivitiesResponse 

type AddActivitiesResponse struct {
	Activities []Activity `json:"activities,omitempty"`
	// contains filtered or unexported fields
}

AddActivitiesResponse is the API response obtained when adding activities to a feed.

type AddActivityResponse 

type AddActivityResponse struct {
	Activity
	// contains filtered or unexported fields
}

AddActivityResponse is the API response obtained when adding a single activity to a feed.

type AddToManyRequest 

type AddToManyRequest struct {
	Activity Activity `json:"activity,omitempty"`
	FeedIDs  []string `json:"feeds,omitempty"`
}

AddToManyRequest is the API request body for adding an activity to multiple feeds at once.

type AggregatedFeed 

type AggregatedFeed struct {
	// contains filtered or unexported fields
}

AggregatedFeed is a Stream aggregated feed, which contains activities grouped based on the grouping function defined on the dashboard.

func (*AggregatedFeed) AddActivities 

func (f *AggregatedFeed) AddActivities(activities ...Activity) (*AddActivitiesResponse, error)

AddActivities adds multiple activities to the feed.

func (*AggregatedFeed) AddActivity 

func (f *AggregatedFeed) AddActivity(activity Activity) (*AddActivityResponse, error)

AddActivity adds a new Activity to the feed.

func (*AggregatedFeed) Follow 

func (f *AggregatedFeed) Follow(feed *FlatFeed, opts ...FollowFeedOption) error

Follow follows the provided feed (which must be a FlatFeed), applying the provided FollowFeedOptions, if any.

func (*AggregatedFeed) GetActivities 

func (f *AggregatedFeed) GetActivities(opts ...GetActivitiesOption) (*AggregatedFeedResponse, error)

GetActivities requests and retrieves the activities and groups for the aggregated feed.

func (*AggregatedFeed) GetFollowing 

func (f *AggregatedFeed) GetFollowing(opts ...FollowingOption) (*FollowingResponse, error)

GetFollowing returns the list of the feeds following the feed, applying the provided FollowingOptions, if any.

func (*AggregatedFeed) GetNextPageActivities 

func (f *AggregatedFeed) GetNextPageActivities(resp *AggregatedFeedResponse) (*AggregatedFeedResponse, error)

GetNextPageActivities returns the activities for the given AggregatedFeed at the "next" page of a previous *AggregatedFeedResponse response, if any.

func (*AggregatedFeed) ID 

func (f *AggregatedFeed) ID() string

ID returns the feed ID, as slug:user_id.

func (*AggregatedFeed) RealtimeToken 

func (f *AggregatedFeed) RealtimeToken(readonly bool) string

RealtimeToken returns a token that can be used client-side to listen in real-time to feed changes.

func (*AggregatedFeed) RemoveActivityByForeignID 

func (f *AggregatedFeed) RemoveActivityByForeignID(foreignID string) error

RemoveActivityByID removes an activity from the feed (if present), using the provided foreignID string argument as the foreign_id field of the activity.

func (*AggregatedFeed) RemoveActivityByID 

func (f *AggregatedFeed) RemoveActivityByID(id string) error

RemoveActivityByID removes an activity from the feed (if present), using the provided id string argument as the ID field of the activity.

func (*AggregatedFeed) Slug 

func (f *AggregatedFeed) Slug() string

Slug returns the feed's slug.

func (*AggregatedFeed) Unfollow 

func (f *AggregatedFeed) Unfollow(target Feed, opts ...UnfollowOption) error

Unfollow unfollows the provided feed, applying the provided UnfollowOptions, if any.

func (*AggregatedFeed) UpdateActivities 

func (f *AggregatedFeed) UpdateActivities(activities ...Activity) error

UpdateActivities updates existing activities in the feed.

func (*AggregatedFeed) UpdateToTargets 

func (f *AggregatedFeed) UpdateToTargets(activity Activity, opts ...UpdateToTargetsOption) error

UpdateToTargets updates the "to" targets for the provided activity, with the options passed as argument for replacing, adding, or removing to targets.

func (*AggregatedFeed) UserID 

func (f *AggregatedFeed) UserID() string

UserID returns the feed's user_id.

type AggregatedFeedResponse 

type AggregatedFeedResponse struct {
	Results []ActivityGroup `json:"results,omitempty"`
	// contains filtered or unexported fields
}

AggregatedFeedResponse is the API response obtained when retrieving activities from an aggregated feed.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client is a Stream API client used for retrieving feeds and performing API calls.

func NewClient 

func NewClient(key, secret string, opts ...ClientOption) (*Client, error)

NewClient builds a new Client with the provided API key and secret. It can be configured further by passing any number of ClientOption parameters.

func NewClientFromEnv 

func NewClientFromEnv() (*Client, error)

NewClientFromEnv build a new Client using environment variables values, with possible values being STREAM_API_KEY, STREAM_API_SECRET, STREAM_API_REGION, and STREAM_API_VERSION.

func (*Client) AddToMany 

func (c *Client) AddToMany(activity Activity, feeds ...Feed) error

AddToMany adds an activity to multiple feeds at once.

func (*Client) AggregatedFeed 

func (c *Client) AggregatedFeed(slug, userID string) *AggregatedFeed

AggregatedFeed returns a new Aggregated Feed with the provided slug and userID.

func (*Client) FlatFeed 

func (c *Client) FlatFeed(slug, userID string) *FlatFeed

FlatFeed returns a new Flat Feed with the provided slug and userID.

func (*Client) FollowMany 

func (c *Client) FollowMany(relationships []FollowRelationship, opts ...FollowManyOption) error

FollowMany creates multiple follows at once.

func (*Client) NotificationFeed 

func (c *Client) NotificationFeed(slug, userID string) *NotificationFeed

NotificationFeed returns a new Notification Feed with the provided slug and userID.

type ClientOption 

type ClientOption func(*Client)

ClientOption is a function used for adding specific configuration options to a Stream client.

func WithAPIRegion 

func WithAPIRegion(region string) ClientOption

WithAPIRegion sets the region for a given Client.

func WithAPIVersion 

func WithAPIVersion(version string) ClientOption

WithAPIVersion sets the version for a given Client.

func WithHTTPRequester 

func WithHTTPRequester(requester Requester) ClientOption

WithHTTPRequester sets the HTTP requester for a given client, used mostly for testing.

type Duration 

type Duration struct {
	time.Duration
}

Duration wraps time.Duration, used because of JSON marshaling and unmarshaling.

func (Duration) MarshalJSON 

func (d Duration) MarshalJSON() ([]byte, error)

MarshalJSON marshals the Duration to a string like "30s".

func (*Duration) UnmarshalJSON 

func (d *Duration) UnmarshalJSON(b []byte) error

UnmarshalJSON for Duration is required because of the incoming duration string.

type Feed 

type Feed interface {
	ID() string
	Slug() string
	UserID() string
	AddActivity(Activity) (*AddActivityResponse, error)
	AddActivities(...Activity) (*AddActivitiesResponse, error)
	UpdateActivities(...Activity) error
	RemoveActivityByID(string) error
	RemoveActivityByForeignID(string) error
	Follow(*FlatFeed, ...FollowFeedOption) error
	GetFollowing(...FollowingOption) (*FollowingResponse, error)
	Unfollow(Feed, ...UnfollowOption) error
	UpdateToTargets(Activity, ...UpdateToTargetsOption) error
	RealtimeToken(bool) string
}

Feed is a generic Stream feed, exporting the generic functions common to any Stream feed.

type FlatFeed 

type FlatFeed struct {
	// contains filtered or unexported fields
}

FlatFeed is a Stream flat feed.

func (*FlatFeed) AddActivities 

func (f *FlatFeed) AddActivities(activities ...Activity) (*AddActivitiesResponse, error)

AddActivities adds multiple activities to the feed.

func (*FlatFeed) AddActivity 

func (f *FlatFeed) AddActivity(activity Activity) (*AddActivityResponse, error)

AddActivity adds a new Activity to the feed.

func (*FlatFeed) Follow 

func (f *FlatFeed) Follow(feed *FlatFeed, opts ...FollowFeedOption) error

Follow follows the provided feed (which must be a FlatFeed), applying the provided FollowFeedOptions, if any.

func (*FlatFeed) GetActivities 

func (f *FlatFeed) GetActivities(opts ...GetActivitiesOption) (*FlatFeedResponse, error)

GetActivities returns the activities for the given FlatFeed, filtering results with the provided GetActivitiesOption parameters.

func (*FlatFeed) GetActivitiesWithRanking 

func (f *FlatFeed) GetActivitiesWithRanking(ranking string, opts ...GetActivitiesOption) (*FlatFeedResponse, error)

GetActivitiesWithRanking returns the activities (filtered) for the given FlatFeed, using the provided ranking method.

func (*FlatFeed) GetFollowers 

func (f *FlatFeed) GetFollowers(opts ...FollowersOption) (*FollowersResponse, error)

GetFollowers returns the feeds following the given FlatFeed.

func (*FlatFeed) GetFollowing 

func (f *FlatFeed) GetFollowing(opts ...FollowingOption) (*FollowingResponse, error)

GetFollowing returns the list of the feeds following the feed, applying the provided FollowingOptions, if any.

func (*FlatFeed) GetNextPageActivities 

func (f *FlatFeed) GetNextPageActivities(resp *FlatFeedResponse) (*FlatFeedResponse, error)

GetNextPageActivities returns the activities for the given FlatFeed at the "next" page of a previous *FlatFeedResponse response, if any.

func (*FlatFeed) ID 

func (f *FlatFeed) ID() string

ID returns the feed ID, as slug:user_id.

func (*FlatFeed) RealtimeToken 

func (f *FlatFeed) RealtimeToken(readonly bool) string

RealtimeToken returns a token that can be used client-side to listen in real-time to feed changes.

func (*FlatFeed) RemoveActivityByForeignID 

func (f *FlatFeed) RemoveActivityByForeignID(foreignID string) error

RemoveActivityByID removes an activity from the feed (if present), using the provided foreignID string argument as the foreign_id field of the activity.

func (*FlatFeed) RemoveActivityByID 

func (f *FlatFeed) RemoveActivityByID(id string) error

RemoveActivityByID removes an activity from the feed (if present), using the provided id string argument as the ID field of the activity.

func (*FlatFeed) Slug 

func (f *FlatFeed) Slug() string

Slug returns the feed's slug.

func (*FlatFeed) Unfollow 

func (f *FlatFeed) Unfollow(target Feed, opts ...UnfollowOption) error

Unfollow unfollows the provided feed, applying the provided UnfollowOptions, if any.

func (*FlatFeed) UpdateActivities 

func (f *FlatFeed) UpdateActivities(activities ...Activity) error

UpdateActivities updates existing activities in the feed.

func (*FlatFeed) UpdateToTargets 

func (f *FlatFeed) UpdateToTargets(activity Activity, opts ...UpdateToTargetsOption) error

UpdateToTargets updates the "to" targets for the provided activity, with the options passed as argument for replacing, adding, or removing to targets.

func (*FlatFeed) UserID 

func (f *FlatFeed) UserID() string

UserID returns the feed's user_id.

type FlatFeedResponse 

type FlatFeedResponse struct {
	Results []Activity `json:"results,omitempty"`
	// contains filtered or unexported fields
}

FlatFeedResponse is the API response obtained when retrieving activities from a flat feed.

type FollowFeedOption 

type FollowFeedOption func(*followFeedOptions)

FollowFeedOption is a function used to customize FollowFeed API calls.

func WithFollowFeedActivityCopyLimit 

func WithFollowFeedActivityCopyLimit(activityCopyLimit int) FollowFeedOption

WithFollowFeedActivityCopyLimit sets the activity copy threshold for Follow Feed API calls.

type FollowManyOption 

type FollowManyOption struct {
	// contains filtered or unexported fields
}

FollowManyOption is an option to customize behavior of Follow Many calls.

func WithFollowManyActivityCopyLimit 

func WithFollowManyActivityCopyLimit(activityCopyLimit int) FollowManyOption

WithFollowManyActivityCopyLimit sets how many activities should be copied from the target feed.

type FollowRelationship 

type FollowRelationship struct {
	Source            string `json:"source,omitempty"`
	Target            string `json:"target,omitempty"`
	ActivityCopyLimit *int   `json:"activity_copy_limit,omitempty"`
}

FollowRelationship represents a follow relationship between a source ("follower") and a target ("following"), used for FollowMany requests.

func NewFollowRelationship 

func NewFollowRelationship(source, target Feed, opts ...FollowRelationshipOption) FollowRelationship

NewFollowRelationship is a helper for creating a FollowRelationship from the source ("follower") and target ("following") feeds.

type FollowRelationshipOption 

type FollowRelationshipOption func(r *FollowRelationship)

FollowRelationshipOption customizes a FollowRelationship.

func WithFollowRelationshipActivityCopyLimit 

func WithFollowRelationshipActivityCopyLimit(activityCopyLimit int) FollowRelationshipOption

WithFollowRelationshipActivityCopyLimit sets the ActivityCopyLimit field for a given FollowRelationship.

type Follower 

type Follower struct {
	FeedID   string `json:"feed_id,omitempty"`
	TargetID string `json:"target_id,omitempty"`
}

Follower is the representation of a feed following another feed.

type FollowersOption 

type FollowersOption struct {
	// contains filtered or unexported fields
}

FollowersOption is an option usable by followers feed methods.

func WithFollowersLimit 

func WithFollowersLimit(limit int) FollowersOption

WithFollowersLimit limits the number of followers in the response to the provided limit.

func WithFollowersOffset 

func WithFollowersOffset(offset int) FollowersOption

WithFollowersOffset returns followers starting from the given offset.

type FollowersResponse 

type FollowersResponse struct {
	// contains filtered or unexported fields
}

FollowersResponse is the API response obtained when retrieving followers from a feed.

type FollowingOption 

type FollowingOption struct {
	// contains filtered or unexported fields
}

FollowingOption is an option usable by following feed methods.

func WithFollowingFilter 

func WithFollowingFilter(ids ...string) FollowingOption

WithFollowingFilter adds the filter parameter to API calls, used when retrieving following feeds, allowing the check whether certain feeds are being followed.

func WithFollowingLimit 

func WithFollowingLimit(limit int) FollowingOption

WithFollowingLimit limits the number of followings in the response to the provided limit.

func WithFollowingOffset 

func WithFollowingOffset(offset int) FollowingOption

WithFollowingOffset returns followings starting from the given offset.

type FollowingResponse 

type FollowingResponse struct {
	// contains filtered or unexported fields
}

FollowingResponse is the API response obtained when retrieving following feeds from a feed.

type GetActivitiesOption 

type GetActivitiesOption struct {
	// contains filtered or unexported fields
}

GetActivitiesOption is an option usable by GetActivities methods for flat and aggregated feeds.

func WithActivitiesIDGT 

func WithActivitiesIDGT(id string) GetActivitiesOption

WithActivitiesIDGT adds the id_gt parameter to API calls, used when retrieving paginated activities from feeds, returning activities with ID greater than the provided id.

func WithActivitiesIDGTE 

func WithActivitiesIDGTE(id string) GetActivitiesOption

WithActivitiesIDGTE adds the id_gte parameter to API calls, used when retrieving paginated activities from feeds, returning activities with ID greater or equal than the provided id.

func WithActivitiesIDLT 

func WithActivitiesIDLT(id string) GetActivitiesOption

WithActivitiesIDLT adds the id_lt parameter to API calls, used when retrieving paginated activities from feeds, returning activities with ID lesser than the provided id.

func WithActivitiesIDLTE 

func WithActivitiesIDLTE(id string) GetActivitiesOption

WithActivitiesIDLTE adds the id_lte parameter to API calls, used when retrieving paginated activities from feeds, returning activities with ID lesser or equal than the provided id.

func WithActivitiesLimit 

func WithActivitiesLimit(limit int) GetActivitiesOption

WithActivitiesLimit adds the limit parameter to API calls which support it, limiting the number of results in the response to the provided limit threshold. Supported operations: retrieve activities, retrieve followers, retrieve following.

func WithActivitiesOffset 

func WithActivitiesOffset(offset int) GetActivitiesOption

WithActivitiesOffset adds the offset parameter to API calls which support it, getting results starting from the provided offset index. Supported operations: retrieve activities, retrieve followers, retrieve following.

func WithCustomParam 

func WithCustomParam(name, value string) GetActivitiesOption

WithCustomParam adds a custom parameter to the read request.

func WithNotificationsMarkRead 

func WithNotificationsMarkRead(all bool, activityIDs ...string) GetActivitiesOption

WithNotificationsMarkRead marks as read the given activity ids in a notification feed. If the all parameter is true, every activity in the feed is marked as read.

func WithNotificationsMarkSeen 

func WithNotificationsMarkSeen(all bool, activityIDs ...string) GetActivitiesOption

WithNotificationsMarkSeen marks as seen the given activity ids in a notification feed. If the all parameter is true, every activity in the feed is marked as seen.

type NotificationFeed 

type NotificationFeed struct {
	// contains filtered or unexported fields
}

NotificationFeed is a Stream notification feed.

func (*NotificationFeed) AddActivities 

func (f *NotificationFeed) AddActivities(activities ...Activity) (*AddActivitiesResponse, error)

AddActivities adds multiple activities to the feed.

func (*NotificationFeed) AddActivity 

func (f *NotificationFeed) AddActivity(activity Activity) (*AddActivityResponse, error)

AddActivity adds a new Activity to the feed.

func (*NotificationFeed) Follow 

func (f *NotificationFeed) Follow(feed *FlatFeed, opts ...FollowFeedOption) error

Follow follows the provided feed (which must be a FlatFeed), applying the provided FollowFeedOptions, if any.

func (*NotificationFeed) GetActivities 

func (f *NotificationFeed) GetActivities(opts ...GetActivitiesOption) (*NotificationFeedResponse, error)

GetActivities returns the activities for the given NotificationFeed, filtering results with the provided GetActivitiesOption parameters.

func (*NotificationFeed) GetFollowing 

func (f *NotificationFeed) GetFollowing(opts ...FollowingOption) (*FollowingResponse, error)

GetFollowing returns the list of the feeds following the feed, applying the provided FollowingOptions, if any.

func (*NotificationFeed) GetNextPageActivities 

func (f *NotificationFeed) GetNextPageActivities(resp *NotificationFeedResponse) (*NotificationFeedResponse, error)

GetNextPageActivities returns the activities for the given NotificationFeed at the "next" page of a previous *NotificationFeedResponse response, if any.

func (*NotificationFeed) ID 

func (f *NotificationFeed) ID() string

ID returns the feed ID, as slug:user_id.

func (*NotificationFeed) RealtimeToken 

func (f *NotificationFeed) RealtimeToken(readonly bool) string

RealtimeToken returns a token that can be used client-side to listen in real-time to feed changes.

func (*NotificationFeed) RemoveActivityByForeignID 

func (f *NotificationFeed) RemoveActivityByForeignID(foreignID string) error

RemoveActivityByID removes an activity from the feed (if present), using the provided foreignID string argument as the foreign_id field of the activity.

func (*NotificationFeed) RemoveActivityByID 

func (f *NotificationFeed) RemoveActivityByID(id string) error

RemoveActivityByID removes an activity from the feed (if present), using the provided id string argument as the ID field of the activity.

func (*NotificationFeed) Slug 

func (f *NotificationFeed) Slug() string

Slug returns the feed's slug.

func (*NotificationFeed) Unfollow 

func (f *NotificationFeed) Unfollow(target Feed, opts ...UnfollowOption) error

Unfollow unfollows the provided feed, applying the provided UnfollowOptions, if any.

func (*NotificationFeed) UpdateActivities 

func (f *NotificationFeed) UpdateActivities(activities ...Activity) error

UpdateActivities updates existing activities in the feed.

func (*NotificationFeed) UpdateToTargets 

func (f *NotificationFeed) UpdateToTargets(activity Activity, opts ...UpdateToTargetsOption) error

UpdateToTargets updates the "to" targets for the provided activity, with the options passed as argument for replacing, adding, or removing to targets.

func (*NotificationFeed) UserID 

func (f *NotificationFeed) UserID() string

UserID returns the feed's user_id.

type NotificationFeedResponse 

type NotificationFeedResponse struct {
	Unseen  int                      `json:"unseen"`
	Unread  int                      `json:"unread"`
	Results []NotificationFeedResult `json:"results"`
	// contains filtered or unexported fields
}

NotificationFeedResponse is the API response obtained when retrieving activities from a notification feed.

type NotificationFeedResult 

type NotificationFeedResult struct {
	ID            string     `json:"id"`
	Activities    []Activity `json:"activities"`
	ActivityCount int        `json:"activity_count"`
	ActorCount    int        `json:"actor_count"`
	Group         string     `json:"group"`
	IsRead        bool       `json:"is_read"`
	IsSeen        bool       `json:"is_seen"`
	Verb          string     `json:"verb"`
}

NotificationFeedResult is a notification-feed specific response, containing the list of activities in the group, plus the extra fields about the group read+seen status.

type Requester 

type Requester interface {
	Do(*http.Request) (*http.Response, error)
}

Requester performs HTTP requests.

type Time 

type Time struct {
	time.Time
}

Time wraps time.Time, used because of custom API time format in JSON marshaling and unmarshaling.

func (Time) MarshalJSON 

func (t Time) MarshalJSON() ([]byte, error)

MarshalJSON marshals Time into a string formatted with the TimeLayout format.

func (*Time) UnmarshalJSON 

func (t *Time) UnmarshalJSON(b []byte) error

UnmarshalJSON for Time is required because of the incoming time string format.

type UnfollowOption 

type UnfollowOption struct {
	// contains filtered or unexported fields
}

UnfollowOption is an option usable with the Unfollow feed method.

func WithUnfollowKeepHistory 

func WithUnfollowKeepHistory(keepHistory bool) UnfollowOption

WithUnfollowKeepHistory adds the keep_history parameter to API calls, used to keep history when unfollowing feeds, rather than purging it (default behavior). If the keepHistory parameter is false, nothing happens.

type UpdateToTargetsOption 

type UpdateToTargetsOption func(*updateToTargetsRequest)

UpdateToTargetsOption determines what operations perform during an UpdateToTargets API call.

func WithToTargetsAdd 

func WithToTargetsAdd(targets ...string) UpdateToTargetsOption

WithToTargetsAdd sets the add to targets, adding them to the activity's existing ones.

func WithToTargetsNew 

func WithToTargetsNew(targets ...string) UpdateToTargetsOption

WithToTargetsNew sets the new to targets, replacing all the existing ones. It cannot be used in combination with any other UpdateToTargetsOption.

func WithToTargetsRemove 

func WithToTargetsRemove(targets ...string) UpdateToTargetsOption

WithToTargetsRemove sets the remove to targets, removing them from activity's the existing ones.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.