Java tutorial
/** * Copyright (C) 2014 Cohesive Integrations, LLC (info@cohesiveintegrations.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package net.di2e.ecdr.search.transform.atom; import java.io.IOException; import java.io.InputStream; import java.io.Serializable; import java.io.StringReader; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.activation.MimeType; import net.di2e.ecdr.api.security.SecurityConfiguration; import net.di2e.ecdr.commons.CDRMetacard; import net.di2e.ecdr.commons.constants.SearchConstants; import org.apache.abdera.Abdera; import org.apache.abdera.model.Entry; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ddf.action.ActionProvider; import ddf.catalog.Constants; import ddf.catalog.data.BinaryContent; import ddf.catalog.data.Metacard; import ddf.catalog.transform.CatalogTransformerException; import ddf.catalog.transform.MetacardTransformer; public class AtomTransformerWithPayload extends AtomTransformer { private static final String TRANSFORMER_ID = "atom-with-payload"; private static final Logger LOGGER = LoggerFactory.getLogger(AtomTransformerWithPayload.class); private Map<String, MetacardTransformer> metacardTransformerMap = null; public AtomTransformerWithPayload(ActionProvider viewMetacardProvider, ActionProvider metadataProvider, ActionProvider resourceProvider, ActionProvider thumbnailProvider, MimeType thumbnailMime, MimeType viewMime, List<SecurityConfiguration> securityConfig) { super(viewMetacardProvider, metadataProvider, resourceProvider, thumbnailProvider, thumbnailMime, viewMime, securityConfig); metacardTransformerMap = new HashMap<String, MetacardTransformer>(); } @Override public void addEntryElements(Entry entry, CDRMetacard metacard, Map<String, Serializable> properties) { // Abdera.getParser() spins up a new thread so must do this ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(AtomTransformerWithPayload.class.getClassLoader()); String metadata = getMetadataXML(metacard, (String) properties.get(SearchConstants.METACARD_TRANSFORMER_NAME)); entry.addExtension(Abdera.getNewParser().parse(new StringReader(metadata)).getRoot()); CDRMetacard newMetacard = new CDRMetacard(metacard); newMetacard.setMetadata(metadata); setEntrySecurity(entry, newMetacard); } finally { Thread.currentThread().setContextClassLoader(currentClassLoader); } } /** * Method responsible for getting the metadata XML String that is associated * with the Metacard. The metadata is retrieved by calling the * MetadataTransformer that is registered with the id that matches the * format String that is passed into the method. If a MetacardTransformer * doesn't exist, or the result of the Transform is not XML, or if there is * an error while transforming, the Metacard.METADATA will be returned * * @param metacard * the Metacard to get the Metacard from * @param format * the format of the MetacardTransformer to use (which is looked * up by MetacardTransformer id) * @return the XML String */ protected String getMetadataXML(Metacard metacard, String format) { String metadata = null; LOGGER.debug( "Getting metadata to include in atom response in the format [{}] from metacardTransformerMap {}", format, metacardTransformerMap.keySet()); if (StringUtils.isNotBlank(format)) { MetacardTransformer metacardTransformer = metacardTransformerMap.get(format); if (metacardTransformer != null) { try { LOGGER.debug( "Calling the MetacardTransformer with id [{}] to transform the Metacard into XML Metadata", format); BinaryContent binaryContent = metacardTransformer.transform(metacard, null); String mimeValue = binaryContent.getMimeTypeValue(); if (StringUtils.isNotBlank(mimeValue) && mimeValue.contains("xml")) { try (InputStream inputStream = binaryContent.getInputStream()) { metadata = IOUtils.toString(inputStream); } catch (IOException e) { LOGGER.warn("Error while writing transformed Metacard into a String: " + e.getMessage(), e); } } } catch (CatalogTransformerException e) { LOGGER.warn("Error while transforming metacard using the [{}] MetacardTransformer", format); LOGGER.warn(e.getMessage(), e); } } } if (metadata == null) { LOGGER.debug( "A MetacardTransform didn't exist for format [{}] or ran into problems when transforming Metacard, so falling back to using the Metadata in the Metacard", format); metadata = metacard.getMetadata(); } LOGGER.trace("Atom Transformer setting Metacard.METADATA to:{}{}", System.lineSeparator(), metadata); return metadata; } /** * Method called by the OSGi container, managed by blueprint whenever a new * MetacardTransformer service is exposed to the OSGi Registry * * @param transformer * the MetacardTransformer that was added * @param map * the service properties for the corresponding * MetacardTransformer */ public void metacardTransformerAdded(MetacardTransformer transformer, Map<String, Object> map) { String id = (String) map.get(Constants.SERVICE_ID); // We need to filter out this transformer from being included in the // Metacard Transformers used to produce metadata records if (!StringUtils.equalsIgnoreCase(id, TRANSFORMER_ID)) { metacardTransformerMap.put(id, transformer); LOGGER.debug("Adding MetacardTransformer with id [{}] to transformer map.", id); } } /** * Method is called when a MetacardTransformer is removed from the OSGi * registry (called by OSGi container, managed by blueprint) * * @param transformer * the MetacardTransformer service that was removed * @param map * the service properties for the corresponding * MetacardTransformer */ public void metacardTransformerRemoved(MetacardTransformer transformer, Map<String, Object> map) { String id = (String) map.get(Constants.SERVICE_ID); metacardTransformerMap.remove(id); LOGGER.debug("Removing MetacardTransformer with id [{}] from transformer map.", id); } }