intercom

package module
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Mar 8, 2016 License: Apache-2.0 Imports: 6 Imported by: 0

README

Intercom-Go

Build Status

Thin client for the Intercom API.

It modified to use own http.Client to make REST request.

Currently in beta, though breaking API changes are not expected.

Install

go get gopkg.in/snakehopper/intercom-go.v1

Usage

Getting a Client

The first step to using Intercom's Go client is to create a client object, using your App ID and Api Key from your settings.

import (
	`gopkg.in/snakehopper/intercom-go.v1`
)

ic := intercom.NewClient(nil, "appID", "apiKey") //replace nil to your http.Client if needed, ex:GAE environment

This client can then be used to make requests.

Client Options

The client can be configured with different options by calls to ic.Option:

ic.Option(intercom.TraceHTTP(true)) // turn http tracing on
ic.Option(intercom.BaseURI("http://intercom.dev")) // change the base uri used, useful for testing
ic.Option(intercom.SetHTTPClient(myHTTPClient)) // set a new HTTP client, see below for more info

or combined:

ic.Option(intercom.TraceHTTP(true), intercom.BaseURI("http://intercom.dev"))
Users
Save
user := intercom.User{
	UserID: "27",
	Email: "test@example.com",
	Name: "InterGopher",
	SignedUpAt: int32(time.Now().Unix()),
	CustomAttributes: map[string]interface{}{"is_cool": true},
}
savedUser, err := ic.Users.Save(&user)
  • One of UserID, or Email is required.
  • SignedUpAt (optional), like all dates in the client, must be an integer(32) representing seconds since Unix Epoch.
Adding/Removing Companies

Adding a Company:

companyList := intercom.CompanyList{
	Companies: []intercom.Company{
		{ID: "5"},
	},
}
user := intercom.User{
	UserID: "27",
	Companies: &companyList,
}

Removing is similar, but adding a Remove: intercom.Bool(true) attribute to a company.

Find
user, err := ic.Users.FindByID("46adad3f09126dca")

user, err := ic.Users.FindByUserID("27")

user, err := ic.Users.FindByEmail("test@example.com")
List
userList, err := ic.Users.List(intercom.PageParams{Page: 2})
userList.Pages // page information
userList.Users // []User

userList, err := ic.Users.ListBySegment("segmentID123", intercom.PageParams{})

userList, err := ic.Users.ListByTag("42", intercom.PageParams{})
Delete
user, err := ic.Users.Delete("46adad3f09126dca")
Contacts
Find
contact, err := ic.Contacts.FindByID("46adad3f09126dca")

contact, err := ic.Contacts.FindByUserID("27")
List
contactList, err := ic.Contacts.List(intercom.PageParams{Page: 2})
contactList.Pages // page information
contactList.Contacts // []Contact

contactList, err := ic.Contacts.ListByEmail("test@example.com", intercom.PageParams{})
Create
contact := intercom.Contact{
	Email: "test@example.com",
	Name: "SomeContact",
	CustomAttributes: map[string]interface{}{"is_cool": true},
}
savedContact, err := ic.Contacts.Create(&contact)
  • No identifier is required.
  • Set values for UserID will be ignored (consider creating Users instead)
Update
contact := intercom.Contact{
	UserID: "abc-13d-3",
	Name: "SomeContact",
	CustomAttributes: map[string]interface{}{"is_cool": true},
}
savedContact, err := ic.Contacts.Update(&contact)
  • ID or UserID is required.
  • Will not create new contacts.
Convert

Used to convert a Contact into a User

contact := intercom.Contact{
	UserID: "abc-13d-3",
}
user := intercom.User{
	Email: "myuser@signedup.com",
}
savedUser, err := ic.Contacts.Convert(&contact, &user)
  • If the User does not already exist in Intercom, the Contact will be uplifted to a User.
  • If the User does exist, the Contact will be merged into it and the User returned.
Companies
Save
company := intercom.Company{
	CompanyID: "27",
	Name: "My Co",
	CustomAttributes: map[string]interface{}{"is_cool": true},
	Plan: &intercom.Plan{Name: "MyPlan"},
}
savedCompany, err := ic.Companies.Save(&company)
  • CompanyID is required.
Find
company, err := ic.Companies.FindByID("46adad3f09126dca")

company, err := ic.Companies.FindByCompanyID("27")

company, err := ic.Companies.FindByName("My Co")
List
companyList, err := ic.Companies.List(intercom.PageParams{Page: 2})
companyList.Pages // page information
companyList.Companies // []Companies

companyList, err := ic.Companies.ListBySegment("segmentID123", intercom.PageParams{})

companyList, err := ic.Companies.ListByTag("42", intercom.PageParams{})
Events
Save
event := intercom.Event{
	UserID: "27",
	EventName: "bought_item",
	CreatedAt: int32(time.Now().Unix()),
	Metadata: map[string]interface{}{"item_name": "PocketWatch"},
}
err := ic.Events.Save(&event)
  • One of UserID, or Email is required.
  • EventName is required.
  • CreatedAt is optional, must be an integer representing seconds since Unix Epoch. Will be set to now unless given.
  • Metadata is optional, and can be constructed using the helper as above, or as a passed map[string]interface{}.
