ModuleController.java

package org.jtheque.views.impl.controllers;

import org.jtheque.collections.CollectionListener;
import org.jtheque.collections.CollectionsService;
import org.jtheque.core.Core;
import org.jtheque.core.lifecycle.LifeCycle;
import org.jtheque.errors.ErrorService;
import org.jtheque.errors.Errors;
import org.jtheque.modules.Module;
import org.jtheque.modules.ModuleException;
import org.jtheque.modules.ModuleException.ModuleOperation;
import org.jtheque.modules.ModuleService;
import org.jtheque.modules.ModuleState;
import org.jtheque.ui.Action;
import org.jtheque.ui.Controller;
import org.jtheque.ui.UIUtils;
import org.jtheque.ui.utils.AbstractController;
import org.jtheque.ui.utils.BetterSwingWorker;
import org.jtheque.updates.InstallationResult;
import org.jtheque.updates.UpdateService;
import org.jtheque.utils.StringUtils;
import org.jtheque.utils.io.SimpleFilter;
import org.jtheque.utils.ui.SwingUtils;
import org.jtheque.views.ViewService;
import org.jtheque.views.panel.ModuleView;
import org.jtheque.views.panel.RepositoryView;

import javax.annotation.Resource;

import java.io.File;

/*
 * Copyright JTheque (Baptiste Wicht)
 *
 * 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.
 */

/**
 * A controller for the module view.
 *
 * @author Baptiste Wicht
 */
public class ModuleController extends AbstractController<ModuleView> {
    @Resource
    private UIUtils uiUtils;

    @Resource
    private ModuleService moduleService;

    @Resource
    private LifeCycle lifeCycle;

    @Resource
    private CollectionsService collectionsService;

    @Resource
    private ErrorService errorService;

    @Resource
    private ViewService viewService;

    @Resource
    private UpdateService updateService;

    @Resource
    private Controller<RepositoryView> repositoryController;

    /**
     * Create a new ModuleController.
     */
    public ModuleController() {
        super(ModuleView.class);
    }

    /**
     * Disable the selected module.
     */
    @Action("modules.actions.disable")
    public void disableModule() {
        Module module = getView().getSelectedModule();

        String error = moduleService.canBeDisabled(module);

        if (StringUtils.isEmpty(error)) {
            new DisableModuleWorker(module).execute();
        } else {
            uiUtils.displayI18nText(error);
        }
    }

    /**
     * Enable the selected module.
     */
    @Action("modules.actions.enable")
    public void enableModule() {
        Module module = getView().getSelectedModule();

        if (module.getState() == ModuleState.DISABLED) {
            if (module.getCoreVersion().isGreaterThan(Core.VERSION)) {
                uiUtils.displayI18nText("modules.message.version.problem");
            } else {
                moduleService.enableModule(module);
                getView().refreshList();
            }
        } else {
            uiUtils.displayI18nText("error.module.not.disabled");
        }
    }

    /**
     * Install a module from a file.
     */
    @Action("modules.actions.file.new")
    public void installFile() {
        File file = SwingUtils.chooseFile(new SimpleFilter("JAR File (*.jar)", "jar"));

        if (file != null) {
            try {
                moduleService.installModule(file);

                uiUtils.displayI18nText("message.module.installed");
            } catch (ModuleException e) {
                addModuleError(e, "error.module.cannot.install");
            }
        }
    }

    /**
     * Add an error to the view from the ModuleException.
     *
     * @param e              The exception.
     * @param defaultMessage The default message if the exception is not internationalized.
     */
    private void addModuleError(ModuleException e, String defaultMessage) {
        if (e.hasI18nMessage()) {
            errorService.addError(Errors.newI18nError(e.getI18nMessage(), e));
        } else {
            errorService.addError(Errors.newI18nError(defaultMessage, e));
        }
    }

    /**
     * Install a module from an URL.
     */
    @Action("modules.actions.url.new")
    public void installURL() {
        String url = uiUtils.askI18nText("dialogs.modules.installFromRepository.url");

        if (StringUtils.isNotEmpty(url)) {
            InstallationResult result = updateService.installModule(url);

            if (result.isInstalled()) {
                try {
                    moduleService.installFromRepository(result.getJarFile());
                } catch (ModuleException e) {
                    addModuleError(e, "error.repository.module.not.installed");
                }
            } else {
                uiUtils.displayI18nText("error.repository.module.not.installed");
            }
        }
    }

    /**
     * Uninstall the given module.
     */
    @Action("modules.actions.uninstall")
    public void uninstallModule() {
        Module module = getView().getSelectedModule();

        String error = moduleService.canBeUninstalled(module);

        if (StringUtils.isEmpty(error)) {
            boolean confirm = uiUtils.askI18nUserForConfirmation(
                    "dialogs.confirm.uninstall",
                    "dialogs.confirm.uninstall.title");

            if (confirm) {
                try {
                    moduleService.uninstallModule(module);
                } catch (ModuleException e) {
                    if (e.getOperation() == ModuleOperation.STOP) {
                        addModuleError(e, "error.module.cannot.stop");
                    } else if (e.getOperation() == ModuleOperation.UNINSTALL) {
                        addModuleError(e, "error.module.cannot.uninstall");
                    }
                }

                getView().refreshList();
            }
        } else {
            uiUtils.displayI18nText(error);
        }
    }

