Examples with MapperNode com.twinsoft.convertigo.eclipse.views.references.model.MapperNode used on opensource projects

Example 1 with MapperNode

use of com.twinsoft.convertigo.eclipse.views.references.model.MapperNode in project convertigo by convertigo.

the class ReferencesView method handleProjectSelection.

private void handleProjectSelection(Object firstElement) {
    List<String> projectNames = Engine.theApp.databaseObjectsManager.getAllProjectNamesList();
    ProjectExplorerView projectExplorerView = ConvertigoPlugin.getDefault().getProjectExplorerView();
    Project projectSelected = null;
    ProjectTreeObject projectTreeObjectSelected = null;
    UnloadedProjectTreeObject unloadedProjectTreeObjectSelected = null;
    if (firstElement instanceof ProjectTreeObject) {
        projectTreeObjectSelected = (ProjectTreeObject) firstElement;
        projectSelected = projectTreeObjectSelected.getObject();
    } else if (firstElement instanceof UnloadedProjectTreeObject) {
        unloadedProjectTreeObjectSelected = (UnloadedProjectTreeObject) firstElement;
        String projectNameSelected = unloadedProjectTreeObjectSelected.getName();
        projectSelected = getProject(projectNameSelected, projectExplorerView);
    }
    if (projectSelected == null) {
        return;
    }
    String projectNameSelected = projectSelected.getName();
    treeViewer.setInput(null);
    // Get the referencing sequences and transactions
    List<Sequence> sequences = projectSelected.getSequencesList();
    RootNode root = new RootNode();
    ProjectNode projectNode = new ProjectNode(root, projectNameSelected, projectSelected);
    root.addChild(projectNode);
    // Get all the projects needed to successfully execute the selected project
    // i.e. get all CallTransaction and CallSequence steps from the selected project
    // that refer to other projects
    RequiresNode requiresNode = new RequiresNode(root, "Requires");
    // Search for external sequence or transaction referenced by CallSequence or CallTransaction
    // from the selected project
    List<String> transactionList = new ArrayList<String>();
    List<String> sequenceList = new ArrayList<String>();
    for (Sequence sequence : sequences) {
        List<Step> steps = sequence.getSteps();
        for (Step step : steps) {
            getRequiredRequestables(step, projectSelected, projectExplorerView, requiresNode, transactionList, sequenceList);
        }
    }
    UrlMapper urlMapper = projectSelected.getUrlMapper();
    if (urlMapper != null) {
        List<UrlMapping> mappings = urlMapper.getMappingList();
        for (UrlMapping mapping : mappings) {
            List<UrlMappingOperation> operations = mapping.getOperationList();
            for (UrlMappingOperation operation : operations) {
                try {
                    String targetRequestableName = operation.getTargetRequestable();
                    if (!targetRequestableName.isEmpty() && !targetRequestableName.startsWith(projectNameSelected)) {
                        handleTargetRequestable(targetRequestableName, projectExplorerView, requiresNode);
                    }
                } catch (Exception e) {
                    ConvertigoPlugin.logException(e, "Error while analyzing the projects hierarchy", true);
                }
            }
        }
    }
    if (requiresNode.hasChildren()) {
        projectNode.addChild(requiresNode);
    } else {
        projectNode.addChild(new InformationNode(projectNode, "This project does not require any other project"));
    }
    // Get all the projects using the selected project
    // i.e. get all CallTransaction and CallSequence steps that refer to transactions
    // or sequences from the selected project
    IsUsedByNode isUsedByNode = new IsUsedByNode(root, "Is used by");
    for (String projectName : projectNames) {
        if (!(projectName.equals(projectNameSelected))) {
            Project project = getProject(projectName, projectExplorerView);
            if (project == null) {
                // Unable to load the project, just ignore it
                ConvertigoPlugin.logWarning("[References View] Unable to load the project \"" + projectName + "\"", false);
                continue;
            }
            ProjectNode projectFolderExports = new ProjectNode(root, projectName, project);
            urlMapper = project.getUrlMapper();
            if (urlMapper != null) {
                MapperNode mapperNode = new MapperNode(projectFolderExports, urlMapper.getName(), urlMapper);
                List<UrlMapping> mappings = urlMapper.getMappingList();
                for (UrlMapping mapping : mappings) {
                    MappingPathNode pathNode = new MappingPathNode(mapperNode, mapping.getPath(), mapping);
                    List<UrlMappingOperation> operations = mapping.getOperationList();
                    for (UrlMappingOperation operation : operations) {
                        String targetRequestable = operation.getTargetRequestable();
                        if (targetRequestable.startsWith(projectNameSelected + ".")) {
                            MappingOperationNode operationNode = new MappingOperationNode(pathNode, operation.getName(), operation);
                            pathNode.addChild(operationNode);
                        }
                    }
                    if (pathNode.hasChildren()) {
                        mapperNode.addChild(pathNode);
                    }
                }
                if (mapperNode.hasChildren()) {
                    projectFolderExports.addChild(mapperNode);
                }
            }
            List<Sequence> sequencesList = project.getSequencesList();
            for (Sequence sequence : sequencesList) {
                // Search for CallTransaction and CallSequence
                // referencing a transaction or sequence
                // from the selected project
                List<Step> stepList = sequence.getSteps();
                SequenceNode sequenceNode = new SequenceNode(root, sequence.getName(), sequence);
                for (Step step : stepList) {
                    getUsedRequestables(step, projectSelected, sequenceNode);
                }
                if (sequenceNode.hasChildren()) {
                    projectFolderExports.addChild(sequenceNode);
                }
            }
            if (projectFolderExports.hasChildren()) {
                isUsedByNode.addChild(projectFolderExports);
            }
        }
    }
    if (isUsedByNode.hasChildren()) {
        projectNode.addChild(isUsedByNode);
    } else {
        projectNode.addChild(new InformationNode(projectNode, "This project is not used by any other project"));
    }
    treeViewer.setInput(null);
    treeViewer.setInput(root);
    treeViewer.expandAll();
}

