OrganigrammeWorkflowViewModel.java

package nc.noumea.mairie.organigramme.viewmodel;

/*
 * #%L
 * Logiciel de Gestion des Organigrammes de la Ville de Nouméa
 * $Id:$
 * $HeadURL:$
 * %%
 * Copyright (C) 2015 Mairie de Nouméa
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/gpl-3.0.html>.
 * #L%
 */

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

import nc.noumea.mairie.organigramme.core.viewmodel.AbstractEditViewModel;
import nc.noumea.mairie.organigramme.core.viewmodel.AbstractViewModel;
import nc.noumea.mairie.organigramme.dto.EntiteDto;
import nc.noumea.mairie.organigramme.enums.FiltreStatut;
import nc.noumea.mairie.organigramme.enums.Statut;
import nc.noumea.mairie.organigramme.enums.Transition;

import org.zkoss.bind.BindUtils;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zul.Messagebox;

/**
 * Classe de gestion du workflow, couplée à un OrganigrammeViewModel.
 * 
 * @author AgileSoft.NC
 */
public class OrganigrammeWorkflowViewModel extends AbstractEditViewModel<EntiteDto> implements Serializable {

	private static final long serialVersionUID = 1L;

	private OrganigrammeViewModel organigrammeViewModel;

	public OrganigrammeWorkflowViewModel(OrganigrammeViewModel organigrammeViewModel) {
		this.organigrammeViewModel = organigrammeViewModel;
	}

	public void passerTransition(Transition transition, EntiteDto entiteDto) {
		if (transition == null) {
			return;
		}
		if (transition.getStatutSource() != entiteDto.getStatut()) {
			AbstractViewModel.showErrorPopup("Bug (de rafraîchissement des boutons de changement de statut) : le statut de l'entité est " + entiteDto.getStatut()
					+ ", mais la transition demandée est " + transition);
			return;
		}
		// @formatter:off
		switch (transition) {

		case TRANSITOIRE:
			executerTransitionTransitoire(entiteDto);
			break;
		case ACTIF_APRES_PREVISION:
			executerTransitionActifApresPrevision(entiteDto);
			break;
		case INACTIF_APRES_TRANSITOIRE:
			executerTransitionInactifApresTransitoire(entiteDto);
			break;
		case INACTIF_APRES_ACTIF:
			executerTransitionInactifApresActif(entiteDto);
			break;
		default:
			break;
		}
		// @formatter:on
	}

	private void executerTransitionTransitoire(EntiteDto entiteDto) {
		executerTransitionWithRefAndDate(Transition.TRANSITOIRE, Statut.TRANSITOIRE, entiteDto);
	}

	private void executerTransitionActifApresPrevision(EntiteDto entiteDto) {
		executerTransitionWithRefAndDate(Transition.ACTIF_APRES_PREVISION, Statut.ACTIF, entiteDto);
	}

	private void executerTransitionInactifApresTransitoire(EntiteDto entiteDto) {
		executerTransitionWithRefAndDate(Transition.INACTIF_APRES_TRANSITOIRE, Statut.INACTIF, entiteDto);
	}

	private void executerTransitionInactifApresActif(EntiteDto entiteDto) {
		executerTransitionWithRefAndDate(Transition.INACTIF_APRES_ACTIF, Statut.INACTIF, entiteDto);
	}

	private void executerTransitionWithRefAndDate(Transition transition, Statut statut, EntiteDto entiteDto) {
		verifieTransitionPossible(transition, entiteDto);

		Map<String, Object> args = new HashMap<>();
		args.put("entity", entiteDto);
		args.put("transition", transition);

		Map<String, Object> arguments = new HashMap<String, Object>();
		arguments.put("entity", entity);
		Executions.createComponents("/layout/popupStatutWithRefAndDate.zul", null, arguments);

		BindUtils.postGlobalCommand(null, null, "ouvrirPopupStatutWithRefAndDate", args);
	}

