DatabookStore (gCube Social Networking Library 1.10.0-3.10.1 API)
Date: 2016-04-09

org.gcube.portal.databook.server

## Interface DatabookStore

- All Known Implementing Classes:
    DBCassandraAstyanaxImpl

      public interface DatabookStore

  Author:
    Massimiliano Assante ISTI-CNR DatabookStore is the high level interface for querying and adding data to DatabookStore

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `addComment(Comment comment)` add a comment to a feed
    `boolean` | `approveFriendship(String from, String to)` userid from approves a friendship to userid to
    `boolean` | `checkUnreadMessagesNotifications(String userid)`
    `boolean` | `checkUnreadNotifications(String userid)`
    `void` | `closeConnection()` close the connection to the underlying database
    `boolean` | `deleteComment(String commentid, String feedid)` delete a comment
    `boolean` | `deleteFeed(String feedid)` delete a Feed from the store
    `boolean` | `deleteHashTags(String feedid, String vreid, List<String> hashtags)`
    `boolean` | `denyFriendship(String from, String to)` userid from denies a friendship to userid to
    `boolean` | `editComment(Comment comment)` edit a comment
    `List<Comment>` | `getAllCommentByFeed(String feedid)`
    `List<Feed>` | `getAllFeedsByApp(String appid)`
    `List<Feed>` | `getAllFeedsByUser(String userid)`
    `List<Feed>` | `getAllFeedsByVRE(String vreid)`
    `List<String>` | `getAllLikedFeedIdsByUser(String userid)`
    `List<Feed>` | `getAllLikedFeedsByUser(String userid, int limit)`
    `List<Like>` | `getAllLikesByFeed(String feedid)`
    `List<Notification>` | `getAllNotificationByUser(String userid, int limit)`
    `List<Feed>` | `getAllPortalPrivacyLevelFeeds()` return all the feeds whose Level is PORTAL
    `List<Attachment>` | `getAttachmentsByFeedId(String feedId)`
    `List<String>` | `getFriends(String userid)`
    `List<Invite>` | `getInvitedEmailsByVRE(String vreid, InviteStatus... status)` Use to get the list of invites per VRE
    `List<String>` | `getPendingFriendRequests(String userid)`
    `List<Notification>` | `getRangeNotificationsByUser(String userid, int from, int quantity)`
    `List<Feed>` | `getRecentFeedsByUser(String userid, int quantity)` return the most recent feeds for this user up to quantity param
    `List<Feed>` | `getRecentFeedsByUserAndDate(String userid, long timeInMillis)`
    `List<Feed>` | `getRecentFeedsByVRE(String vreid, int quantity)` return the most recent feeds for this vre up to quantity param
    `RangeFeeds` | `getRecentFeedsByVREAndRange(String vreid, int from, int quantity)` return the most recent feeds for this vre up to quantity param and the last index of the feeds in the timeline lastReturnedFeedTimelineIndex is usuful to know from where to start the range the second time you ask because there are deletions
    `List<Notification>` | `getUnreadNotificationMessagesByUser(String userid)` return the not yet read notification messages
    `List<Notification>` | `getUnreadNotificationsByUser(String userid)` return the not yet read notifications (not including messages)
    `List<NotificationChannelType>` | `getUserNotificationChannels(String userid, NotificationType notificationType)` return the channels a user chose for being notified for a given notification type
    `Map<NotificationType,NotificationChannelType[]>` | `getUserNotificationPreferences(String userid)` get the notification preferences map (enableor disable the channels to be used for notifying the user)
    `List<Feed>` | `getVREFeedsByHashtag(String vreid, String hashtag)`
    `Map<String,Integer>` | `getVREHashtagsWithOccurrence(String vreid)` get a map of vre hashtags where the key is the hashtag and the value is the occurrence of the hashtag in the VRE
    `String` | `isExistingInvite(String vreid, String email)`
    `boolean` | `like(Like like)` add a like to a feed
    `Feed` | `readFeed(String feedid)` read a feed from a given id
    `Invite` | `readInvite(String inviteid)` read an invite from a given id
    `Notification` | `readNotification(String notificationid)` read a notification from a given id
    `boolean` | `requestFriendship(String from, String to)` userid from requests a friendship to userid to
    `boolean` | `saveAppFeed(Feed feed)` save a Post instance in the store
    `boolean` | `saveAppFeed(Feed feed, List<Attachment> attachments)` Save a feed instance in the store Use this if your app needs to attach more than one file to the post
    `boolean` | `saveFeedToVRETimeline(String feedKey, String vreid)` save a post in the VRES TimeLine in the store
    `boolean` | `saveHashTags(String feedid, String vreid, List<String> hashtags)`
    `InviteOperationResult` | `saveInvite(Invite invite)` Save the invite for a given email into a given vre
    `boolean` | `saveNotification(Notification notification)` save a Notification instance in the store
    `boolean` | `saveUserFeed(Feed feed)` save a Feed instance in the store
    `boolean` | `saveUserFeed(Feed feed, List<Attachment> attachments)` Save a Feed instance in the store having more than one attachment Use this if you need to attach more than one file to the post
    `boolean` | `setAllNotificationReadByUser(String userid)` This is a fast way to set all notification to read quickly
    `boolean` | `setInviteStatus(String vreid, String email, InviteStatus status)` set the status of an invite, see `InviteStatus`
    `boolean` | `setNotificationRead(String notificationidToSet)` set an existing Notification instance in the to read
    `boolean` | `setUserNotificationPreferences(String userid, Map<NotificationType,NotificationChannelType[]> enabledChannels)` set the notification preferences map (enable or disable the channels to be used for notifying the user)
    `boolean` | `unlike(String userid, String likeid, String feedid)` unlike a feed

