Metacat

{

  "pid": "tao.1.1", 

  "field": "annotation_sm", 

  "reject": false, 

  "ranges": [

    {

      "start": "/section[1]/article[1]/form[1]/section[1]/div[1]/div[1]", 

      "end": "/section[1]/article[1]/form[1]/section[1]/div[1]/div[1]", 

      "startOffset": 0, 

      "endOffset": 4

    }

  ], 

  "permissions": {

    "read": [

      "group:__world__"

    ], 

    "delete": [], 

    "admin": [], 

    "update": []

  }, 

  "user": "CN=Benjamin Leinfelder A515,O=University of Chicago,C=US,DC=cilogon,DC=org", 

  "consumer": "metacat", 

  "updated": "2014-12-03T23:29:20.262152+00:00", 

  "quote": "Data", 

  "oa:Motivation": "oa:tagging", 

  "tags": [], 

  "text": "Original annotation content", 

  "created": "2014-12-03T23:09:25.501665+00:00", 

  "uri": "https://cn-dev.test.dataone.org/cn/v1/object/tao.1.1"

}

/**  '$RCSfile$'

 *  Copyright: 2010 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.annotation.store;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import org.dataone.portal.TokenGenerator;

import junit.framework.Test;

import junit.framework.TestSuite;

import net.minidev.json.JSONObject;

import net.minidev.json.JSONValue;

import edu.ucsb.nceas.metacat.dataone.D1NodeServiceTest;

public class AnnotatorStoreTest extends D1NodeServiceTest {

	private static String ANNOTATION_TEST_DOC = "test/annotator-sample.json";

	/**

	 * constructor for the test

	 */

	public AnnotatorStoreTest(String name) {

		super(name);

	}

	/**

	 * Establish a testing framework by initializing appropriate objects

	 */

	public void setUp() throws Exception {

		super.setUp();		

		String testToken = TokenGenerator.getJWT("uid=kepler,o=unaffiliated,dc=ecoinformatics,dc=org", "Kepler");

		request.addHeader("x-annotator-auth-token", testToken);

	}

	/**

	 * Release any objects after tests are complete

	 */

	public void tearDown() {

	}

	/**

	 * Create a suite of tests to be run together

	 */

	public static Test suite() {

		TestSuite suite = new TestSuite();

		suite.addTest(new AnnotatorStoreTest("testRoundTrip"));

		return suite;

	}

	public void testRoundTrip() {

		try {

			// read the test annotation for CRUD operations

			AnnotatorStore as = new AnnotatorStore(request);

			InputStream is = new ByteArrayInputStream(this.getTestDocFromFile(ANNOTATION_TEST_DOC).getBytes("UTF-8"));

			JSONObject annotation = (JSONObject) JSONValue.parse(is);

			String id = as.create(annotation);

			// check the created

			JSONObject originalAnnotation = as.read(id);

			String text = "Original annotation content";

			String originalText = originalAnnotation.get("text").toString();

			assertEquals(text, originalText);

			// test the update

//			text = "updated content";

//			JSONObject partialAnnotation =  (JSONObject) JSONValue.parse("{'text' : '" + text + "' }");

//			as.update(id, partialAnnotation);

//			JSONObject updatedAnnotation = as.read(id);

//			String updatedText = updatedAnnotation.get("text").toString();

//			assertEquals(text, updatedText);

			// TODO: check delete

			as.delete(id);

		} catch (Exception e) {

			e.printStackTrace();

			fail(e.getMessage());

		}

	}

}

    <!-- annotator servlet -->

    <servlet>

      <servlet-name>annotatorServlet</servlet-name>

      <servlet-class>edu.ucsb.nceas.metacat.annotation.store.AnnotatorRestServlet</servlet-class>

      <init-param>

        <param-name>debug</param-name>

        <param-value>1</param-value>

      </init-param>

      <init-param>

        <param-name>listings</param-name>

        <param-value>true</param-value>

      </init-param>

      <load-on-startup>20</load-on-startup>

    </servlet>

    <servlet-mapping>

        <servlet-name>annotatorServlet</servlet-name>

        <url-pattern>/annotator</url-pattern>

    </servlet-mapping>

    <servlet-mapping>

        <servlet-name>annotatorServlet</servlet-name>

        <url-pattern>/annotator/*</url-pattern>

    </servlet-mapping>

/**

 * 

 */

package edu.ucsb.nceas.metacat.annotation.store;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.math.BigInteger;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.Date;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.collections.Predicate;