Example 2 with MapperNode

use of com.twinsoft.convertigo.eclipse.views.references.model.MapperNode in project convertigo by convertigo.

the class ReferencesView method handleTransactionSelection.

private void handleTransactionSelection(Object firstElement) {
    TransactionTreeObject transactionTreeObject = (TransactionTreeObject) firstElement;
    Transaction transaction = transactionTreeObject.getObject();
    String transactionName = transactionTreeObject.getName();
    // Get the referencing sequence steps
    String transactionProjectName = transaction.getProject().getName();
    String transactionConnectorName = transaction.getParent().getName();
    try {
        Project project = null;
        List<String> projectNames = Engine.theApp.databaseObjectsManager.getAllProjectNamesList();
        ProjectExplorerView projectExplorerView = ConvertigoPlugin.getDefault().getProjectExplorerView();
        treeViewer.setInput(null);
        RootNode root = new RootNode();
        TransactionNode transactionFolder = new TransactionNode(root, transactionName, transaction);
        root.addChild(transactionFolder);
        IsUsedByNode isUsedByNode = new IsUsedByNode(transactionFolder, "Is used by");
        RequiresNode requiresNode = new RequiresNode(transactionFolder, "Requires");
        ProjectNode projectFolder = null;
        // Searching all objects are required transaction selected
        Connector connector = transaction.getConnector();
        if (connector instanceof HtmlConnector) {
            Project proj = ((HtmlConnector) connector).getProject();
            ProjectNode projectNode = new ProjectNode(requiresNode, transactionProjectName, proj);
            HtmlTransaction htmlTransaction = (HtmlTransaction) transaction;
            List<Statement> statements = htmlTransaction.getStatements();
            List<ScreenClass> screenClassList = new ArrayList<ScreenClass>();
            List<String> siteClipperConnectorNames = new ArrayList<String>();
            for (Statement statement : statements) {
                if (statement instanceof ScHandlerStatement) {
                    ScHandlerStatement scHandlerStatement = (ScHandlerStatement) statement;
                    String screenClassName = scHandlerStatement.getNormalizedScreenClassName();
                    ScreenClass screenClass = ((HtmlConnector) connector).getScreenClassByName(screenClassName);
                    if (screenClass != null) {
                        if (!screenClassList.contains(screenClass)) {
                            screenClassList.add(screenClass);
                            requiresNode.addChild(new ScreenClassNode(requiresNode, screenClassName, screenClass));
                        }
                    }
                }
                List<Statement> statementList = ((FunctionStatement) statement).getStatements();
                for (Statement st : statementList) {
                    if (st instanceof ContinueWithSiteClipperStatement) {
                        ContinueWithSiteClipperStatement continueWithSiteClipperStatement = (ContinueWithSiteClipperStatement) st;
                        String siteClipperconnectorName = continueWithSiteClipperStatement.getSiteClipperConnectorName();
                        if (!siteClipperConnectorNames.contains(siteClipperconnectorName)) {
                            siteClipperConnectorNames.add(siteClipperconnectorName);
                            Connector siteClipperConnector = proj.getConnectorByName(siteClipperconnectorName);
                            ConnectorNode connectorSiteClipperNode = new SiteClipperConnectorNode(projectNode, siteClipperconnectorName, siteClipperConnector);
                            projectNode.addChild(connectorSiteClipperNode);
                        }
                    }
                }
            }
            if (projectNode.hasChildren()) {
                requiresNode.addChild(projectNode);
            }
        } else if (connector instanceof JavelinConnector) {
            JavelinTransaction javelinTransaction = (JavelinTransaction) transaction;
            String handlers = javelinTransaction.handlers;
            List<JavelinScreenClass> screenClasses = ((JavelinConnector) connector).getAllScreenClasses();
            List<JavelinScreenClass> screenClassList = new ArrayList<JavelinScreenClass>();
            for (JavelinScreenClass screenClass : screenClasses) {
                if (handlers.indexOf("function on" + screenClass.getName()) != -1) {
                    if (!screenClassList.contains(screenClass)) {
                        screenClassList.add(screenClass);
                        requiresNode.addChild(new ScreenClassNode(requiresNode, screenClass.getName(), screenClass));
                    }
                }
            }
        }
        // Searching all objects are used transaction selected
        for (String projectName : projectNames) {
            project = getProject(projectName, projectExplorerView);
            if (project != null) {
                projectFolder = new ProjectNode(isUsedByNode, project.getName(), project);
                UrlMapper urlMapper = project.getUrlMapper();
                if (urlMapper != null) {
                    MapperNode mapperNode = new MapperNode(projectFolder, urlMapper.getName(), urlMapper);
                    List<UrlMapping> mappings = urlMapper.getMappingList();
                    for (UrlMapping mapping : mappings) {
                        MappingPathNode pathNode = new MappingPathNode(mapperNode, mapping.getPath(), mapping);
                        List<UrlMappingOperation> operations = mapping.getOperationList();
                        for (UrlMappingOperation operation : operations) {
                            String targetRequestable = operation.getTargetRequestable();
                            if (targetRequestable.equals(transactionProjectName + "." + transactionConnectorName + "." + transactionName)) {
                                MappingOperationNode operationNode = new MappingOperationNode(pathNode, operation.getName(), operation);
                                pathNode.addChild(operationNode);
                            }
                        }
                        if (pathNode.hasChildren()) {
                            mapperNode.addChild(pathNode);
                        }
                    }
                    if (mapperNode.hasChildren()) {
                        projectFolder.addChild(mapperNode);
                    }
                }
                List<Sequence> sequences = project.getSequencesList();
                for (Sequence sequence : sequences) {
                    List<Step> stepList = sequence.getAllSteps();
                    SequenceNode sequenceNode = new SequenceNode(projectFolder, sequence.getName(), sequence);
                    for (Step step : stepList) {
                        getTransactionReferencing(step, projectExplorerView, sequenceNode, transactionProjectName, transactionConnectorName, transactionName);
                    }
                    if (sequenceNode.hasChildren()) {
                        projectFolder.addChild(sequenceNode);
                    }
                }
                if (projectFolder.hasChildren()) {
                    isUsedByNode.addChild(projectFolder);
                }
            }
        }
        if (requiresNode.hasChildren()) {
            transactionFolder.addChild(requiresNode);
        }
        if (isUsedByNode.hasChildren()) {
            transactionFolder.addChild(isUsedByNode);
        }
        if (!transactionFolder.hasChildren()) {
            transactionFolder.addChild(new InformationNode(projectFolder, "This transaction is not used in any sequence"));
        }
        treeViewer.setInput(root);
        treeViewer.expandAll();
    } catch (EngineException e) {
        ConvertigoPlugin.logException(e, "Error while analyzing the projects hierarchy", true);
    }
}

