Contents


Automate management of Rational Team Concert users

Use the API to create, activate, and archive users programmatically

Comments

Overview

IBM® Rational Team Concert™ is collaborative project planning and change management software. A single Rational Team Concert server can host multiple project areas. Project areas serve as work areas for different teams.

A Rational Team Concert administrator controls rights of users either through the available UI or through a Java API. Selection of the interface depends on the volume of work.

The UI approach is practical if the changes that you need to make only a few changes and they are limited to a small user group.

However, an API-driven approach is more suitable when there are multiple changes to make or when the changes affect a large group of users. Two examples:

  • Adding a large number of users in Rational Team Concert through a migration process
  • Managing access control based on changes in another system (for instance, archiving a user account in case it is removed from the enterprise directory)

In both of those situations, choosing the API approach eliminates system administrator intervention, and routine tasks can be run automatically. The user data input source for Rational Team Concert can vary from being a flat file, to an existing change management system, or an enterprise directory.

This article explains how to use the Rational Team Concert API to create, activate, and archive users at Rational Team Concert.

Scenario

There are two ways to use the Rational Team Concert user interface (UI) to add users: create users or import them.

Problem

The limitation of using the UI for either method is that the administrator can add only one user at a time. These limitations become challenging when you need to add as a group, such as when multiple users exist in another system need to be imported into Rational Team Concert.

Two other aspects of user management are archiving and activating users. An administrator can perform these actions by using the UI, but it becomes challenging when two systems (Rational Team Concert and any other change management system) must be kept in sync. In the manual mode, the Rational Team Concert administrator would need to be involved throughout the process to replicate user settings of Active or Archive as in other change management system.

Solution

The API-driven approach to creating users avoids these limitations. As in this automated mode, users are created programmatically through inputs read from any underlying system. It also helps in cases where two systems (Rational Team Concert and any other change management system) are in sync and users need to be created, archived, or restored automatically rather than waiting for manual intervention to keep both of the systems in sync.

Manage users through the UI

A brief description of Rational Team Concert UI user management steps, illustrated by screen captures, follows. You need to be a Rational Team Concert administrator to carry out these operations.

Create a user

  1. Log in to the Rational Team Concert server by using the web client.
  2. Click the Users tab, and then click Create User.
  3. Add the necessary user details, and then save the user.
Figure 1. Creating a user in Rational Team Concert
Application Administration view in the UI
Application Administration view in the UI

Larger view of Figure 1.

Import users from any directory service

  1. Log in to the Rational Team Concert server by using the web client.
  2. Click the Users tab, and then click Import Users.
  3. Search the users, and select the one that you want to import.
Figure 2. Importing users
Active Users view
Active Users view

Larger view of Figure 2.

Figure 3. Select Users view within Import Users
Search field, Matching user results, user selected
Search field, Matching user results, user selected
Figure 4. Confirmation: User imported successfully
Active Users view shows user added
Active Users view shows user added

Larger view of Figure 4.

Archive active users

  1. Log in to the Rational Team Concert server by using the web client.
  2. Click the Users tab and then Active Users.
  3. Search for the user, and then click Archive User in the Action column as highlighted in the screen capture in Figure 5.
Figure 5. Archiving Users at Rational Team Concert
Active Users view for archiving users
Active Users view for archiving users

Larger view of Figure 5.

Restore archived users

  1. Log in to Rational Team Concert server by using the web client.
  2. Click the Users tab, and then Archived Users.
  3. Search the user, and then click Restore User under the Action column, as highlighted in screen capture in Figure 6.
Figure 6. Restoring users
Archived Users view
Archived Users view

Larger view of Figure 6.

Manage users programmatically through the API

You can also do all of the previously shown UI user management actions through the Rational Team Concert API. Programming through the API will automate and standardize the process, as well as make it fast and error-free when processing user accounts in bulk.

Note:
To use these methods, you need to belong to the JazzAdmins group.

Create a user

As code Listing 1 demonstrates setting the required user details through the object of IContributor class and saving the contributor through contributor manager will create a new user at Rational Team Concert.

Listing 1. User creation through Rational Team Concert API
private IContributor createRTCUser(ITeamRepository repo,String userName,String 
emailAddress,String userId) throws TeamRepositoryException{ 
//Create Item Type Contributor and set its properties 
IContributor i1 = (IContributor) IContributor.ITEM_TYPE.createItem(); 
i1.setName(userName); 
i1.setUserId(userId); 
i1.setEmailAddress(emailAddress); 
i1.setArchived(false); 
return repo.contributorManager().saveContributor(i1, null); 
}

