CAA Web Services Home

public class CAAENOVWSLCMgmtCppWrapper {
    private String SERVICE_ID = "urn:com:dassault_systemes:ENOVWSLCMgmtImpl:ENOVWSLCMgmtImpl:ENOVWSLCMgmtCpp";
    private ILCMgmtWS proxy = null;

    /**
     * Creates a new proxy for the ENOVWSLCMgmtCpp 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 ENOVWSLCMgmtCpp CAA Web service
     * @param timeOut the proxy timeout
     */
    public CAAENOVWSLCMgmtCppWrapper(String clientId, String uri, int timeOut) {
        // Compute the SOAP endpoint URI value that bounds to the deployed
        // implementation of the ENOVWSLCMgmtCpp CAA Web service
        String endpoint = uri + "servicerouter?service=" + SERVICE_ID;

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

        // Required for HTTP session state management on the current proxy
        ((ILCMgmtWSBindingStub) 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.getENOVWSLCMgmtCppPortWSDDServiceName();
            QName name = new QName(portName);
            List chain = registry.getHandlerChain(name);
            chain.add(info);
        }

        // Increase the default client time-out
        ((ILCMgmtWSBindingStub) proxy).setTimeout(timeOut);
    }

 }

public class CAAENOVWSLCMgmtCppWrapper {
...
    public void applyTransition(String objectUUID, String transitionName)
            throws Exception {
        System.out.println(">>> Invoking 'applyTransition' on ENOVWSLCMgmtCpp CAA Web service proxy");
        if (objectUUID == null) {
            throw new IllegalArgumentException("Object UUID is null");
        } else if (transitionName == null) {
            throw new IllegalArgumentException("Transition name is null");
        }
        System.out.println("Object UUID: " + objectUUID);
        System.out.println("Transition name: " + transitionName);

        // Create input data
        Identifier objectId = CAAENOVWSUtils.toIdentifier(objectUUID);

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

public class CAAENOVWSLCMgmtCppWrapper {
 ....
    public String[] getTransitions(String objectUUID) throws Exception {
        System.out.println(">>> Invoking 'getTransitions' on ENOVWSLCMgmtCpp CAA Web service proxy");
        if (objectUUID == null) {
            throw new IllegalArgumentException("Object UUID is null");
        }
        System.out.println("Object UUID: " + objectUUID);

        // Create input data
        Identifier objectId = CAAENOVWSUtils.toIdentifier(objectUUID);
        StringArrayTypeHolder transitionNames = new StringArrayTypeHolder();

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

        if (transitionNames == null || transitionNames.value == null) {
            throw new Exception("Failed to get transitions");
        }
        return transitionNames.value;
    }
}

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

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

    public void runSampleUsageScenario(String enoviaUser) {
        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 classes
            binderWrapper = new CAAENOPosApplicationBinderImplWrapper(clientId,
                    uri, credUser, credPwd, timeOut);
            CAAENOVWSProdStructCppWrapper prodStructWrapper = new CAAENOVWSProdStructCppWrapper(
                    clientId, uri, timeOut);
            CAAENOVWSLCMgmtCppWrapper lcMgmtWrapper = new CAAENOVWSLCMgmtCppWrapper(
                    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 a part reference to test with
            // ------------------------------------------------------------

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

            ENOVIA createPartResultSet = prodStructWrapper.createPartRef(new String[] { "ILCMgmtWS_CAA_PartRef1" },
                                                                         "",
                                                                         "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];

            // ------------------------------------------------------------
            // Step 4 - Get 'Promote' transition
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 4: Getting transitions");
            System.out.println("--------------------------------------------------------------------------------");

            String[] transitionNames = lcMgmtWrapper.getTransitions(partRefUUID);

            for (int i = 0; i < transitionNames.length; i++) {
                System.out.println("Transition[" + i + "]: " + transitionNames[i]);
            }

            // ------------------------------------------------------------
            // Step 5 - Apply default transition
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 5: Applying 'Promote' transition");
            System.out.println("--------------------------------------------------------------------------------");

            // As we just created the part, there should only be 1 transition,
            // 'Promote'
            if (transitionNames.length == 0) {
                throw new Exception("Failed to get default transition");
            } else if (transitionNames.length != 1 || !"Promote".equals(transitionNames[0])) {
                throw new Exception(
                        "Use case does not handle customized lifecycle");
            }

            lcMgmtWrapper.applyTransition(partRefUUID, transitionNames[0]);

            // ------------------------------------------------------------
            // Step 6 - Get transitions
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 6: Getting transitions");
            System.out.println("--------------------------------------------------------------------------------");

            transitionNames = lcMgmtWrapper.getTransitions(partRefUUID);

            for (int i = 0; i < transitionNames.length; i++) {
                System.out.println("Transition[" + i + "]: " + transitionNames[i]);
            }

            // ------------------------------------------------------------
            // Step 7 - Apply 'Demote' transition
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 7: Applying 'Demote' transition");
            System.out.println("--------------------------------------------------------------------------------");

            // As we promoted the part, there should now only be 2 transitions,
            // 'Promote' & 'Demote'
            if (transitionNames.length == 0) {
                throw new Exception("Failed to get default transition");
            } else if (transitionNames.length != 2 || !"Promote".equals(transitionNames[0]) || !"Demote".equals(transitionNames[1])) {
                throw new Exception(
                        "Use case does not handle customized lifecycle");
            }

            // Apply 'Demote' transition
            lcMgmtWrapper.applyTransition(partRefUUID, transitionNames[1]);

            // ------------------------------------------------------------
            // Step 8 - Get default transition again
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 8: Getting transitions");
            System.out.println("--------------------------------------------------------------------------------");

            transitionNames = lcMgmtWrapper.getTransitions(partRefUUID);

            // As we demoted the part, we should be back to the same start state
            for (int i = 0; i < transitionNames.length; i++) {
                System.out.println("Transition[" + i + "]: " + transitionNames[i]);
            }

            if (transitionNames.length != 1 || !"Promote".equals(transitionNames[0])) {
                throw new Exception("Failed to return to initial state");
            }

            // ------------------------------------------------------------
            // Step 9 - Cleanup by deleting created part reference
            // ------------------------------------------------------------

            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("STEP 9: Deleting part reference");
            System.out.println("--------------------------------------------------------------------------------");

            prodStructWrapper.deletePartRef(new String[] { partRefUUID });

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

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

            // The session must be closed even if a call to a method on the
            // ENOVWSLCMgmtCpp CAA Web service fails
            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.getMessage());
                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();
                }
            }
        }
    }
}