ScopeResource.java

/*
 * 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.ontologymanager.web.resources;

import static javax.ws.rs.core.MediaType.APPLICATION_JSON;
import static javax.ws.rs.core.MediaType.MULTIPART_FORM_DATA;
import static javax.ws.rs.core.MediaType.TEXT_HTML;
import static javax.ws.rs.core.MediaType.TEXT_PLAIN;
import static javax.ws.rs.core.Response.Status.BAD_REQUEST;
import static javax.ws.rs.core.Response.Status.CONFLICT;
import static javax.ws.rs.core.Response.Status.FORBIDDEN;
import static javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR;
import static javax.ws.rs.core.Response.Status.NOT_FOUND;
import static org.apache.stanbol.commons.web.base.format.KRFormat.FUNCTIONAL_OWL;
import static org.apache.stanbol.commons.web.base.format.KRFormat.MANCHESTER_OWL;
import static org.apache.stanbol.commons.web.base.format.KRFormat.N3;
import static org.apache.stanbol.commons.web.base.format.KRFormat.N_TRIPLE;
import static org.apache.stanbol.commons.web.base.format.KRFormat.OWL_XML;
import static org.apache.stanbol.commons.web.base.format.KRFormat.RDF_JSON;
import static org.apache.stanbol.commons.web.base.format.KRFormat.RDF_XML;
import static org.apache.stanbol.commons.web.base.format.KRFormat.TURTLE;
import static org.apache.stanbol.commons.web.base.format.KRFormat.X_TURTLE;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

import javax.servlet.ServletContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
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 javax.ws.rs.core.UriInfo;

import org.apache.clerezza.jaxrs.utils.form.FormFile;
import org.apache.clerezza.jaxrs.utils.form.MultiPartBody;
import org.apache.clerezza.commons.rdf.ImmutableGraph;
import org.apache.clerezza.commons.rdf.Graph;
import org.apache.clerezza.rdf.core.access.TcProvider;
import org.apache.clerezza.rdf.core.serializedform.Parser;
import org.apache.clerezza.rdf.core.serializedform.UnsupportedFormatException;
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.owl.util.OWLUtils;
import org.apache.stanbol.commons.owl.util.URIUtils;
import org.apache.stanbol.commons.web.viewable.Viewable;
import org.apache.stanbol.ontologymanager.registry.api.RegistryManager;
import org.apache.stanbol.ontologymanager.registry.api.model.Library;
import org.apache.stanbol.ontologymanager.registry.io.LibrarySource;
import org.apache.stanbol.ontologymanager.servicesapi.collector.DuplicateIDException;
import org.apache.stanbol.ontologymanager.servicesapi.collector.IrremovableOntologyException;
import org.apache.stanbol.ontologymanager.servicesapi.collector.OntologyCollectorModificationException;
import org.apache.stanbol.ontologymanager.servicesapi.collector.UnmodifiableOntologyCollectorException;
import org.apache.stanbol.ontologymanager.servicesapi.io.OntologyInputSource;
import org.apache.stanbol.ontologymanager.servicesapi.io.SetInputSource;
import org.apache.stanbol.ontologymanager.servicesapi.io.StoredOntologySource;
import org.apache.stanbol.ontologymanager.servicesapi.ontology.OntologyLoadingException;
import org.apache.stanbol.ontologymanager.servicesapi.ontology.OntologyProvider;
import org.apache.stanbol.ontologymanager.servicesapi.scope.OntologySpace;
import org.apache.stanbol.ontologymanager.servicesapi.scope.Scope;
import org.apache.stanbol.ontologymanager.servicesapi.scope.ScopeManager;
import org.apache.stanbol.ontologymanager.servicesapi.util.OntologyUtils;
import org.apache.stanbol.ontologymanager.sources.clerezza.GraphContentInputSource;
import org.apache.stanbol.ontologymanager.sources.clerezza.GraphSource;
import org.apache.stanbol.ontologymanager.sources.owlapi.RootOntologySource;
import org.apache.stanbol.ontologymanager.web.util.OntologyPrettyPrintResource;
import org.coode.owlapi.manchesterowlsyntax.ManchesterOWLSyntaxOntologyFormat;
import org.semanticweb.owlapi.model.IRI;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.model.OWLOntologyCreationException;
import org.semanticweb.owlapi.model.OWLOntologyID;
import org.semanticweb.owlapi.model.OWLOntologyStorageException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The REST resource of an OntoNet {@link OntologyScope} whose identifier is known.
 * 
 * @author alexdma
 * 
 */
