Merge pull request #594 from peter-plochan/execute-vis

support for execution of visualization object

Author: liry

src/main/java/com/gooddata/GoodData.java

@@ -518,6 +518,4 @@ public ExecuteAfmService getExecuteAfmService() {
     public LcmService getLcmService() {
         return lcmService;
     }
-
-
 }

src/main/java/com/gooddata/executeafm/ExecuteAfmService.java

@@ -22,16 +22,22 @@
 import static com.gooddata.util.Validate.notNull;
 
 /**
- * Service for executeAfm resource
+ * Service for executing reports with new visualization structures like AFM or Visualization Object.
+ * This includes GD API endpoints:
+ * <ul>
+ *     <li>{@code /executeAfm}</li>
+ *     <li>{@code /executeVisualization}</li>
+ * </ul>
  */
 public class ExecuteAfmService extends AbstractService {
 
-    private static final String EXECUTION_URI = "/gdc/app/projects/{projectId}/executeAfm";
+    private static final String AFM_EXECUTION_URI = "/gdc/app/projects/{projectId}/executeAfm";
+    private static final String VISUALIZATION_EXECUTION_URI = "/gdc/app/projects/{projectId}/executeVisualization";
     private static final String RESULT_OFFSET = "offset";
     private static final String RESULT_LIMIT = "limit";
 
     /**
-     * Service for executeAfm resource
+     * Constructor.
      *
      * @param restTemplate rest template
      * @param settings     settings
@@ -41,17 +47,25 @@ public ExecuteAfmService(final RestTemplate restTemplate, final GoodDataSettings
     }
 
     /**
-     * Executes the given execution returning the execution response
+     * @deprecated use {@link ExecuteAfmService#executeAfm(Project, Execution)}
+     */
+    @Deprecated
+    public ExecutionResponse execute(final Project project, final Execution execution) {
+        return executeAfm(project, execution);
+    }
+
+    /**
+     * Executes the given AFM execution returning the execution response
      * @param project project of the execution
      * @param execution execution
      * @return response of the submitted execution
      */
-    public ExecutionResponse execute(final Project project, final Execution execution) {
+    public ExecutionResponse executeAfm(final Project project, final Execution execution) {
         final String projectId = notNull(notNull(project, "project").getId(), "projectId");
         final ExecutionResponse response;
         try {
             response = restTemplate.postForObject(
-                    EXECUTION_URI,
+                    AFM_EXECUTION_URI,
                     notNull(execution, "execution"),
                     ExecutionResponse.class,
                     projectId);
@@ -66,6 +80,32 @@ public ExecutionResponse execute(final Project project, final Execution executio
         return response;
     }
 
+    /**
+     * Executes the given execution returning the execution response
+     * @param project project of the execution
+     * @param execution execution
+     * @return response of the submitted execution
+     */
+    public ExecutionResponse executeVisualization(final Project project, final VisualizationExecution execution) {
+        final String projectId = notNull(notNull(project, "project").getId(), "projectId");
+        final ExecutionResponse response;
+        try {
+            response = restTemplate.postForObject(
+                    VISUALIZATION_EXECUTION_URI,
+                    notNull(execution, "execution"),
+                    ExecutionResponse.class,
+                    projectId);
+        } catch (GoodDataException | RestClientException e) {
+            throw new GoodDataException("Unable to execute visualization", e);
+        }
+
+        if (response == null) {
+            throw new GoodDataException("Empty response when execution posted to API");
+        }
+
+        return response;
+    }
+
     /**
      * Get for result of given response.
      * @param executionResponse response to get the result

src/main/java/com/gooddata/executeafm/VisualizationExecution.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2004-2018, GoodData(R) Corporation. All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE.txt file in the root directory of this source tree.
+ */
+
+package com.gooddata.executeafm;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import com.gooddata.executeafm.afm.CompatibilityFilter;
+import com.gooddata.executeafm.resultspec.ResultSpec;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Represents structure for triggering execution with reference to visualization object.
+ * Contains additional filters which should be merged with original ones defined in viz. object.
+ */
+@JsonTypeInfo(include = JsonTypeInfo.As.WRAPPER_OBJECT, use = JsonTypeInfo.Id.NAME)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonTypeName("visualizationExecution")
+public class VisualizationExecution {
+
+    private final String reference;
+    private List<CompatibilityFilter> filters;
+    private ResultSpec resultSpec;
+
+    /**
+     * Constructor.
+     * Creates execution of visualization object without any additional filters or result specification.
+     *
+     * @param reference reference uri to visualization object metadata
+     */
+    public VisualizationExecution(final String reference) {
+        this(reference, null, null);
+    }
+
+    /**
+     * @param reference reference uri to visualization object metadata
+     * @param filters additional filters which should be merged
+     * @param resultSpec result specification of executed viz. object
+     */
+    @JsonCreator
+    VisualizationExecution(@JsonProperty("reference") final String reference,
+            @JsonProperty("filters") final List<CompatibilityFilter> filters,
+            @JsonProperty("resultSpec") final ResultSpec resultSpec) {
+        this.reference = reference;
+        this.resultSpec = resultSpec;
+        this.filters = filters;
+    }
+
+    /**
+     * @return reference uri to visualization object metadata
+     */
+    public String getReference() {
+        return reference;
+    }
+
+    public List<CompatibilityFilter> getFilters() {
+        return filters;
+    }
+
+    /**
+     * Sets the result specification and returns this instance
+     *
+     * @param resultSpec result specification of executed viz. object
+     * @return updated execution
+     */
+    public VisualizationExecution setResultSpec(final ResultSpec resultSpec) {
+        this.resultSpec = resultSpec;
+        return this;
+    }
+
+    /**
+     * @return result specification of executed viz. object
+     */
+    public ResultSpec getResultSpec() {
+        return resultSpec;
+    }
+
+    /**
+     * Sets additional filters to this execution.
+     *
+     * @param filters additional filters
+     * @return updated execution
+     */
+    public VisualizationExecution setFilters(final List<CompatibilityFilter> filters) {
+        this.filters = filters;
+        return this;
+    }
+}

src/main/java/com/gooddata/executeafm/afm/ExpressionFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2017, GoodData(R) Corporation. All rights reserved.
+ * Copyright (C) 2007-2018, GoodData(R) Corporation. All rights reserved.
  * This source code is licensed under the BSD-style license found in the
  * LICENSE.txt file in the root directory of this source tree.
  */
@@ -10,11 +10,13 @@
 import com.fasterxml.jackson.annotation.JsonRootName;
 import com.gooddata.util.GoodDataToStringBuilder;
 
+import java.util.Objects;
+
 /**
  * To be deprecated filter using plain expression
  */
 @JsonRootName("expression")
-public class ExpressionFilter implements CompatibilityFilter {
+public final class ExpressionFilter implements CompatibilityFilter {
     static final String NAME = "expression";
     private final String value;
 
@@ -27,12 +29,27 @@ public ExpressionFilter(@JsonProperty("value") final String value) {
         this.value = value;
     }
 
-   public String getValue() {
+    public String getValue() {
         return value;
     }
 
     @Override
     public String toString() {
         return GoodDataToStringBuilder.defaultToString(this);
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof ExpressionFilter))
+            return false;
+        ExpressionFilter that = (ExpressionFilter) o;
+        return Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
 }

src/main/java/com/gooddata/md/visualization/VisualizationConverter.java

@@ -18,16 +18,11 @@
 import com.gooddata.executeafm.afm.NegativeAttributeFilter;
 import com.gooddata.executeafm.afm.PositiveAttributeFilter;
 import com.gooddata.executeafm.afm.SimpleMeasureDefinition;
-import com.gooddata.executeafm.resultspec.AttributeSortItem;
 import com.gooddata.executeafm.resultspec.Dimension;
-import com.gooddata.executeafm.resultspec.Direction;
-import com.gooddata.executeafm.resultspec.MeasureLocatorItem;
-import com.gooddata.executeafm.resultspec.MeasureSortItem;
 import com.gooddata.executeafm.resultspec.ResultSpec;
 import com.gooddata.executeafm.resultspec.SortItem;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -47,35 +42,49 @@ public abstract class VisualizationConverter {
     private static final ObjectMapper MAPPER = new ObjectMapper();
 
     /**
-     * Generate Execution from Visualization object. Currently {@link ResultSpec}'s {@link Dimension}s can be generated
-     * for table and four types of chart: bar, column, line and pie.
+     * Generate Execution from Visualization object.
      *
      * @param visualizationObject which will be converted to {@link Execution}
      * @param visualizationClassGetter {@link Function} for fetching VisualizationClass, which is necessary for correct generation of {@link ResultSpec}
      * @return {@link Execution} object
+     *
+     * @see #convertToAfm(VisualizationObject)
+     * @see #convertToResultSpec(VisualizationObject, Function)
      */
     public static Execution convertToExecution(final VisualizationObject visualizationObject, final Function<String, VisualizationClass> visualizationClassGetter) {
-        VisualizationClass visualizationClass = notNull(visualizationClassGetter).apply(notNull(visualizationObject).getVisualizationClassUri());
-
-        ResultSpec resultSpec = convertToResultSpec(visualizationObject, visualizationClass.getVisualizationType());
+        ResultSpec resultSpec = convertToResultSpec(visualizationObject, visualizationClassGetter);
         Afm afm = convertToAfm(visualizationObject);
         return new Execution(afm, resultSpec);
     }
 
-    static Afm convertToAfm(final VisualizationObject visualizationObject) {
+    /**
+     * Generate Afm from Visualization object.
+     *
+     * @param visualizationObject which will be converted to {@link Execution}
+     * @return {@link Afm} object
+     */
+    public static Afm convertToAfm(final VisualizationObject visualizationObject) {
         final List<AttributeItem> attributes = convertAttributes(visualizationObject.getAttributes());
         final List<CompatibilityFilter> filters = convertFilters(visualizationObject.getFilters());
         final List<MeasureItem> measures = convertMeasures(visualizationObject.getMeasures());
 
         return new Afm(attributes, filters, measures, null);
     }
 
-    static ResultSpec convertToResultSpec(final VisualizationObject visualizationObject,
-                                          final VisualizationType visualizationType) {
-        notNull(visualizationObject);
-        notNull(visualizationType);
+    /**
+     * Generate ResultSpec from Visualization object. Currently {@link ResultSpec}'s {@link Dimension}s can be generated
+     * for table and four types of chart: bar, column, line and pie.
+     *
+     * @param visualizationObject which will be converted to {@link Execution}
+     * @param visualizationClassGetter {@link Function} for fetching VisualizationClass, which is necessary for correct generation of {@link ResultSpec}
+     * @return {@link Execution} object
+     */
+    public static ResultSpec convertToResultSpec(final VisualizationObject visualizationObject,
+                                          final Function<String, VisualizationClass> visualizationClassGetter) {
+        VisualizationClass visualizationClass = notNull(visualizationClassGetter).apply(notNull(visualizationObject).getVisualizationClassUri());
+
         List<SortItem> sorts = getSorting(visualizationObject);
-        List<Dimension> dimensions = getDimensions(visualizationObject, visualizationType);
+        List<Dimension> dimensions = getDimensions(visualizationObject, visualizationClass.getVisualizationType());
         return new ResultSpec(dimensions, sorts);
     }
 
@@ -206,12 +215,11 @@ private static List<CompatibilityFilter> convertFilters(final List<FilterItem> f
     }
 
     private static List<MeasureItem> convertMeasures(final List<Measure> measures) {
-        List<MeasureItem> measuresForAfm = measures.stream()
+        return measures.stream()
                 .map(VisualizationConverter::removeFormat)
                 .map(VisualizationConverter::getAfmMeasure)
                 .map(VisualizationConverter::convertMeasureFilters)
                 .collect(toList());
-        return measuresForAfm;
     }
 
     private static Measure removeFormat(final Measure measure) {

src/main/java/com/gooddata/md/visualization/VisualizationObject.java

@@ -19,8 +19,10 @@
 import static org.apache.commons.lang3.Validate.notNull;
 
 import com.gooddata.executeafm.UriObjQualifier;
+import com.gooddata.executeafm.afm.Afm;
 import com.gooddata.executeafm.afm.FilterItem;
 import com.gooddata.executeafm.Execution;
+import com.gooddata.executeafm.resultspec.ResultSpec;
 import com.gooddata.md.AbstractObj;
 import com.gooddata.md.Meta;
 import com.gooddata.md.Queryable;
@@ -255,11 +257,30 @@ public void setVisualizationClass(UriObjQualifier uri) {
         content.setVisualizationClass(uri);
     }
 
+    /**
+     * @see VisualizationConverter#convertToExecution(VisualizationObject, Function)
+     */
     @JsonIgnore
     public Execution convertToExecution(Function<String, VisualizationClass> visualizationClassgetter) {
         return VisualizationConverter.convertToExecution(this, visualizationClassgetter);
     }
 
+    /**
+     * @see VisualizationConverter#convertToAfm(VisualizationObject)
+     */
+    @JsonIgnore
+    public Afm convertToAfm() {
+        return VisualizationConverter.convertToAfm(this);
+    }
+
+    /**
+     * @see VisualizationConverter#convertToResultSpec(VisualizationObject, Function)
+     */
+    @JsonIgnore
+    public ResultSpec convertToResultSpec(Function<String, VisualizationClass> visualizationClassgetter) {
+        return VisualizationConverter.convertToResultSpec(this, visualizationClassgetter);
+    }
+
     private Content getContent() {
         return content;
     }