Admins
List
adminList, err := ic.Admins.List()
admins := adminList.Admins
Tags
List
tagList, err := ic.Tags.List()
tags := tagList.Tags
Save
tag := intercom.Tag{Name: "GoTag"}
savedTag, err := ic.Tags.Save(&tag)

Name is required. Passing an ID will attempt to update the tag with that ID.

Delete
err := ic.Tags.Delete("6")
Tagging Users/Companies
taggingList := intercom.TaggingList{Name: "GoTag", Users: []intercom.Tagging{{UserID: "27"}}}
savedTag, err := ic.Tags.Tag(&taggingList)

A Tagging can identify a User or Company, and can be set to Untag:

taggingList := intercom.TaggingList{Name: "GoTag", Users: []intercom.Tagging{{UserID: "27", Untag: intercom.Bool(true)}}}
savedTag, err := ic.Tags.Tag(&taggingList)
Segments
List
segmentList := ic.Segments.List()
segments := segmentList.Segments
Find
segment := ic.Segments.Find("abc312daf2397")
Messages
New Admin to User/Contact Email
msg := intercom.NewEmailMessage(intercom.PERSONAL_TEMPLATE, intercom.Admin{ID: "1234"}, intercom.User{Email: "test@example.com"}, "subject", "body")
savedMessage, err := ic.Messages.Save(&msg)

Can use intercom.PLAIN_TEMPLATE too, or replace the intercom.User with an intercom.Contact.

New Admin to User/Contact InApp
msg := intercom.NewInAppMessage(intercom.Admin{ID: "1234"}, intercom.Contact{Email: "test@example.com"}, "body")
savedMessage, err := ic.Messages.Save(&msg)
New User Message
msg := intercom.NewUserMessage(intercom.User{Email: "test@example.com"}, "body")
savedMessage, err := ic.Messages.Save(&msg)
Conversations
Find Conversation
convo, err := intercom.Conversations.Find("1234")
List Conversations
All
convoList, err := intercom.Conversations.ListAll(intercom.PageParams{})
By User

Showing all for user:

convoList, err := intercom.Conversations.ListByUser(&user, intercom.SHOW_ALL, intercom.PageParams{})

Showing just Unread for user:

convoList, err := intercom.Conversations.ListByUser(&user, intercom.SHOW_UNREAD, intercom.PageParams{})
By Admin

Showing all for admin:

convoList, err := intercom.Conversations.ListByAdmin(&admin, intercom.SHOW_ALL, intercom.PageParams{})

Showing just Open for admin:

convoList, err := intercom.Conversations.ListByAdmin(&admin, intercom.SHOW_OPEN, intercom.PageParams{})

Showing just Closed for admin:

convoList, err := intercom.Conversations.ListByAdmin(&admin, intercom.SHOW_CLOSED, intercom.PageParams{})
Reply

User reply:

convo, err := intercom.Conversations.Reply("1234", &user, intercom.CONVERSATION_COMMENT, "my message")

User reply with attachment:

convo, err := intercom.Conversations.ReplyWithAttachmentURLs("1234", &user, intercom.CONVERSATION_COMMENT, "my message", string[]{"http://www.example.com/attachment.jpg"})

User reply that opens:

convo, err := intercom.Conversations.Reply("1234", &user, intercom.CONVERSATION_OPEN, "my message")

Admin reply:

convo, err := intercom.Conversations.Reply("1234", &admin, intercom.CONVERSATION_COMMENT, "my message")

Admin note:

convo, err := intercom.Conversations.Reply("1234", &admin, intercom.CONVERSATION_NOTE, "my message to just admins")
Open and Close

Open:

convo, err := intercom.Conversations.Open("1234", &openerAdmin)

Close:

convo, err := intercom.Conversations.Close("1234", &closerAdmin)
Assign
convo, err := intercom.Conversations.Assign("1234", &assignerAdmin, &assigneeAdmin)
Errors

Errors may be returned from some calls. Errors returned from the API will implement intercom.IntercomError and can be checked:

_, err := ic.Users.FindByEmail("doesnotexist@intercom.io")
if herr, ok := err.(intercom.IntercomError); ok && herr.GetCode() == "not_found" {
	fmt.Print(herr)
}
HTTP Client

The HTTP Client used by this package can be swapped out for one of your choosing, with your own configuration, it just needs to implement the HTTPClient interface:

type HTTPClient interface {
	Get(string, interface{}) ([]byte, error)
	Post(string, interface{}) ([]byte, error)
	Patch(string, interface{}) ([]byte, error)
	Delete(string, interface{}) ([]byte, error)
}

It'll probably need to work with appId, apiKey and baseURI values. See the provided client for an example. Then create an Intercom Client and inject the HTTPClient:

ic := intercom.Client{}
ic.Option(intercom.SetHTTPClient(myHTTPClient))
// ready to go!
On Bools

Due to the way Go represents the zero value for a bool, it's necessary to pass pointers to bool instead in some places.

The helper intercom.Bool(true) creates these for you.

Documentation

Overview

