Changeset 7296

Timestamp:

Feb 20, 2017, 1:04:19 PM (7 years ago)

Author:

Nicklas Nordborg

Message:

References #2056: Improve API for project-specific annotations

Introduced methods on the AnnotationSet class that can be used to create/read/query/delete project-specific or default annotation values no matter what the currently active project is.

The test class has been extended with additional test cases.

Location:

trunk/src

Files:

• core/net/sf/basedb/core/Annotation.java (modified) (4 diffs)
• core/net/sf/basedb/core/AnnotationSet.java (modified) (6 diffs)
• test/TestAnnotation.java (modified) (6 diffs)

trunk/src/core/net/sf/basedb/core/Annotation.java

@@ -311 +311 @@
   }
   
+  private boolean ignoreActiveProject;
+  /**
+    Set the project that this annotation value should 
+    belong to. This will disable the automatic check
+    that creates a new project-specific value when 
+    trying to change the default value and a project
+    is active.
+    @since 3.11
+  */
+  void setProjectId(int projectId)
+  {
+    getData().setProjectId(projectId);
+    ignoreActiveProject = true;
+  }
+  
   /**
     Get the annotation set this annotation belongs to.
@@ -394 +409 @@
   {
     return getData().getProjectId() != 0;
+  }
+  
+  /**
+    Checks if this annotation is ignoring the currently active
+    project. This affects how the {@link #setValuesIfDifferent(List, Unit)}
+    methods treats annotations that represents the default value
+    for a project-specific annotation.
+
+    If this method returns FALSE the default value is not modified.
+    Instead, a new project-specific value for the currently active project
+    is created (or the existing one is updated)
+
+    If this method returns TRUE it is always this annotation that is
+    modified.
+    
+    @return TRUE if ignoring the active project
+    @since 3.11
+  */
+  public boolean isIgnoringActiveProject()
+  {
+    return ignoreActiveProject;
   }
   
