Meetings

Meetings enable teamspace members and other invitees to share documents and engage in other common business pursuits through a web-based interface.

The Collaboration API contains elements that developers can use to create, access, and manage meetings from within FileNet P8 applications. Key meeting elements are:

Meetings Fundamentals

A meeting comprises the following basic information:

When this information is assembled into a MeetingInfo object and passed to a FolderContainer object, a meeting is established and an email notification containing all pertinent details about the meeting is automatically issued to all participants.

At any point before it is scheduled to begin, a meeting may be canceled or any of its properties modified by the host member. Email is issued to all participants when any change to the meeting (scheduling, goal, or agenda) occurs. Email is also automatically issued to members invited to the meeting or removed from the participants list after the original scheduling. For more information on email notifications, see Subscriptions.

The host member starts a meeting at its scheduled time with a call to the Meeting object's getLink method. This method returns a "meeting start" URL, retrieved from a Collaboration Store file, which, when invoked, launches and provides credentials (if necessary) to the web-based application in which the meeting is to be conducted. Any non-host member participant can start the meeting, but must instead call the getStartLink method. After a meeting is started, participants gain access to the meeting by calling getAttendLink (host member only) or getLink (for all other members) and invoking the returned "meeting attend" URL.

Meetings continue until the specified duration (ending time less start time) is met or all participants exit the meeting application.

MeetingSession objects may be created to store information about completed meetings, including any followup meetings that may be scheduled from existing Meeting objects.

Meeting Containment

Meeting data is stored and maintained within a _meetings folder, a subfolder of a teamspace's _internal folder. The _meetings folder implements the FolderContainer interface (an extension of the Container interface) and is based on the containment capabilities of a Content Engine Folder object.

The meetings folder is accessed through any of the following ContainerManager methods:

A new Meeting object is created when a MeetingInfo object is passed to the FolderContainer object's addSubContainer method, as described below.

The Meeting Application

Among the data carried by the MeetingInfo object is a string reference to a collection of configurable data contained in the Collaboration Store file, Collaboration Meetings.xml. This file provides the Meeting object with information about the web application that will host the meeting. The following is a sample meetings definition document:

<?xml version="1.0" encoding="UTF-8"?>
<meetingdefs>
  <meetingdef>
  <defid>{FE45C6AB-FB89-4A88-9905-FDF3CAF3F973}</defid>
  <label>Vendor ABC Online Meeting</label>
  <description>This meeting definition supports ABC Online meetings</description>
  <meetingtype>online</meetingtype>
  <connectionaccessid>{FE45C6AB-FB89-4A88-9905-FDF3CAF3F972}</connectionaccessid>
  </meetingdef>
</meetingdefs>

If the MeetingInfo's meeting definition parameter is set to null, the Meeting object will be passed the first definition in Collaboration Meetings.xml.

To choose from multiple definitions in Collaboration Meetings.xml, you must first create a new MeetingStore object by calling the CollaborationStore's static getMeetingsStore method (providing it with a reference to the object store that contains your teamspace):

    MeetingStore meetingStore = CollaborationStore.getMeetingsStore (objectStore);

A MeetingDefinition object is then created through any of the MeetingsStore retrieval methods. Finally, through the MeetingDefinition object's getLabel method, the definition file's <label> text is passed to the MeetingInfo object. The MeetingsStore retrieval methods are:

Managing Participants

Individual or group attendees may be added to a meeting by passing a SubjectInfo object to the setParticipants method:

    meetingParticipantNames = new Vector();
    meetingParticipantNames.add("bill");
    meetingParticipantNames.add("betty");
    SubjectInfo meetingParticipants = meetingParticipantNames;
    meetingInfo.setParticipants(meetingParticipants);

Similarly, participants may be added or removed in a single call to the Meeting object's updateParticipants method:

    meetingAddParticipants = new Vector();
    meetingAddParticipants.add("joe");
    meetingRemoveParticipants.add("bill");
    SubjectInfo meetingAddedParticipants = meetingAddParticipants;
    SubjectInfo meetingRemovedParticipants = meetingRemoveParticipants;
    meetingInfo.setParticipants(meetingAddedParticipants, meetingRemoveParticipants);

