Package wt.team

See:
Description

Interface Summary

ActorRoleHolder2	ActorRoleHolder2 is an interface for classes implementing role to actor role mappings Supported API: false Extendable: false
IndirectRoleHolder2	Supported API: false Extendable: false
RoleHolder2	RoleHolder is an interface for classes implementing role to principal mappings Supported API: true Extendable: false
TeamManaged	TeamManaged interface objects will get a TeamId attribute.
TeamService	TeamService provides client invokable methods to team services.
TeamServiceSvr	These methods are can only be invoked from classes running in the server.

Class Summary

ChangeNonUniqueTeamNames	The algorithm is as follows to change the duplicate team names from the Team table.
LoadTeam	This class is used by wt.load.StandardLoadService to create objects for classes in the wt.team package.
MigrateProjectToTeamObject	[5/6/2003 Susan Li]: Modify this migrator for 7.0: 1.
MigrateTeamAndTemplate_R62To70	In 6.2 TeamTemplate is unique by name and domain.
RoleActorRoleLink	Use the newRoleActorRoleLink static factory method(s), not the RoleActorRoleLink constructor, to construct instances of this class.
RoleActorRoleMap	Use the newRoleActorRoleMap static factory method(s), not the RoleActorRoleMap constructor, to construct instances of this class.
RolePoolLink	Use the newRolePoolLink static factory method(s), not the RolePoolLink constructor, to construct instances of this class.
RolePoolMap	Use the newRolePoolMap static factory method(s), not the RolePoolMap constructor, to construct instances of this class.
RolePrincipalLink	Use the newRolePrincipalLink static factory method(s), not the RolePrincipalLink constructor, to construct instances of this class.
RolePrincipalMap	Use the newRolePrincipalMap static factory method(s), not the RolePrincipalMap constructor, to construct instances of this class.
RoleRoleLink	Use the newRoleRoleLink static factory method(s), not the RoleRoleLink constructor, to construct instances of this class.
RoleRoleMap	Use the newRoleRoleMap static factory method(s), not the RoleRoleMap constructor, to construct instances of this class.
StandardTeamService	Standard implementation of the team service interfaces.
StandardTeamService.TeamTemplateFlusher
Team	Use the newTeam static factory method(s), not the Team constructor, to construct instances of this class.
TeamCache	This class implements a Team cache service.
TeamCategory	TeamCategory is a specialization of EnumeratedType to provide localizable team category names The localized values for team categories are maintained in a resource bundle RoleRB, and its locale derivatives
TeamDistributionList	Use the newTeamDistributionList static factory method(s), not the TeamDistributionList constructor, to construct instances of this class.
TeamDistributionListIdentity	Enforces the uniqueness constraint for TeamDistributionList
TeamDistributionListReference	TeamDistributionList is a specialization of CachedObjectReference to provide type safe references and access to the name/identity attribute without instantiating the object.
TeamDistributionListReferenceSearch	Search for a reference to the TeamDistributionList listed.
TeamHelper	TeamHelper provides client invokable meethods to team services.
TeamIdentity	Enforces the uniqueness constraint for Team.
TeamReference	TeamReference is a specialization of CachedObjectReference to provide type safe references and access to the name/identity attribute without instantiating the object.
TeamReferenceSearch	Search for a reference to the Team listed.
TeamRoleHolderProcessorService	When executed from a class that extends BasicTemplateProcessor, these script call can be invoked by using the 'useProcessorService service = ' html template entry.
TeamSequence	Supported API: false Extendable: false
TeamServerHelper	Provides server side access to the methods of the TeamServiceSvr interface.
TeamServiceEvent	Provides a service specific event extended from KeyedEvent used in conjunction with the standard implementation of the server-side functionality as defined by the TeamService interface.
TeamServiceFwd	TeamService provides client invokable methods to team services.
TeamTemplate	TeamTemplate establishes associations between roles and principals and/or actor roles.
TeamTemplateCache	This class implements a TeamTemplate cache service.
TeamTemplateCache.CachedTeamTemplates
TeamTemplateCache.TeamTemplateCacheReporter
TeamTemplateCache.TeamTemplateEntry
TeamTemplateCache.UpdateMessage
TeamTemplateIdentity	Enforces the uniqueness constraint for TeamTemplate.
TeamTemplateLink	Use the newTeamTemplateLink static factory method(s), not the TeamTemplateLink constructor, to construct instances of this class.
TeamTemplateReference	TeamTemplateReference is a specialization of CachedObjectReference to provide type safe references and access to the name/identity attribute without instantiating the object.
TeamTemplateReferenceSearch	Search for a reference to the TeamTemplate listed.
WTActorRoleHolder2	Supported API: true Extendable: false
WTIndirectRoleHolder2	Supported API: false Extendable: false
WTRoleHolder2	Supported API: true Extendable: false

Exception Summary

TeamException

Provides an abstraction of an abnormal occurrence or error in the usage or processing of the TeamService.

