001/* 002 * #%L 003 * HAPI FHIR - Server Framework 004 * %% 005 * Copyright (C) 2014 - 2024 Smile CDR, Inc. 006 * %% 007 * Licensed under the Apache License, Version 2.0 (the "License"); 008 * you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at 010 * 011 * http://www.apache.org/licenses/LICENSE-2.0 012 * 013 * Unless required by applicable law or agreed to in writing, software 014 * distributed under the License is distributed on an "AS IS" BASIS, 015 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 016 * See the License for the specific language governing permissions and 017 * limitations under the License. 018 * #L% 019 */ 020package ca.uhn.fhir.rest.server; 021 022import ca.uhn.fhir.context.FhirContext; 023import ca.uhn.fhir.context.FhirVersionEnum; 024import ca.uhn.fhir.i18n.Msg; 025import ca.uhn.fhir.interceptor.api.HookParams; 026import ca.uhn.fhir.interceptor.api.Pointcut; 027import ca.uhn.fhir.model.api.IResource; 028import ca.uhn.fhir.model.api.Include; 029import ca.uhn.fhir.model.api.ResourceMetadataKeyEnum; 030import ca.uhn.fhir.model.primitive.InstantDt; 031import ca.uhn.fhir.parser.IParser; 032import ca.uhn.fhir.rest.api.BundleLinks; 033import ca.uhn.fhir.rest.api.Constants; 034import ca.uhn.fhir.rest.api.DeleteCascadeModeEnum; 035import ca.uhn.fhir.rest.api.EncodingEnum; 036import ca.uhn.fhir.rest.api.PreferHandlingEnum; 037import ca.uhn.fhir.rest.api.PreferHeader; 038import ca.uhn.fhir.rest.api.PreferReturnEnum; 039import ca.uhn.fhir.rest.api.RequestTypeEnum; 040import ca.uhn.fhir.rest.api.RestOperationTypeEnum; 041import ca.uhn.fhir.rest.api.SummaryEnum; 042import ca.uhn.fhir.rest.api.server.IRestfulResponse; 043import ca.uhn.fhir.rest.api.server.IRestfulServer; 044import ca.uhn.fhir.rest.api.server.RequestDetails; 045import ca.uhn.fhir.rest.server.exceptions.InternalErrorException; 046import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException; 047import ca.uhn.fhir.rest.server.method.ElementsParameter; 048import ca.uhn.fhir.rest.server.method.SummaryEnumParameter; 049import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails; 050import ca.uhn.fhir.util.BinaryUtil; 051import ca.uhn.fhir.util.DateUtils; 052import ca.uhn.fhir.util.UrlUtil; 053import com.google.common.collect.Maps; 054import com.google.common.collect.Sets; 055import jakarta.annotation.Nonnull; 056import jakarta.annotation.Nullable; 057import jakarta.servlet.http.HttpServletRequest; 058import org.apache.commons.lang3.StringUtils; 059import org.apache.commons.lang3.math.NumberUtils; 060import org.hl7.fhir.instance.model.api.IAnyResource; 061import org.hl7.fhir.instance.model.api.IBaseBinary; 062import org.hl7.fhir.instance.model.api.IBaseReference; 063import org.hl7.fhir.instance.model.api.IBaseResource; 064import org.hl7.fhir.instance.model.api.IDomainResource; 065import org.hl7.fhir.instance.model.api.IIdType; 066import org.hl7.fhir.instance.model.api.IPrimitiveType; 067 068import java.io.IOException; 069import java.io.OutputStream; 070import java.io.Writer; 071import java.util.Arrays; 072import java.util.Collections; 073import java.util.Date; 074import java.util.EnumSet; 075import java.util.Enumeration; 076import java.util.HashMap; 077import java.util.HashSet; 078import java.util.Iterator; 079import java.util.List; 080import java.util.Map; 081import java.util.Objects; 082import java.util.Set; 083import java.util.StringTokenizer; 084import java.util.TreeSet; 085import java.util.regex.Matcher; 086import java.util.regex.Pattern; 087import java.util.stream.Collectors; 088 089import static org.apache.commons.lang3.StringUtils.isBlank; 090import static org.apache.commons.lang3.StringUtils.isNotBlank; 091import static org.apache.commons.lang3.StringUtils.replace; 092import static org.apache.commons.lang3.StringUtils.trim; 093 094public class RestfulServerUtils { 095 static final Pattern ACCEPT_HEADER_PATTERN = 096 Pattern.compile("\\s*([a-zA-Z0-9+.*/-]+)\\s*(;\\s*([a-zA-Z]+)\\s*=\\s*([a-zA-Z0-9.]+)\\s*)?(,?)"); 097 098 private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(RestfulServerUtils.class); 099 100 private static final HashSet<String> TEXT_ENCODE_ELEMENTS = 101 new HashSet<>(Arrays.asList("*.text", "*.id", "*.meta", "*.(mandatory)")); 102 private static Map<FhirVersionEnum, FhirContext> myFhirContextMap = Collections.synchronizedMap(new HashMap<>()); 103 private static EnumSet<RestOperationTypeEnum> ourOperationsWhichAllowPreferHeader = 104 EnumSet.of(RestOperationTypeEnum.CREATE, RestOperationTypeEnum.UPDATE, RestOperationTypeEnum.PATCH); 105 106 @SuppressWarnings("EnumSwitchStatementWhichMissesCases") 107 public static void configureResponseParser(RequestDetails theRequestDetails, IParser parser) { 108 // Pretty print 109 boolean prettyPrint = RestfulServerUtils.prettyPrintResponse(theRequestDetails.getServer(), theRequestDetails); 110 111 parser.setPrettyPrint(prettyPrint); 112 parser.setServerBaseUrl(theRequestDetails.getFhirServerBase()); 113 114 // Summary mode 115 Set<SummaryEnum> summaryMode = RestfulServerUtils.determineSummaryMode(theRequestDetails); 116 117 // _elements 118 Set<String> elements = ElementsParameter.getElementsValueOrNull(theRequestDetails, false); 119 if (elements != null && !summaryMode.equals(Collections.singleton(SummaryEnum.FALSE))) { 120 throw new InvalidRequestException(Msg.code(304) + "Cannot combine the " + Constants.PARAM_SUMMARY + " and " 121 + Constants.PARAM_ELEMENTS + " parameters"); 122 } 123 124 // _elements:exclude 125 Set<String> elementsExclude = ElementsParameter.getElementsValueOrNull(theRequestDetails, true); 126 if (elementsExclude != null) { 127 parser.setDontEncodeElements(elementsExclude); 128 } 129 130 boolean summaryModeCount = summaryMode.contains(SummaryEnum.COUNT) && summaryMode.size() == 1; 131 if (!summaryModeCount) { 132 String[] countParam = theRequestDetails.getParameters().get(Constants.PARAM_COUNT); 133 if (countParam != null && countParam.length > 0) { 134 summaryModeCount = "0".equalsIgnoreCase(countParam[0]); 135 } 136 } 137 138 if (summaryModeCount) { 139 parser.setEncodeElements(Sets.newHashSet("Bundle.total", "Bundle.type")); 140 } else if (summaryMode.contains(SummaryEnum.TEXT) && summaryMode.size() == 1) { 141 parser.setEncodeElements(TEXT_ENCODE_ELEMENTS); 142 parser.setEncodeElementsAppliesToChildResourcesOnly(true); 143 } else { 144 parser.setSuppressNarratives(summaryMode.contains(SummaryEnum.DATA)); 145 parser.setSummaryMode(summaryMode.contains(SummaryEnum.TRUE)); 146 } 147 148 if (elements != null && elements.size() > 0) { 149 String elementsAppliesTo = "*"; 150 if (isNotBlank(theRequestDetails.getResourceName())) { 151 elementsAppliesTo = theRequestDetails.getResourceName(); 152 } 153 154 Set<String> newElements = new HashSet<>(); 155 for (String next : elements) { 156 if (isNotBlank(next)) { 157 if (Character.isUpperCase(next.charAt(0))) { 158 newElements.add(next); 159 } else { 160 newElements.add(elementsAppliesTo + "." + next); 161 } 162 } 163 } 164 165 /* 166 * We try to be smart about what the user is asking for 167 * when they include an _elements parameter. If we're responding 168 * to something that returns a Bundle (e.g. a search) we assume 169 * the elements don't apply to the Bundle itself, unless 170 * the client has explicitly scoped the Bundle 171 * (i.e. with Bundle.total or something like that) 172 */ 173 boolean haveExplicitBundleElement = false; 174 for (String next : newElements) { 175 if (next.startsWith("Bundle.")) { 176 haveExplicitBundleElement = true; 177 break; 178 } 179 } 180 181 if (theRequestDetails.getRestOperationType() != null) { 182 switch (theRequestDetails.getRestOperationType()) { 183 case SEARCH_SYSTEM: 184 case SEARCH_TYPE: 185 case HISTORY_SYSTEM: 186 case HISTORY_TYPE: 187 case HISTORY_INSTANCE: 188 case GET_PAGE: 189 if (!haveExplicitBundleElement) { 190 parser.setEncodeElementsAppliesToChildResourcesOnly(true); 191 } 192 break; 193 default: 194 break; 195 } 196 } 197 198 parser.setEncodeElements(newElements); 199 } 200 } 201 202 public static String createLinkSelf(String theServerBase, RequestDetails theRequest) { 203 return createLinkSelfWithoutGivenParameters(theServerBase, theRequest, null); 204 } 205 206 /** 207 * This function will create a self link but omit any parameters passed in via the excludedParameterNames list. 208 */ 209 public static String createLinkSelfWithoutGivenParameters( 210 String theServerBase, RequestDetails theRequest, List<String> excludedParameterNames) { 211 String tenantId = StringUtils.defaultString(theRequest.getTenantId()); 212 String requestPath = StringUtils.defaultString(theRequest.getRequestPath()); 213 214 StringBuilder b = new StringBuilder(); 215 b.append(theServerBase); 216 requestPath = StringUtils.substringAfter(requestPath, tenantId); 217 218 if (isNotBlank(requestPath)) { 219 requestPath = StringUtils.prependIfMissing(requestPath, "/"); 220 } 221 222 b.append(requestPath); 223 224 // For POST the URL parameters get jumbled with the post body parameters so don't include them, they might be 225 // huge 226 if (theRequest.getRequestType() == RequestTypeEnum.GET) { 227 boolean first = true; 228 Map<String, String[]> parameters = theRequest.getParameters(); 229 for (String nextParamName : new TreeSet<>(parameters.keySet())) { 230 if (excludedParameterNames == null || !excludedParameterNames.contains(nextParamName)) { 231 for (String nextParamValue : parameters.get(nextParamName)) { 232 if (first) { 233 b.append('?'); 234 first = false; 235 } else { 236 b.append('&'); 237 } 238 b.append(UrlUtil.escapeUrlParam(nextParamName)); 239 b.append('='); 240 b.append(UrlUtil.escapeUrlParam(nextParamValue)); 241 } 242 } 243 } 244 } 245 return b.toString(); 246 } 247 248 public static String createOffsetPagingLink( 249 BundleLinks theBundleLinks, 250 String requestPath, 251 String tenantId, 252 Integer theOffset, 253 Integer theCount, 254 Map<String, String[]> theRequestParameters) { 255 StringBuilder b = new StringBuilder(); 256 b.append(theBundleLinks.serverBase); 257 258 if (isNotBlank(requestPath)) { 259 b.append('/'); 260 if (isNotBlank(tenantId) && requestPath.startsWith(tenantId + "/")) { 261 b.append(requestPath.substring(tenantId.length() + 1)); 262 } else { 263 b.append(requestPath); 264 } 265 } 266 267 Map<String, String[]> params = Maps.newLinkedHashMap(theRequestParameters); 268 params.put(Constants.PARAM_OFFSET, new String[] {String.valueOf(theOffset)}); 269 params.put(Constants.PARAM_COUNT, new String[] {String.valueOf(theCount)}); 270 271 boolean first = true; 272 for (String nextParamName : new TreeSet<>(params.keySet())) { 273 for (String nextParamValue : params.get(nextParamName)) { 274 if (first) { 275 b.append('?'); 276 first = false; 277 } else { 278 b.append('&'); 279 } 280 b.append(UrlUtil.escapeUrlParam(nextParamName)); 281 b.append('='); 282 b.append(UrlUtil.escapeUrlParam(nextParamValue)); 283 } 284 } 285 286 return b.toString(); 287 } 288 289 public static String createPagingLink( 290 BundleLinks theBundleLinks, 291 RequestDetails theRequestDetails, 292 String theSearchId, 293 int theOffset, 294 int theCount, 295 Map<String, String[]> theRequestParameters) { 296 return createPagingLink( 297 theBundleLinks, theRequestDetails, theSearchId, theOffset, theCount, theRequestParameters, null); 298 } 299 300 public static String createPagingLink( 301 BundleLinks theBundleLinks, 302 RequestDetails theRequestDetails, 303 String theSearchId, 304 String thePageId, 305 Map<String, String[]> theRequestParameters) { 306 return createPagingLink( 307 theBundleLinks, theRequestDetails, theSearchId, null, null, theRequestParameters, thePageId); 308 } 309 310 private static String createPagingLink( 311 BundleLinks theBundleLinks, 312 RequestDetails theRequestDetails, 313 String theSearchId, 314 Integer theOffset, 315 Integer theCount, 316 Map<String, String[]> theRequestParameters, 317 String thePageId) { 318 319 String serverBase = theRequestDetails.getFhirServerBase(); 320 321 StringBuilder b = new StringBuilder(); 322 b.append(serverBase); 323 b.append('?'); 324 b.append(Constants.PARAM_PAGINGACTION); 325 b.append('='); 326 b.append(UrlUtil.escapeUrlParam(theSearchId)); 327 328 if (theOffset != null) { 329 b.append('&'); 330 b.append(Constants.PARAM_PAGINGOFFSET); 331 b.append('='); 332 b.append(theOffset); 333 } 334 if (theCount != null) { 335 b.append('&'); 336 b.append(Constants.PARAM_COUNT); 337 b.append('='); 338 b.append(theCount); 339 } 340 if (isNotBlank(thePageId)) { 341 b.append('&'); 342 b.append(Constants.PARAM_PAGEID); 343 b.append('='); 344 b.append(UrlUtil.escapeUrlParam(thePageId)); 345 } 346 String[] strings = theRequestParameters.get(Constants.PARAM_FORMAT); 347 if (strings != null && strings.length > 0) { 348 b.append('&'); 349 b.append(Constants.PARAM_FORMAT); 350 b.append('='); 351 String format = strings[0]; 352 format = replace(format, " ", "+"); 353 b.append(UrlUtil.escapeUrlParam(format)); 354 } 355 if (theBundleLinks.prettyPrint) { 356 b.append('&'); 357 b.append(Constants.PARAM_PRETTY); 358 b.append('='); 359 b.append(Constants.PARAM_PRETTY_VALUE_TRUE); 360 } 361 362 if (theBundleLinks.getIncludes() != null) { 363 for (Include nextInclude : theBundleLinks.getIncludes()) { 364 if (isNotBlank(nextInclude.getValue())) { 365 b.append('&'); 366 b.append(Constants.PARAM_INCLUDE); 367 b.append('='); 368 b.append(UrlUtil.escapeUrlParam(nextInclude.getValue())); 369 } 370 } 371 } 372 373 if (theBundleLinks.bundleType != null) { 374 b.append('&'); 375 b.append(Constants.PARAM_BUNDLETYPE); 376 b.append('='); 377 b.append(theBundleLinks.bundleType.getCode()); 378 } 379 380 // _elements 381 Set<String> elements = ElementsParameter.getElementsValueOrNull(theRequestDetails, false); 382 if (elements != null) { 383 b.append('&'); 384 b.append(Constants.PARAM_ELEMENTS); 385 b.append('='); 386 String nextValue = 387 elements.stream().sorted().map(UrlUtil::escapeUrlParam).collect(Collectors.joining(",")); 388 b.append(nextValue); 389 } 390 391 // _elements:exclude 392 if (theRequestDetails.getServer().getElementsSupport() == ElementsSupportEnum.EXTENDED) { 393 Set<String> elementsExclude = ElementsParameter.getElementsValueOrNull(theRequestDetails, true); 394 if (elementsExclude != null) { 395 b.append('&'); 396 b.append(Constants.PARAM_ELEMENTS + Constants.PARAM_ELEMENTS_EXCLUDE_MODIFIER); 397 b.append('='); 398 String nextValue = elementsExclude.stream() 399 .sorted() 400 .map(UrlUtil::escapeUrlParam) 401 .collect(Collectors.joining(",")); 402 b.append(nextValue); 403 } 404 } 405 406 return b.toString(); 407 } 408 409 @Nullable 410 public static EncodingEnum determineRequestEncodingNoDefault(RequestDetails theReq) { 411 return determineRequestEncodingNoDefault(theReq, false); 412 } 413 414 @Nullable 415 public static EncodingEnum determineRequestEncodingNoDefault(RequestDetails theReq, boolean theStrict) { 416 ResponseEncoding retVal = determineRequestEncodingNoDefaultReturnRE(theReq, theStrict); 417 if (retVal == null) { 418 return null; 419 } 420 return retVal.getEncoding(); 421 } 422 423 private static ResponseEncoding determineRequestEncodingNoDefaultReturnRE( 424 RequestDetails theReq, boolean theStrict) { 425 ResponseEncoding retVal = null; 426 List<String> headers = theReq.getHeaders(Constants.HEADER_CONTENT_TYPE); 427 if (headers != null) { 428 Iterator<String> acceptValues = headers.iterator(); 429 if (acceptValues != null) { 430 while (acceptValues.hasNext() && retVal == null) { 431 String nextAcceptHeaderValue = acceptValues.next(); 432 if (nextAcceptHeaderValue != null && isNotBlank(nextAcceptHeaderValue)) { 433 for (String nextPart : nextAcceptHeaderValue.split(",")) { 434 int scIdx = nextPart.indexOf(';'); 435 if (scIdx == 0) { 436 continue; 437 } 438 if (scIdx != -1) { 439 nextPart = nextPart.substring(0, scIdx); 440 } 441 nextPart = nextPart.trim(); 442 EncodingEnum encoding; 443 if (theStrict) { 444 encoding = EncodingEnum.forContentTypeStrict(nextPart); 445 } else { 446 encoding = EncodingEnum.forContentType(nextPart); 447 } 448 if (encoding != null) { 449 retVal = new ResponseEncoding(theReq.getServer().getFhirContext(), encoding, nextPart); 450 break; 451 } 452 } 453 } 454 } 455 } 456 } 457 return retVal; 458 } 459 460 /** 461 * Returns null if the request doesn't express that it wants FHIR. If it expresses that it wants XML and JSON 462 * equally, returns thePrefer. 463 */ 464 public static ResponseEncoding determineResponseEncodingNoDefault(RequestDetails theReq, EncodingEnum thePrefer) { 465 return determineResponseEncodingNoDefault(theReq, thePrefer, null); 466 } 467 468 /** 469 * Try to determing the response content type, given the request Accept header and 470 * _format parameter. If a value is provided to thePreferContents, we'll 471 * prefer to return that value over the native FHIR value. 472 */ 473 public static ResponseEncoding determineResponseEncodingNoDefault( 474 RequestDetails theReq, EncodingEnum thePrefer, String thePreferContentType) { 475 String[] format = theReq.getParameters().get(Constants.PARAM_FORMAT); 476 if (format != null) { 477 for (String nextFormat : format) { 478 EncodingEnum retVal = EncodingEnum.forContentType(nextFormat); 479 if (retVal != null) { 480 return new ResponseEncoding(theReq.getServer().getFhirContext(), retVal, nextFormat); 481 } 482 } 483 } 484 485 /* 486 * Some browsers (e.g. FF) request "application/xml" in their Accept header, 487 * and we generally want to treat this as a preference for FHIR XML even if 488 * it's not the FHIR version of the CT, which should be "application/xml+fhir". 489 * 490 * When we're serving up Binary resources though, we are a bit more strict, 491 * since Binary is supposed to use native content types unless the client has 492 * explicitly requested FHIR. 493 */ 494 boolean strict = false; 495 if ("Binary".equals(theReq.getResourceName())) { 496 strict = true; 497 } 498 499 /* 500 * The Accept header is kind of ridiculous, e.g. 501 */ 502 // text/xml, application/xml, application/xhtml+xml, text/html;q=0.9, text/plain;q=0.8, image/png, */*;q=0.5 503 504 List<String> acceptValues = theReq.getHeaders(Constants.HEADER_ACCEPT); 505 float bestQ = -1f; 506 ResponseEncoding retVal = null; 507 if (acceptValues != null) { 508 for (String nextAcceptHeaderValue : acceptValues) { 509 StringTokenizer tok = new StringTokenizer(nextAcceptHeaderValue, ","); 510 while (tok.hasMoreTokens()) { 511 String nextToken = tok.nextToken(); 512 int startSpaceIndex = -1; 513 for (int i = 0; i < nextToken.length(); i++) { 514 if (nextToken.charAt(i) != ' ') { 515 startSpaceIndex = i; 516 break; 517 } 518 } 519 520 if (startSpaceIndex == -1) { 521 continue; 522 } 523 524 int endSpaceIndex = -1; 525 for (int i = startSpaceIndex; i < nextToken.length(); i++) { 526 if (nextToken.charAt(i) == ' ' || nextToken.charAt(i) == ';') { 527 endSpaceIndex = i; 528 break; 529 } 530 } 531 532 float q = 1.0f; 533 ResponseEncoding encoding; 534 if (endSpaceIndex == -1) { 535 if (startSpaceIndex == 0) { 536 encoding = getEncodingForContentType( 537 theReq.getServer().getFhirContext(), strict, nextToken, thePreferContentType); 538 } else { 539 encoding = getEncodingForContentType( 540 theReq.getServer().getFhirContext(), 541 strict, 542 nextToken.substring(startSpaceIndex), 543 thePreferContentType); 544 } 545 } else { 546 encoding = getEncodingForContentType( 547 theReq.getServer().getFhirContext(), 548 strict, 549 nextToken.substring(startSpaceIndex, endSpaceIndex), 550 thePreferContentType); 551 String remaining = nextToken.substring(endSpaceIndex + 1); 552 StringTokenizer qualifierTok = new StringTokenizer(remaining, ";"); 553 while (qualifierTok.hasMoreTokens()) { 554 String nextQualifier = qualifierTok.nextToken(); 555 int equalsIndex = nextQualifier.indexOf('='); 556 if (equalsIndex != -1) { 557 String nextQualifierKey = 558 nextQualifier.substring(0, equalsIndex).trim(); 559 String nextQualifierValue = nextQualifier 560 .substring(equalsIndex + 1, nextQualifier.length()) 561 .trim(); 562 if (nextQualifierKey.equals("q")) { 563 try { 564 q = Float.parseFloat(nextQualifierValue); 565 q = Math.max(q, 0.0f); 566 } catch (NumberFormatException e) { 567 ourLog.debug("Invalid Accept header q value: {}", nextQualifierValue); 568 } 569 } 570 } 571 } 572 } 573 574 if (encoding != null) { 575 if (q > bestQ || (q == bestQ && encoding.getEncoding() == thePrefer)) { 576 retVal = encoding; 577 bestQ = q; 578 } 579 } 580 } 581 } 582 } 583 584 /* 585 * If the client hasn't given any indication about which response 586 * encoding they want, let's try the request encoding in case that 587 * is useful (basically this catches the case where the request 588 * has a Content-Type header but not an Accept header) 589 */ 590 if (retVal == null) { 591 retVal = determineRequestEncodingNoDefaultReturnRE(theReq, strict); 592 } 593 594 return retVal; 595 } 596 597 /** 598 * Determine whether a response should be given in JSON or XML format based on the incoming HttpServletRequest's 599 * <code>"_format"</code> parameter and <code>"Accept:"</code> HTTP header. 600 */ 601 public static ResponseEncoding determineResponseEncodingWithDefault(RequestDetails theReq) { 602 ResponseEncoding retVal = 603 determineResponseEncodingNoDefault(theReq, theReq.getServer().getDefaultResponseEncoding()); 604 if (retVal == null) { 605 retVal = new ResponseEncoding( 606 theReq.getServer().getFhirContext(), theReq.getServer().getDefaultResponseEncoding(), null); 607 } 608 return retVal; 609 } 610 611 @Nonnull 612 public static Set<SummaryEnum> determineSummaryMode(RequestDetails theRequest) { 613 Map<String, String[]> requestParams = theRequest.getParameters(); 614 615 Set<SummaryEnum> retVal = SummaryEnumParameter.getSummaryValueOrNull(theRequest); 616 617 if (retVal == null) { 618 /* 619 * HAPI originally supported a custom parameter called _narrative, but this has been superceded by an official 620 * parameter called _summary 621 */ 622 String[] narrative = requestParams.get(Constants.PARAM_NARRATIVE); 623 if (narrative != null && narrative.length > 0) { 624 try { 625 NarrativeModeEnum narrativeMode = NarrativeModeEnum.valueOfCaseInsensitive(narrative[0]); 626 switch (narrativeMode) { 627 case NORMAL: 628 retVal = Collections.singleton(SummaryEnum.FALSE); 629 break; 630 case ONLY: 631 retVal = Collections.singleton(SummaryEnum.TEXT); 632 break; 633 case SUPPRESS: 634 retVal = Collections.singleton(SummaryEnum.DATA); 635 break; 636 } 637 } catch (IllegalArgumentException e) { 638 ourLog.debug("Invalid {} parameter: {}", Constants.PARAM_NARRATIVE, narrative[0]); 639 } 640 } 641 } 642 if (retVal == null) { 643 retVal = Collections.singleton(SummaryEnum.FALSE); 644 } 645 646 return retVal; 647 } 648 649 public static Integer extractCountParameter(RequestDetails theRequest) { 650 return RestfulServerUtils.tryToExtractNamedParameter(theRequest, Constants.PARAM_COUNT); 651 } 652 653 public static Integer extractOffsetParameter(RequestDetails theRequest) { 654 return RestfulServerUtils.tryToExtractNamedParameter(theRequest, Constants.PARAM_OFFSET); 655 } 656 657 public static IPrimitiveType<Date> extractLastUpdatedFromResource(IBaseResource theResource) { 658 IPrimitiveType<Date> lastUpdated = null; 659 if (theResource instanceof IResource) { 660 lastUpdated = ResourceMetadataKeyEnum.UPDATED.get((IResource) theResource); 661 } else if (theResource instanceof IAnyResource) { 662 lastUpdated = new InstantDt(theResource.getMeta().getLastUpdated()); 663 } 664 return lastUpdated; 665 } 666 667 public static IIdType fullyQualifyResourceIdOrReturnNull( 668 IRestfulServerDefaults theServer, IBaseResource theResource, String theServerBase, IIdType theResourceId) { 669 IIdType retVal = null; 670 if (theResourceId.hasIdPart() && isNotBlank(theServerBase)) { 671 String resName = theResourceId.getResourceType(); 672 if (theResource != null && isBlank(resName)) { 673 FhirContext context = theServer.getFhirContext(); 674 context = getContextForVersion(context, theResource.getStructureFhirVersionEnum()); 675 resName = context.getResourceType(theResource); 676 } 677 if (isNotBlank(resName)) { 678 retVal = theResourceId.withServerBase(theServerBase, resName); 679 } 680 } 681 return retVal; 682 } 683 684 private static FhirContext getContextForVersion(FhirContext theContext, FhirVersionEnum theForVersion) { 685 FhirContext context = theContext; 686 if (context.getVersion().getVersion() != theForVersion) { 687 context = myFhirContextMap.get(theForVersion); 688 if (context == null) { 689 context = theForVersion.newContext(); 690 myFhirContextMap.put(theForVersion, context); 691 } 692 } 693 return context; 694 } 695 696 private static ResponseEncoding getEncodingForContentType( 697 FhirContext theFhirContext, boolean theStrict, String theContentType, String thePreferContentType) { 698 EncodingEnum encoding; 699 if (theStrict) { 700 encoding = EncodingEnum.forContentTypeStrict(theContentType); 701 } else { 702 encoding = EncodingEnum.forContentType(theContentType); 703 } 704 if (isNotBlank(thePreferContentType)) { 705 if (thePreferContentType.equals(theContentType)) { 706 return new ResponseEncoding(theFhirContext, encoding, theContentType); 707 } 708 } 709 if (encoding == null) { 710 return null; 711 } 712 return new ResponseEncoding(theFhirContext, encoding, theContentType); 713 } 714 715 public static IParser getNewParser( 716 FhirContext theContext, FhirVersionEnum theForVersion, RequestDetails theRequestDetails) { 717 FhirContext context = getContextForVersion(theContext, theForVersion); 718 719 // Determine response encoding 720 EncodingEnum responseEncoding = RestfulServerUtils.determineResponseEncodingWithDefault(theRequestDetails) 721 .getEncoding(); 722 IParser parser; 723 switch (responseEncoding) { 724 case JSON: 725 parser = context.newJsonParser(); 726 break; 727 case RDF: 728 parser = context.newRDFParser(); 729 break; 730 case XML: 731 default: 732 parser = context.newXmlParser(); 733 break; 734 } 735 736 configureResponseParser(theRequestDetails, parser); 737 738 return parser; 739 } 740 741 public static Set<String> parseAcceptHeaderAndReturnHighestRankedOptions(HttpServletRequest theRequest) { 742 Set<String> retVal = new HashSet<String>(); 743 744 Enumeration<String> acceptValues = theRequest.getHeaders(Constants.HEADER_ACCEPT); 745 if (acceptValues != null) { 746 float bestQ = -1f; 747 while (acceptValues.hasMoreElements()) { 748 String nextAcceptHeaderValue = acceptValues.nextElement(); 749 Matcher m = ACCEPT_HEADER_PATTERN.matcher(nextAcceptHeaderValue); 750 float q = 1.0f; 751 while (m.find()) { 752 String contentTypeGroup = m.group(1); 753 if (isNotBlank(contentTypeGroup)) { 754 755 String name = m.group(3); 756 String value = m.group(4); 757 if (name != null && value != null) { 758 if ("q".equals(name)) { 759 try { 760 q = Float.parseFloat(value); 761 q = Math.max(q, 0.0f); 762 } catch (NumberFormatException e) { 763 ourLog.debug("Invalid Accept header q value: {}", value); 764 } 765 } 766 } 767 768 if (q > bestQ) { 769 retVal.clear(); 770 bestQ = q; 771 } 772 773 if (q == bestQ) { 774 retVal.add(contentTypeGroup.trim()); 775 } 776 } 777 778 if (!",".equals(m.group(5))) { 779 break; 780 } 781 } 782 } 783 } 784 785 return retVal; 786 } 787 788 public static boolean respectPreferHeader(RestOperationTypeEnum theRestOperationType) { 789 return ourOperationsWhichAllowPreferHeader.contains(theRestOperationType); 790 } 791 792 @Nonnull 793 public static PreferHeader parsePreferHeader(IRestfulServer<?> theServer, String theValue) { 794 PreferHeader retVal = new PreferHeader(); 795 796 if (isNotBlank(theValue)) { 797 StringTokenizer tok = new StringTokenizer(theValue, ";,"); 798 while (tok.hasMoreTokens()) { 799 String next = trim(tok.nextToken()); 800 int eqIndex = next.indexOf('='); 801 802 String key; 803 String value; 804 if (eqIndex == -1 || eqIndex >= next.length() - 2) { 805 key = next; 806 value = ""; 807 } else { 808 key = next.substring(0, eqIndex).trim(); 809 value = next.substring(eqIndex + 1).trim(); 810 } 811 812 if (key.equals(Constants.HEADER_PREFER_RETURN)) { 813 814 value = cleanUpValue(value); 815 retVal.setReturn(PreferReturnEnum.fromHeaderValue(value)); 816 817 } else if (key.equals(Constants.HEADER_PREFER_HANDLING)) { 818 819 value = cleanUpValue(value); 820 retVal.setHanding(PreferHandlingEnum.fromHeaderValue(value)); 821 822 } else if (key.equals(Constants.HEADER_PREFER_RESPOND_ASYNC)) { 823 824 retVal.setRespondAsync(true); 825 } 826 } 827 } 828 829 if (retVal.getReturn() == null && theServer != null && theServer.getDefaultPreferReturn() != null) { 830 retVal.setReturn(theServer.getDefaultPreferReturn()); 831 } 832 833 return retVal; 834 } 835 836 private static String cleanUpValue(String value) { 837 if (value.length() < 2) { 838 value = ""; 839 } 840 if ('"' == value.charAt(0) && '"' == value.charAt(value.length() - 1)) { 841 value = value.substring(1, value.length() - 1); 842 } 843 return value; 844 } 845 846 public static boolean prettyPrintResponse(IRestfulServerDefaults theServer, RequestDetails theRequest) { 847 Map<String, String[]> requestParams = theRequest.getParameters(); 848 String[] pretty = requestParams.get(Constants.PARAM_PRETTY); 849 boolean prettyPrint; 850 if (pretty != null && pretty.length > 0) { 851 prettyPrint = Constants.PARAM_PRETTY_VALUE_TRUE.equals(pretty[0]); 852 } else { 853 prettyPrint = theServer.isDefaultPrettyPrint(); 854 List<String> acceptValues = theRequest.getHeaders(Constants.HEADER_ACCEPT); 855 if (acceptValues != null) { 856 for (String nextAcceptHeaderValue : acceptValues) { 857 if (nextAcceptHeaderValue.contains("pretty=true")) { 858 prettyPrint = true; 859 } 860 } 861 } 862 } 863 return prettyPrint; 864 } 865 866 public static Object streamResponseAsResource( 867 IRestfulServerDefaults theServer, 868 IBaseResource theResource, 869 Set<SummaryEnum> theSummaryMode, 870 int theStatusCode, 871 boolean theAddContentLocationHeader, 872 boolean respondGzip, 873 RequestDetails theRequestDetails) 874 throws IOException { 875 return streamResponseAsResource( 876 theServer, 877 theResource, 878 theSummaryMode, 879 theStatusCode, 880 theAddContentLocationHeader, 881 respondGzip, 882 theRequestDetails, 883 null, 884 null); 885 } 886 887 public static Object streamResponseAsResource( 888 IRestfulServerDefaults theServer, 889 IBaseResource theResource, 890 Set<SummaryEnum> theSummaryMode, 891 int theStatusCode, 892 boolean theAddContentLocationHeader, 893 boolean respondGzip, 894 RequestDetails theRequestDetails, 895 IIdType theOperationResourceId, 896 IPrimitiveType<Date> theOperationResourceLastUpdated) 897 throws IOException { 898 IRestfulResponse response = theRequestDetails.getResponse(); 899 900 // Determine response encoding 901 ResponseEncoding responseEncoding = RestfulServerUtils.determineResponseEncodingNoDefault( 902 theRequestDetails, theServer.getDefaultResponseEncoding()); 903 904 String serverBase = theRequestDetails.getFhirServerBase(); 905 IIdType fullId = null; 906 if (theOperationResourceId != null) { 907 fullId = theOperationResourceId; 908 } else if (theResource != null) { 909 if (theResource.getIdElement() != null) { 910 IIdType resourceId = theResource.getIdElement(); 911 fullId = fullyQualifyResourceIdOrReturnNull(theServer, theResource, serverBase, resourceId); 912 } 913 } 914 915 if (theAddContentLocationHeader && fullId != null) { 916 if (theRequestDetails.getRequestType() == RequestTypeEnum.POST) { 917 response.addHeader(Constants.HEADER_LOCATION, fullId.getValue()); 918 } 919 response.addHeader(Constants.HEADER_CONTENT_LOCATION, fullId.getValue()); 920 } 921 922 if (theServer.getETagSupport() == ETagSupportEnum.ENABLED) { 923 if (theRequestDetails.getRestOperationType() != null) { 924 switch (theRequestDetails.getRestOperationType()) { 925 case CREATE: 926 case UPDATE: 927 case READ: 928 case VREAD: 929 if (fullId != null && fullId.hasVersionIdPart()) { 930 String versionIdPart = fullId.getVersionIdPart(); 931 response.addHeader(Constants.HEADER_ETAG, createEtag(versionIdPart)); 932 } else if (theResource != null 933 && theResource.getMeta() != null 934 && isNotBlank(theResource.getMeta().getVersionId())) { 935 String versionId = theResource.getMeta().getVersionId(); 936 response.addHeader(Constants.HEADER_ETAG, createEtag(versionId)); 937 } 938 } 939 } 940 } 941 942 // Binary handling 943 String contentType; 944 if (theResource instanceof IBaseBinary) { 945 IBaseBinary bin = (IBaseBinary) theResource; 946 947 // Add a security context header 948 IBaseReference securityContext = BinaryUtil.getSecurityContext(theServer.getFhirContext(), bin); 949 if (securityContext != null) { 950 String securityContextRef = 951 securityContext.getReferenceElement().getValue(); 952 if (isNotBlank(securityContextRef)) { 953 response.addHeader(Constants.HEADER_X_SECURITY_CONTEXT, securityContextRef); 954 } 955 } 956 957 // If the user didn't explicitly request FHIR as a response, return binary 958 // content directly 959 if (shouldStreamContents(responseEncoding, bin)) { 960 // Force binary resources to download - This is a security measure to prevent 961 // malicious images or HTML blocks being served up as content. 962 contentType = getBinaryContentTypeOrDefault(bin); 963 response.addHeader(Constants.HEADER_CONTENT_DISPOSITION, "Attachment;"); 964 965 Integer contentLength = null; 966 if (bin.hasData()) { 967 contentLength = bin.getContent().length; 968 } 969 970 OutputStream outputStream = response.getResponseOutputStream(theStatusCode, contentType, contentLength); 971 if (bin.hasData()) { 972 outputStream.write(bin.getContent()); 973 } 974 return response.commitResponse(outputStream); 975 } 976 } 977 978 // Ok, we're not serving a binary resource, so apply default encoding 979 if (responseEncoding == null) { 980 responseEncoding = 981 new ResponseEncoding(theServer.getFhirContext(), theServer.getDefaultResponseEncoding(), null); 982 } 983 984 boolean encodingDomainResourceAsText = theSummaryMode.size() == 1 && theSummaryMode.contains(SummaryEnum.TEXT); 985 if (encodingDomainResourceAsText) { 986 /* 987 * If the user requests "text" for a bundle, only suppress the non text elements in the Element.entry.resource 988 * parts, we're not streaming just the narrative as HTML (since bundles don't even 989 * have one) 990 */ 991 if ("Bundle".equals(theServer.getFhirContext().getResourceType(theResource))) { 992 encodingDomainResourceAsText = false; 993 } 994 } 995 996 /* 997 * Last-Modified header 998 */ 999 1000 IPrimitiveType<Date> lastUpdated; 1001 if (theOperationResourceLastUpdated != null) { 1002 lastUpdated = theOperationResourceLastUpdated; 1003 } else { 1004 lastUpdated = extractLastUpdatedFromResource(theResource); 1005 } 1006 if (lastUpdated != null && lastUpdated.isEmpty() == false) { 1007 response.addHeader(Constants.HEADER_LAST_MODIFIED, DateUtils.formatDate(lastUpdated.getValue())); 1008 } 1009 1010 /* 1011 * Stream the response body 1012 */ 1013 1014 if (theResource == null) { 1015 contentType = null; 1016 } else if (encodingDomainResourceAsText) { 1017 contentType = Constants.CT_HTML; 1018 } else { 1019 contentType = responseEncoding.getResourceContentType(); 1020 } 1021 String charset = Constants.CHARSET_NAME_UTF8; 1022 1023 Writer writer = response.getResponseWriter(theStatusCode, contentType, charset, respondGzip); 1024 1025 // Interceptor call: SERVER_OUTGOING_WRITER_CREATED 1026 if (theServer.getInterceptorService() != null 1027 && theServer.getInterceptorService().hasHooks(Pointcut.SERVER_OUTGOING_WRITER_CREATED)) { 1028 HookParams params = new HookParams() 1029 .add(Writer.class, writer) 1030 .add(RequestDetails.class, theRequestDetails) 1031 .addIfMatchesType(ServletRequestDetails.class, theRequestDetails); 1032 Object newWriter = theServer 1033 .getInterceptorService() 1034 .callHooksAndReturnObject(Pointcut.SERVER_OUTGOING_WRITER_CREATED, params); 1035 if (newWriter != null) { 1036 writer = (Writer) newWriter; 1037 } 1038 } 1039 1040 if (theResource == null) { 1041 // No response is being returned 1042 } else if (encodingDomainResourceAsText && theResource instanceof IResource) { 1043 // DSTU2 1044 writer.append(((IResource) theResource).getText().getDiv().getValueAsString()); 1045 } else if (encodingDomainResourceAsText && theResource instanceof IDomainResource) { 1046 // DSTU3+ 1047 try { 1048 writer.append(((IDomainResource) theResource).getText().getDivAsString()); 1049 } catch (Exception e) { 1050 throw new InternalErrorException(Msg.code(305) + e); 1051 } 1052 } else { 1053 FhirVersionEnum forVersion = theResource.getStructureFhirVersionEnum(); 1054 IParser parser = getNewParser(theServer.getFhirContext(), forVersion, theRequestDetails); 1055 parser.encodeResourceToWriter(theResource, writer); 1056 } 1057 1058 return response.commitResponse(writer); 1059 } 1060 1061 private static String getBinaryContentTypeOrDefault(IBaseBinary theBinary) { 1062 String contentType; 1063 if (isNotBlank(theBinary.getContentType())) { 1064 contentType = theBinary.getContentType(); 1065 } else { 1066 contentType = Constants.CT_OCTET_STREAM; 1067 } 1068 return contentType; 1069 } 1070 1071 /** 1072 * Determines whether we should stream out Binary resource content based on the content-type. Logic is: 1073 * - If the binary was externalized and has not been reinflated upstream, return false. 1074 * - If they request octet-stream, return true; 1075 * - If the content-type happens to be a match, return true. 1076 * <p> 1077 * - Construct an EncodingEnum out of the contentType. If this matches the responseEncoding, return true. 1078 * - Otherwise, return false. 1079 * 1080 * @param theResponseEncoding the requested {@link EncodingEnum} determined by the incoming Content-Type header. 1081 * @param theBinary the {@link IBaseBinary} resource to be streamed out. 1082 * @return True if response can be streamed as the requested encoding type, false otherwise. 1083 */ 1084 private static boolean shouldStreamContents(ResponseEncoding theResponseEncoding, IBaseBinary theBinary) { 1085 String contentType = theBinary.getContentType(); 1086 if (theBinary.getContent() == null) { 1087 return false; 1088 } 1089 if (theResponseEncoding == null) { 1090 return true; 1091 } 1092 if (isBlank(contentType)) { 1093 return Constants.CT_OCTET_STREAM.equals(theResponseEncoding.getContentType()); 1094 } else if (contentType.equalsIgnoreCase(theResponseEncoding.getContentType())) { 1095 return true; 1096 } else { 1097 return Objects.equals(EncodingEnum.forContentType(contentType), theResponseEncoding.getEncoding()); 1098 } 1099 } 1100 1101 public static String createEtag(String theVersionId) { 1102 return "W/\"" + theVersionId + '"'; 1103 } 1104 1105 public static Integer tryToExtractNamedParameter(RequestDetails theRequest, String theParamName) { 1106 String[] retVal = theRequest.getParameters().get(theParamName); 1107 if (retVal == null) { 1108 return null; 1109 } 1110 try { 1111 return Integer.parseInt(retVal[0]); 1112 } catch (NumberFormatException e) { 1113 ourLog.debug("Failed to parse {} value '{}': {}", theParamName, retVal[0], e.toString()); 1114 return null; 1115 } 1116 } 1117 1118 public static void validateResourceListNotNull(List<? extends IBaseResource> theResourceList) { 1119 if (theResourceList == null) { 1120 throw new InternalErrorException( 1121 Msg.code(306) + "IBundleProvider returned a null list of resources - This is not allowed"); 1122 } 1123 } 1124 1125 /** 1126 * @since 5.0.0 1127 */ 1128 public static DeleteCascadeDetails extractDeleteCascadeParameter(RequestDetails theRequest) { 1129 DeleteCascadeModeEnum mode = null; 1130 Integer maxRounds = null; 1131 if (theRequest != null) { 1132 String[] cascadeParameters = theRequest.getParameters().get(Constants.PARAMETER_CASCADE_DELETE); 1133 if (cascadeParameters != null && Arrays.asList(cascadeParameters).contains(Constants.CASCADE_DELETE)) { 1134 mode = DeleteCascadeModeEnum.DELETE; 1135 String[] maxRoundsValues = 1136 theRequest.getParameters().get(Constants.PARAMETER_CASCADE_DELETE_MAX_ROUNDS); 1137 if (maxRoundsValues != null && maxRoundsValues.length > 0) { 1138 String maxRoundsString = maxRoundsValues[0]; 1139 maxRounds = parseMaxRoundsString(maxRoundsString); 1140 } 1141 } 1142 1143 if (mode == null) { 1144 String cascadeHeader = theRequest.getHeader(Constants.HEADER_CASCADE); 1145 if (isNotBlank(cascadeHeader)) { 1146 if (Constants.CASCADE_DELETE.equals(cascadeHeader) 1147 || cascadeHeader.startsWith(Constants.CASCADE_DELETE + ";") 1148 || cascadeHeader.startsWith(Constants.CASCADE_DELETE + " ")) { 1149 mode = DeleteCascadeModeEnum.DELETE; 1150 1151 if (cascadeHeader.contains(";")) { 1152 String remainder = cascadeHeader.substring(cascadeHeader.indexOf(';') + 1); 1153 remainder = trim(remainder); 1154 if (remainder.startsWith(Constants.HEADER_CASCADE_MAX_ROUNDS + "=")) { 1155 String maxRoundsString = 1156 remainder.substring(Constants.HEADER_CASCADE_MAX_ROUNDS.length() + 1); 1157 maxRounds = parseMaxRoundsString(maxRoundsString); 1158 } 1159 } 1160 } 1161 } 1162 } 1163 } 1164 1165 if (mode == null) { 1166 mode = DeleteCascadeModeEnum.NONE; 1167 } 1168 1169 return new DeleteCascadeDetails(mode, maxRounds); 1170 } 1171 1172 @Nullable 1173 private static Integer parseMaxRoundsString(String theMaxRoundsString) { 1174 Integer maxRounds; 1175 if (isBlank(theMaxRoundsString)) { 1176 maxRounds = null; 1177 } else if (NumberUtils.isDigits(theMaxRoundsString)) { 1178 maxRounds = Integer.parseInt(theMaxRoundsString); 1179 } else { 1180 throw new InvalidRequestException(Msg.code(2349) + "Invalid value for " 1181 + Constants.PARAMETER_CASCADE_DELETE_MAX_ROUNDS + " parameter"); 1182 } 1183 return maxRounds; 1184 } 1185 1186 private enum NarrativeModeEnum { 1187 NORMAL, 1188 ONLY, 1189 SUPPRESS; 1190 1191 public static NarrativeModeEnum valueOfCaseInsensitive(String theCode) { 1192 return valueOf(NarrativeModeEnum.class, theCode.toUpperCase()); 1193 } 1194 } 1195 1196 /** 1197 * Return type for {@link RestfulServerUtils#determineRequestEncodingNoDefault(RequestDetails)} 1198 */ 1199 public static class ResponseEncoding { 1200 private final String myContentType; 1201 private final EncodingEnum myEncoding; 1202 private final Boolean myNonLegacy; 1203 1204 public ResponseEncoding(FhirContext theCtx, EncodingEnum theEncoding, String theContentType) { 1205 super(); 1206 myEncoding = theEncoding; 1207 myContentType = theContentType; 1208 if (theContentType != null) { 1209 FhirVersionEnum ctxtEnum = theCtx.getVersion().getVersion(); 1210 if (theContentType.equals(EncodingEnum.JSON_PLAIN_STRING) 1211 || theContentType.equals(EncodingEnum.XML_PLAIN_STRING)) { 1212 myNonLegacy = ctxtEnum.isNewerThan(FhirVersionEnum.DSTU2_1); 1213 } else { 1214 myNonLegacy = 1215 ctxtEnum.isNewerThan(FhirVersionEnum.DSTU2_1) && !EncodingEnum.isLegacy(theContentType); 1216 } 1217 } else { 1218 FhirVersionEnum ctxtEnum = theCtx.getVersion().getVersion(); 1219 if (ctxtEnum.isOlderThan(FhirVersionEnum.DSTU3)) { 1220 myNonLegacy = null; 1221 } else { 1222 myNonLegacy = Boolean.TRUE; 1223 } 1224 } 1225 } 1226 1227 public String getContentType() { 1228 return myContentType; 1229 } 1230 1231 public EncodingEnum getEncoding() { 1232 return myEncoding; 1233 } 1234 1235 public String getResourceContentType() { 1236 if (Boolean.TRUE.equals(isNonLegacy())) { 1237 return getEncoding().getResourceContentTypeNonLegacy(); 1238 } 1239 return getEncoding().getResourceContentType(); 1240 } 1241 1242 Boolean isNonLegacy() { 1243 return myNonLegacy; 1244 } 1245 } 1246 1247 public static class DeleteCascadeDetails { 1248 1249 private final DeleteCascadeModeEnum myMode; 1250 private final Integer myMaxRounds; 1251 1252 public DeleteCascadeDetails(DeleteCascadeModeEnum theMode, Integer theMaxRounds) { 1253 myMode = theMode; 1254 myMaxRounds = theMaxRounds; 1255 } 1256 1257 public DeleteCascadeModeEnum getMode() { 1258 return myMode; 1259 } 1260 1261 public Integer getMaxRounds() { 1262 return myMaxRounds; 1263 } 1264 } 1265}