| /* |
| * 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. |
| */ |
| /* |
| * To change this template, choose Tools | Templates |
| * and open the template in the editor. |
| */ |
| |
| package org.apache.stanbol.rules.web.resources; |
| |
| import static javax.ws.rs.core.MediaType.TEXT_HTML; |
| import static javax.ws.rs.core.Response.Status.BAD_REQUEST; |
| //import static org.apache.stanbol.commons.web.base.CorsHelper.addCORSOrigin; |
| //import static org.apache.stanbol.commons.web.base.CorsHelper.enableCORS; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.List; |
| |
| //import javax.servlet.ServletContext; |
| import javax.ws.rs.Consumes; |
| import javax.ws.rs.DELETE; |
| import javax.ws.rs.GET; |
| import javax.ws.rs.OPTIONS; |
| import javax.ws.rs.POST; |
| import javax.ws.rs.PUT; |
| import javax.ws.rs.Path; |
| import javax.ws.rs.PathParam; |
| import javax.ws.rs.Produces; |
| import javax.ws.rs.QueryParam; |
| import javax.ws.rs.WebApplicationException; |
| import javax.ws.rs.core.Context; |
| import javax.ws.rs.core.HttpHeaders; |
| import javax.ws.rs.core.MediaType; |
| import javax.ws.rs.core.Response; |
| import javax.ws.rs.core.Response.ResponseBuilder; |
| import javax.ws.rs.core.Response.Status; |
| |
| import org.apache.clerezza.jaxrs.utils.form.MultiPartBody; |
| import org.apache.clerezza.commons.rdf.IRI; |
| import org.apache.felix.scr.annotations.Component; |
| import org.apache.felix.scr.annotations.Property; |
| import org.apache.felix.scr.annotations.Reference; |
| import org.apache.felix.scr.annotations.Service; |
| import org.apache.stanbol.commons.web.viewable.Viewable; |
| //import org.apache.stanbol.commons.web.base.ContextHelper; |
| import org.apache.stanbol.commons.web.base.format.KRFormat; |
| import org.apache.stanbol.commons.web.base.resource.BaseStanbolResource; |
| import org.apache.stanbol.rules.base.api.AlreadyExistingRecipeException; |
| import org.apache.stanbol.rules.base.api.NoSuchRecipeException; |
| import org.apache.stanbol.rules.base.api.NoSuchRuleInRecipeException; |
| import org.apache.stanbol.rules.base.api.Recipe; |
| import org.apache.stanbol.rules.base.api.RecipeConstructionException; |
| import org.apache.stanbol.rules.base.api.RecipeEliminationException; |
| import org.apache.stanbol.rules.base.api.Rule; |
| import org.apache.stanbol.rules.base.api.RuleAdapter; |
| import org.apache.stanbol.rules.base.api.RuleAdapterManager; |
| import org.apache.stanbol.rules.base.api.RuleAtomCallExeption; |
| import org.apache.stanbol.rules.base.api.RuleStore; |
| import org.apache.stanbol.rules.base.api.UnavailableRuleObjectException; |
| import org.apache.stanbol.rules.base.api.UnsupportedTypeForExportException; |
| import org.apache.stanbol.rules.base.api.util.RecipeList; |
| import org.apache.stanbol.rules.base.api.util.RuleList; |
| import org.apache.stanbol.rules.manager.RecipeImpl; |
| import org.codehaus.jettison.json.JSONArray; |
| import org.codehaus.jettison.json.JSONException; |
| import org.codehaus.jettison.json.JSONObject; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| //import com.sun.jersey.api.view.ImplicitProduces; |
| //import com.sun.jersey.multipart.FormDataParam; |
| |
| /** |
| * |
| * @author elvio, anuzzolese |
| * |
| */ |
| @Component |
| @Service(Object.class) |
| @Property(name="javax.ws.rs", boolValue=true) |
| @Path("/rules") |
| //@ImplicitProduces(MediaType.TEXT_HTML + ";qs=2") |
| public class RulesResource extends BaseStanbolResource { |
| |
| private Logger log = LoggerFactory.getLogger(getClass()); |
| |
| @Reference |
| private RuleStore ruleStore; |
| |
| @Reference |
| private RuleAdapterManager adapterManager; |
| |
| /** |
| * To get the RuleStoreImpl where are stored the rules and the recipes |
| * |
| * @param servletContext |
| * {To get the context where the REST service is running.} |
| */ |
| // public RulesResource(@Context ServletContext servletContext) { |
| // this.ruleStore = (RuleStore) ContextHelper.getServiceFromContext(RuleStore.class, servletContext); |
| // this.adapterManager = (RuleAdapterManager) ContextHelper.getServiceFromContext( |
| // RuleAdapterManager.class, servletContext); |
| // } |
| |
| class RulesResourceResultData extends ResultData{ |
| |
| } |
| @GET |
| @Produces(TEXT_HTML) |
| public Response get(@Context HttpHeaders headers) { |
| ResponseBuilder responseBuilder = Response.ok(new Viewable("index", new RulesResourceResultData()), TEXT_HTML); |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| } |
| |
| /** |
| * It returns the list of recipes whose descriptions match the string passed in the description parameter.<br> |
| * If some recipe matches the description passed a 200 code with the list of recipes is returned. |
| * Otherwise a 404 status code is returned. |
| * |
| * @param description |
| * {@link String} |
| * @return <ul> |
| * <li>200: The list of recipe matching the description provided is returned</li> |
| * <li>404: No recipe matches the description provided</li> |
| * </ul> |
| */ |
| @GET |
| @Produces(value = {MediaType.APPLICATION_JSON, KRFormat.RDF_XML, KRFormat.TURTLE, KRFormat.OWL_XML, |
| KRFormat.RDF_JSON, KRFormat.FUNCTIONAL_OWL, KRFormat.MANCHESTER_OWL, |
| MediaType.TEXT_PLAIN}) |
| @Path("/find/recipes") |
| public Response findRecipes(@QueryParam("description") String description) { |
| |
| log.info("Searching for recipes with description like to {}.", description); |
| |
| RecipeList recipes = ruleStore.findRecipesByDescription(description); |
| |
| log.info("The recipe list is emplty? {} ", recipes.isEmpty()); |
| if (recipes.isEmpty()) { |
| return Response.status(Status.NOT_FOUND).build(); |
| } |
| |
| return Response.ok(recipes).build(); |
| |
| } |
| |
| /** |
| * It returns the list of rule whose names or descriptions match the string passed in the parameter.<br> |
| * If the name parameter is not null the search will be executed on that parameter, otherwise it run on |
| * the description parameter. If both are bound the search will be executed on both.<br/> |
| * If some rule matches the description passed a 200 code with the list of recipes is returned. Otherwise |
| * a 404 status code is returned. |
| * |
| * @param description |
| * {@link String} |
| * @return <ul> |
| * <li>200: The list of recipe matching the description provided is returned</li> |
| * <li>404: No recipe matches the description provided</li> |
| * </ul> |
| */ |
| @GET |
| @Produces(value = {MediaType.APPLICATION_JSON, KRFormat.RDF_XML, KRFormat.TURTLE, KRFormat.OWL_XML, |
| KRFormat.RDF_JSON, KRFormat.FUNCTIONAL_OWL, KRFormat.MANCHESTER_OWL, |
| MediaType.TEXT_PLAIN}) |
| @Path("/find/rules") |
| public Response findRules(@QueryParam("name") String name, @QueryParam("description") String description) { |
| RuleList rules = new RuleList(); |
| if (name != null && !name.isEmpty()) { |
| rules.addAll(ruleStore.findRulesByName(name)); |
| } else { |
| rules.addAll(ruleStore.findRulesByDescription(description)); |
| } |
| |
| if (rules.isEmpty()) { |
| return Response.status(Status.NOT_FOUND).build(); |
| } |
| |
| return Response.ok(rules).build(); |
| |
| } |
| |
| /** |
| * Get a recipe from the rule base (that is the ontology that contains the rules and the recipe). <br/> |
| * If the second parameter is not null then the method returns the rule in the recipe identified by that |
| * parameter. <br/> |
| * |
| * curl -v -X GET http://localhost:8080/kres/rule/http |
| * ://kres.iks-project.eu/ontology/meta/rmi.owl#ProvaParentRule |
| * |
| * @param uri |
| * {A string contains the IRI full name of the rule.} |
| * @return Return: <br/> |
| * 200 The rule is retrieved (import declarations point to KReS Services) <br/> |
| * 404 The rule does not exists in the manager <br/> |
| * 500 Some error occurred |
| * |
| */ |
| @GET |
| @Path("/recipe/{recipe:.+}") |
| @Produces(value = {KRFormat.RDF_XML, KRFormat.TURTLE, KRFormat.OWL_XML, KRFormat.RDF_JSON, |
| KRFormat.FUNCTIONAL_OWL, KRFormat.MANCHESTER_OWL, MediaType.TEXT_PLAIN}) |
| public Response getRule(@PathParam("recipe") String recipeID, |
| @QueryParam("rule") String ruleID, |
| @Context HttpHeaders headers) { |
| |
| Recipe recipe; |
| Rule rule; |
| |
| ResponseBuilder responseBuilder; |
| try { |
| |
| URI uri = new URI(recipeID); |
| if(uri.getScheme() == null){ |
| recipeID = "urn:" + recipeID; |
| log.info("The recipe ID is a URI without scheme. The ID is set to " + recipeID); |
| } |
| |
| recipe = ruleStore.getRecipe(new IRI(recipeID)); |
| |
| if (ruleID != null && !ruleID.isEmpty()) { |
| rule = ruleStore.getRule(recipe, new IRI(ruleID)); |
| RuleList ruleList = new RuleList(); |
| ruleList.add(rule); |
| |
| recipe = new RecipeImpl(recipe.getRecipeID(), recipe.getRecipeDescription(), ruleList); |
| } |
| |
| responseBuilder = Response.ok(recipe); |
| |
| } catch (NoSuchRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } catch (RecipeConstructionException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NO_CONTENT); |
| } catch (NoSuchRuleInRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } catch (URISyntaxException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| } |
| |
| @GET |
| @Path("/recipe/{recipe:.+}") |
| @Produces(value = {MediaType.TEXT_HTML}) |
| public Response showRecipe(@PathParam("recipe") String recipeID, |
| @QueryParam("rule") String ruleID, |
| @Context HttpHeaders headers) { |
| |
| Recipe recipe; |
| Rule rule; |
| |
| ResponseBuilder responseBuilder; |
| try { |
| |
| URI uri = new URI(recipeID); |
| if(uri.getScheme() == null){ |
| recipeID = "urn:" + recipeID; |
| log.info("The recipe ID is a URI without scheme. The ID is set to " + recipeID); |
| } |
| |
| recipe = ruleStore.getRecipe(new IRI(recipeID)); |
| |
| if (ruleID != null && !ruleID.isEmpty()) { |
| rule = ruleStore.getRule(recipe, new IRI(ruleID)); |
| RuleList ruleList = new RuleList(); |
| ruleList.add(rule); |
| |
| recipe = new RecipeImpl(recipe.getRecipeID(), recipe.getRecipeDescription(), ruleList); |
| } |
| |
| responseBuilder = Response.ok(new Viewable("rules", new RulesPrettyPrintResource( |
| uriInfo, recipe))); |
| |
| } catch (NoSuchRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } catch (RecipeConstructionException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NO_CONTENT); |
| } catch (NoSuchRuleInRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } catch (URISyntaxException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| } |
| |
| /** |
| * This method implements a REST service that allows to create a new empty recipe in the store with a |
| * given description.<br/> |
| * The description parameter is OPTIONAL. |
| * |
| * @param recipeID |
| * {@link String} |
| * @param description |
| * {@link String} - OPTIONAL |
| * @param headers |
| * {@link HttpHeaders} |
| * @return <ul> |
| * <li>200 - if the recipe is created</li> |
| * <li>409 - if a recipe with the same identifier exists in the store</li> |
| * </ul> |
| */ |
| @PUT |
| @Consumes(MediaType.WILDCARD) |
| @Path("/recipe/{recipe:.+}") |
| public Response createRecipe(@PathParam("recipe") String recipeID, |
| @QueryParam("description") String description, |
| @Context HttpHeaders headers) { |
| |
| ResponseBuilder responseBuilder; |
| try { |
| |
| URI uri = new URI(recipeID); |
| if(uri.getScheme() == null){ |
| recipeID = "urn:" + recipeID; |
| log.info("The recipe ID is a URI without scheme. The ID is set to " + recipeID); |
| } |
| ruleStore.createRecipe(new IRI(recipeID), description); |
| |
| responseBuilder = Response.ok(); |
| } catch (AlreadyExistingRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.CONFLICT); |
| } catch (URISyntaxException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| |
| } |
| |
| @GET |
| @Path("/recipe") |
| @Produces(value = {KRFormat.RDF_XML, KRFormat.TURTLE, KRFormat.OWL_XML, KRFormat.RDF_JSON, |
| KRFormat.FUNCTIONAL_OWL, KRFormat.MANCHESTER_OWL}) |
| public Response listRecipes(@Context HttpHeaders headers) { |
| ResponseBuilder responseBuilder = null; |
| try { |
| RecipeList recipeList = getListRecipes(); |
| responseBuilder = Response.ok(recipeList); |
| } catch (NoSuchRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } catch (RecipeConstructionException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.INTERNAL_SERVER_ERROR); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| } |
| |
| public RecipeList getListRecipes() throws NoSuchRecipeException, RecipeConstructionException { |
| return ruleStore.listRecipes(); |
| } |
| |
| /** |
| * This method allows to delete a recipe or a rule from the store.<br/> |
| * If the optional rule identifier id provided as second parameter that the rule is deleted. Otherwise it |
| * is the whole recipe to be deleted. |
| * |
| * @param recipe |
| * {@link String} |
| * @param rule |
| * {@link String} - OPTIONAL |
| * @param headers |
| * {@link HttpHeaders} |
| * @return <ul> |
| * <li>200 - if either the recipe or the rule is deleted</li> |
| * <li>204 - it is not possible to delete the rule because the internal construction of the recipe |
| * failed</li> |
| * <li>404 - the rule does not exist</li> |
| * <li>412 - the recipe to which the rule belongs does not exist</li> |
| * <li>500 - if a {@link RecipeEliminationException} exception is thrown</li> |
| * </ul> |
| */ |
| @DELETE |
| @Path("/recipe/{recipe:.+}") |
| public Response removeRecipe(@PathParam("recipe") String recipe, |
| @QueryParam("rule") String rule, |
| @Context HttpHeaders headers) { |
| |
| ResponseBuilder responseBuilder; |
| |
| boolean stop = false; |
| |
| URI uri = null; |
| try { |
| uri = new URI(recipe); |
| } catch (URISyntaxException e1) { |
| log.error(e1.getMessage(), e1); |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| stop = true; |
| } |
| |
| if(!stop){ |
| if(uri != null && uri.getScheme() == null){ |
| recipe = "urn:" + recipe; |
| log.info("The recipe ID is a URI without scheme. The ID is set to " + recipe); |
| } |
| |
| log.info("The recipe ID is : " + recipe); |
| |
| if (rule != null && !rule.isEmpty()) { |
| |
| Recipe rcp; |
| try { |
| rcp = ruleStore.getRecipe(new IRI(recipe)); |
| Rule rl = ruleStore.getRule(rcp, new IRI(rule)); |
| ruleStore.removeRule(rcp, rl); |
| } catch (NoSuchRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.PRECONDITION_FAILED); |
| } catch (RecipeConstructionException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NO_CONTENT); |
| } catch (NoSuchRuleInRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } |
| |
| } else { |
| try { |
| ruleStore.removeRecipe(new IRI(recipe)); |
| } catch (RecipeEliminationException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.INTERNAL_SERVER_ERROR); |
| } |
| } |
| } |
| |
| responseBuilder = Response.ok(); |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| |
| } |
| |
| /** |
| * Add rules to a recipe. An optional description can be provided to the rules. |
| * |
| * @param recipe |
| * {A string contains the IRI of the recipe to be added} |
| * @param rules |
| * {A string contains the rules in Stanbol syntax} |
| * @param description |
| * {A string contains a description of the rule} |
| * @param headers |
| * {The {@link HttpHeaders} |
| * @return Return: <br/> |
| * 200 The recipe has been added<br/> |
| * 409 The recipe has not been added<br/> |
| * 500 Some error occurred |
| */ |
| @POST |
| @Consumes(MediaType.MULTIPART_FORM_DATA) |
| @Produces(value = {KRFormat.TEXT_PLAIN, KRFormat.RDF_JSON}) |
| @Path("/recipe/{recipe:.+}") |
| public Response addRulesToRecipe(@PathParam(value = "recipe") String recipe, |
| MultiPartBody data, |
| @Context HttpHeaders headers) { |
| |
| String description = null; |
| InputStream rules = null; |
| |
| if(data.getTextParameterValues("description") != null){ |
| description = data.getTextParameterValues("description") [0]; |
| } |
| if(data.getFormFileParameterValues("rules") != null){ |
| rules = new ByteArrayInputStream(data.getFormFileParameterValues("rules") [0].getContent()); |
| } |
| |
| if(recipe == null || rules == null || description == null){ |
| throw new WebApplicationException(BAD_REQUEST); |
| } |
| |
| ResponseBuilder responseBuilder; |
| |
| Recipe rcp; |
| try { |
| |
| URI uri = new URI(recipe); |
| if(uri.getScheme() == null){ |
| recipe = "urn:" + recipe; |
| log.info("The recipe ID is a URI without scheme. The ID is set to " + recipe); |
| } |
| |
| rcp = ruleStore.getRecipe(new IRI(recipe)); |
| ruleStore.addRulesToRecipe(rcp, rules, description); |
| |
| responseBuilder = Response.ok(); |
| } catch (NoSuchRecipeException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } catch (RecipeConstructionException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.INTERNAL_SERVER_ERROR); |
| } catch (URISyntaxException e) { |
| log.error(e.getMessage(), e); |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| } |
| |
| /** |
| * Return the String representation of a recipe adapted to another format, e.g., Jena rules, SPARQL |
| * CONSTRUCTs, Clerezza, SWRL, etc. |
| * |
| * @param recipe |
| * {The ID of the recipe} |
| * @param format |
| * {The canonical name of the class we want have back, e.g., |
| * org.apache.stanbol.rules.base.api.Rule for Jena Rules} |
| * @param headers |
| * {@link HttpHeaders} |
| * @return <ul> |
| * <li>200: it works properly and the string representation of the recipe according to the format |
| * provided is returned</li> |
| * <li>204: the recipe does not exist in the store</li> |
| * <li>403: a class exists for the format provided but there is no adapter for that</li> |
| * <li>404: no class exists in the context for the format provided</li> |
| * <li>406: some error occurred while converting a rule of the recipe</li> |
| * <li>409: some atom of a rule in the recipe cannot be converted to the format provided</li> |
| * </ul> |
| */ |
| @GET |
| @Produces(value = {KRFormat.RDF_JSON}) |
| @Path("/adapters/{recipe:.+}") |
| public Response adaptTo(@PathParam("recipe") String recipe, |
| @QueryParam("format") String format, |
| @Context HttpHeaders headers) { |
| |
| ResponseBuilder responseBuilder = null; |
| |
| Class<?> classToLoad; |
| try { |
| // ClassLoader loader = Thread.currentThread().getContextClassLoader(); |
| // classToLoad = loader.loadClass(format); |
| classToLoad = Class.forName(format); |
| |
| URI uri = new URI(recipe); |
| if(uri.getScheme() == null){ |
| recipe = "urn:" + recipe; |
| log.info("The recipe ID is a URI without scheme. The ID is set to " + recipe); |
| } |
| |
| Recipe rcp = ruleStore.getRecipe(new IRI(recipe)); |
| RuleAdapter adapter = adapterManager.getAdapter(rcp, classToLoad); |
| |
| Object adaptedRecipe = adapter.adaptTo(rcp, classToLoad); |
| |
| JSONObject jsonObject = new JSONObject(); |
| try { |
| jsonObject.put("recipe", rcp.getRecipeID().toString()); |
| jsonObject.put("adaptedTo", format); |
| jsonObject.put("result", adaptedRecipe.toString()); |
| } catch (JSONException e) { |
| log.error(e.getMessage(), e); |
| } |
| |
| responseBuilder = Response.ok(jsonObject.toString()); |
| |
| } catch (ClassNotFoundException e) { |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| log.error(e.getMessage(), e); |
| } catch (NoSuchRecipeException e) { |
| responseBuilder = Response.status(Status.NO_CONTENT); |
| log.error(e.getMessage(), e); |
| } catch (RecipeConstructionException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } catch (UnavailableRuleObjectException e) { |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| log.error(e.getMessage(), e); |
| } catch (RuleAtomCallExeption e) { |
| responseBuilder = Response.status(Status.CONFLICT); |
| log.error(e.getMessage(), e); |
| } catch (UnsupportedTypeForExportException e) { |
| responseBuilder = Response.status(Status.FORBIDDEN); |
| log.error(e.getMessage(), e); |
| } catch (URISyntaxException e) { |
| responseBuilder = Response.status(Status.NOT_ACCEPTABLE); |
| log.error(e.getMessage(), e); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| |
| } |
| |
| /** |
| * It returns the list of available {@link RuleAdapter} instances. |
| * |
| * @param headers |
| * {@link HttpHeaders} |
| * @return <ul> |
| * <li>A JSON array containing available adapters.<br/> |
| * Each element of the array is an object composed by the following fields: |
| * <ul> |
| * <li>adapter: the canonical name of the adapter class;</li> |
| * <li>adapter: the canonical name of the instances' class that the adapter provide as output.</li> |
| * </ul> |
| * </li> |
| * <li>404: No adapter exists</li> |
| * </ul> |
| */ |
| @GET |
| @Produces(value = {KRFormat.RDF_JSON}) |
| @Path("/adapters") |
| public Response listAdaptersService(@Context HttpHeaders headers) { |
| |
| ResponseBuilder responseBuilder = null; |
| |
| List<RuleAdapter> adapters = getListAdapters(); |
| |
| if (adapters != null && !adapters.isEmpty()) { |
| JSONObject jsonObject = new JSONObject(); |
| JSONArray jsonArray = new JSONArray(); |
| |
| for (RuleAdapter adapter : adapters) { |
| JSONObject jsonAdapter = new JSONObject(); |
| try { |
| jsonAdapter.put("adapter", adapter.getClass().getCanonicalName()); |
| jsonAdapter.put("adaptTo", adapter.getExportClass().getCanonicalName()); |
| } catch (JSONException e) { |
| log.error(e.getMessage(), e); |
| } |
| |
| jsonArray.put(jsonAdapter); |
| } |
| |
| try { |
| jsonObject.put("adapters", jsonArray); |
| } catch (JSONException e) { |
| log.error(e.getMessage(), e); |
| } |
| |
| responseBuilder = Response.ok(jsonObject.toString()); |
| } else { |
| responseBuilder = Response.status(Status.NOT_FOUND); |
| } |
| |
| // addCORSOrigin(servletContext, responseBuilder, headers); |
| return responseBuilder.build(); |
| |
| } |
| |
| public List<RuleAdapter> getListAdapters() { |
| |
| return adapterManager.listRuleAdapters(); |
| |
| } |
| |
| @OPTIONS |
| public Response handleCorsPreflight(@Context HttpHeaders headers) { |
| ResponseBuilder rb = Response.ok(); |
| // enableCORS(servletContext, rb, headers); |
| return rb.build(); |
| } |
| |
| } |
