webex

Messages are how people communicate in rooms. Each message timestamped and represented in Webex as a distinct block of content. Messages can contain plain text and a single file attachment. See the Message Attachments Guide for a list of supported media types.

new Messages()

Instance Members

▸ listen()

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

Register to listen for incoming attachmentAction events This is an alternate approach to registering for attachmentAction webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. The attachmentActions.listen() event objects can also include additional fields not available in the webhook's JSON payload, specifically: inputs. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.attachmentActions.listen()
  .then(() => {
    console.log('listening to attachmentActions events');
    webex.attachmentActions.on('created', (event) => console.log(`Got an attachmentActions:created event:\n${event}`));
  })
  .catch((e) => console.error(`Unable to register for attachmentAction events: ${e}`));
// Some app logic...
// WHen it is time to cleanup
webex.attachmentActions.stopListening();
webex.attachmentActions.off('created');

▸ listen()

Register to listen for incoming messages events This is an alternate approach to registering for messages webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. The messages.listen() event objects can also include additional fields not available in the webhook's JSON payload: text, markdown, and files. These fields are available when their details are included in the web socket's activity object. Retrieving other fields, such as the html field, will require a manual request to get the corresponding message object. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.messages.listen()
  .then(() => {
    console.log('listening to message events');
    webex.messages.on('created', (event) => console.log(`Got a message:created event:\n${event}`));
    webex.messages.on('deleted', (event) => console.log(`Got a message:deleted event:\n${event}`));
  })
  .catch((e) => console.error(`Unable to register for message events: ${e}`));
// Some app logic...
// When it is time to cleanup
webex.messages.stopListening();
webex.messages.off('created');
webex.messages.off('deleted');

▸ create(message)

Post a new message and/or media content into a room.

create(message: MessageObject): Promise<MessageObject>

Parameters

message (MessageObject)

Returns

Promise<MessageObject>:

Example

webex.rooms.create({title: 'Create Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(message) {
    var assert = require('assert');
    assert(message.id);
    assert(message.personId);
    assert(message.personEmail);
    assert(message.roomId);
    assert(message.created);
    return 'success';
  });
  // => success

▸ update(message, altMessage)

Put an updated message and/or media content into a room instead of existing message.

update(message: MessageObject, altMessage: MessageObject): Promise<MessageObject>

Parameters

message (MessageObject)

altMessage (MessageObject)

Returns

Promise<MessageObject>:

Example

webex.rooms.create({title: 'Create Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message = m;
    return webex.messages.update(message,{markdown:`**What up**`});
  })
  .then(function(m) {
    message = m;
    return webex.messages.update(message.id,{roomId:message.roomId,text:'Howdy!'});
  })
  .then(function(message) {
    var assert = require('assert');
    assert(message.id);
    assert(message.personId);
    assert(message.personEmail);
    assert(message.roomId);
    assert(message.created);
    return 'success';
  });
  // => success

▸ get(message)

Returns a single message.

get(message: (RoomObject | string)): Promise<MessageObject>

Parameters

message ((RoomObject | string))

Returns

Promise<MessageObject>:

Example

var message;
webex.rooms.create({title: 'Get Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message = m;
    return webex.messages.get(message.id);
  })
  .then(function(message2) {
    var assert = require('assert');
    assert.deepEqual(message2, message);
    return 'success';
  });
  // => success

▸ list(options)

Returns a list of messages. In most cases the results will only contain messages posted in rooms that the authenticated user is a member of.

list(options: Object): Promise<Page<MessageObject>>

Parameters

options (Object)

Name	Description
options.roomId `string`
options.max `number`

Returns

Promise<Page<MessageObject>>:

Example

var message1, message2, room;
webex.rooms.create({title: 'List Messages Example'})
  .then(function(r) {
    room = r;
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message1 = m;
    return webex.messages.create({
      text: 'How are you?',
      roomId: room.id
    });
  })
  .then(function(m) {
    message2 = m;
    return webex.messages.list({roomId: room.id});
  })
  .then(function(messages) {
    var assert = require('assert');
    assert.equal(messages.length, 2);
    assert.equal(messages.items[0].id, message2.id);
    assert.equal(messages.items[1].id, message1.id);
    return 'success';
  });
  // => success

▸ remove(message)

Deletes a single message. Deleting a message will notify all members of the room that the authenticated user deleted the message. Generally, users can only delete their own messages except for the case of Moderated Rooms and Org Administrators.

remove(message: (MessageObject | uuid)): Promise

Parameters

message ((MessageObject | uuid))

Returns

Promise: }

Example

