/** * Find the current dasextension::query::errors element or create a new one in the proper place in * the given dasextension element. * * @param dasExt - mandatory - must be a valid dasextension Element * @return */ public ExtensibleElement getErrors(ExtensibleElement dasExt) { // get reference to the dasextension::query element in feed ExtensibleElement query = this.getQuery(dasExt); // get reference to the dasextension::query::errors element in feed QName errorsQname = new QName(this.dasextensionNamespace, "errors"); ExtensibleElement errors = query.getExtension(errorsQname); if (NullChecker.isEmpty(errors)) { List<Element> queryChildren = query.getElements(); if (NullChecker.isEmpty(queryChildren)) { // no children in query, so merely add errors element errors = query.addExtension(errorsQname); } else { // add errors after the last child errors = query.addExtension(errorsQname); } } return errors; }
/** * Adds the given dasextension::query::parameters Element into the given feed. Note: This method * will merge the given queryParameters with any existing query::parameters in the given feed. * * @param feed - mandatory - must contain a valid feed::dasextension Element * @param queryParameters - mandatory - must contain a valid and non-empty * dasextension::query::parameters Element. * @return */ private Feed addQueryParameters(Feed feed, final ExtensibleElement queryParameters) { if (NullChecker.isNotEmpty(feed)) { if (NullChecker.isNotEmpty(queryParameters)) { // get reference to the dasextension element in feed ExtensibleElement dasExt = feed.getExtension(new QName(this.dasextensionNamespace, "dasextension")); if (NullChecker.isNotEmpty(dasExt)) { List<Element> queryParametersEntries = queryParameters.getElements(); if (NullChecker.isNotEmpty(queryParametersEntries)) { // get or create the new dasextension::path::parameters Element ExtensibleElement queryParametersFeed = this.getQueryParameters(dasExt); // add in the dasextension::path::parameters::entry Elements for (Element curQueryParameterEntry : queryParametersEntries) { queryParametersFeed.addExtension(curQueryParameterEntry); } } } } } return feed; }
/** * Places the org.osehra.integration.http.uri.UriInfo uriInfo instance's query parameter values * into the DAS dasextension Atom Feed at feed::dasextension::query::parameters. Notes: The feed * parameter must contain a constructed DAS dasextension Atom Feed. This method will remove any * existing feed::dasextension::query::parameters::entry elements before adding the new entries * from uriInfo. * * @param feed -mandatory - must contain a valid feed::dasextension Element * @param uriInfo - mandatory * @return */ public Feed addQueryParameters(Feed feed, final javax.ws.rs.core.UriInfo uriInfo) { if (NullChecker.isNotEmpty(feed)) { // get reference to the dasextension element in feed ExtensibleElement dasExt = feed.getExtension(new QName(this.dasextensionNamespace, "dasextension")); if (NullChecker.isNotEmpty(dasExt)) { // check for a UriInfo to input if (NullChecker.isNotEmpty(uriInfo) && !(uriInfo.getQueryParameters().isEmpty())) { // get or create reference to the dasextension::query::parameters element in feed ExtensibleElement parameters = this.getQueryParameters(dasExt); // discard any existing path dasextension::path::parameter::entry elements List<Element> queryParameterEntries = parameters.getElements(); if (NullChecker.isNotEmpty(queryParameterEntries)) { for (Element curQueryParameterEntry : queryParameterEntries) { curQueryParameterEntry.discard(); } } // add the dasextension::query::parameters::entry elements from uriInfo QName entryQname = new QName(this.dasextensionNamespace, "entry"); QName keyQname = new QName(this.dasextensionNamespace, "key"); QName valueQname = new QName(this.dasextensionNamespace, "value"); MultivaluedMap<String, String> queryParametersExt = uriInfo.getQueryParameters(); Set<Map.Entry<String, List<String>>> queryParamsEntries = queryParametersExt.entrySet(); for (Map.Entry<String, List<String>> queryParameterEntry : queryParamsEntries) { ExtensibleElement entry = parameters.addExtension(entryQname); ExtensibleElement key = entry.addExtension(keyQname); key.setText(queryParameterEntry.getKey()); for (String entryValue : queryParameterEntry.getValue()) { ExtensibleElement value = entry.addExtension(valueQname); value.setText(entryValue); } } } } } return feed; }
/** * Merge the elements in the given dasextensionToMerge Element into the feed::dasextension element * in the given feed. Note: The dasextension::path::parameters and dasextension::query::parameters * values in the given dasextensionToMerge Element will only be merged into the given feed if the * given feed does not already have these Elements. * * @param feed - mandatory - must contain a valid feed::dasextension Element * @param extensionToMerge - mandatory - must contain a valid dasextension Element * @return */ public Feed mergeDasExtension(Feed feed, final Element dasextensionToMerge) { if (NullChecker.isNotEmpty(feed)) { if (NullChecker.isNotEmpty(dasextensionToMerge)) { QName mergeExtQname = dasextensionToMerge.getQName(); String mergeExtTagName = mergeExtQname.getLocalPart(); // if dasextensionToMerge isn't a dasextension, ignore it if ("dasextension".equals(mergeExtTagName)) { ExtensibleElement feedDasExt = feed.getExtension(new QName(this.dasextensionNamespace, "dasextension")); if (NullChecker.isNotEmpty(feedDasExt)) { // feed contains an existing dasextension, so merge other dasextensionToMerge with it: // merge dasextension::path::parameters if none are already in feed boolean feedPathParametersExists = this.pathParametersExists(feedDasExt); boolean mergePathParametersExists = this.pathParametersExists((ExtensibleElement) dasextensionToMerge); if (false == feedPathParametersExists) { if (mergePathParametersExists) { ExtensibleElement mergePathParameters = this.getPathParameters((ExtensibleElement) dasextensionToMerge); feed = this.addPathParameters(feed, mergePathParameters); } } // merge dasextension::query::parameters if none are already in feed boolean feedQueryParametersExists = this.queryParametersExists(feedDasExt); boolean mergeQueryParametersExists = this.queryParametersExists((ExtensibleElement) dasextensionToMerge); if (false == feedQueryParametersExists) { if (mergeQueryParametersExists) { ExtensibleElement mergeQueryParameters = this.getQueryParameters((ExtensibleElement) dasextensionToMerge); feed = this.addQueryParameters(feed, mergeQueryParameters); } } // collect all of the current dasextension sites::site elements List<Element> siteElements = new ArrayList<Element>(); ExtensibleElement mergeSites = this.getSites((ExtensibleElement) dasextensionToMerge); if (NullChecker.isNotEmpty(mergeSites)) { siteElements.addAll(mergeSites.getElements()); } // add in the site elements into the feed's dasextension for (final Element siteElement : siteElements) { feed = this.addSite(feed, (ExtensibleElement) siteElement); } // collect all of the merge dasextension errors::error elements List<Element> errorElements = new ArrayList<Element>(); ExtensibleElement mergeErrors = this.getErrors((ExtensibleElement) dasextensionToMerge); if (NullChecker.isNotEmpty(mergeErrors)) { errorElements.addAll(mergeErrors.getElements()); } // add in the error elements into the feed's dasextension for (final Element errorElement : errorElements) { feed = this.addError(feed, (ExtensibleElement) errorElement); } } else { // feed has no existing dasextension element, so add in dasextensionToMerge feed.addExtension(dasextensionToMerge); } } } } return feed; }
/** * Adds a single site element into the DAS dasextension Atom Feed. i.e. adds one of the following * inside of feed::dasextension::query::sites: <site> <id></id> <name></name> * <expectedCount></expectedCount> <retrievedCount></retrievedCount> <status></status> * <error></error> </site> Notes: The feed parameter must contain a constructed DAS dasextension * Atom Feed. An existing site element with the same site::name value as the given siteName value * will be removed before the new site element is added. * * @param feed - mandatory - must contain a valid feed::dasextension Element * @param siteName - mandatory * @param siteId - optional * @param siteHttpStatus - mandatory * @param expectedCount - optional * @param retrievedCount - optional * @param siteErrorMessage - optional * @return */ public Feed addSite( Feed feed, final String siteName, final String siteId, final int siteHttpStatus, final String expectedCount, final String retrievedCount, final String siteErrorMessage) { if (NullChecker.isNotEmpty(feed)) { // get reference to the dasextension element in feed ExtensibleElement dasExt = feed.getExtension(new QName(this.dasextensionNamespace, "dasextension")); if (NullChecker.isNotEmpty(dasExt)) { // get reference to the dasextension::query::sites element in feed ExtensibleElement sites = this.getSites(dasExt); // search for any existing site children by site::name value with // the new siteName, and if one is found, remove it List<Element> siteElements = sites.getElements(); for (Element curSiteElement : siteElements) { List<Element> siteChildElements = curSiteElement.getElements(); for (Element curSiteChildElement : siteChildElements) { if ("name".equals(curSiteChildElement.getQName().getLocalPart())) { if (siteName.equals(curSiteChildElement.getText())) { curSiteElement.discard(); } } } } // add the dasextension::query::sites::site element QName siteQname = new QName(this.dasextensionNamespace, "site"); ExtensibleElement site = sites.addExtension(siteQname); if (NullChecker.isNotEmpty(siteId)) { QName idQname = new QName(this.dasextensionNamespace, "id"); ExtensibleElement idElement = site.addExtension(idQname); idElement.setText(siteId); } QName nameQname = new QName(this.dasextensionNamespace, "name"); ExtensibleElement nameElement = site.addExtension(nameQname); nameElement.setText(siteName); if (NullChecker.isNotEmpty(expectedCount)) { QName expectedCountQname = new QName(this.dasextensionNamespace, "expectedCount"); ExtensibleElement expectedCountElement = site.addExtension(expectedCountQname); expectedCountElement.setText(expectedCount); } if (NullChecker.isNotEmpty(retrievedCount)) { QName retrievedCountQname = new QName(this.dasextensionNamespace, "retrievedCount"); ExtensibleElement retrievedCountElement = site.addExtension(retrievedCountQname); retrievedCountElement.setText(retrievedCount); } QName statusQname = new QName(this.dasextensionNamespace, "status"); ExtensibleElement statusElement = site.addExtension(statusQname); String siteStatus = new Integer(siteHttpStatus).toString(); statusElement.setText(siteStatus); if (NullChecker.isNotEmpty(siteErrorMessage)) { QName errorQname = new QName(this.dasextensionNamespace, "error"); ExtensibleElement siteErrorElement = site.addExtension(errorQname); siteErrorElement.setText(siteErrorMessage); } } } return feed; }