Source code

001package org.hl7.fhir.r4.utils.client;
002
003
004
005
006
007/*
008  Copyright (c) 2011+, HL7, Inc.
009  All rights reserved.
010  
011  Redistribution and use in source and binary forms, with or without modification, 
012  are permitted provided that the following conditions are met:
013  
014   * Redistributions of source code must retain the above copyright notice, this 
015     list of conditions and the following disclaimer.
016   * Redistributions in binary form must reproduce the above copyright notice, 
017     this list of conditions and the following disclaimer in the documentation 
018     and/or other materials provided with the distribution.
019   * Neither the name of HL7 nor the names of its contributors may be used to 
020     endorse or promote products derived from this software without specific 
021     prior written permission.
022  
023  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
024  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
025  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
026  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
027  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
028  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
029  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
030  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
031  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
032  POSSIBILITY OF SUCH DAMAGE.
033  
034*/
035
036
037import org.apache.commons.lang3.StringUtils;
038import org.apache.http.client.utils.URIBuilder;
039import org.hl7.fhir.r4.model.Resource;
040import org.hl7.fhir.r4.model.ResourceType;
041import org.hl7.fhir.utilities.Utilities;
042
043import java.net.URI;
044import java.net.URISyntaxException;
045import java.text.SimpleDateFormat;
046import java.util.*;
047import java.util.regex.Matcher;
048import java.util.regex.Pattern;
049
050//Make resources address subclass of URI
051
052/**
053 * Helper class to manage FHIR Resource URIs
054 * 
055 * @author Claude Nanjo
056 *
057 */
058public class ResourceAddress {
059        
060        public static final String REGEX_ID_WITH_HISTORY = "(.*)(/)([a-zA-Z0-9]*)(/)([a-z0-9\\-\\.]{1,64})(/_history/)([a-z0-9\\-\\.]{1,64})$";
061        
062        private URI baseServiceUri;
063        
064        public ResourceAddress(String endpointPath) throws URISyntaxException {//TODO Revisit this exception
065                this.baseServiceUri = ResourceAddress.buildAbsoluteURI(endpointPath);
066        }
067        
068        public ResourceAddress(URI baseServiceUri) {
069                this.baseServiceUri = baseServiceUri;
070        }
071        
072        public URI getBaseServiceUri() {
073                return this.baseServiceUri;
074        }
075        
076        public <T extends Resource> URI resolveOperationURLFromClass(Class<T> resourceClass, String name, String parameters) {
077                return baseServiceUri.resolve(nameForClassWithSlash(resourceClass) +"$"+name+"?"+ parameters);
078        }
079        
080        public <T extends Resource> URI resolveSearchUri(Class<T> resourceClass, Map<String,String> parameters) {
081                return appendHttpParameters(baseServiceUri.resolve(nameForClassWithSlash(resourceClass) +"_search"), parameters);
082        }
083        
084  private <T extends Resource> String nameForClassWithSlash(Class<T> resourceClass) {
085    String n = nameForClass(resourceClass);
086    return n == null ? "" : n +"/";
087        }
088        
089  public <T extends Resource> URI resolveOperationUri(Class<T> resourceClass, String opName) {
090    return baseServiceUri.resolve(nameForClassWithSlash(resourceClass) +"/"+opName);
091  }
092  
093  public <T extends Resource> URI resolveOperationUri(Class<T> resourceClass, String opName, Map<String,String> parameters) {
094    return appendHttpParameters(baseServiceUri.resolve(nameForClassWithSlash(resourceClass) +"$"+opName), parameters);
095  }
096  
097        public <T extends Resource> URI resolveValidateUri(Class<T> resourceClass, String id) {
098                return baseServiceUri.resolve(nameForClassWithSlash(resourceClass) +"$validate/"+id);
099        }
100        
101        public <T extends Resource> URI resolveGetUriFromResourceClass(Class<T> resourceClass) {
102                return baseServiceUri.resolve(nameForClass(resourceClass));
103        }
104        
105        public <T extends Resource> URI resolveGetUriFromResourceClassAndId(Class<T> resourceClass, String id) {
106                return baseServiceUri.resolve(nameForClass(resourceClass) +"/"+id);
107        }
108        
109        public <T extends Resource> URI resolveGetUriFromResourceClassAndIdAndVersion(Class<T> resourceClass, String id, String version) {
110                return baseServiceUri.resolve(nameForClass(resourceClass) +"/"+id+"/_history/"+version);
111        }
112        
113  public <T extends Resource> URI resolveGetUriFromResourceClassAndCanonical(Class<T> resourceClass, String canonicalUrl) {
114    if (canonicalUrl.contains("|"))
115      return baseServiceUri.resolve(nameForClass(resourceClass)+"?url="+canonicalUrl.substring(0, canonicalUrl.indexOf("|"))+"&version="+canonicalUrl.substring(canonicalUrl.indexOf("|")+1));      
116    else
117      return baseServiceUri.resolve(nameForClass(resourceClass)+"?url="+canonicalUrl);
118  }
119  
120        public URI resolveGetHistoryForAllResources(int count) {
121                if(count > 0) {
122                        return appendHttpParameter(baseServiceUri.resolve("_history"), "_count", ""+count);
123                } else {
124                        return baseServiceUri.resolve("_history");
125                }
126}
127        
128        public <T extends Resource> URI resolveGetHistoryForResourceId(Class<T> resourceClass, String id, int count) {
129                return resolveGetHistoryUriForResourceId(resourceClass, id, null, count);
130        }
131        
132        protected <T extends Resource> URI resolveGetHistoryUriForResourceId(Class<T> resourceClass, String id, Object since, int count) {
133                Map<String,String>  parameters = getHistoryParameters(since, count);
134                return appendHttpParameters(baseServiceUri.resolve(nameForClass(resourceClass) + "/" + id + "/_history"), parameters);
135        }
136        
137        public <T extends Resource> URI resolveGetHistoryForResourceType(Class<T> resourceClass, int count) {
138                Map<String,String>  parameters = getHistoryParameters(null, count);
139                return appendHttpParameters(baseServiceUri.resolve(nameForClass(resourceClass) + "/_history"), parameters);
140        }
141        
142        public <T extends Resource> URI resolveGetHistoryForResourceType(Class<T> resourceClass, Object since, int count) {
143                Map<String,String>  parameters = getHistoryParameters(since, count);
144                return appendHttpParameters(baseServiceUri.resolve(nameForClass(resourceClass) + "/_history"), parameters);
145        }
146        
147        public URI resolveGetHistoryForAllResources(Calendar since, int count) {
148                Map<String,String>  parameters = getHistoryParameters(since, count);
149                return appendHttpParameters(baseServiceUri.resolve("_history"), parameters);
150        }
151        
152        public URI resolveGetHistoryForAllResources(Date since, int count) {
153                Map<String,String>  parameters = getHistoryParameters(since, count);
154                return appendHttpParameters(baseServiceUri.resolve("_history"), parameters);
155        }
156        
157        public Map<String,String> getHistoryParameters(Object since, int count) {
158                Map<String,String>  parameters = new HashMap<String,String>();
159                if (since != null) {
160                        parameters.put("_since", since.toString());
161                }
162                if(count > 0) {
163                        parameters.put("_count", ""+count);
164                }
165                return parameters;
166        }
167        
168        public <T extends Resource> URI resolveGetHistoryForResourceId(Class<T> resourceClass, String id, Calendar since, int count) {
169                return resolveGetHistoryUriForResourceId(resourceClass, id, since, count);
170        }
171        
172        public <T extends Resource> URI resolveGetHistoryForResourceId(Class<T> resourceClass, String id, Date since, int count) {
173                return resolveGetHistoryUriForResourceId(resourceClass, id, since, count);
174        }
175        
176        public <T extends Resource> URI resolveGetHistoryForResourceType(Class<T> resourceClass, Calendar since, int count) {
177                return resolveGetHistoryForResourceType(resourceClass, getCalendarDateInIsoTimeFormat(since), count);
178        }
179        
180        public <T extends Resource> URI resolveGetHistoryForResourceType(Class<T> resourceClass, Date since, int count) {
181                return resolveGetHistoryForResourceType(resourceClass, since.toString(), count);
182        }
183        
184        public <T extends Resource> URI resolveGetAllTags() {
185                return baseServiceUri.resolve("_tags");
186        }
187        
188        public <T extends Resource> URI resolveGetAllTagsForResourceType(Class<T> resourceClass) {
189                return baseServiceUri.resolve(nameForClass(resourceClass) + "/_tags");
190        }
191        
192        public <T extends Resource> URI resolveGetTagsForReference(Class<T> resourceClass, String id) {
193                return baseServiceUri.resolve(nameForClass(resourceClass) + "/" + id + "/_tags");
194        }
195        
196        public <T extends Resource> URI resolveGetTagsForResourceVersion(Class<T> resourceClass, String id, String version) {
197                return baseServiceUri.resolve(nameForClass(resourceClass) +"/"+id+"/_history/"+version + "/_tags");
198        }
199        
200        public <T extends Resource> URI resolveDeleteTagsForResourceVersion(Class<T> resourceClass, String id, String version) {
201                return baseServiceUri.resolve(nameForClass(resourceClass) +"/"+id+"/_history/"+version + "/_tags/_delete");
202        }
203        
204
205        public <T extends Resource> String nameForClass(Class<T> resourceClass) {
206          if (resourceClass == null)
207            return null;
208                String res = resourceClass.getSimpleName();
209                if (res.equals("List_"))
210                        return "List";
211                else
212                        return res;
213        }
214        
215  public URI resolveMetadataUri(boolean quick) {
216    return baseServiceUri.resolve(quick ? "metadata?_summary=true" : "metadata");
217  }
218  
219  public URI resolveMetadataTxCaps() {
220    return baseServiceUri.resolve("metadata?mode=terminology");
221  }
222  
223        /**
224         * For now, assume this type of location header structure.
225         * Generalize later: http://hl7connect.healthintersections.com.au/svc/fhir/318/_history/1
226         */
227        public static ResourceVersionedIdentifier parseCreateLocation(String locationResponseHeader) {
228                Pattern pattern = Pattern.compile(REGEX_ID_WITH_HISTORY);
229                Matcher matcher = pattern.matcher(locationResponseHeader);
230                ResourceVersionedIdentifier parsedHeader = null;
231                if(matcher.matches()){
232                        String serviceRoot = matcher.group(1);
233                        String resourceType = matcher.group(3);
234                        String id = matcher.group(5);
235                        String version = matcher.group(7);
236                        parsedHeader = new ResourceVersionedIdentifier(serviceRoot, resourceType, id, version);
237                }
238                return parsedHeader;
239        }
240        
241        public static URI buildAbsoluteURI(String absoluteURI) {
242                
243                if(StringUtils.isBlank(absoluteURI)) {
244                        throw new EFhirClientException("Invalid URI", new URISyntaxException(absoluteURI, "URI/URL cannot be blank"));
245                } 
246                
247                String endpoint = appendForwardSlashToPath(absoluteURI);
248
249                return buildEndpointUriFromString(endpoint);
250        }
251        
252        public static String appendForwardSlashToPath(String path) {
253                if(path.lastIndexOf('/') != path.length() - 1) {
254                        path += "/";
255                }
256                return path;
257        }
258        
259        public static URI buildEndpointUriFromString(String endpointPath) {
260                URI uri = null; 
261                try {
262                        URIBuilder uriBuilder = new URIBuilder(endpointPath);
263                        uri = uriBuilder.build();
264                        String scheme = uri.getScheme();
265                        String host = uri.getHost();
266                        if(!scheme.equalsIgnoreCase("http") && !scheme.equalsIgnoreCase("https")) {
267                                throw new EFhirClientException("Scheme must be 'http' or 'https': " + uri);
268                        }
269                        if(StringUtils.isBlank(host)) {
270                                throw new EFhirClientException("host cannot be blank: " + uri);
271                        }
272                } catch(URISyntaxException e) {
273                        throw new EFhirClientException("Invalid URI", e);
274                }
275                return uri;
276        }
277        
278        public static URI appendQueryStringToUri(URI uri, String parameterName, String parameterValue) {
279                URI modifiedUri = null;
280                try {
281                        URIBuilder uriBuilder = new URIBuilder(uri);
282                        uriBuilder.setQuery(parameterName + "=" + parameterValue);
283                        modifiedUri = uriBuilder.build();
284                } catch(Exception e) {
285                        throw new EFhirClientException("Unable to append query parameter '" + parameterName + "=" + parameterValue + " to URI " + uri, e);
286                }
287                return modifiedUri;
288        }
289        
290        public static String buildRelativePathFromResourceType(ResourceType resourceType) {
291                //return resourceType.toString().toLowerCase()+"/";
292                return resourceType.toString() + "/";
293        }
294        
295        public static String buildRelativePathFromResourceType(ResourceType resourceType, String id) {
296                return buildRelativePathFromResourceType(resourceType)+ "@" + id;
297        }
298        
299        public static String buildRelativePathFromReference(Resource resource) {
300                return buildRelativePathFromResourceType(resource.getResourceType());
301        }
302        
303        public static String buildRelativePathFromReference(Resource resource, String id) {
304                return buildRelativePathFromResourceType(resource.getResourceType(), id);
305        }
306        
307        public static class ResourceVersionedIdentifier {
308                
309                private String serviceRoot;
310                private String resourceType;
311                private String id;
312                private String version;
313                private URI resourceLocation;
314                
315                public ResourceVersionedIdentifier(String serviceRoot, String resourceType, String id, String version, URI resourceLocation) {
316                        this.serviceRoot = serviceRoot;
317                        this.resourceType = resourceType;
318                        this.id = id;
319                        this.version = version;
320                        this.resourceLocation = resourceLocation;
321                }
322                
323                public ResourceVersionedIdentifier(String resourceType, String id, String version, URI resourceLocation) {
324                        this(null, resourceType, id, version, resourceLocation);
325                }
326                
327                public ResourceVersionedIdentifier(String serviceRoot, String resourceType, String id, String version) {
328                        this(serviceRoot, resourceType, id, version, null);
329                }
330                
331                public ResourceVersionedIdentifier(String resourceType, String id, String version) {
332                        this(null, resourceType, id, version, null);
333                }
334                
335                public ResourceVersionedIdentifier(String resourceType, String id) {
336                        this.id = id;
337                }
338                
339                public String getId() {
340                        return this.id;
341                }
342                
343                protected void setId(String id) {
344                        this.id = id;
345                }
346                
347                public String getVersionId() {
348                        return this.version;
349                }
350                
351                protected void setVersionId(String version) {
352                        this.version = version;
353                }
354                
355                public String getResourceType() {
356                        return resourceType;
357                }
358
359                public void setResourceType(String resourceType) {
360                        this.resourceType = resourceType;
361                }
362                
363                public String getServiceRoot() {
364                        return serviceRoot;
365                }
366
367                public void setServiceRoot(String serviceRoot) {
368                        this.serviceRoot = serviceRoot;
369                }
370                
371                public String getResourcePath() {
372                        return this.serviceRoot + "/" + this.resourceType + "/" + this.id;
373                }
374
375                public String getVersion() {
376                        return version;
377                }
378
379                public void setVersion(String version) {
380                        this.version = version;
381                }
382
383                public URI getResourceLocation() {
384                        return this.resourceLocation;
385                }
386                
387                public void setResourceLocation(URI resourceLocation) {
388                        this.resourceLocation = resourceLocation;
389                }
390        }
391        
392        public static String getCalendarDateInIsoTimeFormat(Calendar calendar) {
393                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss", new Locale("en", "US"));//TODO Move out
394                format.setTimeZone(TimeZone.getTimeZone("GMT"));
395            return format.format(calendar.getTime());
396        }
397        
398        public static URI appendHttpParameter(URI basePath, String httpParameterName, String httpParameterValue) {
399                Map<String, String> parameters = new HashMap<String, String>();
400                parameters.put(httpParameterName, httpParameterValue);
401                return appendHttpParameters(basePath, parameters);
402        }
403        
404        public static URI appendHttpParameters(URI basePath, Map<String,String> parameters) {
405        try {
406                Set<String> httpParameterNames = parameters.keySet();
407                String query = basePath.getQuery();
408                
409                for(String httpParameterName : httpParameterNames) {
410                        if(query != null) {
411                                query += "&";
412                        } else {
413                                query = "";
414                        }
415                        query += httpParameterName + "=" + Utilities.encodeUri(parameters.get(httpParameterName));
416                }
417        
418                return new URI(basePath.getScheme(), basePath.getUserInfo(), basePath.getHost(),basePath.getPort(), basePath.getPath(), query, basePath.getFragment());
419        } catch(Exception e) {
420                throw new EFhirClientException("Error appending http parameter", e);
421        }
422    }
423        
424}