- - ### Method Detail

    - #### requestFriendship

          boolean requestFriendship(String from,
                                  String to)

      userid from requests a friendship to userid to
      Returns:
        true if everything went fine

    - #### approveFriendship

          boolean approveFriendship(String from,
                                  String to)

      userid from approves a friendship to userid to
      Returns:
        true if everything went fine

    - #### denyFriendship

          boolean denyFriendship(String from,
                               String to)

      userid from denies a friendship to userid to
      Returns:
        true if everything went fine

    - #### getFriends

          List<String> getFriends(String userid)

      Parameters:
        `userid` - the user id you want to know friends
      Returns:
        a List of userid representing the friends for the given userid

    - #### getPendingFriendRequests

          List<String> getPendingFriendRequests(String userid)

      Parameters:
        `userid` - the user id you want to know the pending friend requests
      Returns:
        a List of userid representing the friends for the given userid

    - #### saveUserFeed

          boolean saveUserFeed(Feed feed)

      save a Feed instance in the store
      Returns:
        true if everything went fine

    - #### saveUserFeed

          boolean saveUserFeed(Feed feed,
                             List<Attachment> attachments)

      Save a Feed instance in the store having more than one attachment Use this if you need to attach more than one file to the post
      Parameters:
        `attachments,` - a list of attachments starting from the second
      Returns:
        true if everything went fine

    - #### deleteFeed

          boolean deleteFeed(String feedid)
                             throws FeedIDNotFoundException,
                                    PrivacyLevelTypeNotFoundException,
                                    FeedTypeNotFoundException,
                                    ColumnNameNotFoundException

      delete a Feed from the store
      Returns:
        true if everything went fine
      Throws:
        `FeedIDNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `FeedTypeNotFoundException`
        `ColumnNameNotFoundException`

    - #### saveFeedToVRETimeline

          boolean saveFeedToVRETimeline(String feedKey,
                                      String vreid)
                                        throws FeedIDNotFoundException

      save a post in the VRES TimeLine in the store
      Parameters:
        `feedKey` - feedKey
        `vreid` - vre identifier
      Returns:
      Throws:
        `FeedIDNotFoundException`

    - #### saveAppFeed

          boolean saveAppFeed(Feed feed)

      save a Post instance in the store
      Returns:
        true if everything went fine

    - #### saveAppFeed

          boolean saveAppFeed(Feed feed,
                            List<Attachment> attachments)

      Save a feed instance in the store Use this if your app needs to attach more than one file to the post
      Parameters:
        `attachments,` - a list of attachments starting from the second
      Returns:
        true if everything went fine

    - #### readFeed

          Feed readFeed(String feedid)
                        throws PrivacyLevelTypeNotFoundException,
                               FeedTypeNotFoundException,
                               FeedIDNotFoundException,
                               ColumnNameNotFoundException

      read a feed from a given id
      Throws:
        `PrivacyLevelTypeNotFoundException`
        `FeedTypeNotFoundException`
        `ColumnNameNotFoundException`
        `FeedIDNotFoundException`

    - #### getAllFeedsByUser

          List<Feed> getAllFeedsByUser(String userid)
                                       throws PrivacyLevelTypeNotFoundException,
                                              FeedTypeNotFoundException,
                                              FeedIDNotFoundException,
                                              ColumnNameNotFoundException

      Parameters:
        `userid` - user identifier return all the feeds belonging to the userid
      Throws:
        `FeedTypeNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `FeedIDNotFoundException`

    - #### getAllFeedsByApp

          List<Feed> getAllFeedsByApp(String appid)
                                      throws PrivacyLevelTypeNotFoundException,
                                             FeedTypeNotFoundException,
                                             FeedIDNotFoundException,
                                             ColumnNameNotFoundException

      Parameters:
        `appid` - application identifier return all the feeds belonging to the appid
      Throws:
        `FeedTypeNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `FeedIDNotFoundException`

    - #### getAllPortalPrivacyLevelFeeds

          List<Feed> getAllPortalPrivacyLevelFeeds()
                                                   throws FeedTypeNotFoundException,
                                                          ColumnNameNotFoundException,
                                                          PrivacyLevelTypeNotFoundException

      return all the feeds whose Level is PORTAL
      Throws:
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `FeedTypeNotFoundException`

    - #### getRecentFeedsByUser

          List<Feed> getRecentFeedsByUser(String userid,
                                        int quantity)
                                          throws PrivacyLevelTypeNotFoundException,
                                                 FeedTypeNotFoundException,
                                                 ColumnNameNotFoundException,
                                                 FeedIDNotFoundException

      return the most recent feeds for this user up to quantity param
      Parameters:
        `userid` - user identifier
        `quantity` - the number of most recent feeds for this user
      Returns:
        a List of most recent feeds for this user
      Throws:
        `FeedTypeNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `FeedIDNotFoundException`

    - #### getAllFeedsByVRE

          List<Feed> getAllFeedsByVRE(String vreid)
                                      throws PrivacyLevelTypeNotFoundException,
                                             FeedTypeNotFoundException,
                                             ColumnNameNotFoundException,
                                             FeedIDNotFoundException

      Parameters:
        `vreid` - vre identifier return all the feeds belonging to the userid
      Throws:
        `FeedTypeNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `FeedIDNotFoundException`

    - #### getRecentFeedsByVRE

          List<Feed> getRecentFeedsByVRE(String vreid,
                                       int quantity)
                                         throws IllegalArgumentException,
                                                PrivacyLevelTypeNotFoundException,
                                                FeedTypeNotFoundException,
                                                ColumnNameNotFoundException,
                                                FeedIDNotFoundException

      return the most recent feeds for this vre up to quantity param
      Parameters:
        `vreid` - VRES identifier
        `quantity` - the number of most recent feeds for this vre
      Returns:
        a List of most recent feeds for this vre
      Throws:
        `FeedTypeNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `IllegalArgumentException`
        `FeedIDNotFoundException`

    - #### getRecentFeedsByVREAndRange

          RangeFeeds getRecentFeedsByVREAndRange(String vreid,
                                               int from,
                                               int quantity)
                                                 throws PrivacyLevelTypeNotFoundException,
                                                        FeedTypeNotFoundException,
                                                        ColumnNameNotFoundException,
                                                        FeedIDNotFoundException

      return the most recent feeds for this vre up to quantity param and the last index of the feeds in the timeline lastReturnedFeedTimelineIndex is usuful to know from where to start the range the second time you ask because there are deletions
      Parameters:
        `vreid` - VRES identifier
        `from` - the range start (most recent feeds for this vre) has to be greater than 0
        `quantity` - the number of most recent feeds for this vre starting from "from" param
      Returns:
        a lastReturnedFeedTimelineIndex containing of most recent feeds for this vre
      Throws:
        `FeedTypeNotFoundException`
        `PrivacyLevelTypeNotFoundException`
        `ColumnNameNotFoundException`
        `FeedIDNotFoundException`

    - #### getRecentFeedsByUserAndDate

          List<Feed> getRecentFeedsByUserAndDate(String userid,
                                               long timeInMillis)
                                                 throws IllegalArgumentException

      Parameters:
        `userid` - user identifier
        `timeInMillis` - time in milliseconds from which you want to start retrieve the feeds
      Returns:
        the number of feeds in the range from: today to: timeInMillis
      Throws:
        `IllegalArgumentException`

    - #### saveNotification

          boolean saveNotification(Notification notification)

      save a Notification instance in the store
      Returns:
        true if everything went fine

    - #### setNotificationRead

          boolean setNotificationRead(String notificationidToSet)
                                      throws NotificationIDNotFoundException,
                                             NotificationTypeNotFoundException,
                                             ColumnNameNotFoundException

      set an existing Notification instance in the to read
      Returns:
        true if everything went fine
      Throws:
        `NotificationIDNotFoundException`
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`

    - #### readNotification

          Notification readNotification(String notificationid)
                                        throws NotificationIDNotFoundException,
                                               NotificationTypeNotFoundException,
                                               ColumnNameNotFoundException

      read a notification from a given id
      Throws:
        `{@link` - ColumnNameNotFoundException}
        `{@link` - NotificationIDNotFoundException}
        `{@link` - NotificationTypeNotFoundException}
        `NotificationIDNotFoundException`
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`

    - #### getAllNotificationByUser

          List<Notification> getAllNotificationByUser(String userid,
                                                    int limit)
                                                      throws NotificationTypeNotFoundException,
                                                             ColumnNameNotFoundException,
                                                             NotificationIDNotFoundException

      Parameters:
        `userid` - user identifier
        `limit` - set 0 to get everything, an int to get the most recent -limit- notifications return all the notifications belonging to the userid up to limit, set 0 to get everything
      Throws:
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`
        `NotificationIDNotFoundException`

    - #### getRangeNotificationsByUser

          List<Notification> getRangeNotificationsByUser(String userid,
                                                       int from,
                                                       int quantity)
                                                         throws NotificationTypeNotFoundException,
                                                                ColumnNameNotFoundException,
                                                                NotificationIDNotFoundException

      Parameters:
        `userid` - user identifier
        `from` - the range start has to be greater than 0
        `quantity` - the number of most recent notifications for this user starting from "from" param
      Returns:
        all the notifications for the userid in the range requested
      Throws:
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`
        `NotificationIDNotFoundException`

    - #### setAllNotificationReadByUser

          boolean setAllNotificationReadByUser(String userid)
                                               throws NotificationIDNotFoundException,
                                                      NotificationTypeNotFoundException,
                                                      ColumnNameNotFoundException

      This is a fast way to set all notification to read quickly
      Parameters:
        `userid` -
      Returns:
        true if everything went fine
      Throws:
        `{@link` - ColumnNameNotFoundException}
        `{@link` - NotificationIDNotFoundException}
        `{@link` - NotificationTypeNotFoundException}
        `NotificationIDNotFoundException`
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`

    - #### getUnreadNotificationsByUser

          List<Notification> getUnreadNotificationsByUser(String userid)
                                                          throws NotificationTypeNotFoundException,
                                                                 ColumnNameNotFoundException,
                                                                 NotificationIDNotFoundException

      return the not yet read notifications (not including messages)
      Parameters:
        `userid` - user identifier
      Returns:
        a List of not yet read notifications for this user
      Throws:
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`
        `NotificationIDNotFoundException`

    - #### getUnreadNotificationMessagesByUser

          List<Notification> getUnreadNotificationMessagesByUser(String userid)
                                                                 throws NotificationTypeNotFoundException,
                                                                        ColumnNameNotFoundException,
                                                                        NotificationIDNotFoundException

      return the not yet read notification messages
      Parameters:
        `userid` - user identifier
      Returns:
        a List of not yet read notifications for this user
      Throws:
        `NotificationTypeNotFoundException`
        `ColumnNameNotFoundException`
        `NotificationIDNotFoundException`

    - #### checkUnreadNotifications

          boolean checkUnreadNotifications(String userid)
                                           throws NotificationIDNotFoundException,
                                                  NotificationTypeNotFoundException,
                                                  ColumnNameNotFoundException

      Parameters:
        `userid` - user identifier
      Returns:
        true if there are unread notifications (not including messages), false if they are all read
      Throws:
        `ColumnNameNotFoundException`
        `NotificationTypeNotFoundException`
        `NotificationIDNotFoundException`

    - #### checkUnreadMessagesNotifications

          boolean checkUnreadMessagesNotifications(String userid)
                                                   throws NotificationIDNotFoundException,
                                                          NotificationTypeNotFoundException,
                                                          ColumnNameNotFoundException

      Parameters:
        `userid` - user identifier
      Returns:
        true if there are unread messages notifications (including messages), false if they are all read
      Throws:
        `ColumnNameNotFoundException`
        `NotificationTypeNotFoundException` - self explaining
        `NotificationChannelTypeNotFoundException` - self explaining
        `NotificationIDNotFoundException`

    - #### getUserNotificationChannels

          List<NotificationChannelType> getUserNotificationChannels(String userid,
                                                                  NotificationType notificationType)
                                                                    throws NotificationChannelTypeNotFoundException,
                                                                           NotificationTypeNotFoundException

      return the channels a user chose for being notified for a given notification type
      Parameters:
        `userid` - user identifier
        `notificationType` - the type of the notification
      Returns:
        a list of NotificationChannelType that represents the channels this user wants to be notified
      Throws:
        `NotificationChannelTypeNotFoundException`
        `NotificationTypeNotFoundException`

    - #### setUserNotificationPreferences

          boolean setUserNotificationPreferences(String userid,
                                               Map<NotificationType,NotificationChannelType[]> enabledChannels)

      set the notification preferences map (enable or disable the channels to be used for notifying the user)
      Parameters:
        `userid` - user identifier
        `notificationType` - the type of the notification
        `enabledChannels` - a map of the channels to which reach the user per notification, empty array or null values to set the key notification type off
      Returns:
        true if everything was fine

    - #### getUserNotificationPreferences

          Map<NotificationType,NotificationChannelType[]> getUserNotificationPreferences(String userid)
                                                                                         throws NotificationTypeNotFoundException,
                                                                                                NotificationChannelTypeNotFoundException

      get the notification preferences map (enableor disable the channels to be used for notifying the user)
      Parameters:
        `userid` - user identifier
      Returns:
        the map
      Throws:
        `NotificationTypeNotFoundException` - self explaining
        `NotificationChannelTypeNotFoundException` - self explaining

    - #### addComment

          boolean addComment(Comment comment)
                             throws FeedIDNotFoundException

      add a comment to a feed
      Parameters:
        `comment` - the Comment instance to add
      Throws:
        `FeedIDNotFoundException`

    - #### getAllCommentByFeed

          List<Comment> getAllCommentByFeed(String feedid)

      Parameters:
        `feedid` - feed identifier return all the comments belonging to the feedid

    - #### editComment

          boolean editComment(Comment comment)
                              throws PrivacyLevelTypeNotFoundException,
                                     FeedTypeNotFoundException,
                                     ColumnNameNotFoundException,
                                     CommentIDNotFoundException,
                                     FeedIDNotFoundException

      edit a comment
      Parameters:
        `commentid` - the comment identifier to edit
      Returns:
        true if success, false otherwise
      Throws:
        `PrivacyLevelTypeNotFoundException`
        `FeedTypeNotFoundException`
        `ColumnNameNotFoundException`
        `CommentIDNotFoundException`
        `FeedIDNotFoundException`

    - #### deleteComment

          boolean deleteComment(String commentid,
                              String feedid)
                                throws PrivacyLevelTypeNotFoundException,
                                       FeedTypeNotFoundException,
                                       ColumnNameNotFoundException,
                                       CommentIDNotFoundException,
                                       FeedIDNotFoundException

      delete a comment
      Parameters:
        `commentid` - the comment identifier to delete
      Returns:
        true if success, false otherwise
      Throws:
        `PrivacyLevelTypeNotFoundException`
        `FeedTypeNotFoundException`
        `ColumnNameNotFoundException`
        `CommentIDNotFoundException`
        `FeedIDNotFoundException`

    - #### like

          boolean like(Like like)
                       throws FeedIDNotFoundException

      add a like to a feed
      Parameters:
        `the` - like instance
      Throws:
        `FeedIDNotFoundException`

    - #### unlike

          boolean unlike(String userid,
                       String likeid,
                       String feedid)
                         throws PrivacyLevelTypeNotFoundException,
                                FeedTypeNotFoundException,
                                ColumnNameNotFoundException,
                                LikeIDNotFoundException,
                                FeedIDNotFoundException

      unlike a feed
      Parameters:
        `userid` - user identifier
        `likeid` - the like identifier to delete
        `feedid` - the feedid to which the comment is associated
      Returns:
        true if success, false otherwise
      Throws:
        `PrivacyLevelTypeNotFoundException`
        `FeedTypeNotFoundException`
        `ColumnNameNotFoundException`
        `LikeIDNotFoundException`
        `FeedIDNotFoundException`

    - #### getAllLikedFeedIdsByUser

          List<String> getAllLikedFeedIdsByUser(String userid)

      Parameters:
        `userid` - user identifier return all the feedids a user has liked

    - #### getAllLikedFeedsByUser

          List<Feed> getAllLikedFeedsByUser(String userid,
                                          int limit)
                                            throws PrivacyLevelTypeNotFoundException,
                                                   FeedTypeNotFoundException,
                                                   FeedIDNotFoundException,
                                                   ColumnNameNotFoundException

      Parameters:
        `userid` - user identifier
        `limit` - set 0 to get everything, an int to get the most recent -limit- liked feeds
      Throws:
        `ColumnNameNotFoundException` - .
        `FeedIDNotFoundException` - .
        `FeedTypeNotFoundException` - .
        `PrivacyLevelTypeNotFoundException`
        `FeedIDNotFoundException` - . return all the feeds a user has liked

    - #### getAllLikesByFeed

          List<Like> getAllLikesByFeed(String feedid)

      Parameters:
        `feedid` - feed identifier return all the likes belonging to the feedid

    - #### saveHashTags

          boolean saveHashTags(String feedid,
                             String vreid,
                             List<String> hashtags)
                               throws FeedIDNotFoundException

      Parameters:
        `hashtags` - the hashtag including the '#'
        `feedid` - the feedid to which the hashtag is associated
        `vreid` - VRE identifier
      Returns:
        true if success, false otherwise
      Throws:
        `FeedIDNotFoundException`

    - #### deleteHashTags

          boolean deleteHashTags(String feedid,
                               String vreid,
                               List<String> hashtags)
                                 throws FeedIDNotFoundException

      Parameters:
        `hashtags` - the hashtag including the '#'
        `feedid` - the feedid to which the hashtag is associated
        `vreid` - VRE identifier
      Returns:
        true if success, false otherwise
      Throws:
        `FeedIDNotFoundException`

    - #### getVREHashtagsWithOccurrence

          Map<String,Integer> getVREHashtagsWithOccurrence(String vreid)

      get a map of vre hashtags where the key is the hashtag and the value is the occurrence of the hashtag in the VRE
      Parameters:
        `vreid` - vre identifier (scope)
      Returns:
        a HashMap of vre Hashtags associated with their occurrence

    - #### getVREFeedsByHashtag

          List<Feed> getVREFeedsByHashtag(String vreid,
                                        String hashtag)
                                          throws PrivacyLevelTypeNotFoundException,
                                                 FeedTypeNotFoundException,
                                                 FeedIDNotFoundException,
                                                 ColumnNameNotFoundException

      Parameters:
        `vreid` - VRE identifier
        `hashtag` - the hashtag to look for including the '#', it is case sensitive
      Returns:
        all the feeds having the hashtag passed as parameter
      Throws:
        `ColumnNameNotFoundException` - .
        `FeedIDNotFoundException` - .
        `FeedTypeNotFoundException` - .
        `PrivacyLevelTypeNotFoundException`
        `FeedIDNotFoundException` - .

    - #### saveInvite

          InviteOperationResult saveInvite(Invite invite)
                                           throws javax.mail.internet.AddressException

      Save the invite for a given email into a given vre
      Parameters:
        `invite` - the invite object instanc to save
      Returns:
        `InviteOperationResult` SUCCESS, FAILED or ALREADY_INVITED (if an invite is sent to en existing email in the same environment more than once)
      Throws:
        `javax.mail.internet.AddressException`

    - #### isExistingInvite

          String isExistingInvite(String vreid,
                                String email)

      Parameters:
        `vreid` - the environment where you want to check the invite
        `email` - the email of the invite to check in the environmnet
      Returns:
        the InviteId if present, null otherwise

    - #### readInvite

          Invite readInvite(String inviteid)
                            throws InviteIDNotFoundException,
                                   InviteStatusNotFoundException

      read an invite from a given id
      Throws:
        `InviteIDNotFoundException`
        `InviteStatusNotFoundException`

    - #### setInviteStatus

          boolean setInviteStatus(String vreid,
                                String email,
                                InviteStatus status)
                                  throws InviteIDNotFoundException,
                                         InviteStatusNotFoundException

      set the status of an invite, see `InviteStatus`
      Throws:
        `InviteIDNotFoundException`
        `InviteStatusNotFoundException`

    - #### getInvitedEmailsByVRE

          List<Invite> getInvitedEmailsByVRE(String vreid,
                                           InviteStatus... status)
                                             throws InviteIDNotFoundException,
                                                    InviteStatusNotFoundException

      Use to get the list of invites per VRE
      Parameters:
        `vreid` - the vre id
        `status` - optional, if you want to restict on the status, e.g. all pending invites
      Returns:
        return the list of invites
      Throws:
        `InviteIDNotFoundException`
        `InviteStatusNotFoundException`

    - #### getAttachmentsByFeedId

          List<Attachment> getAttachmentsByFeedId(String feedId)
                                                  throws FeedIDNotFoundException

      Parameters:
        `feedId` -
      Returns:
        the list of attachments of the feed feedId, starting from the second one (first attachment is included in Feed instance already)
      Throws:
        `FeedIDNotFoundException`

    - #### closeConnection

          void closeConnection()

      close the connection to the underlying database

Copyright © 2016. All Rights Reserved.