MigrateModel.java

package org.ovirt.engine.ui.uicommonweb.models.vms;

import java.util.ArrayList;
import java.util.List;

import org.ovirt.engine.core.common.businessentities.Cluster;
import org.ovirt.engine.core.common.businessentities.VDS;
import org.ovirt.engine.core.common.businessentities.VM;
import org.ovirt.engine.core.compat.Guid;
import org.ovirt.engine.ui.uicommonweb.Linq;
import org.ovirt.engine.ui.uicommonweb.UICommand;
import org.ovirt.engine.ui.uicommonweb.dataprovider.AsyncDataProvider;
import org.ovirt.engine.ui.uicommonweb.models.EntityModel;
import org.ovirt.engine.ui.uicommonweb.models.HasEntity;
import org.ovirt.engine.ui.uicommonweb.models.ListModel;
import org.ovirt.engine.ui.uicommonweb.models.Model;
import org.ovirt.engine.ui.uicompat.ConstantsManager;
import org.ovirt.engine.ui.uicompat.Event;
import org.ovirt.engine.ui.uicompat.EventArgs;
import org.ovirt.engine.ui.uicompat.PropertyChangedEventArgs;

@SuppressWarnings("unused")
public class MigrateModel extends Model {

    private ListModel<VDS> privateHosts;
    private VmListModel<?> parentModel;
    private VM vm;

    public ListModel<VDS> getHosts() {
        return privateHosts;
    }

    private void setHosts(ListModel<VDS> value) {
        privateHosts = value;
    }

    private ListModel<Cluster> clusters;

    public ListModel<Cluster> getClusters() {
        return clusters;
    }

    public void setClusters(ListModel<Cluster> clusters) {
        this.clusters = clusters;
    }

    private ArrayList<VM> privateVmList;

    public ArrayList<VM> getVmList() {
        return privateVmList;
    }

    public void setVmList(ArrayList<VM> value) {
        privateVmList = value;
    }

    private boolean privateVmsOnSameCluster;

    public boolean getVmsOnSameCluster() {
        return privateVmsOnSameCluster;
    }

    public void setVmsOnSameCluster(boolean value) {
        privateVmsOnSameCluster = value;
    }

    private boolean isAutoSelect;

    public boolean getIsAutoSelect() {
        return isAutoSelect;
    }

    public void setIsAutoSelect(boolean value) {
        if (isAutoSelect != value) {
            isAutoSelect = value;
            getHosts().setIsChangeable(!isAutoSelect);
            onPropertyChanged(new PropertyChangedEventArgs("IsAutoSelect")); //$NON-NLS-1$
            setIsSameVdsMessageVisible(!value);
            privateSelectHostAutomatically_IsSelected.setEntity(value);
            privateSelectDestinationHost_IsSelected.setEntity(!value);
            privateHosts.setIsChangeable(!value);
        }
    }

    private boolean isHostSelAvailable;

    public boolean getIsHostSelAvailable() {
        return isHostSelAvailable;
    }

    public void setIsHostSelAvailable(boolean value) {
        if (isHostSelAvailable != value) {
            isHostSelAvailable = value;
            onPropertyChanged(new PropertyChangedEventArgs("IsHostSelAvailable")); //$NON-NLS-1$
        }
    }

    private boolean noSelAvailable;

    public boolean getNoSelAvailable() {
        return noSelAvailable;
    }

    public void setNoSelAvailable(boolean value) {
        if (noSelAvailable != value) {
            noSelAvailable = value;
            onPropertyChanged(new PropertyChangedEventArgs("NoSelAvailable")); //$NON-NLS-1$
        }
    }

    private boolean isSameVdsMessageVisible;

    public boolean getIsSameVdsMessageVisible() {
        return isSameVdsMessageVisible;
    }

    public void setIsSameVdsMessageVisible(boolean value) {
        isSameVdsMessageVisible = value && gethasSameVdsMessage() && !getIsAutoSelect();
        onPropertyChanged(new PropertyChangedEventArgs("IsSameVdsMessageVisible")); //$NON-NLS-1$
    }

    // onPropertyChanged(new PropertyChangedEventArgs("IsSameVdsMessageVisible"));
    private boolean privatehasSameVdsMessage;

    public boolean gethasSameVdsMessage() {
        return privatehasSameVdsMessage;
    }

    public void sethasSameVdsMessage(boolean value) {
        privatehasSameVdsMessage = value;
    }

    private EntityModel<Boolean> privateSelectHostAutomatically_IsSelected;

    public EntityModel<Boolean> getSelectHostAutomatically_IsSelected() {
        return privateSelectHostAutomatically_IsSelected;
    }

    public void setSelectHostAutomatically_IsSelected(EntityModel<Boolean> value) {
        privateSelectHostAutomatically_IsSelected = value;
    }

    private EntityModel<Boolean> privateSelectDestinationHost_IsSelected;

    public EntityModel<Boolean> getSelectDestinationHost_IsSelected() {
        return privateSelectDestinationHost_IsSelected;
    }

    public void setSelectDestinationHost_IsSelected(EntityModel<Boolean> value) {
        privateSelectDestinationHost_IsSelected = value;
    }

