import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
public List<ClientArtifact> getAllArtifacts(String artifactType,
        String nameSpace) throws Exception {
    if (nameSpace == null)
        nameSpace = mClient.getDefaultNamespace();
    EngineConfiguration config = mClient.getEngineConfiguration();
    DispatcherService service = new DispatcherServiceLocator(config);
    URL portAddress = mClient.constructServiceURL("/ws/Dispatcher");
    Dispatcher theService = service.getDispatcher(portAddress);
    String runQuery = "<getArtifactList xmlns='urn:ws.tracker.collabnet.com'><adhocQuery><artifactTypes><artifactType><tagName>"
            + artifactType
            + "</tagName><namespace>"
            + nameSpace
            + "</namespace></artifactType></artifactTypes></adhocQuery></getArtifactList>";
    Request queryRequest = toRequest(createDocument(runQuery));
    Response queryResponse = theService.execute(queryRequest);
    Document queryResponseDocument = toDocument(queryResponse);
    ClientArtifactListXMLHelper result = new ClientArtifactListXMLHelper(
            queryResponseDocument);
    return result.getAllArtifacts();
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
/**
 * Get all artifact changes between from and to times
 * 
 * @param ata
 * @param from
 * @param to
 * @return
 * @throws Exception
 */
public HistoryTransactionList getArtifactChanges(ArtifactType[] ata,
        long from, Long to) throws Exception {
    EngineConfiguration config = mClient.getEngineConfiguration();
    ArtifactHistoryService service = new ArtifactHistoryServiceLocator(
            config);
    URL portAddress = mClient
            .constructServiceURL("/tracker/ArtifactHistory");
    ArtifactHistoryManager theService = service
            .getArtifactHistoryManager(portAddress);

    /*
     * Long to = new Long(System.currentTimeMillis()); long from =
     * to.longValue(); try { from = Long.parseLong(lastSynchDateTime); }
     * catch(NumberFormatException nfe) { }
     */

    TrackerUtil.debug("request artifactChanges() from: " + new Date(from));
    return theService.getArtifactChanges(ata, from, to);
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
/**
 * Get all of the artifacts given a list of ids
 * 
 * @param idList
 * @return
 * @throws Exception
 */
public ClientArtifactListXMLHelper getArtifactsById(Set<String> idList)
        throws Exception {

    EngineConfiguration config = mClient.getEngineConfiguration();
    DispatcherService service = new DispatcherServiceLocator(config);
    URL portAddress = mClient.constructServiceURL("/ws/Dispatcher");
    Dispatcher theService = service.getDispatcher(portAddress);

    String runQuery = "<getArtifactById xmlns='urn:ws.tracker.collabnet.com'> ";
    for (String id : idList) {
        runQuery += "<id>" + id + "</id>";
    }
    runQuery += "</getArtifactById>";

    TrackerUtil.debug("getArtifactsById(): ");
    Response r = theService.execute(toRequest(createDocument(runQuery)));
    Document result = toDocument(r);
    ClientArtifactListXMLHelper helper = new ClientArtifactListXMLHelper(
            result);
    return helper;
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
/**
 * Queries the server and returns a list of artifact types.
 * 
 * @return
 * @throws ServiceException
 * @throws WSException
 * @throws RemoteException
 */
public Collection<TrackerArtifactType> getArtifactTypes()
        throws ServiceException, WSException, RemoteException {
    EngineConfiguration config = mClient.getEngineConfiguration();
    MetadataService service = new MetadataServiceLocator(config);
    URL portAddress = mClient.constructServiceURL("/tracker/Metadata");
    Metadata theService = service.getMetadataService(portAddress);
    ArtifactType[] artifactTypes = theService.getArtifactTypes();
    String key;
    for (ArtifactType type : artifactTypes) {
        key = TrackerUtil.getKey(type.getNamespace(), type.getTagName());
        if (repositoryData == null)
            repositoryData = new TrackerClientData();
        if (repositoryData.getArtifactTypeFromKey(key) == null)
            repositoryData.addArtifactType(new TrackerArtifactType(type));
    }

    return repositoryData.getArtifactTypes();
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
/**
 * Get the metadata for the given artifact. The metadata contains the valid
 * values for attributes and the valid operations that can be performed on
 * the attribute
 * 
 * @param namespace
 * @param artifactType
 * @param artifactId
 * @return
 * @throws ServiceException
 * @throws WSException
 * @throws RemoteException
 */
public ArtifactTypeMetadata getMetaDataForArtifact(String namespace,
        String artifactType, String artifactId) throws ServiceException,
        WSException, RemoteException {
    EngineConfiguration config = mClient.getEngineConfiguration();
    MetadataService service = new MetadataServiceLocator(config);
    URL portAddress = mClient.constructServiceURL("/tracker/Metadata");
    Metadata theService = service.getMetadataService(portAddress);
    TrackerUtil.debug("getMetaDataForArtifact():" + artifactId);
    ArtifactTypeMetadata metaData = theService.getMetadataForArtifact(
            new ArtifactType(artifactType, namespace, ""), artifactId);
    TrackerUtil.debug("getMetaDataForArtifact():done ");
    TrackerArtifactType type = repositoryData
            .getArtifactTypeFromKey(TrackerUtil.getKey(namespace,
                    artifactType));
    if (type == null) {
        type = new TrackerArtifactType(metaData.getArtifactType()
                .getDisplayName(), metaData.getArtifactType().getTagName(),
                metaData.getArtifactType().getNamespace());
    }
    type.populateAttributes(metaData);
    repositoryData.addArtifactType(type);

    return metaData;
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
/**
 * Get the next page of results. This is used by the
 * ClientArtifactListXMLHelper to ensure that all results are returned
 * 
 * @param pageInfo
 * @return
 * @throws Exception
 */
public Document getNextPage(Node pageInfo, String altQueryRef)
        throws Exception {
    validateNextPage(pageInfo, altQueryRef);
    EngineConfiguration config = mClient.getEngineConfiguration();
    DispatcherService service = new DispatcherServiceLocator(config);
    URL portAddress = mClient.constructServiceURL("/ws/Dispatcher");
    Dispatcher theService = service.getDispatcher(portAddress);

    Document doc = createNewXMLDocument(DEFAULT_NAMESPACE, "ns1:"
            + "getNextPage");
    Element root = doc.getDocumentElement();
    Node newPageInfo = doc.importNode(pageInfo, true);
    root.appendChild(newPageInfo);

    TrackerUtil.debug("getNextPage()");
    Response r = theService.execute(toRequest(doc));
    Document result = toDocument(r);

    return result;
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
/**
 * Attach a file to a PT artifact
 * 
 * @param taskId
 * @param comment
 * @param attachment
 * @throws ServiceException
 * @throws WSException
 * @throws RemoteException
 */
public long postAttachment(String taskId, String comment,
        DataSource attachment) throws ServiceException, WSException,
        RemoteException {
    EngineConfiguration config = mClient.getEngineConfiguration();
    AttachmentService service = new AttachmentServiceLocator(config);
    URL portAddress = mClient.constructServiceURL("/tracker/Attachment");
    AttachmentManager theService = service
            .getAttachmentService(portAddress);
    DataHandler attachmentHandler = new DataHandler(attachment);

    theService.addAttachment(taskId, attachment.getName(), comment,
            attachment.getContentType(), attachmentHandler);
    long[] ids = theService.getAttachmentIds(taskId);
    Arrays.sort(ids);
    return ids[ids.length - 1];
}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected CaNanoLabServicePortType createPortType() throws RemoteException {

		CaNanoLabServiceAddressingLocator locator = new CaNanoLabServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		CaNanoLabServicePortType port = null;
		try {
			port = locator.getCaNanoLabServicePortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
private PreprocessDatasetSTATMLServicePortType createPortType() throws RemoteException {

		PreprocessDatasetSTATMLServiceAddressingLocator locator = new PreprocessDatasetSTATMLServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = ClassUtils.getResourceAsStream(getClass(), "client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		PreprocessDatasetSTATMLServicePortType port = null;
		try {
			port = locator.getPreprocessDatasetSTATMLServicePortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
private MageTranslationServicesPortType createPortType() throws RemoteException {

		MageTranslationServicesServiceAddressingLocator locator = new MageTranslationServicesServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = ClassUtils.getResourceAsStream(getClass(), "client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		MageTranslationServicesPortType port = null;
		try {
			port = locator.getMageTranslationServicesPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected PhotoSharingRegistrationPortType createPortType() throws RemoteException {

		PhotoSharingRegistrationServiceAddressingLocator locator = new PhotoSharingRegistrationServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		PhotoSharingRegistrationPortType port = null;
		try {
			port = locator.getPhotoSharingRegistrationPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected GalleryPortType createPortType() throws RemoteException {

		GalleryServiceAddressingLocator locator = new GalleryServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		GalleryPortType port = null;
		try {
			port = locator.getGalleryPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected PhotoSharingPortType createPortType() throws RemoteException {

		PhotoSharingServiceAddressingLocator locator = new PhotoSharingServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		PhotoSharingPortType port = null;
		try {
			port = locator.getPhotoSharingPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected CaGridEnumerationPortType createPortType() throws RemoteException {

		CaGridEnumerationServiceAddressingLocator locator = new CaGridEnumerationServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		CaGridEnumerationPortType port = null;
		try {
			port = locator.getCaGridEnumerationPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected StockPortfolioManagerPortType createPortType() throws RemoteException {

		StockPortfolioManagerServiceAddressingLocator locator = new StockPortfolioManagerServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		StockPortfolioManagerPortType port = null;
		try {
			port = locator.getStockPortfolioManagerPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected StockManagerPortType createPortType() throws RemoteException {

		StockManagerServiceAddressingLocator locator = new StockManagerServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		StockManagerPortType port = null;
		try {
			port = locator.getStockManagerPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected IdentifiersNAServicePortType createPortType() throws RemoteException {

		IdentifiersNAServiceAddressingLocator locator = new IdentifiersNAServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		IdentifiersNAServicePortType port = null;
		try {
			port = locator.getIdentifiersNAServicePortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected CBMPortType createPortType() throws RemoteException {

		CBMServiceAddressingLocator locator = new CBMServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		CBMPortType port = null;
		try {
			port = locator.getCBMPortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected GlobalModelExchangePortType createPortType() throws RemoteException {

		GlobalModelExchangeServiceAddressingLocator locator = new GlobalModelExchangeServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		GlobalModelExchangePortType port = null;
		try {
			port = locator.getGlobalModelExchangePortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}
 

import org.apache.axis.EngineConfiguration; //导入依赖的package包/类
protected TavernaWorkflowServicePortType createPortType() throws RemoteException {

		TavernaWorkflowServiceAddressingLocator locator = new TavernaWorkflowServiceAddressingLocator();
		// attempt to load our context sensitive wsdd file
		InputStream resourceAsStream = getClass().getResourceAsStream("client-config.wsdd");
		if (resourceAsStream != null) {
			// we found it, so tell axis to configure an engine to use it
			EngineConfiguration engineConfig = new FileProvider(resourceAsStream);
			// set the engine of the locator
			locator.setEngine(new AxisClient(engineConfig));
		}
		TavernaWorkflowServicePortType port = null;
		try {
			port = locator.getTavernaWorkflowServicePortTypePort(getEndpointReference());
		} catch (Exception e) {
			throw new RemoteException("Unable to locate portType:" + e.getMessage(), e);
		}

		return port;
	}