All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.zaproxy.zap.extension.autoupdate.AddOnDependencyChecker Maven / Gradle / Ivy

    /*
 * Zed Attack Proxy (ZAP) and its related class files.
 *
 * ZAP is an HTTP/HTTPS proxy for assessing web application security.
 *
 * Copyright 2015 The ZAP Development Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.zaproxy.zap.extension.autoupdate;

import java.awt.BorderLayout;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.SwingConstants;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
import org.apache.commons.collections.CollectionUtils;
import org.jdesktop.swingx.JXTable;
import org.parosproxy.paros.Constant;
import org.parosproxy.paros.extension.Extension;
import org.zaproxy.zap.control.AddOn;
import org.zaproxy.zap.control.AddOnCollection;

/**
 * Helper class that checks the dependency changes when an add-on, or several add-ons, are
 * installed, uninstalled or updated.
 *
 * 
    It also allows to confirm with the user the resulting changes.
 *
 * @since 2.4.0
 */
class AddOnDependencyChecker {

    private final AddOnCollection installedAddOns;
    private final AddOnCollection availableAddOns;

    public AddOnDependencyChecker(
            AddOnCollection installedAddOns, AddOnCollection availableAddOns) {
        this.installedAddOns = installedAddOns;
        this.availableAddOns = availableAddOns;
    }

