The filter dimensions are now corresponding to the retriever chain

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/DataMiningService.java

@@ -19,7 +19,7 @@ public interface DataMiningService extends RemoteService {
 
     Collection<DataRetrieverChainDefinitionDTO> getDataRetrieverChainDefinitionsFor(FunctionDTO statisticToCalculate, String localeInfoName);
 
-    QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception;
+    QueryResult<Set<Object>> getDimensionValuesFor(DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition, String localeInfoName) throws Exception;
     
     <ResultType extends Number> QueryResult<ResultType> runQuery(QueryDefinition queryDefinition) throws Exception;
 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/DataMiningServiceAsync.java

@@ -21,7 +21,7 @@ public interface DataMiningServiceAsync {
     void getDataRetrieverChainDefinitionsFor(FunctionDTO statisticToCalculate, String localeInfoName,
             AsyncCallback<Collection<DataRetrieverChainDefinitionDTO>> callback);
     
-    void getDimensionValuesFor(Collection<FunctionDTO> dimensions, AsyncCallback<QueryResult<Set<Object>>> callback);
+    void getDimensionValuesFor(DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition, String localeInfoName, AsyncCallback<QueryResult<Set<Object>>> callback);
 
     <ResultType extends Number> void runQuery(QueryDefinition queryDefinition, AsyncCallback<QueryResult<ResultType>> callback);
     

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/QueryDefinitionProviderWithControls.java

@@ -11,6 +11,7 @@ import com.google.gwt.user.client.ui.Button;
 import com.google.gwt.user.client.ui.FlowPanel;
 import com.google.gwt.user.client.ui.HorizontalPanel;
 import com.google.gwt.user.client.ui.RequiresResize;
+import com.google.gwt.user.client.ui.VerticalPanel;
 import com.google.gwt.user.client.ui.Widget;
 import com.sap.sailing.gwt.ui.client.ErrorReporter;
 import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
@@ -19,6 +20,7 @@ import com.sap.sailing.gwt.ui.client.shared.components.SettingsDialogComponent;
 import com.sap.sailing.gwt.ui.client.shared.panels.ResizingFlowPanel;
 import com.sap.sailing.gwt.ui.datamining.DataMiningControls;
 import com.sap.sailing.gwt.ui.datamining.DataMiningServiceAsync;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionChangedListener;
 import com.sap.sailing.gwt.ui.datamining.GroupingChangedListener;
 import com.sap.sailing.gwt.ui.datamining.SelectionChangedListener;
 import com.sap.sailing.gwt.ui.datamining.SelectionProvider;
@@ -28,17 +30,19 @@ import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.shared.impl.QueryDefinitionImpl;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public class QueryDefinitionProviderWithControls extends AbstractQueryDefinitionProvider implements DataMiningControls {
 
     private FlowPanel mainPanel;
     private HorizontalPanel controlsPanel;
-
-    private SelectionProvider<?> selectionProvider;
     
     private StatisticProvider statisticProvider;
+    private SimpleDataRetrieverChainDefinitionProvider retrieverChainProvider;
 
     private MultiDimensionalGroupingProvider groupBySelectionPanel;
+    
+    private SelectionProvider<?> selectionProvider;
 
     public QueryDefinitionProviderWithControls(StringMessages stringMessages, SailingServiceAsync sailingService, DataMiningServiceAsync dataMiningService, ErrorReporter errorReporter) {
         super(stringMessages, sailingService, dataMiningService, errorReporter);
@@ -55,7 +59,7 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
 
         mainPanel.add(createFunctionsPanel());
 
-        selectionProvider = new RefreshingSelectionTablesPanel(stringMessages, dataMiningService, errorReporter, statisticProvider);
+        selectionProvider = new RefreshingSelectionTablesPanel(stringMessages, dataMiningService, errorReporter, retrieverChainProvider);
         selectionProvider.addSelectionChangedListener(new SelectionChangedListener() {
             @Override
             public void selectionChanged() {
@@ -70,6 +74,7 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
         HorizontalPanel functionsPanel = new HorizontalPanel();
         functionsPanel.setSpacing(5);
 
+        VerticalPanel statisticAndRetrieverChainPanel = new VerticalPanel();
         statisticProvider = new SimpleStatisticProvider(getStringMessages(), getDataMiningService(), getErrorReporter());
         statisticProvider.addStatisticChangedListener(new StatisticChangedListener() {
             @Override
@@ -77,7 +82,17 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
                 notifyQueryDefinitionChanged();
             }
         });
-        functionsPanel.add(statisticProvider.getEntryWidget());
+        statisticAndRetrieverChainPanel.add(statisticProvider.getEntryWidget());
+        
+        retrieverChainProvider = new SimpleDataRetrieverChainDefinitionProvider(getStringMessages(), getDataMiningService(), getErrorReporter(), statisticProvider);
+        retrieverChainProvider.addDataRetrieverChainDefinitionChangedListener(new DataRetrieverChainDefinitionChangedListener() {
+            @Override
+            public void dataRetrieverChainDefinitionChanged(DataRetrieverChainDefinitionDTO newDataRetrieverChainDefinition) {
+                notifyQueryDefinitionChanged();
+            }
+        });
+        statisticAndRetrieverChainPanel.add(retrieverChainProvider.getEntryWidget());
+        functionsPanel.add(statisticAndRetrieverChainPanel);
 
         groupBySelectionPanel = new MultiDimensionalGroupingProvider(getStringMessages(), getDataMiningService(), getErrorReporter(), statisticProvider);
         groupBySelectionPanel.addGroupingChangedListener(new GroupingChangedListener() {
@@ -107,7 +122,7 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
     @Override
     public QueryDefinition getQueryDefinition() {
         QueryDefinitionImpl queryDTO = new QueryDefinitionImpl(LocaleInfo.getCurrentLocale().getLocaleName(), statisticProvider.getStatisticToCalculate(),
-                                                               statisticProvider.getAggregatorType());
+                                                               statisticProvider.getAggregatorType(), retrieverChainProvider.getDataRetrieverChainDefinition());
         
         for (FunctionDTO dimension : groupBySelectionPanel.getDimensionsToGroupBy()) {
             queryDTO.appendDimensionToGroupBy(dimension);
@@ -123,9 +138,10 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
     @Override
     public void applyQueryDefinition(QueryDefinition queryDefinition) {
         setBlockChangeNotification(true);
-        selectionProvider.applySelection(queryDefinition);
-        groupBySelectionPanel.applyQueryDefinition(queryDefinition);
         statisticProvider.applyQueryDefinition(queryDefinition);
+        retrieverChainProvider.applyQueryDefinition(queryDefinition);
+        groupBySelectionPanel.applyQueryDefinition(queryDefinition);
+        selectionProvider.applySelection(queryDefinition);
         setBlockChangeNotification(false);
         
         notifyQueryDefinitionChanged();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/RefreshingSelectionTablesPanel.java

@@ -26,20 +26,21 @@ import com.sap.sailing.gwt.ui.client.ErrorReporter;
 import com.sap.sailing.gwt.ui.client.StringMessages;
 import com.sap.sailing.gwt.ui.client.shared.components.SettingsDialogComponent;
 import com.sap.sailing.gwt.ui.datamining.DataMiningServiceAsync;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionChangedListener;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionProvider;
 import com.sap.sailing.gwt.ui.datamining.SelectionChangedListener;
 import com.sap.sailing.gwt.ui.datamining.SelectionProvider;
-import com.sap.sailing.gwt.ui.datamining.StatisticChangedListener;
-import com.sap.sailing.gwt.ui.datamining.StatisticProvider;
 import com.sap.sailing.gwt.ui.datamining.settings.RefreshingSelectionTablesSettings;
 import com.sap.sailing.gwt.ui.datamining.settings.RefreshingSelectionTablesSettingsDialogComponent;
+import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.QueryResult;
-import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public class RefreshingSelectionTablesPanel implements SelectionProvider<RefreshingSelectionTablesSettings>,
-                                                       StatisticChangedListener {
+                                                       DataRetrieverChainDefinitionChangedListener {
     
     private static final int resizeDelay = 100;
     private static final double relativeWidthInPercent = 1;
@@ -57,18 +58,18 @@ public class RefreshingSelectionTablesPanel implements SelectionProvider<Refresh
     private Map<GenericGroupKey<FunctionDTO>, SelectionTable<?>> tablesMappedByDimensionAsKeys;
     private Set<SelectionChangedListener> listeners;
     
-    private FunctionDTO currentStatisticToCalculate;
+    private DataRetrieverChainDefinitionDTO currentDataRetrieverChainDefinition;
     
     public RefreshingSelectionTablesPanel(StringMessages stringMessages, DataMiningServiceAsync dataMiningService, ErrorReporter errorReporter,
-                                          StatisticProvider statisticProvider) {
+                                          DataRetrieverChainDefinitionProvider dataRetrieverChainDefinitionProvider) {
         this.stringMessages = stringMessages;
         this.dataMiningService = dataMiningService;
         this.errorReporter = errorReporter;
         settings = new RefreshingSelectionTablesSettings();
         listeners = new HashSet<SelectionChangedListener>();
-        currentStatisticToCalculate = null;
+        currentDataRetrieverChainDefinition = null;
 
-        tablesMappedByDimensionAsKeys = new HashMap<GenericGroupKey<FunctionDTO>, SelectionTable<?>>();
+        tablesMappedByDimensionAsKeys = new HashMap<>();
         
         tablesPanel = new HorizontalPanel();
         
@@ -93,68 +94,79 @@ public class RefreshingSelectionTablesPanel implements SelectionProvider<Refresh
         });
 
         doLayout(Window.getClientWidth(), Window.getClientHeight());
-        statisticProvider.addStatisticChangedListener(this);
+        dataRetrieverChainDefinitionProvider.addDataRetrieverChainDefinitionChangedListener(this);
     }
     
     @Override
-    public void statisticChanged(FunctionDTO newStatisticToCalculate, AggregatorType newAggregatorType) {
-        if (!Objects.equals(currentStatisticToCalculate, newStatisticToCalculate)) {
-            currentStatisticToCalculate = newStatisticToCalculate;
-            updateAvailableTables();
+    public void dataRetrieverChainDefinitionChanged(DataRetrieverChainDefinitionDTO newDataRetrieverChainDefinition) {
+        if (!Objects.equals(currentDataRetrieverChainDefinition, newDataRetrieverChainDefinition)) {
+            currentDataRetrieverChainDefinition = newDataRetrieverChainDefinition;
+            timer.cancel();
+            updateTables();
         }
     }
     
-    private void updateAvailableTables() {
-        dataMiningService.getDimensionsFor(currentStatisticToCalculate, LocaleInfo.getCurrentLocale().getLocaleName(), new AsyncCallback<Collection<FunctionDTO>>() {
+    private void updateTables() {
+        dataMiningService.getDimensionValuesFor(currentDataRetrieverChainDefinition, LocaleInfo.getCurrentLocale().getLocaleName(), new AsyncCallback<QueryResult<Set<Object>>>() {
             @Override
             public void onFailure(Throwable caught) {
                 errorReporter.reportError("Error fetching the dimensions from the server: " + caught.getMessage());
             }
             @Override
-            public void onSuccess(Collection<FunctionDTO> dimensions) {
-                Collection<GenericGroupKey<FunctionDTO>> dimensionsAsKeys = new HashSet<>();
-                for (FunctionDTO dimension : dimensions) {
-                    dimensionsAsKeys.add(new GenericGroupKey<FunctionDTO>(dimension));
-                }
+            public void onSuccess(QueryResult<Set<Object>> dimensionValues) {
+                @SuppressWarnings("unchecked")
+                Collection<GenericGroupKey<FunctionDTO>> dimensionsAsKeys = (Collection<GenericGroupKey<FunctionDTO>>)(Collection<?>) dimensionValues.getResults().keySet();
+                updateAvailableTables(dimensionsAsKeys);
                 
-                Collection<GenericGroupKey<FunctionDTO>> dimensionTablesToBeRemoved = new HashSet<>(tablesMappedByDimensionAsKeys.keySet());
-                dimensionTablesToBeRemoved.removeAll(dimensionsAsKeys);
-                for (GenericGroupKey<FunctionDTO> dimensionToBeRemoved : dimensionTablesToBeRemoved) {
-                    tablesMappedByDimensionAsKeys.remove(dimensionToBeRemoved);
+                boolean tableContentChanged = updateTableValues(dimensionValues.getResults());
+                if (settings.isRerunQueryAfterRefresh() && tableContentChanged) {
+                    notifySelectionChanged();
+                    // TODO query is executed, before the data is ready to be analyzed
+                    // TODO does this error still appear with the new concept?
                 }
-                
-                for (GenericGroupKey<FunctionDTO> dimensionAsKey : dimensionsAsKeys) {
-                    if (!tablesMappedByDimensionAsKeys.containsKey(dimensionAsKey)) {
-                        SelectionTable<?> table = new SelectionTable<>(dimensionAsKey.getValue());
-                        table.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
-                            @Override
-                            public void onSelectionChange(SelectionChangeEvent event) {
-                                notifySelectionChanged();
-                            }
-                        });
-                        
-                        tablesMappedByDimensionAsKeys.put(dimensionAsKey, table);
-                    }
+                if (settings.isRefreshAutomatically()) {
+                    timer.schedule(settings.getRefreshIntervalInMilliseconds());
                 }
-                
-                List<GenericGroupKey<FunctionDTO>> sortedDimensions = new ArrayList<>(tablesMappedByDimensionAsKeys.keySet());
-                Collections.sort(sortedDimensions, new Comparator<GenericGroupKey<FunctionDTO>>() {
-                    @Override
-                    public int compare(GenericGroupKey<FunctionDTO> k1, GenericGroupKey<FunctionDTO> k2) {
-                        return k1.getValue().compareTo(k2.getValue());
-                    }
-                });
-                tablesPanel.clear();
-                for (GenericGroupKey<FunctionDTO> dimension : sortedDimensions) {
-                    tablesPanel.add(tablesMappedByDimensionAsKeys.get(dimension));
-                }
-
-                updateTables();
-                doLayout(Window.getClientWidth(), Window.getClientHeight());
             }
         });
     }
 
+    private void updateAvailableTables(Collection<GenericGroupKey<FunctionDTO>> dimensionsAsKeys) {
+        Collection<GenericGroupKey<FunctionDTO>> dimensionTablesToBeRemoved = new HashSet<>(tablesMappedByDimensionAsKeys.keySet());
+        dimensionTablesToBeRemoved.removeAll(dimensionsAsKeys);
+        for (GenericGroupKey<FunctionDTO> dimensionToBeRemoved : dimensionTablesToBeRemoved) {
+            tablesMappedByDimensionAsKeys.remove(dimensionToBeRemoved);
+        }
+        
+        for (GenericGroupKey<FunctionDTO> dimensionAsKey : dimensionsAsKeys) {
+            if (!tablesMappedByDimensionAsKeys.containsKey(dimensionAsKey)) {
+                SelectionTable<?> table = new SelectionTable<>(dimensionAsKey.getValue());
+                table.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
+                    @Override
+                    public void onSelectionChange(SelectionChangeEvent event) {
+                        notifySelectionChanged();
+                    }
+                });
+                
+                tablesMappedByDimensionAsKeys.put(dimensionAsKey, table);
+            }
+        }
+        
+        List<GenericGroupKey<FunctionDTO>> sortedDimensions = new ArrayList<>(tablesMappedByDimensionAsKeys.keySet());
+        Collections.sort(sortedDimensions, new Comparator<GenericGroupKey<FunctionDTO>>() {
+            @Override
+            public int compare(GenericGroupKey<FunctionDTO> k1, GenericGroupKey<FunctionDTO> k2) {
+                return k1.getValue().compareTo(k2.getValue());
+            }
+        });
+        tablesPanel.clear();
+        for (GenericGroupKey<FunctionDTO> dimension : sortedDimensions) {
+            tablesPanel.add(tablesMappedByDimensionAsKeys.get(dimension));
+        }
+
+        doLayout(Window.getClientWidth(), Window.getClientHeight());
+    }
+
     private void doLayout(int newWindowWidth, int newWindowHeight) {
         int absoluteWidth = (int) ((newWindowWidth - widthMargin) * relativeWidthInPercent);
         int absoluteHeight = (int) (newWindowHeight * relativeHeightInPercent);
@@ -169,53 +181,28 @@ public class RefreshingSelectionTablesPanel implements SelectionProvider<Refresh
         }
     }
 
-    private void updateTables() {
-        Collection<FunctionDTO> dimensions = new HashSet<>();
+    private boolean updateTableValues(Map<GroupKey, Set<Object>> newValues) {
+        boolean tableContentChanged = false;
         for (GenericGroupKey<FunctionDTO> dimensionAsKey : tablesMappedByDimensionAsKeys.keySet()) {
-            dimensions.add(dimensionAsKey.getValue());
+            List<?> sortedDimensionValues = new ArrayList<>();
+            if (newValues.containsKey(dimensionAsKey)) {
+                sortedDimensionValues = new ArrayList<>(newValues.get(dimensionAsKey));
+                Collections.sort(sortedDimensionValues, new Comparator<Object>() {
+                    @Override
+                    public int compare(Object o1, Object o2) {
+                        return o1.toString().compareTo(o2.toString());
+                    }
+                });
+            }
+
+            boolean currentTableContentChanged = tablesMappedByDimensionAsKeys.get(dimensionAsKey).updateContent(
+                    sortedDimensionValues);
+            if (!tableContentChanged) {
+                tableContentChanged = currentTableContentChanged;
+            }
         }
-        
-        if (!dimensions.isEmpty()) {
-            dataMiningService.getDimensionValuesFor(dimensions, new AsyncCallback<QueryResult<Set<Object>>>() {
-                @Override
-                public void onFailure(Throwable caught) {
-                    errorReporter.reportError("Error fetching the dimension values from the server: "
-                            + caught.getMessage());
-                }
 
-                @Override
-                public void onSuccess(QueryResult<Set<Object>> result) {
-                    boolean tableContentChanged = false;
-                    for (GenericGroupKey<FunctionDTO> dimensionAsKey : tablesMappedByDimensionAsKeys.keySet()) {
-                        List<?> sortedDimensionValues = new ArrayList<>();
-                        if (result.getResults().containsKey(dimensionAsKey)) {
-                            sortedDimensionValues = new ArrayList<>(result.getResults().get(dimensionAsKey));
-                            Collections.sort(sortedDimensionValues, new Comparator<Object>() {
-                                @Override
-                                public int compare(Object o1, Object o2) {
-                                    return o1.toString().compareTo(o2.toString());
-                                }
-                            });
-                        }
-
-                        boolean currentTableContentChanged = tablesMappedByDimensionAsKeys.get(dimensionAsKey)
-                                .updateContent(sortedDimensionValues);
-                        if (!tableContentChanged) {
-                            tableContentChanged = currentTableContentChanged;
-                        }
-                    }
-
-                    if (settings.isRerunQueryAfterRefresh() && tableContentChanged) {
-                        notifySelectionChanged();
-                        // TODO query is executed, before the data is ready to be analyzed
-                        // TODO does this error still appear with the new concept?
-                    }
-                    if (settings.isRefreshAutomatically()) {
-                        timer.schedule(settings.getRefreshIntervalInMilliseconds());
-                    }
-                }
-            });
-        }
+        return tableContentChanged;
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/SimpleDataRetrieverChainDefinitionProvider.java

@@ -52,6 +52,7 @@ public class SimpleDataRetrieverChainDefinitionProvider implements DataRetriever
         currentStatisticToCalculate = null;
         
         mainPanel = new HorizontalPanel();
+        mainPanel.setSpacing(5);
         mainPanel.add(new Label(this.stringMessages.retrieveWith()));
         
         retrieverChainsListBox = createRetrieverChainsListBox();
@@ -80,9 +81,9 @@ public class SimpleDataRetrieverChainDefinitionProvider implements DataRetriever
     @Override
     public void statisticChanged(FunctionDTO newStatisticToCalculate, AggregatorType newAggregatorType) {
         if (!Objects.equals(currentStatisticToCalculate, newStatisticToCalculate)) {
-            String currentSourceType = currentStatisticToCalculate.getSourceTypeName();
+            String currentSourceType = currentStatisticToCalculate == null ? null : currentStatisticToCalculate.getSourceTypeName();
             currentStatisticToCalculate = newStatisticToCalculate;
-            if (currentSourceType.equals(newStatisticToCalculate.getSourceTypeName())) {
+            if (!Objects.equals(currentSourceType, newStatisticToCalculate.getSourceTypeName())) {
                 updateAvailableRetrieverChains();
             }
         }
@@ -105,7 +106,7 @@ public class SimpleDataRetrieverChainDefinitionProvider implements DataRetriever
                             retrieverChainsListBox.setValue(retrieverChainToBeSelected);
                             retrieverChainsListBox.setAcceptableValues(sortedRetrieverChains);
                             
-                            if (!currentRetrieverChain.equals(retrieverChainToBeSelected)) {
+                            if (!retrieverChainToBeSelected.equals(currentRetrieverChain)) {
                                 notifyListeners();
                             }
                         } else {
@@ -139,8 +140,7 @@ public class SimpleDataRetrieverChainDefinitionProvider implements DataRetriever
 
     @Override
     public void applyQueryDefinition(QueryDefinition queryDefinition) {
-        // TODO Auto-generated method stub
-
+        retrieverChainsListBox.setValue(queryDefinition.getDataRetrieverChainDefinition(), false);
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/DataMiningServiceImpl.java

@@ -113,14 +113,20 @@ public class DataMiningServiceImpl extends RemoteServiceServlet implements DataM
         
         Collection<FunctionDTO> functionDTOs = new ArrayList<FunctionDTO>();
         for (Function<?> function : functions) {
-            functionDTOs.add(functionDTOFactory.createFunctionDTO(function, locale, dataMiningStringMessages));
+            functionDTOs.add(functionDTOFactory.createFunctionDTO(function, dataMiningStringMessages, locale));
         }
         return functionDTOs;
     }
     
+//    @Override
+//    public QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception {
+//        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), null, dimensions);
+//        return dimensionValuesQuery.run();
+//    }
     @Override
-    public QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception {
-        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), dimensions);
+    public QueryResult<Set<Object>> getDimensionValuesFor(DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition,
+            String localeInfoName) throws Exception {
+        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), dataRetrieverChainDefinition, localeInfoName);
         return dimensionValuesQuery.run();
     }