@Component
@Service(Object.class)
@Property(name = "javax.ws.rs", boolValue = true)
@Path("/ontonet/ontology/{scopeid}")
public class ScopeResource extends AbstractOntologyAccessResource {

    private Logger log = LoggerFactory.getLogger(getClass());

    /*
     * Placeholder for the ONManager to be fetched from the servlet context.
     */
    @Reference
    protected ScopeManager onm;
    @Reference
    protected OntologyProvider<TcProvider> ontologyProvider;

    /*
     * Placeholder for the RegistryManager to be fetched from the servlet context.
     */
    @Reference
    protected RegistryManager regMgr;

    protected Scope scope;

    public ScopeResource() {
        super();
        // log.info("<init> with scope {}", scopeId);
        //
        // this.servletContext = servletContext;
        // this.onm = (ScopeManager) ContextHelper.getServiceFromContext(ScopeManager.class, servletContext);
        // this.regMgr = (RegistryManager) ContextHelper.getServiceFromContext(RegistryManager.class,
        // servletContext);
        // this.ontologyProvider = (OntologyProvider<TcProvider>) ContextHelper.getServiceFromContext(
        // OntologyProvider.class, servletContext);

        // if (scopeId == null || scopeId.isEmpty()) {
        // log.error("Missing path parameter scopeid={}", scopeId);
        // throw new WebApplicationException(NOT_FOUND);
        // }
        // scope = onm.getScope(scopeId);

        // // Skip null checks: the scope might be created with a PUT
        // if (scope == null) {
        // log.error("Scope {} not found", scopeId);
        // throw new WebApplicationException(NOT_FOUND);
        // }
    }