    private static boolean contains(Collection addOns, AddOn addOn) {
        for (AddOn ao : addOns) {
            if (addOn.isSameAddOn(ao)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Calculates the changes required to install the given add-on.
     *
     * 
    It might require updating, installing or uninstalling other add-ons depending on the
     * dependencies of the affected add-ons.
     *
     * @param addOn the add-on that would be installed
     * @return the resulting changes with the add-ons that need to be updated, installed or
     *     uninstalled
     */
    public AddOnChangesResult calculateInstallChanges(AddOn addOn) {
        Set addOns = new HashSet<>();
        addOns.add(addOn);

        return calculateInstallChanges(addOns);
    }

    /**
     * Calculates the changes required to install the given add-ons.
     *
     * 
    It might require updating, installing or uninstalling other add-ons depending on the
     * dependencies of the affected add-ons.
     *
     * @param selectedAddOns the add-ons that would be installed
     * @return the resulting changes with the add-ons that need to be updated, installed or
     *     uninstalled
     */
    public AddOnChangesResult calculateInstallChanges(Set selectedAddOns) {
        return calculateChanges(selectedAddOns, false);
    }

    /**
     * Asks the user for confirmation of install changes.
     *
     * @param parent the parent component of the confirmation dialogue
     * @param changes the changes of the installation
     * @return {@code true} if the user accept the changes, {@code false} otherwise
     */
    public boolean confirmInstallChanges(Component parent, AddOnChangesResult changes) {
        return confirmChanges(parent, changes, false);
    }

    private boolean addDependencies(
            AddOn addOn,
            Set selectedAddOns,
            Set oldVersions,
            Set newVersions,
            Set installs) {
        AddOn.AddOnRunRequirements requirements =
                addOn.calculateInstallRequirements(availableAddOns.getAddOns());

        for (AddOn dep : requirements.getDependencies()) {
            if (selectedAddOns.contains(dep)) {
                continue;
            }

            AddOn installed = installedAddOns.getAddOn(dep.getId());
            if (installed == null) {
                if (AddOn.InstallationStatus.AVAILABLE
                        == availableAddOns.getAddOn(dep.getId()).getInstallationStatus()) {
                    installs.add(dep);
                }
            } else if (dep.isUpdateTo(installed)) {
                if (AddOn.InstallationStatus.AVAILABLE
                        == availableAddOns.getAddOn(dep.getId()).getInstallationStatus()) {
                    oldVersions.add(installed);
                    newVersions.add(dep);
                }
            }
        }

        return requirements.isNewerJavaVersionRequired();
    }

    private boolean confirmChanges(
            Component parent, AddOnChangesResult changesResult, boolean updating) {
        Set selectedAddOnsJavaIssue = new HashSet<>();
        for (AddOn addOn : changesResult.getSelectedAddOns()) {
            if (!addOn.canRunInCurrentJavaVersion()) {
                selectedAddOnsJavaIssue.add(addOn);
            }
        }

        String question;

        Set installs = new HashSet<>(changesResult.getInstalls());
        Set updates = new HashSet<>(changesResult.getNewVersions());

        Set dependents = getDependents(updates, changesResult.getUninstalls());

        if (updating) {
            question =
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.message.continueWithUpdate");
            updates.removeAll(changesResult.getSelectedAddOns());
        } else {
            question =
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.message.continueWithInstallation");
            installs.removeAll(changesResult.getSelectedAddOns());
        }

        if (changesResult.getUninstalls().isEmpty()
                && updates.isEmpty()
                && installs.isEmpty()
                && dependents.isEmpty()
                && changesResult.getOptionalAddOns().isEmpty()
                && changesResult.getSoftUnloadExtensions().isEmpty()
                && changesResult.getUnloadExtensions().isEmpty()) {
            // No other changes required.
            if (selectedAddOnsJavaIssue.isEmpty()) {
                // No need to ask for confirmation.
                return true;
            }

            int size = changesResult.getSelectedAddOns().size();
            if (size == 1) {
                String baseMessage =
                        Constant.messages.getString(
                                "cfu.confirmation.dialogue.message.selectedAddOnNewerJavaVersion",
                                changesResult
                                        .getSelectedAddOns()
                                        .iterator()
                                        .next()
                                        .getMinimumJavaVersion());
                return JOptionPane.showConfirmDialog(
                                parent,
                                baseMessage + question,
                                Constant.PROGRAM_NAME,
                                JOptionPane.YES_NO_OPTION)
                        == JOptionPane.YES_OPTION;
            }

            String mainMessage;
            if (selectedAddOnsJavaIssue.size() == size) {
                mainMessage =
                        Constant.messages.getString(
                                "cfu.confirmation.dialogue.message.addOnsNewerJavaVersion");
            } else {
                mainMessage =
                        Constant.messages.getString(
                                "cfu.confirmation.dialogue.message.someSelectedAddOnsNewerJavaVersion");
            }

            JLabel label =
                    new JLabel(
                            Constant.messages.getString(
                                    "cfu.confirmation.dialogue.message.warnAddOnsNotRunJavaVersion"),
                            ManageAddOnsDialog.ICON_ADD_ON_ISSUES,
                            SwingConstants.LEADING);

            Object[] msgs = {
                mainMessage,
                createScrollableTable(
                        new AddOnTableModel(
                                selectedAddOnsJavaIssue, selectedAddOnsJavaIssue.size())),
                label,
                question
            };

            return JOptionPane.showConfirmDialog(
                            parent, msgs, Constant.PROGRAM_NAME, JOptionPane.YES_NO_OPTION)
                    == JOptionPane.YES_OPTION;
        }

        JPanel panel = new JPanel(new BorderLayout());
        JTabbedPane tabs = new JTabbedPane();
        panel.add(tabs);

        int issues = selectedAddOnsJavaIssue.size();

        if (!selectedAddOnsJavaIssue.isEmpty()) {
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.selectedAddOns"),
                    createScrollableTable(
                            new AddOnTableModel(
                                    selectedAddOnsJavaIssue, selectedAddOnsJavaIssue.size())));
        }

        if (!changesResult.getUninstalls().isEmpty()) {
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.uninstallations"),
                    createScrollableTable(
                            new AddOnTableModel(changesResult.getUninstalls(), false)));
        }

        if (!updates.isEmpty()) {
            AddOnTableModel model = new AddOnTableModel(updates);
            issues += model.getMinimumJavaVersionIssues();
            tabs.add(
                    Constant.messages.getString("cfu.confirmation.dialogue.tab.header.updates"),
                    createScrollableTable(model));
        }

        if (!installs.isEmpty()) {
            AddOnTableModel model = new AddOnTableModel(installs);
            issues += model.getMinimumJavaVersionIssues();
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.installations"),
                    createScrollableTable(model));
        }

        if (!dependents.isEmpty()) {
            AddOnTableModel model = new AddOnTableModel(dependents);
            issues += model.getMinimumJavaVersionIssues();
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.softUninstalls"),
                    createScrollableTable(model));
        }