import org.apache.commons.collections.PredicateUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.http.NameValuePair;

import org.apache.http.client.utils.URLEncodedUtils;

import org.dataone.client.auth.CertificateManager;

import org.dataone.portal.TokenGenerator;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.types.v1.AccessPolicy;

import org.dataone.service.types.v1.AccessRule;

import org.dataone.service.types.v1.Checksum;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.NodeReference;

import org.dataone.service.types.v1.ObjectFormatIdentifier;

import org.dataone.service.types.v1.ObjectInfo;

import org.dataone.service.types.v1.ObjectList;

import org.dataone.service.types.v1.Permission;

import org.dataone.service.types.v1.Session;

import org.dataone.service.types.v1.Subject;

import org.dataone.service.types.v1.util.ChecksumUtil;

import org.dataone.service.types.v2.SystemMetadata;

import org.dataone.service.util.Constants;

import org.dataone.service.util.DateTimeMarshaller;

import edu.ucsb.nceas.metacat.MetaCatServlet;

import edu.ucsb.nceas.metacat.dataone.MNodeService;

import net.minidev.json.JSONArray;

import net.minidev.json.JSONObject;

import net.minidev.json.JSONValue;

/**

 * @author leinfelder

 *

 */

public class AnnotatorStore {

    public static Log logMetacat = LogFactory.getLog(AnnotatorStore.class);

    public static final String ANNOTATION_FORMAT_ID = "http://docs.annotatorjs.org/en/v1.2.x/annotation-format.html";

    private HttpServletRequest request;

	private Session session;

	public AnnotatorStore(HttpServletRequest request) {

		this.request = request;

		try {

			session = CertificateManager.getInstance().getSession(request);

		} catch (InvalidToken e) {

			logMetacat.warn(e.getMessage(), e);

		}

		// try getting it from the token

		if (session == null) {

			String token = request.getHeader("x-annotator-auth-token");

			session = TokenGenerator.getSession(token);

		}

	}

	/**

	 * Generate minimal systemmetadata for new/updated annotation objects

	 * @param annotation

	 * @return

	 * @throws Exception

	 */

	private SystemMetadata computeSystemMetadata(JSONObject annotation) throws Exception {

		SystemMetadata sysmeta = new SystemMetadata();

		ObjectFormatIdentifier formatId = new ObjectFormatIdentifier();

		formatId.setValue(ANNOTATION_FORMAT_ID);

		sysmeta.setFormatId(formatId);

		BigInteger size = BigInteger.valueOf(annotation.toJSONString().getBytes(MetaCatServlet.DEFAULT_ENCODING).length);

		sysmeta.setSize(size);

		Checksum checksum = ChecksumUtil.checksum(annotation.toJSONString().getBytes(MetaCatServlet.DEFAULT_ENCODING), "MD5");

		sysmeta.setChecksum(checksum);

		Subject rightsHolder = session.getSubject();

		sysmeta.setRightsHolder(rightsHolder);

		sysmeta.setSubmitter(rightsHolder);

		NodeReference authoritativeMemberNode = MNodeService.getInstance(request).getCapabilities().getIdentifier();

		sysmeta.setAuthoritativeMemberNode(authoritativeMemberNode );

		sysmeta.setOriginMemberNode(authoritativeMemberNode);

		sysmeta.setDateSysMetadataModified(DateTimeMarshaller.deserializeDateToUTC(annotation.get("updated").toString()));

		sysmeta.setDateUploaded(DateTimeMarshaller.deserializeDateToUTC(annotation.get("created").toString()));		

		// add access access rules for read

		AccessPolicy accessPolicy = new AccessPolicy();

		JSONObject permissions =  (JSONObject) annotation.get("permissions");

		JSONArray readList = (JSONArray) permissions.get("read");

		for (Object read: readList) {

			AccessRule accessRule = new AccessRule();

			Subject user = new Subject();

			String username = read.toString();

			if (username.equals("group:__world__")) {

				user.setValue(Constants.SUBJECT_PUBLIC);

			}

			accessRule.addSubject(user);

			accessRule.addPermission(Permission.READ);

			accessPolicy.addAllow(accessRule);

		}

		sysmeta.setAccessPolicy(accessPolicy);

		return sysmeta;

	}

	/**

	 * Create a new annotation from given object

	 * @param annotation

	 * @return the generated identifier for the annotation

	 * @throws Exception

	 */