Package intercom-go provides a thin client for the Intercom API: http://doc.intercom.io/api/.

The first step to using Intercom's Go client is to create a client object, using your App ID and Api Key from your [settings](http://app.intercom.io/apps/api_keys). 

import (
  "github.com/intercom/intercom-go"
)
ic := intercom.NewClient("appID", "apiKey")

The client can be configured with different options by calls to Option: 

ic.Option(intercom.TraceHTTP(true)) // turn http tracing on
ic.Option(intercom.BaseURI("http://intercom.dev")) // change the base uri used, useful for testing
ic.Option(intercom.SetHTTPClient(myHTTPClient)) // set a new HTTP client

Errors

Errors may be returned from some calls. Errors returned from the API will implement `intercom.IntercomError` and can be checked: 

_, err := ic.Users.FindByEmail("doesnotexist@intercom.io")
if herr, ok := err.(intercom.IntercomError); ok && herr.GetCode() == "not_found" {
  fmt.Print(herr)
}

HTTP Client

The HTTP Client used by this package can be swapped out for one of your choosing, with your own configuration, it just needs to implement the HTTPClient interface: 

type HTTPClient interface {
  Get(string, interface{}) ([]byte, error)
  Post(string, interface{}) ([]byte, error)
  Delete(string, interface{}) ([]byte, error)
}

The client will probably need to work with `appId`, `apiKey` and `baseURI` values. See the provided client for an example. Then create an Intercom Client and inject the HTTPClient: 

ic := intercom.Client{}
ic.Option(intercom.SetHTTPClient(myHTTPClient))
// ready to go!

On Bools

Due to the way Go represents the zero value for a bool, it's necessary to pass pointers to bool instead in some places. The helper `intercom.Bool(true)` creates these for you.

Pagination

For many resources, pagination should be applied through the use of a PageParams object passed into List() functions. 

pageParams := PageParams{
  Page: 2,
  PerPage: 10,
}
ic.Users.List(pageParams)

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BaseURI 

func BaseURI(baseURI string) option

BaseURI sets a base URI for the HTTP Client to use. Defaults to "https://api.intercom.io". Typically this would be used during testing to point to a stubbed service.

func Bool 

func Bool(value bool) *bool

Bool is a helper method to create *bool. *bool is preferred to bool because it allows distinction between false and absence.

func SetHTTPClient 

func SetHTTPClient(httpClient interfaces.HTTPClient) option

SetHTTPClient sets a HTTPClient for the Intercom Client to use. Useful for customising timeout behaviour etc.

func TraceHTTP 

func TraceHTTP(trace bool) option

TraceHTTP turns on HTTP request/response tracing for debugging.

Types

type Admin 

type Admin struct {
	ID    json.Number `json:"id"`
	Type  string      `json:"type"`
	Name  string      `json:"name"`
	Email string      `json:"email"`
}

Admin represents an Admin in Intercom.

func (Admin) IsNobodyAdmin 

func (a Admin) IsNobodyAdmin() bool

IsNobodyAdmin is a helper function to determine if the Admin is 'Nobody'.

func (Admin) MessageAddress added in v1.0.1 

func (a Admin) MessageAddress() MessageAddress

Get the address for a Contact in order to message them

func (Admin) String 

func (a Admin) String() string

type AdminAPI 

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

AdminAPI implements AdminRepository

type AdminList 

type AdminList struct {
	Admins []Admin
}

AdminList represents an object holding list of Admins

type AdminRepository 

type AdminRepository interface {
	// contains filtered or unexported methods
}

AdminRepository defines the interface for working with Admins through the API.

type AdminService 

type AdminService struct {
	Repository AdminRepository
}

AdminService handles interactions with the API through an AdminRepository.

func (*AdminService) List 

func (c *AdminService) List() (AdminList, error)

List lists the Admins associated with your App.

type Client 

type Client struct {
	// Services for interacting with various resources in Intercom.
	Admins        AdminService
	Companies     CompanyService
	Contacts      ContactService
	Conversations ConversationService
	Events        EventService
	Messages      MessageService
	Segments      SegmentService
	Tags          TagService
	Users         UserService

	// Mappings for resources to API constructs
	AdminRepository        AdminRepository
	CompanyRepository      CompanyRepository
	ContactRepository      ContactRepository
	ConversationRepository ConversationRepository
	EventRepository        EventRepository
	MessageRepository      MessageRepository
	SegmentRepository      SegmentRepository
	TagRepository          TagRepository
	UserRepository         UserRepository

	// AppID For Intercom.
	AppID string

	// APIKey for Intercom's API. See http://app.intercom.io/apps/api_keys.
	APIKey string

	// HTTP Client used to interact with the API.
	HTTPClient interfaces.HTTPClient
	// contains filtered or unexported fields
}

A Client manages interacting with the Intercom API.

func NewClient 

func NewClient(tc *http.Client, appID, apiKey string) *Client

NewClient returns a new Intercom API client, configured with the default HTTPClient if tc==nil.

func (*Client) Option 

func (c *Client) Option(opts ...option) (previous option)

Set Options on the Intercom Client, see TraceHTTP, BaseURI and SetHTTPClient.