    public MigrateModel(VmListModel<?> parentModel) {
        this.parentModel = parentModel;
        setHosts(new ListModel<VDS>());
        getHosts().getSelectedItemChangedEvent().addListener(this);

        setSelectHostAutomatically_IsSelected(new EntityModel<Boolean>());
        getSelectHostAutomatically_IsSelected().getEntityChangedEvent().addListener(this);

        setSelectDestinationHost_IsSelected(new EntityModel<Boolean>());
        getSelectDestinationHost_IsSelected().getEntityChangedEvent().addListener(this);

        setClusters(new ListModel<Cluster>());
        getClusters().getSelectedItemChangedEvent().addListener(this);
    }

    public void initializeModel() {
        if (vm.getClusterId() == null) {
            return;
        }

        AsyncDataProvider.getInstance().getClusterList(
                new AsyncQuery<>(clusterList -> {
                    List<Cluster> onlyWithArchitecture = AsyncDataProvider.getInstance().filterClustersWithoutArchitecture(clusterList);
                    List<Cluster> onlyVirt = AsyncDataProvider.getInstance().getClusterByServiceList(onlyWithArchitecture, true, false);


                    Cluster selected = null;
                    for (Cluster cluster : onlyVirt) {
                        if (cluster.getId().equals(vm.getClusterId())) {
                            selected = cluster;
                            break;
                        }
                    }

                    clusters.setItems(onlyVirt, selected != null ? selected : Linq.firstOrNull(onlyVirt));
                }),
                vm.getStoragePoolId());
    }

    private void loadHosts() {
        Cluster selectedCluster = clusters.getSelectedItem();
        if (selectedCluster == null) {
            return;
        }

        AsyncDataProvider.getInstance().getUpHostListByCluster(new AsyncQuery<>(
                returnValue -> postMigrateGetUpHosts(privateVmList, returnValue)), selectedCluster.getName());
    }

    private void postMigrateGetUpHosts(List<VM> selectedVms, List<VDS> hosts) {
        setVmsOnSameCluster(true);
        setIsSameVdsMessageVisible(false);
        setNoSelAvailable(false);

        Guid run_on_vds = null;
        boolean allRunOnSameVds = true;

        for (VM item : selectedVms) {
            if (!item.getClusterId().equals((selectedVms.get(0)).getClusterId())) {
                setVmsOnSameCluster(false);
            }
            if (run_on_vds == null) {
                run_on_vds = item.getRunOnVds();
            }
            else if (allRunOnSameVds && !run_on_vds.equals(item.getRunOnVds())) {
                allRunOnSameVds = false;
            }
        }

        setIsHostSelAvailable(getVmsOnSameCluster() && hosts.size() > 0);

        removeUnselectableHosts(hosts, run_on_vds, allRunOnSameVds);

        getCommands().clear();

        if (hosts.isEmpty()) {
            setIsHostSelAvailable(false);
            getHosts().setItems(new ArrayList<VDS>());

            if (allRunOnSameVds) {
                setNoSelAvailable(true);
                UICommand tempVar = new UICommand("Cancel", parentModel); //$NON-NLS-1$
                tempVar.setTitle(ConstantsManager.getInstance().getConstants().close());
                tempVar.setIsDefault(true);
                tempVar.setIsCancel(true);
                getCommands().add(tempVar);
            }
        } else {
            getHosts().setItems(hosts, Linq.firstOrNull(hosts));
            getCommands().add(UICommand.createDefaultOkUiCommand("OnMigrate", parentModel)); //$NON-NLS-1$
            getCommands().add(UICommand.createCancelUiCommand("Cancel", parentModel)); //$NON-NLS-1$
        }
    }

    private void removeUnselectableHosts(List<VDS> hosts, Guid run_on_vds, boolean allRunOnSameVds) {
        if (getVmsOnSameCluster() && allRunOnSameVds) {
            VDS runOnSameVDS = null;
            for (VDS host : hosts) {
                if (host.getId().equals(run_on_vds)) {
                    runOnSameVDS = host;
                }
            }
            hosts.remove(runOnSameVDS);
        }
    }

    @Override
    public void eventRaised(Event<? extends EventArgs> ev, Object sender, EventArgs args) {
        super.eventRaised(ev, sender, args);
        if (sender == getHosts() && getVmsOnSameCluster()) {
            VDS selectedHost = getHosts().getSelectedItem();
            if (selectedHost == null) {
                return;
            }

            sethasSameVdsMessage(false);
            for (VM vm : getVmList()) {
                if (selectedHost.getId().equals(vm.getRunOnVds())) {
                    sethasSameVdsMessage(true);
                    break;
                }
            }
            setIsSameVdsMessageVisible(gethasSameVdsMessage());
        }
        else if (sender == getClusters()) {
            loadHosts();
        }
        else if (ev.matchesDefinition(HasEntity.entityChangedEventDefinition)) {
            if (sender == getSelectHostAutomatically_IsSelected()) {
                setIsAutoSelect(getSelectHostAutomatically_IsSelected().getEntity());
            }
            else if (sender == getSelectDestinationHost_IsSelected()) {
                setIsAutoSelect(!getSelectDestinationHost_IsSelected().getEntity());
            }
        }
    }

    public void setVm(VM vm) {
        this.vm = vm;
    }
}