stream

package module
v1.14.0 Latest Latest
Warning

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

 Go to latest Published: Nov 16, 2018 License: GPL-3.0 Imports: 19 Imported by: 16

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 Go Report Card

Contents

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)

Analytics

If your app is enabled for analytics collection you can use the Go client to track events. The main documentation for the analytics features is available in our Docs page.

Obtaining an Analytics client

You can obtain a specialized Analytics client (*stream.AnalyticsClient) from a regular client, which you can use to track events:

// Create the client
analytics := client.Analytics()
Tracking engagement

Engagement events can be tracked with the TrackEngagement method of AnalyticsClient. It accepts any number of EngagementEvents.

Events' syntax is not checked by the client, so be sure to follow our documentation about it.

Events are simple maps, but the stream package offers handy helpers to populate such events easily.

// Create the event
event := stream.EngagementEvent{}.
    WithLabel("click").
    WithForeignID("event:1234").
    WithUserData(stream.NewUserData().String("john")).
    WithFeatures(
        stream.NewEventFeature("color", "blue"),
        stream.NewEventFeature("shape", "rectangle"),
    ).
    WithLocation("homepage")

// Track the event(s)
err := analytics.TrackEngagement(event)
if err != nil {
    // ...
}
Tracking impressions

Impression events can be tracked with the TrackImpression method of AnalyticsClient (syntax docs):

// Create the impression events
imp := stream.ImpressionEventData{}.
    WithForeignIDs("product:1", "product:2", "product:3").
    WithUserData(stream.NewUserData().String("john")).
    WithLocation("storepage")

// Track the events
err := analytics.TrackImpression(imp)
if err != nil {
    // ...
}
Email tracking

You can generate URLs to track events and redirect to a specific URL with the RedirectAndTrack method of AnalyticsClient (syntax docs). It accepts any number of engagement and impression events:

// Create the events
engagement := stream.EngagementEvent{}.
    WithLabel("click").
    WithForeignID("event:1234").
    WithUserData(stream.NewUserData().String("john")).
    WithFeatures(
        stream.NewEventFeature("color", "blue"),
        stream.NewEventFeature("shape", "rectangle"),
    ).
    WithLocation("homepage")

impressions := stream.ImpressionEventData{}.
    WithForeignIDs("product:1", "product:2", "product:3").
    WithUserData(stream.NewUserData().String("john")).
    WithLocation("storepage")

// Generate the tracking and redirect URL, which once followed
// will redirect the user to the targetURL.
targetURL := "https://google.com"
url, err := analytics.RedirectAndTrack(targetURL, engagement, impression)
if err != nil {
    // ...
}

// Display the obtained url where needed.

Personalization

Personalization endpoints for enabled apps can be reached using a PersonalizationClient, a specialized client obtained with the Personalization() function of a regular Client.

personalization := client.Personalization()

The PersonalizationClient exposes three functions that you can use to retrieve and manipulate data: Get, Post, and Delete.

For example, to retrieve follow recommendations:

// Get follow recommendations
data := map[string]interface{}{
    "user_id":          123,
    "source_feed_slug": "timeline",
    "target_feed_slug": "user",
}
resp, err = personalization.Get("follow_recommendations", data)
if err != nil {
    // ...
}
fmt.Println(resp)

See the complete docs and examples about personalization features on Stream's documentation pages.

Collections

Collections endpoints for enabled apps can be reached using a specialized CollectionsClient which, like PersonalizationClient, can be obtained from a regular Client:

collections := client.Collections()

CollectionsClient exposes three functions, Upsert, Get, and Delete:

// Upsert the "user" collection
object := stream.CollectionObject{
    ID:   "123",
    Name: "johndoe",
    Data: map[string]interface{}{
        "favorite_color": "blue",
    },
}
err = collections.Upsert("user", object)
if err != nil {
    // ...
}

// Get the data from the "user" collection for ID "123" and "456"
objects, err := collections.Get("user", "123", "456")
if err != nil {
    // ...
}

// Delete the data from the "user" collection for user with ID "123"
err = collections.Delete("user", "123")
if err != nil {
    // ...
}

See the complete docs and examples about collections on Stream's documentation pages.

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")
)
View Source 
var Version = "v1.9.1"

Version is the current release version for this client

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
}

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) 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 AnalyticsClient added in v1.6.0 

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

AnalyticsClient is a specialized client used to send and track analytics events for enabled apps.

func (*AnalyticsClient) RedirectAndTrack added in v1.6.0 

func (c *AnalyticsClient) RedirectAndTrack(url string, events ...map[string]interface{}) (string, error)