type Company 

type Company struct {
	ID               string                 `json:"id,omitempty"`
	CompanyID        string                 `json:"company_id,omitempty"`
	Name             string                 `json:"name,omitempty"`
	RemoteCreatedAt  int32                  `json:"remote_created_at,omitempty"`
	LastRequestAt    int32                  `json:"last_request_at,omitempty"`
	CreatedAt        int32                  `json:"created_at,omitempty"`
	UpdatedAt        int32                  `json:"updated_at,omitempty"`
	SessionCount     int32                  `json:"session_count,omitempty"`
	MonthlySpend     int32                  `json:"monthly_spend,omitempty"`
	UserCount        int32                  `json:"user_count,omitempty"`
	Tags             *TagList               `json:"tags,omitempty"`
	Segments         *SegmentList           `json:"segments,omitempty"`
	Plan             *Plan                  `json:"plan,omitempty"`
	CustomAttributes map[string]interface{} `json:"custom_attributes,omitempty"`
	Remove           *bool                  `json:"-"`
}

Company represents a Company in Intercom Not all of the fields are writeable to the API, non-writeable fields are stripped out from the request. Please see the API documentation for details.

func (Company) String 

func (c Company) String() string

type CompanyAPI 

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

CompanyAPI implements CompanyRepository

type CompanyIdentifiers 

type CompanyIdentifiers struct {
	ID        string `url:"-"`
	CompanyID string `url:"company_id,omitempty"`
	Name      string `url:"name,omitempty"`
}

CompanyIdentifiers to identify a Company using the API

type CompanyList 

type CompanyList struct {
	Pages     PageParams
	Companies []Company
}

CompanyList holds a list of Companies and paging information

type CompanyRepository 

type CompanyRepository interface {
	// contains filtered or unexported methods
}

CompanyRepository defines the interface for working with Companies through the API.

type CompanyService 

type CompanyService struct {
	Repository CompanyRepository
}

CompanyService handles interactions with the API through a CompanyRepository.

func (*CompanyService) FindByCompanyID 

func (c *CompanyService) FindByCompanyID(companyID string) (Company, error)

FindByCompanyID finds a Company using their CompanyID CompanyID is a customer-defined field

func (*CompanyService) FindByID 

func (c *CompanyService) FindByID(id string) (Company, error)

FindByID finds a Company using their Intercom ID

func (*CompanyService) FindByName 

func (c *CompanyService) FindByName(name string) (Company, error)

FindByName finds a Company using their Name

func (*CompanyService) List 

func (c *CompanyService) List(params PageParams) (CompanyList, error)

List Companies

func (*CompanyService) ListBySegment 

func (c *CompanyService) ListBySegment(segmentID string, params PageParams) (CompanyList, error)

List Companies by Segment

func (*CompanyService) ListByTag 

func (c *CompanyService) ListByTag(tagID string, params PageParams) (CompanyList, error)

List Companies by Tag

func (*CompanyService) Save 

func (c *CompanyService) Save(user *Company) (Company, error)

Save a new Company, or update an existing one.

type Contact 

type Contact struct {
	ID                     string                 `json:"id,omitempty"`
	Email                  string                 `json:"email,omitempty"`
	UserID                 string                 `json:"user_id,omitempty"`
	Name                   string                 `json:"name,omitempty"`
	Avatar                 *UserAvatar            `json:"avatar,omitempty"`
	LocationData           *LocationData          `json:"location_data,omitempty"`
	LastRequestAt          int32                  `json:"last_request_at,omitempty"`
	CreatedAt              int32                  `json:"created_at,omitempty"`
	UpdatedAt              int32                  `json:"updated_at,omitempty"`
	SessionCount           int32                  `json:"session_count,omitempty"`
	LastSeenIP             string                 `json:"last_seen_ip,omitempty"`
	SocialProfiles         *SocialProfileList     `json:"social_profiles,omitempty"`
	UnsubscribedFromEmails *bool                  `json:"unsubscribed_from_emails,omitempty"`
	UserAgentData          string                 `json:"user_agent_data,omitempty"`
	Tags                   *TagList               `json:"tags,omitempty"`
	Segments               *SegmentList           `json:"segments,omitempty"`
	Companies              *CompanyList           `json:"companies,omitempty"`
	CustomAttributes       map[string]interface{} `json:"custom_attributes,omitempty"`
	UpdateLastRequestAt    *bool                  `json:"update_last_request_at,omitempty"`
	NewSession             *bool                  `json:"new_session,omitempty"`
}

Contact represents a Contact within Intercom. Not all of the fields are writeable to the API, non-writeable fields are stripped out from the request. Please see the API documentation for details.

func (Contact) MessageAddress added in v1.0.1 

func (c Contact) MessageAddress() MessageAddress

Get the address for a Contact in order to message them

func (Contact) String 

func (c Contact) String() string

type ContactAPI 

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

ContactAPI implements ContactRepository

type ContactList 

type ContactList struct {
	Pages    PageParams
	Contacts []Contact
}

ContactList holds a list of Contacts and paging information

type ContactRepository 

type ContactRepository interface {
	// contains filtered or unexported methods
}

ContactRepository defines the interface for working with Contacts through the API.

type ContactService 

type ContactService struct {
	Repository ContactRepository
}

ContactService handles interactions with the API through a ContactRepository.

func (*ContactService) Convert 

func (c *ContactService) Convert(contact *Contact, user *User) (User, error)

Convert Contact to User

func (*ContactService) Create 

func (c *ContactService) Create(contact *Contact) (Contact, error)

Create Contact

func (*ContactService) Delete 

func (c *ContactService) Delete(contact *Contact) (Contact, error)

Delete Contact

func (*ContactService) FindByID 

func (c *ContactService) FindByID(id string) (Contact, error)

FindByID looks up a Contact by their Intercom ID.

func (*ContactService) FindByUserID 

func (c *ContactService) FindByUserID(userID string) (Contact, error)

FindByUserID looks up a Contact by their UserID (automatically generated server side).

func (*ContactService) List 

func (c *ContactService) List(params PageParams) (ContactList, error)

List all Contacts for App.

func (*ContactService) ListByEmail 

func (c *ContactService) ListByEmail(email string, params PageParams) (ContactList, error)

ListByEmail looks up a list of Contacts by their Email.

func (*ContactService) ListBySegment 

func (c *ContactService) ListBySegment(segmentID string, params PageParams) (ContactList, error)

List Contacts by Segment.

func (*ContactService) ListByTag 

func (c *ContactService) ListByTag(tagID string, params PageParams) (ContactList, error)

List Contacts By Tag.

func (*ContactService) Update 

func (c *ContactService) Update(contact *Contact) (Contact, error)

Update Contact

type Conversation added in v1.0.1 

type Conversation struct {
	ID                  string               `json:"id"`
	CreatedAt           int32                `json:"created_at"`
	UpdatedAt           int32                `json:"updated_at"`
	User                User                 `json:"user"`
	Assignee            Admin                `json:"assignee"`
	Open                bool                 `json:"open"`
	Read                bool                 `json:"read"`
	ConversationMessage ConversationMessage  `json:"conversation_message"`
	ConversationParts   ConversationPartList `json:"conversation_parts"`
}

A Conversation represents a conversation between users and admins in Intercom.

type ConversationAPI added in v1.0.1 

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

ConversationAPI implements ConversationRepository

type ConversationList added in v1.0.1 

type ConversationList struct {
	Pages         PageParams     `json:"pages"`
	Conversations []Conversation `json:"conversations"`
}

ConversationList is a list of Conversations

type ConversationListState added in v1.0.1 

type ConversationListState int

The state of Conversations to query SHOW_ALL shows all conversations, SHOW_OPEN shows only open conversations (only valid for Admin Conversation queries) SHOW_CLOSED shows only closed conversations (only valid for Admin Conversation queries) SHOW_UNREAD shows only unread conversations (only valid for User Conversation queries) 

const (
	SHOW_ALL ConversationListState = iota
	SHOW_OPEN
	SHOW_CLOSED
	SHOW_UNREAD
)

type ConversationMessage added in v1.0.1 

type ConversationMessage struct {
	Subject string         `json:"subject"`
	Body    string         `json:"body"`
	Author  MessageAddress `json:"author"`
}

A ConversationMessage is the message that started the conversation rendered for presentation

type ConversationPart added in v1.0.1 

type ConversationPart struct {
	ID         string         `json:"id"`
	PartType   string         `json:"part_type"`
	Body       string         `json:"body"`
	CreatedAt  int32          `json:"created_at"`
	UpdatedAt  int32          `json:"updated_at"`
	NotifiedAt int32          `json:"notified_at"`
	AssignedTo Admin          `json:"assigned_to"`
	Author     MessageAddress `json:"author"`
}

A ConversationPart is a Reply, Note, or Assignment to a Conversation

type ConversationPartList added in v1.0.1 

type ConversationPartList struct {
	Parts []ConversationPart `json:"conversation_parts"`
}

A ConversationPartList lists the subsequent Conversation Parts

type ConversationRepository added in v1.0.1 

type ConversationRepository interface {
	// contains filtered or unexported methods
}

ConversationRepository defines the interface for working with Conversations through the API.

type ConversationService added in v1.0.1 

type ConversationService struct {
	Repository ConversationRepository
}

ConversationService handles interactions with the API through an ConversationRepository.

func (*ConversationService) Assign added in v1.0.1 

func (c *ConversationService) Assign(id string, assigner, assignee *Admin) (Conversation, error)

Assign a Conversation to an Admin

func (*ConversationService) Close added in v1.0.1 

func (c *ConversationService) Close(id string, closer *Admin) (Conversation, error)

Close a Conversation (without a body)

func (*ConversationService) Find added in v1.0.1 

func (c *ConversationService) Find(id string) (Conversation, error)

Find Conversation by conversation id

func (*ConversationService) ListAll added in v1.0.1 

func (c *ConversationService) ListAll(pageParams PageParams) (ConversationList, error)

List all Conversations

func (*ConversationService) ListByAdmin added in v1.0.1 