	private void verifieTransitionPossible(Transition transition, EntiteDto entiteDto) {
		if (entiteDto.getStatut() != transition.getStatutSource()) {
			throw new IllegalArgumentException("le passage de transition " + transition + " n'est pas autorisé depuis le statut " + entiteDto.getStatut());
		}
	}

	/**
	 * Transition générique simple
	 * 
	 * @param transition
	 *            transition à passer
	 * @param majEntitesEnfant
	 *            doit-on appliquer ou non le changement de statut sur les
	 *            enfants
	 * @param entiteDto
	 *            : l'entité à mettre à jour
	 * @return true si la transition est bien passé
	 */
	public boolean executerTransitionGeneric(Transition transition, boolean majEntitesEnfant, EntiteDto entiteDto) {
		verifieTransitionPossible(transition, entiteDto);
		if (this.organigrammeViewModel.organigrammeService.updateStatut(entiteDto, transition.getStatut(), majEntitesEnfant)) {
			// On recharge l'arbre complet d'ADS et on rafraichi le client.
			// Ainsi on est sur d'avoir une version bien à jour
			this.organigrammeViewModel.entiteDtoRoot = this.organigrammeViewModel.adsWSConsumer.getCurrentTreeWithVDNRoot();

			// On force l'affichage du statut pour pouvoir voir cette entité
			// dans son nouvel état
			forcerAffichageStatut(transition);

			// On refresh si l'onglet est ouvert pour qu'il se mette à jour
			final Map<String, Object> mapEntite = new HashMap<String, Object>();
			mapEntite.put("entity", entiteDto);
			BindUtils.postGlobalCommand(null, null, "refreshEntiteGlobalCommand", mapEntite);

			this.organigrammeViewModel.creeArbreEtRafraichiClient();
			return true;
		}

		return false;
	}

	/**
	 * Force le filtre pour que l'entité soit visible dans son nouveau statut et
	 * affiche un message d'information
	 * 
	 * @param transition
	 *            : la transition a executer
	 */
	private void forcerAffichageStatut(Transition transition) {
		if (transition.getStatut().equals(Statut.TRANSITOIRE)) {
			boolean filtreStatutTransitoireVisible = this.organigrammeViewModel.getSelectedFiltreStatut() != null
					&& (this.organigrammeViewModel.getSelectedFiltreStatut().equals(FiltreStatut.ACTIF_TRANSITOIRE)
							|| this.organigrammeViewModel.getSelectedFiltreStatut().equals(FiltreStatut.ACTIF_TRANSITOIRE_INACTIF) || this.organigrammeViewModel.getSelectedFiltreStatut().equals(
							FiltreStatut.TOUS));
			if (!filtreStatutTransitoireVisible) {
				this.organigrammeViewModel.setSelectedFiltreStatut(FiltreStatut.ACTIF_TRANSITOIRE);
				Messagebox.show("Le filtre d'affichage a été changé pour vous permettre de visualiser l'entité en statut transitoire", "Information", Messagebox.OK, Messagebox.INFORMATION);
			}
		}
		if (transition.getStatut().equals(Statut.INACTIF)) {
			boolean filtreStatutInactifVisible = this.organigrammeViewModel.getSelectedFiltreStatut() != null
					&& (this.organigrammeViewModel.getSelectedFiltreStatut().equals(FiltreStatut.ACTIF_TRANSITOIRE_INACTIF) || this.organigrammeViewModel.getSelectedFiltreStatut().equals(
							FiltreStatut.TOUS));
			if (!filtreStatutInactifVisible) {
				this.organigrammeViewModel.setSelectedFiltreStatut(FiltreStatut.ACTIF_TRANSITOIRE_INACTIF);
				Messagebox.show("Le filtre d'affichage a été changé pour vous permettre de visualiser l'entité en statut inactif", "Information", Messagebox.OK, Messagebox.INFORMATION);
			}
		}
	}
}