RedirectAndTrack is used to send and track analytics ImpressionEvents. It tracks the events data (either EngagementEvents or ImpressionEvents) and redirects to the provided URL string.

func (*AnalyticsClient) TrackEngagement added in v1.6.0 

func (c *AnalyticsClient) TrackEngagement(events ...EngagementEvent) error

TrackEngagement is used to send and track analytics EngagementEvents.

func (*AnalyticsClient) TrackImpression added in v1.6.0 

func (c *AnalyticsClient) TrackImpression(eventsData ImpressionEventsData) error

TrackImpression is used to send and track analytics ImpressionEvents.

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) Analytics added in v1.6.0 

func (c *Client) Analytics() *AnalyticsClient

Analytics returns a new AnalyticsClient sharing the base configuration of the original Client.

func (*Client) Collections added in v1.7.0 

func (c *Client) Collections() *CollectionsClient

Collections returns a new CollectionsClient.

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) GetActivitiesByForeignID added in v1.9.0 

func (c *Client) GetActivitiesByForeignID(values ...ForeignIDTimePair) (*GetActivitiesResponse, error)

GetActivitiesByForeignID returns activities for the current app having the given foreign IDs and timestamps.

func (*Client) GetActivitiesByID added in v1.9.0 

func (c *Client) GetActivitiesByID(ids ...string) (*GetActivitiesResponse, error)

GetActivitiesByID returns activities for the current app having the given IDs.

func (*Client) GetUserSessionToken added in v1.13.0 

func (c *Client) GetUserSessionToken(userID string) (string, error)

func (*Client) GetUserSessionTokenWithClaims added in v1.13.0 

func (c *Client) GetUserSessionTokenWithClaims(userID string, claims map[string]interface{}) (string, error)

func (*Client) NotificationFeed 

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

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

func (*Client) Personalization added in v1.7.0 

func (c *Client) Personalization() *PersonalizationClient

Personalization returns a new PersonalizationClient.

func (*Client) UnfollowMany added in v1.8.0 

func (c *Client) UnfollowMany(relationships []UnfollowRelationship) error

UnfollowMany removes multiple follow relationships at once.

func (*Client) UpdateActivities added in v1.11.0 

func (c *Client) UpdateActivities(activities ...Activity) error

UpdateActivities updates existing activities.

func (*Client) UpdateActivityByForeignID added in v1.9.1 

func (c *Client) UpdateActivityByForeignID(foreignID string, timestamp Time, set map[string]interface{}, unset []string) (*UpdateActivityResponse, error)

UpdateActivityByForeignID performs a partial activity update with the given set and unset operations, returning the affected activity, on the activity with the given foreign ID and timestamp.

func (*Client) UpdateActivityByID added in v1.9.1 

func (c *Client) UpdateActivityByID(id string, set map[string]interface{}, unset []string) (*UpdateActivityResponse, error)

UpdateActivityByID performs a partial activity update with the given set and unset operations, returning the affected activity, on the activity with the given ID.

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 CollectionObject added in v1.7.0 

type CollectionObject struct {
	ID   string
	Data map[string]interface{}
}

CollectionObject is a collection's object.

func (CollectionObject) MarshalJSON added in v1.7.0 

func (o CollectionObject) MarshalJSON() ([]byte, error)

MarshalJSON marshals the CollectionObject to a flat JSON object.

type CollectionsClient added in v1.7.0 

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

CollectionsClient is a specialized client used to interact with the Collection endpoints.

func (*CollectionsClient) CreateReference added in v1.12.0 

func (c *CollectionsClient) CreateReference(collection, id string) string

CreateReference returns a new reference string in the form SO:<collection>:<id>.

func (*CollectionsClient) CreateUserReference added in v1.12.0 

func (c *CollectionsClient) CreateUserReference(id string) string

CreateUserReference is a shorthand for CreateReference, returning a new reference string in the form SO:user:<id>.

func (*CollectionsClient) Delete added in v1.7.0 

func (c *CollectionsClient) Delete(collection string, ids ...string) error

Delete removes from a collection the objects having the given IDs.

func (*CollectionsClient) Get added in v1.7.0 

func (c *CollectionsClient) Get(collection string, ids ...string) ([]GetCollectionResponseObject, error)

Get returns a list of CollectionObjects for the given collection name having the given IDs.

func (*CollectionsClient) Upsert added in v1.7.0 

func (c *CollectionsClient) Upsert(collection string, objects ...CollectionObject) error

Upsert creates new or updates existing objects for the given collection's name.

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 EngagementEvent added in v1.6.0 

type EngagementEvent map[string]interface{}