    @GET
    @Produces(value = {APPLICATION_JSON, N3, N_TRIPLE, RDF_JSON})
    public Response asOntologyGraph(@PathParam("scopeid") String scopeid,
                                    @DefaultValue("false") @QueryParam("merge") boolean merge,
                                    @Context HttpHeaders headers) {

        scope = onm.getScope(scopeid);

        if (scope == null) return Response.status(NOT_FOUND).build();
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        // Export to Clerezza ImmutableGraph, which can be rendered as JSON-LD.
        ResponseBuilder rb = Response.ok(scope.export(ImmutableGraph.class, merge, prefix));
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @GET
    @Produces(value = {RDF_XML, TURTLE, X_TURTLE})
    public Response asOntologyMixed(@PathParam("scopeid") String scopeid,
                                    @DefaultValue("false") @QueryParam("merge") boolean merge,
                                    @Context HttpHeaders headers) {
        scope = onm.getScope(scopeid);

        if (scope == null) return Response.status(NOT_FOUND).build();
        // Export smaller graphs to OWLOntology due to the more human-readable rendering.
        ResponseBuilder rb;
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        if (merge) rb = Response.ok(scope.export(ImmutableGraph.class, merge, prefix));
        else rb = Response.ok(scope.export(OWLOntology.class, merge, prefix));
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @GET
    @Produces(value = {MANCHESTER_OWL, FUNCTIONAL_OWL, OWL_XML, TEXT_PLAIN})
    public Response asOntologyOWL(@PathParam("scopeid") String scopeid,
                                  @DefaultValue("false") @QueryParam("merge") boolean merge,
                                  @Context HttpHeaders headers) {
        scope = onm.getScope(scopeid);

        if (scope == null) return Response.status(NOT_FOUND).build();
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        // Export to OWLOntology due to the more human-readable rendering.
        ResponseBuilder rb = Response.ok(scope.export(OWLOntology.class, merge, prefix));
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @DELETE
    public Response deregisterScope(@PathParam("scopeid") String scopeid,
                                    @Context UriInfo uriInfo,
                                    @Context HttpHeaders headers,
                                    @Context ServletContext servletContext) {
        scope = onm.getScope(scopeid);

        onm.deregisterScope(scope);
        scope = null;
        ResponseBuilder rb = Response.ok();
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    public SortedSet<String> getCoreOntologies() {
        SortedSet<String> result = new TreeSet<String>();
        for (OWLOntologyID id : scope.getCoreSpace().listManagedOntologies())
            result.add(OntologyUtils.encode(id));
        return result;
    }

    @GET
    @Path("/core")
    @Produces(value = {APPLICATION_JSON, N3, N_TRIPLE, RDF_JSON})
    public Response getCoreSpaceGraph(@PathParam("scopeid") String scopeid,
                                      @DefaultValue("false") @QueryParam("merge") boolean merge,
                                      @Context UriInfo uriInfo,
                                      @Context HttpHeaders headers) {
        scope = onm.getScope(scopeid);

        OntologySpace space = scope.getCoreSpace();
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        ImmutableGraph o = space.export(ImmutableGraph.class, merge, prefix);
        ResponseBuilder rb = Response.ok(o);
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @GET
    @Path("/core")
    @Produces(value = {RDF_XML, TURTLE, X_TURTLE, MANCHESTER_OWL, FUNCTIONAL_OWL, OWL_XML, TEXT_PLAIN})
    public Response getCoreSpaceOWL(@PathParam("scopeid") String scopeid,
                                    @DefaultValue("false") @QueryParam("merge") boolean merge,
                                    @Context UriInfo uriInfo,
                                    @Context HttpHeaders headers) {
        scope = onm.getScope(scopeid);

        OntologySpace space = scope.getCoreSpace();
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        OWLOntology o = space.export(OWLOntology.class, merge, prefix);
        ResponseBuilder rb = Response.ok(o);
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    private URI getCreatedResource(String ontologyIRI) {
        return URI.create("/" + ontologyIRI);
    }

    public SortedSet<String> getCustomOntologies() {
        SortedSet<String> result = new TreeSet<String>();
        for (OWLOntologyID id : scope.getCustomSpace().listManagedOntologies())
            result.add(OntologyUtils.encode(id));
        return result;
    }

    @GET
    @Path("/custom")
    @Produces(value = {APPLICATION_JSON, N3, N_TRIPLE, RDF_JSON})
    public Response getCustomSpaceGraph(@PathParam("scopeid") String scopeid,
                                        @DefaultValue("false") @QueryParam("merge") boolean merge,
                                        @Context UriInfo uriInfo,
                                        @Context HttpHeaders headers) {
        scope = onm.getScope(scopeid);

        OntologySpace space = scope.getCustomSpace();
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        ImmutableGraph o = space.export(ImmutableGraph.class, merge, prefix);
        ResponseBuilder rb = Response.ok(o);
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @GET
    @Path("/custom")
    @Produces(value = {RDF_XML, TURTLE, X_TURTLE, MANCHESTER_OWL, FUNCTIONAL_OWL, OWL_XML, TEXT_PLAIN})
    public Response getCustomSpaceOWL(@PathParam("scopeid") String scopeid,
                                      @DefaultValue("false") @QueryParam("merge") boolean merge,
                                      @Context UriInfo uriInfo,
                                      @Context HttpHeaders headers) {
        scope = onm.getScope(scopeid);

        OntologySpace space = scope.getCustomSpace();
        IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
        OWLOntology o = space.export(OWLOntology.class, merge, prefix);
        ResponseBuilder rb = Response.ok(o);
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @GET
    @Produces(TEXT_HTML)
    public Response getHtmlInfo(@PathParam("scopeid") String scopeid, @Context HttpHeaders headers) {
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);

        if (scope == null) rb = Response.status(NOT_FOUND);
        else rb = Response.ok(new Viewable("index", this)); // TODO move to a dedicated class
        rb.header(HttpHeaders.CONTENT_TYPE, TEXT_HTML + "; charset=utf-8");
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    public Set<Library> getLibraries() {
        return regMgr.getLibraries();
    }

    public SortedSet<String> getManageableOntologies() {
        SortedSet<String> result = new TreeSet<String>();
        // for (String s : ontologyProvider.getPublicKeys()) {
        // // String s1 = s.split("::")[1];
        // if (s != null && !s.isEmpty()) result.add(s);
        // }
        for (OWLOntologyID id : ontologyProvider.listPrimaryKeys())
            result.add(OntologyUtils.encode(id));
        for (OWLOntologyID id : scope.getCoreSpace().listManagedOntologies())
            result.remove(OntologyUtils.encode(id));
        for (OWLOntologyID id : scope.getCustomSpace().listManagedOntologies())
            result.remove(OntologyUtils.encode(id));
        return result;
    }

    /*
     * Needed for freemarker
     */
    public Scope getScope() {
        return scope;
    }

    @OPTIONS
    public Response handleCorsPreflight(@Context HttpHeaders headers) {
        ResponseBuilder rb = Response.ok();
        // enableCORS(servletContext, rb, headers, GET, POST, PUT, DELETE, OPTIONS);
        return rb.build();
    }

    @OPTIONS
    @Path("/core")
    public Response handleCorsPreflightCore(@Context HttpHeaders headers) {
        ResponseBuilder rb = Response.ok();
        // enableCORS(servletContext, rb, headers, GET, OPTIONS);
        return rb.build();
    }

    @OPTIONS
    @Path("/custom")
    public Response handleCorsPreflightCustom(@Context HttpHeaders headers) {
        ResponseBuilder rb = Response.ok();
        // enableCORS(servletContext, rb, headers, GET, OPTIONS);
        return rb.build();
    }

    @OPTIONS
    @Path("/{ontologyId:.+}")
    public Response handleCorsPreflightOntology(@Context HttpHeaders headers) {
        ResponseBuilder rb = Response.ok();
        // enableCORS(servletContext, rb, headers, GET, DELETE, OPTIONS);
        return rb.build();
    }

    /**
     * Gets the ontology with the given identifier in its version managed by the session.
     * 
     * @param sessionId
     *            the session identifier.
     * @param ontologyId
     *            the ontology identifier.
     * @param uriInfo
     * @param headers
     * @return the requested managed ontology, or {@link Status#NOT_FOUND} if either the sessionn does not
     *         exist, or the if the ontology either does not exist or is not managed.
     */
    @GET
    @Path("/{ontologyId:.+}")
    @Produces(value = {APPLICATION_JSON, N3, N_TRIPLE, RDF_JSON})
    public Response managedOntologyGetGraph(@PathParam("scopeid") String scopeid,
                                            @PathParam("ontologyId") String ontologyId,
                                            @DefaultValue("false") @QueryParam("merge") boolean merge,
                                            @Context UriInfo uriInfo,
                                            @Context HttpHeaders headers) {
        log.debug("Absolute URL Path {}", uriInfo.getRequestUri());
        log.debug("Ontology ID {}", ontologyId);
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);

        if (scope == null) rb = Response.status(NOT_FOUND);
        else {
            IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
            ImmutableGraph o = null;
            OWLOntologyID id = OntologyUtils.decode(ontologyId);
            OntologySpace spc = scope.getCustomSpace();
            if (spc != null && spc.hasOntology(id)) {
                o = spc.getOntology(id, ImmutableGraph.class, merge, prefix);
            } else {
                spc = scope.getCoreSpace();
                if (spc != null && spc.hasOntology(id)) o = spc.getOntology(id, ImmutableGraph.class, merge, prefix);
            }
            if (o == null) rb = Response.status(NOT_FOUND);
            else rb = Response.ok(o);
        }

        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    /**
     * Gets the ontology with the given identifier in its version managed by the session.
     * 
     * @param sessionId
     *            the session identifier.
     * @param ontologyId
     *            the ontology identifier.
     * @param uriInfo
     * @param headers
     * @return the requested managed ontology, or {@link Status#NOT_FOUND} if either the sessionn does not
     *         exist, or the if the ontology either does not exist or is not managed.
     */
    @GET
    @Path("/{ontologyId:.+}")
    @Produces(value = {RDF_XML, TURTLE, X_TURTLE, MANCHESTER_OWL, FUNCTIONAL_OWL, OWL_XML, TEXT_PLAIN})
    public Response managedOntologyGetOWL(@PathParam("scopeid") String scopeid,
                                          @PathParam("ontologyId") String ontologyId,
                                          @DefaultValue("false") @QueryParam("merge") boolean merge,
                                          @Context UriInfo uriInfo,
                                          @Context HttpHeaders headers) {
        log.debug("Absolute URL Path {}", uriInfo.getRequestUri());
        log.debug("Ontology ID {}", ontologyId);
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);

        if (scope == null) rb = Response.status(NOT_FOUND);
        else {
            IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
            OWLOntology o = null;
            OWLOntologyID id = OntologyUtils.decode(ontologyId);
            OntologySpace spc = scope.getCustomSpace();
            if (spc != null && spc.hasOntology(id)) {
                o = spc.getOntology(id, OWLOntology.class, merge, prefix);
            } else {
                spc = scope.getCoreSpace();
                if (spc != null && spc.hasOntology(id)) o = spc.getOntology(id, OWLOntology.class, merge,
                    prefix);
            }
            if (o == null) rb = Response.status(NOT_FOUND);
            else rb = Response.ok(o);
        }
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @GET
    @Path("/{ontologyId:.+}")
    @Produces(TEXT_HTML)
    public Response managedOntologyShow(@PathParam("scopeid") String scopeid,
                                        @PathParam("ontologyId") String ontologyId,
                                        @Context HttpHeaders headers) {
        ResponseBuilder rb;

        scope = onm.getScope(scopeid);
        if (scope == null) rb = Response.status(NOT_FOUND);
        else if (ontologyId == null || ontologyId.isEmpty()) rb = Response.status(BAD_REQUEST);
        else if (!ontologyProvider.hasOntology(OntologyUtils.decode(ontologyId))) rb = Response
                .status(NOT_FOUND);
        else {
            IRI prefix = IRI.create(getPublicBaseUri() + "ontonet/ontology/");
            OWLOntology o = scope.getCustomSpace().getOntology(OntologyUtils.decode(ontologyId),
                OWLOntology.class, false, prefix);
            if (o == null) o = scope.getCoreSpace().getOntology(OntologyUtils.decode(ontologyId),
                OWLOntology.class, false, prefix);
            if (o == null) rb = Response.status(NOT_FOUND);
            else try {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                o.getOWLOntologyManager().saveOntology(o, new ManchesterOWLSyntaxOntologyFormat(), out);
                rb = Response.ok(new Viewable("ontology",
                        new OntologyPrettyPrintResource(uriInfo, out, scope)));
            } catch (OWLOntologyStorageException e) {
                throw new WebApplicationException(e, INTERNAL_SERVER_ERROR);
            }
        }
        rb.header(HttpHeaders.CONTENT_TYPE, TEXT_HTML + "; charset=utf-8");
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    /**
     * Unloads an ontology from an ontology scope.
     * 
     * @param scopeId
     * @param ontologyid
     * @param uriInfo
     * @param headers
     */
    @DELETE
    @Path("/{ontologyId:.+}")
    public Response managedOntologyUnload(@PathParam("scopeid") String scopeid,
                                          @PathParam("ontologyId") String ontologyId,
                                          @PathParam("scopeid") String scopeId,
                                          @Context UriInfo uriInfo,
                                          @Context HttpHeaders headers) {
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);
        if (ontologyId != null && !ontologyId.trim().isEmpty()) {
            OWLOntologyID id = OntologyUtils.decode(ontologyId);
            OntologySpace cs = scope.getCustomSpace();
            if (!cs.hasOntology(id)) rb = Response.notModified(); // ontology not managed
            else try {
                onm.setScopeActive(scopeId, false);
                cs.removeOntology(id);
                rb = Response.ok();
            } catch (IrremovableOntologyException e) {
                throw new WebApplicationException(e, FORBIDDEN);
            } catch (UnmodifiableOntologyCollectorException e) {
                throw new WebApplicationException(e, FORBIDDEN);
            } catch (OntologyCollectorModificationException e) {
                throw new WebApplicationException(e, INTERNAL_SERVER_ERROR);
            } finally {
                onm.setScopeActive(scopeId, true);
            }
        } else rb = Response.status(BAD_REQUEST); // null/blank ontology ID
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    /**
     * Tells the scope that it should manage the ontology obtained by parsing the supplied content.<br>
     * <br>
     * Note that the PUT method cannot be used, as it is not possible to predict what ID the ontology will
     * have until it is parsed.
     * 
     * @param content
     *            the ontology content
     * @return {@link Status#OK} if the addition was successful, {@link Status#NOT_FOUND} if there is no such
     *         session at all, {@link Status#FORBIDDEN} if the session is locked or cannot modified for some
     *         other reason, {@link Status#INTERNAL_SERVER_ERROR} if some other error occurs.
     */
    @POST
    @Consumes(value = {RDF_XML, OWL_XML, N_TRIPLE, N3, TURTLE, X_TURTLE, FUNCTIONAL_OWL, MANCHESTER_OWL,
                       RDF_JSON})
    public Response manageOntology(InputStream content,
                                   @PathParam("scopeid") String scopeid,
                                   @Context HttpHeaders headers) {
        long before = System.currentTimeMillis();
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);
        if (scope == null) rb = Response.status(NOT_FOUND); // Always check session first
        else try {
            MediaType mt = headers.getMediaType();
            log.debug("POST content claimed to be of type {}.", mt);
            OWLOntologyID key = scope.getCustomSpace().addOntology(
            /*
             * For the time being, REST services operate in-memory (i.e. no TcProvider is supplied to the
             * input source). This means that only the final processed graph is stored.
             * 
             * TODO : we might find a reason to change that in the future.
             */
            new GraphContentInputSource(content, mt.toString(), ontologyProvider.getStore()));
            if (key == null || key.isAnonymous()) {
                log.error("FAILED parse with media type {}.", mt);
                throw new WebApplicationException(INTERNAL_SERVER_ERROR);
            }
            // FIXME ugly but will have to do for the time being
            log.debug("SUCCESS parse with media type {}.", mt);
            String uri = // key.split("::")[1];
            OntologyUtils.encode(key);
            // uri = uri.substring((ontologyProvider.getGraphPrefix() + "::").length());
            URI created = null;
            if (uri != null && !uri.isEmpty()) {
                created = getCreatedResource(uri);
                rb = Response.created(created);
            } else rb = Response.ok();
            log.info("POST request for ontology addition completed in {} ms.",
                (System.currentTimeMillis() - before));
            log.info("New resource URL is {}", created);
        } catch (UnmodifiableOntologyCollectorException e) {
            throw new WebApplicationException(e, FORBIDDEN);
        }
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    /**
     * Tells the session that it should manage the ontology obtained by dereferencing the supplied IRI.<br>
     * <br>
     * Note that the PUT method cannot be used, as it is not possible to predict what ID the ontology will
     * have until it is parsed.
     * 
     * @param content
     *            the ontology physical IRI
     * @return {@link Status#OK} if the addition was successful, {@link Status#NOT_FOUND} if there is no such
     *         session at all, {@link Status#FORBIDDEN} if the session is locked or cannot modified for some
     *         other reason, {@link Status#INTERNAL_SERVER_ERROR} if some other error occurs.
     */
    @POST
    @Consumes(value = MediaType.TEXT_PLAIN)
    public Response manageOntology(String iri,
                                   @PathParam("scopeid") String scopeid,
                                   @Context HttpHeaders headers) {
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);
        if (scope == null) rb = Response.status(NOT_FOUND);
        else try {
            OWLOntologyID key = scope.getCustomSpace().addOntology(new RootOntologySource(IRI.create(iri)));
            URI created = getCreatedResource(OntologyUtils.encode(key));
            rb = Response.created(created);
        } catch (UnmodifiableOntologyCollectorException e) {
            throw new WebApplicationException(e, FORBIDDEN);
        } catch (OWLOntologyCreationException e) {
            throw new WebApplicationException(e, INTERNAL_SERVER_ERROR);
        }
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    @POST
    @Consumes({MULTIPART_FORM_DATA})
    @Produces({TEXT_HTML, TEXT_PLAIN, RDF_XML, TURTLE, X_TURTLE, N3})
    public Response postOntology(MultiPartBody data,
                                 @PathParam("scopeid") String scopeid,
                                 @Context HttpHeaders headers) {
        log.info(" post(MultiPartBody data) scope: {}", scopeid);
        ResponseBuilder rb;
        scope = onm.getScope(scopeid);

        // TODO remove and make sure it is set across the method
        rb = Response.status(BAD_REQUEST);

        IRI location = null, library = null;
        FormFile file = null; // If found, it takes precedence over location.
        String format = null;
        Set<String> keys = new HashSet<String>();

        // for (BodyPart bpart : data.getBodyParts()) {
        // log.debug("is a {}", bpart.getClass());
        // if (bpart instanceof FormDataBodyPart) {
        // FormDataBodyPart dbp = (FormDataBodyPart) bpart;
        // String name = dbp.getName();
        // if (name.equals("file")) file = bpart.getEntityAs(File.class);
        // else {
        // String value = dbp.getValue();
        // if (name.equals("format") && !value.equals("auto")) format = value;
        // else if (name.equals("url")) try {
        // URI.create(value); // To throw 400 if malformed.
        // location = IRI.create(value);
        // } catch (Exception ex) {
        // log.error("Malformed IRI for " + value, ex);
        // throw new WebApplicationException(ex, BAD_REQUEST);
        // }
        // else if (name.equals("library") && !"null".equals(value)) try {
        // URI.create(value); // To throw 400 if malformed.
        // library = IRI.create(value);
        // } catch (Exception ex) {
        // log.error("Malformed IRI for " + value, ex);
        // throw new WebApplicationException(ex, BAD_REQUEST);
        // }
        // else if (name.equals("stored") && !"null".equals(value)) {
        // log.info("Request to manage ontology with key {}", value);
        // keys.add(value);
        // }
        // }
        //
        // }
        // }

        if (data.getFormFileParameterValues("file").length > 0) {
            file = data.getFormFileParameterValues("file")[0];
        }
        // else {
        if (data.getTextParameterValues("format").length > 0) {
            String value = data.getTextParameterValues("format")[0];
            if (!value.equals("auto")) {
                format = value;
            }
        }
        if (data.getTextParameterValues("url").length > 0) {
            String value = data.getTextParameterValues("url")[0];
            try {
                URI.create(value); // To throw 400 if malformed.
                location = IRI.create(value);
            } catch (Exception ex) {
                log.error("Malformed IRI for param url " + value, ex);
                throw new WebApplicationException(ex, BAD_REQUEST);
            }
        }
        if (data.getTextParameterValues("library").length > 0) {
            String value = data.getTextParameterValues("library")[0];
            try {
                URI.create(value); // To throw 400 if malformed.
                library = IRI.create(value);
            } catch (Exception ex) {
                log.error("Malformed IRI for param library " + value, ex);
                throw new WebApplicationException(ex, BAD_REQUEST);
            }
        }
        if (data.getTextParameterValues("stored").length > 0) {
            String value = data.getTextParameterValues("stored")[0];
            keys.add(value);
        }

        log.debug("Parameters:");
        log.debug("file: {}", file);
        log.debug("url: {}", location);
        log.debug("format: {}", format);
        log.debug("keys: {}", keys);

        boolean fileOk = file != null;
        // if(fileOk && !(file.canRead() && file.exists())){
        // log.error("File is not accessible: {}", file);
        // throw new WebApplicationException(INTERNAL_SERVER_ERROR);
        // }
        if (fileOk || location != null || library != null) { // File and location take precedence

            // src = new GraphContentInputSource(content, format, ontologyProvider.getStore());

            // Then add the file
            OntologyInputSource<?> src = null;
            if (fileOk) {

                /*
                 * Because the ontology provider's load method could fail after only one attempt without
                 * resetting the stream, we might have to do that ourselves.
                 */
                List<String> formats;
                if (format != null && !format.trim().isEmpty()) formats = Collections.singletonList(format);
                else // The RESTful API has its own list of preferred formats
                formats = Arrays.asList(RDF_XML, TURTLE, X_TURTLE, N3, N_TRIPLE, OWL_XML,
                        FUNCTIONAL_OWL, MANCHESTER_OWL, RDF_JSON);
                int unsupported = 0, failed = 0;
                Iterator<String> itf = formats.iterator();
                if (!itf.hasNext()) throw new OntologyLoadingException("No suitable format found or defined.");
                do {
                    String f = itf.next();
                    try {
                        // Re-instantiate the stream on every attempt
                        InputStream content = new ByteArrayInputStream(file.getContent());
                        // ClerezzaOWLUtils.guessOntologyID(new FileInputStream(file), Parser.getInstance(),
                        // f);
                        OWLOntologyID guessed = OWLUtils.guessOntologyID(content, Parser.getInstance(), f);
                        log.debug("guessed ontology id: {}", guessed);
                        if (guessed != null && !guessed.isAnonymous()
                            && ontologyProvider.hasOntology(guessed)) {
                            // rb = Response.status(Status.CONFLICT);
                            this.submitted = guessed;
                            if (headers.getAcceptableMediaTypes().contains(MediaType.TEXT_HTML_TYPE)) {
                                rb.entity(new Viewable("conflict.ftl", new ScopeResultData())); 
                                rb.header(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_HTML + "; charset=utf-8");
                            }
                            break;
                        } else {
                            content = new ByteArrayInputStream(file.getContent());
                            log.debug("Recreated input stream for format {}", f);
                            src = new GraphContentInputSource(content, f, ontologyProvider.getStore());
                        }
                    } catch (UnsupportedFormatException e) {
                        log.warn(
                            "POST method failed for media type {}. This should not happen (should fail earlier)",
                            headers.getMediaType());
                        // rb = Response.status(UNSUPPORTED_MEDIA_TYPE);
                        unsupported++;
                    } catch (IOException e) {
                        log.debug(">>> FAILURE format {} (I/O error)", f);
                        failed++;
                    } catch (Exception e) { // SAXParseException and others
                        log.debug(">>> FAILURE format {} (parse error)", f);
                        failed++;
                    }
                } while (src == null && itf.hasNext());
            }

            if (src != null) {
                OWLOntologyID key = scope.getCustomSpace().addOntology(src);
                if (key == null || key.isAnonymous()) throw new WebApplicationException(INTERNAL_SERVER_ERROR);
                // FIXME ugly but will have to do for the time being
                String uri = // key.split("::")[1];
                OntologyUtils.encode(key);
                // uri = uri.substring((ontologyProvider.getGraphPrefix() + "::").length());
                if (uri != null && !uri.isEmpty()) {
                    rb = Response.seeOther(URI.create("/ontonet/ontology/" + scope.getID() + "/" + uri));
                } else rb = Response.ok();
            } else if (rb == null) rb = Response.status(INTERNAL_SERVER_ERROR);
        }

        if (!keys.isEmpty()) {
            for (String key : keys)
                scope.getCustomSpace().addOntology(new StoredOntologySource(OntologyUtils.decode(key)));
            rb = Response.seeOther(URI.create("/ontonet/ontology/" + scope.getID()));
        }
        // else throw new WebApplicationException(BAD_REQUEST);
        // rb.header(HttpHeaders.CONTENT_TYPE, TEXT_HTML + "; charset=utf-8");
        // FIXME return an appropriate response e.g. 201
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    /**
     * At least one between corereg and coreont must be present. Registry iris supersede ontology iris.
     * 
     * @param scopeid
     * @param coreRegistry
     *            a. If it is a well-formed IRI it supersedes <code>coreOntology</code>.
     * @param coreOntologies
     * @param customRegistry
     *            a. If it is a well-formed IRI it supersedes <code>customOntology</code>.
     * @param customOntologies
     * @param activate
     *            if true, the new scope will be activated upon creation.
     * @param uriInfo
     * @param headers
     * @return
     */
    @PUT
    @Consumes(MediaType.WILDCARD)
    public Response registerScope(@PathParam("scopeid") String scopeid,
                                  @QueryParam("corereg") final List<String> coreRegistries,
                                  @QueryParam("coreont") final List<String> coreOntologies,
                                  @DefaultValue("false") @QueryParam("activate") boolean activate,
                                  @Context HttpHeaders headers) {
        log.debug("Request URI {}", uriInfo.getRequestUri());

        scope = onm.getScope(scopeid);
        List<OntologyInputSource<?>> srcs = new ArrayList<OntologyInputSource<?>>(coreOntologies.size()
                                                                                  + coreRegistries.size());
        // First thing, check registry sources.
        if (coreRegistries != null) for (String reg : coreRegistries)
            if (reg != null && !reg.isEmpty()) try {
                // Library IDs are sanitized differently
                srcs.add(new LibrarySource(URIUtils.desanitize(IRI.create(reg)), regMgr));
            } catch (Exception e1) {
                throw new WebApplicationException(e1, BAD_REQUEST);
                // Bad or not supplied core registry, try the ontology.
            }

        // Then ontology sources
        if (coreOntologies != null) for (String ont : coreOntologies)
            if (ont != null && !ont.isEmpty()) try {
                srcs.add(new RootOntologySource(IRI.create(ont)));
            } catch (OWLOntologyCreationException e2) {
                // If this fails too, throw a bad request.
                throw new WebApplicationException(e2, BAD_REQUEST);
            }

        // Now the creation.
        try {
            // Expand core sources
            List<OntologyInputSource<?>> expanded = new ArrayList<OntologyInputSource<?>>();
            for (OntologyInputSource<?> coreSrc : srcs)
                if (coreSrc != null) {
                    if (coreSrc instanceof SetInputSource) {
                        for (Object o : ((SetInputSource<?>) coreSrc).getOntologies()) {
                            OntologyInputSource<?> src = null;
                            if (o instanceof OWLOntology) src = new RootOntologySource((OWLOntology) o);
                            else if (o instanceof Graph) src = new GraphSource(
                                    (Graph) o);
                            if (src != null) expanded.add(src);
                        }
                    } else expanded.add(coreSrc); // Must be denoting a single ontology
                }
            scope = onm.createOntologyScope(scopeid, expanded.toArray(new OntologyInputSource[0]));
            // Setup and register the scope. If no custom space was set, it will
            // still be open for modification.
            scope.setUp();
            onm.setScopeActive(scopeid, activate);
        } catch (DuplicateIDException e) {
            throw new WebApplicationException(e, CONFLICT);
        } catch (Exception ex) {
            throw new WebApplicationException(ex, INTERNAL_SERVER_ERROR);
        }

        ResponseBuilder rb = Response.created(uriInfo.getAbsolutePath());
        // addCORSOrigin(servletContext, rb, headers);
        return rb.build();
    }

    public class ScopeResultData extends ResultData {

        public OWLOntologyID getRepresentedOntologyKey() {
            log.info("getRepresentedOntologyKey {}",ScopeResource.this.getRepresentedOntologyKey());
            return ScopeResource.this.getRepresentedOntologyKey();
        }

        public String stringForm(OWLOntologyID ontologyID) {
            return OntologyUtils.encode(ontologyID);
        }
    }

}