From 9a881615a0c0a58c247adc66edc867cdab790690 Mon Sep 17 00:00:00 2001 From: "giancarlo.panichi" Date: Mon, 15 Feb 2016 13:35:02 +0000 Subject: [PATCH] 2251: Accounting Manager - Stacked column chart for tops https://support.d4science.org/issues/2251 Start Stacked Chart on Storage git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/portlets/admin/accounting-manager@124191 82a268e6-3cf1-43bd-a215-b396298e98cf --- .settings/org.eclipse.wst.common.component | 3 - pom.xml | 6 +- .../maindata/charts/AccountingChart4Job.java | 8 +- .../charts/AccountingChart4Portlet.java | 5 +- .../charts/AccountingChart4Storage.java | 57 +- .../maindata/charts/AccountingChart4Task.java | 5 +- .../client/maindata/charts/job/JobChart.java | 614 ++++++++++++++++++ .../charts/storage/StorageChart4Multi.java | 50 ++ .../charts/storage/StorageChart4Top.java | 50 ++ .../charts/storage/StorageChartBuilder.java | 26 + .../charts/storage/StorageChartDirector.java | 31 + .../charts/storage/StorageChartPanel.java | 34 + .../charts/storage/StorageChartSpec.java | 22 + .../StorageChartMultiPanel.java} | 19 +- .../storage/panels/StorageChartTopPanel.java | 501 ++++++++++++++ .../charts/utils/StorageChartMeasure.java | 63 ++ .../client/menu/AccountingManagerMenu.java | 3 +- .../server/AccountingManagerServiceImpl.java | 8 +- .../accountingmanager/server/SessionUtil.java | 7 +- .../server/amservice/AccountingCaller.java | 317 +++++---- .../amservice/AccountingCallerInterface.java | 32 + .../amservice/AccountingCallerTester.java | 153 +++++ .../amservice/query/AccountingQuery4Job.java | 19 +- .../query/AccountingQuery4Portlet.java | 19 +- .../amservice/query/AccountingQuery4Task.java | 17 +- .../response/SeriesResponse4Job.java | 39 +- .../accountingmanager/shared/Constants.java | 3 + ...ntingManagerStorageChartDrawException.java | 38 ++ 28 files changed, 1942 insertions(+), 207 deletions(-) create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/job/JobChart.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Multi.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Top.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartBuilder.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartDirector.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartPanel.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartSpec.java rename src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/{StorageChart.java => panels/StorageChartMultiPanel.java} (97%) create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartTopPanel.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/utils/StorageChartMeasure.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerInterface.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerTester.java create mode 100644 src/main/java/org/gcube/portlets/admin/accountingmanager/shared/exception/AccountingManagerStorageChartDrawException.java diff --git a/.settings/org.eclipse.wst.common.component b/.settings/org.eclipse.wst.common.component index e6d61c1..798b382 100644 --- a/.settings/org.eclipse.wst.common.component +++ b/.settings/org.eclipse.wst.common.component @@ -4,9 +4,6 @@ - - uses - diff --git a/pom.xml b/pom.xml index 9e1b110..7730ff0 100644 --- a/pom.xml +++ b/pom.xml @@ -80,6 +80,11 @@ accounting-lib [2.0.0-SNAPSHOT,3.0.0-SNAPSHOT) + + org.gcube.common + authorization-client + + @@ -241,7 +246,6 @@ [1.0.0-SNAPSHOT,2.0.0-SNAPSHOT) - com.allen-sauer.gwt.log diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Job.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Job.java index 61904cc..c00761e 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Job.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Job.java @@ -1,8 +1,8 @@ package org.gcube.portlets.admin.accountingmanager.client.maindata.charts; -import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.job.JobChart; import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; -import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesJob; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerChartDrawException; /** @@ -32,12 +32,12 @@ public class AccountingChart4Job extends AccountingChartBuilder { return; } - if (!(accountingStateData.getSeriesResponse() instanceof SeriesStorage)) { + if (!(accountingStateData.getSeriesResponse() instanceof SeriesJob)) { accountingChartSpec.setChart(accountingChartPanel); return; } - StorageChart container=new StorageChart(accountingStateData); + JobChart container=new JobChart(accountingStateData); accountingChartPanel = new AccountingChartPanel(container); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Portlet.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Portlet.java index 4aea109..df779b0 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Portlet.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Portlet.java @@ -1,6 +1,5 @@ package org.gcube.portlets.admin.accountingmanager.client.maindata.charts; -import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart; import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerChartDrawException; @@ -37,9 +36,9 @@ public class AccountingChart4Portlet extends AccountingChartBuilder { return; } - StorageChart container=new StorageChart(accountingStateData); + //StorageChart container=new StorageChart(accountingStateData); - accountingChartPanel = new AccountingChartPanel(container); + //accountingChartPanel = new AccountingChartPanel(container); accountingChartSpec.setChart(accountingChartPanel); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Storage.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Storage.java index 5b9dcbe..fc9f052 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Storage.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Storage.java @@ -1,9 +1,15 @@ package org.gcube.portlets.admin.accountingmanager.client.maindata.charts; -import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart4Top; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChartBuilder; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChartDirector; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChartPanel; import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerChartDrawException; +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerStorageChartDrawException; + +import com.allen_sauer.gwt.log.client.Log; /** * Accounting Chart 4 Storage @@ -14,7 +20,6 @@ import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingMan */ public class AccountingChart4Storage extends AccountingChartBuilder { - private AccountingStateData accountingStateData; public AccountingChart4Storage(AccountingStateData accountingStateData) { @@ -37,12 +42,52 @@ public class AccountingChart4Storage extends AccountingChartBuilder { accountingChartSpec.setChart(accountingChartPanel); return; } - - StorageChart container=new StorageChart(accountingStateData); - - accountingChartPanel = new AccountingChartPanel(container); + + StorageChartPanel container = createStorageChartPanel(); + + accountingChartPanel = new AccountingChartPanel(container.getChart()); accountingChartSpec.setChart(accountingChartPanel); } + + private StorageChartPanel createStorageChartPanel() throws AccountingManagerStorageChartDrawException { + + if (accountingStateData == null + || accountingStateData.getAccountingType() == null) { + return null; + } + + switch (accountingStateData.getAccountingType()) { + + case STORAGE: + return createStorageChart(new StorageChart4Top( + accountingStateData)); + + default: + + return null; + } + + } + + private StorageChartPanel createStorageChart( + StorageChartBuilder chartBuilder) throws AccountingManagerStorageChartDrawException { + + try { + StorageChartDirector director = new StorageChartDirector(); + director.setStorageChartBuilder(chartBuilder); + director.constructStorageChart(); + + StorageChartPanel chart = director.getStorageChart(); + + return chart; + } catch (AccountingManagerStorageChartDrawException e) { + Log.error(e.getLocalizedMessage()); + e.printStackTrace(); + throw e; + } + + } + } diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Task.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Task.java index a77c9b8..fbd3f06 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Task.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/AccountingChart4Task.java @@ -1,6 +1,5 @@ package org.gcube.portlets.admin.accountingmanager.client.maindata.charts; -import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart; import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerChartDrawException; @@ -37,9 +36,9 @@ public class AccountingChart4Task extends AccountingChartBuilder { return; } - StorageChart container=new StorageChart(accountingStateData); + //StorageChart container=new StorageChart(accountingStateData); - accountingChartPanel = new AccountingChartPanel(container); + //accountingChartPanel = new AccountingChartPanel(container); accountingChartSpec.setChart(accountingChartPanel); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/job/JobChart.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/job/JobChart.java new file mode 100644 index 0000000..9d155e6 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/job/JobChart.java @@ -0,0 +1,614 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.job; + +import java.util.Date; + +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils.ChartTimeMeasure; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils.DownloadConstants; +import org.gcube.portlets.admin.accountingmanager.client.resource.AccountingManagerResources; +import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesJob; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesJobData; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesService; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesServiceData; + +import com.allen_sauer.gwt.log.client.Log; +import com.github.highcharts4gwt.client.view.widget.HighchartsLayoutPanel; +import com.github.highcharts4gwt.model.array.api.ArrayNumber; +import com.github.highcharts4gwt.model.array.api.ArrayString; +import com.github.highcharts4gwt.model.factory.api.HighchartsOptionFactory; +import com.github.highcharts4gwt.model.factory.jso.JsoHighchartsOptionFactory; +import com.github.highcharts4gwt.model.highcharts.option.api.ChartOptions; +import com.github.highcharts4gwt.model.highcharts.option.api.SeriesArea; +import com.github.highcharts4gwt.model.highcharts.option.api.SeriesColumn; +import com.google.gwt.event.logical.shared.SelectionEvent; +import com.google.gwt.event.logical.shared.SelectionHandler; +import com.google.gwt.i18n.client.DateTimeFormat; +import com.google.gwt.i18n.client.DateTimeFormat.PredefinedFormat; +import com.sencha.gxt.cell.core.client.ButtonCell.ButtonArrowAlign; +import com.sencha.gxt.cell.core.client.ButtonCell.IconAlign; +import com.sencha.gxt.core.client.util.Margins; +import com.sencha.gxt.widget.core.client.button.TextButton; +import com.sencha.gxt.widget.core.client.button.ToggleButton; +import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutData; +import com.sencha.gxt.widget.core.client.container.MarginData; +import com.sencha.gxt.widget.core.client.container.SimpleContainer; +import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer; +import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer.VerticalLayoutData; +import com.sencha.gxt.widget.core.client.event.SelectEvent; +import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler; +import com.sencha.gxt.widget.core.client.menu.Item; +import com.sencha.gxt.widget.core.client.menu.Menu; +import com.sencha.gxt.widget.core.client.menu.MenuItem; +import com.sencha.gxt.widget.core.client.toolbar.ToolBar; + +/** + * + * @author giancarlo email: g.panichi@isti.cnr.it + * + */ +public class JobChart extends SimpleContainer { + private DateTimeFormat dtf=DateTimeFormat.getFormat(PredefinedFormat.YEAR_MONTH_DAY); + + private static final String SINGLE_AXIS = "Single Axis"; + private AccountingStateData accountingStateData; + private HighchartsLayoutPanel highchartsLayoutPanel; + + // Replace Menu + private MenuItem downloadPNGItem; + private MenuItem downloadJPGItem; + private MenuItem downloadPDFItem; + private MenuItem downloadSVGItem; + ChartOptions options; + + public JobChart(AccountingStateData accountingStateData) { + this.accountingStateData = accountingStateData; + forceLayoutOnResize = true; + create(); + + } + + private void create() { + ToolBar toolBar = new ToolBar(); + toolBar.setSpacing(2); + // Download + final TextButton downloadButton = new TextButton(DownloadConstants.DOWNLOAD, + AccountingManagerResources.INSTANCE + .accountingDownload24()); + // downloadButton.setScale(ButtonScale.MEDIUM); + downloadButton.setIconAlign(IconAlign.RIGHT); + downloadButton.setArrowAlign(ButtonArrowAlign.RIGHT); + downloadButton.setMenu(createDownloadMenu()); + + toolBar.add(downloadButton, new BoxLayoutData(new Margins(0))); + + // Single Axis + final ToggleButton toggleButton = new ToggleButton(SINGLE_AXIS); + toggleButton.setIcon(AccountingManagerResources.INSTANCE + .accountingChartVariableAxis24()); + toggleButton.setIconAlign(IconAlign.RIGHT); + toggleButton.setValue(false); + + toggleButton.addSelectHandler(new SelectHandler() { + + @Override + public void onSelect(SelectEvent event) { + if (toggleButton.getValue()) { + createSingleAxisChart(); + highchartsLayoutPanel.renderChart(options); + } else { + createMultiAxisChart(); + highchartsLayoutPanel.renderChart(options); + } + forceLayout(); + } + }); + + //toolBar.add(toggleButton, new BoxLayoutData(new Margins(0))); + + // + createMultiAxisChart(); + + highchartsLayoutPanel = new HighchartsLayoutPanel(); + highchartsLayoutPanel.renderChart(options); + + // + VerticalLayoutContainer vert = new VerticalLayoutContainer(); + vert.add(toolBar, new VerticalLayoutData(1, -1, new Margins(0))); + vert.add(highchartsLayoutPanel, new VerticalLayoutData(1, 1, + new Margins(0))); + + add(vert, new MarginData(0)); + + } + + private Menu createDownloadMenu() { + + Menu menuDownload = new Menu(); + downloadPNGItem = new MenuItem(DownloadConstants.DOWNLOAD_PNG, + AccountingManagerResources.INSTANCE + .accountingFilePNG24()); + downloadPNGItem.setHeight(30); + downloadJPGItem = new MenuItem(DownloadConstants.DOWNLOAD_JPG, + AccountingManagerResources.INSTANCE + .accountingFileJPG24()); + downloadJPGItem.setHeight(30); + downloadPDFItem = new MenuItem(DownloadConstants.DOWNLOAD_PDF, + AccountingManagerResources.INSTANCE + .accountingFilePDF24()); + downloadPDFItem.setHeight(30); + downloadSVGItem = new MenuItem(DownloadConstants.DOWNLOAD_SVG, + AccountingManagerResources.INSTANCE + .accountingFileSVG24()); + downloadSVGItem.setHeight(30); + + + downloadPNGItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadPNG(id); + + } + }); + + downloadJPGItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadJPG(id); + } + }); + + downloadPDFItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadPDF(id); + } + }); + + downloadSVGItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadSVG(id); + } + }); + + menuDownload.add(downloadPNGItem); + menuDownload.add(downloadJPGItem); + menuDownload.add(downloadPDFItem); + menuDownload.add(downloadSVGItem); + return menuDownload; + + } + + // chart.options.exporting.buttons.contextButton.menuItems[0].onclick(); + + public static native void onDownloadPNG(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.service.ServiceChart::options); + console.log(chart); + chart.exportChart(); + + }-*/; + + public static native void onDownloadJPG(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.service.ServiceChart::options); + console.log(chart); + chart.exportChart({ + type : 'image/jpeg' + }); + + }-*/; + + public static native void onDownloadPDF(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.service.ServiceChart::options); + console.log(chart); + chart.exportChart({ + type : 'application/pdf' + }); + + }-*/; + + public static native void onDownloadSVG(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.service.ServiceChart::options); + console.log(chart); + chart.exportChart({ + type : 'image/svg+xml' + }); + + }-*/; + + private void createMultiAxisChart() { + SeriesJob seriesJob = (SeriesJob) accountingStateData + .getSeriesResponse(); + + double minRange = ChartTimeMeasure + .calculateMinRange(accountingStateData.getSeriesRequest() + .getAccountingPeriod()); + + double interval = ChartTimeMeasure + .calculateInterval(accountingStateData.getSeriesRequest() + .getAccountingPeriod()); + + Date dateStart=dtf.parse(accountingStateData.getSeriesRequest() + .getAccountingPeriod().getStartDate()); + + dateStart.setTime(dateStart.getTime() + + ChartTimeMeasure.timeZoneOffset() * ChartTimeMeasure.MINUTE); + + Log.debug("BuildChart DateStart: " + + DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_FULL) + .format(dateStart)); + + HighchartsOptionFactory highchartsFactory = new JsoHighchartsOptionFactory(); + options = highchartsFactory.createChartOptions(); + + options.navigation().buttonOptions().enabled(false); + options.exporting().filename("AccountingService"); + options.chart().zoomType("xy"); + + options.title().text("Accounting Job"); + + /* + * options.subtitle().text("Click and drag in the plot area to zoom in"); + */ + + ArrayString colors = options.colors(); + // colors.setValue(0, "#cc0038"); + // colors.setValue(1, "#32cd32"); + + // xAxis + options.xAxis().type("datetime").minRange(minRange); + + // yAxis + String multiAxis = "[{" + " \"id\": \"OperationCount\"," + + " \"labels\": { " + " \"format\": \"{value}\"," + + " \"style\": { " + " \"color\": \"" + + colors.get(1) + + "\"" + + " }" + + " }," + + " \"title\": { " + + " \"text\": \"Operation Count\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(1) + + "\"" + + " }" + + " }" + + "} , {" + + " \"id\": \"Duration\", " + + " \"title\": {" + + " \"text\": \"Duration\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(0) + + "\"" + + " }" + + " }," + + " \"labels\": {" + + " \"format\": \"{value} ms\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(0) + + "\"" + + " }" + + " }," + + " \"opposite\": \"true\"" + + ", \"showFirstLabel\": \"false\"" + + "} , {" + + " \"id\": \"MaxInvocationTime\", " + + " \"title\": {" + + " \"text\": \"Max Invocation Time\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(2) + + "\"" + + " }" + + " }," + + " \"labels\": {" + + " \"format\": \"{value} ms\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(2) + + "\"" + + " }" + + " }," + + " \"opposite\": \"true\"" + + ", \"showFirstLabel\": \"false\"" + + "} , {" + + " \"id\": \"MinInvocationTime\", " + + " \"title\": {" + + " \"text\": \"Min Invocation Time\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(3) + + "\"" + + " }" + + " }," + + " \"labels\": {" + + " \"format\": \"{value} ms\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(3) + + "\"" + + " }" + + " }," + + " \"opposite\": \"true\"" + + ", \"showFirstLabel\": \"false\"" + "}]" + + ; + + options.setFieldAsJsonObject("yAxis", multiAxis); + + // does not seem to be working + String fillcolor = "{" + "\"linearGradient\": {" + "\"x1\": 0," + + "\"y1\": 0," + "\"x2\": 0," + "\"y2\": 1" + "}," + + "\"stops\": [" + "[" + "0, \"#058DC7\"" + "]," + "[" + + "1, \"#FFFFFF\"" + "]" + "]" + "}"; + + options.plotOptions().area() + .setFieldAsJsonObject("fillColor", fillcolor).marker() + .radius(2).lineWidth(1).states().hover().lineWidth(1); + + SeriesColumn seriesOperationCount = highchartsFactory + .createSeriesColumn(); + seriesOperationCount.name("Operation Count"); + seriesOperationCount.color(colors.get(1)); + seriesOperationCount.type("column"); + + ArrayNumber dataOperationCount = seriesOperationCount + .dataAsArrayNumber(); + + seriesOperationCount.pointInterval(interval).pointStart( + dateStart.getTime()); + + SeriesArea seriesDuration = highchartsFactory.createSeriesArea(); + seriesDuration.name("Duration"); + seriesDuration.color(colors.get(0)); + seriesDuration.yAxisAsString("Duration"); + + ArrayNumber dataDuration = seriesDuration.dataAsArrayNumber(); + + seriesDuration.pointInterval(interval).pointStart(dateStart.getTime()); + + SeriesArea seriesMaxInvocationTime = highchartsFactory + .createSeriesArea(); + seriesMaxInvocationTime.name("Max Invocation Time"); + seriesMaxInvocationTime.color(colors.get(2)); + seriesMaxInvocationTime.yAxisAsString("MaxInvocationTime"); + + ArrayNumber dataMaxInvocationTime = seriesMaxInvocationTime + .dataAsArrayNumber(); + + seriesMaxInvocationTime.pointInterval(interval).pointStart( + dateStart.getTime()); + + SeriesArea seriesMinInvocationTime = highchartsFactory + .createSeriesArea(); + seriesMinInvocationTime.name("Min Invocation Time"); + seriesMinInvocationTime.color(colors.get(3)); + seriesMinInvocationTime.yAxisAsString("MinInvocationTime"); + + ArrayNumber dataMinInvocationTime = seriesMinInvocationTime + .dataAsArrayNumber(); + + seriesMinInvocationTime.pointInterval(interval).pointStart( + dateStart.getTime()); + + for (SeriesJobData seriesServiceData : seriesJob.getSeries()) { + dataOperationCount.push(seriesServiceData.getOperationCount()); + dataDuration.push(seriesServiceData.getOperationCount()); + dataMaxInvocationTime + .push(seriesServiceData.getOperationCount()); + dataMinInvocationTime + .push(seriesServiceData.getOperationCount()); + + //dataDuration.push(seriesServiceData.getDuration()); + //dataMaxInvocationTime + // .push(seriesServiceData.getMaxInvocationTime()); + //dataMinInvocationTime + // .push(seriesServiceData.getMinInvocationTime()); + } + + options.series().addToEnd(seriesOperationCount); + options.series().addToEnd(seriesDuration); + options.series().addToEnd(seriesMaxInvocationTime); + options.series().addToEnd(seriesMinInvocationTime); + + options.chart().showAxes(true); + + options.legend().enabled(true); + // options.legend().layout("vertical"); + // options.legend().align("left"); + // options.legend().x(120); + // options.legend().verticalAlign("top"); + // options.legend().y(100); + // options.legend().floating(true); + // options.legend() + // .backgroundColor( + // "(Highcharts.theme && Highcharts.theme.legendBackgroundColor) || 'white'"); + return; + } + + private void createSingleAxisChart() { + SeriesService seriesService = (SeriesService) accountingStateData + .getSeriesResponse(); + + double minRange = ChartTimeMeasure + .calculateMinRange(accountingStateData.getSeriesRequest() + .getAccountingPeriod()); + + double interval = ChartTimeMeasure + .calculateInterval(accountingStateData.getSeriesRequest() + .getAccountingPeriod()); + + Date dateStart=dtf.parse(accountingStateData.getSeriesRequest() + .getAccountingPeriod().getStartDate()); + + dateStart.setTime(dateStart.getTime() + + ChartTimeMeasure.timeZoneOffset() * ChartTimeMeasure.MINUTE); + + Log.debug("BuildChart DateStart: " + + DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_FULL) + .format(dateStart)); + + HighchartsOptionFactory highchartsFactory = new JsoHighchartsOptionFactory(); + options = highchartsFactory.createChartOptions(); + + options.navigation().buttonOptions().enabled(false); + options.exporting().filename("AccountingService"); + options.chart().zoomType("xy"); + + options.title().text("Accounting Service"); + + /* + * options.subtitle().text("Click and drag in the plot area to zoom in"); + */ + + ArrayString colors = options.colors(); + // colors.setValue(0, "#cc0038"); + // colors.setValue(1, "#32cd32"); + + // xAxis + options.xAxis().type("datetime").minRange(minRange); + + // yAxis + // options.yAxis().title().text("Exchange rate"); + // Highcharts.getOptions().colors[0] + + String multiAxis = "[{" + " \"id\": \"OperationCount\"," + + " \"labels\": { " + " \"format\": \"{value}\"," + + " \"style\": { " + " \"color\": \"" + + colors.get(1) + + "\"" + + " }" + + " }," + + " \"title\": { " + + " \"text\": \"Operation Count\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(1) + + "\"" + + " }" + + " }" + + "} , {" + + " \"id\": \"ServiceData\", " + + " \"linkedTo\": \"0\"," + + " \"gridLineWidth\": \"0\"," + + " \"title\": {" + + " \"text\": \"\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(1) + + "\"" + + " }" + + " }," + + " \"labels\": {" + + " \"format\": \"{value} ms\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(1) + + "\"" + " }" + " }," + " \"opposite\": \"true\"" + // + + // ", \"showFirstLabel\": \"false\"" + // + + "}]"; + + options.setFieldAsJsonObject("yAxis", multiAxis); + + // does not seem to be working + String fillcolor = "{" + "\"linearGradient\": {" + "\"x1\": 0," + + "\"y1\": 0," + "\"x2\": 0," + "\"y2\": 1" + "}," + + "\"stops\": [" + "[" + "0, \"#058DC7\"" + "]," + "[" + + "1, \"#FFFFFF\"" + "]" + "]" + "}"; + + options.plotOptions().area() + .setFieldAsJsonObject("fillColor", fillcolor).marker() + .radius(2).lineWidth(1).states().hover().lineWidth(1); + + SeriesColumn seriesOperationCount = highchartsFactory + .createSeriesColumn(); + seriesOperationCount.name("Operation Count"); + seriesOperationCount.color(colors.get(1)); + seriesOperationCount.type("column"); + + ArrayNumber dataOperationCount = seriesOperationCount + .dataAsArrayNumber(); + + seriesOperationCount.pointInterval(interval).pointStart( + dateStart.getTime()); + + SeriesArea seriesDuration = highchartsFactory.createSeriesArea(); + seriesDuration.name("Duration"); + seriesDuration.color(colors.get(0)); + + ArrayNumber dataDuration = seriesDuration.dataAsArrayNumber(); + + seriesDuration.pointInterval(interval).pointStart(dateStart.getTime()); + + SeriesArea seriesMaxInvocationTime = highchartsFactory + .createSeriesArea(); + seriesMaxInvocationTime.name("Max Invocation Time"); + seriesMaxInvocationTime.color(colors.get(2)); + + ArrayNumber dataMaxInvocationTime = seriesMaxInvocationTime + .dataAsArrayNumber(); + + seriesMaxInvocationTime.pointInterval(interval).pointStart( + dateStart.getTime()); + + SeriesArea seriesMinInvocationTime = highchartsFactory + .createSeriesArea(); + seriesMinInvocationTime.name("Min Invocation Time"); + seriesMinInvocationTime.color(colors.get(3)); + // seriesMinInvocationTime.yAxisAsString("MinInvocationTime"); + + ArrayNumber dataMinInvocationTime = seriesMinInvocationTime + .dataAsArrayNumber(); + + seriesMinInvocationTime.pointInterval(interval).pointStart( + dateStart.getTime()); + + for (SeriesServiceData seriesServiceData : seriesService.getSeries()) { + dataOperationCount.push(seriesServiceData.getOperationCount()); + dataDuration.push(seriesServiceData.getDuration()); + dataMaxInvocationTime + .push(seriesServiceData.getMaxInvocationTime()); + dataMinInvocationTime + .push(seriesServiceData.getMinInvocationTime()); + } + + options.series().addToEnd(seriesOperationCount); + options.series().addToEnd(seriesDuration); + options.series().addToEnd(seriesMaxInvocationTime); + options.series().addToEnd(seriesMinInvocationTime); + + options.chart().showAxes(true); + + options.legend().enabled(true); + return; + } + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Multi.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Multi.java new file mode 100644 index 0000000..10ca87f --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Multi.java @@ -0,0 +1,50 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; + +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartMultiPanel; +import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerStorageChartDrawException; + +/** + * Accounting Chart 4 Storage Multi + * + * @author "Giancarlo Panichi" email: g.panichi@isti.cnr.it + * + */ +public class StorageChart4Multi extends StorageChartBuilder { + + private AccountingStateData accountingStateData; + + public StorageChart4Multi(AccountingStateData accountingStateData) { + this.accountingStateData = accountingStateData; + } + + @Override + public void buildChart() throws AccountingManagerStorageChartDrawException { + StorageChartPanel storageChartPanel = null; + + if (accountingStateData == null + || accountingStateData.getAccountingType() == null + || accountingStateData.getSeriesRequest() == null + || accountingStateData.getSeriesResponse() == null) { + storageChartSpec.setChart(storageChartPanel); + return; + } + + if (!(accountingStateData.getSeriesResponse() instanceof SeriesStorage)) { + storageChartSpec.setChart(storageChartPanel); + return; + } + + StorageChartMultiPanel container = new StorageChartMultiPanel(accountingStateData); + + storageChartPanel = new StorageChartPanel(container); + + storageChartSpec.setChart(storageChartPanel); + + } + + + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Top.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Top.java new file mode 100644 index 0000000..5267533 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart4Top.java @@ -0,0 +1,50 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; + +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartTopPanel; +import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerStorageChartDrawException; + +/** + * Accounting Chart 4 Storage Top + * + * @author "Giancarlo Panichi" email: g.panichi@isti.cnr.it + * + */ +public class StorageChart4Top extends StorageChartBuilder { + + private AccountingStateData accountingStateData; + + public StorageChart4Top(AccountingStateData accountingStateData) { + this.accountingStateData = accountingStateData; + } + + @Override + public void buildChart() throws AccountingManagerStorageChartDrawException { + StorageChartPanel storageChartPanel = null; + + if (accountingStateData == null + || accountingStateData.getAccountingType() == null + || accountingStateData.getSeriesRequest() == null + || accountingStateData.getSeriesResponse() == null) { + storageChartSpec.setChart(storageChartPanel); + return; + } + + if (!(accountingStateData.getSeriesResponse() instanceof SeriesStorage)) { + storageChartSpec.setChart(storageChartPanel); + return; + } + + StorageChartTopPanel container = new StorageChartTopPanel(accountingStateData); + + storageChartPanel = new StorageChartPanel(container); + + storageChartSpec.setChart(storageChartPanel); + + } + + + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartBuilder.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartBuilder.java new file mode 100644 index 0000000..5162dba --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartBuilder.java @@ -0,0 +1,26 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; + +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerStorageChartDrawException; + +/** + * Abstract class for build Accounting Chart + * + * @author "Giancarlo Panichi" + * email: g.panichi@isti.cnr.it + * + */ +public abstract class StorageChartBuilder { + protected StorageChartSpec storageChartSpec; + + public StorageChartSpec getStorageChartSpec(){ + return storageChartSpec; + } + public void createSpec(){ + storageChartSpec=new StorageChartSpec(); + + } + + public abstract void buildChart() throws AccountingManagerStorageChartDrawException; + + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartDirector.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartDirector.java new file mode 100644 index 0000000..83c0d55 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartDirector.java @@ -0,0 +1,31 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; + +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerStorageChartDrawException; + + +/** + * Storage Chart Director + * + * @author "Giancarlo Panichi" + * email: g.panichi@isti.cnr.it + * + */ +public class StorageChartDirector { + StorageChartBuilder storageChartBuilder; + + public void setStorageChartBuilder( + StorageChartBuilder storageChartBuilder) { + this.storageChartBuilder = storageChartBuilder; + } + + public StorageChartPanel getStorageChart() { + return storageChartBuilder.getStorageChartSpec().getChart(); + + } + + public void constructStorageChart() throws AccountingManagerStorageChartDrawException { + storageChartBuilder.createSpec(); + storageChartBuilder.buildChart(); + + } +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartPanel.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartPanel.java new file mode 100644 index 0000000..0ff4288 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartPanel.java @@ -0,0 +1,34 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; + +import com.sencha.gxt.widget.core.client.container.Container; + +/** + * Storage Chart Panel + * + * @author giancarlo email: g.panichi@isti.cnr.it + * + */ +public class StorageChartPanel { + + private Container chart; + + public StorageChartPanel(Container chart) { + super(); + this.chart = chart; + } + + public Container getChart() { + return chart; + } + + public void setChart(Container chart) { + this.chart = chart; + } + + @Override + public String toString() { + return "StorageChartPanel [chart=" + chart + "]"; + } + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartSpec.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartSpec.java new file mode 100644 index 0000000..4ad66d9 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChartSpec.java @@ -0,0 +1,22 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; + + +/** + * Storage Chart Specification + * + * @author "Giancarlo Panichi" email: g.panichi@isti.cnr.it + * + */ +public class StorageChartSpec { + private StorageChartPanel chart; + + public StorageChartPanel getChart() { + return chart; + } + + public void setChart(StorageChartPanel chart) { + this.chart = chart; + } + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartMultiPanel.java similarity index 97% rename from src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart.java rename to src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartMultiPanel.java index 0429b23..ad373b5 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/StorageChart.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartMultiPanel.java @@ -1,4 +1,4 @@ -package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage; +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels; import java.util.Date; @@ -43,7 +43,7 @@ import com.sencha.gxt.widget.core.client.toolbar.ToolBar; * href="mailto:g.panichi@isti.cnr.it">g.panichi@isti.cnr.it * */ -public class StorageChart extends SimpleContainer { +public class StorageChartMultiPanel extends SimpleContainer { private static final String DATA_VOLUME_UNIT = "Data Volume Unit"; @@ -58,7 +58,7 @@ public class StorageChart extends SimpleContainer { private MenuItem downloadJPGItem; private MenuItem downloadPDFItem; private MenuItem downloadSVGItem; - + // Unit Menu private MenuItem kBItem; private MenuItem MBItem; @@ -71,7 +71,7 @@ public class StorageChart extends SimpleContainer { private long unitMeasure = ByteUnitMeasure.getMegaByteDimForStorage(); private String unitMeasureLabel = ByteUnitMeasure.MB; - public StorageChart(AccountingStateData accountingStateData) { + public StorageChartMultiPanel(AccountingStateData accountingStateData) { this.accountingStateData = accountingStateData; forceLayoutOnResize = true; create(); @@ -115,6 +115,7 @@ public class StorageChart extends SimpleContainer { } + private void updateChart() { vert.remove(highchartsLayoutPanel); // @@ -189,6 +190,7 @@ public class StorageChart extends SimpleContainer { } + private Menu createUnitMenu() { Menu menuUnit = new Menu(); kBItem = new MenuItem(ByteUnitMeasure.KILOBYTE); @@ -255,7 +257,7 @@ public class StorageChart extends SimpleContainer { var chart = $wnd .jQuery('#' + id) .highcharts( - this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart::options); + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartMultiPanel::options); console.log(chart); chart.exportChart(); @@ -266,7 +268,7 @@ public class StorageChart extends SimpleContainer { var chart = $wnd .jQuery('#' + id) .highcharts( - this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart::options); + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartMultiPanel::options); console.log(chart); chart.exportChart({ type : 'image/jpeg' @@ -279,7 +281,7 @@ public class StorageChart extends SimpleContainer { var chart = $wnd .jQuery('#' + id) .highcharts( - this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart::options); + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartMultiPanel::options); console.log(chart); chart.exportChart({ type : 'application/pdf' @@ -292,7 +294,7 @@ public class StorageChart extends SimpleContainer { var chart = $wnd .jQuery('#' + id) .highcharts( - this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.StorageChart::options); + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartMultiPanel::options); console.log(chart); chart.exportChart({ type : 'image/svg+xml' @@ -437,4 +439,5 @@ public class StorageChart extends SimpleContainer { return; } + } diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartTopPanel.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartTopPanel.java new file mode 100644 index 0000000..6dc10e5 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/storage/panels/StorageChartTopPanel.java @@ -0,0 +1,501 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels; + +import java.util.ArrayList; +import java.util.Date; + +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils.ByteUnitMeasure; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils.ChartTimeMeasure; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils.DownloadConstants; +import org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils.StorageChartMeasure; +import org.gcube.portlets.admin.accountingmanager.client.resource.AccountingManagerResources; +import org.gcube.portlets.admin.accountingmanager.client.state.AccountingStateData; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorageData; + +import com.allen_sauer.gwt.log.client.Log; +import com.github.highcharts4gwt.client.view.widget.HighchartsLayoutPanel; +import com.github.highcharts4gwt.model.array.api.ArrayNumber; +import com.github.highcharts4gwt.model.array.api.ArrayString; +import com.github.highcharts4gwt.model.factory.api.HighchartsOptionFactory; +import com.github.highcharts4gwt.model.factory.jso.JsoHighchartsOptionFactory; +import com.github.highcharts4gwt.model.highcharts.option.api.ChartOptions; +import com.github.highcharts4gwt.model.highcharts.option.api.SeriesColumn; +import com.google.gwt.event.logical.shared.SelectionEvent; +import com.google.gwt.event.logical.shared.SelectionHandler; +import com.google.gwt.i18n.client.DateTimeFormat; +import com.google.gwt.i18n.client.DateTimeFormat.PredefinedFormat; +import com.sencha.gxt.cell.core.client.ButtonCell.ButtonArrowAlign; +import com.sencha.gxt.cell.core.client.ButtonCell.IconAlign; +import com.sencha.gxt.core.client.util.Margins; +import com.sencha.gxt.widget.core.client.button.TextButton; +import com.sencha.gxt.widget.core.client.container.BoxLayoutContainer.BoxLayoutData; +import com.sencha.gxt.widget.core.client.container.MarginData; +import com.sencha.gxt.widget.core.client.container.SimpleContainer; +import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer; +import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer.VerticalLayoutData; +import com.sencha.gxt.widget.core.client.menu.Item; +import com.sencha.gxt.widget.core.client.menu.Menu; +import com.sencha.gxt.widget.core.client.menu.MenuItem; +import com.sencha.gxt.widget.core.client.toolbar.ToolBar; + +/** + * + * @author giancarlo email: g.panichi@isti.cnr.it + * + */ +public class StorageChartTopPanel extends SimpleContainer { + + private static final String DATA_VOLUME_UNIT = "Data Volume Unit"; + private static final String MEASURE_TYPE = "Measure"; + + private DateTimeFormat dtf = DateTimeFormat + .getFormat(PredefinedFormat.YEAR_MONTH_DAY); + + private AccountingStateData accountingStateData; + private HighchartsLayoutPanel highchartsLayoutPanel; + + // Download Menu + private MenuItem downloadPNGItem; + private MenuItem downloadJPGItem; + private MenuItem downloadPDFItem; + private MenuItem downloadSVGItem; + + // Measure Menu + private MenuItem dataVolumeItem; + private MenuItem operationCountItem; + + // Unit Menu + private MenuItem kBItem; + private MenuItem MBItem; + private MenuItem GBItem; + private MenuItem TBItem; + + ChartOptions options; + + private VerticalLayoutContainer vert; + private long unitMeasure = ByteUnitMeasure.getMegaByteDimForStorage(); + private String unitMeasureLabel = ByteUnitMeasure.MB; + + public StorageChartTopPanel(AccountingStateData accountingStateData) { + this.accountingStateData = accountingStateData; + forceLayoutOnResize = true; + create(); + + } + + private void create() { + ToolBar toolBar = new ToolBar(); + toolBar.setSpacing(2); + // Download + final TextButton downloadButton = new TextButton( + DownloadConstants.DOWNLOAD, + AccountingManagerResources.INSTANCE.accountingDownload24()); + // downloadButton.setScale(ButtonScale.MEDIUM); + downloadButton.setIconAlign(IconAlign.RIGHT); + downloadButton.setArrowAlign(ButtonArrowAlign.RIGHT); + downloadButton.setMenu(createDownloadMenu()); + + // Measure + final TextButton measureButton = new TextButton(MEASURE_TYPE, + AccountingManagerResources.INSTANCE.accountingByte24()); + measureButton.setIconAlign(IconAlign.RIGHT); + measureButton.setArrowAlign(ButtonArrowAlign.RIGHT); + measureButton.setMenu(createMeasureMenu()); + + // Unit + final TextButton unitButton = new TextButton(DATA_VOLUME_UNIT, + AccountingManagerResources.INSTANCE.accountingByte24()); + unitButton.setIconAlign(IconAlign.RIGHT); + unitButton.setArrowAlign(ButtonArrowAlign.RIGHT); + unitButton.setMenu(createUnitMenu()); + + toolBar.add(downloadButton, new BoxLayoutData(new Margins(0))); + toolBar.add(measureButton, new BoxLayoutData(new Margins(0))); + toolBar.add(unitButton, new BoxLayoutData(new Margins(0))); + + // + createChart(); + + highchartsLayoutPanel = new HighchartsLayoutPanel(); + highchartsLayoutPanel.renderChart(options); + + // + vert = new VerticalLayoutContainer(); + vert.add(toolBar, new VerticalLayoutData(1, -1, new Margins(0))); + vert.add(highchartsLayoutPanel, new VerticalLayoutData(1, 1, + new Margins(0))); + + add(vert, new MarginData(0)); + + } + + private void updateChart() { + vert.remove(highchartsLayoutPanel); + // + createChart(); + + highchartsLayoutPanel = new HighchartsLayoutPanel(); + highchartsLayoutPanel.renderChart(options); + + vert.add(highchartsLayoutPanel, new VerticalLayoutData(1, 1, + new Margins(0))); + + forceLayout(); + } + + private Menu createDownloadMenu() { + Menu menuDownload = new Menu(); + downloadPNGItem = new MenuItem(DownloadConstants.DOWNLOAD_PNG, + AccountingManagerResources.INSTANCE.accountingFilePNG24()); + downloadPNGItem.setHeight(30); + downloadJPGItem = new MenuItem(DownloadConstants.DOWNLOAD_JPG, + AccountingManagerResources.INSTANCE.accountingFileJPG24()); + downloadJPGItem.setHeight(30); + downloadPDFItem = new MenuItem(DownloadConstants.DOWNLOAD_PDF, + AccountingManagerResources.INSTANCE.accountingFilePDF24()); + downloadPDFItem.setHeight(30); + downloadSVGItem = new MenuItem(DownloadConstants.DOWNLOAD_SVG, + AccountingManagerResources.INSTANCE.accountingFileSVG24()); + downloadSVGItem.setHeight(30); + + downloadPNGItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadPNG(id); + + } + }); + + downloadJPGItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadJPG(id); + } + }); + + downloadPDFItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadPDF(id); + } + }); + + downloadSVGItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + String id = highchartsLayoutPanel.getElement().getId(); + onDownloadSVG(id); + } + }); + + menuDownload.add(downloadPNGItem); + menuDownload.add(downloadJPGItem); + menuDownload.add(downloadPDFItem); + menuDownload.add(downloadSVGItem); + return menuDownload; + + } + + private Menu createMeasureMenu() { + Menu menuMeasure = new Menu(); + dataVolumeItem = new MenuItem("Data Volume"); + dataVolumeItem.setHeight(30); + operationCountItem = new MenuItem("Operation Count"); + operationCountItem.setHeight(30); + + dataVolumeItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + // DataVolume + updateChart(); + } + }); + + operationCountItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + // OperationCount + updateChart(); + } + }); + + menuMeasure.add(dataVolumeItem); + menuMeasure.add(operationCountItem); + + return menuMeasure; + + } + + private Menu createUnitMenu() { + Menu menuUnit = new Menu(); + kBItem = new MenuItem(ByteUnitMeasure.KILOBYTE); + kBItem.setHeight(30); + MBItem = new MenuItem(ByteUnitMeasure.MEGABYTE); + MBItem.setHeight(30); + GBItem = new MenuItem(ByteUnitMeasure.GIGABYTE); + GBItem.setHeight(30); + TBItem = new MenuItem(ByteUnitMeasure.TERABYTE); + TBItem.setHeight(30); + + kBItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + unitMeasure = ByteUnitMeasure.getKiloByteDimForStorage(); + unitMeasureLabel = ByteUnitMeasure.kB; + updateChart(); + } + }); + + MBItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + unitMeasure = ByteUnitMeasure.getMegaByteDimForStorage(); + unitMeasureLabel = ByteUnitMeasure.MB; + updateChart(); + } + }); + + GBItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + unitMeasure = ByteUnitMeasure.getGigaByteDimForStorage(); + unitMeasureLabel = ByteUnitMeasure.GB; + updateChart(); + } + }); + + TBItem.addSelectionHandler(new SelectionHandler() { + + @Override + public void onSelection(SelectionEvent event) { + unitMeasure = ByteUnitMeasure.getTeraByteDimForStorage(); + unitMeasureLabel = ByteUnitMeasure.TB; + updateChart(); + } + }); + + menuUnit.add(kBItem); + menuUnit.add(MBItem); + menuUnit.add(GBItem); + menuUnit.add(TBItem); + return menuUnit; + + } + + // chart.options.exporting.buttons.contextButton.menuItems[0].onclick(); + + public static native void onDownloadPNG(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartTopPanel::options); + console.log(chart); + chart.exportChart(); + + }-*/; + + public static native void onDownloadJPG(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartTopPanel::options); + console.log(chart); + chart.exportChart({ + type : 'image/jpeg' + }); + + }-*/; + + public static native void onDownloadPDF(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartTopPanel::options); + console.log(chart); + chart.exportChart({ + type : 'application/pdf' + }); + + }-*/; + + public static native void onDownloadSVG(String id) /*-{ + console.log(id); + var chart = $wnd + .jQuery('#' + id) + .highcharts( + this.@org.gcube.portlets.admin.accountingmanager.client.maindata.charts.storage.panels.StorageChartTopPanel::options); + console.log(chart); + chart.exportChart({ + type : 'image/svg+xml' + }); + + }-*/; + + private void createChart() { + SeriesStorage seriesStorage = (SeriesStorage) accountingStateData + .getSeriesResponse(); + + double minRange = ChartTimeMeasure + .calculateMinRange(accountingStateData.getSeriesRequest() + .getAccountingPeriod()); + + double interval = ChartTimeMeasure + .calculateInterval(accountingStateData.getSeriesRequest() + .getAccountingPeriod()); + + Date dateStart = dtf.parse(accountingStateData.getSeriesRequest() + .getAccountingPeriod().getStartDate()); + + dateStart.setTime(dateStart.getTime() + + ChartTimeMeasure.timeZoneOffset() * ChartTimeMeasure.MINUTE); + + Log.debug("BuildChart DateStart: " + + DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_FULL) + .format(dateStart)); + + HighchartsOptionFactory highchartsFactory = new JsoHighchartsOptionFactory(); + + options = highchartsFactory.createChartOptions(); + options.chart().zoomType("xy"); + options.exporting().buttons().contextButton().enabled(false); + options.exporting().filename("AccountingStorageTop"); + options.title().text("Accounting Storage Top"); + + /* + * options.subtitle().text("Click and drag in the plot area to zoom in"); + */ + + ArrayString colors = options.colors(); + // colors.setValue(0, "#cc0038"); + // colors.setValue(1, "#32cd32"); + + // xAxis + options.xAxis().type("datetime").minRange(minRange); + + // yAxis + options.setFieldAsJsonObject("yAxis", retrieveYAxis(colors)); + + options.plotOptions().setFieldAsJsonObject( + "column", + "{ " + "\"stacking\": \"normal\"," + "\"dataLabels\": { " + + " \"enabled\": \"true\"," + + " \"color\": \"white\", " + " \"style\": {" + + " \"textShadow\": \"0 0 3px black\"" + " }" + + " }" + " }"); + + ArrayList seriesColumn = new ArrayList<>(); + for (int i = 1; i < 6; i++) { + SeriesColumn seriesOperationCount = highchartsFactory + .createSeriesColumn(); + seriesOperationCount.name("Operation Count" + i); + seriesOperationCount.color(colors.get(i)); + seriesOperationCount.type("column"); + + ArrayNumber dataOperationCount = seriesOperationCount + .dataAsArrayNumber(); + + for (SeriesStorageData seriesStorageData : seriesStorage + .getSeries()) { + dataOperationCount.push(seriesStorageData.getOperationCount()); + } + + seriesOperationCount.pointInterval(interval).pointStart( + dateStart.getTime()); + seriesColumn.add(seriesOperationCount); + + } + + for (SeriesColumn serie : seriesColumn) { + options.series().addToEnd(serie); + } + + options.chart().showAxes(true); + + options.legend().enabled(true); + return; + } + + private String retrieveYAxis(ArrayString colors) { + StorageChartMeasure storageChartMeasure = StorageChartMeasure.DataVolume; + + switch (storageChartMeasure) { + case DataVolume: + return "[{" + " \"id\": \"Data Volume\"," + " \"labels\": {" + + " \"format\": \"{value} " + + unitMeasureLabel + + "\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(0) + + "\"" + + " }" + + " }," + + " \"stackLabels\": {" + + " \"enabled\": \"true\"," + + " \"style\": {" + + " \"fontWeight\": \"bold\"," + + " \"color\": \"gray\"" + + " } " + + " }," + + " \"title\": { " + + " \"text\": \"Data Volume\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(1) + "\"" + " }" + " }" + "}]"; + + case OperationCount: + return "[{" + " \"id\": \"OperationCount\"," + " \"labels\": { " + + " \"format\": \"{value}\"," + " \"style\": { " + + " \"color\": \"" + colors.get(1) + "\"" + " }" + + " }," + " \"stackLabels\": {" + " \"enabled\": \"true\"," + + " \"style\": {" + " \"fontWeight\": \"bold\"," + + " \"color\": \"gray\"" + " } " + " }," + + " \"title\": { " + " \"text\": \"Operation Count\"," + + " \"style\": {" + " \"color\": \"" + + colors.get(1) + "\"" + " }" + " }" + "}]"; + + default: + return "[{" + " \"id\": \"Data Volume\"," + " \"labels\": {" + + " \"format\": \"{value} " + + unitMeasureLabel + + "\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(0) + + "\"" + + " }" + + " }," + + " \"stackLabels\": {" + + " \"enabled\": \"true\"," + + " \"style\": {" + + " \"fontWeight\": \"bold\"," + + " \"color\": \"gray\"" + + " } " + + " }," + + " \"title\": { " + + " \"text\": \"Data Volume\"," + + " \"style\": {" + + " \"color\": \"" + + colors.get(1) + "\"" + " }" + " }" + "}]"; + + } + + } + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/utils/StorageChartMeasure.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/utils/StorageChartMeasure.java new file mode 100644 index 0000000..df54e05 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/maindata/charts/utils/StorageChartMeasure.java @@ -0,0 +1,63 @@ +package org.gcube.portlets.admin.accountingmanager.client.maindata.charts.utils; + +import java.util.Arrays; +import java.util.List; + +/** + * Storage Chart Measure + * + * + * @author Giancarlo Panichi email: g.panichi@isti.cnr.it + * + */ + +public enum StorageChartMeasure { + + DataVolume("Data Volume"), OperationCount("Operation Count"); + + /** + * @param text + */ + private StorageChartMeasure(final String id) { + this.id = id; + } + + private final String id; + + @Override + public String toString() { + return id; + } + + public String getLabel() { + return id; + } + + public String getId() { + return id; + } + + /** + * + * @param id + * @return + */ + public static StorageChartMeasure getFromId(String id) { + if (id == null || id.isEmpty()) + return null; + + for (StorageChartMeasure columnDataType : values()) { + if (columnDataType.id.compareToIgnoreCase(id) == 0) { + return columnDataType; + } + } + return null; + } + + public static List asList() { + List list = Arrays.asList(values()); + return list; + } + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/menu/AccountingManagerMenu.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/menu/AccountingManagerMenu.java index b438597..c0d59e0 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/client/menu/AccountingManagerMenu.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/client/menu/AccountingManagerMenu.java @@ -63,12 +63,13 @@ public class AccountingManagerMenu extends TabPanel { taskItemConf.setIcon(AccountingManagerResources.INSTANCE.accountingTask48()); EmptyPanel taskCategory=new EmptyPanel(AccountingType.TASK.name()); add(taskCategory, taskItemConf); + */ TabItemConfig jobItemConf = new TabItemConfig("Job", false); jobItemConf.setIcon(AccountingManagerResources.INSTANCE.accountingJob48()); EmptyPanel jobCategory=new EmptyPanel(AccountingType.JOB.name()); add(jobCategory, jobItemConf); - */ + setActiveWidget(getWidget(0)); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/AccountingManagerServiceImpl.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/AccountingManagerServiceImpl.java index 16d25a5..8dc0af4 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/AccountingManagerServiceImpl.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/AccountingManagerServiceImpl.java @@ -8,6 +8,8 @@ import javax.servlet.http.HttpSession; import org.gcube.application.framework.core.session.ASLSession; import org.gcube.portlets.admin.accountingmanager.client.rpc.AccountingManagerService; import org.gcube.portlets.admin.accountingmanager.server.amservice.AccountingCaller; +import org.gcube.portlets.admin.accountingmanager.server.amservice.AccountingCallerInterface; +import org.gcube.portlets.admin.accountingmanager.server.amservice.AccountingCallerTester; import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingType; import org.gcube.portlets.admin.accountingmanager.shared.data.FilterKey; import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValue; @@ -87,7 +89,7 @@ public class AccountingManagerServiceImpl extends RemoteServiceServlet try { HttpSession session = this.getThreadLocalRequest().getSession(); SessionUtil.getAslSession(session); - AccountingCaller accountingCaller = new AccountingCaller(); + AccountingCallerInterface accountingCaller = new AccountingCallerTester(); SeriesResponse seriesResponse = accountingCaller.getSeries( accountingType, seriesRequest); @@ -115,7 +117,7 @@ public class AccountingManagerServiceImpl extends RemoteServiceServlet HttpSession session = this.getThreadLocalRequest().getSession(); SessionUtil.getAslSession(session); - AccountingCaller accountingCaller = new AccountingCaller(); + AccountingCallerInterface accountingCaller = new AccountingCallerTester(); ArrayList filterKeys = accountingCaller.getFilterKeys(accountingType); return filterKeys; @@ -143,7 +145,7 @@ public class AccountingManagerServiceImpl extends RemoteServiceServlet HttpSession session = this.getThreadLocalRequest().getSession(); SessionUtil.getAslSession(session); - AccountingCaller accountingCaller = new AccountingCaller(); + AccountingCallerInterface accountingCaller = new AccountingCallerTester(); ArrayList filterValues = accountingCaller.getFilterValues(filterValuesRequest); return filterValues; diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/SessionUtil.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/SessionUtil.java index 70023e4..564ae05 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/SessionUtil.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/SessionUtil.java @@ -8,6 +8,7 @@ import javax.servlet.http.HttpSession; import org.gcube.application.framework.core.session.ASLSession; import org.gcube.application.framework.core.session.SessionManager; import org.gcube.portal.custom.scopemanager.scopehelper.ScopeHelper; +import org.gcube.portlets.admin.accountingmanager.shared.Constants; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerSessionExpiredException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -29,9 +30,9 @@ public class SessionUtil { ASLSession session; if (username == null) { logger.warn("no user found in session, use test user"); - throw new AccountingManagerSessionExpiredException("Session Expired!"); + /*throw new AccountingManagerSessionExpiredException("Session Expired!");*/ + - /* // Remove comment for Test username = Constants.DEFAULT_USER; String scope = Constants.DEFAULT_SCOPE; @@ -40,7 +41,7 @@ public class SessionUtil { session = SessionManager.getInstance().getASLSession( httpSession.getId(), username); session.setScope(scope); - */ + } else { session = SessionManager.getInstance().getASLSession( httpSession.getId(), username); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCaller.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCaller.java index 4e6de3e..72cf5f2 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCaller.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCaller.java @@ -5,6 +5,7 @@ import java.util.List; import org.gcube.accounting.analytics.Info; import org.gcube.accounting.analytics.ResourceRecordQuery; +import org.gcube.accounting.datamodel.aggregation.AggregatedJobUsageRecord; import org.gcube.accounting.datamodel.aggregation.AggregatedServiceUsageRecord; import org.gcube.accounting.datamodel.aggregation.AggregatedStorageUsageRecord; import org.gcube.portlets.admin.accountingmanager.server.amservice.query.AccountingQuery; @@ -38,180 +39,178 @@ import org.slf4j.LoggerFactory; * href="mailto:g.panichi@isti.cnr.it">g.panichi@isti.cnr.it * */ -public class AccountingCaller { - private static Logger logger = LoggerFactory +public class AccountingCaller implements AccountingCallerInterface { + static Logger logger = LoggerFactory .getLogger(AccountingCaller.class); public AccountingCaller() { - + super(); } - + public ArrayList getFilterKeys(AccountingType accountingType) throws AccountingManagerServiceException { - try { - logger.debug("getFilterKeys(): [AccountingType=" + accountingType - + "]"); - if (accountingType == null) { - return new ArrayList(); - } - ArrayList filterKeys = new ArrayList(); - List keys; - - ResourceRecordQuery rrq = new ResourceRecordQuery(); - - switch (accountingType) { - case JOB: - // keys=rrq.getKeys(AggregatedJobUsageRecord.class); - return filterKeys; - case PORTLET: - // keys=rrq.getKeys(AggregatedPortletUsageRecord.class); - return filterKeys; - case SERVICE: - keys = rrq.getKeys(AggregatedServiceUsageRecord.class); - break; - case STORAGE: - keys = rrq.getKeys(AggregatedStorageUsageRecord.class); - break; - case TASK: - // keys=rrq.getKeys(AggregatedTaskUsageRecord.class); - return filterKeys; - default: - return filterKeys; - } - for (String key : keys) { - if (key != null && !key.isEmpty()) { - filterKeys.add(new FilterKey(key)); + try { + logger.debug("getFilterKeys(): [AccountingType=" + accountingType + + "]"); + if (accountingType == null) { + return new ArrayList(); + } + ArrayList filterKeys = new ArrayList(); + List keys; + + ResourceRecordQuery rrq = new ResourceRecordQuery(); + + switch (accountingType) { + case JOB: + keys=rrq.getKeys(AggregatedJobUsageRecord.class); + break; + case PORTLET: + // keys=rrq.getKeys(AggregatedPortletUsageRecord.class); + return filterKeys; + case SERVICE: + keys = rrq.getKeys(AggregatedServiceUsageRecord.class); + break; + case STORAGE: + keys = rrq.getKeys(AggregatedStorageUsageRecord.class); + break; + case TASK: + // keys=rrq.getKeys(AggregatedTaskUsageRecord.class); + return filterKeys; + default: + return filterKeys; + } + for (String key : keys) { + if (key != null && !key.isEmpty()) { + filterKeys.add(new FilterKey(key)); + } + } + logger.debug("List FilterKeys:"+filterKeys); + return filterKeys; + } catch (Throwable e) { + logger.error("Error in getFilterKeys(): " + e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("No keys available!"); + } } - return filterKeys; - } catch (Throwable e) { - logger.error("Error in getFilterKeys(): " + e.getLocalizedMessage()); - e.printStackTrace(); - throw new AccountingManagerServiceException("No keys available!"); - - } - } - - public ArrayList getFilterValues( - FilterValuesRequest filterValuesRequest) + public ArrayList getFilterValues(FilterValuesRequest filterValuesRequest) throws AccountingManagerServiceException { - try { - logger.debug("getFilterValue(): [FilterValueRequest=" - + filterValuesRequest + "]"); - if (filterValuesRequest == null - || filterValuesRequest.getAccountingType() == null - || filterValuesRequest.getFilterKey() == null) { - return new ArrayList(); - } - - ArrayList filteValues = new ArrayList(); - List values; - - ResourceRecordQuery rrq = new ResourceRecordQuery(); - - switch (filterValuesRequest.getAccountingType()) { - case JOB: - // values = - // rrq.getPossibleValuesForKey(AggregatedJobUsageRecord.class, - // filterValuesRequest - // .getFilterKey().getKey()); - return filteValues; - case PORTLET: - // values = rrq.getPossibleValuesForKey( - // AggregatedPortletUsageRecord.class, filterValuesRequest - // .getFilterKey().getKey()); - return filteValues; - case SERVICE: - values = rrq.getPossibleValuesForKey( - AggregatedServiceUsageRecord.class, filterValuesRequest - .getFilterKey().getKey()); - break; - case STORAGE: - values = rrq.getPossibleValuesForKey( - AggregatedStorageUsageRecord.class, filterValuesRequest - .getFilterKey().getKey()); - break; - case TASK: - // values = rrq.getPossibleValuesForKey( - // AggregatedTaskUsageRecord.class, filterValuesRequest - // .getFilterKey().getKey()); - return filteValues; - default: - return filteValues; - } - for (String value : values) { - if (value != null && !value.isEmpty()) { - filteValues.add(new FilterValue(value)); + try { + logger.debug("getFilterValue(): [FilterValueRequest=" + + filterValuesRequest + "]"); + if (filterValuesRequest == null + || filterValuesRequest.getAccountingType() == null + || filterValuesRequest.getFilterKey() == null) { + return new ArrayList(); + } + + ArrayList filteValues = new ArrayList(); + List values; + + ResourceRecordQuery rrq = new ResourceRecordQuery(); + + switch (filterValuesRequest.getAccountingType()) { + case JOB: + values = + rrq.getPossibleValuesForKey(AggregatedJobUsageRecord.class, + filterValuesRequest.getFilterKey().getKey()); + return filteValues; + case PORTLET: + // values = rrq.getPossibleValuesForKey( + // AggregatedPortletUsageRecord.class, filterValuesRequest + // .getFilterKey().getKey()); + return filteValues; + case SERVICE: + values = rrq.getPossibleValuesForKey( + AggregatedServiceUsageRecord.class, filterValuesRequest + .getFilterKey().getKey()); + break; + case STORAGE: + values = rrq.getPossibleValuesForKey( + AggregatedStorageUsageRecord.class, filterValuesRequest + .getFilterKey().getKey()); + break; + case TASK: + // values = rrq.getPossibleValuesForKey( + // AggregatedTaskUsageRecord.class, filterValuesRequest + // .getFilterKey().getKey()); + return filteValues; + default: + return filteValues; + } + for (String value : values) { + if (value != null && !value.isEmpty()) { + filteValues.add(new FilterValue(value)); + } + } + + return filteValues; + } catch (Throwable e) { + logger.error("Error in getFilterValues(): " + + e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("No values available!"); + } } - return filteValues; - } catch (Throwable e) { - logger.error("Error in getFilterValues(): " - + e.getLocalizedMessage()); - e.printStackTrace(); - throw new AccountingManagerServiceException("No values available!"); - - } - } - - public SeriesResponse getSeries(AccountingType accountingType, - SeriesRequest seriesRequest) + public SeriesResponse getSeries(AccountingType accountingType, SeriesRequest seriesRequest) throws AccountingManagerServiceException { - try { - logger.debug("getSeries(): [AccountingType=" + accountingType - + " , seriesRequest=" + seriesRequest + "]"); - - ResourceRecordQuery rrq = new ResourceRecordQuery(); - - AccountingQueryBuilder queryBuilder = getAccountQueryBuilder( - accountingType, seriesRequest); - - AccountingQueryDirector director = new AccountingQueryDirector(); - director.setAccountingQueryBuilder(queryBuilder); - director.constructAccountingQuery(); - AccountingQuery query = director.getAccountingQuery(); - - if (query == null) { - throw new AccountingManagerServiceException( - "Error in invocation: Operation not supported"); + try { + logger.debug("getSeries(): [AccountingType=" + accountingType + + " , seriesRequest=" + seriesRequest + "]"); + + ResourceRecordQuery rrq = new ResourceRecordQuery(); + + AccountingQueryBuilder queryBuilder = getAccountQueryBuilder( + accountingType, seriesRequest); + + AccountingQueryDirector director = new AccountingQueryDirector(); + director.setAccountingQueryBuilder(queryBuilder); + director.constructAccountingQuery(); + AccountingQuery query = director.getAccountingQuery(); + + if (query == null) { + throw new AccountingManagerServiceException( + "Error in invocation: Operation not supported"); + } + + logger.debug("Query: " + query); + + List infos = rrq.getInfo(query.getType(), + query.getTemporalConstraint(), query.getFilters(), true); + if (infos == null) { + throw new AccountingManagerServiceException( + "Error retrieving list of info: list is null!"); + } + logger.debug("Retrieved Infos"); + logger.debug("Infos: " + infos); + + SeriesResponseBuilder seriesResponseBuilder = getSeriesResponseBuilder( + accountingType, infos); + + SeriesResponseDirector seriesResponseDirector = new SeriesResponseDirector(); + seriesResponseDirector + .setSeriesResponseBuilder(seriesResponseBuilder); + seriesResponseDirector.constructSeriesResponse(); + SeriesResponse seriesResponse = seriesResponseDirector + .getSeriesResponse(); + + if (seriesResponse == null) { + throw new AccountingManagerServiceException( + "Error creating series response!"); + } + logger.debug("SeriesResponse Created: " + seriesResponse); + return seriesResponse; + } catch (Throwable e) { + logger.error("Error in GetSeries(): " + e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("No data available!"); + + } } - - logger.debug("Query: " + query); - - List infos = rrq.getInfo(query.getType(), - query.getTemporalConstraint(), query.getFilters(), true); - if (infos == null) { - throw new AccountingManagerServiceException( - "Error retrieving list of info: list is null!"); - } - logger.debug("Retrieved Infos"); - logger.debug("Infos: " + infos); - - SeriesResponseBuilder seriesResponseBuilder = getSeriesResponseBuilder( - accountingType, infos); - - SeriesResponseDirector seriesResponseDirector = new SeriesResponseDirector(); - seriesResponseDirector - .setSeriesResponseBuilder(seriesResponseBuilder); - seriesResponseDirector.constructSeriesResponse(); - SeriesResponse seriesResponse = seriesResponseDirector - .getSeriesResponse(); - - if (seriesResponse == null) { - throw new AccountingManagerServiceException( - "Error creating series response!"); - } - logger.debug("SeriesResponse Created: " + seriesResponse); - return seriesResponse; - } catch (Throwable e) { - logger.error("Error in GetSeries(): " + e.getLocalizedMessage()); - e.printStackTrace(); - throw new AccountingManagerServiceException("No data available!"); - - } - } + private AccountingQueryBuilder getAccountQueryBuilder( AccountingType accountingType, SeriesRequest seriesRequest) diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerInterface.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerInterface.java new file mode 100644 index 0000000..d676681 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerInterface.java @@ -0,0 +1,32 @@ +package org.gcube.portlets.admin.accountingmanager.server.amservice; + +import java.util.ArrayList; + +import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingType; +import org.gcube.portlets.admin.accountingmanager.shared.data.FilterKey; +import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValue; +import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValuesRequest; +import org.gcube.portlets.admin.accountingmanager.shared.data.query.SeriesRequest; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesResponse; +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerServiceException; + +/** + * + * @author Giancarlo Panichi email: g.panichi@isti.cnr.it + * + */ +public interface AccountingCallerInterface { + + public ArrayList getFilterKeys(AccountingType accountingType) + throws AccountingManagerServiceException; + + public ArrayList getFilterValues( + FilterValuesRequest filterValuesRequest) + throws AccountingManagerServiceException; + + public SeriesResponse getSeries(AccountingType accountingType, + SeriesRequest seriesRequest) + throws AccountingManagerServiceException; + +} \ No newline at end of file diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerTester.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerTester.java new file mode 100644 index 0000000..9fd7c11 --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/AccountingCallerTester.java @@ -0,0 +1,153 @@ +package org.gcube.portlets.admin.accountingmanager.server.amservice; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.List; + +import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingType; +import org.gcube.portlets.admin.accountingmanager.shared.data.FilterKey; +import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValue; +import org.gcube.portlets.admin.accountingmanager.shared.data.FilterValuesRequest; +import org.gcube.portlets.admin.accountingmanager.shared.data.query.SeriesRequest; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesResponse; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorage; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesStorageData; +import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerServiceException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + + +/** + * + * @author giancarlo email: g.panichi@isti.cnr.it + * + */ +public class AccountingCallerTester implements AccountingCallerInterface { + static Logger logger = LoggerFactory + .getLogger(AccountingCallerTester.class); + + public AccountingCallerTester() { + super(); + } + + public ArrayList getFilterKeys(AccountingType accountingType) + throws AccountingManagerServiceException { + try { + logger.debug("getFilterKeys(): [AccountingType=" + accountingType + + "]"); + if (accountingType == null) { + return new ArrayList(); + } + ArrayList filterKeys = new ArrayList(); + FilterKey key=new FilterKey("ConsumerId"); + FilterKey key1=new FilterKey("ClassName"); + + filterKeys.add(key); + filterKeys.add(key1); + + logger.debug("List FilterKeys:"+filterKeys); + return filterKeys; + } catch (Throwable e) { + logger.error("Error in getFilterKeys(): " + e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("No keys available!"); + + } + } + + public ArrayList getFilterValues(FilterValuesRequest filterValuesRequest) + throws AccountingManagerServiceException { + try { + logger.debug("getFilterValue(): [FilterValueRequest=" + + filterValuesRequest + "]"); + if (filterValuesRequest == null + || filterValuesRequest.getAccountingType() == null + || filterValuesRequest.getFilterKey() == null) { + return new ArrayList(); + } + + ArrayList filteValues = new ArrayList(); + List values; + + String[] vals={"giancarlo.panichi","gianpaolo.coro"}; + + switch (filterValuesRequest.getAccountingType()) { + case JOB: + values = Arrays.asList(vals); + case PORTLET: + values = Arrays.asList(vals); + case SERVICE: + values = Arrays.asList(vals); + case STORAGE: + values = Arrays.asList(vals); + case TASK: + values = Arrays.asList(vals); + default: + values = Arrays.asList(vals); + } + for (String value : values) { + if (value != null && !value.isEmpty()) { + filteValues.add(new FilterValue(value)); + } + } + + return filteValues; + } catch (Throwable e) { + logger.error("Error in getFilterValues(): " + + e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("No values available!"); + + } + } + + public SeriesResponse getSeries(AccountingType accountingType, SeriesRequest seriesRequest) + throws AccountingManagerServiceException { + try { + logger.debug("getSeries(): [AccountingType=" + accountingType + + " , seriesRequest=" + seriesRequest + "]"); + SeriesResponse seriesResponse=null; + switch(accountingType){ + case JOB: + break; + case PORTLET: + break; + case SERVICE: + break; + case STORAGE: + ArrayList seriesStorageData=new ArrayList<>(); + for(int i=0;i<30;i++){ + SeriesStorageData data=new SeriesStorageData(new Date(), new Double(10*Math.random()).longValue(),new Double(100*Math.random()).longValue()); + seriesStorageData.add(data); + + } + seriesResponse=new SeriesStorage(seriesStorageData); + break; + case TASK: + break; + default: + break; + + } + + if (seriesResponse == null) { + throw new AccountingManagerServiceException( + "Error creating series response!"); + } + logger.debug("SeriesResponse Created: " + seriesResponse); + return seriesResponse; + } catch (Throwable e) { + logger.error("Error in GetSeries(): " + e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("No data available!"); + + } + } + + + + +} diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Job.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Job.java index 68f13e8..687b87c 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Job.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Job.java @@ -1,12 +1,15 @@ package org.gcube.portlets.admin.accountingmanager.server.amservice.query; import java.text.ParseException; +import java.util.ArrayList; import java.util.Calendar; import java.util.GregorianCalendar; +import org.gcube.accounting.analytics.Filter; import org.gcube.accounting.analytics.TemporalConstraint; import org.gcube.accounting.datamodel.aggregation.AggregatedJobUsageRecord; import org.gcube.portlets.admin.accountingmanager.server.amservice.PeriodModeMap; +import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilter; import org.gcube.portlets.admin.accountingmanager.shared.data.query.SeriesRequest; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerServiceException; import org.slf4j.Logger; @@ -52,15 +55,27 @@ public class AccountingQuery4Job extends AccountingQueryBuilder { endCalendar.set(GregorianCalendar.SECOND, 59); endCalendar.set(GregorianCalendar.MILLISECOND, 999); - TemporalConstraint temporalConstraint = new TemporalConstraint( startCalendar.getTimeInMillis(), endCalendar.getTimeInMillis(), PeriodModeMap.getMode(seriesRequest.getAccountingPeriod() .getPeriod())); + ArrayList accountingFilters = seriesRequest + .getFilters(); + + ArrayList filters = null; + if (accountingFilters != null) { + filters = new ArrayList(); + for (AccountingFilter accountigFilters : accountingFilters) { + Filter filter = new Filter(accountigFilters.getFilterKey() + .getKey(), accountigFilters.getFilterValue()); + filters.add(filter); + } + } + AccountingQuery invocation = new AccountingQuery( - AggregatedJobUsageRecord.class, temporalConstraint,null); + AggregatedJobUsageRecord.class, temporalConstraint, filters); accountingQuerySpec.setOp(invocation); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Portlet.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Portlet.java index ef56bcd..fd0d1a9 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Portlet.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Portlet.java @@ -1,12 +1,15 @@ package org.gcube.portlets.admin.accountingmanager.server.amservice.query; import java.text.ParseException; +import java.util.ArrayList; import java.util.Calendar; import java.util.GregorianCalendar; +import org.gcube.accounting.analytics.Filter; import org.gcube.accounting.analytics.TemporalConstraint; import org.gcube.accounting.datamodel.aggregation.AggregatedPortletUsageRecord; import org.gcube.portlets.admin.accountingmanager.server.amservice.PeriodModeMap; +import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilter; import org.gcube.portlets.admin.accountingmanager.shared.data.query.SeriesRequest; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerServiceException; import org.slf4j.Logger; @@ -51,15 +54,27 @@ public class AccountingQuery4Portlet extends AccountingQueryBuilder { endCalendar.set(GregorianCalendar.SECOND, 59); endCalendar.set(GregorianCalendar.MILLISECOND, 999); - TemporalConstraint temporalConstraint = new TemporalConstraint( startCalendar.getTimeInMillis(), endCalendar.getTimeInMillis(), PeriodModeMap.getMode(seriesRequest.getAccountingPeriod() .getPeriod())); + ArrayList accountingFilters = seriesRequest + .getFilters(); + + ArrayList filters = null; + if (accountingFilters != null) { + filters = new ArrayList(); + for (AccountingFilter accountigFilters : accountingFilters) { + Filter filter = new Filter(accountigFilters.getFilterKey() + .getKey(), accountigFilters.getFilterValue()); + filters.add(filter); + } + } + AccountingQuery invocation = new AccountingQuery( - AggregatedPortletUsageRecord.class, temporalConstraint,null); + AggregatedPortletUsageRecord.class, temporalConstraint,filters); accountingQuerySpec.setOp(invocation); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Task.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Task.java index 2dc88cd..b159a81 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Task.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/query/AccountingQuery4Task.java @@ -1,12 +1,15 @@ package org.gcube.portlets.admin.accountingmanager.server.amservice.query; import java.text.ParseException; +import java.util.ArrayList; import java.util.Calendar; import java.util.GregorianCalendar; +import org.gcube.accounting.analytics.Filter; import org.gcube.accounting.analytics.TemporalConstraint; import org.gcube.accounting.datamodel.aggregation.AggregatedTaskUsageRecord; import org.gcube.portlets.admin.accountingmanager.server.amservice.PeriodModeMap; +import org.gcube.portlets.admin.accountingmanager.shared.data.AccountingFilter; import org.gcube.portlets.admin.accountingmanager.shared.data.query.SeriesRequest; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerServiceException; import org.slf4j.Logger; @@ -58,8 +61,20 @@ public class AccountingQuery4Task extends AccountingQueryBuilder { PeriodModeMap.getMode(seriesRequest.getAccountingPeriod() .getPeriod())); + ArrayList accountingFilters = seriesRequest + .getFilters(); + + ArrayList filters = null; + if (accountingFilters != null) { + filters = new ArrayList(); + for (AccountingFilter accountigFilters : accountingFilters) { + Filter filter = new Filter(accountigFilters.getFilterKey() + .getKey(), accountigFilters.getFilterValue()); + filters.add(filter); + } + } AccountingQuery invocation = new AccountingQuery( - AggregatedTaskUsageRecord.class, temporalConstraint,null); + AggregatedTaskUsageRecord.class, temporalConstraint,filters); accountingQuerySpec.setOp(invocation); diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/response/SeriesResponse4Job.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/response/SeriesResponse4Job.java index 3fbf354..ffd8928 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/response/SeriesResponse4Job.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/server/amservice/response/SeriesResponse4Job.java @@ -1,10 +1,14 @@ package org.gcube.portlets.admin.accountingmanager.server.amservice.response; +import java.util.ArrayList; import java.util.List; import org.gcube.accounting.analytics.Info; -import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesResponse; +import org.gcube.accounting.datamodel.aggregation.AggregatedJobUsageRecord; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesJob; +import org.gcube.portlets.admin.accountingmanager.shared.data.response.SeriesJobData; import org.gcube.portlets.admin.accountingmanager.shared.exception.AccountingManagerServiceException; +import org.json.JSONObject; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -26,14 +30,33 @@ public class SeriesResponse4Job extends SeriesResponseBuilder { @Override public void buildSeriesResponse() throws AccountingManagerServiceException { - if(infos.size()<=0){ - logger.error("Error creating series for job accounting: No data available!"); - throw new AccountingManagerServiceException("No data available!"); + try { + if(infos.size()<=0){ + logger.error("Error creating series for job accounting: No data available!"); + throw new AccountingManagerServiceException("No data available!"); + } + + ArrayList series=new ArrayList(); + for (Info info : infos) { + JSONObject jso = info.getValue(); + //Long duration = jso.getLong(AggregatedJobUsageRecord.DURATION); + Long operationCount = jso + .getLong(AggregatedJobUsageRecord.OPERATION_COUNT); + //Long maxInvocationTime = jso.getLong(AggregatedServiceUsageRecord.MAX_INVOCATION_TIME); + //Long minInvocationTime = jso.getLong(AggregatedServiceUsageRecord.MIN_INVOCATION_TIME); + + series.add(new SeriesJobData(info.getCalendar().getTime(), operationCount)); + + } + + SeriesJob seriesService = new SeriesJob(series); + + seriesResponseSpec.setSr(seriesService); + } catch (Throwable e) { + logger.error("Error creating series for job accounting: "+e.getLocalizedMessage()); + e.printStackTrace(); + throw new AccountingManagerServiceException("Error creating series for job accounting: "+e.getLocalizedMessage()); } - SeriesResponse seriesResponse = new SeriesResponse(); - - seriesResponseSpec.setSr(seriesResponse); - } } diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/Constants.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/Constants.java index 3003304..06e436b 100644 --- a/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/Constants.java +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/Constants.java @@ -16,6 +16,9 @@ public class Constants { //public final static String DEFAULT_USER = "test.user"; //public final static String DEFAULT_SCOPE = "/gcube/devNext"; //public final static String DEFAULT_SCOPE = "/gcube/devsec/devVRE"; + + //public final static String DEFAULT_SCOPE = "/gcube/devNext/NextNext"; + public final static String DEFAULT_SCOPE = "/gcube"; diff --git a/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/exception/AccountingManagerStorageChartDrawException.java b/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/exception/AccountingManagerStorageChartDrawException.java new file mode 100644 index 0000000..ff6ec1e --- /dev/null +++ b/src/main/java/org/gcube/portlets/admin/accountingmanager/shared/exception/AccountingManagerStorageChartDrawException.java @@ -0,0 +1,38 @@ +/** + * + */ +package org.gcube.portlets.admin.accountingmanager.shared.exception; + +/** + * + * @author "Giancarlo Panichi" + * g.panichi@isti.cnr.it + * + */ +public class AccountingManagerStorageChartDrawException extends AccountingManagerChartDrawException { + + + private static final long serialVersionUID = -8737011216478988776L; + + + /** + * + */ + public AccountingManagerStorageChartDrawException() { + super(); + } + + /** + * @param message + */ + public AccountingManagerStorageChartDrawException(String message) { + super(message); + } + + + public AccountingManagerStorageChartDrawException(String message,Throwable t) { + super(message,t); + } + + +}