Example 3 with MapperNode

use of com.twinsoft.convertigo.eclipse.views.references.model.MapperNode in project convertigo by convertigo.

the class ReferencesView method handleSequenceSelection.

private void handleSequenceSelection(Object firstElement) {
    SequenceTreeObject sequenceTreeObject = (SequenceTreeObject) firstElement;
    Sequence sequenceSelected = sequenceTreeObject.getObject();
    String sequenceSelectedName = sequenceSelected.getName();
    // String sequenceProjectName = sequenceSelected.getProject().getName();
    List<String> projectNames = Engine.theApp.databaseObjectsManager.getAllProjectNamesList();
    ProjectExplorerView projectExplorerView = ConvertigoPlugin.getDefault().getProjectExplorerView();
    treeViewer.setInput(null);
    // Get the referencing sequence steps
    List<String> referencingSequence = new ArrayList<String>();
    RootNode root = new RootNode();
    SequenceNode sequenceFolder = new SequenceNode(root, sequenceSelectedName, sequenceSelected);
    root.addChild(sequenceFolder);
    IsUsedByNode isUsedByNode = new IsUsedByNode(sequenceFolder, "Is used by");
    // Searching all objects that reference the selected sequence
    for (String projectName : projectNames) {
        Project project = getProject(projectName, projectExplorerView);
        if (project != null) {
            ProjectNode projectFolder = null;
            projectFolder = new ProjectNode(isUsedByNode, project.getName(), project);
            List<Sequence> sequences = project.getSequencesList();
            referencingSequence.clear();
            UrlMapper urlMapper = project.getUrlMapper();
            if (urlMapper != null) {
                MapperNode mapperNode = new MapperNode(projectFolder, urlMapper.getName(), urlMapper);
                List<UrlMapping> mappings = urlMapper.getMappingList();
                for (UrlMapping mapping : mappings) {
                    MappingPathNode pathNode = new MappingPathNode(mapperNode, mapping.getPath(), mapping);
                    List<UrlMappingOperation> operations = mapping.getOperationList();
                    for (UrlMappingOperation operation : operations) {
                        String targetRequestable = operation.getTargetRequestable();
                        if (targetRequestable.equals(projectName + "." + sequenceSelectedName)) {
                            MappingOperationNode operationNode = new MappingOperationNode(pathNode, operation.getName(), operation);
                            pathNode.addChild(operationNode);
                        }
                    }
                    if (pathNode.hasChildren()) {
                        mapperNode.addChild(pathNode);
                    }
                }
                if (mapperNode.hasChildren()) {
                    projectFolder.addChild(mapperNode);
                }
            }
            for (Sequence sequence : sequences) {
                List<Step> steps = sequence.getSteps();
                for (Step step : steps) {
                    SequenceNode sequenceNode = new SequenceNode(projectFolder, sequence.getName(), sequence);
                    getSequenceReferencingIsUsedBy(step, sequenceSelected, sequenceNode);
                    if (sequenceNode.hasChildren()) {
                        projectFolder.addChild(sequenceNode);
                    }
                }
            }
            if (projectFolder.hasChildren()) {
                isUsedByNode.addChild(projectFolder);
            }
        }
    }
    List<Step> steps = sequenceSelected.getSteps();
    RequiresNode requiresNode = new RequiresNode(root, "Requires");
    // Searching all objects that are referenced by the selected sequence
    List<String> transactionList = new ArrayList<String>();
    List<String> sequenceList = new ArrayList<String>();
    for (Step step : steps) {
        getSequenceReferencingRequires(step, sequenceSelected, projectExplorerView, requiresNode, transactionList, sequenceList);
    }
    if (requiresNode.hasChildren()) {
        sequenceFolder.addChild(requiresNode);
    }
    if (isUsedByNode.hasChildren()) {
        sequenceFolder.addChild(isUsedByNode);
    }
    if (!sequenceFolder.hasChildren()) {
        sequenceFolder.addChild(new InformationNode(sequenceFolder, "This sequence is not used in any sequence"));
    }
    treeViewer.setInput(root);
    treeViewer.expandAll();
}

Example 4 with MapperNode

use of com.twinsoft.convertigo.eclipse.views.references.model.MapperNode in project convertigo by convertigo.

the class ReferencesView method handleConnectorSelection.

private void handleConnectorSelection(Object firstElement) {
    ConnectorTreeObject connectorTreeObject = (ConnectorTreeObject) firstElement;
    Connector connectorSelected = connectorTreeObject.getObject();
    String connectorSelectedName = connectorSelected.getName();
    Project projectConnectorSelected = connectorSelected.getProject();
    String connectorProjectName = connectorSelected.getProject().getName();
    List<Transaction> transactions = connectorSelected.getTransactionsList();
    try {
        Project project = null;
        List<String> projectNames = Engine.theApp.databaseObjectsManager.getAllProjectNamesList();
        ProjectExplorerView projectExplorerView = ConvertigoPlugin.getDefault().getProjectExplorerView();
        treeViewer.setInput(null);
        RootNode root = new RootNode();
        ConnectorNode connectorNode = null;
        connectorNode = getConnectorNode(root, connectorSelected);
        root.addChild(connectorNode);
        IsUsedByNode isUsedByNode = new IsUsedByNode(connectorNode, "Is used by");
        RequiresNode requiresNode = new RequiresNode(connectorNode, "Requires");
        ProjectNode projectFolder = null;
        // Search handlers are that referenced by the selected connector for continue with site Clipper
        if (connectorSelected instanceof HtmlConnector) {
            ProjectNode projectNode = new ProjectNode(requiresNode, connectorProjectName, projectConnectorSelected);
            for (Transaction transaction : transactions) {
                List<Statement> statements = ((HtmlTransaction) transaction).getStatements();
                List<String> siteClipperConnectorNames = new ArrayList<String>();
                for (Statement statement : statements) {
                    List<Statement> statementList = ((FunctionStatement) statement).getStatements();
                    for (Statement st : statementList) {
                        if (st instanceof ContinueWithSiteClipperStatement) {
                            ContinueWithSiteClipperStatement continueWithSiteClipperStatement = (ContinueWithSiteClipperStatement) st;
                            String siteClipperconnectorName = continueWithSiteClipperStatement.getSiteClipperConnectorName();
                            if (!siteClipperConnectorNames.contains(siteClipperconnectorName)) {
                                siteClipperConnectorNames.add(siteClipperconnectorName);
                                Connector siteClipperConnector = projectConnectorSelected.getConnectorByName(siteClipperconnectorName);
                                ConnectorNode connectorSiteClipperNode = new SiteClipperConnectorNode(projectNode, siteClipperconnectorName, siteClipperConnector);
                                projectNode.addChild(connectorSiteClipperNode);
                            }
                        }
                    }
                }
            }
            if (projectNode.hasChildren()) {
                requiresNode.addChild(projectNode);
            }
        } else if (connectorSelected instanceof SiteClipperConnector) {
            List<Connector> connectors = projectConnectorSelected.getConnectorsList();
            ProjectNode projectNode = new ProjectNode(isUsedByNode, connectorProjectName, projectConnectorSelected);
            for (Connector connector : connectors) {
                if (connector instanceof HtmlConnector) {
                    List<Transaction> transactionList = ((HtmlConnector) connector).getTransactionsList();
                    for (Transaction transaction : transactionList) {
                        List<Statement> statements = ((HtmlTransaction) transaction).getStatements();
                        for (Statement statement : statements) {
                            List<Statement> statementList = ((FunctionStatement) statement).getStatements();
                            for (Statement st : statementList) {
                                if (st instanceof ContinueWithSiteClipperStatement) {
                                    String sourceSiteClipperConnectorName = ((ContinueWithSiteClipperStatement) st).getSiteClipperConnectorName();
                                    if (sourceSiteClipperConnectorName.equals(connectorSelectedName)) {
                                        ContinueWithSiteClipperStatement continueWithSiteClipperStatement = (ContinueWithSiteClipperStatement) st;
                                        HtmlConnectorNode htmlConnectorNode = new HtmlConnectorNode(projectNode, connector.getName(), connector);
                                        projectNode.addChild(htmlConnectorNode);
                                        TransactionNode transactionNode = new TransactionNode(htmlConnectorNode, transaction.getName(), continueWithSiteClipperStatement);
                                        htmlConnectorNode.addChild(transactionNode);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (projectNode.hasChildren()) {
                isUsedByNode.addChild(projectNode);
            }
        }
        // Searching all objects that are referenced by the selected connector
        for (String projectName : projectNames) {
            project = getProject(projectName, projectExplorerView);
            if (project != null) {
                projectFolder = new ProjectNode(isUsedByNode, projectName, project);
                UrlMapper urlMapper = project.getUrlMapper();
                if (urlMapper != null) {
                    MapperNode mapperNode = new MapperNode(projectFolder, urlMapper.getName(), urlMapper);
                    List<UrlMapping> mappings = urlMapper.getMappingList();
                    for (UrlMapping mapping : mappings) {
                        MappingPathNode pathNode = new MappingPathNode(mapperNode, mapping.getPath(), mapping);
                        List<UrlMappingOperation> operations = mapping.getOperationList();
                        for (UrlMappingOperation operation : operations) {
                            String targetRequestable = operation.getTargetRequestable();
                            if (targetRequestable.startsWith(projectConnectorSelected + "." + connectorSelectedName + ".")) {
                                MappingOperationNode operationNode = new MappingOperationNode(pathNode, operation.getName(), operation);
                                pathNode.addChild(operationNode);
                            }
                        }
                        if (pathNode.hasChildren()) {
                            mapperNode.addChild(pathNode);
                        }
                    }
                    if (mapperNode.hasChildren()) {
                        projectFolder.addChild(mapperNode);
                    }
                }
                List<Sequence> sequences = project.getSequencesList();
                for (Sequence sequence : sequences) {
                    List<Step> steps = sequence.getSteps();
                    SequenceNode sequenceNode = new SequenceNode(projectFolder, sequence.getName(), sequence);
                    for (Step step : steps) {
                        getConnectorReferencingIsUsedBy(step, projectExplorerView, sequenceNode, transactions, connectorProjectName, connectorSelectedName);
                    }
                    if (sequenceNode.hasChildren()) {
                        projectFolder.addChild(sequenceNode);
                    }
                }
                if (projectFolder.hasChildren()) {
                    isUsedByNode.addChild(projectFolder);
                }
            }
        }
        if (requiresNode.hasChildren()) {
            connectorNode.addChild(requiresNode);
        }
        if (isUsedByNode.hasChildren()) {
            connectorNode.addChild(isUsedByNode);
        }
        if (!connectorNode.hasChildren()) {
            connectorNode.addChild(new InformationNode(connectorNode, "This connector is not used by any other objects"));
        }
        treeViewer.setInput(root);
        treeViewer.expandAll();
    } catch (EngineException e) {
        ConvertigoPlugin.logException(e, "Error while analyzing the projects hierarchy", true);
    }
}