func (c *ConversationService) ListByAdmin(admin *Admin, state ConversationListState, pageParams PageParams) (ConversationList, error)

List Conversations by Admin

func (*ConversationService) ListByUser added in v1.0.1 

func (c *ConversationService) ListByUser(user *User, state ConversationListState, pageParams PageParams) (ConversationList, error)

List Conversations by User

func (*ConversationService) MarkRead added in v1.0.1 

func (c *ConversationService) MarkRead(id string) (Conversation, error)

Mark Conversation as read (by a User)

func (*ConversationService) Open added in v1.0.1 

func (c *ConversationService) Open(id string, opener *Admin) (Conversation, error)

Open a Conversation (without a body)

func (*ConversationService) Reply added in v1.0.1 

func (c *ConversationService) Reply(id string, author MessagePerson, replyType ReplyType, body string) (Conversation, error)

func (*ConversationService) ReplyWithAttachmentURLs added in v1.0.1 

func (c *ConversationService) ReplyWithAttachmentURLs(id string, author MessagePerson, replyType ReplyType, body string, attachmentURLs []string) (Conversation, error)

Reply to a Conversation by id

type Event 

type Event struct {
	Email     string                 `json:"email,omitempty"`
	UserID    string                 `json:"user_id,omitempty"`
	EventName string                 `json:"event_name,omitempty"`
	CreatedAt int32                  `json:"created_at,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

An Event represents a new event that happens to a User.

func (Event) String 

func (e Event) String() string

type EventAPI 

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

EventAPI implements EventRepository

type EventRepository 

type EventRepository interface {
	// contains filtered or unexported methods
}

EventRepository defines the interface for working with Events through the API.

type EventService 

type EventService struct {
	Repository EventRepository
}

EventService handles interactions with the API through an EventRepository.

func (*EventService) Save 

func (e *EventService) Save(event *Event) error

Save a new Event

type IntercomError 

type IntercomError interface {
	Error() string
	GetStatusCode() int
	GetCode() string
	GetMessage() string
}

IntercomError is a known error from the Intercom API

type LocationData 

type LocationData struct {
	CityName      string  `json:"city_name,omitempty"`
	ContinentCode string  `json:"continent_code,omitempty"`
	CountryName   string  `json:"country_name,omitempty"`
	Latitude      float64 `json:"latitude,omitempty"`
	Longitude     float64 `json:"longitude,omitempty"`
	PostalCode    string  `json:"postal_code,omitempty"`
	RegionName    string  `json:"region_name,omitempty"`
	Timezone      string  `json:"timezone,omitempty"`
	CountryCode   string  `json:"country_code,omitempty"`
}

LocationData represents the location for a User.

func (LocationData) String 

func (l LocationData) String() string

type MessageAPI added in v1.0.1 

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

MessageAPI implements MessageRepository

type MessageAddress added in v1.0.1 

type MessageAddress struct {
	Type   string `json:"type,omitempty"`
	ID     string `json:"id,omitempty"`
	Email  string `json:"email,omitempty"`
	UserID string `json:"user_id,omitempty"`
}

type MessagePerson added in v1.0.1 

type MessagePerson interface {
	MessageAddress() MessageAddress
}

A MessagePerson is someone to send a Message to and from.

type MessageRepository added in v1.0.1 

type MessageRepository interface {
	// contains filtered or unexported methods
}

MessageRepository defines the interface for creating and updating Messages through the API.

type MessageRequest added in v1.0.1 

type MessageRequest struct {
	MessageType string         `json:"message_type,omitempty"`
	Subject     string         `json:"subject,omitempty"`
	Body        string         `json:"body,omitempty"`
	Template    string         `json:"template,omitempty"`
	From        MessageAddress `json:"from,omitempty"`
	To          MessageAddress `json:"to,omitempty"`
}

MessageRequest represents a Message to be sent through Intercom from/to an Admin, User, or Contact.

func NewEmailMessage added in v1.0.1 

func NewEmailMessage(template MessageTemplate, from, to MessagePerson, subject, body string) MessageRequest

NewEmailMessage creates a new *Message of email type.

func NewInAppMessage added in v1.0.1 

func NewInAppMessage(from, to MessagePerson, body string) MessageRequest

NewInAppMessage creates a new *Message of InApp (widget) type.

func NewUserMessage added in v1.0.1 

func NewUserMessage(from MessagePerson, body string) MessageRequest

NewUserMessage creates a new *Message from a User.

type MessageResponse added in v1.0.1 

type MessageResponse struct {
	MessageType string          `json:"message_type,omitempty"`
	ID          string          `json:"id"`
	CreatedAt   int32           `json:"created_at,omitempty"`
	Owner       MessageAddress  `json:"owner,omitempty"`
	Subject     string          `json:"subject,omitempty"`
	Body        string          `json:"body,omitempty"`
	Template    MessageTemplate `json:"template,omitempty"`
}

MessageResponse represents a Message to be sent through Intercom from/to an Admin, User, or Contact.

func (MessageResponse) String added in v1.0.1 

func (m MessageResponse) String() string

type MessageService added in v1.0.1 

type MessageService struct {
	Repository MessageRepository
}

MessageService handles interactions with the API through an MessageRepository.

func (*MessageService) Save added in v1.0.1 

func (m *MessageService) Save(message *MessageRequest) (MessageResponse, error)

Save (send) a Message

type MessageTemplate added in v1.0.1 

type MessageTemplate int

MessageTemplate determines the template used for email messages to Users or Contacts (plain or personal) 

const (
	NO_TEMPLATE MessageTemplate = iota
	PERSONAL_TEMPLATE
	PLAIN_TEMPLATE
)

func (MessageTemplate) String added in v1.0.1 

func (template MessageTemplate) String() string

type PageParams 

type PageParams struct {
	Page       int32 `json:"page" url:"page,omitempty"`
	PerPage    int32 `json:"per_page" url:"per_page,omitempty"`
	TotalPages int32 `json:"total_pages" url:"-"`
}

PageParams determine paging information to and from the API

type Plan 

type Plan struct {
	ID   string `json:"id,omitempty"`
	Name string `json:"name,omitempty"`
}

The Plan a Company is on

func (Plan) String 

func (p Plan) String() string

type Reply added in v1.0.1 

type Reply struct {
	Type           string   `json:"type"`
	ReplyType      string   `json:"message_type"`
	Body           string   `json:"body,omitempty"`
	AssigneeID     string   `json:"assignee_id,omitempty"`
	AdminID        string   `json:"admin_id,omitempty"`
	IntercomID     string   `json:"intercom_user_id,omitempty"`
	Email          string   `json:"email,omitempty"`
	UserID         string   `json:"user_id,omitempty"`
	AttachmentURLs []string `json:"attachment_urls,omitempty"`
}

A Reply to an Intercom conversation

type ReplyType added in v1.0.1 

type ReplyType int

ReplyType determines the type of Reply 

const (
	CONVERSATION_COMMENT ReplyType = iota
	CONVERSATION_NOTE
	CONVERSATION_ASSIGN
	CONVERSATION_OPEN
	CONVERSATION_CLOSE
)

func (ReplyType) String added in v1.0.1 

func (reply ReplyType) String() string

type Segment 

type Segment struct {
	ID         string            `json:"id,omitempty"`
	Name       string            `json:"name,omitempty"`
	CreatedAt  int32             `json:"created_at,omitempty"`
	UpdatedAt  int32             `json:"updated_at,omitempty"`
	PersonType SegmentPersonType `json:"person_type,omitempty"`
}

Segment represents an Segment in Intercom.

func (Segment) String 

func (s Segment) String() string

type SegmentAPI 

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

SegmentAPI implements SegmentRepository

type SegmentList 

type SegmentList struct {
	Segments []Segment `json:"segments,omitempty"`
}

SegmentList, an object holding a list of Segments

type SegmentPersonType 

type SegmentPersonType int
const (
	USER SegmentPersonType = iota
	CONTACT
)

func (SegmentPersonType) String 

func (segmentPersonType SegmentPersonType) String() string

type SegmentRepository 

type SegmentRepository interface {
	// contains filtered or unexported methods
}

SegmentRepository defines the interface for working with Segments through the API.

type SegmentService 

type SegmentService struct {
	Repository SegmentRepository
}

SegmentService handles interactions with the API through a SegmentRepository.

func (*SegmentService) Find 

func (t *SegmentService) Find(id string) (Segment, error)

Find a particular Segment in the App

func (*SegmentService) List 

func (t *SegmentService) List() (SegmentList, error)

List all Segments for the App

type SocialProfile 

type SocialProfile struct {
	Name     string `json:"name,omitempty"`
	ID       string `json:"id,omitempty"`
	Username string `json:"username,omitempty"`
	URL      string `json:"url,omitempty"`
}

SocialProfile represents a social account for a User.

func (SocialProfile) String 

func (s SocialProfile) String() string

type SocialProfileList 

type SocialProfileList struct {
	SocialProfiles []SocialProfile `json:"social_profiles,omitempty"`
}

SocialProfile list is a list of SocialProfiles for a User.

type Tag 

type Tag struct {
	ID   string `json:"id,omitempty"`
	Name string `json:"name,omitempty"`
}

Tag represents an Tag in Intercom.

func (Tag) String 

func (t Tag) String() string

type TagAPI 

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

TagAPI implements TagRepository

type TagList 

type TagList struct {
	Tags []Tag `json:"tags,omitempty"`
}

TagList, an object holding a list of Tags

type TagRepository 

type TagRepository interface {
	// contains filtered or unexported methods
}

TagRepository defines the interface for working with Tags through the API.

type TagService 

type TagService struct {
	Repository TagRepository
}

TagService handles interactions with the API through a TagRepository.

func (*TagService) Delete 

func (t *TagService) Delete(id string) error

Delete a Tag

func (*TagService) List 

func (t *TagService) List() (TagList, error)

List all Tags for the App

func (*TagService) Save 

func (t *TagService) Save(tag *Tag) (Tag, error)

Save a new Tag for the App.

func (*TagService) Tag 

func (t *TagService) Tag(taggingList *TaggingList) (Tag, error)

Tag Users or Companies using a TaggingList.

type Tagging 

type Tagging struct {
	ID        string `json:"id,omitempty"`
	UserID    string `json:"user_id,omitempty"`
	Email     string `json:"email,omitempty"`
	CompanyID string `json:"company_id,omitempty"`
	Untag     *bool  `json:"untag,omitempty"`
}

A Tagging is an object identifying a User or Company to be tagged, that can optionally be set to untag.

type TaggingList 

type TaggingList struct {
	Name      string    `json:"name,omitempty"`
	Users     []Tagging `json:"users,omitempty"`
	Companies []Tagging `json:"companies,omitempty"`
}

TaggingList is an object used to Tag Users and Companies. The Name should be that of the Tag required, and Users and Companies are lists of Taggings

type User 

type User struct {
	ID                     string                 `json:"id,omitempty"`
	Email                  string                 `json:"email,omitempty"`
	UserID                 string                 `json:"user_id,omitempty"`
	Anonymous              *bool                  `json:"anonymous,omitempty"`
	Name                   string                 `json:"name,omitempty"`
	Pseudonym              string                 `json:"pseudonym,omitempty"`
	Avatar                 *UserAvatar            `json:"avatar,omitempty"`
	LocationData           *LocationData          `json:"location_data,omitempty"`
	SignedUpAt             int32                  `json:"signed_up_at,omitempty"`
	RemoteCreatedAt        int32                  `json:"remote_created_at,omitempty"`
	LastRequestAt          int32                  `json:"last_request_at,omitempty"`
	CreatedAt              int32                  `json:"created_at,omitempty"`
	UpdatedAt              int32                  `json:"updated_at,omitempty"`
	SessionCount           int32                  `json:"session_count,omitempty"`
	LastSeenIP             string                 `json:"last_seen_ip,omitempty"`
	SocialProfiles         *SocialProfileList     `json:"social_profiles,omitempty"`
	UnsubscribedFromEmails *bool                  `json:"unsubscribed_from_emails,omitempty"`
	UserAgentData          string                 `json:"user_agent_data,omitempty"`
	Tags                   *TagList               `json:"tags,omitempty"`
	Segments               *SegmentList           `json:"segments,omitempty"`
	Companies              *CompanyList           `json:"companies,omitempty"`
	CustomAttributes       map[string]interface{} `json:"custom_attributes,omitempty"`
	UpdateLastRequestAt    *bool                  `json:"update_last_request_at,omitempty"`
	NewSession             *bool                  `json:"new_session,omitempty"`
	LastSeenUserAgent      string                 `json:"last_seen_user_agent,omitempty"`
}

User represents a User within Intercom. Not all of the fields are writeable to the API, non-writeable fields are stripped out from the request. Please see the API documentation for details.

func (User) MessageAddress added in v1.0.1 

func (u User) MessageAddress() MessageAddress

Get the address for an User in order to message them

func (User) String 

func (u User) String() string

type UserAPI 

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

UserAPI implements UserRepository

type UserAvatar 

type UserAvatar struct {
	ImageURL string `json:"image_url,omitempty"`
}

UserAvatar represents an avatar for a User.

func (UserAvatar) String 

func (a UserAvatar) String() string

type UserCompany 

type UserCompany struct {
	ID     string `json:"id,omitempty"`
	Name   string `json:"name,omitempty"`
	Remove *bool  `json:"remove,omitempty"`
}

A Company the User belongs to used to update Companies on a User.

type UserIdentifiers 

type UserIdentifiers struct {
	ID     string `url:"-"`
	UserID string `url:"user_id,omitempty"`
	Email  string `url:"email,omitempty"`
}

UserIdentifiers are used to identify Users in Intercom.

type UserList 

type UserList struct {
	Pages PageParams
	Users []User
}

UserList holds a list of Users and paging information

type UserRepository 

type UserRepository interface {
	// contains filtered or unexported methods
}

UserRepository defines the interface for working with Users through the API.

type UserService 

type UserService struct {
	Repository UserRepository
}

UserService handles interactions with the API through a UserRepository.

func (*UserService) Delete 

func (u *UserService) Delete(id string) (User, error)

func (*UserService) FindByEmail 

func (u *UserService) FindByEmail(email string) (User, error)

FindByEmail looks up a User by their Email.

func (*UserService) FindByID 

func (u *UserService) FindByID(id string) (User, error)

FindByID looks up a User by their Intercom ID.

func (*UserService) FindByUserID 

func (u *UserService) FindByUserID(userID string) (User, error)

FindByUserID looks up a User by their UserID (customer supplied).

func (*UserService) List 

func (u *UserService) List(params PageParams) (UserList, error)

List all Users for App.

func (*UserService) ListBySegment 

func (u *UserService) ListBySegment(segmentID string, params PageParams) (UserList, error)

List Users by Segment.

func (*UserService) ListByTag 

func (u *UserService) ListByTag(tagID string, params PageParams) (UserList, error)

List Users By Tag.

func (*UserService) Save 

func (u *UserService) Save(user *User) (User, error)

Save a User, creating or updating them.

Source Files

View all Source files

Directories

Path Synopsis

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.