@@ -706 +742 @@
     changed. The project-specific annotation can be retrieved by calling
     {@link AnnotationSet#getAnnotation(AnnotationType)}.
+    <p>
+    An exception to the above (since BASE 3.11) is if the annotation was loaded with
+    {@link AnnotationSet#getProjectAnnotation(AnnotationType, int)} in 
+    which case currently active project is ignored and the values are
+    always changed on this annotation (eg. the same as if this annotation
+    was not using project-specific annotations).
+    Use the {@link #isIgnoringActiveProject()} to find out if the active 
+    project is ignored or not.
     
     @param values A list containing the new values
@@ -736 +780 @@
     
     int projectId = getSessionControl().getActiveProjectId();
-    boolean useProjectAnnotations = isInDatabase() && annotationType.getProjectAnnotations() && 
-      projectId != 0 && getData().getProjectId() == 0;
+    boolean useProjectAnnotations = !ignoreActiveProject && isInDatabase() && 
+      annotationType.getProjectAnnotations() && projectId != 0 && getData().getProjectId() == 0;
     if (useProjectAnnotations)
     {

trunk/src/core/net/sf/basedb/core/AnnotationSet.java

@@ -602 +602 @@
   
   /**
+    Get a value for a project-specific annotation using the specified project id instead
+    of the currently active project. Note that this method behaves differently than
+    the {@link #getAnnotation(AnnotationType)} method.
+    
+     * If the annotation type is not using project annotation, the project id is ignored
+     * If projectId=0 the default annotation  value is returned (new or existing)
+     * If projectId!=0 a project-specific annotation value is returned (new or existing,
+       the default value is never returned)
+       
+    The returned annotation is always locked to the project it has been defined for.
+    Calling {@link Annotation#setValuesIfDifferent(List, Unit)} will always modify the
+    existing value (it will not create a new project-specific value when trying
+    to change the default value).
+
+    @param annotationType The annotation type
+    @param projectId The project id or 0 to get the default value
+    @since 3.11
+  */
+  public Annotation getProjectAnnotation(AnnotationType annotationType, int projectId)
+  {
+    if (annotationType == null) throw new InvalidUseOfNullException("annotationType");
+    DbControl dc = getDbControl();
+    
+    int primary = Annotation.Source.PRIMARY.ordinal();
+    if (!annotationType.getProjectAnnotations()) projectId = 0;
+
+    // Search for an existing primary annotation
+    AnnotationTypeData atd = annotationType.getData();
+    AnnotationData found = null;
+    for (AnnotationData ad : getData().getAnnotations())
+    {
+      if (ad.getSource() == primary && ad.getAnnotationType().equals(atd))
+      {
+        // This is a primary annotation of the correct type
+        // Check for project-specific match
+        if (ad.getProjectId() == projectId)
+        {
+          found = ad;
+          break;
+        }
+      }
+    }
+    
+    Annotation a = null;
+    if (found != null) 
+    {
+      a = dc.getItem(Annotation.class, found);
+    }
+    else
+    {
+      // Create a new annotation
+      checkPermission(Permission.WRITE);
+      annotationType.checkPermission(Permission.USE);
+      // AnnotatableProxy items allow annotations of all types
+      boolean isAnnotatableProxy = AnnotatableProxy.class.isAssignableFrom(getItemType().getItemClass());
+      if (!isAnnotatableProxy && !annotationType.isEnabledForItem(getItemType()) &&  
+        !annotationType.isProtocolParameter(getItem().getProtocol()))
+      {
+        throw new InvalidAnnotationException(annotationType, getItemType());
+      }
+      
+      a = Annotation.getNewPrimary(dc, this, atd);
+      dc.saveItemIf(this, a, false);
+      setSnapshotInvalid();
+    }
+    
+    a.setProjectId(projectId);
+    
+    return a;
+  }
+  
+  
+  /**
     Check if the annotation set contains primary annotation of the specified type.
     
@@ -652 +725 @@
   
   /**
+    Check if the annotation set contains an annotation of the specified type.
+    If the annotation type has enabled project-specific annotations 
+    (see {@link AnnotationType#getProjectAnnotations()}), this method 
+    will only check if an annotation for the given project exists (or the
+    default value if projectId=0). Annotations that are specific
+    for other projects are ignored.
+    
+    @param annotationType An <code>AnnotationType</code> object
+    @param source The source type of the annotation or null if it doesn't matter
+    @param projectId The project id or 0 to get the default value
+    
+    @return TRUE if the annotation set contains an annotation of 
+      the specified type, FALSE otherwise
+    @since 3.11
+  */
+  public boolean hasProjectAnnotation(AnnotationType annotationType, Annotation.Source source, int projectId)
+  {
+    if (annotationType == null) return false;
+    
+    DbControl dc = getDbControl();
+    if (!annotationType.getProjectAnnotations()) projectId = 0;
+    
+    AnnotationTypeData atd = annotationType.getData();
+    for (AnnotationData ad : getData().getAnnotations())
+    {
+      boolean matchSource = source == null || ad.getSource() == source.ordinal();
+      // Matches current project or the default value
+      boolean matchProject = ad.getProjectId() == projectId;
+      if (matchSource && matchProject && ad.getAnnotationType().equals(atd))
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  
+  /**
     Delete the primary annotation of the specified annotation type.
 
@@ -669 +780 @@
     throws PermissionDeniedException, InvalidDataException, BaseException
   {
+    removeProjectAnnotation(annotationType, getSessionControl().getActiveProjectId());
+  }
+  
+  /**
+    Delete the primary annotation of the specified annotation type.
+  
+    Note that this method is intended to be used
+    with project-specific annotation and will only remove the value
+    for the given project (or the default value if projectId=0).
+    
+    @param annotationType The type of the annotation to delete
+    @param projectId The project id or 0 to remove the default value
+    @throws PermissionDeniedException If the logged in user
+      doesn't have write permission
+    @throws InvalidDataException If the annotation type is null
+    @throws BaseException If there is another error
+    @since 3.11
+  */
+  public void removeProjectAnnotation(AnnotationType annotationType, int projectId)
+    throws PermissionDeniedException, InvalidDataException, BaseException
+  {
     checkPermission(Permission.WRITE);
     if (annotationType == null) throw new InvalidUseOfNullException("annotationType");
     annotationType.checkPermission(Permission.USE);
+    if (!annotationType.getProjectAnnotations()) projectId = 0;
     
     DbControl dc = getDbControl();
     int primary = Annotation.Source.PRIMARY.ordinal();
-    int activeProjectId = annotationType.getProjectAnnotations() ? 
-      dc.getSessionControl().getActiveProjectId() : 0;
     AnnotationTypeData atd = annotationType.getData();
     
@@ -684 +815 @@
       AnnotationData a = it.next();
       boolean matchSource = a.getSource() == primary;
-      boolean matchProject = a.getProjectId() == activeProjectId;
+      boolean matchProject = a.getProjectId() == projectId;
       if (matchSource && matchProject && a.getAnnotationType().equals(atd))
       {
@@ -699 +830 @@
     }
   }
-  
+
   /**
     Get a query returning annotations with the specified source.
+    
+    If the annotation type is using project-specific annotations
+    the query will load project-specific values where they exists
+    and otherwise default values.
 
     @param source A source or null to not filter on source
@@ -725 +860 @@
     return query;
   }
+
+  /**
+    Get a query returning annotations with the specified source
+    and belonging to the specified project (or default
+    values if projectId=0).
+  
+    @param source A source or null to not filter on source
+    @param projectId The project id or 0 to query default values
+    @since 3.11
+  */
+  public ItemQuery<Annotation> getProjectAnnotations(Annotation.Source source, int projectId)
+  {
+    ItemQuery<Annotation> query = Annotation.getQuery();
+    query.restrictPermanent(
+      Restrictions.eq(
+        Hql.property("annotationSet"),
+        Hql.entity(this)
+    ));
+    query.restrictPermanent(
+      Restrictions.eq(
+        Hql.property("projectId"), 
+        Expressions.integer(projectId)
+    ));
+    if (source != null)
+    {
+      query.restrictPermanent(
+        Restrictions.eq(
+          Hql.property("source"), 
+          Expressions.integer(source.ordinal())
+      ));
+    }
+    return query;
+  }
+
   
   /**

trunk/src/test/TestAnnotation.java

@@ -70 +70 @@
     int arrayDesignId = TestArrayDesign.test_create(Platform.GENERIC, true);
     int arrayDesignId2 = TestArrayDesign.test_create(Platform.AFFYMETRIX, true);
+    int arrayDesignId3 = TestArrayDesign.test_create(Platform.AFFYMETRIX, true);
 
     // Create project and a project-specific annotation
@@ -116 +117 @@
     int project1AnnotationId = test_annotatate(Item.ARRAYDESIGN, arrayDesignId2, projectSpecificId, 0, "project 1 value");
     test_inherit_annotation(Item.RAWBIOASSAY, rawBioAssayId2, project1AnnotationId, false);
+    
     TestProject.test_noactive_project();
     
@@ -123 +125 @@
       ok = false;
     }
-
+    
     // Check that the annotation values are as expected
     test_project_annotation(Item.ARRAYDESIGN, arrayDesignId2, projectSpecificId, "default value", "project 1 value");
@@ -130 +132 @@
     TestProject.test_activate_project(project2, null);
     test_project_annotation(Item.ARRAYDESIGN, arrayDesignId2, projectSpecificId, "default value", "project 1 value");
-
+    TestProject.test_noactive_project();
+    
+    // Test new API for working with project-specific values
+    // Create project-specific value when no project is active
+    test_annotatate_forceproject(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, project1, "project 1 value (3)");
+
+    // Create default value when a project is active
+    TestProject.test_activate_project(project1, null);
+    test_annotatate_forceproject(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, 0, "default value (3)");
+
+    // Check the values
+    test_project_annotation(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, "project 1 value (3)", "default value (3)");
+    TestProject.test_activate_project(project2, null);
+    test_project_annotation(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, "default value (3)", "project 1 value (3)");
+    TestProject.test_noactive_project();
+    test_project_annotation(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, "default value (3)", "project 1 value (3)");
+    
+    // Update project-specific value when no project is active
+    test_annotatate_forceproject(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, project1, "project 1 value (updated)");
+    // Update default value when a project is active
+    TestProject.test_activate_project(project1, null);
+    test_annotatate_forceproject(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, 0, "default value (updated)");
+    
+    // Check the values
+    test_project_annotation(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, "project 1 value (updated)", "default value (updated)");
+    TestProject.test_activate_project(project2, null);
+    test_project_annotation(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, "default value (updated)", "project 1 value (updated)");
+    TestProject.test_noactive_project();
+    test_project_annotation(Item.ARRAYDESIGN, arrayDesignId3, projectSpecificId, "default value (updated)", "project 1 value (updated)");
     
     if (TestUtil.waitBeforeDelete()) TestUtil.waitForEnter();
@@ -162 +192 @@
     TestArrayDesign.test_delete(arrayDesignId);
     TestArrayDesign.test_delete(arrayDesignId2);
+    TestArrayDesign.test_delete(arrayDesignId3);
     TestAnnotationType.test_delete(projectSpecificId);
     TestAnnotationType.test_delete(intId);
@@ -240 +271 @@
   }
 
+  static int test_annotatate_forceproject(Item itemType, int itemId, int annotationTypeId, int projectId, Object... value)
+  {
+    if (itemId == 0 || annotationTypeId == 0) return 0;
+    int id = 0;
+    DbControl dc = null;
+    try
+    {
+      dc = TestUtil.getDbControl();
+      Annotatable annotatable = (Annotatable)itemType.getById(dc, itemId);
+      AnnotationType at = AnnotationType.getById(dc, annotationTypeId);
+
+      AnnotationSet as = annotatable.getAnnotationSet();
+      Annotation a = as.getProjectAnnotation(at, projectId);
+      
+      if (value != null)
+      {
+        List<Object> l = new ArrayList<Object>();
+        l.addAll(Arrays.asList(value));
+        boolean changed = a.setValuesIfDifferent(l, null);
+      }
+      dc.commit();
+      id = a.getId();
+      dc = TestUtil.getDbControl();
+      dc.reattachItem(a, false);
+      write_item(0, a);
+      write("--Create annotation OK");
+    }
+    catch (Throwable ex)
+    {
+      write("--Create annotation FAILED");
+      ex.printStackTrace();
+      ok = false;
+    }
+    finally
+    {
+      if (dc != null) dc.close();
+    }
+    return id;
+  }
+
+  
   static void test_remove_annotation(Item itemType, int itemId, int annotationTypeId)
   {