	public String create(JSONObject annotation) throws Exception {

		// use the dataone API to create an object for the annotation

		// create identifiers for the object

		Identifier pid = MNodeService.getInstance(request).generateIdentifier(session, "UUID", "annotation");

		Identifier sid = MNodeService.getInstance(request).generateIdentifier(session, "UUID", "annotation");

		// add properties to the annotation

		// TODO: use SID for the identifier when implemented

		annotation.put("id", pid.getValue());

		annotation.put("user", session.getSubject().getValue());

		Date now = Calendar.getInstance().getTime();

		annotation.put("created", DateTimeMarshaller.serializeDateToUTC(now));

		annotation.put("updated", DateTimeMarshaller.serializeDateToUTC(now));

		// generate sys meta

		SystemMetadata sysmeta = computeSystemMetadata(annotation);

		sysmeta.setIdentifier(pid);

		sysmeta.setSeriesId(sid);

		// create it on the node

		InputStream object = new ByteArrayInputStream(annotation.toJSONString().getBytes(MetaCatServlet.DEFAULT_ENCODING));

		MNodeService.getInstance(request).create(session, pid, object, sysmeta);

		return pid.getValue();

	}

	/**

	 * Read the annotation for given id

	 * @param id

	 * @return

	 * @throws Exception

	 */

	public JSONObject read(String id) throws Exception {

		// read the annotation out as JSON object

		Identifier sid = new Identifier();

		sid.setValue(id);

		InputStream object = MNodeService.getInstance(request).get(session, sid);

		JSONObject annotation = (JSONObject) JSONValue.parse(object);

		return annotation;

	}

	/**

	 * TODO: implement when series ID is supported

	 * @param id

	 * @param partialAnnotation

	 * @return

	 */

	public JSONObject update(String id, JSONObject partialAnnotation) {

		// TODO Auto-generated method stub

		return null;

	}

	/**

	 * TODO: allow full delete?

	 * Remove the annotation from the store

	 * @param id

	 * @throws Exception

	 */

	public void delete(String id) throws Exception {

		// read the annotation out as JSON object

		Identifier sid = new Identifier();

		sid.setValue(id);

		//MNodeService.getInstance(request).delete(session, sid);

		MNodeService.getInstance(request).archive(session, sid);

	}

	/**

	 * Query annotation store using given query expression

	 * @param query

	 * @return result listing the total matches and each annotation as a "row"

	 * @throws Exception

	 */

	public JSONObject search(String query) throws Exception {

		JSONObject results = new JSONObject();

		// TODO: better search algorithm!

		JSONArray annotations = this.index();

		Collection<Predicate> predicates = new ArrayList<Predicate>();

		List<NameValuePair> criteria = URLEncodedUtils.parse(query, Charset.forName(MetaCatServlet.DEFAULT_ENCODING));

		for (NameValuePair pair: criteria) {

			if (pair.getName().equals("limit") || pair.getName().equals("offset")) {

				continue;

			}

			// otherwise add the criteria

			predicates.add(new AnnotationPredicate(pair.getName(), pair.getValue()));

		}

		Predicate allPredicate = PredicateUtils.allPredicate(predicates);

		CollectionUtils.filter(annotations, allPredicate);

		results.put("total", annotations.size());

		results.put("rows", annotations);

		return results ;

	}

	/**

	 * Show the API version information for this store

	 * @return

	 */

	public JSONObject root() {

		JSONObject versionInfo = new JSONObject();

		versionInfo.put("name", "Metacat Annotator Store API");

		versionInfo.put("version", "1.2.9");

		return versionInfo ;

	}

	/**

	 * List all the annotations in the store

	 * @return

	 * @throws Exception

	 */

	public JSONArray index() throws Exception {

		JSONArray annotations = new JSONArray();

		ObjectFormatIdentifier objectFormatId = new ObjectFormatIdentifier();

		objectFormatId.setValue(ANNOTATION_FORMAT_ID);

		Integer start = 0;

		Integer count = 1000;

		ObjectList objects = MNodeService.getInstance(request).listObjects(session, null, null, objectFormatId, null, true, start, count);

		for (ObjectInfo info: objects.getObjectInfoList()) {

			Identifier pid = info.getIdentifier();

			SystemMetadata sysMeta = MNodeService.getInstance(request).getSystemMetadata(session, pid);

			// remember we don't have true delete yet

			if ( (sysMeta.getArchived() != null && sysMeta.getArchived().booleanValue()) || sysMeta.getObsoletedBy() != null) {

				continue;

			}

			JSONObject annotation = this.read(pid.getValue());

			annotations.add(annotation);

		}

		return annotations ;

	}

}

