CAA Web Services Home

public class CAAENOVWSConcEngCppWrapper {
    private String SERVICE_ID = "urn:com:dassault_systemes:ENOVWSConcEngImpl:ENOVWSConcEngImpl:ENOVWSConcEngCpp";
    private IConcEngWS proxy = null;

    /**
     * Creates a new proxy for the ENOVWSConcEngCpp CAA Web service
     * implementation and configures it.
     * 
     * @param clientId the client identifier used to maintain the session state
     * accross distinct proxies
     * @param uri the root URI of the Web application hosting the implementation
     * of the ENOVWSConcEngCpp CAA Web service
     * @param timeOut the proxy timeout
     */
    public CAAENOVWSConcEngCppWrapper(String clientId, String uri, int timeOut) {
        // Compute the SOAP endpoint URI value that bounds to the deployed
        // implementation of the ENOVWSConcEngCpp CAA Web service
        String endpoint = uri + "servicerouter?service=" + SERVICE_ID;

        // Retrieve proxy instance
        ENOVWSConcEngCppLocator locator = new ENOVWSConcEngCppLocator();
        try {
            proxy = locator.getENOVWSConcEngCppPort(new URL(endpoint));
        } catch (MalformedURLException e) {
            e.printStackTrace();
            throw new RuntimeException(
                    "Invalid SOAP endpoint URI specified for the ENOVWSConcEngCpp CAA Web service proxy");
        } catch (ServiceException e) {
            e.printStackTrace();
            throw new RuntimeException(
                    "Unable to instantiate the ENOVWSConcEngCpp CAA Web service proxy");
        }

        // Required for HTTP session state management on the current proxy
        ((IConcEngWSBindingStub) proxy).setMaintainSession(true);

        if (clientId != null) {
            // Used to maintain the HTTP session state accross distinct proxies
            HandlerInfo info = new HandlerInfo();
            info.setHandlerClass(CustomSessionHandler.class);
            Map handlerConfig = new HashMap();
            handlerConfig.put(CustomSessionHandler.CLIENT_ID, clientId);
            info.setHandlerConfig(handlerConfig);

            HandlerRegistry registry = locator.getHandlerRegistry();
            String portName = locator.getENOVWSConcEngCppPortWSDDServiceName();
            QName name = new QName(portName);
            List chain = registry.getHandlerChain(name);
            chain.add(info);
        }
        // Increase the default client time-out
        ((IConcEngWSBindingStub) proxy).setTimeout(timeOut);
    }

public class CAAENOVWSConcEngCppWrapper {
 ....

	public void lock(String[] ids)
		throws Exception {
		System.out.println(">>> Invoking 'lock' on ENOVWSConcEngCpp CAA Web service proxy");
		if (ids == null) {
			throw new IllegalArgumentException(
					"object UUID array is null");
		}
		// Create input data
		Identifier[] idents = CAAENOVWSUtils.toIdentifierArray(ids);
	

		// Invoke method on remote CAA Web service
		try {
			Status status = proxy.lock(idents);
			System.out.println("Status: " + status.getStatus());
		} catch (CATServiceExceptionType e) {
			throw e;
		} catch (Throwable t) {
			throw new Exception("Failed to lock objects", t);
		}
	} 

}

public class CAAENOVWSConcEngCppWrapper {
.....

	public void unlock(String[] ids)
		throws Exception {
		System.out.println(">>> Invoking 'unlock' on ENOVWSConcEngCpp CAA Web service proxy");
		if (ids == null) {
			throw new IllegalArgumentException(
					"object UUID array is null");
		}
		// Create input data
		Identifier[] idents = CAAENOVWSUtils.toIdentifierArray(ids);
	

		// Invoke method on remote CAA Web service
		try {
			Status status = proxy.unlock(idents);
			System.out.println("Status: " + status.getStatus());
		} catch (CATServiceExceptionType e) {
			throw e;
		} catch (Throwable t) {
			throw new Exception("Failed to unlock objects", t);
		}
	}

}

public class CAAENOVWSConcEngCppWrapper {
.....

