implement aggregation of historical events (eiffel-community#52)

Implement aggregation of historical events when a new start event is consumed

Author: vasile-baluta

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.github.ericsson</groupId>
     <artifactId>eiffel-intelligence</artifactId>
-    <version>0.0.3</version>
+    <version>0.0.4</version>
 
     <packaging>war</packaging>
 
@@ -192,7 +192,7 @@
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
             </plugin>
-
+            
             <!-- PhoenixNAP RAML Code Generator plugin used to generate sources
                 from raml -->
             <plugin>
@@ -224,8 +224,8 @@
                         </goals>
                     </execution>
                 </executions>
-            </plugin>
-
+            </plugin>      
+            
             <!-- required for adding generated sources -->
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
@@ -244,13 +244,15 @@
                         </configuration>
                     </execution>
                 </executions>
-            </plugin>
-
+            </plugin>    
+           
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>2.20</version>
                 <configuration>
+                    <forkCount>1</forkCount>
+                    <reuseForks>false</reuseForks>
                     <excludes>
                         <exclude>${someModule.test.excludes}</exclude>
                     </excludes>

src/main/java/com/ericsson/ei/controller/RuleCheckControllerImpl.java

@@ -46,11 +46,12 @@ public class RuleCheckControllerImpl implements RuleCheckController {
     JmesPathInterface jmesPathInterface;
 
     /**
-     * This method interacts with JmesPathInterface class method runRuleOnEvent to
-     * evaluate a rule on JSON object.
+     * This method interacts with JmesPathInterface class method runRuleOnEvent
+     * to evaluate a rule on JSON object.
      * 
      * @param rule-
-     *            takes a String as a rule that need to be evaluated on JSON content
+     *            takes a String as a rule that need to be evaluated on JSON
+     *            content
      * @param jsonContent-
      *            takes JSON object as a String
      * @return return a String object

src/main/java/com/ericsson/ei/erqueryservice/ERQueryService.java

@@ -17,11 +17,7 @@
 */
 package com.ericsson.ei.erqueryservice;
 
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.annotation.PostConstruct;
-
+import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Getter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -33,29 +29,26 @@
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestClientException;
 import org.springframework.web.client.RestOperations;
+import org.springframework.web.util.UriComponents;
 import org.springframework.web.util.UriComponentsBuilder;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ArrayNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
+import javax.annotation.PostConstruct;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 
 /**
  * @author evasiba
- *
  */
 @Component
 public class ERQueryService {
 
     static Logger log = (Logger) LoggerFactory.getLogger(ERQueryService.class);
-
     private RestOperations rest;
-
-    public final static int DOWNSTREAM = 0;
-    public final static int UPSTREAM = 1;
-    public final static int DOWNANDUPSTREAM = 2;
-
     @Getter
     @Value("${er.url}")
     private String url;
@@ -73,102 +66,104 @@ public void setRest(RestOperations rest) {
      * eventID.
      *
      * @param eventId
+     *            the id of the event.
      * @return ResponseEntity
      */
     public ResponseEntity<String> getEventDataById(String eventId) {
-        String erUrl = url.trim() + "{id}";
-        log.info("The url is : " + erUrl);
-        Map<String, String> params = new HashMap<>();
-        params.put("id", eventId);
-        ResponseEntity<String> response = null;
-        log.info("The ID parameter is set");
+        final String erUrl = URI.create(url.trim() + "/" + "{id}").normalize().toString();
+        log.debug("The URL to ER is: " + erUrl);
+
+        final Map<String, String> params = Collections.singletonMap("id", eventId);
+        log.trace("The ID parameter is set");
         try {
-            response = rest.getForEntity(erUrl, String.class, params);
-            log.info("The response is : " + response.toString());
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
+            final ResponseEntity<String> response = rest.getForEntity(erUrl, String.class, params);
+            log.trace("The response is : " + response.toString());
+        } catch (RestClientException e) {
+            log.error("Error occurred while executing REST GET to: " + erUrl + " for " + eventId, e);
         }
-        return response;
+
+        return null;
     }
 
     /**
      * This method is used to fetch only the upstream or downstream or both
-     * event information from ER2.0 based on the eventID and searchAction
+     * event information from ER2.0 based on the eventID and searchOption
      * conditions.
      *
      * @param eventId
-     * @param searchAction
-     * @param limitParam
-     * @param levelsParam
+     *            the id of the event.
+     * @param searchOption
+     *            the SearchOption to indicate whether to search up, down or
+     *            both ways from the eventId.
+     * @param limit
+     *            sets the limit of how many events up and/or down stream from
+     *            the eventId to include in the result.
+     * @param levels
+     *            sets the limit of how many levels up and/or down stream from
+     *            the eventId to include in the result.
      * @param tree
+     *            whether or not to retain the tree structure in the result.
      * @return ResponseEntity
      */
+    public ResponseEntity<JsonNode> getEventStreamDataById(String eventId, SearchOption searchOption, int limit,
+            int levels, boolean tree) {
 
-    public ResponseEntity<JsonNode> getEventStreamDataById(String eventId, int searchAction, int limitParam,
-            int levelsParam, boolean tree) {
-
-        String erUrl = url.trim() + eventId;
-        log.info("The url is : " + erUrl);
+        final String erUrl = URI.create(url.trim() + "/" + eventId).normalize().toString();
+        log.debug("The URL to ER is: " + erUrl);
 
         // Request Body parameters
-        JsonNode uriParams = getSearchParameters(searchAction);
-
-        // Add query parameter
-        UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(erUrl).queryParam("limit", limitParam)
-                .queryParam("levels", levelsParam).queryParam("tree", tree);
+        final SearchParameters searchParameters = getSearchParameters(searchOption);
 
-        HttpHeaders headers = new HttpHeaders();
+        // Build query parameters
+        final UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(erUrl).queryParam("limit", limit)
+                .queryParam("levels", levels).queryParam("tree", tree);
+        final HttpHeaders headers = new HttpHeaders();
         headers.setContentType(MediaType.APPLICATION_JSON);
 
-        HttpEntity<JsonNode> requestEntity = new HttpEntity<>(uriParams, headers);
-        log.info("The request is : " + builder.buildAndExpand(uriParams).toUri().toString());
-
-        ResponseEntity<JsonNode> response = rest.exchange(builder.buildAndExpand(uriParams).toUri(), HttpMethod.POST,
-                requestEntity, JsonNode.class);
-        return response;
-    }
-
-    /** Generates the json object used as body for downstream/upstream
-     * query requests
-     * @param searchAction - one of DOWNSTREAM, UPSTREAM or DOWNANDUPSTREAM
-     * @return
-     */
-    public JsonNode getSearchParameters(int searchAction) {
-        JsonNode uriParams = null;
-        ObjectMapper objectmapper = new ObjectMapper();
-
-        String[] linkTypes = {"ALL"};
+        final HttpEntity<SearchParameters> requestEntity = new HttpEntity<>(searchParameters, headers);
+        final UriComponents uriComponents = builder.buildAndExpand(searchParameters);
+        log.debug("The request is : " + uriComponents.toUri().toString());
 
         try {
-            uriParams = objectmapper.readTree("{}");
-            if (searchAction == DOWNSTREAM) {
-                putSearchParameter(uriParams, "dlt", linkTypes);
-            } else if (searchAction == UPSTREAM) {
-                putSearchParameter(uriParams, "ult", linkTypes);
-            } else if (searchAction == DOWNANDUPSTREAM) {
-                putSearchParameter(uriParams, "dlt", linkTypes);
-                putSearchParameter(uriParams, "ult", linkTypes);
-            }
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
+            return rest.exchange(uriComponents.toUri(), HttpMethod.POST, requestEntity, JsonNode.class);
+        } catch (RestClientException e) {
+            log.error("Error occurred while executing REST POST to: " + erUrl + " for\n" + requestEntity, e);
         }
-        return uriParams;
+
+        return null;
     }
 
-    /** Create an array node with link types for upstream or downstream query
-     * @param params
-     * @param actionString
-     * @param linkTypes
+    /**
+     * Build the search parameters to be used to query ER.
+     *
+     * @param searchOption
+     *            one of UP_STREAM, DOWN_STREAM or UP_AND_DOWN_STREAM
+     * @return the search parameters to be used
      */
-    public void putSearchParameter(JsonNode params, String actionString, String[] linkTypes) {
-        ArrayNode node =((ObjectNode) params).putArray(actionString);
-        for (String string : linkTypes) {
-            node.add(string);
+    private SearchParameters getSearchParameters(SearchOption searchOption) {
+        final SearchParameters searchParameters = new SearchParameters();
+        final List<LinkType> allLinkTypes = Collections.singletonList(LinkType.ALL);
+        switch (searchOption) {
+        case DOWN_STREAM:
+            searchParameters.setUlt(new ArrayList<>());
+            searchParameters.setDlt(allLinkTypes);
+            break;
+        case UP_STREAM:
+            searchParameters.setUlt(allLinkTypes);
+            searchParameters.setDlt(new ArrayList<>());
+            break;
+        case UP_AND_DOWN_STREAM:
+            searchParameters.setUlt(allLinkTypes);
+            searchParameters.setDlt(allLinkTypes);
+            break;
         }
+
+        return searchParameters;
     }
 
     @PostConstruct
     public void init() {
+        // TODO: is this needed?
         log.debug("The url parameter is : " + url);
     }
 }

src/main/java/com/ericsson/ei/erqueryservice/LinkType.java

@@ -0,0 +1,51 @@
+/*
+
+   Copyright 2017 Ericsson AB.
+   For a full list of individual contributors, please see the commit history.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+package com.ericsson.ei.erqueryservice;
+
+import java.util.Arrays;
+import java.util.List;
+
+public enum LinkType {
+    // Link types
+    CAUSE,
+    CONTEXT,
+    FLOW_CONTEXT,
+    ACTIVITY_EXECUTION,
+    PREVIOUS_ACTIVITY_EXECUTION,
+    PREVIOUS_VERSION,
+    COMPOSITION,
+    ENVIRONMENT,
+    ARTIFACT,
+    SUBJECT,
+    ELEMENT,
+    BASE,
+    CHANGE,
+    TEST_SUITE_EXECUTION,
+    TEST_CASE_EXECUTION,
+    IUT,
+    TERC,
+    MODIFIED_ANNOUNCEMENT,
+    SUB_CONFIDENCE_LEVEL,
+    REUSED_ARTIFACT,
+    VERIFICATION_BASIS,
+    ALL;
+
+    public static List<LinkType> asList() {
+        return Arrays.asList(values());
+    }
+}

src/main/java/com/ericsson/ei/erqueryservice/SearchOption.java

@@ -0,0 +1,24 @@
+/*
+
+   Copyright 2017 Ericsson AB.
+   For a full list of individual contributors, please see the commit history.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+package com.ericsson.ei.erqueryservice;
+
+public enum SearchOption {
+    DOWN_STREAM,
+    UP_STREAM,
+    UP_AND_DOWN_STREAM
+}