        SelectableAddOnTableModel optionalAddOnsTableModel = null;
        if (!changesResult.getOptionalAddOns().isEmpty()) {
            optionalAddOnsTableModel =
                    new SelectableAddOnTableModel(
                            Constant.messages.getString("cfu.generic.table.header.selectInstall"),
                            changesResult.getOptionalAddOns());
            issues += optionalAddOnsTableModel.getMinimumJavaVersionIssues();
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.optionalAddOns"),
                    createScrollableTable(optionalAddOnsTableModel));
        }

        if (!changesResult.getUnloadExtensions().isEmpty()) {
            ExtensionsTableModel model =
                    new ExtensionsTableModel(changesResult.getUnloadExtensions());
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.extensionUnloads"),
                    createScrollableTable(model));
        }

        if (!changesResult.getSoftUnloadExtensions().isEmpty()) {
            ExtensionsTableModel model =
                    new ExtensionsTableModel(changesResult.getSoftUnloadExtensions());
            tabs.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.tab.header.extensionSoftUnloads"),
                    createScrollableTable(model));
        }

        List optionPaneContents = new ArrayList<>();

        if (!changesResult.getOptionalAddOns().isEmpty()
                && changesResult.getUninstalls().isEmpty()
                && updates.isEmpty()
                && installs.isEmpty()
                && dependents.isEmpty()
                && changesResult.getSoftUnloadExtensions().isEmpty()
                && changesResult.getUnloadExtensions().isEmpty()) {
            optionPaneContents.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.message.suggestedChanges"));
        } else if (!changesResult.getOptionalAddOns().isEmpty()) {
            optionPaneContents.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.message.requiredSuggestedChanges"));
        } else {
            optionPaneContents.add(
                    Constant.messages.getString(
                            "cfu.confirmation.dialogue.message.requiredChanges"));
        }

        optionPaneContents.add(panel);

        if (issues != 0) {
            String message;
            if (selectedAddOnsJavaIssue.size() == issues) {
                if (selectedAddOnsJavaIssue.size() == changesResult.getSelectedAddOns().size()) {
                    message =
                            Constant.messages.getString(
                                    "cfu.confirmation.dialogue.message.selectedAddOnsNewerJavaVersion");
                } else {
                    message =
                            Constant.messages.getString(
                                    "cfu.confirmation.dialogue.message.someUnnamedSelectedAddOnsNewerJavaVersion");
                }
            } else if (issues == 1) {
                message =
                        Constant.messages.getString(
                                "cfu.confirmation.dialogue.message.addOnNewerJavaVersion");
            } else {
                message =
                        Constant.messages.getString(
                                "cfu.confirmation.dialogue.message.someAddOnsNewerJavaVersion");
            }

            JLabel label =
                    new JLabel(
                            Constant.messages.getString(
                                    "cfu.confirmation.dialogue.message.warnUnknownNumberAddOnsNotRunJavaVersion"),
                            ManageAddOnsDialog.ICON_ADD_ON_ISSUES,
                            SwingConstants.LEADING);

            optionPaneContents.add(message);
            optionPaneContents.add(label);
        }

        optionPaneContents.add(question);

        boolean confirmed =
                JOptionPane.showConfirmDialog(
                                parent,
                                optionPaneContents.toArray(),
                                Constant.PROGRAM_NAME,
                                JOptionPane.YES_NO_OPTION)
                        == JOptionPane.YES_OPTION;

        if (confirmed && optionalAddOnsTableModel != null) {
            changesResult.getInstalls().addAll(optionalAddOnsTableModel.getSelectedAddOns());
        }

        return confirmed;
    }

    private Set getDependents(Set updates, Set ignoreAddOns) {
        Set dependents = new HashSet<>();
        for (AddOn update : updates) {
            addDependents(dependents, update, ignoreAddOns);
        }
        return dependents;
    }

    private void addDependents(Set dependents, AddOn addOn, Set ignoreAddOns) {
        for (AddOn availableAddOn : installedAddOns.getInstalledAddOns()) {
            if (!ignoreAddOns.contains(availableAddOn)
                    && availableAddOn.dependsOn(addOn)
                    && dependents.contains(availableAddOn)) {
                dependents.add(availableAddOn);
                addDependents(dependents, availableAddOn, ignoreAddOns);
            }
        }
    }

    private static JScrollPane createScrollableTable(TableModel model) {
        JXTable table = new JXTable(model);
        table.setColumnControlVisible(true);
        table.setVisibleRowCount(Math.min(model.getRowCount() + 1, 5));
        table.packAll();
        return new JScrollPane(table);
    }

    /**
     * Calculates the changes required to update the given add-on.
     *
     * 
    It might require updating, installing or uninstalling other add-ons depending on the
     * dependencies of the affected add-ons.
     *
     * @param addOn the add-on that would be updated
     * @return the resulting changes with the add-ons that need to be updated, installed or
     *     uninstalled
     * @since 2.4.3
     */
    public AddOnChangesResult calculateUpdateChanges(AddOn addOn) {
        Set addOns = new HashSet<>();
        addOns.add(addOn);
        return calculateUpdateChanges(addOns);
    }

    /**
     * Calculates the changes required to update the given add-ons.
     *
     * 
    It might require updating, installing or uninstalling other add-ons depending on the
     * dependencies of the affected add-ons.
     *
     * @param addOns the add-ons that would be updated
     * @return the resulting changes with the add-ons that need to be updated, installed or
     *     uninstalled
     */
    public AddOnChangesResult calculateUpdateChanges(Set addOns) {
        return calculateChanges(addOns, true);
    }

    /**
     * Asks the user for confirmation of update changes.
     *
     * @param parent the parent component of the confirmation dialogue
     * @param changes the changes of the update
     * @return {@code true} if the user accept the changes, {@code false} otherwise
     */
    public boolean confirmUpdateChanges(Component parent, AddOnChangesResult changes) {
        return confirmChanges(parent, changes, true);
    }

    private AddOnChangesResult calculateChanges(Set selectedAddOns, boolean updating) {
        Set oldVersions = new HashSet<>();
        Set uninstalls = new HashSet<>();
        Set newVersions = new HashSet<>();
        Set installs = new HashSet<>();

        if (updating) {
            for (AddOn update : selectedAddOns) {
                AddOn oldVersion = installedAddOns.getAddOn(update.getId());
                oldVersions.add(oldVersion);
            }
        }

        boolean newerJavaVersion = false;
        for (AddOn addOn : selectedAddOns) {
            newerJavaVersion |=
                    addDependencies(addOn, selectedAddOns, oldVersions, newVersions, installs);
        }

        Set remainingInstalledAddOns = new HashSet<>();
        for (AddOn addOn : installedAddOns.getAddOns()) {
            if (!contains(selectedAddOns, addOn) && !contains(newVersions, addOn)) {
                remainingInstalledAddOns.add(addOn);
            }
        }

        Set changedAddOns = new HashSet<>();
        changedAddOns.addAll(selectedAddOns);
        changedAddOns.addAll(installs);
        changedAddOns.addAll(newVersions);

        Set expectedInstalledAddOns = new HashSet<>(remainingInstalledAddOns);
        expectedInstalledAddOns.addAll(changedAddOns);

        changedAddOns.addAll(oldVersions);

        for (AddOn addOn : remainingInstalledAddOns) {
            if (addOn.dependsOn(changedAddOns)
                    && addOn.calculateInstallRequirements(expectedInstalledAddOns)
                            .hasDependencyIssue()) {
                uninstalls.add(addOn);
            }
        }

        for (Iterator it = uninstalls.iterator(); it.hasNext(); ) {
            AddOn addOn = it.next();
            AddOn addOnUpdate = availableAddOns.getAddOn(addOn.getId());
            if (addOnUpdate != null && !addOnUpdate.equals(addOn)) {
                it.remove();
                oldVersions.add(addOn);
                newVersions.add(addOnUpdate);
                newerJavaVersion |=
                        addDependencies(
                                addOnUpdate, selectedAddOns, oldVersions, newVersions, installs);
            }
        }

        for (Iterator it = uninstalls.iterator(); it.hasNext(); ) {
            AddOn addOn = it.next();
            if (contains(installs, addOn)
                    || contains(newVersions, addOn)
                    || (addOn.calculateInstallRequirements(installedAddOns.getAddOns())
                                    .hasDependencyIssue()
                            && !containsAny(addOn.getIdsAddOnDependencies(), uninstalls))) {
                it.remove();
            }
        }

        if (updating) {
            newVersions.addAll(selectedAddOns);
        } else {
            installs.addAll(selectedAddOns);
        }

        expectedInstalledAddOns = new HashSet<>(remainingInstalledAddOns);
        expectedInstalledAddOns.removeAll(uninstalls);
        expectedInstalledAddOns.removeAll(oldVersions);
        expectedInstalledAddOns.addAll(installs);
        expectedInstalledAddOns.addAll(newVersions);

        Set unloadExtensions = new HashSet<>();
        Set softUnloadExtensions = new HashSet<>();
        Set optionalAddOns = new HashSet<>();
        for (AddOn addOn : expectedInstalledAddOns) {
            List extensionsWithDeps = addOn.getExtensionsWithDeps();
            for (Extension extension : addOn.getLoadedExtensionsWithDeps()) {
                AddOn.AddOnRunRequirements requirements =
                        addOn.calculateExtensionInstallRequirements(
                                extension, expectedInstalledAddOns);
                AddOn.ExtensionRunRequirements extReqs =
                        requirements.getExtensionRequirements().get(0);
                if (!extReqs.isRunnable()) {
                    unloadExtensions.add(extension);
                } else if (CollectionUtils.containsAny(extReqs.getDependencies(), oldVersions)) {
                    softUnloadExtensions.add(extension);
                }
                extensionsWithDeps.remove(extReqs.getClassname());
            }

            for (String classname : extensionsWithDeps) {
                AddOn.AddOnRunRequirements requirements =
                        addOn.calculateExtensionInstallRequirements(
                                classname, availableAddOns.getAddOns());
                AddOn.ExtensionRunRequirements extReqs =
                        requirements.getExtensionRequirements().get(0);
                if (extReqs.isRunnable()) {
                    optionalAddOns.addAll(extReqs.getDependencies());
                }
            }
        }

        optionalAddOns.removeAll(installs);
        optionalAddOns.removeAll(newVersions);
        optionalAddOns.removeAll(remainingInstalledAddOns);

        return new AddOnChangesResult(
                selectedAddOns,
                oldVersions,
                uninstalls,
                newVersions,
                installs,
                newerJavaVersion,
                optionalAddOns,
                unloadExtensions,
                softUnloadExtensions);
    }

    /**
     * Calculates the changes required to uninstall the given add-ons.
     *
     * 
    It might require uninstalling other add-ons depending on the dependencies of the affected
     * add-ons.
     *
     * @param selectedAddOns the add-ons that would be uninstalled
     * @return the resulting changes with the add-ons that need to be uninstalled
     */
    public UninstallationResult calculateUninstallChanges(Set selectedAddOns) {
        List remainingAddOns = new ArrayList<>(installedAddOns.getAddOns());
        remainingAddOns.removeAll(selectedAddOns);

        Set uninstallations = new HashSet<>();
        List addOnsToCheck = new ArrayList<>(remainingAddOns);
        while (!addOnsToCheck.isEmpty()) {
            AddOn addOn = addOnsToCheck.remove(0);
            AddOn.AddOnRunRequirements requirements =
                    addOn.calculateInstallRequirements(remainingAddOns);

            if (!requirements.hasDependencyIssue()) {
                addOnsToCheck.removeAll(requirements.getDependencies());
            } else if (AddOn.InstallationStatus.UNINSTALLATION_FAILED
                    != addOn.getInstallationStatus()) {
                uninstallations.add(addOn);
            }
        }

        for (Iterator it = uninstallations.iterator(); it.hasNext(); ) {
            AddOn addOn = it.next();
            if (addOn.calculateInstallRequirements(installedAddOns.getAddOns()).hasDependencyIssue()
                    && !containsAny(addOn.getIdsAddOnDependencies(), uninstallations)) {
                it.remove();
            }
        }

        remainingAddOns.removeAll(uninstallations);
        Set extensions = new HashSet<>();
        for (AddOn addOn : remainingAddOns) {
            if (addOn.hasExtensionsWithDeps()) {
                for (Extension ext : addOn.getLoadedExtensions()) {
                    AddOn.AddOnRunRequirements requirements =
                            addOn.calculateExtensionInstallRequirements(ext, remainingAddOns);
                    if (!requirements.getExtensionRequirements().isEmpty()) {
                        AddOn.ExtensionRunRequirements extReqs =
                                requirements.getExtensionRequirements().get(0);
                        if (!extReqs.isRunnable()) {
                            extensions.add(ext);
                        }
                    }
                }
            }
        }

        uninstallations.addAll(selectedAddOns);
        return new UninstallationResult(selectedAddOns, uninstallations, extensions);
    }

    private boolean containsAny(List addOnIds, Collection addOns) {
        for (String id : addOnIds) {
            for (AddOn addOn : addOns) {
                if (id.equals(addOn.getId())) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Asks the user for confirmation of uninstall changes.
     *
     * 
    User will also be warned about add-ons that are being uninstalled which are required by
     * add-ons being downloaded.
     *
     * @param parent the parent component of the confirmation dialogue
     * @param result the calculation result of the uninstallation
     * @param addOnsBeingDownloaded the add-ons being downloaded to check if depend on the add-ons
     *     being uninstalled
     * @return {@code true} if the user accept the changes, {@code false} otherwise
     */
    public boolean confirmUninstallChanges(
            Component parent, UninstallationResult result, Set addOnsBeingDownloaded) {

        Set forcedUninstallations = new HashSet<>(result.getUninstallations());
        forcedUninstallations.removeAll(result.getSelectedAddOns());

        boolean dependencyDownloadFound = false;
        for (AddOn addOnDownloading : addOnsBeingDownloaded) {
            if (containsAny(addOnDownloading.getIdsAddOnDependencies(), forcedUninstallations)) {
                dependencyDownloadFound = true;
                break;
            }
        }

        if (!dependencyDownloadFound) {
            for (AddOn addOnDownloading : addOnsBeingDownloaded) {
                if (containsAny(
                        addOnDownloading.getIdsAddOnDependencies(), result.getSelectedAddOns())) {
                    dependencyDownloadFound = true;
                    break;
                }
            }
        }

        if (dependencyDownloadFound) {
            if (JOptionPane.showConfirmDialog(
                            parent,
                            new Object[] {
                                Constant.messages.getString(
                                        "cfu.confirmation.dialogue.message.uninstallsRequiredByAddOnsDownloading"),
                                Constant.messages.getString(
                                        "cfu.confirmation.dialogue.message.continueWithUninstallation")
                            },
                            Constant.PROGRAM_NAME,
                            JOptionPane.YES_NO_OPTION)
                    != JOptionPane.YES_OPTION) {
                return false;
            }
        }

        if (forcedUninstallations.isEmpty() && result.getExtensions().isEmpty()) {
            return JOptionPane.showConfirmDialog(
                            parent,
                            Constant.messages.getString("cfu.uninstall.confirm"),
                            Constant.PROGRAM_NAME,
                            JOptionPane.YES_NO_OPTION)
                    == JOptionPane.YES_OPTION;
        }

        if (result.getExtensions().isEmpty()) {
            return JOptionPane.showConfirmDialog(
                            parent,
                            new Object[] {
                                Constant.messages.getString(
                                        "cfu.uninstall.dependentAddOns.confirm"),
                                createScrollableTable(
                                        new AddOnTableModel(forcedUninstallations, false)),
                                Constant.messages.getString(
                                        "cfu.confirmation.dialogue.message.continueWithUninstallation")
                            },
                            Constant.PROGRAM_NAME,
                            JOptionPane.YES_NO_OPTION)
                    == JOptionPane.YES_OPTION;
        }

        if (forcedUninstallations.isEmpty()) {
            return JOptionPane.showConfirmDialog(
                            parent,
                            new Object[] {
                                Constant.messages.getString(
                                        "cfu.uninstall.dependentExtensions.confirm"),
                                createScrollableTable(
                                        new ExtensionsTableModel(result.getExtensions())),
                                Constant.messages.getString(
                                        "cfu.confirmation.dialogue.message.continueWithUninstallation")
                            },
                            Constant.PROGRAM_NAME,
                            JOptionPane.YES_NO_OPTION)
                    == JOptionPane.YES_OPTION;
        }

        JPanel panel = new JPanel(new BorderLayout());
        JTabbedPane tabs = new JTabbedPane();
        panel.add(tabs);

        tabs.add(
                Constant.messages.getString("cfu.confirmation.dialogue.tab.header.uninstallations"),
                createScrollableTable(new AddOnTableModel(forcedUninstallations, false)));

        tabs.add(
                Constant.messages.getString(
                        "cfu.confirmation.dialogue.tab.header.extensionUnloads"),
                createScrollableTable(new ExtensionsTableModel(result.getExtensions())));

        List optionPaneContents = new ArrayList<>();
        optionPaneContents.add(
                Constant.messages.getString("cfu.uninstall.dependentAddonsAndExtensions.confirm"));
        optionPaneContents.add(panel);
        optionPaneContents.add(
                Constant.messages.getString(
                        "cfu.confirmation.dialogue.message.continueWithUninstallation"));

        return JOptionPane.showConfirmDialog(
                        parent,
                        optionPaneContents.toArray(),
                        Constant.PROGRAM_NAME,
                        JOptionPane.YES_NO_OPTION)
                == JOptionPane.YES_OPTION;
    }

    /**
     * The result of an installation or update of add-on(s).
     *
     * 
    Contains all add-ons that need to be installed, updated and uninstalled as the result of
     * the changes.
     */
    public static class AddOnChangesResult {

        private final Set selectedAddOns;
        private final Set oldVersions;
        private final Set uninstalls;
        private final Set newVersions;
        private final Set installs;
        private final boolean newerJavaVersion;
        private final Set optionalAddOns;
        private final Set unloadExtensions;
        private final Set softUnloadExtensions;

        private AddOnChangesResult(
                Set selectedAddOns,
                Set oldVersions,
                Set uninstalls,
                Set newVersions,
                Set installs,
                boolean newerJavaVersion,
                Set optionalAddOns,
                Set unloadExtensions,
                Set softUnloadExtensions) {
            this.selectedAddOns = selectedAddOns;
            this.oldVersions = oldVersions;
            this.uninstalls = uninstalls;
            this.newVersions = newVersions;
            this.installs = installs;
            this.newerJavaVersion = newerJavaVersion;
            this.optionalAddOns = optionalAddOns;
            this.unloadExtensions = unloadExtensions;
            this.softUnloadExtensions = softUnloadExtensions;
        }

        /**
         * Gets the add-ons selected for installation or updated.
         *
         * @return the add-ons selected for installation or updated
         */
        public Set getSelectedAddOns() {
            return selectedAddOns;
        }

        /**
         * Gets old versions of the add-ons that need to be updated as result of the changes.
         *
         * @return the old versions of the add-ons that need to be updated
         */
        public Set getOldVersions() {
            return oldVersions;
        }

        /**
         * Gets the add-ons that need to be uninstalled as result of the changes.
         *
         * @return the the add-ons that need to be uninstalled
         */
        public Set getUninstalls() {
            return uninstalls;
        }

        /**
         * Gets the new versions of add-ons that need to be updated as result of the changes.
         *
         * @return the new versions of the add-ons
         */
        public Set getNewVersions() {
            return newVersions;
        }

        /**
         * Gets the add-ons that need to be installed as result of the changes.
         *
         * @return the add-ons that need to be installed
         * @see #getNewVersions()
         */
        public Set getInstalls() {
            return installs;
        }

        /**
         * Tells whether or not a newer Java version is required by any of add-ons as result of the
         * changes.
         *
         * @return {@code true} if a newer Java version is required by any of the add-ons, {@code
         *     false} otherwise
         */
        public boolean isNewerJavaVersionRequired() {
            return newerJavaVersion;
        }

        /**
         * Gets the optional add-ons.
         *
         * @return the optional add-ons
         */
        public Set getOptionalAddOns() {
            return optionalAddOns;
        }

        /**
         * Gets the extensions that have to be unloaded as result of the changes.
         *
         * @return the extensions that have to be unloaded
         */
        public Set getUnloadExtensions() {
            return unloadExtensions;
        }

        /**
         * Gets the extensions that have to be soft unloaded as result of the changes. The extension
         * will be unloaded and then loaded once the dependency is updated-
         *
         * @return the extensions that have to be soft unloaded
         */
        public Set getSoftUnloadExtensions() {
            return softUnloadExtensions;
        }

        /**
         * Add the contents from the specified results
         *
         * @param result
         */
        public void addResults(AddOnChangesResult result) {
            selectedAddOns.addAll(result.getSelectedAddOns());
            oldVersions.addAll(result.oldVersions);
            uninstalls.addAll(result.getUninstalls());
            newVersions.addAll(result.getNewVersions());
            installs.addAll(result.getInstalls());
            optionalAddOns.addAll(result.getOptionalAddOns());
            unloadExtensions.addAll(result.getUnloadExtensions());
            softUnloadExtensions.addAll(result.getSoftUnloadExtensions());
        }
    }

    /**
     * The result of an uninstallation of add-on(s).
     *
     * 
    Contains all add-ons that need to be uninstalled as the result of an uninstallation or
     * several.
     */
    public static class UninstallationResult {

        private final Set selectedAddOns;
        private final Set uninstallations;
        private final Set extensions;

        private UninstallationResult(
                Set selectedAddOns, Set uninstallations, Set extensions) {
            this.selectedAddOns = selectedAddOns;
            this.uninstallations = uninstallations;
            this.extensions = extensions;
        }

        /**
         * Gets the add-ons selected for uninstallation.
         *
         * @return the add-ons selected for uninstallation
         */
        public Set getSelectedAddOns() {
            return selectedAddOns;
        }

        /**
         * Gets all the add-ons (selected and dependencies) that need to be uninstalled as result of
         * the uninstallations.
         *
         * @return all the add-ons that need to be uninstalled
         */
        public Set getUninstallations() {
            return uninstallations;
        }

        /**
         * Gets the extensions that are affected by the changes, but not its add-on.
         *
         * @return the extensions affected by the changes
         */
        public Set getExtensions() {
            return extensions;
        }
    }

    @SuppressWarnings("serial")
    private static class AddOnTableModel extends AbstractTableModel {

        private static final long serialVersionUID = 5446781970087315105L;

        private static final String[] COLUMNS = {
            Constant.messages.getString("cfu.generic.table.header.addOn"),
            Constant.messages.getString("cfu.generic.table.header.version"),
            Constant.messages.getString("cfu.generic.table.header.minimumJavaVersion")
        };

        private final List addOns;
        private final int columnCount;
        private final int issues;

        public AddOnTableModel(Collection addOns) {
            this(addOns, true);
        }

        public AddOnTableModel(Collection addOns, boolean checkMinimumJavaVersion) {
            this.addOns = new ArrayList<>(addOns);

            int count = 0;
            if (checkMinimumJavaVersion) {
                for (AddOn addOn : addOns) {
                    if (!addOn.canRunInCurrentJavaVersion()) {
                        ++count;
                    }
                }
            }
            issues = count;
            columnCount = issues != 0 ? COLUMNS.length : COLUMNS.length - 1;
        }

        public AddOnTableModel(Collection addOns, int numberOfIssues) {
            this.addOns = new ArrayList<>(addOns);
            issues = numberOfIssues;
            columnCount = numberOfIssues != 0 ? COLUMNS.length : COLUMNS.length - 1;
        }

        public int getMinimumJavaVersionIssues() {
            return issues;
        }

        @Override
        public String getColumnName(int column) {
            return COLUMNS[column];
        }

        @Override
        public int getColumnCount() {
            return columnCount;
        }

        @Override
        public int getRowCount() {
            return addOns.size();
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            AddOn addOn = getAddOn(rowIndex);
            switch (columnIndex) {
                case 0:
                    return addOn.getName();
                case 1:
                    return addOn.getVersion();
                case 2:
                    return addOn.getMinimumJavaVersion();
                default:
                    return "";
            }
        }

        protected AddOn getAddOn(int rowIndex) {
            return addOns.get(rowIndex);
        }
    }

    private static class SelectableAddOnTableModel extends AddOnTableModel {

        private static final long serialVersionUID = 2337381848530495407L;

        private final String selectionRowName;
        private final Boolean[] selections;

        public SelectableAddOnTableModel(String selectionRowName, Collection addOns) {
            super(addOns, true);

            this.selectionRowName = selectionRowName;
            selections = new Boolean[addOns.size()];
            for (int i = 0; i < selections.length; i++) {
                selections[i] = Boolean.FALSE;
            }
        }

        @Override
        public String getColumnName(int column) {
            if (column == 0) {
                return selectionRowName;
            }
            return super.getColumnName(column - 1);
        }

        @Override
        public int getColumnCount() {
            return super.getColumnCount() + 1;
        }

        @Override
        public Class getColumnClass(int columnIndex) {
            if (columnIndex == 0) {
                return Boolean.class;
            }
            return super.getColumnClass(columnIndex - 1);
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            if (columnIndex == 0) {
                return selections[rowIndex];
            }
            return super.getValueAt(rowIndex, columnIndex - 1);
        }

        @Override
        public boolean isCellEditable(int rowIndex, int columnIndex) {
            return columnIndex == 0;
        }

        @Override
        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
            if (columnIndex == 0 && aValue instanceof Boolean) {
                selections[rowIndex] = (Boolean) aValue;
                fireTableCellUpdated(rowIndex, columnIndex);
            }
        }

        public List getSelectedAddOns() {
            List selectedAddOns = new ArrayList<>(selections.length);
            for (int i = 0; i < selections.length; i++) {
                if (selections[i]) {
                    selectedAddOns.add(getAddOn(i));
                }
            }
            return selectedAddOns;
        }
    }

    @SuppressWarnings("serial")
    private static class ExtensionsTableModel extends AbstractTableModel {

        private static final long serialVersionUID = 5446781970087315105L;

        private static final String[] COLUMNS = {
            Constant.messages.getString("cfu.generic.table.header.extension")
        };

        private final List extensions;

        public ExtensionsTableModel(Collection extensions) {
            this.extensions = new ArrayList<>(extensions);
        }

        @Override
        public String getColumnName(int column) {
            return COLUMNS[column];
        }

        @Override
        public int getColumnCount() {
            return COLUMNS.length;
        }

        @Override
        public int getRowCount() {
            return extensions.size();
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            Extension extension = extensions.get(rowIndex);
            switch (columnIndex) {
                case 0:
                    return extension.getUIName();
                default:
                    return "";
            }
        }
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy