Examples with MigrationProblems com.liferay.ide.project.core.upgrade.MigrationProblems used on opensource projects

Example 1 with MigrationProblems

use of com.liferay.ide.project.core.upgrade.MigrationProblems in project liferay-ide by liferay.

the class MigrationUtil method _removeProblemFromMigrationContainer.

private static boolean _removeProblemFromMigrationContainer(String projectName, MigrationProblemsContainer container) {
    boolean removed = false;
    if (container != null) {
        List<MigrationProblems> problems = new ArrayList<>(Arrays.asList(container.getProblemsArray()));
        for (MigrationProblems mp : problems) {
            if (mp.getSuffix().equals(projectName)) {
                problems.remove(mp);
                removed = true;
                break;
            }
        }
        try {
            if (ListUtil.isNotEmpty(problems)) {
                container.setProblemsArray(problems.toArray(new MigrationProblems[0]));
                UpgradeAssistantSettingsUtil.setObjectToStore(MigrationProblemsContainer.class, container);
            } else {
                UpgradeAssistantSettingsUtil.setObjectToStore(MigrationProblemsContainer.class, null);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
    return removed;
}

Example 2 with MigrationProblems

use of com.liferay.ide.project.core.upgrade.MigrationProblems in project liferay-ide by liferay.

the class RemoveAction method run.

@Override
public void run() {
    // final MigrationView mv = (MigrationView) UIUtil.showView( MigrationView.ID );
    // final CommonViewer commonViewer = mv.getCommonViewer();
    final FindBreakingChangesPage page = UpgradeView.getPage(Page.findbreackingchangesPageId, FindBreakingChangesPage.class);
    final TreeViewer treeViewer = page.getTreeViewer();
    Object selection = treeViewer.getStructuredSelection().getFirstElement();
    if (selection instanceof MigrationProblems) {
        MigrationProblems migrationProblem = (MigrationProblems) selection;
        MigrationUtil.removeMigrationProblems(migrationProblem);
        IResource project = MigrationUtil.getResourceFromMigrationProblems(migrationProblem);
        if (project != null) {
            MarkerUtil.clearMarkers(project, MigrationConstants.MARKER_TYPE, null);
        }
    }
    treeViewer.setInput(CoreUtil.getWorkspaceRoot());
    treeViewer.expandToLevel(2);
}

Example 3 with MigrationProblems

use of com.liferay.ide.project.core.upgrade.MigrationProblems in project liferay-ide by liferay.

the class MigrateProjectHandler method findMigrationProblems.

public void findMigrationProblems(final IPath[] locations, final String[] projectName) {
    Job job = new WorkspaceJob("Finding migration problems...") {

        @Override
        public IStatus runInWorkspace(final IProgressMonitor monitor) throws CoreException {
            IStatus retval = Status.OK_STATUS;
            final BundleContext context = FrameworkUtil.getBundle(getClass()).getBundleContext();
            ProgressMonitor override = new ProgressMonitor() {

                @Override
                public void beginTask(String taskName, int totalWork) {
                    monitor.beginTask(taskName, totalWork);
                }

                @Override
                public void done() {
                    monitor.done();
                }

                @Override
                public boolean isCanceled() {
                    return monitor.isCanceled();
                }

                @Override
                public void setTaskName(String taskName) {
                    monitor.setTaskName(taskName);
                }

                @Override
                public void worked(int work) {
                    monitor.worked(work);
                }
            };
            try {
                final ServiceReference<Migration> sr = context.getServiceReference(Migration.class);
                final Migration m = context.getService(sr);
                List<Problem> allProblems = null;
                boolean singleFile = false;
                if ((locations.length == 1) && locations[0].toFile().exists() && locations[0].toFile().isFile()) {
                    singleFile = true;
                }
                MigrationProblemsContainer container = null;
                if (_combineExistedProblem == true) {
                    container = UpgradeAssistantSettingsUtil.getObjectFromStore(MigrationProblemsContainer.class);
                }
                List<MigrationProblems> migrationProblemsList = new ArrayList<>();
                if (container == null) {
                    container = new MigrationProblemsContainer();
                }
                if (container.getProblemsArray() != null) {
                    List<MigrationProblems> mpList = Arrays.asList(container.getProblemsArray());
                    for (MigrationProblems mp : mpList) {
                        migrationProblemsList.add(mp);
                    }
                }
                for (int j = 0; j < locations.length; j++) {
                    allProblems = new ArrayList<>();
                    if (!override.isCanceled() && _shouldSearch(locations[j].toFile())) {
                        List<Problem> problems = null;
                        if (singleFile) {
                            _clearFileMarkers(locations[j].toFile());
                            Set<File> files = new HashSet<>();
                            files.add(locations[j].toFile());
                            problems = m.findProblems(files, override);
                        } else {
                            problems = m.findProblems(locations[j].toFile(), override);
                        }
                        for (Problem problem : problems) {
                            if (_shouldAdd(problem)) {
                                allProblems.add(problem);
                            }
                        }
                    }
                    if (ListUtil.isNotEmpty(allProblems)) {
                        _addMarkers(allProblems);
                        MigrationProblems migrationProblems = new MigrationProblems();
                        FileProblems[] fileProblems = FileProblemsUtil.newFileProblemsListFrom(allProblems.toArray(new Problem[0]));
                        migrationProblems.setProblems(fileProblems);
                        migrationProblems.setType("Code Problems");
                        migrationProblems.setSuffix(projectName[j]);
                        int index = _isAlreadyExist(migrationProblemsList, projectName, j);
                        if (index != -1) {
                            if (singleFile) {
                                UpgradeProblems up = migrationProblemsList.get(index);
                                FileProblems[] problems = up.getProblems();
                                for (int n = 0; n < problems.length; n++) {
                                    FileProblems fp = problems[n];
                                    String problemFilePath = fp.getFile().getPath();
                                    String initProblemFilePath = locations[0].toFile().getPath();
                                    if (problemFilePath.equals(initProblemFilePath)) {
                                        problems[n] = fileProblems[0];
                                        break;
                                    }
                                }
                                migrationProblems.setProblems(problems);
                            }
                            migrationProblemsList.set(index, migrationProblems);
                        } else {
                            migrationProblemsList.add(migrationProblems);
                        }
                    } else {
                        int index = _isAlreadyExist(migrationProblemsList, projectName, j);
                        if (index != -1) {
                            if (singleFile) {
                                MigrationProblems mp = migrationProblemsList.get(index);
                                FileProblems[] fps = mp.getProblems();
                                List<FileProblems> fpList = Arrays.asList(fps);
                                List<FileProblems> newFPList = new ArrayList<>();
                                for (FileProblems fp : fpList) {
                                    String problemFilePath = fp.getFile().getPath();
                                    String initProblemFilePath = locations[0].toFile().getPath();
                                    if (!problemFilePath.equals(initProblemFilePath)) {
                                        newFPList.add(fp);
                                    }
                                }
                                mp.setProblems(newFPList.toArray(new FileProblems[0]));
                                migrationProblemsList.set(index, mp);
                            } else {
                                migrationProblemsList.remove(index);
                            }
                        }
                    }
                }
                if (ListUtil.isNotEmpty(migrationProblemsList)) {
                    container.setProblemsArray(migrationProblemsList.toArray(new MigrationProblems[0]));
                    UpgradeAssistantSettingsUtil.setObjectToStore(MigrationProblemsContainer.class, container);
                } else {
                    UpgradeAssistantSettingsUtil.setObjectToStore(MigrationProblemsContainer.class, null);
                }
                if (singleFile) {
                    refreshViewer(allProblems);
                } else {
                    allProblems.add(new Problem());
                    m.reportProblems(allProblems, Migration.DETAIL_LONG, "ide");
                }
            } catch (Exception e) {
                retval = ProjectUI.createErrorStatus("Error in migrate command", e);
            }
            return retval;
        }
    };
    try {
        ProjectUI.getProgressService().showInDialog(Display.getDefault().getActiveShell(), job);
    } catch (Exception e) {
    }
    job.schedule();
}

Example 4 with MigrationProblems

use of com.liferay.ide.project.core.upgrade.MigrationProblems in project liferay-ide by liferay.

the class MigrateProjectHandler method refreshViewer.

protected void refreshViewer(List<Problem> allProblems) {
    FindBreakingChangesPage page = UpgradeView.getPage(Page.findbreackingchangesPageId, FindBreakingChangesPage.class);
    TableViewer problemsViewer = page.get_problemsViewer();
    TreeViewer treeViewer = page.getTreeViewer();
    UIUtil.async(new Runnable() {

        @Override
        public void run() {
            problemsViewer.setInput(allProblems);
            Object currentTreeNode = treeViewer.getStructuredSelection().getFirstElement();
            String currentPath = null;
            if (currentTreeNode instanceof FileProblems) {
                FileProblems currentNode = (FileProblems) currentTreeNode;
                File currentFile = currentNode.getFile();
                currentPath = currentFile.getAbsolutePath();
            }
            MigrationContentProvider contentProvider = (MigrationContentProvider) treeViewer.getContentProvider();
            MigrationProblemsContainer mc = (MigrationProblemsContainer) contentProvider.getProblems().get(0);
            for (MigrationProblems project : mc.getProblemsArray()) {
                Iterator<FileProblems> fileProblemItertor = new LinkedList<>(Arrays.asList(project.getProblems())).iterator();
                while (fileProblemItertor.hasNext()) {
                    FileProblems fileProblem = fileProblemItertor.next();
                    File file = fileProblem.getFile();
                    String fileAbsolutePath = file.getAbsolutePath();
                    if (fileAbsolutePath.equals(currentPath)) {
                        List<Problem> problems = fileProblem.getProblems();
                        problems.clear();
                        problems.addAll(allProblems);
                        break;
                    }
                }
            }
        }
    });
}

Example 5 with MigrationProblems

use of com.liferay.ide.project.core.upgrade.MigrationProblems in project liferay-ide by liferay.

the class MigrationUtil method updateMigrationProblemToStore.

public static void updateMigrationProblemToStore(Problem problem) {
    File file = problem.getFile();
    try {
        MigrationProblemsContainer container = UpgradeAssistantSettingsUtil.getObjectFromStore(MigrationProblemsContainer.class);
        boolean found = false;
        for (MigrationProblems mp : container.getProblemsArray()) {
            for (FileProblems fileProblem : mp.getProblems()) {
                if (fileProblem.getFile().equals(file)) {
                    for (int i = 0; i < fileProblem.getProblems().size(); i++) {
                        Problem p = fileProblem.getProblems().get(i);
                        if (p.equals(problem)) {
                            fileProblem.getProblems().set(i, problem);
                            found = true;
                            break;
                        }
                    }
                }
                if (found) {
                    break;
                }
            }
            if (found) {
                break;
            }
        }
        UpgradeAssistantSettingsUtil.setObjectToStore(MigrationProblemsContainer.class, container);
    } catch (IOException ioe) {
    }
}