Changeset 7613

Timestamp:

04/17/09 16:42:43 (16 months ago)

Author:

dragisak

Message:

Redesign annotation feeds to include replies.

• Cache annotation feeds in feedCache
• Invalidate results of reply query separately
• Add anchors to annotation display and link to them from reply feed
• Rename Blob and UnmanagedBlob? classes
• Move feed action and service classes into their own package

Addresses #814

Location:

head/ambra

Files:

• libs/otm-models/src/main/java/org/topazproject/ambra/models/AnnotationBlob.java (modified) (1 diff)
• libs/otm-models/src/main/java/org/topazproject/ambra/models/ByteArrayBlob.java (moved) (moved from head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/UnmanagedBlob.java) (3 diffs)
• libs/otm-models/src/main/java/org/topazproject/ambra/models/ReplyBlob.java (modified) (1 diff)
• libs/otm-models/src/main/java/org/topazproject/ambra/models/Representation.java (modified) (2 diffs)
• libs/otm-models/src/main/java/org/topazproject/ambra/models/StreamedBlob.java (moved) (moved from head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/Blob.java) (4 diffs)
• libs/otm-models/src/test/java/org/topazproject/ambra/models/ModelsTest.java (modified) (1 diff)
• webapp/src/main/java/org/topazproject/ambra/annotation/service/AnnotationConverter.java (modified) (6 diffs)
• webapp/src/main/java/org/topazproject/ambra/annotation/service/AnnotationService.java (modified) (7 diffs)
• webapp/src/main/java/org/topazproject/ambra/annotation/service/BaseAnnotation.java (modified) (3 diffs)
• webapp/src/main/java/org/topazproject/ambra/annotation/service/ReplyService.java (modified) (6 diffs)
• webapp/src/main/java/org/topazproject/ambra/annotation/service/WebAnnotation.java (modified) (2 diffs)
• webapp/src/main/java/org/topazproject/ambra/annotation/service/WebReply.java (modified) (2 diffs)
• webapp/src/main/java/org/topazproject/ambra/feed (added)
• webapp/src/main/java/org/topazproject/ambra/feed/action (added)
• webapp/src/main/java/org/topazproject/ambra/feed/action/FeedAction.java (moved) (moved from head/ambra/webapp/src/main/java/org/topazproject/ambra/article/action/ArticleFeed.java) (9 diffs, 1 prop)
• webapp/src/main/java/org/topazproject/ambra/feed/service (added)
• webapp/src/main/java/org/topazproject/ambra/feed/service/AnnotationFeedCacheKey.java (added)
• webapp/src/main/java/org/topazproject/ambra/feed/service/ArticleFeedCacheKey.java (moved) (moved from head/ambra/webapp/src/main/java/org/topazproject/ambra/article/service/FeedCacheKey.java) (10 diffs, 1 prop)
• webapp/src/main/java/org/topazproject/ambra/feed/service/FeedService.java (moved) (moved from head/ambra/webapp/src/main/java/org/topazproject/ambra/article/service/ArticleFeedService.java) (26 diffs)
• webapp/src/main/java/org/topazproject/ambra/struts2/AmbraFeedResult.java (modified) (26 diffs)
• webapp/src/main/resources/struts.xml (modified) (1 diff)
• webapp/src/main/webapp/discussion/threaded_replies.ftl (modified) (3 diffs)
• webapp/src/main/webapp/WEB-INF/applicationContext.xml (modified) (1 diff)
• webapp/src/test/java/org/topazproject/ambra/annotation/service/AnnotationServiceTest.java (modified) (6 diffs)

head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/AnnotationBlob.java

@@ -30 +30 @@
  */
 @Entity()
