Class BasicItem

    • Field Detail

      • data

        private final BasicData data
        The data class from the net.sf.basedb.core.data layer that holds the data for this item.
      • dc

        private WeakReference<DbControl> dc
        A reference to the current DbControl object. We use a WeakReference since we it is always the client applications responsibility to keep control over the DbControl object.
      • permissions

        private int permissions
        The logged in user's permission to this item. Calculated by the initPermissions(int, int) method.
      • hasBeenCalledFromGetAnnotationSet

        private boolean hasBeenCalledFromGetAnnotationSet
      • hasBeenCalledFromAnnotationBatcher

        private boolean hasBeenCalledFromAnnotationBatcher
    • Method Detail

      • hasPermission

        public final boolean hasPermission​(Permission permission)
        Checks if the logged in user has the specified permission on this item. The default implementation only checks the role keys for permissions. A subclass may not override this method since it would make it possible to bypass security checks.

        Subclasses that needs to check other keys, such as the SharedItem should override the initPermissions(int,int) method instead.

        Specified by:
        hasPermission in interface AccessControlled
        Parameters:
        permission - A value from the Permission class
        Returns:
        TRUE if the user has the permission, FALSE otherwise
      • getId

        public final int getId()
        Description copied from interface: Identifiable
        Get the id for the item. If it hasn't yet been saved to the database 0 is returned.
        Specified by:
        getId in interface Identifiable
        Returns:
        The id of the item or 0
      • getVersion

        public final int getVersion()
        Description copied from interface: Identifiable
        Get the version number of the item. The version number is incremented each time the item is updated and is used to prevent that the same item is updated at the same time by two or more different threads or processes.
        Specified by:
        getVersion in interface Identifiable
      • equals

        public final boolean equals​(Object o)
        Check if this item is equal to another item. They are considered to be equal if their BasicData objects are equal.
        Overrides:
        equals in class Object
        See Also:
        BasicData.equals(Object)
      • hashCode

        public final int hashCode()
        The hash code is calculated at object construction and remains the same during the objects lifetime. For new items the hash code is randomly generated. Items loaded from the database calculates the hash code from the from the id.
        Overrides:
        hashCode in class Object
        See Also:
        BasicData.hashCode()
      • isInDatabase

        public final boolean isInDatabase()
        Checks if the item has been saved to the database or not.
        Returns:
        TRUE if the item is saved to the database, FALSE otherwise
      • isUsed

        public boolean isUsed()
                       throws BaseException
        Check if this item is used by some other item. With used we mean that another item is linking to this item in way that prevents this item from beeing deleted. Ie. if we tried to delete an item that is used, we would get a foreign key violation error from the database. If the subclass overrides this method it should propagate the call to the superclass, ie. super.isUsed(), unless it has decided that the item is used by some other means.
        Returns:
        TRUE if this item is used, FALSE otherwise
        Throws:
        BaseException - If not able to tell if item is used or not.
        See Also:
        getUsingItems()
      • getUsingItems

        public Set<ItemProxy> getUsingItems()
                                     throws BaseException
        Get all items that are using this item. This method must be implemented in a way that is consistent with the isUsed() method. Ie. a subclass must override both or none of these methods. The method must return a set with proxies for all items (even if the logged in user doesn't have read permission for all of them). With the proxy it is possible to get the ID and type of the item. To get full access to the item the logged in user must of course have read permission to it.
        Returns:
        A set containing proxies for the items, or an empty set if no items are using this item
        Throws:
        BaseException - If there is an error loading the items
        Since:
        2.2
        See Also:
        addUsingItems(Set, Item, org.hibernate.query.Query)
      • breakCircularReferences

        int breakCircularReferences​(Set<ItemProxy> items)
        Break references to items that may lead to circular references. This method is intended to be implemented by subclasses and should only break references leading to items that are found in the given set of items. This method is called from the Trashcan which has already confirmed that the given items are about to be deleted and may have circular references between them. NOTE! This method should not check AnyToAny links. This has already been done in the trashcan code.
        Since:
        3.8
      • checkBatchAnnotatableUsage

        void checkBatchAnnotatableUsage​(boolean annotationSet,
                                        boolean batcher)
        Annotatable items that are used with the AnnotationBatcher must not call Annotatable.getAnnotationSet() in the same transaction. This method is a helper method for keeping track of which method that has been called.
        Parameters:
        annotationSet - TRUE when called from the getAnnotationSet method
        batcher - TRUE when called from the batcher
        Since:
        3.8
      • addUsingItems

        protected void addUsingItems​(Set<ItemProxy> using,
                                     Item itemType,
                                     Query<Integer> query)
        Add items to the set of items using this one.
        Parameters:
        using - The set to add to
        itemType - The type of items to add
        query - A Hibernate query that returns the ID of items that are using this one
        Since:
        2.2
      • addUsingItems

        protected void addUsingItems​(Set<ItemProxy> using,
                                     Query<? extends BasicData> query)
        Add items to the set of items using this one.
        Parameters:
        using - The set to add to
        query - A Hibernate query that returns BasicData objects
        Since:
        2.2
      • addAnnotatableParents

        protected void addAnnotatableParents​(DbControl dc,
                                             Set<Annotatable> parents,
                                             AnnotatableData... items)
        Try to load the the item-class representation of all the data-class items ignoring permission problems. The loaded items are added to the 'parents' set. Typically used by Annotatable.getAnnotatableParents() implementations to load all annotatable parent items.
        Since:
        3.7
      • getData

        abstract BasicData getData()
        Get the BasicData object that holds all data for this item.
      • getBasicData

        final BasicData getBasicData()
      • setDbControl

        final void setDbControl​(DbControl dbControl)
        Set the DbControl object that should manage this item. A null value detaches the item
      • initPermissions

        void initPermissions​(int granted,
                             int denied)
                      throws BaseException
        Initialise the logged in user's permissions for this item. For items loaded from the database, the default implementation checks the role keys. For new items, write permission is added.

        Subclasses that needs to check other keys or properties, such as the OwnedItem and SharedItem should override this method. The subclass should calculate additional permissions to be granted or denied, and combine those with whatever was passed as parameters. Use the binary OR operator ( | ) to combine the permissions. Finally the subclass must call super.initPermissions(granted, denied).

        Parameters:
        granted - Permissions that have been granted by the subclass
        denied - Permissions that have been denied by the subclass
        Throws:
        BaseException - If the permissions couldn't be initialised
      • setProjectDefaults

        void setProjectDefaults​(Project activeProject)
                         throws BaseException
        This method is called before inserting new items into the database to allow items to propagate default values from the active project. This method is only called when a project is active.

        Implementation note! Subclasses should only set default values for properties that hasn't been set explicitly by client code, also accounting for setAbc(null) calls.

        Parameters:
        activeProject - The currently active project
        Throws:
        BaseException
        Since:
        2.9