EngagementEvent represent an analytics engagement event. It must be populated with the available methods, or custom data can be arbitrarily added to it manually as key(string),value(interface{}) pairs.

func (EngagementEvent) WithBoost added in v1.6.0 

func (e EngagementEvent) WithBoost(boost int) EngagementEvent

WithBoost sets the event's boost field to the given int.

func (EngagementEvent) WithContent added in v1.6.0 

func (e EngagementEvent) WithContent(foreignID string, content map[string]interface{}) EngagementEvent

WithContent sets the event's content field to the given content map, and also sets the foreign_id field of such object to the given foreign ID string. If just the foreign ID is required to be sent, use the WithForeignID method.

func (EngagementEvent) WithFeatures added in v1.6.0 

func (e EngagementEvent) WithFeatures(features ...EventFeature) EngagementEvent

WithFeatures sets the event's features field to the given list of EventFeatures.

func (EngagementEvent) WithFeedID added in v1.6.0 

func (e EngagementEvent) WithFeedID(feedID string) EngagementEvent

WithFeedID sets the event's feed_id field to the given string.

func (EngagementEvent) WithForeignID added in v1.6.0 

func (e EngagementEvent) WithForeignID(foreignID string) EngagementEvent

WithForeignID sets the event's content field to the given foreign ID. If the content payload must be an object, use the WithContent method.

func (EngagementEvent) WithLabel added in v1.6.0 

func (e EngagementEvent) WithLabel(label string) EngagementEvent

WithLabel sets the event's label field to the given string.

func (EngagementEvent) WithLocation added in v1.6.0 

func (e EngagementEvent) WithLocation(location string) EngagementEvent

WithLocation sets the event's location field to the given string.

func (EngagementEvent) WithPosition added in v1.6.0 

func (e EngagementEvent) WithPosition(position int) EngagementEvent

WithPosition sets the event's position field to the given int.

func (EngagementEvent) WithTrackedAt added in v1.6.0 

func (e EngagementEvent) WithTrackedAt(trackedAt time.Time) EngagementEvent

WithTrackedAt sets the event's tracked_at field to the given time.Time.

func (EngagementEvent) WithUserData added in v1.6.0 

func (e EngagementEvent) WithUserData(userData *UserData) EngagementEvent

WithUserData sets the event's user_data field to the given UserData's value.

type EventFeature added in v1.6.0 

type EventFeature struct {
	Group string `json:"group"`
	Value string `json:"value"`
}

EventFeature is a single analytics event feature, a pair of group and value strings.

func NewEventFeature added in v1.6.0 

func NewEventFeature(group, value string) EventFeature

NewEventFeature returns a new EventFeature from the given group and value params.

type Feed 

type Feed interface {
	ID() string
	Slug() string
	UserID() string
	AddActivity(Activity) (*AddActivityResponse, error)
	AddActivities(...Activity) (*AddActivitiesResponse, 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) 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 ForeignIDTimePair added in v1.9.0 

type ForeignIDTimePair struct {
	ForeignID string
	Timestamp Time
}

ForeignIDTimePair couples an activity's foreignID and timestamp.

func NewForeignIDTimePair added in v1.9.0 

func NewForeignIDTimePair(foreignID string, timestamp Time) ForeignIDTimePair

NewForeignIDTimePair creates a new ForeignIDTimePair with the given foreign ID and timestamp.

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 GetActivitiesResponse added in v1.9.0 

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

GetActivitiesResponse contains a slice of Activity returned by GetActivitiesByID and GetActivitiesByForeignID requests.

type GetCollectionResponseObject added in v1.10.0 

type GetCollectionResponseObject struct {
	ForeignID string                 `json:"foreign_id"`
	Data      map[string]interface{} `json:"data"`
}

GetCollectionResponseObject represent a single response coming from a Collection Get request after a CollectionsClient.Get call.

type ImpressionEventsData added in v1.6.0 

type ImpressionEventsData map[string]interface{}

ImpressionEventsData represents the payload of an arbitrary number of impression events. It must be populated with the available methods, or custom data can be arbitrarily added to it manually as key(string),value(interface{}) pairs.

func (ImpressionEventsData) AddForeignIDs added in v1.6.0 

func (d ImpressionEventsData) AddForeignIDs(foreignIDs ...string) ImpressionEventsData

AddForeignIDs adds the given foreign ID strings to the content_list field, creating it if it doesn't exist.

func (ImpressionEventsData) WithFeatures added in v1.6.0 

func (d ImpressionEventsData) WithFeatures(features ...EventFeature) ImpressionEventsData

WithFeatures sets the features field to the given list of EventFeatures.

func (ImpressionEventsData) WithFeedID added in v1.6.0 

func (d ImpressionEventsData) WithFeedID(feedID string) ImpressionEventsData

WithFeedID sets the feed_id field to the given string.

func (ImpressionEventsData) WithForeignIDs added in v1.6.0 

func (d ImpressionEventsData) WithForeignIDs(foreignIDs ...string) ImpressionEventsData

WithForeignIDs sets the content_list field to the given list of strings.

func (ImpressionEventsData) WithLocation added in v1.6.0 

func (d ImpressionEventsData) WithLocation(location string) ImpressionEventsData

WithLocation sets the location field to the given string.

func (ImpressionEventsData) WithPosition added in v1.6.0 

func (d ImpressionEventsData) WithPosition(position int) ImpressionEventsData

WithPosition sets the position field to the given int.

func (ImpressionEventsData) WithTrackedAt added in v1.6.0 

func (d ImpressionEventsData) WithTrackedAt(trackedAt time.Time) ImpressionEventsData

WithTrackedAt sets the tracked_at field to the given time.Time.

func (ImpressionEventsData) WithUserData added in v1.6.0 

func (d ImpressionEventsData) WithUserData(userData *UserData) ImpressionEventsData

WithUserData sets the user_data field to the given UserData value.

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) 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 PersonalizationClient added in v1.7.0 

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