Import and create users through the API

Rational Team Concert also provides a way to import users directly from an external user registry to a Rational Team Concert repository. For this, the Rational Team Concert server needs to be configured to use the ExternalUser Registry (LDAP in the example in Listing 2).

Listing 2. Importing a user from the ExternalUser Registry
private boolean importUserToRTC(ITeamRepository repo,IContributor cont) throws 
TeamRepositoryException{ 
//Get the ExternalUser Registry and retrieve the required user 
IExternalUserRegistryManager externalUserRegMgr = repo.externalUserRegistryManager(); 
IExternalUser exUser = externalUserRegMgr.fetchUser("test1@in.ibm.com", null); 
if (exUser!=null) { 
    //Once User is found in ExternalUser Registry import it 
    cont = (IContributor) cont.getWorkingCopy(); 
    cont.setEmailAddress(exUser.getEmailAddresses().get(0)); 
    cont.setName(exUser.getFullNames().get(0)); 
    cont.setUserId(exUser.getUserId()); 
    cont.setArchived(false); 
    cont = repo.contributorManager().saveContributor(cont, null); 
    return true; 
} 
else{ 
    System.out.println("User doesn't exist in ExternalUser Registry"); 
    return false;
} 
}

Archive and restore users

After users' accounts are archived in the Jazz Repository, those users will not be able to log in to Rational Team Concert Server unless they are restored to active user status.

Listing 3. Method to archive a user in Rational Team Concert
public void archiveUsers(ITeamRepository repo) 
throws TeamRepositoryException{ 
// Archive the user in Rational Team Concert 
IContributor cont = repo.contributorManager() 
    .fetchContributorByUserId("user_id", null); 
if (cont.isArchived()) 
    return; 
cont = (IContributor) cont.getWorkingCopy(); 
cont.setArchived(true); 
repo.contributorManager().saveContributor(cont, null); 
}
Listing 4. Method to restore an archived user
public void restoreUser(ITeamRepository repo) 
    throws TeamRepositoryException, IOException{ 
IContributor cont = repo.contributorManager(). 
fetchContributorByUserId(("abc@in.ibm.com"), null); 
if (!cont.isArchived()) 
return; 
// Restore the user in Rational Team Concert 
cont = (IContributor) cont.getWorkingCopy(); 
cont.setArchived(false); 
repo.contributorManager().saveContributor(cont, null); 
}

Synchronize users from an external repository

Integrating Rational Team Concert with any external system might require migration of data to keep the two repositories in sync. Otherwise, updates made to add a user on one of the systems might fail on the other if the user does not exist in the other repository. Therefore, users in the two repositories need to be synchronized. For simplicity, in this example, we will fetch the user information from a property file. The actual practice will involve the extraction of user details from an external change configuration management repository).

Figure 7. Synchronizing users across two repositories
Diagram, synchronizing Jazz, external repositories

Map user properties across two repositories

You need to create a user synchronization rule to specify how Rational Team Concert item properties map to external repository object fields.

  1. Create a User Synchronization rule (Rational Team Concert-User.xml for this example).
  2. Then insert the following field values:
Type mapping section
FieldValue
Item TypeContributor – com.ibm.team.repository
Item Type Qualifier(Leave blank)
Item ManagerContributor Manager
External RepositoryName of your external repository
External ManagerExternal repository manager for the user (varies)
External TypeUser

Property section

Add all of the required properties that need to be synced, and map them appropriately with the item property.

Item propertyPropagationExternal property
EmailAddress Both directions address
Name Both directions name
UserId Both directions user_id
Login
Repository name

Figure 8 is a screen capture of the synchronization rule file developed.

Note:
For this example, we are taking unique_identifier as the External Identifier and User_id as the Item Identifier. The unique identifier can be anything that is unique in the external repository or a combination of two or three external properties. Here, we will be taking the unique identifier as combination of login, underscore, and property file name, for example: login_property file name.

Figure 8. User synchronization rule
Synchronization rule view
Synchronization rule view

Larger view of Figure 8.

Synchronize users with Rational Team Concert

For this example, we are assuming that the details of the users that need to be synchronized in Rational Team Concert are available in a simple property file named User.properties (see Listing 5 for file contents). The administrator will create a program that reads this file, converting the users' details into a list of users, so we can synchronize with Rational Team Concert.

