/*******************************************************************************
* Copyright 2006 - 2014 Vienna University of Technology,
* Department of Software Technology and Interactive Systems, IFS
*
* 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 eu.scape_project.planning.plato.wfview.full;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.enterprise.context.ConversationScoped;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import eu.scape_project.planning.manager.ByteStreamManager;
import eu.scape_project.planning.model.Alternative;
import eu.scape_project.planning.model.DigitalObject;
import eu.scape_project.planning.model.Plan;
import eu.scape_project.planning.model.PlanState;
import eu.scape_project.planning.model.PolicyNode;
import eu.scape_project.planning.model.aggregators.WeightedMultiplication;
import eu.scape_project.planning.model.aggregators.WeightedSum;
import eu.scape_project.planning.model.beans.ResultNode;
import eu.scape_project.planning.model.tree.TreeNode;
import eu.scape_project.planning.plato.bean.TreeHelperBean;
import eu.scape_project.planning.plato.wf.AbstractWorkflowStep;
import eu.scape_project.planning.plato.wf.AnalyseResults;
import eu.scape_project.planning.plato.wfview.AbstractView;
import eu.scape_project.planning.plato.wfview.beans.ReportLeaf;
import eu.scape_project.planning.utils.Downloader;
/**
* View bean for the workflow step analyse results.
*/
@Named("analyseResults")
@ConversationScoped
public class AnalyseResultsView extends AbstractView {
private static final long serialVersionUID = 1L;
@Inject
private Logger log;
@Inject
private AnalyseResults analyseResults;
@Inject
private Downloader downloader;
@Inject
private ByteStreamManager bytestreamManager;
@Inject
private TreeHelperBean policytreeHelper;
@Inject
private TreeHelperBean requirementstreeHelper;
@Inject
private TreeHelperBean resultstreeHelper;
/**
* Variable encapsulating the PolicyTree-Root in a list. This is required,
* because <rich:treeModelRecursiveAdaptor> root variable requires a list to
* work properly.
*/
private List<PolicyNode> policyRoots;
/**
* Variable encapsulating the RequirementsTree-Root in a list. This is
* required, because <rich:treeModelRecursiveAdaptor> root variable requires
* a list to work properly.
*/
private List<TreeNode> requirementsRoots;
/**
* List of leaves containing result- and transformed-values.
*/
private List<ReportLeaf> leafBeans;
/**
* Alternatives which did not produce a knock-out(=evaluate to 0) and
* therefore can be chosen as recommended one.
*/
private List<Alternative> acceptableAlternatives;
/**
* Variable encapsulating the aggregated sum result tree-Root in a list.
* This is required, because <rich:treeModelRecursiveAdaptor> root variable
* requires a list to work properly.
*/
private List<ResultNode> aggSumResultNodes;
/**
* Variable encapsulating the aggregated multiplication result tree-Root in
* a list. This is required, because <rich:treeModelRecursiveAdaptor> root
* variable requires a list to work properly.
*/
private List<ResultNode> aggMultResultNodes;
/**
* Indicates whether there are knocked out alternatives present.
*/
private boolean knockedoutAlternativePresent;
/**
* Indicates if all considered alternatives should be shown in the weighted
* sum result tree.
*/
private boolean showAllConsideredAlternativesForWeightedSum;
private boolean displayChangelogs;
/**
* Alternatives showed in weighted sum result tree.
*/
private List<Alternative> weightedSumResultTreeShownAlternatives;
/**
* Recommended alternative selected by the user represented as String
* (Because JSF-SelectOneMenu cannot handle Strings appropriately).
*/
private String recommendedAlternativeAsString;
/**
* Constructs a new view bean.
*/
public AnalyseResultsView() {
currentPlanState = PlanState.WEIGHTS_SET;
name = "Analyse Results";
viewUrl = "/plan/analyseresults.jsf";
group = "menu.analyseResults";
displayChangelogs = false;
policyRoots = new ArrayList<PolicyNode>();
requirementsRoots = new ArrayList<TreeNode>();
leafBeans = new ArrayList<ReportLeaf>();
acceptableAlternatives = new ArrayList<Alternative>();
aggSumResultNodes = new ArrayList<ResultNode>();
aggMultResultNodes = new ArrayList<ResultNode>();
knockedoutAlternativePresent = true;
showAllConsideredAlternativesForWeightedSum = false;
weightedSumResultTreeShownAlternatives = new ArrayList<Alternative>();
recommendedAlternativeAsString = "";
}
@Override
public void init(Plan plan) {
super.init(plan);
policyRoots.clear();
if (plan.getProjectBasis().getPolicyTree() != null) {
PolicyNode policyRoot = plan.getProjectBasis().getPolicyTree().getRoot();
if (policyRoot != null) {
policyRoots.add(policyRoot);
policytreeHelper.expandAll(policyRoot);
}
}
requirementsRoots.clear();
if (plan.getTree() != null) {
TreeNode requirementsRoot = plan.getTree().getRoot();
if (requirementsRoot != null) {
requirementsRoots.add(requirementsRoot);
requirementstreeHelper.expandAll(requirementsRoot);
}
}
leafBeans = analyseResults.constructPlanReportLeaves();
acceptableAlternatives = plan.getAcceptableAlternatives();
aggMultResultNodes.clear();
aggMultResultNodes.add(new ResultNode(plan.getTree().getRoot(), new WeightedMultiplication(), plan
.getAlternativesDefinition().getConsideredAlternatives()));
aggSumResultNodes.clear();
// calculate result nodes for all considered alternatives
ResultNode sumResultNode = new ResultNode(plan.getTree().getRoot(), new WeightedSum(), plan
.getAlternativesDefinition().getConsideredAlternatives());
aggSumResultNodes.add(sumResultNode);
knockedoutAlternativePresent = acceptableAlternatives.size() != plan.getAlternativesDefinition()
.getConsideredAlternatives().size();
showAllConsideredAlternativesForWeightedSum = false;
weightedSumResultTreeShownAlternatives = acceptableAlternatives;
analyseResults.analyseSensitivity(sumResultNode, acceptableAlternatives);
if (plan.getRecommendation().getAlternative() != null) {
recommendedAlternativeAsString = plan.getRecommendation().getAlternative().getName();
} else {
recommendedAlternativeAsString = "";
}
}
@Override
protected AbstractWorkflowStep getWfStep() {
return analyseResults;
}
/**
* Starts a download for the given digital object. Uses
* {@link eu.scape_project.planning.util.Downloader} to perform the
* download.
*
* @param object
* the digital object to download
*/
public void download(final DigitalObject object) {
File file = bytestreamManager.getTempFile(object.getPid());
if (file != null) {
downloader.download(object, file);
} else {
log.error("Failed to retrieve object: " + object.getPid());
}
}
/**
* Method responsible for turning changelog-display on/off.
*/
public void switchDisplayChangelogs() {
displayChangelogs = !displayChangelogs;
}
/**
* Method responsible for switching listed weighted sum alternatives between
* all considered and all acceptable.
*/
public void switchShowAllConsideredAlternativesForWeightedSum() {
if (showAllConsideredAlternativesForWeightedSum) {
weightedSumResultTreeShownAlternatives = plan.getAlternativesDefinition().getConsideredAlternatives();
} else {
weightedSumResultTreeShownAlternatives = acceptableAlternatives;
}
}
/**
* Method responsible for returning the current time as String.
*
* @return Current time as String.
*/
public String getCurrentDate() {
return SimpleDateFormat.getDateTimeInstance().format(new Date());
}
/**
* Sets the recommended alternative identified by the alternative name.
*
* @param recommendedAlternativeAsString
* the name of the recommended alternative
*/
public void setRecommendedAlternativeAsString(String recommendedAlternativeAsString) {
this.recommendedAlternativeAsString = recommendedAlternativeAsString;
updateAlternativeRecommendation(recommendedAlternativeAsString);
}
/**
* Method responsible for updating the recommended alternative in the model
* based on the given alternative-name.
*
* @param alternativeName
* Alternative name of the recommended alternative
*/
private void updateAlternativeRecommendation(String alternativeName) {
Alternative recommendedAlternative = null;
for (Alternative a : plan.getAlternativesDefinition().getAlternatives()) {
if (a.getName().equals(alternativeName)) {
recommendedAlternative = a;
break;
}
}
analyseResults.recommendAlternative(recommendedAlternative);
}
// --------------- getter/setter ---------------
public boolean isDisplayChangelogs() {
return displayChangelogs;
}
public List<PolicyNode> getPolicyRoots() {
return policyRoots;
}
public List<TreeNode> getRequirementsRoots() {
return requirementsRoots;
}
public List<ReportLeaf> getLeafBeans() {
return leafBeans;
}
public List<Alternative> getAcceptableAlternatives() {
return acceptableAlternatives;
}
public List<ResultNode> getAggSumResultNodes() {
return aggSumResultNodes;
}
public List<ResultNode> getAggMultResultNodes() {
return aggMultResultNodes;
}
public boolean isKnockedoutAlternativePresent() {
return knockedoutAlternativePresent;
}
public boolean isShowAllConsideredAlternativesForWeightedSum() {
return showAllConsideredAlternativesForWeightedSum;
}
public void setShowAllConsideredAlternativesForWeightedSum(boolean showAllConsideredAlternativesForWeightedSum) {
this.showAllConsideredAlternativesForWeightedSum = showAllConsideredAlternativesForWeightedSum;
}
public List<Alternative> getWeightedSumResultTreeShownAlternatives() {
return weightedSumResultTreeShownAlternatives;
}
public String getRecommendedAlternativeAsString() {
return recommendedAlternativeAsString;
}
public TreeHelperBean getPolicytreeHelper() {
return policytreeHelper;
}
public TreeHelperBean getRequirementstreeHelper() {
return requirementstreeHelper;
}
public TreeHelperBean getResultstreeHelper() {
return resultstreeHelper;
}
}