var message1, room;
webex.rooms.create({title: 'Messages Example'})
  .then(function(r) {
    room = r;
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id
    });
  })
  .then(function(m) {
    message1 = m;
    return webex.messages.create({
      text: 'How are you?',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.messages.remove(message1);
  })
  .then(function() {
    return webex.messages.list({roomId: room.id});
  })
  .then(function(messages) {
    var assert = require('assert');
    assert.equal(messages.items.length, 1);
    assert(messages.items[0].id !== message1.id);
    return 'success';
  });
  // => success

Resources

These are the resources provided by Webex instances for interacting with our developer API

Memberships

packages/@webex/plugin-memberships/src/memberships.js

Memberships represent a person's relationship to a room. Use this API to list members of any room that you're in or create memberships to invite someone to a room. Memberships can also be updated to make someone a moderator or deleted to remove them from the room.

new Memberships()

Instance Members

▸ listen()

packages/@webex/plugin-memberships/src/memberships.js

Register to listen for incoming membership events This is an alternate approach to registering for membership webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.memberships.listen()
  .then(() => {
    console.log('listening to membership events');
    webex.memberships.on('created', (event) => {
      console.log(`Got a membership:created event:\n${event}`);
    }
    webex.memberships.on('updated', (event) => {
       console.log(`Got a membership:updated event:\n${event}`);
    }
    webex.memberships.on('seen', (event) => {
      // This represents a "read receipt" and will include a
      // lastSeenId for the message this member has just "read",
      // There is currently no equivalent webhook for this event.
      console.log(`Got a membership:seen event:\n${event}`);
    }
    webex.memberships.on('deleted', (event) =>  => {
      console.log(`Got a membership:created event:\n${event}`);
    }
  })
  .catch((e) => console.error(`Unable to register for membership events: ${e}`));
// App logic goes here...
// Later when it is time to clean up
webex.memberships.stopListening();
webex.memberships.off('created');
webex.memberships.off('updated');
webex.memberships.off('seen');
webex.memberships.off('deleted');

▸ create(membership)

packages/@webex/plugin-memberships/src/memberships.js

Adds a person to a room. The person can be added by ID (personId) or by Email Address (personEmail). The person can be optionally added to the room as a moderator.

create(membership: MembershipObject): Promise<MembershipObject>

Parameters

membership (MembershipObject)

Returns

Promise<MembershipObject>:

Example

webex.rooms.create({title: 'Create Membership Example'})
  .then(function(room) {
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
   });
  })
  .then(function(membership) {
    var assert = require('assert');
    assert(membership.id);
    assert(membership.roomId);
    assert(membership.personId);
    assert(membership.personEmail);
    assert('isModerator' in membership);
    assert('isMonitor' in membership);
    assert(membership.created);
    return 'success';
  });
  // => success

▸ get(membership)

packages/@webex/plugin-memberships/src/memberships.js

Returns a single membership.

get(membership: (MembershipObject | uuid)): Promise<MembershipObject>

Parameters

membership ((MembershipObject | uuid))

Returns

Promise<MembershipObject>:

Example

var membership;
webex.rooms.create({title: 'Get Membership Example'})
  .then(function(room) {
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.memberships.get(m.id);
  })
  .then(function(m) {
    var assert = require('assert');
    assert.deepEqual(m, membership);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-memberships/src/memberships.js

Returns a list of memberships. In most cases the results will only contain rooms that the authenticated user is a member of. You can filter the results by room to list people in a room or by person to find rooms that a specific person is a member of.

list(options: Object): Promise<Page<MembershipObject>>

Parameters

options (Object)

Name	Description
options.personId `string`
options.personEmail `string`
options.roomId `string`
options.max `number`

Returns

Promise<Page<MembershipObject>>:

Example

var room;
webex.rooms.create({title: 'List Membership Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
    });
  })
  .then(function() {
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 2);
    for (var i = 0; i < memberships.length; i+= 1) {
      assert.equal(memberships.items[i].roomId, room.id);
    }
    return 'success';
  });
  // => success

▸ listWithReadStatus(options)

packages/@webex/plugin-memberships/src/memberships.js

Returns a list of memberships with details about the lastSeenId for each user, allowing a client to indicate "read status" in a space GUI

This differs from the memberships.list() function in the following ways: -- it accepts only a room or object with a valid roomId -- no other options, eg: max, are considered -- results are not paginated -- memberships in the return do not include the "created", "isRoomHidden", fields -- memberships in the return do include the new "lastSeenId", and "lastSeenDate" fields these will not exist if the member has never "seen" the space

In general this function should be used only when the client needs to access read status info.

This function may be deprecated when this info is provided in the membership objects returned in the list function.

listWithReadStatus(options: Object): Promise<MembershipObjectList>

Parameters

options (Object)

Name	Description
options.roomId `string`

Returns

Promise<MembershipObjectList>:

▸ remove(membership)

packages/@webex/plugin-memberships/src/memberships.js

Deletes a single membership.

remove(membership: (MembershipObject | uuid)): Promise

Parameters

membership ((MembershipObject | uuid))

Returns

Promise:

Example

var membership, room;
webex.rooms.create({title: 'Remove Membership Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
     personEmail: 'alice@example.com',
     roomId: room.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 2);
    return webex.memberships.remove(membership);
  })
  .then(function() {
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    var assert = require('assert');
    assert.equal(memberships.length, 1);
    return 'success';
  });
  // => success

▸ update(membership)

packages/@webex/plugin-memberships/src/memberships.js

Used to update a single membership's properties

update(membership: (MembershipObject | uuid)): Promise<MembershipObject>

Parameters

membership ((MembershipObject | uuid))

Returns

Promise<MembershipObject>:

Example

// Change membership to make user a moderator
var membership, room;
webex.rooms.create({title: 'Memberships Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.list({roomId: room.id});
  })
  .then(function(memberships) {
    membership = memberships.items[0];
    var assert = require('assert');
    assert.equal(membership.isModerator, false);
    membership.isModerator = true;
    return webex.memberships.update(membership);
  })
  .then(function() {
    return webex.memberships.get(membership.id);
  })
  .then(function(membership) {
    var assert = require('assert');
    assert.equal(membership.isModerator, true);
    return 'success';
  });
  // => success

// Hide a one on one space
var assert = require('assert');
var membership, myId;
webex.people.get('me')
  .then(function(person) {
    myId = personId;
    return webex.messages.create({
      toPersonEmail: 'otherUser@acme.com',
      text: 'This message will create a 1-1 space'
    });
  })
  then(function(message) {
    return webex.memberships.list({
      roomId: message.roomId,
      personId: myId
    });
  })
  .then((memberships) => {
    membership = memberships.items[0];
    assert.equal(membership.isRoomHidden, false);
    membership.isRoomHidden = true;
    // This will generate a memberships:updated event
    // that will only be seen by this user
    return webex.memberships.update(membership);
  })
  .then(function(membership) {
    assert.equal(membership.isRoomHidden, true);
    return 'success';
  });
  // => success

▸ updateLastSeen(message)

packages/@webex/plugin-memberships/src/memberships.js

Updates the lastSeenId attribute of a membership. Call this method to send a "read receipt" for a given message. This will update the lastSeenId for the user's membership in space where the message is.

updateLastSeen(message: string): Promise<MembershipObject>

Parameters

message (string)

Returns

Promise<MembershipObject>:

People

packages/@webex/plugin-people/src/people.js

new People()

Instance Members

▸ get(person)

packages/@webex/plugin-people/src/people.js

Returns a single person by ID

get(person: (PersonObject | uuid | string)): Promise<PersonObject>

Parameters

person ((PersonObject | uuid | string))

Returns

Promise<PersonObject>:

Example

webex.rooms.create({title: 'Get Person Example'})
  .then(function(room) {
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    return webex.people.get(membership.personId);
  })
  .then(function(alice) {
    var assert = require('assert');
    assert(alice.id);
    assert(Array.isArray(alice.emails));
    assert.equal(alice.emails.filter(function(email) {
      return email === 'alice@example.com';
    }).length, 1);
    assert(alice.displayName);
    assert(alice.created);
    return 'success';
  });
  // => success

▸ list(options, showAllTypes)

packages/@webex/plugin-people/src/people.js

Returns a list of people

list(options: (Object | Array<uuid>), showAllTypes: bool): Promise<Page<PersonObject>>

Parameters

options ((Object | Array<uuid>)) or array of uuids

Name	Description
options.email `email`	Returns people with an email that contains this string
options.displayName `string`	Returns people with a name that contains this string

showAllTypes (bool) optional flag that requires Hydra to send every type field, even if the type is not "person" (e.g.: SX10, webhook_integration, etc.)

Returns

Promise<Page<PersonObject>>:

Example

var room;
webex.rooms.create({title: 'List People Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.memberships.create({
      personEmail: 'bob@example.com',
      roomId: room.id
    });
  })
  .then(function() {
    return webex.people.list({email: 'alice@example.com'});
  })
  .then(function(people) {
    var assert = require('assert');
    assert.equal(people.length, 1);
    var person = people.items[0];
    assert(person.id);
    assert(Array.isArray(person.emails));
    assert(person.displayName);
    assert(person.created);
    return 'success';
  });
  // => success