Listing 5. Contents of User.properties file
#User details stored in simple property file

#User 1 details 

login = Test1 
email_address = test1@in.ibm.com 
name = Test1 User 
user_id = test1@in.ibm.com 
deleteDate = 12/08/2011 

#User2 details 

login = Test2 
email_address = test2@in.ibm.com 
name = Test2 User 
user_id = test2@in.ibm.com 
deleteDate = 20/02/2012

Thus, each user's details will be put into a hash map that has the respective field names (login, email_address , name , user_id, deleteDate) as keys. Each UserHashMap would need to be added in the ArrayList object. You will be iterating over this list to programmatically synchronize users with Rational Team Concert.

First, you will be checking whether the proxy of a user that is being synchronized already exists or not (see Listing 6). A user proxy is a representation of a user between the external and Jazz repositories. It is associated with the URI of the external object, which is nothing but a unique identifier for the external object. If it exists, it means that the user is already synchronized, so that particular user will be skipped during synchronization.

Listing 6. Method to check whether a user proxy exists
private boolean 
userProxyExists(ITeamRepository repo,String uniqueIdentifier,String login)throws 
URISyntaxException, TeamRepositoryException{ 
IInteropManager interopManager = (IInteropManager) 
repo.getClientLibrary(IInteropManager.class); 
URI u = new URI(uniqueIdentifier); 
IExternalProxy proxy = interopManager.findProxybyUri(u, null); 

if (proxy != null) { 
    System.out.println("User with login id :" + login + " is already synched in 
Rational Team Concert "); 
    return true; 
}elsereturn false; 
} 
}

When a user proxy does not exist, synchronization will continue. It is possible that the proxy of the user does not exist but the corresponding contributor (user) already exists on Rational Team Concert server. In that case, it means that the user was imported into Rational Team Concert earlier but perhaps with a different repository. In such cases, whether to proceed is at the administrator's discretion. The example in Listing 7 just changes the names and email addresses of the users in such situations.