	public ObjectLockInfo[] getLock(String[] ids)
		throws Exception {
		System.out.println(">>> Invoking 'lock' on ENOVWSConcEngCpp CAA Web service proxy");
		if (ids == null) {
			throw new IllegalArgumentException(
					"object UUID array is null");
		}
		// Create input data
		SessionToken token = new SessionToken();  //place holder not used
		Identifier[] idents = CAAENOVWSUtils.toIdentifierArray(ids);
	

		// Invoke method on remote CAA Web service
		try {
			ObjectLockInfoArrayTypeHolder lockHolder = new ObjectLockInfoArrayTypeHolder();
			Status status = proxy.getLock(token, idents, lockHolder);
			System.out.println("Status: " + status.getStatus());
			return lockHolder.value;
		} catch (CATServiceExceptionType e) {
			throw e;
		} catch (Throwable t) {
			throw new Exception("Failed to getLock", t);
		}
	}	

}

public class CAAENOVWSConcEngCppWrapper {
    ........

	public void transferOwnership(ObjectLockInfo [] lockInfos)
		throws Exception {
		System.out.println(">>> Invoking 'transferOwnership' on ENOVWSConcEngCpp CAA Web service proxy");
		if (lockInfos== null) {
			throw new IllegalArgumentException(
					"object lock info is null");
		}
		// Create input data
		SessionToken token = new SessionToken();  //place holder not used

		// Invoke method on remote CAA Web service
		try {
			Status status = proxy.transferOwnership(token, lockInfos, false);
			System.out.println("Status: " + status.getStatus());
		} catch (CATServiceExceptionType e) {
			throw e;
		} catch (Throwable t) {
			throw new Exception("Failed to transferownership", t);
		}
	}		
}

public class CAAENOVWSConcEngCppUseCase {
    private String uri = null;
    private String credUser = null;
    private String credPwd = null;

    public CAAENOVWSConcEngCppUseCase(String uri,
                                      String credUser,
                                      String credPwd) {
        this.uri = uri;
        this.credUser = credUser;
        this.credPwd = credPwd;
    }

