webex

Create a new Webex instance

Create a new Webex instance configured for your OAuth client

const webex = Webex.init({
  config: {
    credentials: {
      authorizationString: `<AUTHORIZATION URL FROM DEVELOPER PORTAL>`
    }
  }
});

Create a new Webex instance configured for a Bot

const webex = Webex.init({
  credentials: `<BOT TOKEN FROM DEVELOPER PORTAL>`
});

Alias of AuthorizationBrowser#isAuthorizing

Type: boolean

Indicates if an Authorization Code exchange is inflight

Type: boolean

Kicks off an oauth flow

Kicks off the Authorization Code grant flow. Typically called via AuthorizationBrowser#initiateLogin

Kicks off the Implicit Code grant flow. Typically called via AuthorizationBrowser#initiateLogin

Requests a Webex access token for a user already authenticated into your product.

Note: You'll need to supply a jwtRefreshCallback of the form Promise<jwt> = jwtRefreshCallback(webex) for automatic token refresh to work.

Called by WebexCore#logout(). Redirects to the logout page

Alias of AuthorizationNode#isAuthorizing

Type: boolean

Indicates if an Authorization Code exchange is inflight

Type: boolean

Exchanges an authorization code for an access token

Requests a Webex access token for a user already authenticated into your product.

Note: You'll need to supply a jwtRefreshCallback of the form Promise<jwt> = jwtRefreshCallback(webex) for automatic token refresh to work.

Explicitly sets up the meetings plugin by registering the device, connecting to mercury, and listening for locus events.

Explicitly tears down the meetings plugin by deregistering the device, disconnecting from mercury, and stops listening to locus events

initializes the reachability instance for Meetings

gets the reachability instance for Meetings

initializes and starts gathering reachability for Meetings

gets the personal meeting room instance, for saved PMR values for this user

Create a meeting.

get a specifc meeting given it's type matched to the value, i.e., locus url

Get all meetings.

syncs all the meeting from server

Get all scheduled meetings.

Get the Stats Analyzer singleton

Get the Stats Calculator singleton

Checks if the machine has at least one audio or video device

Get the devices from the Media module

The PersonalMeetingRoom object to interact with server

Type: Object

If the meetings plugin has been registered and listening via Meetings#register

Type: Boolean

Uploads logs to the webex services for tracking

Get the logger instance for plugin-meetings

The property name for what collection will be stored, i.e., this.meetingInfos, this.meetings, etc.

Type: String

The actual object for the collection

Type: Object

Meetings Ready Event Emitted when the meetings instance on webex is ready

Meetings Network Disconnected Event Emitted when the meetings instance is disconnected from the internal mercury server

Meetings Registered Event Emitted when the meetings instance has been registered and listening

Meeting Removed Event Emitted when a meeting was removed from the cache of meetings

Type: Object

Meeting Added Event Emitted when a meeting was added to the cache of meetings

Type: Object

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.

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 equivelent 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');

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.

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

Returns a single membership.

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

Returns a list of memberships. In most cases the results will only contain rooms that the authentiated 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.

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

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.

Deletes a single membership.

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

Used to update a single membership's properties

// 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

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.

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.

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');

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.

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');

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

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

Returns a single message.

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

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

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

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.

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

Returns a single person by ID

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

Returns a list of people

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

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.

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');

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.

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

Returns a single room.

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

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

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

Returns a list of rooms with details about the data of the last actvity 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 considerd 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. Reccomended 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 andle 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.

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

For rooms where lastActivityDate > lastSeenDate the room can be considerd 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.

Deletes a single room.

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

Used to update a single room's properties.

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

Create a new team.

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

Returns a single team

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 teams.

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 a team.

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

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

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 details for a membership by ID.

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

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

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

Deletes a membership by ID.

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

Updates properties for a membership.

Posts a webhook.

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

Shows details for a webhook.

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

Lists all webhooks.

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

Delete a webhook.

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 a webhook.

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

Format logs (for upload)

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

Post a new attachment action for a message with attachment.

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

Returns a single attachment action.

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

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

Initializes the Metrics singleton with a meeting Collection.

poste Meeting event metrics

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

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

Returns a formated string of the user agent.

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.

Uploads logs to the support server

format the media array for send

make a browser call to get the media

Returns the direction and tracks

creates peerconnection and attaches streams

updates all the media streams and creates a new media offer

creates a new offer

generates share streams

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

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

proxy to browser navigator.mediaDevices.enumerateDevices()

Toggle a specific stream noop as of now, does nothing

Stop input stream

Stop input stream

generates streams for audio video and share

makes sure the screen pc sdp has content:slides for server

handles ice trickling and establishes ICE connection onto peer connection object

swapping tracks

adding streams to peerConnection

setting the remote description

create offer with a valid paramater

rollBack local description in peerconnection

shut down the peer connection