class AnnotationPredicate implements Predicate {

	private String name;

	private String value;

	public AnnotationPredicate(String name, String value) {

		this.name = name;

		this.value = value;

	}

	@Override

	public boolean evaluate(Object obj) {

		JSONObject annotation = (JSONObject) obj;

		// simple string equals for now

		String actualValue = (String) annotation.get(name);

		if (actualValue == null) {

			return false;

		}

		return actualValue.equals(value);

	}

}

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$Date$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.annotation.store;

import java.io.IOException;

import java.io.InputStream;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import net.minidev.json.JSONArray;

import net.minidev.json.JSONObject;

import net.minidev.json.JSONValue;

import org.apache.log4j.Logger;

/**

 * Metacat REST handler for Annotator storage API

 * http://docs.annotatorjs.org/en/v1.2.x/storage.html#core-storage-api 

 *  

 */

public class AnnotatorRestServlet extends HttpServlet {

    protected Logger logMetacat;

    private String getResource(HttpServletRequest request) {

    	// get the resource

        String resource = request.getPathInfo();

        resource = resource.substring(resource.indexOf("/") + 1);

        return resource;

    }

    /**

     * Initalize servlet by setting logger

     */

    @Override

    public void init(ServletConfig config) throws ServletException {

        logMetacat = Logger.getLogger(this.getClass());

        super.init(config);

    }

    /** Handle "GET" method requests from HTTP clients */

    @Override

    protected void doGet(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException {

        logMetacat.debug("HTTP Verb: GET");

        String resource = this.getResource(request);

        if (resource.startsWith("annotations/")) {

        	String id = request.getPathInfo().substring(request.getPathInfo().lastIndexOf("/") + 1);

        	AnnotatorStore as = new AnnotatorStore(request);

        	try {

				JSONObject annotation = as.read(id);

				annotation.writeJSONString(response.getWriter());

				return;

			} catch (Exception e) {

				throw new ServletException(e);

			}

        }

        // handle listing them

        if (resource.startsWith("annotations")) {

        	AnnotatorStore as = new AnnotatorStore(request);

        	try {

				JSONArray annotations = as.index();

				annotations.writeJSONString(response.getWriter());

				return;

			} catch (Exception e) {

				throw new ServletException(e);

			}

        }

        // handle searching them

        if (resource.startsWith("search")) {

        	String query = request.getQueryString();

        	AnnotatorStore as = new AnnotatorStore(request);

        	try {

				JSONObject results = as.search(query);

				results.writeJSONString(response.getWriter());

				return;

			} catch (Exception e) {

				e.printStackTrace();

				throw new ServletException(e);

			}

        }

    }

    /** Handle "POST" method requests from HTTP clients */

    @Override

    protected void doPost(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException {

        logMetacat.debug("HTTP Verb: POST");

        String resource = this.getResource(request);

        if (resource.equals("annotations")) {

        	AnnotatorStore as = new AnnotatorStore(request);

        	try {

        		// get the annotation from the request

        		InputStream is = request.getInputStream();

    			JSONObject annotation = (JSONObject) JSONValue.parse(is);

    			// create it on the node

				String id = as.create(annotation);

				// TODO: determine which is the correct approach for responding to CREATE

				// redirect to read

				response.setStatus(303);

				response.sendRedirect(request.getRequestURI() + "/" + id);

				// write it back in the response

				JSONObject result = as.read(id);

				result.writeJSONString(response.getWriter());

			} catch (Exception e) {

				throw new ServletException(e);

			}

        }

    }

    /** Handle "DELETE" method requests from HTTP clients */

    @Override

    protected void doDelete(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException {

        logMetacat.debug("HTTP Verb: DELETE");

        String resource = this.getResource(request);

        if (resource.startsWith("annotations/")) {

        	String id = request.getPathInfo().substring(request.getPathInfo().lastIndexOf("/") + 1);

        	AnnotatorStore as = new AnnotatorStore(request);

        	try {

        		// delete the annotation

        		as.delete(id);

        		// say no content

        		response.setContentLength(0);

				response.setStatus(204);

			} catch (Exception e) {

				throw new ServletException(e);

			}

        }

    }

    /** Handle "PUT" method requests from HTTP clients */

    @Override

    protected void doPut(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException {

        logMetacat.debug("HTTP Verb: PUT");

    }

    /** Handle "HEAD" method requests from HTTP clients */

    @Override

    protected void doHead(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException {

        logMetacat.debug("HTTP Verb: HEAD");

    }

}