    public void runSampleUsageScenario(String enoviaUser, String newOwnerStr) {
        boolean success = false;
        Exception exception = null;
        CAAENOPosApplicationBinderImplWrapper binderWrapper = null;
        SessionToken sessionToken = null;

        try {
            // ------------------------------------------------------------
            // Step 1 - Instantiate and configure the proxy
            // ------------------------------------------------------------

            System.out.println("STEP 1: Instantiating and configuring CAA Web service proxy");

            String clientId = new Long(System.currentTimeMillis()).toString();
            int timeOut = 360000;

            // Instantiate the wrapper client class
            binderWrapper = new CAAENOPosApplicationBinderImplWrapper(clientId,
                    uri, credUser, credPwd, timeOut);
            CAAENOVWSProdStructCppWrapper prodStructWrapper = new CAAENOVWSProdStructCppWrapper(
                    clientId, uri, timeOut);
            CAAENOVWSCntMgmtCppWrapper cntMgmtWrapper = new CAAENOVWSCntMgmtCppWrapper(
                    clientId, uri, timeOut);
            CAAENOVWSConcEngCppWrapper concEngWrapper = new CAAENOVWSConcEngCppWrapper(
                    clientId, uri, timeOut);

            // ------------------------------------------------------------
            // Step 2 - Open session with ENOVIA LCA V5
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 2: Opening session with ENOVIA LCA V5");
            System.out.println("--------------------------------------------------------------------------------");

            String[] userContexts = binderWrapper.getUserContexts(enoviaUser);

            System.out.println("Found " + userContexts.length + " context(s) in database");
            System.out.println("Displaying list of available contexts:");
            for (int i = 0; i < userContexts.length; i++) {
                System.out.println("Context[" + i + "]: " + userContexts[i]);
            }

            System.out.println("\n--------------------------------------------------------------------------------");
            System.out.println("STEP 3: Logging on to ENOVIA LCA V5");
            System.out.println("--------------------------------------------------------------------------------");

            if (userContexts.length == 0) {
                throw new Exception("No context found for the user specified");
            }
            sessionToken = binderWrapper.login(userContexts[0]);

            // ------------------------------------------------------------
            // Step 3 - Create 2 documents
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 3: Creating 2 documents");
            System.out.println("--------------------------------------------------------------------------------");

            String docId1 = "CAAWSConc1" + System.currentTimeMillis(); // the VID
            // has to be unique
            String docName1 = "Doc1" + docId1;
            String domain = "DOCDIR";

            ENOVIA createDocResultSet1 = cntMgmtWrapper.createDocument(docId1,
                                                                       docName1,
                                                                       domain);

            String[] docUUIDs1 = cntMgmtWrapper.getENOVIA_VPMDocumentRevisionUUIDs(createDocResultSet1);
            if (docUUIDs1.length > 1) {
                throw new Exception(
                        "Invalid state: more than 1 document was returned");
            } else if (docUUIDs1.length != 1) {
                throw new Exception("Failed to create the document");
            }
            String docUUID1 = docUUIDs1[0];

            CAAENOVWSUtils.displayResults(createDocResultSet1, 1);

            String docId2 = "CAAWSConc2" + System.currentTimeMillis();
            String docName2 = "Doc2" + docId2;

            ENOVIA createDocResultSet2 = cntMgmtWrapper.createDocument(docId2,
                                                                       docName2,
                                                                       domain);

            String[] docUUIDs2 = cntMgmtWrapper.getENOVIA_VPMDocumentRevisionUUIDs(createDocResultSet2);
            if (docUUIDs2.length > 1) {
                throw new Exception(
                        "Invalid state: more than 1 document was returned");
            } else if (docUUIDs2.length != 1) {
                throw new Exception("Failed to create the document");
            }
            String docUUID2 = docUUIDs2[0];

            CAAENOVWSUtils.displayResults(createDocResultSet2, 1);

            // ------------------------------------------------------------
            // Step 4 - Create part
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 4: Creating part reference");
            System.out.println("--------------------------------------------------------------------------------");

            String partNumber = "CAAWSConcPrt" + System.currentTimeMillis();

            ENOVIA createPartResultSet = prodStructWrapper.createPartRef(new String[] { partNumber },
                                                                         "PRODUCT",
                                                                         "FALSE");

            String[] partRefUUIDs = prodStructWrapper.getENOVIA_VPMPartVersionUUIDs(createPartResultSet);
            if (partRefUUIDs.length > 1) {
                throw new Exception(
                        "Invalid state: more than 1 part reference was returned");
            } else if (partRefUUIDs.length != 1) {
                throw new Exception("Failed to create part reference");
            }
            String partRefUUID = partRefUUIDs[0];

            CAAENOVWSUtils.displayResults(createPartResultSet, 1);

            // ------------------------------------------------------------
            // Step 5 - Attach document to part
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 5: Attaching document 1&2 to part");
            System.out.println("--------------------------------------------------------------------------------");

            String attachType = "Primary"; // "Primary" or "Secondary"
            String role = "Documentation"; // "Representation" or
            // "Documentation"
            String[] docUUIDs = { docUUID1, docUUID2 };

            cntMgmtWrapper.attachDocument(partRefUUID,
                                          docUUIDs,
                                          attachType,
                                          role);

            // ------------------------------------------------------------
            // Step 6 - Check in document
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 6: Check in document 1");
            System.out.println("--------------------------------------------------------------------------------");

            String fileName = "CAAFileTestForCntCheckIn.txt";
            String vaultName = "";
            String fileContent = "asasasasasaasasasasaskljadlkfhslkdfhsdlfhklsdh;asdhjl;dfhsdhjksdfhkshjkshjksdhfjksdhfjksd";
            byte[] data = fileContent.getBytes();

            ENOVIA checkInResultSet = cntMgmtWrapper.ckeckIn(docUUID1,
                                                             fileName,
                                                             vaultName,
                                                             data);

            CAAENOVWSUtils.displayResults(checkInResultSet, 1);

            // ------------------------------------------------------------
            // Step 7 - lock document 2
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 7: lock document2 ");
            System.out.println("--------------------------------------------------------------------------------");
            

            String[] docIDs = { docUUID2 };
            concEngWrapper.lock(docIDs);

            // ------------------------------------------------------------
            // Step 8 - getLock of doc1, doc2 (locked) and partRef
            // ------------------------------------------------------------
            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("Step 8 - getLock of doc1, doc2 (locked) and partRef ");
            System.out.println("--------------------------------------------------------------------------------");
 

            String[] objIDs = { docUUID1, docUUID2, partRefUUID};
            ObjectLockInfo lockInfos []= concEngWrapper.getLock(objIDs);
            

            CAAENOVWSUtils.displayLockInfo(lockInfos);
            // ------------------------------------------------------------
            // Step 9 - transfer  doc1 and partRef ownership
            // ------------------------------------------------------------
            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("Step 9 - transfer  doc1 and partRef ownership ");
            System.out.println("--------------------------------------------------------------------------------");
  	            

            StringTokenizer sToken = new StringTokenizer(newOwnerStr);
            String user = sToken.nextToken(".");
            String org = sToken.nextToken(".");
            String proj = sToken.nextToken(".");
            System.out.println("user="+user+" org="+org+" proj="+proj);
            

            ObjectLockInfo doclock1 = new ObjectLockInfo();
            doclock1.setObjID(CAAENOVWSUtils.toIdentifier(docUUID1));
            doclock1.setUser(user);
            doclock1.setProject(proj);
            doclock1.setOrganization(org);            
           

            ObjectLockInfo partLock2 = new ObjectLockInfo();
            partLock2.setObjID(CAAENOVWSUtils.toIdentifier(partRefUUID));
            partLock2.setUser(user);
            partLock2.setProject(proj);
            partLock2.setOrganization(org);             
         

            ObjectLockInfo newlockInfo[] = {doclock1, partLock2};
            concEngWrapper.transferOwnership(newlockInfo);
            

            // ------------------------------------------------------------
            // Step 10 - getLock of doc1, and partRef to show new user 
            // ------------------------------------------------------------
            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("Step 10 - getLock of doc1, and partRef to see new owner");
            System.out.println("--------------------------------------------------------------------------------");
            String[] newObjIDs = { docUUID1, partRefUUID};
            ObjectLockInfo lockInfos2 []= concEngWrapper.getLock(newObjIDs);
            

            CAAENOVWSUtils.displayLockInfo(lockInfos2);
                

            // ------------------------------------------------------------
            // Step 11 - unlock doc2
            // ------------------------------------------------------------           
            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("Step 11 - unlock doc2");
            System.out.println("--------------------------------------------------------------------------------");
            String[] docIDs2 = { docUUID2 };
            concEngWrapper.unlock(docIDs2);          
            

            success = true;
        } catch (CATServiceExceptionType e) {
            exception = e;
        } catch (Exception e) {
            exception = e;
        } finally {
            // ------------------------------------------------------------
            // Step 12 - Terminate opened session
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 12: Terminating opened session with ENOVIA LCA V5");
            System.out.println("--------------------------------------------------------------------------------");

            // The session must be closed even if a call to a method on the
            try {
                binderWrapper.logout(sessionToken);
            } catch (Exception e) {
                System.err.println("Failed to logout gracefully");
            }
        }

        if (success) {
            System.out.println("================================================================================");
            System.out.println("Use case execution successful");
        } else {
            System.out.println("================================================================================");
            System.out.println("Use case execution failed");
            System.out.println("--------------------------------------------------------------------------------");
            if (exception instanceof CATServiceExceptionType) {
                CATServiceExceptionType e = (CATServiceExceptionType) exception;
                System.out.println("Error code: " + e.getCode());
                System.out.println("Error message: " + e.getMessage1());
                if (e.getErrorArguments() != null) {
                    String[] errorArguments = e.getErrorArguments();
                    System.out.println("Error arguments: " + errorArguments.length);
                    for (int i = 0; i < errorArguments.length; i++) {
                        System.out.println("\tArgument[" + i + "]: " + errorArguments[i]);
                    }
                }
            } else {
                System.out.println(exception.getMessage());
                if (exception.getCause() != null) {
                    // Handle nested exceptions launched from the use case
                    System.out.println("Exception details:");
                    exception.getCause().printStackTrace();
                } else if (exception.getStackTrace() != null && exception.getStackTrace().length != 0) {
                    // Handle unexpected exceptions
                    System.out.println("Exception details:");
                    exception.printStackTrace();
                }
            }
        }
    }
}