PersonalizationClient is a specialized client for personalization features.

func (*PersonalizationClient) Delete added in v1.7.0 

func (c *PersonalizationClient) Delete(resource string, params map[string]interface{}) error

Delete removes data from the given resource, adding the given params to the request.

func (*PersonalizationClient) Get added in v1.7.0 

func (c *PersonalizationClient) Get(resource string, params map[string]interface{}) (*PersonalizationResponse, error)

Get obtains a PersonalizationResponse for the given resource and params.

func (*PersonalizationClient) Post added in v1.7.0 

func (c *PersonalizationClient) Post(resource string, params map[string]interface{}, data map[string]interface{}) error

Post sends data to the given resource, adding the given params to the request.

type PersonalizationResponse added in v1.7.0 

type PersonalizationResponse struct {
	AppID    int                      `json:"app_id"`
	Duration Duration                 `json:"duration"`
	Limit    int                      `json:"limit"`
	Offset   int                      `json:"offset"`
	Version  string                   `json:"version"`
	Results  []map[string]interface{} `json:"results"`
	// contains filtered or unexported fields
}

PersonalizationResponse is a generic response from the personalization endpoints obtained after a PersonalizationClient.Get call. Common JSON fields are directly available as struct fields, while non-standard JSON fields can be retrieved using the Extra() method.

func (*PersonalizationResponse) Extra added in v1.7.0 

func (r *PersonalizationResponse) Extra() map[string]interface{}

Extra returns the non-common response fields as a map[string]interface{}.

func (*PersonalizationResponse) UnmarshalJSON added in v1.7.0 

func (r *PersonalizationResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON for PersonalizationResponse is required because of the incoming duration string, and for storing non-standard fields without losing their values, so they can be retrieved later on with the Extra() function.

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 UnfollowRelationship added in v1.8.0 

type UnfollowRelationship struct {
	Source      string `json:"source"`
	Target      string `json:"target"`
	KeepHistory bool   `json:"keep_history"`
}

UnfollowRelationship represents a single follow relationship to remove, used for UnfollowMany requests.

type UpdateActivityResponse added in v1.9.1 

type UpdateActivityResponse struct {
	Activity
}

UpdateActivityResponse is the response returned by the UpdateActivityByID and UpdateActivityByForeignID methods.

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.

type UserData added in v1.6.0 

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

UserData represents an analytics event user data field, which can either be a single string/integer representing the user's ID, or a dictionary made of an ID (string or integer) and a string alias. For example NewUserData().Int(123).Alias("john") will result in a dictionary like {"user_data":{"id": 123, "alias": "john"}}, while NewUserData().String("bob") will result in {"user_data": "bob"}.

func NewUserData added in v1.6.0 

func NewUserData() *UserData

NewUserData initializes an empty UserData type, which must be populated using the String, Int, and/or Alias methods.

func (*UserData) Alias added in v1.6.0 

func (d *UserData) Alias(alias string) *UserData

Alias sets the alias as the given string.

func (*UserData) Int added in v1.6.0 

func (d *UserData) Int(id int) *UserData

Int sets the ID as the given integer.

func (*UserData) String added in v1.6.0 

func (d *UserData) String(id string) *UserData

String sets the ID as the given string.

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.