| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with this |
| * work for additional information regarding copyright ownership. The ASF |
| * licenses this file to You 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 org.apache.stanbol.enhancer.jersey.resource; |
| |
| import static javax.ws.rs.core.MediaType.APPLICATION_FORM_URLENCODED; |
| import static javax.ws.rs.core.MediaType.TEXT_HTML; |
| import static org.apache.stanbol.commons.web.base.CorsHelper.addCORSOrigin; |
| |
| import java.io.IOException; |
| import java.util.HashSet; |
| import java.util.LinkedHashSet; |
| import java.util.Set; |
| |
| import javax.servlet.ServletContext; |
| import javax.ws.rs.Consumes; |
| import javax.ws.rs.FormParam; |
| import javax.ws.rs.GET; |
| import javax.ws.rs.POST; |
| import javax.ws.rs.Produces; |
| import javax.ws.rs.WebApplicationException; |
| import javax.ws.rs.core.Context; |
| import javax.ws.rs.core.HttpHeaders; |
| import javax.ws.rs.core.Response; |
| import javax.ws.rs.core.Response.ResponseBuilder; |
| |
| import org.apache.clerezza.rdf.core.Graph; |
| import org.apache.clerezza.rdf.core.NonLiteral; |
| import org.apache.clerezza.rdf.core.TripleCollection; |
| import org.apache.clerezza.rdf.core.serializedform.Serializer; |
| import org.apache.clerezza.rdf.core.sparql.QueryEngine; |
| import org.apache.stanbol.commons.viewable.Viewable; |
| import org.apache.stanbol.commons.web.base.ContextHelper; |
| import org.apache.stanbol.enhancer.servicesapi.Chain; |
| import org.apache.stanbol.enhancer.servicesapi.ChainException; |
| import org.apache.stanbol.enhancer.servicesapi.ContentItem; |
| import org.apache.stanbol.enhancer.servicesapi.EngineException; |
| import org.apache.stanbol.enhancer.servicesapi.EnhancementEngine; |
| import org.apache.stanbol.enhancer.servicesapi.EnhancementException; |
| import org.apache.stanbol.enhancer.servicesapi.helper.ExecutionPlanHelper; |
| import org.apache.stanbol.enhancer.servicesapi.impl.StringSource; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| |
| /** |
| * Abstract super class for all Enhancer endpoint that do also provide the |
| * Stanbol Enhancer Web UI. This includes "/enhancer", /enhancer/chain/{name} |
| * and "/engines". |
| * |
| * @author Rupert Westenthaler |
| * |
| */ |
| public abstract class AbstractEnhancerUiResource extends AbstractEnhancerResource { |
| |
| private final Logger log = LoggerFactory.getLogger(getClass()); |
| /** |
| * Optional dependency - might be <code>null</code> |
| */ |
| protected QueryEngine queryEngine; |
| protected final Serializer serializer; |
| private LinkedHashSet<ExecutionNode> _executionNodes; |
| private LinkedHashSet<ExecutionNode> _activeNodes; |
| protected final Chain chain; |
| |
| public AbstractEnhancerUiResource(String chainName,ServletContext context) { |
| super(context); |
| serializer = ContextHelper.getServiceFromContext(Serializer.class, context); |
| queryEngine = ContextHelper.getServiceFromContext(QueryEngine.class, context); |
| if(chainName == null){ |
| chain = chainManager.getDefault(); |
| } else { |
| this.chain = chainManager.getChain(chainName); |
| } |
| if(this.chain == null){ |
| throw new WebApplicationException(Response.Status.NOT_FOUND); |
| } |
| } |
| |
| @GET |
| @Produces(TEXT_HTML) |
| public Response get(@Context HttpHeaders headers) { |
| ResponseBuilder res = Response.ok(new Viewable("index", this, AbstractEnhancerUiResource.class), TEXT_HTML); |
| addCORSOrigin(servletContext, res, headers); |
| return res.build(); |
| } |
| |
| /** |
| * Form-based OpenCalais-compatible interface |
| * |
| * TODO: should we parse the OpenCalais paramsXML and find the closest Stanbol Enhancer semantics too? |
| * |
| * Note: the format parameter is not part of the official API |
| * |
| * @throws EngineException |
| * if the content is somehow corrupted |
| * @throws IOException |
| */ |
| @POST |
| @Consumes(APPLICATION_FORM_URLENCODED) |
| public Response enhanceFromForm(@FormParam("content") String content, |
| @FormParam("format") String format, |
| @FormParam("ajax") boolean buildAjaxview, |
| @Context HttpHeaders headers) throws EnhancementException, |
| IOException { |
| log.info("enhance from From: " + content); |
| ContentItem ci = ciFactory.createContentItem(new StringSource(content)); |
| if(!buildAjaxview){ //rewrite to a normal EnhancementRequest |
| return enhanceFromData(ci, false, null, false, null, false, null, headers); |
| } else { //enhance and build the AJAX response |
| EnhancementException enhancementException; |
| try { |
| enhance(ci); |
| enhancementException = null; |
| } catch (EnhancementException e){ |
| enhancementException = e; |
| } |
| ContentItemResource contentItemResource = new ContentItemResource(null, ci, uriInfo, "", |
| serializer, servletContext, enhancementException); |
| contentItemResource.setRdfSerializationFormat(format); |
| Viewable ajaxView = new Viewable("/ajax/contentitem", contentItemResource); |
| ResponseBuilder rb = Response.ok(ajaxView); |
| rb.header(HttpHeaders.CONTENT_TYPE, TEXT_HTML + "; charset=UTF-8"); |
| addCORSOrigin(servletContext, rb, headers); |
| return rb.build(); |
| } |
| } |
| |
| public boolean isEngineActive(String name) { |
| return engineManager.isEngine(name); |
| } |
| |
| public String getServiceUrl() { |
| String uri = uriInfo.getAbsolutePath().toString(); |
| return uri.charAt(uri.length()-1) == '/' ? |
| uri.substring(0, uri.length()-1) : uri; |
| } |
| |
| /** |
| * Getter for the executionNodes |
| * |
| * @return |
| */ |
| public Set<ExecutionNode> getExecutionNodes() { |
| if (_executionNodes == null) { |
| Graph ep; |
| try { |
| ep = chain.getExecutionPlan(); |
| } catch (ChainException e) { |
| ep = null; |
| } |
| if (ep != null) { |
| _executionNodes = new LinkedHashSet<ExecutionNode>(); |
| Set<NonLiteral> processed = new HashSet<NonLiteral>(); |
| Set<NonLiteral> next; |
| do { |
| next = ExecutionPlanHelper.getExecutable(ep, processed); |
| for (NonLiteral node : next) { |
| _executionNodes.add(new ExecutionNode(ep, node)); |
| } |
| processed.addAll(next); |
| } while (!next.isEmpty()); |
| } |
| } |
| return _executionNodes; |
| } |
| |
| public Set<ExecutionNode> getActiveNodes() { |
| if (_activeNodes == null) { |
| Set<ExecutionNode> ens = getExecutionNodes(); |
| if (ens != null) { |
| _activeNodes = new LinkedHashSet<ExecutionNode>(); |
| for (ExecutionNode en : ens) { |
| if (en.isEngineActive()) { |
| _activeNodes.add(en); |
| } |
| } |
| } |
| } |
| return _activeNodes; |
| } |
| |
| public Chain getChain() { |
| return chain; |
| } |
| |
| public boolean isChainAvailable() { |
| Set<ExecutionNode> nodes = getExecutionNodes(); |
| if (nodes == null) { |
| return false; |
| } |
| for (ExecutionNode node : getExecutionNodes()) { |
| if (!node.isOptional() && !node.isEngineActive()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| public class ExecutionNode { |
| |
| private final NonLiteral node; |
| private final TripleCollection ep; |
| private final boolean optional; |
| private final String engineName; |
| |
| public ExecutionNode(TripleCollection executionPlan, NonLiteral node) { |
| this.node = node; |
| this.ep = executionPlan; |
| this.optional = ExecutionPlanHelper.isOptional(ep, node); |
| this.engineName = ExecutionPlanHelper.getEngine(ep, node); |
| } |
| |
| public boolean isOptional() { |
| return optional; |
| } |
| |
| public String getEngineName() { |
| return engineName; |
| } |
| |
| public EnhancementEngine getEngine() { |
| return engineManager.getEngine(engineName); |
| } |
| |
| public boolean isEngineActive() { |
| return engineManager.isEngine(engineName); |
| } |
| |
| @Override |
| public int hashCode() { |
| return node.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return o instanceof ExecutionNode && ((ExecutionNode) o).node.equals(node); |
| } |
| } |
| } |