Example usage of array method

var room;
var aliceId;
var bobId;
webex.rooms.create({title: 'List People Array Example'})
  .then(function(r) {
    room = r;
    return webex.memberships.create({
      personEmail: 'alice@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    aliceId = membership.personId;
  })
  .then(function() {
    return webex.memberships.create({
      personEmail: 'bob@example.com',
      roomId: room.id
    });
  })
  .then(function(membership) {
    bobId = membership.personId;
  })
  .then(function() {
    return webex.people.list([aliceId, bobId]);
  })
  .then(function(people) {
    var assert = require('assert');
    assert.equal(people.length, 2);
    var person = people.items[0];
    assert(person.id);
    assert(Array.isArray(person.emails));
    assert(person.displayName);
    assert(person.created);
    return 'success';
  });
  // => success

Rooms

packages/@webex/plugin-rooms/src/rooms.js

Rooms are virtual meeting places for getting stuff done. This resource represents the room itself. Check out the Memberships API to learn how to add and remove people from rooms and the Messages API for posting and managing content.

new Rooms()

Instance Members

▸ listen()

packages/@webex/plugin-rooms/src/rooms.js

Register to listen for incoming rooms events This is an alternate approach to registering for rooms webhooks. The events passed to any registered handlers will be similar to the webhook JSON, but will omit webhook specific fields such as name, secret, url, etc. To utilize the listen() method, the authorization token used will need to have spark:all and spark:kms scopes enabled. Note that by configuring your application to enable or disable spark:all via its configuration page will also enable or disable spark:kms. See the Sample App for more details.

listen(): Promise

Returns

Promise:

Example

webex.rooms.listen()
  .then(() => {
    console.log('listening to room events');
    webex.rooms.on('created', (event) => console.log(`Got a room:created event:\n${event}`);
    webex.rooms.on('updated', (event) => console.log(`Got a room:updated event:\n${event}`);
  })
  .catch((e) => console.error(`Unable to register for room events: ${e}`));
// Some app logic...
// WHen it is time to cleanup
webex.rooms.stopListening();
webex.rooms.off('created');
webex.rooms.off('updated');

▸ create(room)

packages/@webex/plugin-rooms/src/rooms.js

Creates a new room. The authenticated user is automatically added as a member of the room. See the Memberships API to learn how to add more people to the room.

create(room: RoomObject): Promise<RoomObject>

Parameters

room (RoomObject)

Returns

Promise<RoomObject>:

Example

webex.rooms.create({title: 'Create Room Example'})
  .then(function(room) {
    var assert = require('assert')
    assert(typeof room.created === 'string');
    assert(typeof room.id === 'string');
    assert(room.title === 'Create Room Example');
    console.log(room.title);
    return 'success';
  });
  // => success

▸ get(room, options)

packages/@webex/plugin-rooms/src/rooms.js

Returns a single room.

get(room: (RoomObject | string), options: Object): Promise<RoomObject>

Parameters

room ((RoomObject | string))

options (Object)

Returns

Promise<RoomObject>:

Example

var room;
webex.rooms.create({title: 'Get Room Example'})
  .then(function(r) {
    room = r
    return webex.rooms.get(room.id)
  })
  .then(function(r) {
    var assert = require('assert');
    assert.deepEqual(r, room);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-rooms/src/rooms.js

Returns a list of rooms. In most cases the results will only contain rooms that the authenticated user is a member of.

list(options: Object): Promise<Page<RoomObject>>

Parameters

options (Object)

Name	Description
options.max `Object`	Limit the maximum number of rooms in the response.

Returns

Promise<Page<RoomObject>>:

Example

var createdRooms;
Promise.all([
  webex.rooms.create({title: 'List Rooms Example 1'}),
  webex.rooms.create({title: 'List Rooms Example 2'}),
  webex.rooms.create({title: 'List Rooms Example 3'})
])
  .then(function(r) {
    createdRooms = r;
    return webex.rooms.list({max: 3})
      .then(function(rooms) {
        var assert = require('assert');
        assert(rooms.length === 3);
        for (var i = 0; i < rooms.items.length; i+= 1) {
          assert(createdRooms.filter(function(room) {
            return room.id === rooms.items[i].id;
          }).length === 1);
        }
        return 'success';
      });
  });
  // => success

▸ listWithReadStatus(maxRecent)

packages/@webex/plugin-rooms/src/rooms.js

Returns a list of rooms with details about the data of the last activity in the room, and the date of the users last presences in the room. The list is sorted with this with most recent activity first

For rooms where lastActivityDate > lastSeenDate the space can be considered to be "unread"

This differs from the rooms.list() function in the following ways: -- when called with no parameters it returns an array of all spaces, up to 1000, that the user is a member of -- pagination is not supported. ALL rooms are returned which can result in a large payload -- For users with hundreds of spaces, this API can take some time to to return, for this reason it supports an optional maxRecent parameter. If set this will return only the specified number of spaces with activity in the last two weeks. Recommended value is 30. Max supported is 100. -- only "id", "type", "lastActivityDate", and "lastSeenDate" are guaranteed to be available for each room in the list -- "title" is usually returned, but not guaranteed

In general this function should be used only when the client needs to access read status info, for example on startup. After startup, clients should track message and membership:seen events to maintain read status client side.

Since this API can take some time to return up to 1000 spaces, it is recommended that custom clients call this first with the maxRecent parameter set to 30, so that they can display some of the more recents spaces. Calling this API a second time with no parameters will return all the spaces.

Not all spaces may be returned, for example when users in more than 1000 spaces, or when a new spaces is added after this function is called, but before it returns. Custom clients should be prepared to gracefully handle cases where an event occurs in a space not returned by this call, by querying rooms.getWithReadStatus() with the id of the room in question

This function may be deprecated when this info is provided in the membership objects returned in the list function.

listWithReadStatus(maxRecent: int): Promise<RoomInfoObjectList>

Parameters

maxRecent

(int
            = 0)

Returns

Promise<RoomInfoObjectList>:

▸ getWithReadStatus(roomId)

packages/@webex/plugin-rooms/src/rooms.js

Returns a single room object with details about the data of the last activity in the room, and the date of the users last presence in the room.

For rooms where lastActivityDate > lastSeenDate the room can be considered to be "unread"

This differs from the rooms.get() function in the following ways: -- it takes a single roomId parameter to fetch -- no other options are considered -- only "id", "type", "lastActivityDate", and "lastSeenDate" are guaranteed to be available in the return object -- "title" is usually returned, but not guaranteed

In general clients should use the listWithReadStatus() method on startup to get the initial roomStatus and then update their client side copy by responding to message, membership and room events.

This function allows a custom client to be "nimble" if it is responding to an event with a roomId that was not in the original fetch. The anticipated behavior is that getWithReadStats is called "just in time", with the resulting room object being added to the list of cached room objects on the client side.

This function may be deprecated when this info is provided in the room object returned in the get function.

getWithReadStatus(roomId: string): Promise<RoomInfoObject>

Parameters

roomId (string)

Returns

Promise<RoomInfoObject>:

▸ remove(room)

packages/@webex/plugin-rooms/src/rooms.js

Deletes a single room.

remove(room: (RoomObject | string)): Promise

Parameters

room ((RoomObject | string))

Returns

Promise:

Example

var room;
webex.rooms.create({title: 'Remove Room Example'})
 .then(function(r) {
   room = r;
   return webex.rooms.remove(room.id);
 })
 .then(function() {
   return webex.rooms.get(room.id);
 })
 .then(function() {
   var assert = require('assert');
   assert(false, 'the previous get should have failed');
 })
 .catch(function(reason) {
   var assert = require('assert');
   assert.equal(reason.statusCode, 404);
   return 'success'
 });
 // => success

▸ update(room)

packages/@webex/plugin-rooms/src/rooms.js

Used to update a single room's properties.

update(room: RoomObject): Promise<RoomObject>

Parameters

room (RoomObject)

Returns

Promise<RoomObject>:

Example

var room;
webex.rooms.update({title: 'Update Room Example'})
  .then(function(r) {
    room = r;
    room.title = 'Update Room Example (Updated Title)';
    return webex.rooms.update(room);
  })
  .then(function() {
    return webex.rooms.get(room.id);
  })
  .then(function(room) {
   var assert = require('assert');
    assert.equal(room.title, 'Update Room Example (Updated Title)');
    return 'success';
  });
  // => success

Teams

packages/@webex/plugin-teams/src/teams.js

new Teams()

Instance Members

▸ create(team)

packages/@webex/plugin-teams/src/teams.js

Create a new team.

create(team: TeamObject): Promise<TeamObject>

Parameters

team (TeamObject)

Returns

Promise<TeamObject>:

Example

webex.teams.create({name: 'Create Team Example'})
  .then(function(team) {
    var assert = require('assert');
    assert(team.id);
    assert(team.name);
    assert(team.created);
    return 'success';
  });
  // => success

▸ get(team, options)

packages/@webex/plugin-teams/src/teams.js

Returns a single team

get(team: (TeamObject | string), options: Object): Promise<TeamObject>

Parameters

team ((TeamObject | string))

options (Object)

Returns

Promise<TeamObject>:

Example

var team;
webex.teams.create({name: 'Get Team Example'})
  .then(function(r) {
    team = r;
    return webex.teams.get(team.id);
  })
  .then(function(team2) {
    var assert = require('assert');
    assert.equal(team2.id, team.id);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-teams/src/teams.js

List teams.

list(options: object): Promise<Page<TeamObject>>

Parameters

options (object)

Name	Description
options.max `object`	Limit the maximum number of teams in the response.

Returns

Promise<Page<TeamObject>>:

Example

var createdRooms;
Promise.all([
  webex.teams.create({name: 'List Teams Example 1'}),
  webex.teams.create({name: 'List Teams Example 2'}),
  webex.teams.create({name: 'List Teams Example 3'})
])
  .then(function(r) {
    createdRooms = r;
    return webex.teams.list({max: 3});
  })
  .then(function(teams) {
    var assert = require('assert');
    assert(teams.length === 3);
    for (var i = 0; i < teams.items.length; i+= 1) {
      assert(createdRooms.filter(function(room) {
        return room.id === teams.items[i].id;
      }).length === 1);
    }
    return 'success';
  });
  // => success

▸ update(team)

packages/@webex/plugin-teams/src/teams.js

Update a team.

update(team: TeamObject): Promise<TeamObject>

Parameters

team (TeamObject)

Returns

Promise<TeamObject>:

Example

var teams;
webex.teams.create({name: 'Update Team Example'})
  .then(function(r) {
    teams = r;
    teams.name = 'Teams Example (Updated Title)';
    return webex.teams.update(teams);
  })
  .then(function() {
    return webex.teams.get(teams.id);
  })
  .then(function(teams) {
    var assert = require('assert');
    assert.equal(teams.name, 'Teams Example (Updated Title)');
    return 'success';
  });
  // => success

TeamMemberships

packages/@webex/plugin-team-memberships/src/team-memberships.js

Team Memberships represent a person's relationship to a team. Use this API to list members of any team that you're in or create memberships to invite someone to a team. Team memberships can also be updated to make someone a moderator or deleted to remove them from the team.

Just like in the Webex app, you must be a member of the team in order to list its memberships or invite people.

new TeamMemberships()

Instance Members

▸ create(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Add someone to a team by Person ID or email address; optionally making them a moderator.

create(membership: TeamMembershipObject): Promise<TeamMembershipObject>

Parameters

membership (TeamMembershipObject)

Returns

Promise<TeamMembershipObject>:

Example

webex.teams.create({name: 'Create Team Membership Example'})
  .then(function(team) {
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
   });
  })
  .then(function(membership) {
    var assert = require('assert');
    assert(membership.id);
    assert(membership.teamId);
    assert(membership.personId);
    assert(membership.personEmail);
    assert('isModerator' in membership);
    assert(membership.created);
    return 'success';
  });
  // => success

▸ get(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Get details for a membership by ID.

get(membership: (TeamMembershipObject | string)): Promise<TeamMembershipObject>

Parameters

membership ((TeamMembershipObject | string))

Returns

Promise<TeamMembershipObject>:

Example

var membership;
webex.teams.create({name: 'Get Team Memberships Example'})
  .then(function(team) {
    return webex.teamMemberships.create({
      personEmail: 'alice@example.com',
      teamId: team.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.teamMemberships.get(m.id);
  })
  .then(function(m) {
    var assert = require('assert');
    assert.deepEqual(m, membership);
    return 'success';
  });
  // => success

▸ list(options)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Lists all team memberships. By default, lists memberships for teams to which the authenticated user belongs.

list(options: Object): [type]

Parameters

options (Object)

Name	Description
options.max `string`

Returns

[type]:

Example

var team;
webex.teams.create({name: 'List Team Memberships Example'})
  .then(function(t) {
    team = t;
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
    });
  })
  .then(function() {
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 2);
    for (var i = 0; i < teamMemberships.length; i+= 1) {
      assert.equal(teamMemberships.items[i].teamId, team.id);
    }
    return 'success';
  });
  // => success

▸ remove(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Deletes a membership by ID.

remove(membership: (TeamMembershipObject | string)): Promise

Parameters

membership ((TeamMembershipObject | string))

Returns

Promise:

Example

var membership, team;
webex.teams.create({name: 'Remove Team Memberships Example'})
  .then(function(t) {
    team = t;
    return webex.teamMemberships.create({
     personEmail: 'alice@example.com',
     teamId: team.id
    });
  })
  .then(function(m) {
    membership = m;
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 2);
    return webex.teamMemberships.remove(membership);
  })
  .then(function() {
    return webex.teamMemberships.list({teamId: team.id});
  })
  .then(function(teamMemberships) {
    var assert = require('assert');
    assert.equal(teamMemberships.length, 1);
    return 'success';
  });
  // => success

▸ update(membership)

packages/@webex/plugin-team-memberships/src/team-memberships.js

Updates properties for a membership.

update(membership: TeamMembershipObject): Promise<TeamMembershipObject>

Parameters

membership (TeamMembershipObject)

Returns

Promise<TeamMembershipObject>:

Webhooks

Webhooks allow your app to be notified via HTTP when a specific event occurs on Webex. For example, your app can register a webhook to be notified when a new message is posted into a specific room.

new Webhooks()

Instance Members

▸ create(webhook)

Posts a webhook.

create(webhook: WebhookObject): Promise<Webhook>

Parameters

webhook (WebhookObject)

Returns

Promise<Webhook>:

Example

webex.rooms.create({title: 'Create Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(webhook) {
    var assert = require('assert');
    assert(webhook.id);
    assert(webhook.resource);
    assert(webhook.event);
    assert(webhook.filter);
    assert(webhook.targetUrl);
    assert(webhook.name);
    return 'success';
  });
  // => success

▸ get(webhook)

Shows details for a webhook.

get(webhook: (Webhook | string)): Promise<Webhook>

Parameters

webhook ((Webhook | string))

Returns

Promise<Webhook>:

Example

var webhook;
webex.rooms.create({title: 'Get Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.get(webhook.id);
  })
  .then(function(webhook2) {
    var assert = require('assert');
    assert.deepEqual(webhook2, webhook);
    return 'success';
  });
  // => success

▸ list(options)

Lists all webhooks.

list(options: Object): Promise<Array<Webhook>>

Parameters

options (Object)

Name	Description
options.max `integer`	Limit the maximum number of webhooks in the response.

Returns

Promise<Array<Webhook>>:

Example

var room, webhook;
webex.rooms.create({title: 'List Webhooks Example'})
  .then(function(r) {
    room = r;
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.list();
  })
  .then(function(webhooks) {
    var assert = require('assert');
    assert.equal(webhooks.items.filter(function(w) {
      return w.id === webhook.id;
    }).length, 1);
    return 'success';
  });
  // => success

▸ remove(webhook)

Delete a webhook.

remove(webhook: (Webhook | string)): Promise

Parameters

webhook ((Webhook | string))

Returns

Promise:

Example

var room, webhook;
webex.rooms.create({title: 'Remove Webhook Example'})
  .then(function(r) {
    room = r;
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    return webex.webhooks.remove(webhook);
  })
  .then(function() {
    return webex.webhooks.list();
  })
  .then(function(webhooks) {
    var assert = require('assert');
    assert.equal(webhooks.items.filter(function(w) {
      return w.id === webhook.id;
    }).length, 0);
    return 'success';
  });
  // => success

▸ update(webhook)

Update a webhook.

update(webhook: Webhook): Promise<Webhook>

Parameters

webhook (Webhook)

Returns

Promise<Webhook>:

Example

var webhook;
webex.rooms.create({title: 'Webhook Example'})
  .then(function(room) {
    return webex.webhooks.create({
      resource: 'messages',
      event: 'created',
      filter: 'roomId=' + room.id,
      targetUrl: 'https://example.com/webhook',
      name: 'Test Webhook'
    });
  })
  .then(function(w) {
    webhook = w;
    webhook.targetUrl = 'https://example.com/webhook/newtarget';
    return webex.webhooks.update(webhook);
  })
  .then(function() {
    return webex.webhooks.get(webhook);
  })
  .then(function(webhook) {
    var assert = require('assert');
    assert.equal(webhook.targetUrl, 'https://example.com/webhook/newtarget');
    return 'success';
  });
  // => success

Logging

Logger

packages/@webex/plugin-logger/src/logger.js

new Logger()

Instance Members

▸ formatLogs()

packages/@webex/plugin-logger/src/logger.js

Format logs (for upload)

If separate client, SDK buffers is configured, merge the buffers, if configured

formatLogs(): string

Returns

string: formatted buffer

LoggerConfig

packages/@webex/plugin-logger/src/config.js

LoggerConfig

Type: Object

Properties

historyLength (number?) : Maximum number of entries to store in the log buffer.

Example

{
  level: process.env.WEBEX_LOG_LEVEL,
  historyLength: 1000
}

Types

The following typedefs describes the responses of the various API calls.

MembershipObject

packages/@webex/plugin-memberships/src/memberships.js

MembershipObject

Type: Object

Properties

id (string) : Unique identifier for the membership

roomId (string) : The room ID

personId (string) : The person ID

personEmail (email) : The email address of the person / room member

isModerator (boolean) : Indicates whether the specified person should be a room moderator

isMonitor (boolean) : Indicates whether the specified member is a room monitor

created (isoDate) : The date and time that this membership was created

MessageObject

MessageObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the message

personId (string) : The ID for the author of the message

personEmail (email) : The email for the author of the message

roomId (string) : The ID for the room of the message

text (string) : The message posted to the room in plain text

markdown (string) : The message posted to the room in markdown

files (Array<string>) : The source URL(s) for the message attachment(s). See the Message Attachments Guide for a list of supported media types.

created (isoDate) : (server generated) The date and time that the message was created

PersonObject

packages/@webex/plugin-people/src/people.js

PersonObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the person

emails (Array<email>) : Email addresses of the person

displayName (string) : Display name of the person

created (isoDate) : (server generated) The date and time that the person was created

RoomObject

packages/@webex/plugin-rooms/src/rooms.js

RoomObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the room

title (string) : The display name for the room. All room members will see the title so make it something good

teamId (string) : (optional) The ID of the team to which the room belongs

created (isoDate) : (server generated) The date and time that the room was created

TeamObject

packages/@webex/plugin-teams/src/teams.js

TeamObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the team

name (string) : The name of the team

created (isoDate) : (server generated) The date and time that the team was created

TeamMembershipObject

packages/@webex/plugin-team-memberships/src/team-memberships.js

TeamMembershipObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the team membership

teamId (string) : The team ID

personId (string) : The person ID

personEmail (string) : The email address of the person

isModerator (boolean) : Set to true to make the person a team moderator

created (string) : (server generated) The date and time that the team membership was created

WebhookObject

WebhookObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the webhook

resource (string) : The resource type for the webhook

event (string) : The event type for the webhook

filter (string) : The filter that defines the webhook scope

targetUrl (string) : The URL that receives POST requests for each event

name (string) : A user-friendly name for this webhook

created (string) : (server generated) The date and time that the webhook was created

email

packages/webex/src/index.js

An email address, as a string.

Type: string

isoDate

packages/webex/src/index.js

The date and time, specified in ISO 8601 extended offset date/time format (e.g. 2015-10-18T14:26:16+00:00).

isoDate

Type: string

AttachmentActionObject

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

AttachmentActionObject

Type: Object

Properties

id (string) : (server generated) Unique identifier for the attachment action

messageId (string) : The ID of the message in which attachment action is to be performed

type (string) : The type of attachment action eg., submit

inputs (Object) : The inputs for form fields in attachment message

personId (string) : (server generated) The ID for the author of the attachment action

roomId (string) : (server generated) The ID for the room of the message

created (isoDate) : (server generated) The date and time that the message was created

AttachmentActions

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

AttachmentActions are events that communicate information when a user clicks on an Action.Submit button in a card displayed in Webex Information conveyed in an AttachmentAction includes details about the user that clicked the button along with any card specific inputs. See the Attachments Actions API Documentation for more details

new AttachmentActions()

Instance Members

▸ create(attachmentAction)

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

Post a new attachment action for a message with attachment.

create(attachmentAction: AttachmentActionObject): Promise<AttachmentActionObject>

Parameters

attachmentAction (AttachmentActionObject)

Returns

Promise<AttachmentActionObject>:

Example

webex.rooms.create({title: 'Create Message with card Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id,
      attachments:[ {
         contentType: 'application/vnd.microsoft.card.adaptive',
        content: {
          type: 'AdaptiveCard',
          version: '1.0',
          body: [
           {
            type: 'TextBlock',
            text: '',
            size: 'large'
            },
          {
            type: 'TextBlock',
            text: 'Adaptive Cards',
            separation: 'none'
          }
          {
          type: 'Input.Date',
          id: 'dueDate'
          }
      ],
    actions: [
        {
            type: 'Action.Submit',
            title: 'Due Date'
        }
    ]
  }
 }]
    });
  })
  .then(function(message) {
   return webex.attachmentActions.create({
     type: 'submit',
     messageId: message.id,
     inputs:{
       dueDate: '26/06/1995'
     }
   })
   .then(function(attachmentAction)){
     var assert = require('assert');
     assert(attachmentAction.id);
     assert(attachmentAction.type);
     assert(attachmentAction.personId);
     assert(attachmentAction.inputs);
     assert(attachmentAction.messageId);
     assert(attachmentAction.roomId);
     assert(attachmentAction.created);
     return 'success';
    }
  });
  // => success

▸ get(attachmentAction)

packages/@webex/plugin-attachment-actions/src/attachmentActions.js

Returns a single attachment action.

get(attachmentAction: string): Promise<AttachmentActionObject>

Parameters

attachmentAction (string)

Returns

Promise<AttachmentActionObject>:

Example

var attachmentAction;
webex.rooms.create({title: 'Get Message Example'})
  .then(function(room) {
    return webex.messages.create({
      text: 'Howdy!',
      roomId: room.id,
      attachments:[ {
         contentType: 'application/vnd.microsoft.card.adaptive',
        content: {
          type: 'AdaptiveCard',
          version: '1.0',
          body: [
           {
            type: 'TextBlock',
            text: '',
            size: 'large'
            },
          {
            type: 'TextBlock',
            text: 'Adaptive Cards',
            separation: 'none'
          },
          {
          type: 'Input.Date',
          id: 'dueDate'
          }
      ],
    actions: [
        {
            type: 'Action.Submit',
            title: 'Due Date'
        }
    ]
  }
 }]
    });
  })
  .then(function(message) {
    return webex.attachmentActions.create({
     type: 'submit',
     messageId: message.id,
     inputs:{
       dueDate: '26/06/1995'
     });
  })
  .then(function(attachmentAction) {
    return webex.attachmentActions.get(attachmentAction.id)
  })
   .then(function(attachmentAction){
       var assert = require('assert');
       assert.deepEqual(attachmentAction, attachmentAction);
       return 'success';
     })
  // => success

getAll

packages/@webex/plugin-device-manager/src/device-manager.js

Gets a list of all recent devices associated with the user the device list gets populated from Redis

getAll(): Promise<Device>

Returns

Promise<Device>:

refresh

packages/@webex/plugin-device-manager/src/device-manager.js

Gets a list of all recent devices associated with the user the device list gets populated from Redis

refresh(): Promise<Device>

Returns

Promise<Device>:

search

packages/@webex/plugin-device-manager/src/device-manager.js

Search for a device by name

search(options: Object): Promise<Device>

Parameters

options (Object)

Name	Description
options.searchQuery `string`

Returns

Promise<Device>:

upsert

packages/@webex/plugin-device-manager/src/device-manager.js

Caches the device info and also registers to Redis for subsequent fetches

upsert(device: Object): deviceInfo

Parameters

device (Object)

Name	Description
device.id `string`

Returns

deviceInfo:

get

packages/@webex/plugin-device-manager/src/device-manager.js

Retreives device info of a particular device

get(token: string): Promise<deviceInfo>

Parameters

token (string)

Returns

Promise<deviceInfo>:

remove

packages/@webex/plugin-device-manager/src/device-manager.js

Unregisters the device from Redis, will not fetch in subsequent loads, similar to space.deleteBinding()

remove(deviceId: string): Promise<deviceInfo>

Parameters

deviceId (string)

Returns

Promise<deviceInfo>:

requestPin

packages/@webex/plugin-device-manager/src/device-manager.js

Requests to display PIN on the device

requestPin(device: object, options: object): Promise<deviceInfo>

Parameters

device (object)

options

(object
            = {})

Name	Description
options.data `object`

Returns

Promise<deviceInfo>:

pair

packages/@webex/plugin-device-manager/src/device-manager.js

pairs the device with the user (manual pairing), also adds it to user's recents list for subsequent fetches. similar to space.join()

pair(options: object): Promise<deviceInfo>

Parameters

options

(object
            = {})

Name	Description
options.pin `number`

Returns

Promise<deviceInfo>:

unpair

packages/@webex/plugin-device-manager/src/device-manager.js

unpairs the device with the user (manual/ultrasonic pairing), but still keeps in the recents list/does not remove from Redis options.removeAllDevices will remove all associated devices to user similar to space.leave()

unpair(options: object): Promise<deviceInfo>

Parameters

options

(object
            = {})

Name	Description
options.removeAllDevices `boolean`

Returns

Promise<deviceInfo>:

bindSpace

packages/@webex/plugin-device-manager/src/device-manager.js

binds the space to the paired device (if supported) similar to space.bindConversation()

bindSpace(options: object): Promise<deviceInfo>

Parameters

options

(object
            = {})

Name	Description
options.url `boolean`	, conversation url
options.kmsResourceObjectUrl `boolean`	of the convo

Returns

Promise<deviceInfo>:

unbindSpace

packages/@webex/plugin-device-manager/src/device-manager.js

unbinds the space to the paired device (if supported) similar to space.unbindConversation()

unbindSpace(): Promise<deviceInfo>

Returns

Promise<deviceInfo>:

getAudioState

packages/@webex/plugin-device-manager/src/device-manager.js

Gets the audio state of the paired device similar to device.getAudioState()

getAudioState(): Promise<audioState>

Returns

Promise<audioState>:

putAudioState

packages/@webex/plugin-device-manager/src/device-manager.js

Updates audio state of the paired device, should be called every 10 minutes or when mic or volume state is changed similar to device.putAudioState()

putAudioState(space: object, audioState: object): Promise<audioState>

Parameters

space (object)

audioState

(object
            = {})

Returns

Promise<audioState>:

mute

packages/@webex/plugin-device-manager/src/device-manager.js

Mutes paired device similar to device.mute()

mute(): Promise<audioState>

Returns

Promise<audioState>:

unmute

packages/@webex/plugin-device-manager/src/device-manager.js

Unmutes paired device similar to device.unmute()

unmute(): Promise<audioState>

Returns

Promise<audioState>:

increaseVolume

packages/@webex/plugin-device-manager/src/device-manager.js

Increases paired device's volume similar to device.increaseVolume()

increaseVolume(): Promise<audioState>

Returns

Promise<audioState>:

decreaseVolume

packages/@webex/plugin-device-manager/src/device-manager.js

Decreases paired device's volume similar to device.decreaseVolume()

decreaseVolume(): Promise<audioState>

Returns

Promise<audioState>:

setVolume

packages/@webex/plugin-device-manager/src/device-manager.js

Sets paired device's volume but should use increase and decrease api instead similar to device.setVolume()

setVolume(level: number): Promise<audioState>

Parameters

level

(number
            = 0)

Returns

Promise<audioState>:

_updateDeviceMetadata

packages/@webex/plugin-device-manager/src/device-manager.js

Utility function to update decrypted device name on device object

_updateDeviceMetadata(deviceArray: Array): device

Parameters

deviceArray

(Array
            = [])

Returns

device:

_decryptDeviceName

packages/@webex/plugin-device-manager/src/device-manager.js

Utility function to update decrypted device name on device object

_decryptDeviceName(inDevice: object): device

Parameters

inDevice

(object
            = {})

Returns

device:

_receiveDeviceUpdates

packages/@webex/plugin-device-manager/src/device-manager.js

Utility function to update device info on mercury updates

_receiveDeviceUpdates(device: object): device

Parameters

device (object)

Returns

device:

Metrics

packages/@webex/plugin-meetings/src/metrics/index.ts

Metrics handles all the call metrics events

new Metrics()

Static Members

▸ initMediaPayload(eventType, identifiers, options)

packages/@webex/plugin-meetings/src/metrics/index.ts

get the payload specific for a media quality event through call analyzer

initMediaPayload(eventType: String, identifiers: Object, options: Object): Object

Parameters

eventType (String) the event name

identifiers (Object) contains the identifiers needed for CA

Name	Description
identifiers.correlationId `String`
identifiers.locusUrl `String`
identifiers.locusId `String`

options

(Object
            = {})

Name	Description
options.intervalData `Object`
options.clientType `String`

Returns

Object:

Instance Members

▸ initialSetup(meetingCollection, webex)

packages/@webex/plugin-meetings/src/metrics/index.ts

Initializes the Metrics singleton with a meeting Collection.

initialSetup(meetingCollection: Object, webex: Object): void

Parameters

meetingCollection (Object) meetings object

webex (Object) webex SDK object

Returns

void:

▸ postEvent(options)

packages/@webex/plugin-meetings/src/metrics/index.ts

poste Meeting event metrics

postEvent(options: object): object

Parameters

options (object) {meetingId/meeting} as a json object

Name	Description
options.meeting `Meeting`	Meeting object
options.meetingId `String`
options.data `object`
options.event `object`

Returns

object: null

▸ initPayload(eventType, identifiers, options)

packages/@webex/plugin-meetings/src/metrics/index.ts

Docs for Call analyzer metrics https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml

initPayload(eventType: any, identifiers: any, options: any)

Parameters

eventType (any)

identifiers (any)

options (any)

▸ parseLocusError(err, showToUser)

packages/@webex/plugin-meetings/src/metrics/index.ts

This function Parses a Locus error and returns a diagnostic event payload. It should keep updating from: https://sqbu-github.cisco.com/WebExSquared/spark-client-framework/blob/master/spark-client-framework/Adapters/TelephonyAdapter/TelephonyAdapter.cpp#L920

parseLocusError(err: Object, showToUser: boolean): {showToUser: boolean, category: string, errorDescription: string, errorCode: number, errorData: any, fatal: boolean, name: string}

Parameters

err (Object) the error Object from Locus response

showToUser (boolean) true if a toast is shown to user

Returns

{showToUser: boolean, category: string, errorDescription: string, errorCode: number, errorData: any, fatal: boolean, name: string}

▸ userAgentToString()

packages/@webex/plugin-meetings/src/metrics/index.ts

Returns a formated string of the user agent.

userAgentToString(): string

Returns

string: formatted user agent information

▸ sendBehavioralMetric(metricName, metricFields, metricTags)

packages/@webex/plugin-meetings/src/metrics/index.ts

Uploads given metric to the Metrics service as an Behavioral metric. Metadata about the environment such as browser, OS, SDK and their versions are automatically added when the metric is sent.

The Metrics service will send an Behavioral metric to InfluxDB for aggregation. See https://confluence-eng-gpk2.cisco.com/conf/display/WBXT/Getting+started+with+Metrics+Service.

sendBehavioralMetric(metricName: string, metricFields: Object, metricTags: Object): void

Parameters

metricName (string) Name of the metric (measurement) to send

metricFields

(Object
            = {})

Key-valye pairs of data or values about this metric

metricTags

(Object
            = {})

Key-value pairs of metric metadata

Returns

void:

LogsRequest

packages/@webex/plugin-meetings/src/common/logs/request.ts

new LogsRequest()

Static Members

▸ uploadLogs(options)

packages/@webex/plugin-meetings/src/common/logs/request.ts

Uploads logs to the support server

uploadLogs(options: Object): Promise<String>

Parameters

options

(Object
            = {})

Name	Description
options.feedbackId `String` (default `uuid.v4`)	ID used for tracking
options.locusId `String?`
options.correlationId `String?`
options.callStart `String?`	Call Start Time
options.meetingId `String?`	webex meeting ID

Returns

Promise<String>: Feedback ID

MediaDirection

MediaDirection

Type: Object

Properties

sendAudio (boolean)

receiveAudio (boolean)

sendVideo (boolean)

receiveVideo (boolean)

sendShare (boolean)

receiveShare (boolean)

MediaDirection

packages/@webex/plugin-meetings/src/meeting/index.ts

MediaDirection

Type: Object

Properties

sendAudio (boolean)

receiveAudio (boolean)

sendVideo (boolean)

receiveVideo (boolean)

sendShare (boolean)

receiveShare (boolean)

isSharing (boolean)

SendOptions

SendOptions

Type: Object

Properties

sharePreferences (Object)

SendOptions

packages/@webex/plugin-meetings/src/meeting/index.ts

SendOptions

Type: Object

Properties

sendAudio (Boolean)

sendVideo (Boolean)

sendShare (Boolean)

Media

Media

Type: any

Static Members

▸ setLocalTrack(enabled, track)

setLocalTrack(enabled: boolean, track: MediaStreamTrack): Boolean

Parameters

enabled (boolean)

track (MediaStreamTrack)

Returns

Boolean:

▸ reconnectMedia(peerConnection, meetingProperties)

reconnectMedia(peerConnection: RTCPeerConnection, meetingProperties: Object): Promise

Parameters

peerConnection (RTCPeerConnection)

meetingProperties (Object)

Name	Description
meetingProperties.meetingId `string`
meetingProperties.remoteQualityLevel `string`	LOW\|MEDIUM\|HIGH
meetingProperties.enableRtx `any`
meetingProperties.enableExtmap `any`

Returns

Promise:

▸ generateLocalMedias(mediaId, audioMuted, videoMuted)

format the media array for send

generateLocalMedias(mediaId: String, audioMuted: Boolean, videoMuted: Boolean): Array

Parameters

mediaId (String)

audioMuted (Boolean)

videoMuted (Boolean)

Returns

Array: medias

▸ getLocalMedia(options, config)

make a browser call to get the media

getLocalMedia(options: SendOptions, config: Object): Promise

Parameters

options (SendOptions)

config (Object) SDK Configuration for meetings plugin

Returns

Promise:

▸ checkTracks(trackType, track, receiveTracks)

Returns the direction and tracks

checkTracks(trackType: string, track: object, receiveTracks: boolean): Object

Parameters

trackType (string) type of track (audio/video)

track (object) tracks passed

receiveTracks (boolean) do you want to receive tracks from the remote side

Returns

Object: returns direction tracks to be added in transceiver

▸ attachMedia(mediaProperties, meetingProperties)

creates peerconnection and attaches streams

attachMedia(mediaProperties: MediaDirection, meetingProperties: Object): Array

Parameters

mediaProperties (MediaDirection)

meetingProperties (Object)

Name	Description
meetingProperties.meetingId `string`
meetingProperties.remoteQualityLevel `string`	LOW\|MEDIUM\|HIGH
meetingProperties.enableRtx `any`
meetingProperties.enableExtmap `any`

Returns

Array: [peerConnection, ]

▸ updateMedia(mediaProperties, meetingProperties)

updates all the media streams and creates a new media offer

updateMedia(mediaProperties: MediaDirection, meetingProperties: Object): Promise

Parameters

mediaProperties (MediaDirection)

meetingProperties (Object)

Name	Description
meetingProperties.meetingId `string`
meetingProperties.remoteQualityLevel `string`	LOW\|MEDIUM\|HIGH
meetingProperties.enableRtx `any`
meetingProperties.enableExtmap `any`

Returns

Promise:

▸ setTrackOnTransceiver(transceiver, options)

setTrackOnTransceiver(transceiver: RTCRtpTransceiver, options: Object): undefined

Parameters

transceiver (RTCRtpTransceiver)

options (Object)

Name	Description
options.track `MediaStreamTrack`

Returns

undefined:

▸ updateTransceiver(meetingProperties, peerConnection, transceiver, options)

creates a new offer

updateTransceiver(meetingProperties: Object, peerConnection: RTCPeerConnection, transceiver: RTCRtpTransceiver, options: Object): Promise

Parameters

meetingProperties (Object)

Name	Description
meetingProperties.meetingId `string`
meetingProperties.remoteQualityLevel `string`	LOW\|MEDIUM\|HIGH
meetingProperties.enableRtx `any`
meetingProperties.enableExtmap `any`

peerConnection (RTCPeerConnection)

transceiver (RTCRtpTransceiver)

options (Object) see #Media.setTrackOnTransceiver

Returns

Promise:

▸ getDisplayMedia(options, config)

generates share streams

getDisplayMedia(options: Object, config: Object): Promise<MediaStream>

Parameters

options (Object) parameter

Name	Description
options.sendAudio `Boolean`	send audio from the display share
options.sendShare `Boolean`	send video from the display share
options.sharePreferences `Object`
options.sharePreferences.shareConstraints `MediaTrackConstraints`	constraints to apply to video
options.sharePreferences.highFrameRate `Boolean`	if shareConstraints isn't provided, set default values based off of this boolean

config

(Object
            = {})

SDK Configuration for meetings plugin

Returns

Promise<MediaStream>:

https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints

▸ getMedia(audio, video, config)

generates audio and video using constraints (often called after getSupportedDevices)

getMedia(audio: (Object | Boolean), video: (Object | Boolean), config: Object): Object

Parameters

audio ((Object | Boolean)) gum constraints

video ((Object | Boolean)) gum constraints

config (Object) SDK Configuration for meetings plugin

Returns

Object: {streams}

▸ getSupportedDevice(options?)

Checks if the machine has at least one audio or video device (Dont use this for screen share)

getSupportedDevice(options: object?): Object

Parameters

options (object?) { sendAudio: true/false, sendVideo: true/false }

Name	Description
options.sendAudio `any`
options.sendVideo `any`

Returns

Object: { sendAudio: true/false, sendVideo: true/false }

▸ getDevices()

proxy to browser navigator.mediaDevices.enumerateDevices()

getDevices(): Promise

Returns

Promise:

▸ toggleStream()

Toggle a specific stream noop as of now, does nothing

toggleStream(): null

Returns

null:

▸ stopTracks(track)

Stop input stream

stopTracks(track: MediaTrack): null

Parameters

track (MediaTrack) A media stream

Returns

null:

▸ stopStream(stream)

Stop input stream

stopStream(stream: Stream): null

Deprecated: after v1.89.3

Parameters

stream (Stream) A media stream

Returns

null:

▸ getUserMedia(mediaSetting, audioVideo, sharePreferences, config)