    /**
     * Stop the selected module.
     */
    @Action("modules.actions.stop")
    public void stopModule() {
        final Module module = getView().getSelectedModule();

        String error = moduleService.canBeStopped(module);

        if (StringUtils.isEmpty(error)) {
            new StopModuleWorker(module).execute();
        } else {
            uiUtils.displayI18nText(error);
        }
    }

    /**
     * Start the selected module.
     */
    @Action("modules.actions.start")
    public void startModule() {
        Module module = getView().getSelectedModule();

        String error = moduleService.canBeStarted(module);

        if (StringUtils.isEmpty(error)) {
            if (moduleService.needTwoPhasesLoading(module)) {
                getView().closeDown();
                viewService.displayCollectionView();
                collectionsService.addCollectionListener(new StartModuleWorker(module));
            } else {
                new StartModuleWorker(module).execute();
            }
        } else {
            uiUtils.displayI18nText(error);
        }
    }

    /**
     * Update the selected module.
     */
    @Action("modules.actions.update")
    public void updateModule() {
        final Module module = getView().getSelectedModule();

        if (updateService.isUpToDate(module)) {
            uiUtils.displayI18nText("message.update.no.version");
        } else {
            new UpdateModuleWorker(module).execute();
        }
    }

    /**
     * Update the core.
     */
    @Action("modules.actions.update.kernel")
    public void updateCore() {
        if (updateService.isCurrentVersionUpToDate()) {
            uiUtils.displayI18nText("message.update.no.version");
        } else {
            new UpdateCoreWorker().execute();
        }
    }

    /**
     * Display the repository.
     */
    @Action("modules.actions.repository")
    public void repository() {
        repositoryController.getView().display();
    }

    /**
     * A simple swing worker to make work in the module view. The module view is waiting during the operations.
     *
     * @author Baptiste Wicht
     */
    private abstract class ModuleWorker extends BetterSwingWorker {
        @Override
        protected final void before() {
            getView().getWindowState().startWait();
        }

        @Override
        protected final void done() {
            getView().refreshList();
            getView().getWindowState().stopWait();
        }
    }

    /**
     * A simple swing worker to start the module.
     *
     * @author Baptiste Wicht
     */
    private final class StartModuleWorker extends ModuleWorker implements CollectionListener {
        private final Module module;

        /**
         * Construct a new StartModuleWorker for the given module.
         *
         * @param module The module to start.
         */
        private StartModuleWorker(Module module) {
            this.module = module;
        }

        @Override
        protected void doInBackground() {
            try {
                moduleService.startModule(module);
            } catch (ModuleException e) {
                addModuleError(e, "error.module.cannot.start");
            }
        }

        @Override
        public void collectionChosen() {
            collectionsService.removeCollectionListener(this);

            viewService.closeCollectionView();

            execute();

            getView().display();
        }
    }

    /**
     * A simple swing worker to stop the module.
     *
     * @author Baptiste Wicht
     */
    private final class StopModuleWorker extends ModuleWorker {
        private final Module module;

        /**
         * Construct a new StopModuleWorker for the given module.
         *
         * @param module The module to start.
         */
        private StopModuleWorker(Module module) {
            this.module = module;
        }

        @Override
        protected void doInBackground() {
            try {
                moduleService.stopModule(module);
            } catch (ModuleException e) {
                addModuleError(e, "error.module.cannot.stop");
            }
        }
    }

    /**
     * A simple swing worker to disable the module.
     *
     * @author Baptiste Wicht
     */
    private final class DisableModuleWorker extends ModuleWorker {
        private final Module module;

        /**
         * Construct a new DisableModuleWorker for the given module.
         *
         * @param module The module to disable.
         */
        private DisableModuleWorker(Module module) {
            this.module = module;
        }

        @Override
        protected void doInBackground() {
            try {
                moduleService.disableModule(module);
            } catch (ModuleException e) {
                addModuleError(e, "error.module.cannot.stop");
            }
        }
    }

    /**
     * A simple swing worker to update the core.
     *
     * @author Baptiste Wicht
     */
    private final class UpdateCoreWorker extends ModuleWorker {
        @Override
        protected void doInBackground() {
            updateService.updateCore();
            lifeCycle.restart();
        }
    }

    /**
     * A simple swing worker to update a module.
     *
     * @author Baptiste Wicht
     */
    private final class UpdateModuleWorker extends ModuleWorker {
        private final Module module;

        /**
         * Construct a new UpdateModuleWorker for the given module.
         *
         * @param module The module to start.
         */
        private UpdateModuleWorker(Module module) {
            this.module = module;
        }

        @Override
        protected void doInBackground() {
            boolean restart = false;

            if (module.getState() == ModuleState.STARTED) {
                try {
                    moduleService.stopModule(module);
                } catch (ModuleException e) {
                    addModuleError(e, "error.module.cannot.stop");

                    return;
                }

                restart = true;
            }

            updateService.update(module);

            if (restart) {
                try {
                    moduleService.startModule(module);
                } catch (ModuleException e) {
                    addModuleError(e, "error.module.cannot.start");
                }
            }
        }
    }
}