Creating a Meeting

The following code describes how a Meeting object might be created in a known object store and teamspace. For information on teamspace objects, see Teamspaces; for information on creating and managing object stores, see the Content Java API topic, Working With Object Stores.

    // Locate a meeting definition (not required if the definition label value is known,
    // or if the default definition is to be used)
    MeetingsStore meetingsStore = CollaborationStore.getMeetingsStore(objectStore);
    Iterator meetingDefinitions = meetingsStore.getMeetingDefinitions().iterator();
    String definitionLabel = null;
    String targetConnectionID = "{FE45C6AB-FB89-4A88-9905-FDF3CAF3F972}";
    while (meetingDefinitions.hasNext())
    {
    meetingDefinition = (MeetingDefinition) meetingDefinitions.next();
    if ( meetingDefinition.getConnectionAccessId() == targetConnectionID )
      {
      definitionLabel = meetingDefinition.getLabel();
      }
    }
    // pass meeting definition and other basic meeting data to a MeetingInfo object
    MeetingInfo meetingInfo = new MeetingInfo(null, definitionLabel, teamSpace,
      startDateTime, endDateTime, purpose, agenda, hostID, inviteeIDs);
    ContainerManager containerManager = teamSpace.getContainerManager();
    FolderContainer meetingsContainer = (FolderContainer)
       containerManager.getContainerByDefinitionID (Collaboration.COLLABORATION_MEETINGS_CONTAINER_DEFID);
    Meeting meetingObject = meetingsContainer.addSubContainer(meetingInfo);

Creating a Meeting from an Existing Meeting

A new MeetingInfo object can also be created from an existing meeting in any teamspace. Characteristics of the MeetingInfo object can then be modified as needed to set up the new meeting:

    MeetingInfo meetingInfo = new MeetingInfo(existingMeetingObject);
    meetingInfo.setName("Q1 budget proposals");
    meetingInfo.setPurpose("To consider draft proposals");
    java.util.Date newStartDateTime = new java.util.Date(currentDateTime.getTime() + 1000000 );
    java.util.Date newEndDateTime = new java.util.Date(currentDateTime.getTime() + 1000000 + 400000 );
    meetingInfo.setStartDateTime(newStartDateTime);
    meetingInfo.setEndDateTime(newEndDateTime);
    //...

Updating Meetings

Meeting properties may be modified using a number of Meeting and MeetingInfo methods. Several of these are described above in Managing Participants and Creating a Meeting. Others include:

    // change the meeting start and end times (or set a new meeting duration)
    meetingObject.setDateTimes(Date newStartDateTime, Date newEndDateTime);

    // if a different user name and password is required
    // for the specified web-based application that will host the meeting,
    // use the setConnectionCredentials method, available in both the
    // Meeting and MeetingInfo classes:
    meetingInfo.setConnectionCredentials(newPassword, newUserName, saveCredentials);

    // to update specific properties using setProperties:
    Properties meetingProps = meetingObject.getProperties();
    Property meetingAgenda = meetingObject.getProperty(Property.AGENDA_SYMNAME);
    Property meetingPurpose = meetingObject.getProperty(Property.PURPOSE_SYMNAME);
    meetingAgenda.setValue("Q2 Budget");
    meetingPurpose.setValue("Consider budget proposals.");
    meetingProps.add(meetingAgenda);
    meetingProps.add(meetingPurpose);
    meetingObject.setProperties(meetingProps);

    // bulkUpdate(Map meetingPropsMap) is also available to update agenda,
    // start and end date/times, and meeting purpose:
    meetingPropsMap.put(Meeting.AGENDA_SYMNAME, strNewAgenda);
    meetingPropsMap.put(Meeting.STARTDATETIME_SYMNAME, dateUpdatedStartDateTime);
    meetingPropsMap.put(Meeting.ENDDATETIME_SYMNAME, dateUpdatedEndDateTime);
    meetingPropsMap.put(Meeting.PURPOSE_SYMNAME, strUpdatedPurpose);
    meetingObject.bulkUpdate(meetingPropsMap);

Retaining Meeting Properties

After creating a new Meeting object, you may want to retain and store certain identifying properties to ease the task of retrieving the meeting for starting, stopping, or performing other operations:

    String meetingID = meetingObject.getID();
    String meetingPurpose = meetingObject.getPurpose();
    String meetingSite = meetingObject.getDefinitionName();
    String meetingURL = meetingObject.getLink();
    String meetingStart = meetingObject.getStartDateTime();
    // or gather all properties of the meeting into a single list object:
    Properties meetingProps = meetingObject.getProperties();
    // to review the property names and values:
    Iterator itProps = meetingProps.iterator();
    while ( itProps.hasNext() )
    {
    Property meetingProp = (Property) itProps.next();
    String meetingProp.getName();
    Object objPropValue = meetingProp.getValue();
    }

Meeting Notifications

Whenever a meeting is created, modified, or deleted, an email message describing the action is automatically sent to all participants. The email message is constructed from templates stored in the Collaboration Store.

Email notifications (also constructed from provided templates) may also be issued to all participants at any point prior to the start of a meeting through the Meeting object's notifyParticipants method. The method takes one parameter, a notification type, which may be any of the following:

Retrieving a Meeting

To retrieve a Meeting object, first get the _meetings container (as described in Creating a Meeting), then either iterate through all available meetings or locate your meeting through a unique property:

    ContainerManager containerManager = teamSpace.getContainerManager();
    FolderContainer meetingsContainer = (FolderContainer)
    containerManager.getContainerByDefinitionID (Collaboration.COLLABORATION_MEETINGS_CONTAINER_DEFID);
    // either iterate through existing meetings...
    Iterator meetingObjects = meetingsContainer.getSubContainers().iterator();
    Meeting meetingObject = null;
    String meetingPurpose = "To consider draft proposals";
    while (meetingObjects.hasNext())
    {
    aMeetingObject = (Meeting) meetingObjects.next();
    if ( aMeetingObject.getPurpose() == meetingPurpose )
      {
      meetingObject = aMeetingObject;
      }
    }
    // ...or locate the meeting through a unique property (such as its ID):
    // Meeting meetingObject = (Meeting) meetingsContainer.findContaineeByID("{9999999-8888-7777-6666-555555555555}");

Starting and Attending Meetings

Meeting commencement or attendance by all participants except the host member is handled by the Meeting object's getLink method. The host member requires different methods for the two operations: getStartLink and getAttendLink.

All three methods return the same value: An automatically-constructed URL to the web-based application that will host the meeting.

Canceling or Deleting Meetings

Meetings may be canceled at any point prior to commencement by calling the Meeting object's cancel method. Email is automatically issued to all participants. Canceled meetings may be rescheduled.

To remove a meeting, call the Meeting object's delete method. Deleting a meeting automatically removes the meeting subcontainer and all containees associated with the meeting, including the MeetingSession object.

Meeting Sessions

MeetingSession objects are created for the purpose of retaining and allowing examination of such session information as agenda, attendee IDs, and the start and end times of concluded meetings. MeetingSession objects may be created at the conclusion of each meeting, and are stored as containees of the specified meeting. Session information is automatically deleted when its parent meeting is deleted.

To create a MeetingSession object, use the addContainee method of the retrieved Meeting object:

	MeetingSession meetingSession = meetingObject.addContainee(null); 

A MeetingSession object may be retrieved by iterating through a Meeting object's containees:

    Iterator meetingContainees = meetingObject.getContainees().iterator();
    MeetingSession meetingSession = null;
    while (meetingContainees.hasNext())
    {
    thisContainee = meetingContainees.next();
    if ( aContainee.getType() == Collaboration.TYPE_MEETINGSESSION )
      {
      meetingSession = thisContainee;
      }
    }
    // ...or locate the meeting session through a unique property (such as the ID) of its containing meeting:
    // MeetingSession meetingSession = meetingObject.findContaineeByID("{9999999-8888-7777-6666-555555555555}");

Additional Information

For information on how meetings are created and managed within the FileNet P8 TCM application, see Overview of Meetings.