package org.ovirt.engine.ui.uicommonweb.models.clusters;
import org.ovirt.engine.core.common.businessentities.gluster.GlusterHookContentType;
import org.ovirt.engine.core.common.businessentities.gluster.GlusterHookEntity;
import org.ovirt.engine.core.common.businessentities.gluster.GlusterHookStatus;
import org.ovirt.engine.core.common.businessentities.gluster.GlusterServerHook;
import org.ovirt.engine.ui.uicommonweb.dataprovider.AsyncDataProvider;
import org.ovirt.engine.ui.uicommonweb.models.EntityModel;
import org.ovirt.engine.ui.uicommonweb.models.ListModel;
import org.ovirt.engine.ui.uicommonweb.models.Model;
public class GlusterHookResolveConflictsModel extends Model {
private GlusterHookEntity hookEntity;
private ListModel<EntityModel<GlusterServerHook>> hookSources;
private GlusterHookContentModel contentModel;
private EntityModel<Boolean> resolveContentConflict;
private ListModel<GlusterServerHook> serverHooksList;
private EntityModel<Boolean> resolveStatusConflict;
private EntityModel<Boolean> resolveStatusConflictEnable;
private EntityModel<Boolean> resolveStatusConflictDisable;
private EntityModel<Boolean> resolveMissingConflict;
private EntityModel<Boolean> resolveMissingConflictCopy;
private EntityModel<Boolean> resolveMissingConflictRemove;
public GlusterHookEntity getGlusterHookEntity() {
return hookEntity;
}
public void setGlusterHookEntity(GlusterHookEntity hookEntity) {
this.hookEntity = hookEntity;
if (hookEntity != null) {
getResolveContentConflict().setEntity(hookEntity.isContentConflict());
getResolveStatusConflict().setEntity(hookEntity.isStatusConflict());
getResolveMissingConflict().setEntity(hookEntity.isMissingHookConflict());
}
}
public ListModel<EntityModel<GlusterServerHook>> getHookSources() {
return hookSources;
}
public void setHookSources(ListModel<EntityModel<GlusterServerHook>> hookSources) {
this.hookSources = hookSources;
}
public ListModel<GlusterServerHook> getServerHooksList() {
return serverHooksList;
}
public void setServerHooksList(ListModel<GlusterServerHook> serverHooksList) {
this.serverHooksList = serverHooksList;
}
public GlusterHookContentModel getContentModel() {
return contentModel;
}
public void setContentModel(GlusterHookContentModel contentModel) {
this.contentModel = contentModel;
}
public EntityModel<Boolean> getResolveContentConflict() {
return resolveContentConflict;
}
public void setResolveContentConflict(EntityModel<Boolean> resolveContentConflict) {
this.resolveContentConflict = resolveContentConflict;
}
public EntityModel<Boolean> getResolveStatusConflict() {
return resolveStatusConflict;
}
public void setResolveStatusConflict(EntityModel<Boolean> resolveStatusConflict) {
this.resolveStatusConflict = resolveStatusConflict;
}
public EntityModel<Boolean> getResolveStatusConflictEnable() {
return resolveStatusConflictEnable;
}
public void setResolveStatusConflictEnable(EntityModel<Boolean> resolveStatusConflictEnable) {
this.resolveStatusConflictEnable = resolveStatusConflictEnable;
}
public EntityModel<Boolean> getResolveStatusConflictDisable() {
return resolveStatusConflictDisable;
}
public void setResolveStatusConflictDisable(EntityModel<Boolean> resolveStatusConflictDisable) {
this.resolveStatusConflictDisable = resolveStatusConflictDisable;
}
public EntityModel<Boolean> getResolveMissingConflict() {
return resolveMissingConflict;
}
public void setResolveMissingConflict(EntityModel<Boolean> resolveMissingConflict) {
this.resolveMissingConflict = resolveMissingConflict;
}
public EntityModel<Boolean> getResolveMissingConflictCopy() {
return resolveMissingConflictCopy;
}
public void setResolveMissingConflictCopy(EntityModel<Boolean> resolveMissingConflictCopy) {
this.resolveMissingConflictCopy = resolveMissingConflictCopy;
}
public EntityModel<Boolean> getResolveMissingConflictRemove() {
return resolveMissingConflictRemove;
}
public void setResolveMissingConflictRemove(EntityModel<Boolean> resolveMissingConflictRemove) {
this.resolveMissingConflictRemove = resolveMissingConflictRemove;
}
public GlusterHookResolveConflictsModel() {
setHookSources(new ListModel<EntityModel<GlusterServerHook>>());
setContentModel(new GlusterHookContentModel());
setResolveContentConflict(new EntityModel<Boolean>());
setServerHooksList(new ListModel<GlusterServerHook>());
setResolveStatusConflict(new EntityModel<Boolean>());
setResolveStatusConflictEnable(new EntityModel<Boolean>());
setResolveStatusConflictDisable(new EntityModel<Boolean>());
setResolveMissingConflict(new EntityModel<Boolean>());
setResolveMissingConflictCopy(new EntityModel<Boolean>());
setResolveMissingConflictRemove(new EntityModel<Boolean>());
getHookSources().getSelectedItemChangedEvent().addListener((ev, sender, args) -> onSelectedHookSourceChanged());
getResolveContentConflict().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveContentConflict().getEntity() == null) {
getServerHooksList().setIsChangeable(false);
}
else {
getServerHooksList().setIsChangeable(getResolveContentConflict().getEntity());
}
});
getResolveStatusConflict().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveStatusConflict().getEntity() == null) {
getResolveStatusConflictEnable().setIsChangeable(false);
getResolveStatusConflictDisable().setIsChangeable(false);
}
else {
getResolveStatusConflictEnable().setIsChangeable(getResolveStatusConflict().getEntity());
getResolveStatusConflictDisable().setIsChangeable(getResolveStatusConflict().getEntity());
}
});
getResolveStatusConflictEnable().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveStatusConflictEnable().getEntity()) {
getResolveStatusConflictDisable().setEntity(Boolean.FALSE);
}
});
getResolveStatusConflictDisable().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveStatusConflictDisable().getEntity()) {
getResolveStatusConflictEnable().setEntity(Boolean.FALSE);
}
});
getResolveMissingConflict().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveMissingConflict().getEntity() == null) {
getResolveMissingConflictCopy().setIsChangeable(false);
getResolveMissingConflictRemove().setIsChangeable(false);
}
else {
getResolveMissingConflictCopy().setIsChangeable(getResolveMissingConflict().getEntity());
getResolveMissingConflictRemove().setIsChangeable(getResolveMissingConflict().getEntity());
}
});
getResolveMissingConflictCopy().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveMissingConflictCopy().getEntity()) {
getResolveMissingConflictRemove().setEntity(Boolean.FALSE);
}
});
getResolveMissingConflictRemove().getEntityChangedEvent().addListener((ev, sender, args) -> {
if (getResolveMissingConflictRemove().getEntity()) {
getResolveMissingConflictCopy().setEntity(Boolean.FALSE);
}
updateConflictActionsAvailability(getResolveMissingConflictRemove().getEntity());
});
getResolveContentConflict().setEntity(Boolean.FALSE);
getResolveStatusConflict().setEntity(Boolean.FALSE);
getResolveStatusConflictEnable().setEntity(Boolean.TRUE);
getResolveStatusConflictDisable().setEntity(Boolean.FALSE);
getResolveMissingConflictCopy().setEntity(Boolean.TRUE);
getResolveMissingConflictRemove().setEntity(Boolean.FALSE);
}
private void updateConflictActionsAvailability(boolean isRemove) {
getResolveContentConflict().setEntity(!isRemove);
getResolveContentConflict().setIsChangeable(!isRemove);
getResolveStatusConflict().setEntity(!isRemove);
getResolveStatusConflict().setIsChangeable(!isRemove);
}
private void onSelectedHookSourceChanged() {
EntityModel<GlusterServerHook> selectedItem = getHookSources().getSelectedItem();
if (selectedItem == null) {
return;
}
GlusterServerHook selectedServer = selectedItem.getEntity();
getServerHooksList().setSelectedItem(selectedServer);
if (selectedServer.getStatus() == GlusterHookStatus.MISSING) {
getContentModel().getContent().setEntity(null);
getContentModel().getStatus().setEntity(null);
getContentModel().getMd5Checksum().setEntity(null);
return;
}
getContentModel().getStatus().setEntity(selectedServer.getStatus());
getContentModel().getMd5Checksum().setEntity(selectedServer.getChecksum());
if (selectedServer.getContentType() == GlusterHookContentType.TEXT) {
startProgress();
AsyncDataProvider.getInstance().getGlusterHookContent(new AsyncQuery<>(content -> {
getContentModel().getContent().setEntity(content);
stopProgress();
}), getGlusterHookEntity().getId(), selectedServer.getServerId());
}
else {
getContentModel().getContent().setEntity(null);
}
}
public boolean isAnyResolveActionSelected() {
return getResolveContentConflict().getEntity() || getResolveStatusConflict().getEntity()
|| getResolveMissingConflict().getEntity();
}
}