001package org.hl7.fhir.r5.utils.client;
002
003/*-
004 * #%L
005 * org.hl7.fhir.r5
006 * %%
007 * Copyright (C) 2014 - 2019 Health Level 7
008 * %%
009 * Licensed under the Apache License, Version 2.0 (the "License");
010 * you may not use this file except in compliance with the License.
011 * You may obtain a copy of the License at
012 * 
013 *      http://www.apache.org/licenses/LICENSE-2.0
014 * 
015 * Unless required by applicable law or agreed to in writing, software
016 * distributed under the License is distributed on an "AS IS" BASIS,
017 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
018 * See the License for the specific language governing permissions and
019 * limitations under the License.
020 * #L%
021 */
022
023
024
025/*
026  Copyright (c) 2011+, HL7, Inc.
027  All rights reserved.
028  
029  Redistribution and use in source and binary forms, with or without modification, 
030  are permitted provided that the following conditions are met:
031  
032   * Redistributions of source code must retain the above copyright notice, this 
033     list of conditions and the following disclaimer.
034   * Redistributions in binary form must reproduce the above copyright notice, 
035     this list of conditions and the following disclaimer in the documentation 
036     and/or other materials provided with the distribution.
037   * Neither the name of HL7 nor the names of its contributors may be used to 
038     endorse or promote products derived from this software without specific 
039     prior written permission.
040  
041  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
042  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
043  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
044  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
045  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
046  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
047  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
048  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
049  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
050  POSSIBILITY OF SUCH DAMAGE.
051  
052*/
053
054import java.net.URI;
055import java.net.URISyntaxException;
056import java.util.HashMap;
057import java.util.List;
058import java.util.Map;
059
060import org.apache.http.Header;
061import org.apache.http.HttpHost;
062import org.hl7.fhir.r5.model.Bundle;
063import org.hl7.fhir.r5.model.CapabilityStatement;
064import org.hl7.fhir.r5.model.CodeSystem;
065import org.hl7.fhir.r5.model.Coding;
066import org.hl7.fhir.r5.model.ConceptMap;
067import org.hl7.fhir.r5.model.OperationOutcome;
068import org.hl7.fhir.r5.model.Parameters;
069import org.hl7.fhir.r5.model.Parameters.ParametersParameterComponent;
070import org.hl7.fhir.r5.model.PrimitiveType;
071import org.hl7.fhir.r5.model.Resource;
072import org.hl7.fhir.r5.model.StringType;
073import org.hl7.fhir.r5.model.TerminologyCapabilities;
074import org.hl7.fhir.r5.model.ValueSet;
075import org.hl7.fhir.utilities.Utilities;
076
077/**
078 * Very Simple RESTful client. This is purely for use in the standalone 
079 * tools jar packages. It doesn't support many features, only what the tools
080 * need.
081 * 
082 * To use, initialize class and set base service URI as follows:
083 * 
084 * <pre><code>
085 * FHIRSimpleClient fhirClient = new FHIRSimpleClient();
086 * fhirClient.initialize("http://my.fhir.domain/myServiceRoot");
087 * </code></pre>
088 * 
089 * Default Accept and Content-Type headers are application/fhir+xml and application/fhir+json.
090 * 
091 * These can be changed by invoking the following setter functions:
092 * 
093 * <pre><code>
094 * setPreferredResourceFormat()
095 * setPreferredFeedFormat()
096 * </code></pre>
097 * 
098 * TODO Review all sad paths. 
099 * 
100 * @author Claude Nanjo
101 *
102 */
103public class FHIRToolingClient {
104        
105        public static final String DATETIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ssK";
106        public static final String DATE_FORMAT = "yyyy-MM-dd";
107        public static final String hostKey = "http.proxyHost";
108        public static final String portKey = "http.proxyPort";
109        
110        private String base;
111        private ResourceAddress resourceAddress;
112        private ResourceFormat preferredResourceFormat;
113        private int maxResultSetSize = -1;//_count
114        private CapabilityStatement capabilities;
115
116        private ClientUtils utils = new ClientUtils();
117        
118        //Pass enpoint for client - URI
119  public FHIRToolingClient(String baseServiceUrl) throws URISyntaxException {
120    preferredResourceFormat = ResourceFormat.RESOURCE_XML;
121    detectProxy();
122    initialize(baseServiceUrl);
123  }
124  
125  public FHIRToolingClient(String baseServiceUrl, String username, String password) throws URISyntaxException {
126    preferredResourceFormat = ResourceFormat.RESOURCE_XML;
127    utils.setUsername(username);
128    utils.setPassword(password);
129    detectProxy();
130    initialize(baseServiceUrl);
131  }
132  
133        public void configureProxy(String proxyHost, int proxyPort) {
134                utils.setProxy(new HttpHost(proxyHost, proxyPort));
135        }
136        
137        public void detectProxy() {
138                String host = System.getenv(hostKey);
139                String port = System.getenv(portKey);
140
141                if(host==null) {
142                        host = System.getProperty(hostKey);
143                }
144                
145                if(port==null) {
146                        port = System.getProperty(portKey);
147                }
148                
149                if(host!=null && port!=null) {
150                        this.configureProxy(host, Integer.parseInt(port));
151                }
152        }
153        
154        public void initialize(String baseServiceUrl)  throws URISyntaxException {
155          base = baseServiceUrl;
156                resourceAddress = new ResourceAddress(baseServiceUrl);
157                this.maxResultSetSize = -1;
158                checkCapabilities();
159        }
160        
161        private void checkCapabilities() {
162          try {
163      capabilities = getCapabilitiesStatementQuick();
164          } catch (Throwable e) {
165          }
166   }
167
168  public String getPreferredResourceFormat() {
169    return preferredResourceFormat.getHeader();
170  }
171  
172        public void setPreferredResourceFormat(ResourceFormat resourceFormat) {
173                preferredResourceFormat = resourceFormat;
174        }
175        
176        public int getMaximumRecordCount() {
177                return maxResultSetSize;
178        }
179        
180        public void setMaximumRecordCount(int maxResultSetSize) {
181                this.maxResultSetSize = maxResultSetSize;
182        }
183        
184        public TerminologyCapabilities getTerminologyCapabilities() {
185    return (TerminologyCapabilities) utils.issueGetResourceRequest(resourceAddress.resolveMetadataTxCaps(), getPreferredResourceFormat()).getReference();
186        }
187        
188        public CapabilityStatement getCapabilitiesStatement() {
189          CapabilityStatement conformance = null;
190                try {
191                conformance = (CapabilityStatement)utils.issueGetResourceRequest(resourceAddress.resolveMetadataUri(false), getPreferredResourceFormat()).getReference();
192                } catch(Exception e) {
193                        handleException("An error has occurred while trying to fetch the server's conformance statement", e);
194                }
195                return conformance;
196        }
197        
198  public CapabilityStatement getCapabilitiesStatementQuick() throws EFhirClientException {
199    if (capabilities != null)
200      return capabilities;
201    try {
202      capabilities = (CapabilityStatement)utils.issueGetResourceRequest(resourceAddress.resolveMetadataUri(true), getPreferredResourceFormat()).getReference();
203    } catch(Exception e) {
204      handleException("An error has occurred while trying to fetch the server's conformance statement", e);
205    }
206    return capabilities;
207  }
208  
209        public <T extends Resource> T read(Class<T> resourceClass, String id) {//TODO Change this to AddressableResource
210                ResourceRequest<T> result = null;
211                try {
212                        result = utils.issueGetResourceRequest(resourceAddress.resolveGetUriFromResourceClassAndId(resourceClass, id), getPreferredResourceFormat());
213                        result.addErrorStatus(410);//gone
214                        result.addErrorStatus(404);//unknown
215                        result.addSuccessStatus(200);//Only one for now
216                        if(result.isUnsuccessfulRequest()) {
217                                throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
218                        }
219                } catch (Exception e) {
220                        handleException("An error has occurred while trying to read this resource", e);
221                }
222                return result.getPayload();
223        }
224
225        public <T extends Resource> T vread(Class<T> resourceClass, String id, String version) {
226                ResourceRequest<T> result = null;
227                try {
228                        result = utils.issueGetResourceRequest(resourceAddress.resolveGetUriFromResourceClassAndIdAndVersion(resourceClass, id, version), getPreferredResourceFormat());
229                        result.addErrorStatus(410);//gone
230                        result.addErrorStatus(404);//unknown
231                        result.addErrorStatus(405);//unknown
232                        result.addSuccessStatus(200);//Only one for now
233                        if(result.isUnsuccessfulRequest()) {
234                                throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
235                        }
236                } catch (Exception e) {
237                        handleException("An error has occurred while trying to read this version of the resource", e);
238                }
239                return result.getPayload();
240        }
241        
242        // GET fhir/ValueSet?url=http://hl7.org/fhir/ValueSet/clinical-findings&version=0.8
243
244  public <T extends Resource> T getCanonical(Class<T> resourceClass, String canonicalURL) {
245    ResourceRequest<T> result = null;
246    try {
247      result = utils.issueGetResourceRequest(resourceAddress.resolveGetUriFromResourceClassAndCanonical(resourceClass, canonicalURL), getPreferredResourceFormat());
248      result.addErrorStatus(410);//gone
249      result.addErrorStatus(404);//unknown
250      result.addErrorStatus(405);//unknown
251      result.addSuccessStatus(200);//Only one for now
252      if(result.isUnsuccessfulRequest()) {
253        throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
254      }
255    } catch (Exception e) {
256      handleException("An error has occurred while trying to read this version of the resource", e);
257    }
258    Bundle bnd = (Bundle) result.getPayload();
259    if (bnd.getEntry().size() == 0)
260      throw new EFhirClientException("No matching resource found for canonical URL '"+canonicalURL+"'");
261    if (bnd.getEntry().size() > 1)
262      throw new EFhirClientException("Multiple matching resources found for canonical URL '"+canonicalURL+"'");
263    return (T) bnd.getEntry().get(0).getResource();
264  }
265  
266//      
267//      public <T extends Resource> T update(Class<T> resourceClass, T resource, String id) {
268//              ResourceRequest<T> result = null;
269//              try {
270//                      List<Header> headers = null;
271//                      result = utils.issuePutRequest(resourceAddress.resolveGetUriFromResourceClassAndId(resourceClass, id),utils.getResourceAsByteArray(resource, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers, proxy);
272//                      result.addErrorStatus(410);//gone
273//                      result.addErrorStatus(404);//unknown
274//                      result.addErrorStatus(405);
275//                      result.addErrorStatus(422);//Unprocessable Entity
276//                      result.addSuccessStatus(200);
277//                      result.addSuccessStatus(201);
278//                      if(result.isUnsuccessfulRequest()) {
279//                              throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
280//                      }
281//              } catch(Exception e) {
282//                      throw new EFhirClientException("An error has occurred while trying to update this resource", e);
283//              }
284//              // TODO oe 26.1.2015 could be made nicer if only OperationOutcome       locationheader is returned with an operationOutcome would be returned (and not  the resource also) we make another read
285//              try {
286//                OperationOutcome operationOutcome = (OperationOutcome)result.getPayload();
287//                ResourceAddress.ResourceVersionedIdentifier resVersionedIdentifier = ResourceAddress.parseCreateLocation(result.getLocation());
288//                return this.vread(resourceClass, resVersionedIdentifier.getId(),resVersionedIdentifier.getVersionId());
289//              } catch(ClassCastException e) {
290//                // if we fall throught we have the correct type already in the create
291//              }
292//
293//              return result.getPayload();
294//      }
295
296//      
297//      public <T extends Resource> boolean delete(Class<T> resourceClass, String id) {
298//              try {
299//                      return utils.issueDeleteRequest(resourceAddress.resolveGetUriFromResourceClassAndId(resourceClass, id), proxy);
300//              } catch(Exception e) {
301//                      throw new EFhirClientException("An error has occurred while trying to delete this resource", e);
302//              }
303//
304//      }
305
306//      
307//      public <T extends Resource> OperationOutcome create(Class<T> resourceClass, T resource) {
308//        ResourceRequest<T> resourceRequest = null;
309//        try {
310//          List<Header> headers = null;
311//          resourceRequest = utils.issuePostRequest(resourceAddress.resolveGetUriFromResourceClass(resourceClass),utils.getResourceAsByteArray(resource, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers, proxy);
312//          resourceRequest.addSuccessStatus(201);
313//          if(resourceRequest.isUnsuccessfulRequest()) {
314//            throw new EFhirClientException("Server responded with HTTP error code " + resourceRequest.getHttpStatus(), (OperationOutcome)resourceRequest.getPayload());
315//          }
316//        } catch(Exception e) {
317//          handleException("An error has occurred while trying to create this resource", e);
318//        }
319//        OperationOutcome operationOutcome = null;;
320//        try {
321//          operationOutcome = (OperationOutcome)resourceRequest.getPayload();
322//          ResourceAddress.ResourceVersionedIdentifier resVersionedIdentifier = 
323//              ResourceAddress.parseCreateLocation(resourceRequest.getLocation());
324//          OperationOutcomeIssueComponent issue = operationOutcome.addIssue();
325//          issue.setSeverity(IssueSeverity.INFORMATION);
326//          issue.setUserData(ResourceAddress.ResourceVersionedIdentifier.class.toString(),
327//              resVersionedIdentifier);
328//          return operationOutcome;
329//        } catch(ClassCastException e) {
330//          // some server (e.g. grahams) returns the resource directly
331//          operationOutcome = new OperationOutcome();
332//          OperationOutcomeIssueComponent issue = operationOutcome.addIssue();
333//          issue.setSeverity(IssueSeverity.INFORMATION);
334//          issue.setUserData(ResourceRequest.class.toString(),
335//              resourceRequest.getPayload());
336//          return operationOutcome;
337//        }     
338//      }
339
340//      
341//      public <T extends Resource> Bundle history(Calendar lastUpdate, Class<T> resourceClass, String id) {
342//              Bundle history = null;
343//              try {
344//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForResourceId(resourceClass, id, lastUpdate, maxResultSetSize), getPreferredResourceFormat(), proxy);
345//              } catch (Exception e) {
346//                      handleException("An error has occurred while trying to retrieve history information for this resource", e);
347//              }
348//              return history;
349//      }
350
351//      
352//      public <T extends Resource> Bundle history(Date lastUpdate, Class<T> resourceClass, String id) {
353//              Bundle history = null;
354//              try {
355//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForResourceId(resourceClass, id, lastUpdate, maxResultSetSize), getPreferredResourceFormat(), proxy);
356//              } catch (Exception e) {
357//                      handleException("An error has occurred while trying to retrieve history information for this resource", e);
358//              }
359//              return history;
360//      }
361//
362//      
363//      public <T extends Resource> Bundle history(Calendar lastUpdate, Class<T> resourceClass) {
364//              Bundle history = null;
365//              try {
366//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForResourceType(resourceClass, lastUpdate, maxResultSetSize), getPreferredResourceFormat(), proxy);
367//              } catch (Exception e) {
368//                      handleException("An error has occurred while trying to retrieve history information for this resource type", e);
369//              }
370//              return history;
371//      }
372//      
373//      
374//      public <T extends Resource> Bundle history(Date lastUpdate, Class<T> resourceClass) {
375//              Bundle history = null;
376//              try {
377//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForResourceType(resourceClass, lastUpdate, maxResultSetSize), getPreferredResourceFormat(), proxy);
378//              } catch (Exception e) {
379//                      handleException("An error has occurred while trying to retrieve history information for this resource type", e);
380//              }
381//              return history;
382//      }
383//      
384//      
385//      public <T extends Resource> Bundle history(Class<T> resourceClass) {
386//              Bundle history = null;
387//              try {
388//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForResourceType(resourceClass, maxResultSetSize), getPreferredResourceFormat(), proxy);
389//              } catch (Exception e) {
390//                      handleException("An error has occurred while trying to retrieve history information for this resource type", e);
391//              }
392//              return history;
393//      }
394//      
395//      
396//      public <T extends Resource> Bundle history(Class<T> resourceClass, String id) {
397//              Bundle history = null;
398//              try {
399//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForResourceId(resourceClass, id, maxResultSetSize), getPreferredResourceFormat(), proxy);
400//              } catch (Exception e) {
401//                      handleException("An error has occurred while trying to retrieve history information for this resource", e);
402//              }
403//              return history;
404//      }
405//
406//      
407//      public <T extends Resource> Bundle history(Date lastUpdate) {
408//              Bundle history = null;
409//              try {
410//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForAllResources(lastUpdate, maxResultSetSize), getPreferredResourceFormat(), proxy);
411//              } catch (Exception e) {
412//                      handleException("An error has occurred while trying to retrieve history since last update",e);
413//              }
414//              return history;
415//      }
416//
417//      
418//      public <T extends Resource> Bundle history(Calendar lastUpdate) {
419//              Bundle history = null;
420//              try {
421//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForAllResources(lastUpdate, maxResultSetSize), getPreferredResourceFormat(), proxy);
422//              } catch (Exception e) {
423//                      handleException("An error has occurred while trying to retrieve history since last update",e);
424//              }
425//              return history;
426//      }
427//
428//      
429//      public <T extends Resource> Bundle history() {
430//              Bundle history = null;
431//              try {
432//                      history = utils.issueGetFeedRequest(resourceAddress.resolveGetHistoryForAllResources(maxResultSetSize), getPreferredResourceFormat(), proxy);
433//              } catch (Exception e) {
434//                      handleException("An error has occurred while trying to retrieve history since last update",e);
435//              }
436//              return history;
437//      }
438//
439//      
440//      public <T extends Resource> Bundle search(Class<T> resourceClass, Map<String, String> parameters) {
441//              Bundle searchResults = null;
442//              try {
443//                      searchResults = utils.issueGetFeedRequest(resourceAddress.resolveSearchUri(resourceClass, parameters), getPreferredResourceFormat(), proxy);
444//              } catch (Exception e) {
445//                      handleException("Error performing search with parameters " + parameters, e);
446//              }
447//              return searchResults;
448//      }
449//      
450//  
451//  public <T extends Resource> Bundle searchPost(Class<T> resourceClass, T resource, Map<String, String> parameters) {
452//    Bundle searchResults = null;
453//    try {
454//      searchResults = utils.issuePostFeedRequest(resourceAddress.resolveSearchUri(resourceClass, new HashMap<String, String>()), parameters, "src", resource, getPreferredResourceFormat());
455//    } catch (Exception e) {
456//      handleException("Error performing search with parameters " + parameters, e);
457//    }
458//    return searchResults;
459//  }
460        
461        
462  public <T extends Resource> Parameters operateType(Class<T> resourceClass, String name, Parameters params) {
463        boolean complex = false;
464        for (ParametersParameterComponent p : params.getParameter())
465                complex = complex || !(p.getValue() instanceof PrimitiveType);
466        Parameters searchResults = null;
467                        String ps = "";
468                try {
469      if (!complex)
470                        for (ParametersParameterComponent p : params.getParameter())
471                        if (p.getValue() instanceof PrimitiveType)
472                          ps += p.getName() + "=" + Utilities.encodeUri(((PrimitiveType) p.getValue()).asStringValue())+"&";
473                ResourceRequest<T> result;
474                if (complex)
475                        result = utils.issuePostRequest(resourceAddress.resolveOperationURLFromClass(resourceClass, name, ps), utils.getResourceAsByteArray(params, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat());
476                else 
477                        result = utils.issueGetResourceRequest(resourceAddress.resolveOperationURLFromClass(resourceClass, name, ps), getPreferredResourceFormat());
478                        result.addErrorStatus(410);//gone
479                        result.addErrorStatus(404);//unknown
480                        result.addSuccessStatus(200);//Only one for now
481                        if(result.isUnsuccessfulRequest()) 
482                                throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
483                if (result.getPayload() instanceof Parameters)
484                        return (Parameters) result.getPayload();
485                else {
486                        Parameters p_out = new Parameters();
487                        p_out.addParameter().setName("return").setResource(result.getPayload());
488                        return p_out;
489                }
490                } catch (Exception e) {
491                        handleException("Error performing operation '"+name+"' with parameters " + ps, e);              
492                }
493                return null;
494  }
495
496  
497        public Bundle transaction(Bundle batch) {
498                Bundle transactionResult = null;
499                try {
500                        transactionResult = utils.postBatchRequest(resourceAddress.getBaseServiceUri(), utils.getFeedAsByteArray(batch, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat());
501                } catch (Exception e) {
502                        handleException("An error occurred trying to process this transaction request", e);
503                }
504                return transactionResult;
505        }
506        
507        @SuppressWarnings("unchecked")
508        
509        public <T extends Resource> OperationOutcome validate(Class<T> resourceClass, T resource, String id) {
510                ResourceRequest<T> result = null;
511                try {
512                        result = utils.issuePostRequest(resourceAddress.resolveValidateUri(resourceClass, id), utils.getResourceAsByteArray(resource, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat());
513                        result.addErrorStatus(400);//gone
514                        result.addErrorStatus(422);//Unprocessable Entity
515                        result.addSuccessStatus(200);//OK
516                        if(result.isUnsuccessfulRequest()) {
517                                throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
518                        }
519                } catch(Exception e) {
520                        handleException("An error has occurred while trying to validate this resource", e);
521                }
522                return (OperationOutcome)result.getPayload();
523        }
524        
525        /* change to meta operations
526        
527        public List<Coding> getAllTags() {
528                TagListRequest result = null;
529                try {
530                        result = utils.issueGetRequestForTagList(resourceAddress.resolveGetAllTags(), getPreferredResourceFormat(), null, proxy);
531                } catch (Exception e) {
532                        handleException("An error has occurred while trying to retrieve all tags", e);
533                }
534                return result.getPayload();
535        }
536        
537        
538        public <T extends Resource> List<Coding> getAllTagsForResourceType(Class<T> resourceClass) {
539                TagListRequest result = null;
540                try {
541                        result = utils.issueGetRequestForTagList(resourceAddress.resolveGetAllTagsForResourceType(resourceClass), getPreferredResourceFormat(), null, proxy);
542                } catch (Exception e) {
543                        handleException("An error has occurred while trying to retrieve tags for this resource type", e);
544                }
545                return result.getPayload();
546        }
547        
548        
549        public <T extends Resource> List<Coding> getTagsForReference(Class<T> resource, String id) {
550                TagListRequest result = null;
551                try {
552                        result = utils.issueGetRequestForTagList(resourceAddress.resolveGetTagsForReference(resource, id), getPreferredResourceFormat(), null, proxy);
553                } catch (Exception e) {
554                        handleException("An error has occurred while trying to retrieve tags for this resource", e);
555                }
556                return result.getPayload();
557        }
558        
559        
560        public <T extends Resource> List<Coding> getTagsForResourceVersion(Class<T> resource, String id, String versionId) {
561                TagListRequest result = null;
562                try {
563                        result = utils.issueGetRequestForTagList(resourceAddress.resolveGetTagsForResourceVersion(resource, id, versionId), getPreferredResourceFormat(), null, proxy);
564                } catch (Exception e) {
565                        handleException("An error has occurred while trying to retrieve tags for this resource version", e);
566                }
567                return result.getPayload();
568        }
569        
570//      
571//      public <T extends Resource> boolean deleteTagsForReference(Class<T> resourceClass, String id) {
572//              try {
573//                      return utils.issueDeleteRequest(resourceAddress.resolveGetTagsForReference(resourceClass, id), proxy);
574//              } catch(Exception e) {
575//                      handleException("An error has occurred while trying to retrieve tags for this resource version", e);
576//                      throw new EFhirClientException("An error has occurred while trying to delete this resource", e);
577//              }
578//
579//      }
580//      
581//      
582//      public <T extends Resource> boolean deleteTagsForResourceVersion(Class<T> resourceClass, String id, List<Coding> tags, String version) {
583//              try {
584//                      return utils.issueDeleteRequest(resourceAddress.resolveGetTagsForResourceVersion(resourceClass, id, version), proxy);
585//              } catch(Exception e) {
586//                      handleException("An error has occurred while trying to retrieve tags for this resource version", e);
587//                      throw new EFhirClientException("An error has occurred while trying to delete this resource", e);
588//              }
589//      }
590        
591        
592        public <T extends Resource> List<Coding> createTags(List<Coding> tags, Class<T> resourceClass, String id) {
593                TagListRequest request = null;
594                try {
595                        request = utils.issuePostRequestForTagList(resourceAddress.resolveGetTagsForReference(resourceClass, id),utils.getTagListAsByteArray(tags, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), null, proxy);
596                        request.addSuccessStatus(201);
597                        request.addSuccessStatus(200);
598                        if(request.isUnsuccessfulRequest()) {
599                                throw new EFhirClientException("Server responded with HTTP error code " + request.getHttpStatus());
600                        }
601                } catch(Exception e) {
602                        handleException("An error has occurred while trying to set tags for this resource", e);
603                }
604                return request.getPayload();
605        }
606        
607        
608        public <T extends Resource> List<Coding> createTags(List<Coding> tags, Class<T> resourceClass, String id, String version) {
609                TagListRequest request = null;
610                try {
611                        request = utils.issuePostRequestForTagList(resourceAddress.resolveGetTagsForResourceVersion(resourceClass, id, version),utils.getTagListAsByteArray(tags, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), null, proxy);
612                        request.addSuccessStatus(201);
613                        request.addSuccessStatus(200);
614                        if(request.isUnsuccessfulRequest()) {
615                                throw new EFhirClientException("Server responded with HTTP error code " + request.getHttpStatus());
616                        }
617                } catch(Exception e) {
618                        handleException("An error has occurred while trying to set the tags for this resource version", e);
619                }
620                return request.getPayload();
621        }
622
623        
624        public <T extends Resource> List<Coding> deleteTags(List<Coding> tags, Class<T> resourceClass, String id, String version) {
625                TagListRequest request = null;
626                try {
627                        request = utils.issuePostRequestForTagList(resourceAddress.resolveDeleteTagsForResourceVersion(resourceClass, id, version),utils.getTagListAsByteArray(tags, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), null, proxy);
628                        request.addSuccessStatus(201);
629                        request.addSuccessStatus(200);
630                        if(request.isUnsuccessfulRequest()) {
631                                throw new EFhirClientException("Server responded with HTTP error code " + request.getHttpStatus());
632                        }
633                } catch(Exception e) {
634                        handleException("An error has occurred while trying to delete the tags for this resource version", e);
635                }
636                return request.getPayload();
637        }
638        */
639
640        /**
641         * Helper method to prevent nesting of previously thrown EFhirClientExceptions
642         * 
643         * @param e
644         * @throws EFhirClientException
645         */
646        protected void handleException(String message, Exception e) throws EFhirClientException {
647                if(e instanceof EFhirClientException) {
648                        throw (EFhirClientException)e;
649                } else {
650                        throw new EFhirClientException(message, e);
651                }
652        }
653        
654        /**
655         * Helper method to determine whether desired resource representation
656         * is Json or XML.
657         * 
658         * @param format
659         * @return
660         */
661        protected boolean isJson(String format) {
662                boolean isJson = false;
663                if(format.toLowerCase().contains("json")) {
664                        isJson = true;
665                }
666                return isJson;
667        }
668                
669  public Bundle fetchFeed(String url) {
670                Bundle feed = null;
671                try {
672                        feed = utils.issueGetFeedRequest(new URI(url), getPreferredResourceFormat());
673                } catch (Exception e) {
674                        handleException("An error has occurred while trying to retrieve history since last update",e);
675                }
676                return feed;
677  }
678  
679  public ValueSet expandValueset(ValueSet source, Parameters expParams) {
680    List<Header> headers = null;
681    Parameters p = expParams == null ? new Parameters() : expParams.copy();
682    p.addParameter().setName("valueSet").setResource(source);
683    ResourceRequest<Resource> result = utils.issuePostRequest(resourceAddress.resolveOperationUri(ValueSet.class, "expand"), 
684        utils.getResourceAsByteArray(p, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers);
685    result.addErrorStatus(410);//gone
686    result.addErrorStatus(404);//unknown
687    result.addErrorStatus(405);
688    result.addErrorStatus(422);//Unprocessable Entity
689    result.addSuccessStatus(200);
690    result.addSuccessStatus(201);
691    if(result.isUnsuccessfulRequest()) {
692      throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
693    }
694    return (ValueSet) result.getPayload();
695  }
696
697  
698  public Parameters lookupCode(Map<String, String> params) {
699    ResourceRequest<Resource> result = utils.issueGetResourceRequest(resourceAddress.resolveOperationUri(CodeSystem.class, "lookup", params), getPreferredResourceFormat());
700    result.addErrorStatus(410);//gone
701    result.addErrorStatus(404);//unknown
702    result.addErrorStatus(405);
703    result.addErrorStatus(422);//Unprocessable Entity
704    result.addSuccessStatus(200);
705    result.addSuccessStatus(201);
706    if(result.isUnsuccessfulRequest()) {
707      throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
708    }
709    return (Parameters) result.getPayload();
710  }
711  public ValueSet expandValueset(ValueSet source, Parameters expParams, Map<String, String> params) {
712    List<Header> headers = null;
713    Parameters p = expParams == null ? new Parameters() : expParams.copy();
714    p.addParameter().setName("valueSet").setResource(source);
715    for (String n : params.keySet())
716      p.addParameter().setName(n).setValue(new StringType(params.get(n)));
717    ResourceRequest<Resource> result = utils.issuePostRequest(resourceAddress.resolveOperationUri(ValueSet.class, "expand", params), 
718        utils.getResourceAsByteArray(p, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers);
719    result.addErrorStatus(410);//gone
720    result.addErrorStatus(404);//unknown
721    result.addErrorStatus(405);
722    result.addErrorStatus(422);//Unprocessable Entity
723    result.addSuccessStatus(200);
724    result.addSuccessStatus(201);
725    if(result.isUnsuccessfulRequest()) {
726      throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
727    }
728    return (ValueSet) result.getPayload();
729  }
730  
731//  public ValueSet expandValueset(ValueSet source, ExpansionProfile profile, Map<String, String> params) {
732//    List<Header> headers = null;
733//    ResourceRequest<Resource> result = utils.issuePostRequest(resourceAddress.resolveOperationUri(ValueSet.class, "expand", params), 
734//        utils.getResourceAsByteArray(source, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers, proxy);
735//    result.addErrorStatus(410);//gone
736//    result.addErrorStatus(404);//unknown
737//    result.addErrorStatus(405);
738//    result.addErrorStatus(422);//Unprocessable Entity
739//    result.addSuccessStatus(200);
740//    result.addSuccessStatus(201);
741//    if(result.isUnsuccessfulRequest()) {
742//      throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
743//    }
744//    return (ValueSet) result.getPayload();
745//  }
746  
747  
748  public String getAddress() {
749    return base;
750  }
751
752  public ConceptMap initializeClosure(String name) {
753    Parameters params = new Parameters();
754    params.addParameter().setName("name").setValue(new StringType(name));
755    List<Header> headers = null;
756    ResourceRequest<Resource> result = utils.issuePostRequest(resourceAddress.resolveOperationUri(null, "closure", new HashMap<String, String>()),
757        utils.getResourceAsByteArray(params, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers);
758    result.addErrorStatus(410);//gone
759    result.addErrorStatus(404);//unknown
760    result.addErrorStatus(405);
761    result.addErrorStatus(422);//Unprocessable Entity
762    result.addSuccessStatus(200);
763    result.addSuccessStatus(201);
764    if(result.isUnsuccessfulRequest()) {
765      throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
766    }
767    return (ConceptMap) result.getPayload();
768  }
769
770  public ConceptMap updateClosure(String name, Coding coding) {
771    Parameters params = new Parameters();
772    params.addParameter().setName("name").setValue(new StringType(name));
773    params.addParameter().setName("concept").setValue(coding);
774    List<Header> headers = null;
775    ResourceRequest<Resource> result = utils.issuePostRequest(resourceAddress.resolveOperationUri(null, "closure", new HashMap<String, String>()),
776        utils.getResourceAsByteArray(params, false, isJson(getPreferredResourceFormat())), getPreferredResourceFormat(), headers);
777    result.addErrorStatus(410);//gone
778    result.addErrorStatus(404);//unknown
779    result.addErrorStatus(405);
780    result.addErrorStatus(422);//Unprocessable Entity
781    result.addSuccessStatus(200);
782    result.addSuccessStatus(201);
783    if(result.isUnsuccessfulRequest()) {
784      throw new EFhirClientException("Server returned error code " + result.getHttpStatus(), (OperationOutcome)result.getPayload());
785    }
786    return (ConceptMap) result.getPayload();
787  }
788
789  public int getTimeout() {
790    return utils.getTimeout();
791  }
792
793  public void setTimeout(int timeout) {
794    utils.setTimeout(timeout);
795  }
796
797  public String getUsername() {
798    return utils.getUsername();
799  }
800
801  public void setUsername(String username) {
802    utils.setUsername(username);
803  }
804
805  public String getPassword() {
806    return utils.getPassword();
807  }
808
809  public void setPassword(String password) {
810    utils.setPassword(password);
811  }
812
813  public ToolingClientLogger getLogger() {
814    return utils.getLogger();
815  }
816
817  public void setLogger(ToolingClientLogger logger) {
818    utils.setLogger(logger);
819  }
820
821
822}