source: AnnotationManagerN4J/src/main/java/de/mpiwg/itgroup/annotations/restlet/AnnotatorAnnotations.java @ 4:3599b29c393f

/**
 * Implements the "annotations" uri of the Annotator API. see
 * <https://github.com/okfn/annotator/wiki/Storage>
 */
package de.mpiwg.itgroup.annotations.restlet;

import java.io.IOException;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.restlet.data.Status;
import org.restlet.ext.json.JsonRepresentation;
import org.restlet.representation.Representation;
import org.restlet.resource.Delete;
import org.restlet.resource.Get;
import org.restlet.resource.Post;
import org.restlet.resource.Put;

import de.mpiwg.itgroup.annotations.Annotation;
import de.mpiwg.itgroup.annotations.neo4j.AnnotationStore;

/**
 * Implements the "annotations" uri of the Annotator API. see
 * <https://github.com/okfn/annotator/wiki/Storage>
 * 
 * @author dwinter, casties
 * 
 */
public class AnnotatorAnnotations extends AnnotatorResourceImpl {

    protected String getAllowedMethodsForHeader() {
        return "OPTIONS,GET,POST,PUT,DELETE";
    }

    /**
     * GET with JSON content-type.
     * 
     * @param entity
     * @return
     */
    @Get("json")
    public Representation doGetJSON(Representation entity) {
        logger.debug("AnnotatorAnnotations doGetJSON!");
        setCorsHeaders();
        // id from URI /annotations/{id}
        String jsonId = (String) getRequest().getAttributes().get("id");
        String id = decodeJsonId(jsonId);
        logger.debug("annotation-id=" + id);

        // TODO: what to return without id - list of all annotations?

        // TODO: what to do with authentication?
        boolean authenticated = isAuthenticated(entity);
        logger.debug("request authenticated=" + authenticated);

        Annotation annots = getAnnotationStore().getAnnotationById(id);
        if (annots != null) {
            // there should be only one
            JSONObject result = createAnnotatorJson(annots);
            logger.debug("sending:");
            logger.debug(result);
            return new JsonRepresentation(result);
        } else {
            JSONArray results = new JSONArray();
            // annotator read request returns a list of annotation objects
            logger.debug("sending:");
            logger.debug(results);
            return new JsonRepresentation(results);
        }
    }

    /**
     * POST with JSON content-type.
     * 
     * json hash: username: name des users xpointer: xpointer auf den Ausschnitt
     * (incl. der URL des Dokumentes) text: text der annotation annoturl: url
     * auf eine Annotation falls extern
     * 
     * @return
     */
    @Post("json")
    public Representation doPostJson(Representation entity) {
        logger.debug("AnnotatorAnnotations doPostJSON!");
        // set headers
        setCorsHeaders();
        Annotation annot = null;
        try {
            JsonRepresentation jrep = new JsonRepresentation(entity);
            JSONObject jo = jrep.getJsonObject();
            if (jo == null) {
                setStatus(Status.SERVER_ERROR_INTERNAL);
                return null;
            }
            // make sure id is not set for POST
            jo.remove("id");
            // get Annotation object from posted JSON
            annot = createAnnotation(jo, entity);
        } catch (IOException e1) {
            setStatus(Status.SERVER_ERROR_INTERNAL);
            return null;
        } catch (JSONException e) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            return null;
        }
        if (annot == null) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            return null;
        }
        Annotation storedAnnot;
        // store Annotation
        storedAnnot = getAnnotationStore().storeAnnotation(annot);
        /*
         * according to https://github.com/okfn/annotator/wiki/Storage we should
         * return 303: see other. For now we return the annotation.
         */
        JSONObject jo = createAnnotatorJson(storedAnnot);
        JsonRepresentation retRep = new JsonRepresentation(jo);
        return retRep;
    }

    /**
     * PUT with JSON content-type.
     * 
     * @param entity
     * @return
     */
    @Put("json")
    public Representation doPutJSON(Representation entity) {
        logger.debug("AnnotatorAnnotations doPutJSON!");
        setCorsHeaders();
        // id from URI /annotations/{id}
        String jsonId = (String) getRequest().getAttributes().get("id");
        String id = decodeJsonId(jsonId);
        logger.debug("annotation-id=" + id);

        // TODO: what to do with authentication? we should check the owner
        boolean authenticated = isAuthenticated(entity);
        logger.debug("request authenticated=" + authenticated);
        if (!authenticated) {
            setStatus(Status.CLIENT_ERROR_FORBIDDEN, "Not Authorized!");
            return null;
        }

        Annotation annot = null;
        AnnotationStore store = getAnnotationStore();
        try {
            JsonRepresentation jrep = new JsonRepresentation(entity);
            JSONObject jo = jrep.getJsonObject();
            if (jo == null) {
                setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
                return null;
            }
            // get stored Annotation
            Annotation storedAnnot = store.getAnnotationById(id);
            if (storedAnnot == null) {
                setStatus(Status.CLIENT_ERROR_NOT_FOUND);
                return null;
            }
            // update from posted JSON
            annot = updateAnnotation(storedAnnot, jo, entity);
            // store Annotation
            storedAnnot = store.storeAnnotation(annot);
            /*
             * according to https://github.com/okfn/annotator/wiki/Storage we
             * should return 303: see other. but the client doesn't like it
             * setStatus(Status.REDIRECTION_SEE_OTHER); // go to same URL as
             * this one Reference thisUrl = this.getReference();
             * this.getResponse().setLocationRef(thisUrl);
             */
            // return new annotation
            jo = createAnnotatorJson(storedAnnot);
            JsonRepresentation retRep = new JsonRepresentation(jo);
            return retRep;
        } catch (JSONException e) {
            e.printStackTrace();
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
        } catch (IOException e) {
            e.printStackTrace();
            setStatus(Status.SERVER_ERROR_INTERNAL, "Other Error");
        }
        return null;
    }

    /**
     * DELETE with JSON content-type.
     * 
     * @param entity
     * @return
     */
    @Delete("json")
    public Representation doDeleteJSON(Representation entity) {
        logger.debug("AnnotatorAnnotations doDeleteJSON!");
        setCorsHeaders();
        // id from URI /annotations/{id}
        String jsonId = (String) getRequest().getAttributes().get("id");
        String id = decodeJsonId(jsonId);
        logger.debug("annotation-id=" + id);

        // TODO: what to do with authentication? we should check the owner
        boolean authenticated = isAuthenticated(entity);
        logger.debug("request authenticated=" + authenticated);
        if (!authenticated) {
            setStatus(Status.CLIENT_ERROR_FORBIDDEN, "Not Authorized!");
            return null;
        }

        // delete annotation
        getAnnotationStore().deleteById(id);
        setStatus(Status.SUCCESS_NO_CONTENT);
        return null;
    }

}