-public class AnnotationBlob extends UnmanagedBlob implements CompetingInterest {
+public class AnnotationBlob extends ByteArrayBlob implements CompetingInterest {
   private static final long serialVersionUID = 6834878451274759551L;
   private String id;

head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/ByteArrayBlob.java

@@ -32 +32 @@
  */
 @Entity()
-public abstract class UnmanagedBlob implements Serializable {
+public abstract class ByteArrayBlob implements Serializable {
   private static final long serialVersionUID = -783693796375733488L;
 
@@ -40 +40 @@
    * Creates a new Blob object.
    */
-  public UnmanagedBlob() {
+  public ByteArrayBlob() {
   }
 
@@ -48 +48 @@
    * @param contentType the content type
    */
-  public UnmanagedBlob(String contentType) {
+  public ByteArrayBlob(String contentType) {
     // FIXME: contentType
   }

head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/ReplyBlob.java

@@ -30 +30 @@
  */
 @Entity()
-public class ReplyBlob extends UnmanagedBlob implements CompetingInterest {
+public class ReplyBlob extends ByteArrayBlob implements CompetingInterest {
   private static final long serialVersionUID = -1561876836328885263L;
   private String id;

head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/Representation.java

@@ -2 +2 @@
  * $Id$
  *
- * Copyright (c) 2006-2008 by Topaz, Inc.
+ * Copyright (c) 2006-2009 by Topaz, Inc.
  * http://topazproject.org
  *
@@ -37 +37 @@
  */
 @Entity(graph = "ri", types = {"topaz:Representation"})
-public class Representation extends Blob implements PostLoadEventListener, PreInsertEventListener {
+public class Representation extends StreamedBlob
+    implements PostLoadEventListener, PreInsertEventListener {
   private static final long serialVersionUID = 8927830952382002736L;
 

head/ambra/libs/otm-models/src/main/java/org/topazproject/ambra/models/StreamedBlob.java

@@ -2 +2 @@
  * $Id$
  *
- * Copyright (c) 2007-2008 by Topaz, Inc.
+ * Copyright (c) 2007-2009 by Topaz, Inc.
  * http://topazproject.org
  *
@@ -24 +24 @@
 
 /**
- * Base class for blobs loaded from the BlobStore.
+ * Base class for blobs loaded from the BlobStore. Blob content is not loaded but accessed through
+ * input and output streams.
  *
  * @author Pradeep Krishnan
  */
 @Entity()
-public abstract class Blob implements Serializable {
+public abstract class StreamedBlob implements Serializable {
   private static final long serialVersionUID = -783693796375733488L;
 
@@ -37 +38 @@
    * Creates a new Blob object.
    */
-  public Blob() {
+  public StreamedBlob() {
   }
 
@@ -45 +46 @@
    * @param contentType the content type
    */
-  public Blob(String contentType) {
+  public StreamedBlob(String contentType) {
     // FIXME: contentType
   }

head/ambra/libs/otm-models/src/test/java/org/topazproject/ambra/models/ModelsTest.java

@@ -56 +56 @@
                   UserPreferences.class, UserProfile.class, UserRole.class, Journal.class, Issue.class,
                   Aggregation.class, EditorialBoard.class, Correction.class, FormalCorrection.class,
-                  Retraction.class, Blob.class, ReplyBlob.class, AnnotationBlob.class
+                  Retraction.class, StreamedBlob.class, ReplyBlob.class, AnnotationBlob.class
     };
 

head/ambra/webapp/src/main/java/org/topazproject/ambra/annotation/service/AnnotationConverter.java

@@ -29 +29 @@
 
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Required;
 
 import org.topazproject.ambra.annotation.Commentary;
 import org.topazproject.ambra.models.Annotea;
 import org.topazproject.ambra.models.ArticleAnnotation;
-import org.topazproject.ambra.models.UnmanagedBlob;
+import org.topazproject.ambra.models.ByteArrayBlob;
 import org.topazproject.ambra.models.Reply;
 import org.topazproject.ambra.user.service.UserService;
@@ -40 +41 @@
 
 /**
- * A kind of utility class to convert types between topaz and ambra types for
+ * A utility class to convert types between topaz and ambra types for
  * Annotations and Replies
  */
@@ -66 +67 @@
 
   /**
-   * Converts and <code>ArticleAnnotation</code> to <code>List&lt;Webannotation&gt;</code>
+   * Converts and <code>ArticleAnnotation</code> to <code>List&lt;WebAnnotation&gt;</code>
    *
    * @param annotations an list of annotations
@@ -84 +85 @@
 
     return wa;
+  }
+
+  /**
+   * Converts and <code>Reply</code> to <code>List&lt;WebReply&gt;</code>
+   *
+   * @param replies an list of replies
+   * @param needCreatorName indicates if a display-name of the creator needs to be fetched
+   * @param needBody indicates if the annotation body is required
+   * @return an array of Annotation objects as required by the web layer
+   */
+  @Transactional(readOnly = true)
+  public List<WebReply> convertReplies(final List<Reply> replies,
+                                boolean needCreatorName,
+                                boolean needBody) {
+    final List<WebReply> wr  = new ArrayList<WebReply>();
+
+    for (Reply reply : replies) {
+      if (reply != null)
+        wr.add(convert(reply, needCreatorName, needBody));
+    }
+
+    return wr;
   }
 
@@ -117 +140 @@
     return new WebAnnotation(annotation, creator, body);
   }
+
   /**
    * Creates a hierarchical array of replies based on the flat array passed in.
@@ -208 +232 @@
 
   /**
-   * @return Returns the userService.
-   */
-  protected UserService getUserService() {
-    return userService;
-  }
-
-  /**
    * @param userService The userService to set.
    */
+  @Required
   public void setUserService(UserService userService) {
     this.userService = userService;
   }
 
-  private String loadBody(final Annotea<? extends UnmanagedBlob> annotea)
+  private String loadBody(final Annotea<? extends ByteArrayBlob> annotea)
       throws OtmException, Error {
 
-    UnmanagedBlob blob = annotea.getBody();
+    ByteArrayBlob blob = annotea.getBody();
     try {
       return  (blob == null || blob.getBody() == null) ? "" : new String(blob.getBody(), "UTF-8");

head/ambra/webapp/src/main/java/org/topazproject/ambra/annotation/service/AnnotationService.java

@@ -140 +140 @@
     AnnotationBlob blob = new AnnotationBlob(contentType);
     blob.setCIStatement(ciStatement);
+    blob.setBody(body.getBytes(getEncodingCharset()));
 
     final ArticleAnnotation annotation = annotationClass.newInstance();
@@ -153 +154 @@
     String newId = session.saveOrUpdate(annotation);
     // now that the blob is created by OTM, write to it
-    blob.setBody(body.getBytes(getEncodingCharset()));
 
     if (log.isDebugEnabled())
@@ -316 +316 @@
 
   /**
-   * Get all annotations satisfying the criteria.
-   *
-   * @param articleId  limits the list to annotations from a particular article.
-   * @param startDate  is the date to start searching from. If null, start from begining of time.
-   *                   Can be iso8601 formatted or string representation of Date object.
-   * @param endDate    is the date to search until. If null, search until present date
-   * @param mediator   the mediator of the annotation.
-   * @param annotType  a filter list of rdf types for the annotations.
-   * @param states     array of states to filter on
-   * @param ascending  controls the sort order (by date).
-   * @param maxResults the maximum number of results to return, or 0 for no limit
-   *
-   * @return the (possibly empty) list of articles.
-   *
-   * @throws ParseException if any of the dates or query could not be parsed
-   * @throws URISyntaxException if an element of annotType cannot be parsed as a URI
-   */
-  @Transactional(readOnly = true)
-  public List<ArticleAnnotation> getAnnotations(String articleId, Date startDate, Date endDate,
-                                                String mediator, List<String> annotType,
-                                                int[] states, boolean ascending, int maxResults)
-  throws ParseException, URISyntaxException {
-    List<String> annotationIds = getAnnotationIds(articleId, startDate, endDate, mediator,
-                                                  annotType, states, ascending, maxResults);
-
-    return getAnnotations(annotationIds);
-  }
-
-  /**
    * Get a list of all annotation Ids satifying the given criteria. All caching is done
    * at the object level by the session.
    *
-   * @param targetId  limits annotations to a particlualr target id.
    * @param startDate  search for annotation after start date.
    * @param endDate    is the date to search until. If null, search until present date
-   * @param mediator   annotation mediator
-   * @param annotType  a filter list of rdf types for the annotations.
-   * @param states     the list of annotation states to search for (all states if null or empty)
-   * @param ascending  controls the sort order (by date).
+   * @param annotTypes List of annotation types
    * @param maxResults the maximum number of results to return, or 0 for no limit
    *
@@ -363 +330 @@
    */
   @Transactional(readOnly = true)
-  public List<String> getAnnotationIds(String targetId, Date startDate, Date endDate,
-                                       String mediator, List<String> annotType, int[] states,
-                                       boolean ascending, int maxResults)
+  public List<String> getAnnotationIds(Date startDate, Date endDate, Set<String> annotTypes,
+                                       int maxResults)
   throws ParseException, URISyntaxException {
+
+    // create the query, applying parameters
+    Query annotationQuery = getAnnotationQuery(startDate, endDate, annotTypes, maxResults);
+
+    Results annotationResults = annotationQuery.execute();
+    List<String> res = new ArrayList<String>();
+
+    while (annotationResults.next()) {
+      URI id = annotationResults.getURI(0);
+      try {
+        // apply access-controls
+        pep.checkAccess(AnnotationsPEP.LIST_ANNOTATIONS, id);
+        res.add(id.toString());
+      } catch (SecurityException se) {
+        if (log.isDebugEnabled())
+          log.debug("Filtering URI " + id + " from Annotation list due to PEP SecurityException", se);
+      }
+    }
+
+    return res;
+  }
+
+
+  /**
+   * Get a list of all reply Ids satifying the given criteria. All caching is done
+   * at the object level by the session.
+   *
+   * @param startDate  search for replies after start date.
+   * @param endDate    is the date to search until. If null, search until present date
+   * @param annotTypes List of annotation types
+   * @param maxResults the maximum number of results to return, or 0 for no limit
+   *
+   * @return the (possibly empty) list of article ids.
+   *
+   * @throws ParseException   if any of the dates or query could not be parsed
+   * @throws URISyntaxException  if an element of annotType cannot be parsed as a URI
+   */
+  @Transactional(readOnly = true)
+  public List<String> getReplyIds(Date startDate, Date endDate, Set<String> annotTypes, int maxResults)
+  throws ParseException, URISyntaxException {
+
+    // create the query, applying parameters
+    Query query = getReplyQuery(startDate, endDate, annotTypes, maxResults);
+
+    Results results = query.execute();
+    List<String> res = new ArrayList<String>();
+
+    while (results.next()) {
+      URI id = results.getURI(0);
+      URI annotationId = results.getURI(2);
+      try {
+        // apply access-controls
+        pep.checkAccess(AnnotationsPEP.LIST_ANNOTATIONS, annotationId);
+        res.add(id.toString());
+      } catch (SecurityException se) {
+        if (log.isDebugEnabled())
+          log.debug("Filtering reply " + id + " from Annotation list due to PEP SecurityException", se);
+      }
+    }
+
+    return res;
+  }
+
+  private Query getReplyQuery(Date startDate, Date endDate, Set<String> annotTypes,
+                              int maxResults)
+      throws URISyntaxException {
+
+    String queryString = createReplyQueryString(startDate, endDate, annotTypes, maxResults);
+    Query query = session.createQuery(queryString);
+
+    bindCommonParams(startDate, endDate, annotTypes, query);
+    return query;
+  }
+
+  private Query getAnnotationQuery(Date startDate, Date endDate, Set<String> annotTypes,
+                                   int maxResults)
+      throws URISyntaxException {
+    String queryString = createAnnotationQueryString(startDate, endDate, annotTypes, maxResults);
+    Query query = session.createQuery(queryString);
+
+    bindCommonParams(startDate, endDate, annotTypes, query);
+    return query;
+  }
+
+  private void bindCommonParams(Date startDate, Date endDate, Set<String> annotTypes, Query query)
+      throws URISyntaxException {
+
+    if (startDate != null)
+      query.setParameter("sd",  startDate);
+    if (endDate != null)
+      query.setParameter("ed",  endDate);
+
+    if (annotTypes != null) {
+      int i = 0;
+      for (String type : annotTypes) {
+        query.setUri("type" + i++, URI.create(type));
+      }
+    }
+  }
+
+  private String createAnnotationQueryString(Date startDate, Date endDate, Set<String> annotTypes,
+                                             int maxResults) {
+
     StringBuilder qry = new StringBuilder();
 
-    if (targetId != null) {
-      qry.append("select a.id id, cr from Annotation a ");
-      qry.append("where cr := a.created and ");
-      qry.append("a.annotates = :targ ");
-    } else {
-      qry.append("select a.id id, cr from ArticleAnnotation a, Article ar ");
-      qry.append("where a.annotates = ar and cr := a.created ");
-    }
-
-    if (mediator != null)
-      qry.append("and a.mediator = :med ");
-
+    qry.append("select a.id id, cr from ArticleAnnotation a, Article ar ");
+    qry.append("where a.annotates = ar and cr := a.created ");
+
+    appendCommonCriteria(startDate, endDate, annotTypes, maxResults, qry);
+
+    qry.append(';');
+
+    return qry.toString();
+  }
+
+  // For now only fetches all Replys
+  private String createReplyQueryString(Date startDate, Date endDate, Set<String> annotTypes,
+                                        int maxResults) {
+
+    StringBuilder qry = new StringBuilder();
+
+    qry.append("select r.id id, cr, a.id annid from Reply r, ArticleAnnotation a, Article ar ")
+       .append("where cr := r.created and r.root = a and a.annotates = ar ");
+
+    appendCommonCriteria(startDate, endDate, annotTypes, maxResults, qry);
+
+    qry.append(';');
+
+    return qry.toString();
+  }
+
+  private void appendCommonCriteria(Date startDate, Date endDate, Set<String> annotTypes,
+                                    int maxResults, StringBuilder qry) {
     // apply date constraints
     if (startDate != null)
@@ -387 +472 @@
       qry.append("and le(cr, :ed) ");
 
-    // match all states
-    if (states != null && states.length > 0) {
+
+    // match all types
+    if (annotTypes != null && annotTypes.size() > 0) {
       qry.append("and (");
-      for (int idx = 0; idx < states.length; idx++)
-        qry.append("art.state = :st").append(idx).append(" or ");
+      for (int i = 0; i < annotTypes.size(); i++)
+        qry.append("a.<rdf:type> = :type").append(i).append(" or ");
       qry.setLength(qry.length() - 4);
       qry.append(") ");
     }
-
-    // match all types
-    if (annotType != null && annotType.size() > 0) {
-      qry.append("and (");
-      for (int idx = 0; idx < annotType.size(); idx++)
-        qry.append("a.<rdf:type> = :type").append(idx).append(" or ");
-      qry.setLength(qry.length() - 4);
-      qry.append(") ");
-    }
-
     // add ordering and limit
-    qry.append("order by cr ").append(ascending ? "asc" : "desc").append(", id asc");
+    qry.append("order by cr asc, id asc");
 
     if (maxResults > 0)
       qry.append(" limit ").append(maxResults);
-
-    qry.append(";");
-
-    // create the query, applying parameters
-    Query q = session.createQuery(qry.toString());
-
-    if (targetId != null)
-      q.setParameter("targ", targetId);
-    if (mediator != null)
-      q.setParameter("med", mediator);
-    if (startDate != null)
-      q.setParameter("sd",  startDate);
-    if (endDate != null)
-      q.setParameter("ed",  endDate);
-    for (int idx = 0; states != null && idx < states.length; idx++)
-      q.setParameter("st" + idx, states[idx]);
-    for (int idx = 0; annotType != null && idx < annotType.size(); idx++)
-      q.setUri("type" + idx, new URI(annotType.get(idx)));
-
-    Results r = q.execute();
-    // apply access-controls
-    List<String> res = new ArrayList<String>();
-    while (r.next()) {
-      URI id = r.getURI(0);
-      try {
-        pep.checkAccess(AnnotationsPEP.LIST_ANNOTATIONS, id);
-        res.add(id.toString());
-      } catch (SecurityException se) {
-        if (log.isDebugEnabled())
-          log.debug("Filtering URI " + id + " from Article list due to PEP SecurityException", se);
-      }
-    }
-    return res;
   }
 
@@ -515 +558 @@
     ArticleAnnotation   a = session.get(ArticleAnnotation.class, annotationId);
     if (a == null)
-      throw new IllegalArgumentException("invalid annoation id: " + annotationId);
+      throw new IllegalArgumentException("invalid annotation id: " + annotationId);
 
     return a;
@@ -644 +687 @@
    * @param mimeType mimeType
    * @param body body
-   * @parem ciStatement competing interesting statement
+   * @param ciStatement competing interesting statement
    * @param isPublic isPublic
    * @param user logged in user

head/ambra/webapp/src/main/java/org/topazproject/ambra/annotation/service/BaseAnnotation.java

@@ -22 +22 @@
 
 import org.topazproject.ambra.models.Annotea;
-import org.topazproject.ambra.models.UnmanagedBlob;
+import org.topazproject.ambra.models.ByteArrayBlob;
 import org.topazproject.ambra.util.TextUtils;
 
@@ -36 +36 @@
  * @param <T> the Annotea sub-class being delegated to.
  */
-public abstract class BaseAnnotation<T extends Annotea<? extends UnmanagedBlob>> {
+public abstract class BaseAnnotation<T extends Annotea<? extends ByteArrayBlob>> {
   /** An integer constant to indicate a unique value for the  */
   private static final int TRUNCATED_COMMENT_LENGTH = 256;
@@ -204 +204 @@
     this.originalBodyContent = originalBodyContent;
   }
+
+  public abstract String getCommentTitle();
+
+  public abstract String getCIStatement();
 }

head/ambra/webapp/src/main/java/org/topazproject/ambra/annotation/service/ReplyService.java

@@ -20 +20 @@
 
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
+import java.util.Set;
+import java.text.ParseException;
 
 import org.apache.commons.logging.Log;
@@ -49 +52 @@
   private static final Log log = LogFactory.getLog(ReplyService.class);
 
+  private AnnotationService  annotationService;   // Annotation service Spring injected.
   private RepliesPEP pep;
   private String     defaultType;
@@ -62 +66 @@
   public void setRepliesPdp(PDP pdp) {
     this.pep = new RepliesPEP(pdp);
+  }
+
+  @Required
+  public void setAnnotationService(AnnotationService annotationService) {
+    this.annotationService = annotationService;
   }
 
@@ -91 +100 @@
     ReplyBlob blob = new ReplyBlob(contentType);
     blob.setCIStatement(ciStatement);
+    blob.setBody(body.getBytes(getEncodingCharset()));
 
     final Reply r = new ReplyThread();
@@ -103 +113 @@
 
     String  newId = session.saveOrUpdate(r);
-    blob.setBody(body.getBytes(getEncodingCharset()));
 
     permissionsService.propagatePermissions(newId, new String[] { blob.getId() });
@@ -175 +184 @@
       remove(all, t);
   }
+
+  /**
+   * Get all replies specified by the list of reply ids.
+   *
+   * @param replyIds a list of annotations Ids to retrieve.
+   *
+   * @return the (possibly empty) list of replies.
+   *
+   */
+  @Transactional(readOnly = true)
+  public List<Reply> getReplies(List<String> replyIds) {
+    List<Reply> replies = new ArrayList<Reply>();
+
+    for (String id : replyIds)  {
+      try {
+        replies.add(getReply(id));
+      } catch (IllegalArgumentException iae) {
+        if (log.isDebugEnabled())
+          log.debug("Ignored illegal reply id:" + id);
+      } catch (SecurityException se) {
+        if (log.isDebugEnabled())
+          log.debug("Filtering URI " + id + " from Reply list due to PEP SecurityException", se);
+      }
+    }
+    return replies;
+  }
+
+  /**
+   * Get all replies satisfying the criteria.
+   *
+   * @param startDate  is the date to start searching from. If null, start from begining of time.
+   *                   Can be iso8601 formatted or string representation of Date object.
+   * @param endDate    is the date to search until. If null, search until present date
+   * @param annotType  a filter list of rdf types for the annotations.
+   * @param maxResults the maximum number of results to return, or 0 for no limit
+   *
+   * @return the (possibly empty) list of replies.
+   *
+   * @throws java.text.ParseException if any of the dates or query could not be parsed
+   * @throws java.net.URISyntaxException if an element of annotType cannot be parsed as a URI
+   */
+  @Transactional(readOnly = true)
+  public List<Reply> getReplies(Date startDate, Date endDate, Set<String> annotType, int maxResults)
+  throws ParseException, URISyntaxException {
+    List<String> replyIds = annotationService.getReplyIds(startDate, endDate, annotType, maxResults);
+    return getReplies(replyIds);
+  }
+
+
 
   /**

head/ambra/webapp/src/main/java/org/topazproject/ambra/annotation/service/WebAnnotation.java

@@ -75 +75 @@
   * @return title as String.
   */
+  @Override
   public String getCommentTitle() {
     String title;
@@ -124 +125 @@
   * @return CIStatement as String.
   */
+  @Override
   public String getCIStatement() {
     AnnotationBlob b = annotea.getBody();

head/ambra/webapp/src/main/java/org/topazproject/ambra/annotation/service/WebReply.java

@@ -67 +67 @@
    * @return title as String.
    */
+  @Override
   public String getCommentTitle() {
     return escapeText(annotea.getTitle());
@@ -90 +91 @@
   * @return CIStatement as String.
   */
+  @Override
   public String getCIStatement() {
     ReplyBlob r = annotea.getBody();

head/ambra/webapp/src/main/java/org/topazproject/ambra/feed/action/FeedAction.java

@@ -2 +2 @@
  * $Id$
  *
- * Copyright (c) 2006-2007 by Topaz, Inc.
+ * Copyright (c) 2006-2009 by Topaz, Inc.
  * http://topazproject.org
  *
@@ -18 +18 @@
  */
 
-package org.topazproject.ambra.article.action;
+package org.topazproject.ambra.feed.action;
 
 import java.util.List;
-import java.util.ArrayList;
 
 import org.apache.commons.logging.Log;
@@ -27 +26 @@
 
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Required;
 
 import org.topazproject.ambra.action.BaseActionSupport;
-import org.topazproject.ambra.article.service.ArticleFeedService;
-import org.topazproject.ambra.article.service.FeedCacheKey;
-import org.topazproject.ambra.article.service.ArticleFeedService.FEED_TYPES;
+import org.topazproject.ambra.feed.service.FeedService;
+import org.topazproject.ambra.feed.service.ArticleFeedCacheKey;
+import org.topazproject.ambra.feed.service.FeedService.FEED_TYPES;
+import org.topazproject.ambra.feed.service.AnnotationFeedCacheKey;
 
 import com.opensymphony.xwork2.ModelDriven;
@@ -91 +92 @@
  * maxResults  Integer          No         30          The maximun number of result to return.
  * type        String           No         Article     Article,Annotation,FormalCorrectionAnnot
- *                                                     MinorCorrectionAnnot,CommentAnnot,Issue
+ *                                                     MinorCorrectionAnnot,RetractionAnnot,
+ *                                                     CommentAnnot,Issue
  * </pre>
  *
- * @see       org.topazproject.ambra.article.service.FeedCacheKey
+ * @see       org.topazproject.ambra.feed.service.ArticleFeedCacheKey
  * @see       org.topazproject.ambra.struts2.AmbraFeedResult
  *
@@ -101 +103 @@
  */
  @SuppressWarnings("UnusedDeclaration")
-public class ArticleFeed extends BaseActionSupport implements ModelDriven {
-  private static final Log log = LogFactory.getLog(ArticleFeed.class);
-
-  //TODO: move these to BaseAction support and standardize on result dispatching.
-  private static final String ATOM_RESULT = "ATOM1_0";
-  private static final String JSON_RESULT = "json";
-
-  private        ArticleFeedService  articleFeedService; // Feed Service Spring injected.
-  private        FeedCacheKey        cacheKey;           // The cache key and action data model
-  private        List<String>        articleIds;         // List of Article IDs; result of search
+public class FeedAction extends BaseActionSupport implements ModelDriven {
+  private static final Log log = LogFactory.getLog(FeedAction.class);
+
+  private FeedService         feedService; // Feed Service Spring injected.
+  private ArticleFeedCacheKey cacheKey;    // The cache key and action data model
+  private List<String>        articleIds;  // List of Article or Annotation IDs; result of search
+  private List<String>        replyIds;    // List of Reply IDs; result of search
 
   /**
@@ -120 +119 @@
   @Transactional(readOnly = true)
   public String execute() throws Exception {
-    List<String> annotTypes = new ArrayList<String>();
     FEED_TYPES t = cacheKey.feedType();
 
     switch (t) {
       case Annotation :
-        articleIds = articleFeedService.getAnnotationIds(cacheKey, null);
-        break;
       case FormalCorrectionAnnot :
-        annotTypes.add(t.rdfType()) ;
-        articleIds = articleFeedService.getAnnotationIds(cacheKey,annotTypes);
-        break;
       case MinorCorrectionAnnot :
-        annotTypes.add(t.rdfType()) ;
-        articleIds = articleFeedService.getAnnotationIds(cacheKey,annotTypes);
-        break;
-     case CommentAnnot :
-        annotTypes.add(t.rdfType()) ;
-        articleIds = articleFeedService.getAnnotationIds(cacheKey,annotTypes);
+      case RetractionAnnot:
+      case CommentAnnot :
+        articleIds = feedService.getAnnotationIds(
+            new AnnotationFeedCacheKey(AnnotationFeedCacheKey.Type.ANNOTATIONS, cacheKey));
+        replyIds = feedService.getReplyIds(
+            new AnnotationFeedCacheKey(AnnotationFeedCacheKey.Type.REPLIES, cacheKey));
         break;
       case Article :
-        articleIds = articleFeedService.getArticleIds(cacheKey);
+        articleIds = feedService.getArticleIds(cacheKey);
         break;
       case Issue :
-        articleIds = articleFeedService.getIssueArticleIds(cacheKey, getCurrentJournal());
+        articleIds = feedService.getIssueArticleIds(cacheKey, getCurrentJournal());
         break;
     }
@@ -164 +157 @@
     cacheKey.setJournal(getCurrentJournal());
     cacheKey.validate(this);
-  }
-
-  /**
-   * Set <code>articleFeedService</code> field to the article Feed service singleton.
-   *
-   * @param  articleFeedService  the object transaction model reference
-   */
-  public void setArticleFeedService(final ArticleFeedService articleFeedService) {
-    this.articleFeedService = articleFeedService;
-  }
-
-  /**
-   * This is the results of the query which consist of a list of article ID's.
-   *
-   * @return the list of article ID's returned from the query.
+    if (log.isErrorEnabled()) {
+
+      for (Object key : getFieldErrors().keySet()) {
+        log.error("Validate error: " + getFieldErrors().get(key) + " on " + key +
+            " for cache key: " + cacheKey);
+      }
+    }
+  }
+
+  /**
+   * Set <code>feedService</code> field to the article Feed service singleton.
+   *
+   * @param  feedService  the object transaction model reference
+   */
+  @Required
+  public void setFeedService(final FeedService feedService) {
+    this.feedService = feedService;
+  }
+
+  /**
+   * This is the results of the query which consist of a list of article or annotation ID's.
+   *
+   * @return the list of article/annotation ID's returned from the query.
    */
   public List<String> getIds() {
@@ -185 +186 @@
 
   /**
+   * This is the results of the query which consist of a list of reply ID's.
+   *
+   * @return the list of reply ID's returned from the query.
+   */
+  public List<String> getReplyIds() {
+    return replyIds;
+  }
+
+  /**
    * Return the cache key being used by this action.
    *
    * @return  Key to the cache which is also the data model of the action
    */
-  public FeedCacheKey getCacheKey() {
+  public ArticleFeedCacheKey getCacheKey() {
     return this.cacheKey;
   }
@@ -203 +213 @@
      * Make sure caheKey is not created twice.
      */
-    return (cacheKey == null) ? cacheKey = articleFeedService.newCacheKey() : cacheKey;
+    return (cacheKey == null) ? cacheKey = feedService.newCacheKey() : cacheKey;
   }
 

head/ambra/webapp/src/main/java/org/topazproject/ambra/feed/service/ArticleFeedCacheKey.java

@@ -18 +18 @@
  */
 
-package org.topazproject.ambra.article.service;
+package org.topazproject.ambra.feed.service;
 
 import org.topazproject.ambra.action.BaseActionSupport;
@@ -27 +27 @@
 import java.text.ParseException;
 import java.net.URI;
-import org.topazproject.ambra.article.service.ArticleFeedService.FEED_TYPES;
 
 /**
@@ -42 +41 @@
  * affect the output.
  *
- * @see       org.topazproject.ambra.article.service.ArticleFeedService
- * @see       org.topazproject.ambra.article.service.ArticleFeedService.Invalidator
- * @see       org.topazproject.ambra.article.service.ArticleFeedService.FEED_TYPES
+ * @see       FeedService
+ * @see       FeedService.Invalidator
+ * @see       FeedService.FEED_TYPES
  * @see       org.topazproject.ambra.struts2.AmbraFeedResult
  */
-public class FeedCacheKey implements Serializable, Comparable {
+public class ArticleFeedCacheKey implements Serializable, Comparable {
   private static final long serialVersionUID = 1L;
   private String journal;
@@ -64 +63 @@
   private int maxResults;
   private URI issueURI;
-  private String type = FEED_TYPES.Article.toString();
+  private String type;
 
   final SimpleDateFormat dateFrmt = new SimpleDateFormat("yyyy-MM-dd");
@@ -72 +71 @@
    * Key Constructor - currently does nothing.
    */
-  public FeedCacheKey() {
+  public ArticleFeedCacheKey() {
+    type = FeedService.FEED_TYPES.Article.toString();
   }
 
@@ -120 +120 @@
   @Override
   public boolean equals(Object o) {
-    if (o == null || !(o instanceof FeedCacheKey))
+    if (o == null || !(o instanceof ArticleFeedCacheKey))
       return false;
-    FeedCacheKey key = (FeedCacheKey) o;
+
+    if (o == this)
+      return true;
+
+    ArticleFeedCacheKey key = (ArticleFeedCacheKey) o;
     return (
         key.hashCode == this.hashCode
@@ -160 +164 @@
   public String toString() {
     StringBuilder builder = new StringBuilder();
-
-    builder.append("journal=").append(journal);
-    builder.append("; type=").append(type);
+    builder.append("ArticleFeedCacheKey{")
+           .append("journal=").append(journal)
+           .append(", type=").append(type);
 
     if (sDate != null)
-      builder.append("; startDate=").append(sDate);
+      builder.append(", startDate=").append(sDate);
 
     if (eDate != null)
-      builder.append("; endDate=").append(eDate);
+      builder.append(", endDate=").append(eDate);
 
     if (category != null)
-      builder.append("; category=").append(category);
+      builder.append(", category=").append(category);
 
     if (author != null)
-      builder.append("; author=").append(author);
+      builder.append(", author=").append(author);
 
     if (issueURI != null)
-      builder.append("; issueURIr=").append(issueURI);
-
-    builder.append("; maxResults=").append(maxResults);
+      builder.append(", issueURIr=").append(issueURI);
+
+    builder.append(", maxResults=").append(maxResults)
+           .append('}');
 
     return builder.toString();
@@ -210 +215 @@
    * @param action - the BaseSupportAction allows reporting of field errors. Pass in a reference
    *               incase we want to report them.
-   * @see ArticleFeedService
+   * @see FeedService
    */
   @SuppressWarnings("UnusedDeclaration")
@@ -232 +237 @@
 
     // If there is garbage in the type default to Article
-    if (feedType() == FEED_TYPES.Invalid)
-      type = FEED_TYPES.Article.toString();
+    if (feedType() == FeedService.FEED_TYPES.Invalid)
+      type = FeedService.FEED_TYPES.Article.toString();
 
     // Need a positive non-zero number of results
@@ -253 +258 @@
    *         any of the types)
    */
-  public FEED_TYPES feedType() {
-    FEED_TYPES t;
+  public FeedService.FEED_TYPES feedType() {
+    FeedService.FEED_TYPES t;
     try {
-      t = FEED_TYPES.valueOf(type);
+      t = FeedService.FEED_TYPES.valueOf(type);
     } catch (Exception e) {
       // It's ok just return invalid.
-      t = FEED_TYPES.Invalid;
+      t = FeedService.FEED_TYPES.Invalid;
     }
     return t;

head/ambra/webapp/src/main/java/org/topazproject/ambra/feed/service/FeedService.java

@@ -17 +17 @@
  * limitations under the License.
  */
-package org.topazproject.ambra.article.service;
+package org.topazproject.ambra.feed.service;
 
 import java.net.URI;
@@ -25 +25 @@
 import java.util.Date;
 import java.util.List;
-import java.util.Set;
 
 import org.apache.commons.logging.Log;
@@ -44 +43 @@
 import org.topazproject.ambra.models.RatingSummary;
 import org.topazproject.ambra.models.Reply;
+import org.topazproject.ambra.models.Retraction;
 import org.topazproject.ambra.annotation.service.AnnotationService;
 import org.topazproject.ambra.annotation.service.AnnotationConverter;
 import org.topazproject.ambra.annotation.service.WebAnnotation;
+import org.topazproject.ambra.annotation.service.ReplyService;
+import org.topazproject.ambra.annotation.service.WebReply;
 import org.topazproject.ambra.cache.AbstractObjectListener;
 import org.topazproject.ambra.cache.Cache;
@@ -53 +55 @@
 import org.topazproject.ambra.model.article.ArticleInfo;
 import org.topazproject.ambra.article.action.TOCArticleGroup;
+import org.topazproject.ambra.article.service.ArticleOtmService;
+import org.topazproject.ambra.article.service.BrowseService;
+import org.topazproject.ambra.article.service.NoSuchArticleIdException;
 
 import org.topazproject.otm.Session;
@@ -59 +64 @@
 
 /**
- * The <code>ArticleFeedService</code> supplies the API for querying and caching
- * feed request. <code>ArticleFeedService</code> is a Spring injected singleton
+ * The <code>FeedService</code> supplies the API for querying and caching
+ * feed request. <code>FeedService</code> is a Spring injected singleton
  * which coordinates access to the <code>annotationService, articleOtmService</code>
  * and <code>feedCache</code>.
  */
-public class ArticleFeedService {
-  private static final Log log = LogFactory.getLog(ArticleFeedService.class);
-
-  private AnnotationService  annotationService;   // Annotation service Spring injected.
-  private ArticleOtmService  articleOtmService;   // Article Otm service Spring injected
-  private BrowseService      browseService;       // Browse Article Servcie Spring Injected
-  private JournalService     journalService;      // Journal service Spring injected.
-  private Cache              feedCache;           // Feed Cache Spring injected
-  private Invalidator        invalidator;         // Cache invalidator
-  private Session            session;
+public class FeedService {
+  private static final Log log = LogFactory.getLog(FeedService.class);
+
+  private AnnotationService   annotationService;    // Annotation service Spring injected.
+  private ReplyService        replyService;         // Reply service Spring injected.
+  private ArticleOtmService   articleOtmService;    // Article Otm service Spring injected
+  private BrowseService       browseService;        // Browse Article Servcie Spring Injected
+  private JournalService      journalService;       // Journal service Spring injected.
+  private AnnotationConverter annotationConverter; // Annotation converter
+  private Cache               feedCache;            // Feed Cache Spring injected
+  private Invalidator         invalidator;          // Cache invalidator
+  private Session             session;
 
   /**
@@ -92 +99 @@
     MinorCorrectionAnnot   { public String rdfType() { return MinorCorrection.RDF_TYPE;   }
                              public Class  isClass() { return MinorCorrection.class;      } },
+    RetractionAnnot        { public String rdfType() { return Retraction.RDF_TYPE;        }
+                             public Class  isClass() { return Retraction.class;           } },
     RatingAnnot            { public String rdfType() { return Rating.RDF_TYPE;            }
                              public Class  isClass() { return Rating.class;               } },
@@ -111 +120 @@
    * Constructor - currently does nothing.
    */
-  public ArticleFeedService(){
+  public FeedService(){
   }
 
@@ -119 +128 @@
    * @return Key a new cache key to be used as a data model for the FeedAction.
    */
-  public FeedCacheKey newCacheKey() {
-    return new FeedCacheKey();
+  public ArticleFeedCacheKey newCacheKey() {
+    return new ArticleFeedCacheKey();
   }
 
@@ -132 +141 @@
    * @throws ApplicationException ApplicationException
    */
-  public List<String> getArticleIds(final FeedCacheKey cacheKey) throws ApplicationException {
+  public List<String> getArticleIds(final ArticleFeedCacheKey cacheKey) throws ApplicationException {
     // Create a local lookup based on the feed URI.
     Cache.Lookup<List<String>, ApplicationException> lookUp =
@@ -147 +156 @@
    *
    * @param cacheKey is both the feedAction data model and cache key.
+   * @param journal Current journal
    * @return List&lt;String&gt; if article Ids.
    * @throws ApplicationException ApplicationException
-   */
-  public List<String> getIssueArticleIds(final FeedCacheKey cacheKey, String journal) throws
+   * @throws URISyntaxException URISyntaxException
+   */
+  public List<String> getIssueArticleIds(final ArticleFeedCacheKey cacheKey, String journal) throws
       URISyntaxException, ApplicationException {
     List<String> articleList  = new ArrayList<String>();
@@ -181 +192 @@
 
   /**
-   * Returns a list of annotations associated with a particular article.
-   *
-   * @param targetId  limits annotationIds to a particlular target
-   * @param annotType  a filter list of rdf types for the annotations.
-   * @param maxResult maximum number of annotations to return
-   * @param needBody   boolean specifying whether the body of the annotation is needed
-   * @return <code>List&lt;WebAnnotation&gt;</code> a list of webannotations that related to the
-   *         specified article
-   * @throws ApplicationException  Converts all exceptions to ApplicationException
-   */
-  public List<WebAnnotation> getAnnotations(final String targetId, List<String> annotType,
-      int maxResult, boolean needBody) throws ApplicationException {
-    AnnotationConverter converter = new AnnotationConverter();
-    List<WebAnnotation> webAnnot;
-
-    try {
-      List<ArticleAnnotation> annotations = annotationService.getAnnotations(
-                                              targetId, null, null, null,
-                                              annotType, null, true,  maxResult);
-      webAnnot = converter.convert(annotations,true, needBody);
-    } catch (Exception ex) {
-      throw new ApplicationException(ex);
-    }
-    return webAnnot;
-  }
-
-  /**
    * Returns a list of annotation Ids based on parameters contained in
-   * the cache key. If a start date is not specified tjen a default
+   * the cache key. If a start date is not specified then a default
    * date is used but not stored in the key.
    *
-   * @param cacheKey is both the feedAction data model and cache key.
-   * @param annotType  a filter list of rdf types for the annotations.
+   * @param cacheKey cache key.
    * @return <code>List&lt;String&gt;</code> a list of annotation Ids
    * @throws ApplicationException   Converts all exceptions to ApplicationException
    */
-  public List<String> getAnnotationIds(final FeedCacheKey cacheKey, List<String> annotType)
+  public List<String> getAnnotationIds(final AnnotationFeedCacheKey cacheKey)
       throws ApplicationException {
+
+    // Create a local lookup based on the feed URI.
+    Cache.Lookup<List<String>, ApplicationException> lookUp =
+      new Cache.SynchronizedLookup<List<String>, ApplicationException>(cacheKey) {
+        public List<String> lookup() throws ApplicationException {
+          return fetchAnnotationIds(cacheKey);
+        }
+      };
+    // Get articel ID's from the feed cache or add it
+    return feedCache.get(cacheKey, -1, lookUp);
+  }
+
+  /**
+   * Returns a list of reply Ids based on parameters contained in
+   * the cache key. If a start date is not specified then a default
+   * date is used but not stored in the key.
+   *
+   * @param cacheKey cache key
+   * @return <code>List&lt;String&gt;</code> a list of reply Ids
+   * @throws ApplicationException   Converts all exceptions to ApplicationException
+   */
+  public List<String> getReplyIds(final AnnotationFeedCacheKey cacheKey)
+      throws ApplicationException {
+
+    // Create a local lookup based on the feed URI.
+    Cache.Lookup<List<String>, ApplicationException> lookUp =
+      new Cache.SynchronizedLookup<List<String>, ApplicationException>(cacheKey) {
+        public List<String> lookup() throws ApplicationException {
+          return fetchReplyIds(cacheKey);
+        }
+      };
+    // Get articel ID's from the feed cache or add it
+    return feedCache.get(cacheKey, -1, lookUp);
+  }
+
+  private List<String> fetchAnnotationIds(final AnnotationFeedCacheKey cacheKey)
+      throws ApplicationException {
+    
     List<String> annotIds;
     try {
       annotIds = annotationService.getAnnotationIds(
-                      null, cacheKey.getSDate(), cacheKey.getEDate(),
-                      null, annotType, null, true, cacheKey.getMaxResults());
+                 cacheKey.getStartDate(), cacheKey.getEndDate(), cacheKey.getAnnotationTypes(),
+                 cacheKey.getMaxResults());
 
     } catch (Exception ex) {
@@ -231 +252 @@
   }
 
-  /**
-   * Returns a list of annotations which meet the criteria set by parameters in
-   * the cache key.
-   *
-   * @param cacheKey is both the feedAction data model and cache key.
-   * @param annotType  a filter list of rdf types for the annotations.
-   * @return <code>List&lt;WebAnnotation&gt;</code> a list of webannotations that related to the
-   *         specified article
-   * @throws ApplicationException   Converts all exceptions to ApplicationException
-   */
-  // FIXME: Dead code - Method is not used anywhere
-  public List<WebAnnotation> getAnnotations(final FeedCacheKey cacheKey, List<String> annotType)
+  private List<String> fetchReplyIds(final AnnotationFeedCacheKey cacheKey)
       throws ApplicationException {
-    AnnotationConverter converter = new AnnotationConverter();
-    List<WebAnnotation> webAnnot;
-
+
+    List<String> replyIds;
     try {
-      List<ArticleAnnotation> annotations = annotationService.getAnnotations(
-                                null, cacheKey.getSDate(), cacheKey.getEDate(),
-                                null, annotType, null, true, cacheKey.getMaxResults());
-      webAnnot = converter.convert(annotations,true,true);
+      replyIds = annotationService.getReplyIds(
+                 cacheKey.getStartDate(), cacheKey.getEndDate(), cacheKey.getAnnotationTypes(),
+                 cacheKey.getMaxResults());
+
     } catch (Exception ex) {
       throw new ApplicationException(ex);
     }
-    return webAnnot;
+    return  replyIds;
   }
 
@@ -269 +278 @@
   public List<WebAnnotation> getAnnotations(final List<String> annotIds)
       throws ApplicationException {
-    AnnotationConverter converter = new AnnotationConverter();
     List<WebAnnotation> webAnnot;
 
     try {
       List<ArticleAnnotation> annotations = annotationService.getAnnotations(annotIds);
-      webAnnot = converter.convert(annotations,true,true);
+      webAnnot = annotationConverter.convert(annotations,true,true);
     } catch (Exception ex) {
       throw new ApplicationException(ex);
     }
     return webAnnot;
+  }
+
+  /**
+   * Returns a list of replies associated with a particular list
+   * annotation Ids.
+   *
+   * @param replyIds a list of reply Ids to retrieve.
+   * @return <code>List&lt;WebReply&gt;</code> a list of webareplies
+   *         with the specified Ids.
+   * @throws ApplicationException   Converts all exceptions to ApplicationException
+   */
+  public List<WebReply> getReplies(final List<String> replyIds)
+      throws ApplicationException {
+
+    List<WebReply> webReplies;
+
+    try {
+      List<Reply> replies = replyService.getReplies(replyIds);
+      webReplies = annotationConverter.convertReplies(replies,true,true);
+    } catch (Exception ex) {
+      throw new ApplicationException(ex);
+    }
+    return webReplies;
   }
 
@@ -289 +320 @@
    * @throws  ApplicationException Converts all exceptions to ApplicationException
    */
-  private List<String> fetchArticleIds(final FeedCacheKey cacheKey) throws ApplicationException {
+  private List<String> fetchArticleIds(final ArticleFeedCacheKey cacheKey) throws ApplicationException {
     List<String> categoriesList = new ArrayList<String>();
     if (cacheKey.getCategory() != null && cacheKey.getCategory().length() > 0) {
@@ -348 +379 @@
 
   /**
+   * @param replyService Reply Service
+   */
+  @Required
+  public void setReplyService(ReplyService replyService) {
+    this.replyService = replyService;
+  }
+
+  /**
    * @param browseService   Browse Service
    */
@@ -355 +394 @@
     this.browseService = browseService;
   }
+
+  /**
+   * @param annotationConverter  Annotation converter
+   */
+  @Required
+  public void setAnnotationConverter(AnnotationConverter annotationConverter) {
+    this.annotationConverter = annotationConverter;
+  }
+
+
 
   /**
@@ -405 +454 @@
    * then remove that cache entry.
    *
-   * @see ArticleFeedService
+   * @see FeedService
    */
   public class Invalidator extends AbstractObjectListener {
@@ -427 +476 @@
       } else if (object instanceof Journal) {
         invalidateFeedCacheForJournal((Journal)object, updates);
+      } else if (object instanceof ArticleAnnotation) {
+        invalidateFeedCacheForAnnotation((ArticleAnnotation)object);
+      } else if (object instanceof Reply) {
+        invalidateFeedCacheForReply((Reply)object);
       }
     }
@@ -444 +497 @@
         throws Exception {
       // If this is an Active Article check to see if it invalidates the feed cache
-      if (object instanceof Article && ((Article) object).getState() == Article.STATE_ACTIVE)
-        invalidateFeedCacheForArticle((Article)object);
+      if (object instanceof Article && ((Article) object).getState() == Article.STATE_ACTIVE) {
+        invalidateFeedCacheForArticle((Article) object);
+      } else if (object instanceof ArticleAnnotation) {
+        invalidateFeedCacheForAnnotation((ArticleAnnotation) object);
+      } else if (object instanceof Reply) {
+        invalidateFeedCacheForReply((Reply) object);
+      }
     }
 
@@ -474 +532 @@
      * @param article the article which might change the cash.
      */
-    @SuppressWarnings("unchecked")
     private void invalidateFeedCacheForArticle(Article article) {
-      for (FeedCacheKey key : (Set<FeedCacheKey>) feedCache.getKeys()) {
-        if (matches(key, article, true))
-          feedCache.remove(key);
+
+      for (Object key : feedCache.getKeys()) {
+        if (key instanceof ArticleFeedCacheKey) {
+          if (matchesArticle((ArticleFeedCacheKey) key, article))
+            feedCache.remove(key);
+        } else if (key instanceof AnnotationFeedCacheKey) {
+          if(matchesJournal(article, ((AnnotationFeedCacheKey)key).getJournal()))
+            feedCache.remove(key);
+        }
       }
     }
@@ -488 +551 @@
      * @param journal  the journal of interest
      */
-    @SuppressWarnings("unchecked")
     private void invalidateFeedCacheForJournalArticle(Journal journal) {
-      for (FeedCacheKey key : (Set<FeedCacheKey>) feedCache.getKeys()) {
-        if (key.getJournal().equals(journal.getKey())) {
-          feedCache.remove(key);
-        }
-      }
-    }
+      for (Object key : feedCache.getKeys()) {
+        if (key instanceof ArticleFeedCacheKey) {
+          if (((ArticleFeedCacheKey) key).getJournal().equals(journal.getKey()))
+            feedCache.remove(key);
+        } else if (key instanceof AnnotationFeedCacheKey) {
+          if (((AnnotationFeedCacheKey)key).getJournal().equals(journal.getKey()))
+            feedCache.remove(key);
+        }
+      }
+    }
+
+    /**
+     * Invalidate the cache entries based on a article annotation.
+     *
+     * @param annotation The annotation.
+     */
+    private void invalidateFeedCacheForAnnotation(ArticleAnnotation annotation) {
+      for (Object key : feedCache.getKeys()) {
+        if (key instanceof AnnotationFeedCacheKey) {
+          if (matchesAnnotation((AnnotationFeedCacheKey)key, annotation))
+            feedCache.remove(key);
+        }
+      }
+    }
+
+
+    /**
+     * Invalidate the cache entries based on a annotation reply.
+     *
+     * @param reply The reply.
+     */
+    private void invalidateFeedCacheForReply(Reply reply) {
+      for (Object key : feedCache.getKeys()) {
+        if (key instanceof AnnotationFeedCacheKey) {
+          AnnotationFeedCacheKey annotationKey = (AnnotationFeedCacheKey) key;
+          if (matchesReply(annotationKey, reply))
+            feedCache.remove(key);
+        }
+      }
+    }
+
+
+
 
     /**
@@ -527 +626 @@
      * @param key          the cache key and input parameters
      * @param article      article that has caused the change
-     * @param checkJournal include journal as part of match if true.
      * @return boolean true if we need to remove this entry from the cache
      */
-    private boolean matches(FeedCacheKey key, Article article, boolean checkJournal) {
-      if (checkJournal && !matchesJournal(key, article))
+    private boolean matchesArticle(ArticleFeedCacheKey key, Article article) {
+      if (!matchesJournal(article, key.getJournal()))
         return false;
 
       DublinCore dc = article.getDublinCore();
- 
-      if (!matchesDates(key, dc))
+
+      return matchesDates(dc.getDate(), key.getSDate(), key.getEDate()) &&
+             matchesCategory(key, article) &&
+             matchesAuthor(key, dc);
+
+    }
+
+    private boolean matchesAnnotation(AnnotationFeedCacheKey key, ArticleAnnotation annotation) {
+      try {
+        Article article = articleOtmService.getArticle(annotation.getAnnotates());
+        if (!matchesJournal(article, key.getJournal()))
+          return false;
+
+      } catch (NoSuchArticleIdException e) {
+        log.error("Failed trying to invalidate FeedCache for annotation " + annotation.getId() +
+            " and key " + key.toString(), e);
+        return true; // remove this cache entry
+      }
+
+      return matchesDates(annotation.getCreated(), key.getStartDate(), key.getEndDate()) &&
+             matchesAnnotationType(key, annotation);
+
+    }
+
+
+    private boolean matchesReply(AnnotationFeedCacheKey key, Reply reply) {
+
+      if (key.getType() != AnnotationFeedCacheKey.Type.REPLIES)
         return false;
 
-      return (!matchesCategory(key, article) && !matchesAuthor(key, dc));
-
-    }
+      ArticleAnnotation annotation = annotationService.getAnnotation(reply.getRoot());
+      if (annotation != null) {
+        try {
+          Article article = articleOtmService.getArticle(annotation.getAnnotates());
+          if (!matchesJournal(article, key.getJournal()))
+            return false;
+        } catch (NoSuchArticleIdException e) {
+          log.error("Failed trying to invalidate FeedCache for reply " + reply.getId() +
+              " and key " + key.toString(), e);
+          return true; // remove this cache entry
+        }
+
+        if (!matchesAnnotationType(key, annotation))
+          return false;
+
+      } else {
+        log.error("Root annotation not found for reply " + reply.getId());
+        return true;  // remove this cache entry
+      }
+
+      return matchesDates(reply.getCreated(), key.getStartDate(), key.getEndDate());
+
+    }
+
 
     /**
@@ -553 +698 @@
      * @return  boolean true if there is a match
      */
-    private boolean matchesAuthor(FeedCacheKey key, DublinCore dc) {
+    private boolean matchesAuthor(ArticleFeedCacheKey key, DublinCore dc) {
       boolean matches = false;
 
@@ -580 +725 @@
      * @return boolean true if the category matches (key.category = null is wildcard)
      */
-    private boolean matchesCategory(FeedCacheKey key, Article article) {
+    private boolean matchesCategory(ArticleFeedCacheKey key, Article article) {
       boolean matches = false;
 
@@ -596 +741 @@
     }
 
+    private boolean matchesAnnotationType(AnnotationFeedCacheKey key, ArticleAnnotation annotation) {
+
+      return key.getAnnotationTypes() == null ||
+             key.getAnnotationTypes().size() == 0 ||
+             key.getAnnotationTypes().contains(FEED_TYPES.Annotation.rdfType()) ||
+             annotation instanceof FormalCorrection &&
+                key.getAnnotationTypes().contains(FEED_TYPES.FormalCorrectionAnnot.rdfType()) ||
+             annotation instanceof MinorCorrection &&
+                key.getAnnotationTypes().contains(FEED_TYPES.MinorCorrectionAnnot.rdfType()) ||
+             annotation instanceof Comment &&
+                key.getAnnotationTypes().contains(FEED_TYPES.CommentAnnot.rdfType()) ||
+             annotation instanceof Retraction &&
+                key.getAnnotationTypes().contains(FEED_TYPES.RetractionAnnot.rdfType());
+
+    }
+
+
     /**
      * Check to see if the article date is between the start and end date specified in the key. If
      * it is then return true and the entry for this key should be removed.
      *
-     * @param key cache key
-     * @param dc  Dublincore field from the article
-     *
+     * @param createDate date object is created
+     * @param startDate Start date, can be null.
+     * @param endDate End date can be null.
      * @return boolean true if the article date falls between the start and end date
      */
-    private boolean matchesDates(FeedCacheKey key, DublinCore dc) {
-      Date articleDate = dc.getDate();
+    private boolean matchesDates(Date createDate, Date startDate, Date endDate) {
+
       boolean matches = false;
 
       // If start and end are null then it doesn't matter what the article date is.
-      if ((key.getEDate() == null) && (key.getSDate() == null)) {
+      if ((endDate == null) && (startDate == null)) {
         matches = true;
-      } else if (articleDate != null) {
-        if ((key.getEDate() == null) && articleDate.after(key.getSDate())) {
+      } else if (createDate != null) {
+        if ((endDate == null) && createDate.after(startDate)) {
           matches = true;
-        } else if ((key.getSDate() == null) && articleDate.before(key.getEDate())) {
+        } else if ((startDate == null) && createDate.before(endDate)) {
           matches = true;
-        } else if (articleDate.after(key.getSDate()) && articleDate.before(key.getEDate())) {
+        } else if (createDate.after(startDate) && createDate.before(endDate)) {
           matches = true;
         }
@@ -628 +790 @@
      * journals the article belongs to.
      *
-     * @param key      a cache key and actiopn data model
      * @param article  the article
+     * @param journalKey Journal
      * @return boolean true if key.journal matches one of the journals returned
      *         by the journal service.
      */
-    private boolean matchesJournal(FeedCacheKey key, Article article) {
+    private boolean matchesJournal(Article article, String journalKey) {
       boolean matches = false;
 
-      if (key.getJournal() != null) {
+      if (journalKey != null) {
         for (Journal journal : journalService.getJournalsForObject(article.getId())) {
-          if (journal.getKey().equals(key.getJournal())) {
+          if (journal.getKey().equals(journalKey)) {
             matches = true;
             break;

head/ambra/webapp/src/main/java/org/topazproject/ambra/struts2/AmbraFeedResult.java

@@ -32 +32 @@
 import java.util.Date;
 import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
 
 import java.io.Writer;
@@ -50 +52 @@
 import org.topazproject.ambra.models.Representation;
 import org.topazproject.ambra.models.UserProfile;
-import org.topazproject.ambra.article.action.ArticleFeed;
-import org.topazproject.ambra.article.service.ArticleFeedService;
-import org.topazproject.ambra.article.service.FeedCacheKey;
-import org.topazproject.ambra.article.service.ArticleFeedService.FEED_TYPES;
+import org.topazproject.ambra.feed.service.FeedService;
+import org.topazproject.ambra.feed.service.ArticleFeedCacheKey;
+import org.topazproject.ambra.feed.service.FeedService.FEED_TYPES;
 import org.topazproject.ambra.web.VirtualJournalContext;
 import org.topazproject.ambra.configuration.ConfigurationStore;
@@ -59 +60 @@
 import org.jdom.Element;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Required;
 import org.topazproject.ambra.models.UserAccount;
 import org.topazproject.ambra.annotation.service.WebAnnotation;
+import org.topazproject.ambra.annotation.service.WebReply;
+import org.topazproject.ambra.annotation.service.BaseAnnotation;
 import org.topazproject.ambra.ApplicationException;
 import org.topazproject.ambra.model.article.ArticleType;
@@ -87 +91 @@
  * </pre>
  *
- * @see       org.topazproject.ambra.article.service.FeedCacheKey
- * @see       ArticleFeed
+ * @see       org.topazproject.ambra.feed.service.ArticleFeedCacheKey
+ * @see       org.topazproject.ambra.feed.action.FeedAction
  *
  * @author jsuttor
  */
 public class AmbraFeedResult extends Feed implements Result {
-  private List<Article>       articles;
-  private List<WebAnnotation> annotations;
-  private ArticleFeedService  articleFeedService;
+  private FeedService feedService;
   private ArticleXMLUtils     articleXmlUtils;
 
@@ -179 +181 @@
   @SuppressWarnings("unchecked")
   public void execute(ActionInvocation ai) throws Exception {
+
     HttpServletRequest request = ServletActionContext.getRequest();
     String pathInfo = request.getPathInfo();
@@ -189 +192 @@
 
     // Get the article IDs that were cached by the feed.
-    FeedCacheKey cacheKey = (FeedCacheKey)ai.getStack().findValue("cacheKey");
-    List<String> articleIds = (List<String>) ai.getStack().findValue("Ids");
-    FEED_TYPES t =  cacheKey.feedType();
-
-    switch (t) {
-      case Annotation:
-      case FormalCorrectionAnnot:
-      case MinorCorrectionAnnot:
-      case CommentAnnot:
-        annotations = articleFeedService.getAnnotations(articleIds);
-        break;
-      case Article :
-      case Issue :
-        articles = articleFeedService.getArticles(articleIds);
-        break;
-    }
-
-    String xmlBase = (cacheKey.getRelativeLinks() ? "" : JOURNAL_URI);
+    ArticleFeedCacheKey cacheKey = (ArticleFeedCacheKey)ai.getStack().findValue("cacheKey");
 
     List<Link> otherLinks = new ArrayList<Link>();
@@ -217 +203 @@
 
     Content tagline = new Content();
-
     tagline.setValue(FEED_TAGLINE());
     setTagline(tagline);
+
     setUpdated(new Date());
     setIcon(FEED_ICON());
@@ -230 +216 @@
     setAuthors(feedAuthors);
 
-    // Add each Article as a Feed Entry
+    String xmlBase = (cacheKey.getRelativeLinks() ? "" : JOURNAL_URI);
+
+
+    FEED_TYPES t =  cacheKey.feedType();
+
+    List<String> articleIds = (List<String>) ai.getStack().findValue("Ids");
+
+    // Add each Article or Annotations as a Feed Entry
     List<Entry> entries = null;
 
@@ -237 +230 @@
       case FormalCorrectionAnnot:
       case MinorCorrectionAnnot:
+      case RetractionAnnot:
       case CommentAnnot:
-        entries = buildAnnotationFeed(xmlBase);
+        List<WebAnnotation> annotations = feedService.getAnnotations(articleIds);
+        List<String> replyIds = (List<String>) ai.getStack().findValue("ReplyIds");
+        List<WebReply> replies = feedService.getReplies(replyIds);
+        entries = buildAnnotationFeed(xmlBase, annotations, replies, cacheKey.getMaxResults());
         break;
       case Article :
       case Issue :
-        entries = buildArticleFeed(cacheKey, xmlBase);
+        List<Article> articles = feedService.getArticles(articleIds);
+        entries = buildArticleFeed(cacheKey, xmlBase, articles);
         break;
     }
@@ -255 +253 @@
    *
    * @param xmlBase   xml base url
+   * @param annotations list of web annotations
+   * @param replies list of web replies
+   * @param maxResults maximum number of results to display
    * @return List of entries for the feed
    * @throws Exception   Exception
    */
-  private List<Entry> buildAnnotationFeed(String xmlBase) throws Exception {
+  private List<Entry> buildAnnotationFeed(String xmlBase,
+                                          List<WebAnnotation> annotations,
+                                          List<WebReply> replies,
+                                          int maxResults)
+      throws Exception {
+
+    // Combine annotations and replies sorted by date
+    SortedMap<Date, BaseAnnotation> map = new TreeMap<Date, BaseAnnotation>();
+
+    for (WebAnnotation annotation : annotations) {
+      map.put(annotation.getCreatedAsDate(), annotation);
+    }
+
+    for (WebReply reply : replies) {
+      map.put(reply.getCreatedAsDate(), reply);
+    }
+
     // Add each Article as a Feed Entry
     List<Entry> entries = new ArrayList<Entry>();
 
-    for (WebAnnotation annot : annotations) {
+    int i = 0;
+    for (BaseAnnotation annot : map.values()) {
+
       Entry entry = newEntry(annot);
-      List<String> ids = new ArrayList<String>();
-      List<Article> art;
-      List<Link> altLinks = new ArrayList<Link>();
-
-      ids.add(annot.getAnnotates());
-      art = articleFeedService.getArticles(ids);
+
+      String displayName;
+      List<String> articleIds = new ArrayList<String>();
+      if (annot instanceof WebReply) {
+        WebReply webReply = (WebReply) annot;
+        List<String> rootAnnotationIds = new ArrayList<String>();
+        rootAnnotationIds.add(webReply.getRoot());
+        List<WebAnnotation> rootAnnotations = feedService.getAnnotations(rootAnnotationIds);
+        articleIds.add(rootAnnotations.get(0).getAnnotates());
+        displayName = "Reply";
+      } else {
+        WebAnnotation webAnnotation = (WebAnnotation) annot;
+        articleIds.add(webAnnotation.getAnnotates());
+        displayName = webAnnotation.getDisplayName();
+      }
+
+      List<Article> art = feedService.getArticles(articleIds);
 
       // Link to annotation via xmlbase
       Link selfLink = newSelfLink(annot, xmlBase);
+
+      List<Link> altLinks = new ArrayList<Link>();
       altLinks.add(selfLink);
 
@@ -287 +319 @@
       Person person = new Person();
 
-      UserAccount ua = articleFeedService.getUserAcctFrmID(annot.getCreator());
+      UserAccount ua = feedService.getUserAcctFrmID(annot.getCreator());
       if (ua != null)
         person.setName(ua.getProfile().getDisplayName());
@@ -296 +328 @@
       entry.setAuthors(authors);
 
-      List <Content> contents = newAnnotationsList(annot, selfLink);
+      List <Content> contents = newAnnotationsList(selfLink, displayName, annot.getComment());
       entry.setContents(contents);
 
-      List<com.sun.syndication.feed.atom.Category> categories = newCategoryList(annot);
+      List<com.sun.syndication.feed.atom.Category> categories = newCategoryList(displayName);
       entry.setCategories(categories);
 
       // Add completed Entry to List
       entries.add(entry);
+
+      // i starts with 1, if maxResults=0 this will not interrupt the loop
+      if (++i == maxResults)
+        break;
     }
     return entries;
@@ -312 +348 @@
    * by the query action.
    *
-   * @param cacheKey   cache/data model
+   * @param cacheKey    cache/data model
    * @param xmlBase     xml base url
+   * @param articles    list of articles
    * @return List of entries for feed.
    */
-  private List<Entry> buildArticleFeed(FeedCacheKey cacheKey, String xmlBase) {
+  private List<Entry> buildArticleFeed(ArticleFeedCacheKey cacheKey, String xmlBase, List<Article> articles) {
     // Add each Article as a Feed Entry
     List<Entry> entries = new ArrayList<Entry>();
@@ -456 +493 @@
    * @return List<Content> consisting of HTML descriptions of the article and author
    */
-  private List<Content>newContentsList(FeedCacheKey cacheKey, Article article, String authorNames,
+  private List<Content>newContentsList(ArticleFeedCacheKey cacheKey, Article article, String authorNames,
       int numAuthors) {
     List<Content> contents = new ArrayList<Content>();
@@ -490 +527 @@
    * the Author (or Authors if extended format) and the DublinCore description of the article.
    *
-   * @param annotation  annotation to convert into Content element
    * @param link        link to the article
    *
+   * @param entryTypeDisplay text to describe type of entry : FormalCorrection, Reply ...
+   * @param comment Comment
    * @return List<Content> consisting of HTML descriptions of the article and author
    *
@@ -498 +536 @@
    */
 
-  private List<Content>newAnnotationsList(WebAnnotation annotation, Link link)
-                         throws ApplicationException {
+  private List<Content> newAnnotationsList(Link link, String entryTypeDisplay, String comment)
+      throws ApplicationException {
+
     List<Content> contents = new ArrayList<Content>();
     Content description = new Content();
-    String displayName = annotation.getDisplayName();
     description.setType("html");
 
     StringBuilder text = new StringBuilder();
     text.append("<p>");
-    if (displayName != null) {
-      String d = displayName + " on ";
-      text.append(d);
-    }
-
-    {
-      String d = " <a href=" + link.getHref() + ">" + link.getTitle() + "</a></p>";
-      text.append(d);
-      d = "<p>" + annotation.getComment() + "</p>";
-      text.append(d);
-    }
+    if (entryTypeDisplay != null)
+      text.append(entryTypeDisplay).append(" on ");
+
+    text.append(" <a href=")
+        .append(link.getHref())
+        .append('>')
+        .append(link.getTitle())
+        .append("</a></p>")
+        .append("<p>")
+        .append(comment)
+        .append("</p>");
     description.setValue(text.toString());
     contents.add(description);
@@ -553 +591 @@
    * @return String of authors names.
    */
-  private String newAuthorsList(FeedCacheKey cacheKey, Article article, List<Person> authors) {
+  private String newAuthorsList(ArticleFeedCacheKey cacheKey, Article article, List<Person> authors) {
     Citation bc = article.getDublinCore().getBibliographicCitation();
     StringBuilder authorNames = new StringBuilder();
@@ -628 +666 @@
    * @return  link to the article
    */
-  private Link newSelfLink(WebAnnotation annot, String xmlBase) {
+  private Link newSelfLink(BaseAnnotation annot, String xmlBase) {
+
+    String url;
+    if (annot instanceof WebReply) {
+      url = ((WebReply)annot).getRoot();
+    } else {
+      url = doiToUrl(annot.getId());
+    }
+
+    StringBuilder href = new StringBuilder(xmlBase)
+          .append("annotation/listThread.action?inReplyTo=")
+          .append(url)
+          .append("&root=")
+          .append(url);
+
+    // add anchor
+    if (annot instanceof WebReply) {
+      href.append('#').append(annot.getId());
+    }
+
     Link link = new Link();
-    String href = xmlBase + "annotation/listThread.action?inReplyTo=";
-    String url = doiToUrl(annot.getId());
-
     link.setRel("alternate");
-    link.setHref(href + url + "&root=" + url);
+    link.setHref(href.toString());
     link.setTitle(annot.getCommentTitle());
     return link;
@@ -691 +745 @@
    * @return Entry  feed entry
    */
-  private Entry newEntry(WebAnnotation annot) {
+  private Entry newEntry(BaseAnnotation annot) {
     Entry entry = new Entry();
 
@@ -704 +758 @@
   }
 
+
   /**
    * Create a default Plos person element.
@@ -728 +783 @@
    * @return <code>Link</code> user provide link.
    */
-  private Link newLink(FeedCacheKey cacheKey, String uri) {
+  private Link newLink(ArticleFeedCacheKey cacheKey, String uri) {
     if (cacheKey.getSelfLink() == null || cacheKey.getSelfLink().equals("")) {
       if (uri.startsWith("/")) {
@@ -748 +803 @@
    * Build an atom feed categroy list for for the WebAnnotation.
    *
-   * @param annotation build category element from annotation
-   *
+   * @param displayName Name of the entry.
    * @return  List of  atom categories
    */
-  public List<com.sun.syndication.feed.atom.Category> newCategoryList(WebAnnotation annotation) {
+  public List<com.sun.syndication.feed.atom.Category> newCategoryList(String displayName) {
     List<com.sun.syndication.feed.atom.Category> categories =
         new ArrayList<com.sun.syndication.feed.atom.Category>();
     com.sun.syndication.feed.atom.Category cat = new com.sun.syndication.feed.atom.Category();
 
-    cat.setTerm(annotation.getDisplayName());
-    cat.setLabel(annotation.getDisplayName());
+    cat.setTerm(displayName);
+    cat.setLabel(displayName);
     categories.add(cat);
 
@@ -771 +825 @@
    * @return String identifier generated for this feed
    */
-  private String newFeedID(FeedCacheKey cacheKey) {
+  private String newFeedID(ArticleFeedCacheKey cacheKey) {
     String id = FEED_ID();
     if (cacheKey.getCategory() != null && cacheKey.getCategory().length() > 0)
@@ -787 +841 @@
    * @return String feed title.
    */
-  private String newFeedTitle(FeedCacheKey cacheKey) {
+  private String newFeedTitle(ArticleFeedCacheKey cacheKey) {
     String feedTitle = cacheKey.getTitle();
 
@@ -870 +924 @@
    * @param articleXmlUtils  a set of XML transformation utilities
    */
+  @Required
   public void setArticleXmlUtils(ArticleXMLUtils articleXmlUtils) {
     this.articleXmlUtils = articleXmlUtils;
@@ -875 +930 @@
 
   /**
-   * @param  articleFeedService    Article Feed Service
-   */
-  public void setArticleFeedService(ArticleFeedService articleFeedService) {
-    this.articleFeedService = articleFeedService;
+   * @param  feedService    Article Feed Service
+   */
+  @Required
+  public void setFeedService(FeedService feedService) {
+    this.feedService = feedService;
   }
 }

head/ambra/webapp/src/main/resources/struts.xml

@@ -427 +427 @@
     <default-action-ref name="pageNotFound" />
 
-    <action name="getFeed" class="org.topazproject.ambra.article.action.ArticleFeed">
-      <result name="success" type="feed">
-        <param name="feedName">wireFeed</param>
+    <action name="getFeed" class="org.topazproject.ambra.feed.action.FeedAction">
+      <result name="success" type="feed"/>
+      <result name="input" type="httpheader">
+        <param name="status">400</param><!-- Http status: Bad Request-->
       </result>
     </action>

head/ambra/webapp/src/main/webapp/discussion/threaded_replies.ftl

@@ -2 +2 @@
   $HeadURL::                                                                            $
   $Id$
-  
+
   Copyright (c) 2007-2009 by Topaz, Inc.
   http://topazproject.org
-  
+
   Licensed 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,
@@ -31 +31 @@
         <div class="hd">
           <!-- begin response title -->
-          <h3>${reply.commentTitle}</h3>
+          <h3><a name="${reply.id}">${reply.commentTitle}</a></h3>
           <!-- end : response title -->
           <!-- begin : response poster details -->
@@ -97 +97 @@
       <div class="hd">
         <!-- begin response title -->
-        <h3>${baseAnnotation.commentTitle}</h3>
+        <h3><a name="${baseAnnotation.id}">${baseAnnotation.commentTitle}</a></h3>
         <!-- end : response title -->
         <!-- begin : response poster detail -->

head/ambra/webapp/src/main/webapp/WEB-INF/applicationContext.xml

@@ -94 +94 @@
    </bean>
 
-  <bean id="articleFeedService" class="org.topazproject.ambra.article.service.ArticleFeedService">
+  <bean id="feedService" class="org.topazproject.ambra.feed.service.FeedService">
     <property name="articleOtmService" ref="articleOtmService"/>
     <property name="annotationService" ref="annotationService"/>

head/ambra/webapp/src/test/java/org/topazproject/ambra/annotation/service/AnnotationServiceTest.java

@@ -54 +54 @@
 import java.util.ArrayList;
 import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 import java.text.SimpleDateFormat;
 import java.text.ParseException;
@@ -147 +149 @@
   }
 
-  
+
   @Test
-  public void getAnnotations() throws ParseException, URISyntaxException {
+  public void getAnnotationIds() throws ParseException, URISyntaxException {
 
     IMocksControl ctl = createControl();
@@ -155 +157 @@
     PDP pdp = ctl.createMock(PDP.class);
     Session session = ctl.createMock(Session.class);
-    Query query = ctl.createMock(Query.class);
-    Results results = ctl.createMock(Results.class);
+    Query annQuery = ctl.createMock(Query.class);
+    Results annResults = ctl.createMock(Results.class);
     CacheManager cacheManager = ctl.createMock(CacheManager.class);
     MockCache cache = new MockCache();
@@ -164 +166 @@
     Date startDate = dateFormat.parse("02/01/2009");
     Date endDate = dateFormat.parse("03/10/2009");
-    int[] states = {0, 1};
-    List<String> annotType = new ArrayList<String>();
+    Set<String> annotType = new HashSet<String>();
     annotType.add("FormalCorrection");
     annotType.add("MinorCorrection");
 
-    String articleId = "info:doi/10.1371/journal.pone.0002250";
-    String queryString = "select a.id id, cr from Annotation a " +
-        "where cr := a.created and a.annotates = :targ and a.mediator = :med and ge(cr, :sd) " +
-        "and le(cr, :ed) and (art.state = :st0 or art.state = :st1) " +
+    String queryString = "select a.id id, cr from ArticleAnnotation a, Article ar " +
+        "where a.annotates = ar " +
+        "and cr := a.created " +
+        "and ge(cr, :sd) " +
+        "and le(cr, :ed) " +
         "and (a.<rdf:type> = :type0 or a.<rdf:type> = :type1) " +
-        "order by cr asc, id asc limit 20;";
+        "order by cr asc, id asc limit 3;";
+
     String applicationId = "test-app";
+
     URI annotation1id = URI.create("info:doi/10.1371/annotation1");
     URI annotation2id = URI.create("info:doi/10.1371/annotation2");
     URI annotation3id = URI.create("info:doi/10.1371/annotation3");
 
-    Comment comment = new Comment();
-    comment.setId(annotation1id);
-    FormalCorrection formalCorrection = new FormalCorrection();
-    formalCorrection.setId(annotation2id);
-    MinorCorrection minorCorrection = new MinorCorrection();
-    minorCorrection.setId(annotation3id);
-
-    List<ArticleAnnotation> expected = new ArrayList<ArticleAnnotation>();
-    expected.add(comment);
-    expected.add(formalCorrection);
-    expected.add(minorCorrection);
+    List<String> expected = new ArrayList<String>();
+    expected.add(annotation1id.toString());
+    expected.add(annotation2id.toString());
+    expected.add(annotation3id.toString());
 
     cacheManager.registerListener(isA(AbstractObjectListener.class));
@@ -199 +196 @@
         .anyTimes();
 
+    // Run Annotation Query
     expect(session.createQuery(queryString))
-        .andReturn(query);
-    expect(query.setParameter("targ", articleId))
-        .andReturn(query);
-    expect(query.setParameter("med", applicationId))
-        .andReturn(query);
-    expect(query.setParameter("sd", startDate))
-        .andReturn(query);
-    expect(query.setParameter("ed", endDate))
-        .andReturn(query);
-
-    for (int i = 0; i < states.length; i++) {
-      expect(query.setParameter("st"+i, states[i]))
-          .andReturn(query);
+        .andReturn(annQuery);
+    expect(annQuery.setParameter("sd", startDate))
+        .andReturn(annQuery);
+    expect(annQuery.setParameter("ed", endDate))
+        .andReturn(annQuery);
+
+    int i = 0;
+    for (String type : annotType) {
+      expect(annQuery.setUri("type"+i++, URI.create(type)))
+          .andReturn(annQuery);
     }
 
-    for (int i = 0; i < annotType.size(); i++) {
-      expect(query.setUri("type"+i, URI.create(annotType.get(i))))
-          .andReturn(query);
-    }
-
-    expect(query.execute())
-        .andReturn(results);
-
-    expect(results.next())
+    expect(annQuery.execute())
+        .andReturn(annResults);
+
+    expect(annResults.next())
         .andReturn(true).times(3)
         .andReturn(false);
-    expect(results.getURI(0))
+    expect(annResults.getURI(0))
         .andReturn(annotation1id)
         .andReturn(annotation2id)
         .andReturn(annotation3id);
-    
-    expect(session.get(ArticleAnnotation.class, annotation1id.toString()))
-        .andReturn(comment);
-    expect(session.get(ArticleAnnotation.class, annotation2id.toString()))
-        .andReturn(formalCorrection);
-    expect(session.get(ArticleAnnotation.class, annotation3id.toString()))
-        .andReturn(minorCorrection);
-    
+
     ctl.replay();
 
@@ -251 +234 @@
 
 
-    List<ArticleAnnotation> annotations = annotationService.getAnnotations(
-        articleId, startDate, endDate, applicationId, annotType, states, true, 20);
-
-    assertEquals(annotations, expected);
+    List<String> annotationIds = annotationService.getAnnotationIds(startDate, endDate,
+        new HashSet<String>(annotType), 3);
+
+    assertEquals(annotationIds, expected);
 
     ctl.verify();