17
17
*/
18
18
package com .ericsson .ei .erqueryservice ;
19
19
20
- import java .util .HashMap ;
21
- import java .util .Map ;
22
-
23
- import javax .annotation .PostConstruct ;
24
-
20
+ import com .fasterxml .jackson .databind .JsonNode ;
25
21
import lombok .Getter ;
26
22
import org .slf4j .Logger ;
27
23
import org .slf4j .LoggerFactory ;
33
29
import org .springframework .http .MediaType ;
34
30
import org .springframework .http .ResponseEntity ;
35
31
import org .springframework .stereotype .Component ;
36
- import org .springframework .util . LinkedMultiValueMap ;
32
+ import org .springframework .web . client . RestClientException ;
37
33
import org .springframework .web .client .RestOperations ;
34
+ import org .springframework .web .util .UriComponents ;
38
35
import org .springframework .web .util .UriComponentsBuilder ;
39
36
40
- import com .fasterxml .jackson .databind .JsonNode ;
41
- import com .fasterxml .jackson .databind .ObjectMapper ;
42
- import com .fasterxml .jackson .databind .node .ArrayNode ;
43
- import com .fasterxml .jackson .databind .node .ObjectNode ;
37
+ import javax .annotation .PostConstruct ;
38
+ import java .net .URI ;
39
+ import java .util .ArrayList ;
40
+ import java .util .Collections ;
41
+ import java .util .List ;
42
+ import java .util .Map ;
44
43
45
44
/**
46
45
* @author evasiba
47
- *
48
46
*/
49
47
@ Component
50
48
public class ERQueryService {
51
49
52
50
static Logger log = (Logger ) LoggerFactory .getLogger (ERQueryService .class );
53
-
54
51
private RestOperations rest ;
55
-
56
- public final static int DOWNSTREAM = 0 ;
57
- public final static int UPSTREAM = 1 ;
58
- public final static int DOWNANDUPSTREAM = 2 ;
59
-
60
52
@ Getter
61
53
@ Value ("${er.url}" )
62
54
private String url ;
@@ -74,102 +66,104 @@ public void setRest(RestOperations rest) {
74
66
* eventID.
75
67
*
76
68
* @param eventId
69
+ * the id of the event.
77
70
* @return ResponseEntity
78
71
*/
79
- public ResponseEntity getEventDataById (String eventId ) {
80
- String erUrl = url .trim () + "{id}" ;
81
- log .info ("The url is : " + erUrl );
82
- Map <String , String > params = new HashMap <String , String >();
83
- params .put ("id" , eventId );
84
- ResponseEntity <String > response = null ;
85
- log .info ("The ID parameter is set" );
72
+ public ResponseEntity <String > getEventDataById (String eventId ) {
73
+ final String erUrl = URI .create (url .trim () + "/" + "{id}" ).normalize ().toString ();
74
+ log .debug ("The URL to ER is: " + erUrl );
75
+
76
+ final Map <String , String > params = Collections .singletonMap ("id" , eventId );
77
+ log .trace ("The ID parameter is set" );
86
78
try {
87
- response = rest .getForEntity (erUrl , String .class , params );
88
- log .info ("The response is : " + response .toString ());
89
- } catch (Exception e ) {
90
- log .error (e . getMessage () , e );
79
+ final ResponseEntity < String > response = rest .getForEntity (erUrl , String .class , params );
80
+ log .trace ("The response is : " + response .toString ());
81
+ } catch (RestClientException e ) {
82
+ log .error ("Error occurred while executing REST GET to: " + erUrl + " for " + eventId , e );
91
83
}
92
- return response ;
84
+
85
+ return null ;
93
86
}
94
87
95
88
/**
96
89
* This method is used to fetch only the upstream or downstream or both
97
- * event information from ER2.0 based on the eventID and searchAction
90
+ * event information from ER2.0 based on the eventID and searchOption
98
91
* conditions.
99
92
*
100
93
* @param eventId
101
- * @param searchAction
102
- * @param limitParam
103
- * @param levelsParam
94
+ * the id of the event.
95
+ * @param searchOption
96
+ * the SearchOption to indicate whether to search up, down or
97
+ * both ways from the eventId.
98
+ * @param limit
99
+ * sets the limit of how many events up and/or down stream from
100
+ * the eventId to include in the result.
101
+ * @param levels
102
+ * sets the limit of how many levels up and/or down stream from
103
+ * the eventId to include in the result.
104
104
* @param tree
105
+ * whether or not to retain the tree structure in the result.
105
106
* @return ResponseEntity
106
107
*/
108
+ public ResponseEntity <JsonNode > getEventStreamDataById (String eventId , SearchOption searchOption , int limit ,
109
+ int levels , boolean tree ) {
107
110
108
- public ResponseEntity getEventStreamDataById (String eventId , int searchAction , int limitParam ,
109
- int levelsParam , boolean tree ) {
110
-
111
- String erUrl = url .trim () + eventId ;
112
- log .info ("The url is : " + erUrl );
111
+ final String erUrl = URI .create (url .trim () + "/" + eventId ).normalize ().toString ();
112
+ log .debug ("The URL to ER is: " + erUrl );
113
113
114
114
// Request Body parameters
115
- JsonNode uriParams = getSearchParameters (searchAction );
116
-
117
- // Add query parameter
118
- UriComponentsBuilder builder = UriComponentsBuilder .fromUriString (erUrl ).queryParam ("limit" , limitParam )
119
- .queryParam ("levels" , levelsParam ).queryParam ("tree" , tree );
115
+ final SearchParameters searchParameters = getSearchParameters (searchOption );
120
116
121
- HttpHeaders headers = new HttpHeaders ();
117
+ // Build query parameters
118
+ final UriComponentsBuilder builder = UriComponentsBuilder .fromUriString (erUrl ).queryParam ("limit" , limit )
119
+ .queryParam ("levels" , levels ).queryParam ("tree" , tree );
120
+ final HttpHeaders headers = new HttpHeaders ();
122
121
headers .setContentType (MediaType .APPLICATION_JSON );
123
122
124
- HttpEntity <LinkedMultiValueMap <String , Object >> requestEntity = new HttpEntity (uriParams , headers );
125
- log .info ("The request is : " + builder .buildAndExpand (uriParams ).toUri ().toString ());
126
-
127
- ResponseEntity response = rest .exchange (builder .buildAndExpand (uriParams ).toUri (), HttpMethod .POST ,
128
- requestEntity , JsonNode .class );
129
- return response ;
130
- }
131
-
132
- /** Generates the json object used as body for downstream/upstream
133
- * query requests
134
- * @param searchAction - one of DOWNSTREAM, UPSTREAM or DOWNANDUPSTREAM
135
- * @return
136
- */
137
- public JsonNode getSearchParameters (int searchAction ) {
138
- JsonNode uriParams = null ;
139
- ObjectMapper objectmapper = new ObjectMapper ();
140
-
141
- String [] linkTypes = {"ALL" };
123
+ final HttpEntity <SearchParameters > requestEntity = new HttpEntity <>(searchParameters , headers );
124
+ final UriComponents uriComponents = builder .buildAndExpand (searchParameters );
125
+ log .debug ("The request is : " + uriComponents .toUri ().toString ());
142
126
143
127
try {
144
- uriParams = objectmapper .readTree ("{}" );
145
- if (searchAction == DOWNSTREAM ) {
146
- putSearchParameter (uriParams , "dlt" , linkTypes );
147
- } else if (searchAction == UPSTREAM ) {
148
- putSearchParameter (uriParams , "ult" , linkTypes );
149
- } else if (searchAction == DOWNANDUPSTREAM ) {
150
- putSearchParameter (uriParams , "dlt" , linkTypes );
151
- putSearchParameter (uriParams , "ult" , linkTypes );
152
- }
153
- } catch (Exception e ) {
154
- log .error (e .getMessage (), e );
128
+ return rest .exchange (uriComponents .toUri (), HttpMethod .POST , requestEntity , JsonNode .class );
129
+ } catch (RestClientException e ) {
130
+ log .error ("Error occurred while executing REST POST to: " + erUrl + " for\n " + requestEntity , e );
155
131
}
156
- return uriParams ;
132
+
133
+ return null ;
157
134
}
158
135
159
- /** Create an array node with link types for upstream or downstream query
160
- * @param params
161
- * @param actionString
162
- * @param linkTypes
136
+ /**
137
+ * Build the search parameters to be used to query ER.
138
+ *
139
+ * @param searchOption
140
+ * one of UP_STREAM, DOWN_STREAM or UP_AND_DOWN_STREAM
141
+ * @return the search parameters to be used
163
142
*/
164
- public void putSearchParameter (JsonNode params , String actionString , String [] linkTypes ) {
165
- ArrayNode node =((ObjectNode ) params ).putArray (actionString );
166
- for (String string : linkTypes ) {
167
- node .add (string );
143
+ private SearchParameters getSearchParameters (SearchOption searchOption ) {
144
+ final SearchParameters searchParameters = new SearchParameters ();
145
+ final List <LinkType > allLinkTypes = Collections .singletonList (LinkType .ALL );
146
+ switch (searchOption ) {
147
+ case DOWN_STREAM :
148
+ searchParameters .setUlt (new ArrayList <>());
149
+ searchParameters .setDlt (allLinkTypes );
150
+ break ;
151
+ case UP_STREAM :
152
+ searchParameters .setUlt (allLinkTypes );
153
+ searchParameters .setDlt (new ArrayList <>());
154
+ break ;
155
+ case UP_AND_DOWN_STREAM :
156
+ searchParameters .setUlt (allLinkTypes );
157
+ searchParameters .setDlt (allLinkTypes );
158
+ break ;
168
159
}
160
+
161
+ return searchParameters ;
169
162
}
170
163
171
164
@ PostConstruct
172
165
public void init () {
166
+ // TODO: is this needed?
173
167
log .debug ("The url parameter is : " + url );
174
168
}
175
169
}
0 commit comments