Package wt.team Description

Team Management Service

The Team Managed Service provides the ability to create roleholders that map participants to roles. This package provides TeamTemplates and Teams that are used by the Windchill System to manage participation in Workflows and Life cycles.

Design Overview

The team service is designed to be a plug-and-play component in the Windchill system and is intended to be used for both client and server development. Business objects, asserted as being TeamManaged and Advanced Lifecycle Managed have a team created for it and assigned to it during the PRE_STORE event processing.

External Interface

TeamManaged

The TeamManaged interface provides an abstraction of a plug-and-play

component. The intent is that, in an object model, a business object would assert

that it is TeamManaged by inheriting (that is, it implements) the

TeamManaged interface. With this assertion, the business object can have an association to a team template and team.

TeamHelper

The TeamHelper provides an abstraction as the API to the team service.

The API’s methods can be categorized as either local or remote invocations. The

local methods are getters of information. The remote methods serve as wrappers to a service that

promotes server-side functionality.

TeamServerHelper

The TeamServerHelper provides an abstraction of the server-side API to the

team services. These methods can be invoked only from server-side

processing.

TeamCycleService

The TeamService provides an abstraction that specifies and promotes server side

functionality as a service that is remotely available for use by a client. This

interface is intended to define all the necessary server-side functionality for team management.

TeamServiceEvent

The TeamServiceEvent provides an abstraction of a specialized keyed event

used by the team service to signal other services that something has occurred.

This gives other services in a plug-and-play architecture the opportunity to act

accordingly upon these events. Validation, vetoing, and post-processing are

typical reactions to events.

The team service emits the following event:

RETEAM

The reteam event is emitted whenever the reteam API is called. The reteam API reassigns the team template of the object and re-resolves the team membership.

TeamException

The TeamException provides an abstraction of an abnormal occurrence or

error in the usage or processing of the team service. This exception can be

localized through a given resource bundle, and other exceptions can be nested

within it.

Event Processing

The team service is an event listener. The service listens for and acts upon the

following standard Windchill events:

CLEANUP_LINK

When a CLEANUP_LINK event is emitted for a team link object, the associated objects are cleaned up in the database.

REPLACE_MEMBER

When a REPLACE_MEMBER event is emitted, any role-principal mappings for the user in the container and associated teams are reassigned to the new user.

PRE_CHANGE_DOMAIN

When a PRE_CHANGE_DOMAIN event is emitted for Windchill PDM, the objects team is moved to the new domain of the object.

PRE_DELETE

When a PRE_DELETE event is emitted for Windchill PDM, the team associated to the object is deleted if it is not shared by another team managed (excluding workflow processes) object.

The roleholders provide a way to map role-principals, role-actor role and role-role mappings for an object. This package provides roleholders that are used by advanced life cycle managed objects, workflow and life cycle.

Team Template: The team template is a WTActorRoleHolder2. This means it can have role-principal mappings and role-actor role mappings. It is used out of the box as a template to create a team instance that is used by lifecycle and workflow to determine participants for a particular role.

Team: The team is a WTRoleHolder2. This means it can only have role-principal mappings. During the PRE_STORE processing, advanced life cycle managed objects will have a team created and assigned to it if the object is not already assigned to a team.

Role resolution: When the team is created, the team is resolved from the team template and life cycle phase template roles. In the case of PDMLink, the context team role members are also added to the team. Team template role mappings take precedence over the lifecycle phase template roles. That is, if a role exists in both, only the team template membership will be resolved into the team.

Example: An object is created by Mary. Here are the role mappings for the team template, phase template and the resulting team.

Role	Team Template	Phase Template	Team
Reviewer	Tom, Dick, Jane	----	Tom, Dick, Jane
Change Owner	---	Reviwer	Tom, Dick, Jane
Designer	Creator Actor Role	Change Owner	Mary

Multi Object API’s.

This service provides a multi object API to create teams for a list of objects. The API signature is:

WTList createTeams( WTList objects, List names, WTRoleHolder2 roleHolder )

This API returns a list of teams created for the object. The names list can be null;

Example: You want to create a list of teams for some documents and assign them to the objects prior to persisting the objects.

WTList docs=new WTArrayList();

for (int i=0; i < docNumber; i++) {

docs.add(createDocument(…..); //create document returns a non persisted document to you.

}

TeamTemplate template=TeamHelper.service.getTeamTemplate(container, name);

WTList teams=TeamHelper.service.createTeams(docs, null, template);

//now assign the object the team and team template

iterator= teams.persistableIterator();

int count=0;

try {

while (iterator.hasNext()) {

TeamManaged object=(TeamManaged)iterator.next();

TeamHelper.setTeamTemplate(object, template);

TeamHelper.setTeam(object, (Team)list.getPersistable(count++));S

}

}

catch (WTPropertyVetoException e) {

e.printStackTrace();

}

//Now save the objects

PersistenceHelper.manager.store(docs);