Listing 7. Method to synchronize a user with Rational Team Concert
public void syncUser(ITeamRepository jazzRepo,IProjectAreaHandle 
projectAreaHandle,Map<String,String> UserMap) throws 
TeamRepositoryException, URISyntaxException 
{

String address = (String) UserMap.get("email_address"); 
IContributor cont =null; 
try { 
    cont = fTeamRepository.contributorManager().fetchContributorByUserId(address, null);
}catch (ItemNotFoundException e) { 
    System.out.println("User :" + address +" 
    not found in contributorManager repository"); 
} 
if (cont != null) { 
    // now user with this id is already present in Rational Team Concert
    // simply change the name to avoid confliction. 
    UserMap.put("name", cont.getName()); 
    UserMap.put("email_address", cont.getEmailAddress()); 
} 
else 
    {//Contributor doesn't exist in Rational Team Concert. Need to import the User from 
    ExternalUserRegistry 
    if (manager == null) 
    manager = fTeamRepository.externalUserRegistryManager(); 
    IExternalUser user = null; 
    user = manager.fetchUser(address, new NullProgressMonitor()); 
    if (user!=null) 
        System.out.println("User found in directory service :"+ address); 
} 
//Fetch User Sync Rule to get the External Identifier 
IInteropManager interopManager = (IInteropManager) 
jazzRepo.getClientLibrary(IInteropManager.class); 
ISyncRuleHandle[] syncRuleHandles = interopManager 
.findSyncRulesByExternalTypeNameAndProjectArea("User",projectAreaHandle, null); 
ISyncRule syncRule = (ISyncRule) fTeamRepository.itemManager() 
.fetchCompleteItem(syncRuleHandles[0],IItemManager.REFRESH, null); 

IPropertyMapping externalIDmapping = syncRule 
.getExternalIdentifierPropertyMapping(); 

String externalID = externalIDmapping.getExternalPropertyName(); 

String uniqueId = (String) UserMap.get(externalID); 
URI u = new URI(uniqueId); 
IExternalProxy proxy = interopManager.findProxybyUri(u, null); 
IExternalState externalState = null; 

if (proxy == null) { 
    System.out.println("Creating a new proxy."); 
    proxy = InteropFactory.INSTANCE.createExternalProxy(); 
    proxy.setSyncRule(syncRule); 
    proxy = interopManager.saveProxyWithUri(proxy, u, null); 
    } 
if (proxy.getExternalStateItemHandle() == null) { 
    externalState = InteropFactory.INSTANCE.createExternalState(); 
} else {
    externalState = (IExternalState) interopManager 
    .getExternalState(proxy, null).getWorkingCopy(); 
    } 
externalState.setState(UserMap); 
externalState = interopManager.saveExternalState(externalState,null); 
proxy = 
interopManager.synchronizeIncomingAndWait(proxy,externalState,null,syncRule ,null); 

SynchronizationStatus syncStatus = proxy.getSynchronizationStatus(); 
if (syncStatus != SynchronizationStatus.INCOMING_ERROR) { 
    // Check if there are any blocking proxies and display status as 
    // pending blocked. 
    
    IExternalProxyHandle[] blockingProxies = interopManager 
    .getBlockingProxies(proxy, true, null); 
        if (blockingProxies.length != 0) { 
            System.out.println("Synchronization is blocked for 
          User"+UserMap.get("name")); 
          } else 
            System.out.println("Synchronization for User + "+UserMap.get("name")+
            "successfully completed"); 
}
else { 
    System.out.println("Synchronization has error for User + 
    "+UserMap.get("name")+ "Error is"+proxy.getLastErrorString()); 
    } 
}

In case the contributor does not exist, the user is imported from the external user registry (LDAP in this example). The external identifier value is extracted from the UserMap, and the corresponding URI is constructed. If the ExternalProxy corresponding to this URI doesn’t exit, a proxy is created, a corresponding syncRule is set, and the proxy is saved. UserMap is saved as an ExternalState of the proxy, and synchronization of this user is triggered for completion. The synchronization process will wait for this request to finish first before synchronizing with other users. If the request completes successfully, the full state of the proxy object resulting from processing the request is returned. If the request does not complete successfully (meaning that it was aborted or canceled, not that there was a synchronization error), then null is returned. The following statuses can occur for the synchronization process of user:-

UNINITIALIZED
This indicates that no external state has been received yet. This is the default state of a newly created proxy.
 
OK
The last known state of the external object has been synchronized with the last known state of a Jazz item without any errors.
 
PENDING
The operation is pending for the proxy.
 
INCOMING ERROR
The synchronization process failed for some reason.
 

There is a possibility that the synchronization for a user can get blocked for some reason. In such cases, the proxy needs to be deleted first so you can try synchronizing it again. If the status is INCOMING ERROR, then you can retrieve the cause of the error and take steps to avoid having it happen again.

This process will be carried out for all users that need to be synchronized. You can check the synchronization status by right-clicking the sync rule of the user from the Synchronization Rules View and selecting Show Unsynchronized.

Tip:
It is better to use the synchronizeIncomingAndWait method than synchronizeIncoming, because it waits for the request to get completed and then moves to process only further synchronization requests, regardless of the synchronizeIncoming method. This puts the request at the end of the synchronization queue and returns immediately without verifying completion. That might lead to errors or blocking of proxies of other synchronizations items (defects or features) that might be referenced by the users that are still in the synchronization queue, waiting for synchronization.

Archive and restore users

When the user no longer exist in the external repository because they have been archived or deleted, to synchronize the external objects referenced by such users, you need to archive those users on the Rational Team Concert server. You can check whether the contributor is archived on the server by using calling the isArchived() method on each contributor, cont.isArchived(), which will return True if the user is archived on the server or False if not.

To run the synchronization across the repositories, it is necessary to restore the archived users first, execute the synchronization for external objects, and then archive the users again on Rational Team Concert server. Restoration of users is necessary to synchronize external objects successfully, because archived users will not be able to log in to the repository. Listing 8 demonstrates how to restore an archived Rational Team Concert user. Here, you can pass UserMap.get("user_id") to fetch the contributor by user_id.

After the synchronization finishes, you need to archive deleted users again. Users that have deleted dates in the UserMap will be archived.

Listing 8. Method to archive users in Rational Team Concert
public void archiveUsers(ITeamRepository repo, Map<String,String> UserMap){ 
for(String key :UserMap.keySet()){ 

    if (UserMap.get("deleteDate")!= null && !(UserMap.get("deleteDate").equals(""))) { 
        // Archive the user in Rational Team Concert
        IContributor cont = repo.contributorManager() 
        .fetchContributorByUserId(UserMap.get("user_id"), null); 
        if (cont.isArchived()) 
            continue; 
        cont = (IContributor) cont.getWorkingCopy(); 
        cont.setArchived(true); 
        repo.contributorManager().saveContributor(cont, null); 
        }
}
}

Thus, the updates of these users will still be replicated to the Jazz repository as archived users.

Synchronize a Rational Team Concert user with an external repository

Synchronizing users from Rational Team Concert to with an external repository involves Outgoing Synchronization from the Rational Team Concert server to the external repository. By default, the Outgoing Synchronization process is disabled on the Jazz server. To enable it and to create an external repository connection, see "Change Management in the Rational Team Concert" in the information center (see Related topics for a link).

You will create a class that will implement an IInteropExternalManager interface and extend the AbstractInteropExternalManager abstract class. This class will trigger the Outgoing Synchronization from the Rational Team Concert server. The class will implement canCreateObject, updateState, createObject, and findObject methods to carry out the Outgoing Synchronization process completely and return the result of any update or creation done in external repository back to Rational Team Concert.

To explain this simply here, we again take a property file and create or update user details in it. In practice, a flat file can be replaced in any external repository and its APIs can be used to create or update user details. See External Repository Implementation to learn more (see Related topics for a link).

Outgoing synchronization happens as follows:

  1. The findObject method attempts to find existing objects in the external repository.
  2. If a matching object is found, the current properties of that object are returned, and the getState method is called to retrieve the current state of a connected external object. Appropriate property values can be applied to update changes on an existing external object.
  3. If it is not found, a new object is created in the external repository if the CanCreateObject is set to True.
Listing 9. Find External Object method (findObject) in property file
public URI findObject(final String typeName, final String idPropName, 
final Map<String, ?> state,final Map<String, Object> returnedState, 
final List<String> propertyNames,final 
IExternalRepositoryConnection externalConnection) { 
String uniqueID = ""; 
String name = null; 
try { 
    if(idPropName==null) 
        return null; 
    if(state.containsKey(idPropName)){ 
        name = (String) state.get(idPropName); 
        if(name ==null) 
        return null; 
    }else{ 
        System.out.println("Unique property not available"); 
        return null; 
    } 
    Map<String,Object> externalState = new HashMap<String,Object>(); 
    HashMap UserMap = new HashMap(); 
    uniqueID = (String) state.get(idPropName); 
    String temp[] = uniqueID.split("_"); //uniqueID is combination of login External 
    Repository (property file in our case) 
    String login = temp[0]; 
    Properties propertyValues = new Properties(); 
    // Read properties file 
    readPropertyFile(propertyValues); 
    //Get property value depending on key 
    Object value = propertyValues.getProperty(login); 
    if(value!=null){ 
        UserMap.put("login", value); 
        UserMap.put("email_address", propertyValues.getProperty("email_address")); 
        UserMap.put("name", propertyValues.getProperty("name")); 
        UserMap.put("user_id", propertyValues.getProperty("user_id")); 
        UserMap.put("deleteDate", propertyValues.getProperty("deleteDate ")); 
        externalState = UserMap; 
        }elsereturn null; 
        
        returnedState.putAll(externalState); 
        return URI.create((String)returnedState.get("uniqueID")); 
        } catch (final Exception erEx) { 

            ExceptionHandler.handleException(erEx); 
            throw new RuntimeException(erEx); 
        } 
    } 
// Read properties file 
public void readPropertyFile(Properties propertyValues) throws IOException{ 
File dir = new File("file:\\C:\\User.properties"); 
String url = dir.toString(); 
InputStream stream = null; 
String path = "C:\\User.properties"; 

URL fileURL = new URL(url); 
stream = fileURL.openStream(); 
stream = new FileInputStream(path); 
propertyValues.load(stream); 
}

The Find method called above will find the details of the user from the properties file by login, which is retrieved from the unique_identifier. The method will create and return a URI of the user if a user is found in the properties file. Otherwise, it returns null.

Create External Object method (createObject)

If findObject() returns null (if the external state of the object is null, it means that no external object exists with the required unique_identifier), the external object can be created, depending on whether the administrator wants to create external object in external repository or not. If the administrator requires the creation of an external object in the external repository, canCreateObject will return True, and the createObject method will be called by InteropService, thus creating an external object in external repository (in this example, details for a new user will be added in the properties file) and will return the CreationInfo object.

Listing 10. Method to create an object in an external repository
public boolean canCreateObject(String typeName) {
// Users can be created in ExternalRepository 
return true; 
} 

public CreationInfo createObject(final String typeName, 
final Map<String, ?> state,final Map<String, Object> returnedState, 
final List<String> propertyNames,final IExternalRepositoryConnection externalConnection,
final IProcessArea processArea) { 
                
Properties propertyValues = new Properties(); 
URI uri = null; 
String address = (String) state.get("address"); 
String name = (String) state.get("name"); 
String userId = (String) state.get("user_id"); 
Map<String,String> UserMap =new HashMap<String,String>(); 
Map<String,String> externalState = new HashMap<String, String>(); 

/*Query if the User exists in User.properties or not */ 
try {
    readPropertyFile(propertyValues); 
} catch (IOException e) { 

    e.printStackTrace(); 
} 
Object value = propertyValues.getProperty(userId); 
if(value==null || value.toString().equals("")){ 
//Put User details as the user doesn't exists in User.properties 
    propertyValues.setProperty("name2", name); 
    propertyValues.setProperty("user_id2", userId); 
    propertyValues.setProperty("email_address2", address); 
    propertyValues.setProperty("login2", userId); 
    propertyValues.setProperty("deleteDate2", ""); 
    try { 
    propertyValues.store(new FileOutputStream("C:\\User.properties",true), 
    "User3 details"); 
    } catch (FileNotFoundException e) { 
    
        e.printStackTrace(); 
    } catch (IOException e) { 

        e.printStackTrace(); 
    } 
    uri = URI.create(userId+"_"+"User.properties"); 
    } else 
    //User already exists in External Repository, just create uri 
    uri = URI.create(value+"_"+"User.properties"); 

    UserMap.put("address", address); 
    UserMap.put("name", name); 
    UserMap.put("user_id", userId); 
    externalState = UserMap; 
    if (externalState == null) { 
    return null; 
    } 
returnedState.putAll(externalState); 
return new CreationInfo(uri, null); 
}

Thus, if a user is not found in User.properties file and canCreateObject is also set to True, a new user will be inserted in the property file.

Update External Object method (updateState)

This method updates the state of external object in the property file. It returns the saved state after the update succeeds. The administrator can be selective about updating changes in an external repository also. The example in Listing 11 merely updates the property file in case the user name is changed on the Rational Team Concert server.

Listing 11. Method to update an object in an external repository
public boolean updateState(final String typeName, final URI uri,final Map<String, ?> 
newState, 
final Map<String, ?> lastState,final Map<String, Object> returnedState,final List<String> 
propertyNames,final ExternalRepositoryConnection externalConnection,final IProcessArea 
processArea) { 
Properties propertyValues = new Properties(); 
HashMap UserMap = new HashMap(); 
Map<String,Object> newMap = null; 
//Iterating over newState fetched from Rational Team Concert Server and 
//updating property file
only in case the user name has changed

for (Iterator<String> it = newState.keySet().iterator(); it.hasNext();){ 
    String key = it.next(); 
    if(key.equals("name")){ 
    String s2 = (String)newState.get(key); 
    //Update UserName in property file 
    try { 
        readPropertyFile(propertyValues); 
    } catch (IOException e) { 

        e.printStackTrace(); 
    } 
    propertyValues.setProperty(key, s2); 
    try { 
        propertyValues.store(new FileOutputStream("C:\\User.properties",true), "User3 
    details"); 
    } catch (FileNotFoundException e) { 

        e.printStackTrace(); 
    } catch (IOException e) { 

        e.printStackTrace(); 
    } 
    UserMap.put("login", propertyValues.getProperty("login")); 
    UserMap.put("email_address", propertyValues.getProperty("email_address")); 
    UserMap.put("name", propertyValues.getProperty("name")); 
    UserMap.put("user_id", propertyValues.getProperty("user_id")); 
    UserMap.put("deleteDate", propertyValues.getProperty("deleteDate ")); 
    newMap = UserMap; 
    
    returnedState.putAll(newMap); 
    return true; 
    } 
    } 
    return false; 
}

Tip:
This code is in the SynchroniseUser.zip file (see the Downloadable resources section.)

Summary

You have seen that the Rational Team Concert administrator can create, import, synchronize, and manage Rational Team Concert users across both external and Jazz repositories at run time without any manual effort. Using Rational Team Concert APIs saves time in completing the synchronization process across both of the repositories


Downloadable resources


Related topic


Comments

Sign in or register to add and subscribe to comments.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Rational, DevOps
ArticleID=813413
ArticleTitle=Automate management of Rational Team Concert users
publish-date=05082012