1089 lines
41 KiB
Java
1089 lines
41 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.portlets.user.performfishanalytics.client.controllers;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.gcube.portlets.user.performfishanalytics.client.DataMinerAlgorithms;
|
|
import org.gcube.portlets.user.performfishanalytics.client.PerformFishAnalyticsConstant;
|
|
import org.gcube.portlets.user.performfishanalytics.client.PerformFishAnalyticsConstant.POPULATION_LEVEL;
|
|
import org.gcube.portlets.user.performfishanalytics.client.PerformFishAnalyticsServiceAsync;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.AddedBatchIdEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.AddedBatchIdEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.CallAlgorithmEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.CallAlgorithmEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.LoadBatchesEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.LoadBatchesEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.LoadPopulationTypeEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.LoadPopulationTypeEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.LoadSynopticTableEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.LoadSynopticTableEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.PerformFishFieldFormChangedEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.PerformFishFieldFormChangedEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.SelectedKPIEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.SelectedKPIEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.SelectedPopulationTypeEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.SelectedPopulationTypeEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.SubmitRequestEvent;
|
|
import org.gcube.portlets.user.performfishanalytics.client.event.SubmitRequestEventHandler;
|
|
import org.gcube.portlets.user.performfishanalytics.client.resources.PerformFishResources;
|
|
import org.gcube.portlets.user.performfishanalytics.client.view.LoaderIcon;
|
|
import org.gcube.portlets.user.performfishanalytics.client.viewbinder.AnalyticsPanelResult;
|
|
import org.gcube.portlets.user.performfishanalytics.client.viewbinder.DeaPanelResult;
|
|
import org.gcube.portlets.user.performfishanalytics.client.viewbinder.ShowResult;
|
|
import org.gcube.portlets.user.performfishanalytics.client.viewbinder.SubmitRequestPanel;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.KPI;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.OutputFile;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.PopulationType;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.csv.CSVFile;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.dataminer.DataMinerResponse;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.performfishservice.PerformFishInitParameter;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.performfishservice.PerformFishResponse;
|
|
|
|
import com.github.gwtbootstrap.client.ui.Alert;
|
|
import com.github.gwtbootstrap.client.ui.Modal;
|
|
import com.github.gwtbootstrap.client.ui.Tab;
|
|
import com.github.gwtbootstrap.client.ui.constants.AlertType;
|
|
import com.github.gwtbootstrap.client.ui.constants.ControlGroupType;
|
|
import com.google.gwt.core.client.Scheduler;
|
|
import com.google.gwt.core.shared.GWT;
|
|
import com.google.gwt.dom.client.Style.Unit;
|
|
import com.google.gwt.event.shared.HandlerManager;
|
|
import com.google.gwt.resources.client.TextResource;
|
|
import com.google.gwt.user.client.Window;
|
|
import com.google.gwt.user.client.rpc.AsyncCallback;
|
|
import com.google.gwt.user.client.ui.ComplexPanel;
|
|
import com.google.gwt.user.client.ui.FlexTable;
|
|
import com.google.gwt.user.client.ui.HTML;
|
|
import com.google.gwt.user.client.ui.HTMLPanel;
|
|
import com.google.gwt.user.client.ui.HorizontalPanel;
|
|
import com.google.gwt.user.client.ui.Panel;
|
|
import com.google.gwt.user.client.ui.VerticalPanel;
|
|
|
|
/**
|
|
* The Class PerformFishAnalyticsController.
|
|
*
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it Jan 16, 2019
|
|
*/
|
|
public class PerformFishAnalyticsController {
|
|
|
|
/** The Constant eventBus. */
|
|
|
|
public final static HandlerManager eventBus = new HandlerManager(null);
|
|
|
|
/** The view controller. */
|
|
private PerformFishAnalyticsViewController viewController;
|
|
|
|
/** The decrypt parameters. */
|
|
private PerformFishInitParameter decryptParameters;
|
|
|
|
private Map<Integer, FlexTable> boxPlotOrderBy = new HashMap<Integer, FlexTable>();
|
|
|
|
private Map<Integer, FlexTable> synopticOrderBy = new HashMap<Integer, FlexTable>();
|
|
|
|
/**
|
|
* Instantiates a new perform fish analytics controller.
|
|
*/
|
|
public PerformFishAnalyticsController() {
|
|
|
|
registerHandlers();
|
|
viewController = new PerformFishAnalyticsViewController();
|
|
}
|
|
|
|
/**
|
|
* Sets the inits the parmaters.
|
|
*
|
|
* @param result
|
|
* the new inits the parmaters
|
|
*/
|
|
public void setInitParmaters(PerformFishInitParameter result) {
|
|
this.decryptParameters = result;
|
|
}
|
|
|
|
/**
|
|
* Register handlers.
|
|
*/
|
|
private void registerHandlers() {
|
|
|
|
eventBus.addHandler(LoadPopulationTypeEvent.TYPE, new LoadPopulationTypeEventHandler() {
|
|
|
|
@Override
|
|
public void onLoadPopulationType(LoadPopulationTypeEvent loadPopulationEvent) {
|
|
|
|
viewController.loadPopulationTypeForLevelAndBatchType(loadPopulationEvent.getPopulationName(),
|
|
decryptParameters);
|
|
|
|
// if(loadPopulationEvent.getPopulationName().equals(POPULATION_LEVEL.BATCH.name()))
|
|
// {
|
|
//
|
|
// }else {
|
|
// viewAnnualController.loadPopulationTypeForLevelAndBatchType(loadPopulationEvent.getPopulationName(),
|
|
// decryptParameters);
|
|
// }
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(CallAlgorithmEvent.TYPE, new CallAlgorithmEventHandler() {
|
|
|
|
@Override
|
|
public void onCall(CallAlgorithmEvent callAlgorithmEvent) {
|
|
|
|
callAlgorithm(callAlgorithmEvent.getAlgorithm(), callAlgorithmEvent.getFocusID(),
|
|
callAlgorithmEvent.getInputKPI(), callAlgorithmEvent.getOutputKPI());
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(SelectedPopulationTypeEvent.TYPE, new SelectedPopulationTypeEventHandler() {
|
|
|
|
@Override
|
|
public void onSelectedPopulationType(SelectedPopulationTypeEvent selectedPopulationTypeEvent) {
|
|
|
|
PopulationType opt = selectedPopulationTypeEvent.getSelectedPopulationType();
|
|
viewController.setRootPopulationTypeForKPIs(selectedPopulationTypeEvent.getSelectedPopulationType());
|
|
|
|
if (opt.getName().equalsIgnoreCase(
|
|
PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_INDIVIDUAL_CLOSED_BATCHES.name())
|
|
|| opt.getName()
|
|
.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_INDIVIDUAL.name())
|
|
|| opt.getName().equals(
|
|
PerformFishAnalyticsConstant.BATCH_LEVEL.HATCHERY_INDIVIDUAL_CLOSED_BATCHES.name())
|
|
|| opt.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.HATCHERY_INDIVIDUAL.name())
|
|
|| opt.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.PRE_ONGROWING.name())
|
|
|| opt.getName()
|
|
.equals(PerformFishAnalyticsConstant.BATCH_LEVEL.PRE_ONGROWING_CLOSED_BATCHES.name())) {
|
|
viewController.visibleSynopticTable(true);
|
|
} else {
|
|
viewController.visibleSynopticTable(false);
|
|
}
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(SelectedKPIEvent.TYPE, new SelectedKPIEventHandler() {
|
|
|
|
@Override
|
|
public void onSelectedKPI(SelectedKPIEvent selectedKPI) {
|
|
|
|
viewController.manageKPI(selectedKPI.getKpi(), selectedKPI.isChecked(),
|
|
selectedKPI.getSelectedPopulationType());
|
|
int selectedKPIsSize = viewController.getSelectedKPIs().size();
|
|
// viewController.manageAlgorithmsSubmit(selectedKPIsSize);
|
|
String selectedBatchId = viewController.getSelectedBatchID();
|
|
if (selectedBatchId == null || selectedBatchId.isEmpty()) {
|
|
viewController.enableAllAlgorithmsForSubmit(false);
|
|
} else
|
|
viewController.manageAlgorithmsSubmit(selectedKPIsSize);
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(LoadBatchesEvent.TYPE, new LoadBatchesEventHandler() {
|
|
|
|
@Override
|
|
public void onLoadBatches(LoadBatchesEvent loadBatchesEvent) {
|
|
|
|
viewController.hideErrors();
|
|
|
|
final Map<String, List<String>> mapParameters = new HashMap<String, List<String>>();
|
|
String farmId = decryptParameters.getParameters()
|
|
.get(PerformFishAnalyticsConstant.PERFORM_FISH_FARMID_PARAM);
|
|
String batchType = viewController.getForm().getBatchType();
|
|
String species = viewController.getForm().getSpecies();
|
|
List<String> listArea = viewController.getForm().getArea();
|
|
List<String> listPeriod = viewController.getForm().getPeriod();
|
|
List<String> listQuarter = viewController.getForm().getQuarter();
|
|
|
|
mapParameters.put(PerformFishAnalyticsConstant.PERFORM_FISH_FARMID_PARAM, Arrays.asList(farmId));
|
|
mapParameters.put(PerformFishAnalyticsConstant.PERFORM_FISH_BATCH_TYPE_PARAM, Arrays.asList(batchType));
|
|
mapParameters.put(PerformFishAnalyticsConstant.PERFORM_FISH_SPECIES_ID_PARAM, Arrays.asList(species));
|
|
|
|
if (!listArea.isEmpty()) {
|
|
mapParameters.put(PerformFishAnalyticsConstant.PERFORM_FISH_AREA_PARAM, listArea);
|
|
}
|
|
if (!listPeriod.isEmpty()) {
|
|
mapParameters.put(PerformFishAnalyticsConstant.PERFORM_FISH_PERIOD_PARAM, listPeriod);
|
|
}
|
|
if (!listQuarter.isEmpty()) {
|
|
mapParameters.put(PerformFishAnalyticsConstant.PERFORM_FISH_QUARTER_PARAM, listQuarter);
|
|
}
|
|
|
|
final Modal modal = new Modal(true);
|
|
modal.setCloseVisible(false);
|
|
modal.hide(false);
|
|
final VerticalPanel vp = new VerticalPanel();
|
|
LoaderIcon loader = new LoaderIcon("Loading batch(es) from PerformFish service, please wait...");
|
|
vp.add(loader);
|
|
loader.show(true);
|
|
modal.add(vp);
|
|
PerformFishAnalyticsServiceAsync.Util.getInstance().submitRequestToPerformFishService(mapParameters,
|
|
new AsyncCallback<PerformFishResponse>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
modal.hide();
|
|
Window.alert(caught.getMessage());
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(PerformFishResponse performFishResponse) {
|
|
modal.hide();
|
|
viewController.managePerformFishServiceResponse(performFishResponse, mapParameters,
|
|
POPULATION_LEVEL.BATCH);
|
|
}
|
|
});
|
|
modal.show();
|
|
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(PerformFishFieldFormChangedEvent.TYPE, new PerformFishFieldFormChangedEventHandler() {
|
|
|
|
@Override
|
|
public void onFieldFormChanged(PerformFishFieldFormChangedEvent performFishFieldFormChangedEvent) {
|
|
|
|
viewController.setReloadPerformFishServiceData(true);
|
|
boolean isValidForm = viewController.validatePerformFishInputFields();
|
|
|
|
viewController.resetBatchIdStatus();
|
|
|
|
if (isValidForm) {
|
|
// viewController.resetBatchIdStatus();
|
|
viewController.setBatchIdStatus(ControlGroupType.INFO);
|
|
viewController.enableLoadBatches(true);
|
|
viewController.enableSynopticTable(false);
|
|
viewController.showAlertForLoadBatches(
|
|
"Please load your batches corresponding to the selected options, by pressing the 'Load Batches' button",
|
|
AlertType.INFO, false);
|
|
viewController.enableAllAlgorithmsForSubmit(false);
|
|
|
|
} else {
|
|
viewController.enableLoadBatches(false);
|
|
viewController.enableSynopticTable(false);
|
|
viewController.enableAllAlgorithmsForSubmit(false);
|
|
}
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(AddedBatchIdEvent.TYPE, new AddedBatchIdEventHandler() {
|
|
|
|
@Override
|
|
public void onAddedBatchId(AddedBatchIdEvent checkValidBatchIdEvent) {
|
|
|
|
boolean isBatchIdValid = viewController.validateBatchIdSelection();
|
|
if (isBatchIdValid) {
|
|
viewController.enableAllAlgorithmsForSubmit(true);
|
|
viewController.enableSynopticTable(true);
|
|
} else {
|
|
viewController.enableAllAlgorithmsForSubmit(false);
|
|
viewController.enableSynopticTable(false);
|
|
}
|
|
|
|
// viewController.resyncSelectedKPIs();
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(SubmitRequestEvent.TYPE, new SubmitRequestEventHandler() {
|
|
|
|
@Override
|
|
public void onSubmitRequest(SubmitRequestEvent submitRequestEvent) {
|
|
|
|
boolean isValidBatchId = viewController.validateBatchIdSelection();
|
|
|
|
boolean isValidKPI = viewController.validateKPIFields();
|
|
|
|
List<KPI> selectedKPI = viewController.getSelectedKPIs();
|
|
viewController.manageAlgorithmsSubmit(selectedKPI.size());
|
|
|
|
if (isValidBatchId && isValidKPI) {
|
|
|
|
switch (submitRequestEvent.getChartType()) {
|
|
|
|
case BOXPLOT:
|
|
// UNARY
|
|
callAlgorithm(submitRequestEvent.getChartType(), viewController.getSelectedBatchID(),
|
|
selectedKPI, null);
|
|
break;
|
|
|
|
case SCATTER:
|
|
if (selectedKPI.size() == 2)
|
|
callAlgorithm(submitRequestEvent.getChartType(), viewController.getSelectedBatchID(),
|
|
selectedKPI, null);
|
|
else
|
|
Window.alert("Something seems wrong... You must select exactly two KPIs to execute the "
|
|
+ submitRequestEvent.getChartType());
|
|
break;
|
|
case CORRELATION:
|
|
callDataMinerServiceForChartTypeCorrelation(viewController.getPerformFishResponse(),
|
|
viewController.getRequestMapParameters());
|
|
break;
|
|
case SPEEDOMETER:
|
|
// UNARY
|
|
callAlgorithm(submitRequestEvent.getChartType(), viewController.getSelectedBatchID(),
|
|
selectedKPI, selectedKPI);
|
|
break;
|
|
case DEA_ANALYSIS:
|
|
createTabToSelectIOParametersForDeaAnalysis(viewController.getPerformFishResponse(),
|
|
viewController.getRequestMapParameters());
|
|
break;
|
|
case DEA_CHART:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_HATCHERY:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_PREGROW:
|
|
break;
|
|
case PERFORMFISH_SYNOPTIC_TABLE_FARM:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
});
|
|
|
|
eventBus.addHandler(LoadSynopticTableEvent.TYPE, new LoadSynopticTableEventHandler() {
|
|
|
|
@Override
|
|
public void onLoadSynopticTable(LoadSynopticTableEvent loadSynopticTableEvent) {
|
|
|
|
boolean isValidBatchId = viewController.validateBatchIdSelection();
|
|
|
|
if (isValidBatchId) {
|
|
callAlgorithmSynopticTableBatch(viewController.getPerformFishResponse(),
|
|
viewController.getRequestMapParameters());
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
/**
|
|
* Call algorithm synoptic table batch.
|
|
*
|
|
* @param performFishResponse
|
|
* the perform fish response
|
|
* @param performFishRequestParameters
|
|
* the perform fish request parameters
|
|
*/
|
|
private void callAlgorithmSynopticTableBatch(final PerformFishResponse performFishResponse,
|
|
final Map<String, List<String>> performFishRequestParameters) {
|
|
GWT.log("Read perform fish response: " + performFishResponse);
|
|
|
|
String batchTableURL = performFishResponse.getMapParameters().get(PerformFishAnalyticsConstant.BATCHES_TABLE);
|
|
|
|
if (batchTableURL == null || batchTableURL.isEmpty())
|
|
Window.alert("Something seems wrong. No batches tables matching with parameter "
|
|
+ PerformFishAnalyticsConstant.BATCHES_TABLE + " returned from service");
|
|
|
|
final Map<String, List<String>> mapParameters = new HashMap<String, List<String>>();
|
|
|
|
StringBuilder dataInputsFormatter = new StringBuilder();
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_INPUT_TABLE + "=" + batchTableURL + ";");
|
|
|
|
// READ THE INPUT FILE
|
|
String popType = viewController.getForm().getBatchType();
|
|
|
|
DataMinerAlgorithms chartType = null;
|
|
if (popType.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_INDIVIDUAL_CLOSED_BATCHES.name())
|
|
|| popType.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_INDIVIDUAL.name())) {
|
|
chartType = DataMinerAlgorithms.PERFORMFISH_SYNOPTICTABLE_BATCH;
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_QUARTER_LABELS + "="
|
|
+ PerformFishAnalyticsConstant.DM_VALUE_ALL + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_ZONE_LABELS + "="
|
|
+ PerformFishAnalyticsConstant.DM_VALUE_ALL + ";");
|
|
} else if (popType
|
|
.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.HATCHERY_INDIVIDUAL_CLOSED_BATCHES.name())
|
|
|| popType.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.HATCHERY_INDIVIDUAL.name())) {
|
|
chartType = DataMinerAlgorithms.PERFORMFISH_SYNOPTICTABLE_BATCH_HATCHERY;
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_STOCKING_PERIOD + "="
|
|
+ PerformFishAnalyticsConstant.DM_VALUE_ALL + ";");
|
|
} else if (popType.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.PRE_ONGROWING.name()) || popType
|
|
.equalsIgnoreCase(PerformFishAnalyticsConstant.BATCH_LEVEL.PRE_ONGROWING_CLOSED_BATCHES.name())) {
|
|
chartType = DataMinerAlgorithms.PERFORMFISH_SYNOPTICTABLE_BATCH_PREGROW;
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_ZONE_LABELS + "="
|
|
+ PerformFishAnalyticsConstant.DM_VALUE_ALL + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_STOCKING_PERIOD + "="
|
|
+ PerformFishAnalyticsConstant.DM_VALUE_ALL + ";");
|
|
}
|
|
|
|
String dataInParameters = dataInputsFormatter.toString();
|
|
mapParameters.put(PerformFishAnalyticsConstant.DATA_INPUTS, Arrays.asList(dataInParameters));
|
|
mapParameters.put("Identifier", Arrays.asList(
|
|
"org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mappedclasses.transducerers." + chartType));
|
|
|
|
GWT.log("Calling DM service with client input parameters: " + mapParameters);
|
|
|
|
final SubmitRequestPanel submitRequestPanel = new SubmitRequestPanel("", 1);
|
|
// submitRequestPanel.getElement().addClassName("ext-horizontal-panel");
|
|
String tabTitle = "Synoptic Table"; // CAMEL CASE
|
|
final Tab tab = viewController.createTab(tabTitle + " #" + (viewController.currentNumberOfTab() + 1),
|
|
PerformFishResources.INSTANCE.synopticTable().getText(), submitRequestPanel);
|
|
final HTMLPanel panelContainer = submitRequestPanel.getContainerPanel();
|
|
|
|
final LoaderIcon loaderIcon = new LoaderIcon(
|
|
"Submitting request to " + DataMinerAlgorithms.PERFORMFISH_SYNOPTICTABLE_BATCH.getTitle() + "...");
|
|
loaderIcon.setVisible(true);
|
|
panelContainer.setVisible(true);
|
|
panelContainer.add(loaderIcon);
|
|
Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
|
|
@Override
|
|
public void execute() {
|
|
loaderIcon.setFocus(true);
|
|
}
|
|
});
|
|
|
|
final DataMinerAlgorithms toFinalChartType = chartType;
|
|
PerformFishAnalyticsServiceAsync.Util.getInstance().callDMServiceToLoadSynopticTable(performFishResponse,
|
|
mapParameters, new AsyncCallback<DataMinerResponse>() {
|
|
|
|
@Override
|
|
public void onSuccess(DataMinerResponse dmResponse) {
|
|
loaderIcon.setVisible(false);
|
|
checkTabSpinner(submitRequestPanel, tab);
|
|
// field_unary_algorithm.setVisible(true);
|
|
GWT.log("I'm displaying: " + dmResponse);
|
|
displayOutputFilesAsStaticEntities(dmResponse, toFinalChartType, null, null, null,
|
|
panelContainer, false);
|
|
}
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
loaderIcon.setVisible(false);
|
|
checkTabSpinner(submitRequestPanel, tab);
|
|
displayOutputFilesAsStaticEntities(null, toFinalChartType, null, null, null, panelContainer,
|
|
true);
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
//
|
|
private void createTabToSelectIOParametersForDeaAnalysis(final PerformFishResponse performFishResponse,
|
|
final Map<String, List<String>> performFishRequestParameters) {
|
|
|
|
GWT.log("Read perform fish response: " + performFishResponse);
|
|
|
|
String batchTableURL = performFishResponse.getMapParameters().get(PerformFishAnalyticsConstant.BATCHES_TABLE);
|
|
|
|
if (batchTableURL == null || batchTableURL.isEmpty())
|
|
Window.alert("Something seems wrong. No batches tables matching with parameter "
|
|
+ PerformFishAnalyticsConstant.BATCHES_TABLE + " returned from service");
|
|
|
|
final Map<String, List<String>> mapParameters = new HashMap<String, List<String>>();
|
|
|
|
StringBuilder dataInputsFormatter = new StringBuilder();
|
|
|
|
dataInputsFormatter
|
|
.append(PerformFishAnalyticsConstant.DM_SCALEP_PARAM + "=" + viewController.getForm().getLevel() + ";");
|
|
String theBatchType = viewController.getForm().getBatchType();
|
|
theBatchType = theBatchType.replace("_CLOSED_BATCHES", ""); // REMOVING
|
|
// SUFFIX
|
|
// _CLOSED_BATCHES
|
|
// FOR
|
|
// DATAMINER
|
|
// CALL
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_BATCHTYPE_PARAM + "=" + theBatchType + ";");
|
|
dataInputsFormatter
|
|
.append(PerformFishAnalyticsConstant.DM_CHARTTYPE_PARAM + "=" + DataMinerAlgorithms.CORRELATION + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_FARMFILE_PARAM + "=" + batchTableURL + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_FOCUS_PARAM + "="+viewController.getSelectedBatchID()+";");
|
|
|
|
String kpiCodes = "";
|
|
for (KPI kpi : viewController.getSelectedKPIs()) {
|
|
kpiCodes += kpi.getCode() + "|";
|
|
}
|
|
// remove last |
|
|
kpiCodes = kpiCodes.substring(0, kpiCodes.length() - 1);
|
|
dataInputsFormatter.append("inputKPI=" + kpiCodes + ";");
|
|
// dataInputsFormatter.append("outputKPI=;");
|
|
|
|
String dataInParameters = dataInputsFormatter.toString();
|
|
GWT.log("Calling DM service with client input parameters: " + dataInParameters);
|
|
|
|
mapParameters.put(PerformFishAnalyticsConstant.DATA_INPUTS, Arrays.asList(dataInParameters));
|
|
|
|
final SubmitRequestPanel submitRequestPanel = new SubmitRequestPanel("", 1);
|
|
submitRequestPanel.showLoader(false, null);
|
|
|
|
String tabTitle = DataMinerAlgorithms.DEA_ANALYSIS.getTitle();
|
|
final Tab tab = viewController.createTab(tabTitle+" #" + (viewController.currentNumberOfTab() + 1),
|
|
PerformFishResources.INSTANCE.batch_DEAANALYSIS().getText(), submitRequestPanel);
|
|
viewController.noSpinner(tab);
|
|
final List<KPI> selectedKPI = new ArrayList<KPI>(viewController.getSelectedKPIs());
|
|
|
|
DeaPanelResult deaPanelResult = new DeaPanelResult();
|
|
deaPanelResult.addSelectedKPIs(selectedKPI);
|
|
deaPanelResult.addParameters(PerformFishAnalyticsConstant.DATA_INPUTS, mapParameters,
|
|
viewController.getForm().getBatchType());
|
|
submitRequestPanel.addWidget(deaPanelResult);
|
|
}
|
|
|
|
/**
|
|
* Call data miner service for chart type correlation.
|
|
*
|
|
* @param performFishResponse
|
|
* the perform fish response
|
|
* @param performFishRequestParameters
|
|
* the perform fish request parameters
|
|
*/
|
|
private void callDataMinerServiceForChartTypeCorrelation(final PerformFishResponse performFishResponse,
|
|
final Map<String, List<String>> performFishRequestParameters) {
|
|
|
|
GWT.log("Read perform fish response: " + performFishResponse);
|
|
|
|
String batchTableURL = performFishResponse.getMapParameters().get(PerformFishAnalyticsConstant.BATCHES_TABLE);
|
|
|
|
if (batchTableURL == null || batchTableURL.isEmpty())
|
|
Window.alert("Something seems wrong. No batches tables matching with parameter "
|
|
+ PerformFishAnalyticsConstant.BATCHES_TABLE + " returned from service");
|
|
|
|
final Map<String, List<String>> mapParameters = new HashMap<String, List<String>>();
|
|
|
|
StringBuilder dataInputsFormatter = new StringBuilder();
|
|
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_SCALEP_PARAM + "=BATCH;");
|
|
String theBatchType = viewController.getForm().getBatchType();
|
|
theBatchType = theBatchType.replace("_CLOSED_BATCHES", ""); // REMOVING
|
|
// SUFFIX
|
|
// _CLOSED_BATCHES
|
|
// FOR
|
|
// DATAMINER
|
|
// CALL
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_BATCHTYPE_PARAM + "=" + theBatchType + ";");
|
|
dataInputsFormatter
|
|
.append(PerformFishAnalyticsConstant.DM_CHARTTYPE_PARAM + "=" + DataMinerAlgorithms.CORRELATION + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_FARMFILE_PARAM + "=" + batchTableURL + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_FOCUS_PARAM + "=ID;");
|
|
|
|
String kpiCodes = "";
|
|
for (KPI kpi : viewController.getSelectedKPIs()) {
|
|
kpiCodes += kpi.getCode() + "|";
|
|
}
|
|
// remove last |
|
|
kpiCodes = kpiCodes.substring(0, kpiCodes.length() - 1);
|
|
dataInputsFormatter.append("inputKPI=" + kpiCodes + ";");
|
|
// dataInputsFormatter.append("outputKPI=;");
|
|
|
|
String dataInParameters = dataInputsFormatter.toString();
|
|
GWT.log("Calling DM service with client input parameters: " + dataInParameters);
|
|
|
|
mapParameters.put(PerformFishAnalyticsConstant.DATA_INPUTS, Arrays.asList(dataInParameters));
|
|
|
|
final SubmitRequestPanel submitRequestPanel = new SubmitRequestPanel("", 1);
|
|
submitRequestPanel.showLoader(true,
|
|
"Submitting " + DataMinerAlgorithms.CORRELATION.getTitle() + " request to DM Service...");
|
|
|
|
String tabTitle = DataMinerAlgorithms.CORRELATION.getTitle();
|
|
final Tab tab = viewController.createTab(tabTitle + " #" + (viewController.currentNumberOfTab() + 1),
|
|
PerformFishResources.INSTANCE.batch_CORRELATION().getText(), submitRequestPanel);
|
|
|
|
final List<KPI> selectedKPI = new ArrayList<KPI>(viewController.getSelectedKPIs());
|
|
final List<String> batchIDs = new ArrayList<String>(viewController.getListBatchesID());
|
|
PerformFishAnalyticsServiceAsync.Util.getInstance().callingDataMinerPerformFishCorrelationAnalysis(
|
|
performFishResponse, mapParameters, new AsyncCallback<DataMinerResponse>() {
|
|
|
|
@Override
|
|
public void onSuccess(DataMinerResponse dmResponse) {
|
|
submitRequestPanel.showLoader(false, null);
|
|
checkTabSpinner(submitRequestPanel, tab);
|
|
AnalyticsPanelResult analyticsPanelResult = new AnalyticsPanelResult();
|
|
analyticsPanelResult.addSelectedAreas(
|
|
performFishRequestParameters.get(PerformFishAnalyticsConstant.PERFORM_FISH_AREA_PARAM));
|
|
analyticsPanelResult.addSelectedKPIs(selectedKPI);
|
|
analyticsPanelResult.addListFocusIds(batchIDs);
|
|
analyticsPanelResult.addParameters(PerformFishAnalyticsConstant.DATA_INPUTS, mapParameters,
|
|
viewController.getForm().getBatchType());
|
|
analyticsPanelResult.addResults(dmResponse);
|
|
submitRequestPanel.addWidget(analyticsPanelResult);
|
|
// viewController.geTabPanelView().addResult(resultPanel,
|
|
// "Analysis
|
|
// #"+(viewController.geTabPanelView().countTab()+1));
|
|
// modal.hide();
|
|
}
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
GWT.log(caught.toString());
|
|
submitRequestPanel.showLoader(false, null);
|
|
checkTabSpinner(submitRequestPanel, tab);
|
|
try {
|
|
AnalyticsPanelResult analyticsPanelResult = new AnalyticsPanelResult();
|
|
analyticsPanelResult.addSelectedAreas(performFishRequestParameters
|
|
.get(PerformFishAnalyticsConstant.PERFORM_FISH_AREA_PARAM));
|
|
analyticsPanelResult.addSelectedKPIs(selectedKPI);
|
|
analyticsPanelResult.addListFocusIds(batchIDs);
|
|
analyticsPanelResult.addParameters(PerformFishAnalyticsConstant.DATA_INPUTS, mapParameters,
|
|
viewController.getForm().getBatchType());
|
|
submitRequestPanel.addWidget(analyticsPanelResult);
|
|
} catch (Exception e) {
|
|
GWT.log("Error in AnalyticsPanelResult: " + e.getLocalizedMessage(), e);
|
|
}
|
|
|
|
Alert error = new Alert(caught.getMessage());
|
|
error.setClose(false);
|
|
error.setType(AlertType.ERROR);
|
|
submitRequestPanel.addWidget(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creating new TAB and calling DM algorithm.
|
|
*
|
|
* @param algorithm
|
|
* the algorithm
|
|
* @param focusID
|
|
* the focus id
|
|
* @param inputKPI
|
|
* the input kpi
|
|
* @param outputKPI
|
|
* the output kpi
|
|
*/
|
|
private void callAlgorithm(DataMinerAlgorithms algorithm, String focusID, List<KPI> inputKPI,
|
|
final List<KPI> outputKPI) {
|
|
|
|
String selectedBatchID = viewController.getSelectedBatchID();
|
|
|
|
if (selectedBatchID == null || selectedBatchID.isEmpty())
|
|
Window.alert("Something seems wrong, no selected BatchID, try again");
|
|
|
|
// submitRequestPanel.getElement().addClassName("ext-horizontal-panel");
|
|
String tabTitle = algorithm.getTitle();
|
|
|
|
// TO MANAGE ALGORITHMS DESCRIPTION
|
|
TextResource algDescr = null;
|
|
switch (algorithm) {
|
|
case BOXPLOT:
|
|
algDescr = PerformFishResources.INSTANCE.batch_BOXPLOT();
|
|
break;
|
|
case CORRELATION:
|
|
algDescr = PerformFishResources.INSTANCE.batch_CORRELATION();
|
|
break;
|
|
case DEA_ANALYSIS:
|
|
break;
|
|
case DEA_CHART:
|
|
break;
|
|
case PERFORMFISH_SYNOPTIC_TABLE_FARM:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH:
|
|
break;
|
|
case SCATTER:
|
|
algDescr = PerformFishResources.INSTANCE.batch_SCATTER();
|
|
break;
|
|
case SPEEDOMETER:
|
|
algDescr = PerformFishResources.INSTANCE.batch_SPEEDOMETER();
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_HATCHERY:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_PREGROW:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
String algDesrTxt = algDescr != null ? algDescr.getText() : null;
|
|
final SubmitRequestPanel submitRequestPanel = new SubmitRequestPanel("", 1);
|
|
Tab tab = viewController.createTab(tabTitle + " #" + (viewController.currentNumberOfTab() + 1), algDesrTxt,
|
|
submitRequestPanel);
|
|
|
|
switch (algorithm) {
|
|
case BOXPLOT:
|
|
case SPEEDOMETER:
|
|
|
|
submitRequestPanel.setTotalRequests(inputKPI.size());
|
|
for (KPI kpi : inputKPI) {
|
|
String title = "KPI: " + kpi.getName();
|
|
HTML toBigTitle = new HTML(title);
|
|
toBigTitle.getElement().addClassName("to-big-title");
|
|
submitRequestPanel.addWidget(toBigTitle);
|
|
HorizontalPanel hp = new HorizontalPanel();
|
|
hp.getElement().addClassName("ext-horizontal-panel");
|
|
callDataMinerServiceForChart(viewController.getPerformFishResponse(), POPULATION_LEVEL.BATCH,
|
|
Arrays.asList(kpi), Arrays.asList(kpi), algorithm, focusID, submitRequestPanel, hp, tab);
|
|
// resultPanel.add(hp);
|
|
submitRequestPanel.addWidget(hp);
|
|
}
|
|
break;
|
|
case SCATTER:
|
|
|
|
if (inputKPI.get(0) == null || inputKPI.get(1) == null) {
|
|
submitRequestPanel
|
|
.setTheTitle("Sorry, something seems wrong, the selected KPIs are not valid. Please try again");
|
|
checkTabSpinner(submitRequestPanel, tab);
|
|
return;
|
|
// Window.alert("Something seems wrong, no selected BatchID, try
|
|
// again");
|
|
}
|
|
|
|
String titleScatter = "KPI: " + inputKPI.get(0).getName() + " vs " + inputKPI.get(1).getName();
|
|
submitRequestPanel.setTheTitle(titleScatter);
|
|
|
|
default:
|
|
callDataMinerServiceForChart(viewController.getPerformFishResponse(), POPULATION_LEVEL.BATCH, inputKPI,
|
|
outputKPI, algorithm, focusID, submitRequestPanel, submitRequestPanel.getContainerPanel(), tab);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call data miner service for chart.
|
|
*
|
|
* @param performFishResponse
|
|
* the perform fish response
|
|
* @param scalePValue
|
|
* the scale p value
|
|
* @param inputKPI
|
|
* the input kpi
|
|
* @param outputKPI
|
|
* the output kpi
|
|
* @param chartType
|
|
* the chart type
|
|
* @param focusID
|
|
* the focus id
|
|
* @param requestPanel
|
|
* the request panel
|
|
* @param panelContainer
|
|
* the panel
|
|
* @param tab
|
|
* the tab
|
|
*/
|
|
private void callDataMinerServiceForChart(PerformFishResponse performFishResponse, POPULATION_LEVEL scalePValue,
|
|
final List<KPI> inputKPI, final List<KPI> outputKPI, final DataMinerAlgorithms chartType,
|
|
final String focusID, final SubmitRequestPanel requestPanel, final ComplexPanel panelContainer,
|
|
final Tab tab) {
|
|
|
|
GWT.log("Read perform fish response: " + performFishResponse);
|
|
|
|
String batchTableURL = performFishResponse.getMapParameters().get(PerformFishAnalyticsConstant.BATCHES_TABLE);
|
|
|
|
if (batchTableURL == null || batchTableURL.isEmpty())
|
|
Window.alert("Something seems wrong. No batches tables matching with parameter "
|
|
+ PerformFishAnalyticsConstant.BATCHES_TABLE + " returned from service");
|
|
|
|
StringBuilder dataInputsFormatter = new StringBuilder();
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_SCALEP_PARAM + "=" + scalePValue.name() + ";");
|
|
String theBatchType = viewController.getForm().getBatchType();
|
|
theBatchType = theBatchType.replace("_CLOSED_BATCHES", ""); // REMOVING
|
|
// SUFFIX
|
|
// _CLOSED_BATCHES
|
|
// FOR
|
|
// DATAMINER
|
|
// CALL
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_BATCHTYPE_PARAM + "=" + theBatchType + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_CHARTTYPE_PARAM + "=" + chartType + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_FARMFILE_PARAM + "=" + batchTableURL + ";");
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_FOCUS_PARAM + "=" + focusID + ";");
|
|
|
|
if (inputKPI != null && inputKPI.size() > 0) {
|
|
String kpiCodes = "";
|
|
for (KPI kpi : inputKPI) {
|
|
kpiCodes += kpi.getCode() + "|";
|
|
}
|
|
// remove last |
|
|
kpiCodes = kpiCodes.substring(0, kpiCodes.length() - 1);
|
|
|
|
GWT.log("Input KPICodes: " + kpiCodes);
|
|
// ADDING KPIs code
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_INPUT_KPI_PARAM + "=" + kpiCodes + ";");
|
|
|
|
}
|
|
|
|
if (outputKPI != null && outputKPI.size() > 0) {
|
|
String kpiCodes = "";
|
|
for (KPI kpi : outputKPI) {
|
|
kpiCodes += kpi.getCode() + "|";
|
|
}
|
|
// remove last |
|
|
kpiCodes = kpiCodes.substring(0, kpiCodes.length() - 1);
|
|
|
|
GWT.log("Output KPICodes: " + kpiCodes);
|
|
// ADDING KPIs code
|
|
dataInputsFormatter.append(PerformFishAnalyticsConstant.DM_OUTPUT_KPI_PARAM + "=" + kpiCodes + ";");
|
|
|
|
}
|
|
|
|
String dataInParameters = dataInputsFormatter.toString();
|
|
GWT.log("Calling DM service with client input parameters: " + dataInParameters);
|
|
|
|
Map<String, List<String>> mapParameters = new HashMap<String, List<String>>();
|
|
mapParameters.put(PerformFishAnalyticsConstant.DATA_INPUTS, Arrays.asList(dataInParameters));
|
|
|
|
final LoaderIcon loaderIcon = new LoaderIcon("Submitting request to " + chartType.getTitle() + " Analysis...");
|
|
loaderIcon.setVisible(true);
|
|
panelContainer.setVisible(true);
|
|
panelContainer.add(loaderIcon);
|
|
Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
|
|
@Override
|
|
public void execute() {
|
|
loaderIcon.setFocus(true);
|
|
}
|
|
});
|
|
|
|
PerformFishAnalyticsServiceAsync.Util.getInstance().callingDataMinerPerformFishAnalysis(mapParameters,
|
|
new AsyncCallback<DataMinerResponse>() {
|
|
|
|
@Override
|
|
public void onSuccess(DataMinerResponse dmResponse) {
|
|
loaderIcon.setVisible(false);
|
|
checkTabSpinner(requestPanel, tab);
|
|
// field_unary_algorithm.setVisible(true);
|
|
GWT.log("I'm displaying: " + dmResponse);
|
|
displayOutputFilesAsStaticEntities(dmResponse, chartType, inputKPI, outputKPI, focusID,
|
|
panelContainer, false);
|
|
}
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
loaderIcon.setVisible(false);
|
|
checkTabSpinner(requestPanel, tab);
|
|
displayOutputFilesAsStaticEntities(null, chartType, inputKPI, outputKPI, focusID,
|
|
panelContainer, true);
|
|
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Remove the spinner if all DM responses are returned.
|
|
*
|
|
* @param requestPanel
|
|
* the request panel
|
|
* @param tab
|
|
* the tab
|
|
*/
|
|
private void checkTabSpinner(SubmitRequestPanel requestPanel, Tab tab) {
|
|
requestPanel.incrementCompletedRequests();
|
|
int completed = requestPanel.getCompletedRequests();
|
|
int total = requestPanel.getTotalRequests();
|
|
|
|
if (completed >= total) {
|
|
viewController.noSpinner(tab);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Display output files as static entities.
|
|
*
|
|
* @param dmResponse
|
|
* the dm response
|
|
* @param chartType
|
|
* the chart type
|
|
* @param inputKPIs
|
|
* the input kp is
|
|
* @param outputKPIs
|
|
* the output kp is
|
|
* @param focusID
|
|
* the focus id
|
|
* @param container
|
|
* the container
|
|
* @param displayError
|
|
* the display error
|
|
*/
|
|
private void displayOutputFilesAsStaticEntities(final DataMinerResponse dmResponse,
|
|
final DataMinerAlgorithms chartType, List<KPI> inputKPIs, List<KPI> outputKPIs, final String focusID,
|
|
final Panel container, boolean displayError) {
|
|
|
|
String title = displayError ? "No results " : "";
|
|
|
|
if (displayError) {
|
|
Alert alert = new Alert(title);
|
|
alert.setType(AlertType.ERROR);
|
|
alert.setClose(false);
|
|
alert.getElement().getStyle().setMargin(10, Unit.PX);
|
|
container.add(alert);
|
|
return;
|
|
}
|
|
|
|
final String toTitle = title;
|
|
|
|
for (final OutputFile outputFile : dmResponse.getListOutput()) {
|
|
|
|
switch (outputFile.getDataType()) {
|
|
case IMAGE:
|
|
PerformFishAnalyticsServiceAsync.Util.getInstance().getImageFile(outputFile,
|
|
new AsyncCallback<String>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
// showAlert(caught.getMessage(),
|
|
// AlertType.ERROR, true,
|
|
// uib_vp_deanalanlysis_request_container);
|
|
Window.alert(caught.getMessage());
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(String base64Content) {
|
|
|
|
String title = toTitle;
|
|
switch (chartType) {
|
|
case BOXPLOT:
|
|
title = chartType.getName() + " - on all batches<br>";
|
|
title += "Blue dots indicate the selected batch(es): " + focusID;
|
|
|
|
ShowResult showResult = new ShowResult(title);
|
|
showResult.showImage(base64Content);
|
|
displayingOrderedBoxPlot(dmResponse, title, container, showResult);
|
|
return;
|
|
case CORRELATION:
|
|
break;
|
|
case DEA_ANALYSIS:
|
|
break;
|
|
case SCATTER:
|
|
break;
|
|
case SPEEDOMETER:
|
|
title = chartType.getTitle() + "<br>";
|
|
title += "Selected Batch ID: " + focusID + "<br>";
|
|
title += "Normalized with respect to all batches in the VRE";
|
|
break;
|
|
case DEA_CHART:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH:
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_HATCHERY:
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_PREGROW:
|
|
case PERFORMFISH_SYNOPTIC_TABLE_FARM:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ShowResult showResult = new ShowResult(title);
|
|
showResult.showImage(base64Content);
|
|
container.add(showResult);
|
|
|
|
}
|
|
});
|
|
break;
|
|
case CSV:
|
|
PerformFishAnalyticsServiceAsync.Util.getInstance().getCSVFile(outputFile, true,
|
|
new AsyncCallback<CSVFile>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
// showAlert(caught.getMessage(),
|
|
// AlertType.ERROR, true,
|
|
// uib_vp_deanalanlysis_request_container);
|
|
Window.alert(caught.getMessage());
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(CSVFile result) {
|
|
GWT.log("Displaying: " + result);
|
|
|
|
String cssTableStyle = "simpletable";
|
|
|
|
String title = toTitle;
|
|
switch (chartType) {
|
|
case BOXPLOT:
|
|
|
|
if (result.getFileName().contains("_user")) {
|
|
title = "My Batch(es)";
|
|
} else {
|
|
title = "All batches in the VRE (including mine)";
|
|
}
|
|
title += "<br>";
|
|
title += "Data aggregation is performed by considering batches as base units";
|
|
|
|
ShowResult showResult = new ShowResult(title);
|
|
showResult.showCSVFile(result, cssTableStyle);
|
|
displayingOrderedBoxPlot(dmResponse, title, container, showResult);
|
|
|
|
return;
|
|
|
|
case CORRELATION:
|
|
break;
|
|
case DEA_ANALYSIS:
|
|
break;
|
|
case SCATTER:
|
|
break;
|
|
case SPEEDOMETER:
|
|
break;
|
|
case DEA_CHART:
|
|
break;
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH:
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_HATCHERY:
|
|
case PERFORMFISH_SYNOPTICTABLE_BATCH_PREGROW:
|
|
|
|
if (!result.getFileName().contains("legend")) {
|
|
cssTableStyle = "synoptictable-batch";
|
|
} else {
|
|
cssTableStyle = "simpletable-synoptic";
|
|
}
|
|
|
|
ShowResult showResultSin = new ShowResult(title);
|
|
showResultSin.showCSVFile(result, cssTableStyle);
|
|
displayingOrderedSynopticTable(dmResponse, result.getFileName(), container,
|
|
showResultSin);
|
|
|
|
return;
|
|
case PERFORMFISH_SYNOPTIC_TABLE_FARM:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// ALL OTHER CASES
|
|
ShowResult showResult = new ShowResult(title);
|
|
showResult.showCSVFile(result, cssTableStyle);
|
|
container.add(showResult);
|
|
}
|
|
});
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void displayingOrderedBoxPlot(final DataMinerResponse dmResponse, String title, final Panel container,
|
|
ShowResult showResult) {
|
|
int hashcode = dmResponse.hashCode();
|
|
GWT.log("The hascode is: " + hashcode);
|
|
FlexTable flex = boxPlotOrderBy.get(hashcode);
|
|
|
|
if (flex == null) {
|
|
GWT.log("The flextable is null");
|
|
flex = new FlexTable();
|
|
boxPlotOrderBy.put(hashcode, flex);
|
|
container.add(flex);
|
|
}
|
|
|
|
if (title.startsWith("My")) {
|
|
flex.setWidget(0, 0, showResult);
|
|
} else if (title.startsWith("All")) {
|
|
flex.setWidget(0, 1, showResult);
|
|
} else {
|
|
flex.setWidget(0, 2, showResult);
|
|
}
|
|
}
|
|
|
|
private void displayingOrderedSynopticTable(final DataMinerResponse dmResponse, String fileName,
|
|
final Panel container, ShowResult showResult) {
|
|
int hashcode = dmResponse.hashCode();
|
|
GWT.log("The hascode is: " + hashcode);
|
|
FlexTable flex = synopticOrderBy.get(hashcode);
|
|
|
|
if (flex == null) {
|
|
GWT.log("The flextable is null");
|
|
flex = new FlexTable();
|
|
synopticOrderBy.put(hashcode, flex);
|
|
container.add(flex);
|
|
}
|
|
|
|
if (fileName.toLowerCase().contains("legend")) {
|
|
flex.setWidget(0, 0, showResult);
|
|
} else {
|
|
flex.setWidget(flex.getRowCount() + 1, 0, showResult);
|
|
}
|
|
}
|
|
}
|