Package org.exoplatform.agenda.service

Interface AgendaEventService

public interface AgendaEventService

  • Field Details

    • CALENDAR_EDITED_BY_SHAREE_EVENT

      static final String CALENDAR_EDITED_BY_SHAREE_EVENT
      Broadcast once a colleague holding an edit share on a personal calendar (EXO-90378) — and holding no older right over the event — added, changed or removed one of its events; source the CalendarEditorChange, data the calendar owner's identity identifier.

      Raised by the event service alone, which is the one place that knows by what right a writer wrote. The owner is told about the one case they cannot otherwise see coming; a change of their own, of a space manager, of the event's creator or of an attendee allowed to update raises nothing.

      See Also:

  • Method Details

    • getEvents

      List<Event> getEvents(EventFilter eventFilter, ZoneId userTimeZone, long userIdentityId) throws IllegalAccessException
      Retrieves the list of events available for a designated user filtered by criteria defined in a filter.

      The filter's calendarIds (EventFilter) name the calendars other users shared with the reader (EXO-90357): each is checked against the reader — accessible, or shared with them — and the whole request is refused otherwise. A private event of a shared calendar comes back masked (Event.isMasked()).

      Parameters:
      eventFilter - a filter used to define criteria to get list of objects
      userTimeZone - User time zone
      userIdentityId - user Identity identifier
      Returns:
      List of Event accessible to user
      Throws:
      IllegalAccessException - when user is not allowed to access events, or names a calendar in calendarIds they may not read

    • getParentRecurrentEvents

      List<Event> getParentRecurrentEvents(ZonedDateTime start, ZonedDateTime end, ZoneId timeZone)
      Retrieve parent recurrent events switch event filter.
      Parameters:
      start - start of period of events to retrieve
      end - end of period of events to retrieve
      timeZone - used time zone to compute dates
      Returns:
      List of Event

    • getEventById

      Event getEventById(long eventId, ZoneId timeZone, long identityId) throws IllegalAccessException
      Retrieves an event identified by its technical identifier.
      Parameters:
      eventId - technical identifier of event
      timeZone - used timezone to convert dates
      identityId - Identity technical identifier
      Returns:
      Corresponding Event or null if not found
      Throws:
      IllegalAccessException - when user is not allowed to access event

    • getEventById

      Event getEventById(long eventId)
      Retrieves an event identified by its technical identifier.
      Parameters:
      eventId - technical identifier of event
      Returns:
      Corresponding Event or null if not found

    • getEventOccurrence

      Event getEventOccurrence(long parentEventId, ZonedDateTime occurrenceId, ZoneId userTimeZone, long identityId) throws IllegalAccessException
      Retrieves Event Occurrence identified by parent recurrence Event identifier and occurrence date
      Parameters:
      parentEventId - Event technical identifier
      occurrenceId - Date of occurrence
      userTimeZone - used user timezone
      identityId - user Identity identifier requesting event
      Returns:
      Event representing occurrence of parent recurrent event
      Throws:
      IllegalAccessException - when the user can't access the event served (see canAccessEvent(Event, long)): a stored exceptional occurrence is checked through its own row, as an event of its own; a computed occurrence through its parent

    • getExceptionalOccurrenceEvents

      List<Event> getExceptionalOccurrenceEvents(long eventId, ZoneId timeZone, long userIdentityId) throws IllegalAccessException
      Retrieves the list of exceptional occurrences of an event identified by its technical identifier.
      Parameters:
      eventId - technical identifier of parent recurrent event
      timeZone - used timezone to compute events
      userIdentityId -
      Returns:
      list of Exceptional Events if found, else null
      Throws:
      IllegalAccessException - when user is not allowed to access event

    • moveExceptionalOccurrences

      List<Long> moveExceptionalOccurrences(long fromEventId, long toEventId, ZonedDateTime fromDate, long userIdentityId) throws IllegalAccessException, AgendaException
      Moves the exceptional occurrences of a recurring event dated from a given day on under another recurring event: the second half of a "this and upcoming" split, whose continuing series is created first so that the dates the organiser had customised from the split point on survive the shortening of the first series instead of being dropped with their answers. Each moved row is then merged into its new series as a date individually modified is merged into a series change: what was customised on the date is kept, what was not follows the new series, and a day the new series does not produce is dropped, as a series change drops it. A row the new series already holds for a date a kept row moved to — the reminder computing listener materialises the next days of a series on its creation — is deleted when it carries nothing of its own against the new series, so that a date keeps one row.
      Parameters:
      fromEventId - the recurring event the rows belong to
      toEventId - the recurring event they move under, in the same calendar
      fromDate - the occurrence the split starts from, inclusive, compared as occurrences are, within twelve hours
      userIdentityId - who is splitting; must be allowed to update both events
      Returns:
      the identifiers of the rows moved and kept by the merge
      Throws:
      IllegalAccessException - when the user may not update one of the two events
      AgendaException - when one of the two events does not exist
      IllegalArgumentException - when the two events are one, when one of them is not a recurring series or when they live in different calendars; the message is the code agenda.seriesSplit.notAllowed

    • getExceptionalOccurrenceEvent

      Event getExceptionalOccurrenceEvent(long eventId, ZonedDateTime occurrenceId)
      Retrieves an event identified by its technical identifier.
      Parameters:
      eventId - technical identifier of parent recurrent event
      occurrenceId - technical occurrence event identifier
      Returns:
      Exceptional Event if found, else null

    • createEventExceptionalOccurrence

      Event createEventExceptionalOccurrence(long eventId, List<EventAttendee> attendees, List<EventConference> conferences, List<EventReminder> reminders, ZonedDateTime occurrenceId) throws AgendaException
      Create a new exceptional occurrence for a parent recurrent event
      Parameters:
      eventId - technical identifier of parent recurrent event
      attendees - List of attendees
      conferences - List of conferences
      reminders - List of reminders
      occurrenceId - event occurent identifier
      Returns:
      newly created Event
      Throws:
      AgendaException - when the event attributes aren't valid

    • saveEventExceptionalOccurrence

      Event saveEventExceptionalOccurrence(long eventId, ZonedDateTime occurrenceId) throws AgendaException
      Creates an exceptional occurrence for a recurrent event and occurrence ID
      Parameters:
      eventId - parent recurrent event identifier
      occurrenceId - Occurrence identifier
      Returns:
      created Event
      Throws:
      AgendaException - when an error occurs hile creating event

    • createEvent

      Event createEvent(Event event, List<EventAttendee> attendees, List<EventConference> conferences, List<EventReminder> reminders, List<EventDateOption> dateOptions, RemoteEvent remoteEvent, boolean sendInvitation, long userIdentityId) throws IllegalAccessException, AgendaException
      Creates an event in designated calendar or in user personal calendar if null
      Parameters:
      event - Event to create
      attendees - event attendees of type EventAttendee
      conferences - event conferences of type EventConference
      reminders - List of preferred user reminders of type EventReminder
      dateOptions - List of EventDateOption of corresponding event
      remoteEvent - RemoteEvent of synchronized event by user to remote connector
      sendInvitation - whether send invitation to attendees or not
      userIdentityId - user Identity identifier
      Returns:
      Created Event with technichal identifier
      Throws:
      IllegalAccessException - when user is not allowed to create event on calendar, or creates an exceptional occurrence of a recurring event (a parent) that they aren't allowed to update
      AgendaException - when the event attributes aren't valid, or when the parent event isn't found

    • updateEvent

      Event updateEvent(Event event, List<EventAttendee> attendees, List<EventConference> conferences, List<EventReminder> reminders, List<EventDateOption> dateOptions, RemoteEvent remoteEvent, boolean sendInvitation, long userIdentityId) throws IllegalAccessException, org.exoplatform.commons.exception.ObjectNotFoundException, AgendaException
      Updates an existing event in-place when the user is owner of parent Calendar, else this will duplicate the event and add it into his personal calendar
      Parameters:
      event - Event to create
      attendees - event attendees of type EventAttendee
      conferences - event conferences of type EventConference
      reminders - List of preferred user reminders of type EventReminder
      dateOptions - List of EventDateOption of corresponding event
      remoteEvent - RemoteEvent of synchronized event by user to remote connector
      sendInvitation - whether re-send invitation to attendees or not
      userIdentityId - user Identity identifier
      Returns:
      Updated Event
      Throws:
      IllegalAccessException - when user is not allowed to update event, or moves it to another calendar in which they can't create events
      org.exoplatform.commons.exception.ObjectNotFoundException - when the event identified by its technical identifier is not found
      AgendaException - when the event attributes aren't valid

    • updateEventFields

      void updateEventFields(long eventId, Map<String,List<String>> fields, boolean updateAllOccurrences, boolean sendInvitation, long userIdentityId) throws IllegalAccessException, org.exoplatform.commons.exception.ObjectNotFoundException, AgendaException
      Updates a single field for a given Event identified by its technical identifier. When the event is of type 'recurrent', if parameter updateAllOccurrences is set to true, it will update the event field for all exceptional occurrences as well.
      Parameters:
      eventId - Event technical identifier to update
      fields - Event fields with field name as map key and field value as map value
      updateAllOccurrences - whether apply modification on all exceptional occurrences as well or not
      sendInvitation - whether re-send invitation to attendees or not
      userIdentityId - user Identity identifier
      Throws:
      IllegalAccessException - when user is not allowed to update event, or moves it to another calendar in which they can't create events
      org.exoplatform.commons.exception.ObjectNotFoundException - when the event identified by its technical identifier is not found
      AgendaException - when the event attribute isn't valid

    • deleteEventById

      Event deleteEventById(long eventId, long userIdentityId) throws IllegalAccessException, org.exoplatform.commons.exception.ObjectNotFoundException
      Deletes an existing event
      Parameters:
      eventId - Event technical identifier to delete
      userIdentityId - user Identity identifier
      Returns:
      deleted Event
      Throws:
      IllegalAccessException - when user is not authorized to delete the event
      org.exoplatform.commons.exception.ObjectNotFoundException - when the event identified by its technical identifier is not found

    • canAccessEvent

      boolean canAccessEvent(Event event, long identityId)
      Check whether user can access event or not.
      Parameters:
      event - Event to check its permission
      identityId - Identity technical identifier
      Returns:
      true if the user is a member of Calendar owner Identity or is an EventAttendee, else return false.

    • getEventAccess

      EventAccess getEventAccess(Event event, long identityId)
      How a user may read an event (EXO-90357): fully, only through a calendar share — in which case a private event is rendered as busy time — or not at all. canAccessEvent(org.exoplatform.agenda.model.Event, long) is this answer being anything but EventAccess.NONE.
      Parameters:
      event - Event to check
      identityId - Identity technical identifier of the reader
      Returns:
      the access, never null

    • canUpdateEvent

      boolean canUpdateEvent(Event event, long userIdentityId)
      Check whether user can update or delete an event or not.
      Parameters:
      event - Event to check its permission
      userIdentityId - user Identity identifier
      Returns:
      true if the user is a manager of Calendar owner Identity or is an EventAttendee, else return false.

    • canCreateEvent

      boolean canCreateEvent(Calendar calendar, long userIdentityId)
      Check whether user can create an event in selected Calendar or not.
      Parameters:
      calendar - of type Calendar
      userIdentityId - user Identity identifier
      Returns:
      true if the user is a member of Calendar owner Identity, else return false.

    • search

      List<EventSearchResult> search(AgendaEventSearchFilter filter)
      Search the list of events available with query for the currentUser
      Parameters:
      filter - AgendaEventSearchFilter used to filter the events
      Returns:
      List of EventSearchResult

    • getEventOccurrencesInPeriod

      List<Event> getEventOccurrencesInPeriod(Event recurrentEvent, ZonedDateTime start, ZonedDateTime end, ZoneId timezone, int limit)
      Retrieves occurrences, without exceptional, of a recurrent event in a given period of time.
      Parameters:
      recurrentEvent - Event of type recurrence
      start - Period start date
      end - Period end date
      timezone - used timezone to compute events
      limit - maximum number of occurrences to retrieve
      Returns:
      List of Event of type Occurrence (not Exceptional occurrences)

    • selectEventDateOption

      void selectEventDateOption(long eventId, long dateOptionId, long userIdentityId) throws org.exoplatform.commons.exception.ObjectNotFoundException, IllegalAccessException
      Choose a selected EventDateOption for a given Event
      Parameters:
      eventId - technical identifier of Event
      dateOptionId - Technical identifier of EventDateOption
      userIdentityId - user Identity identifier
      Throws:
      org.exoplatform.commons.exception.ObjectNotFoundException - when Event is not found using identifier or EventDateOption is not found using technical identifier
      IllegalAccessException - when user is not an allowed participant of the event who can modifies it

    • getEventDatePolls

      List<Event> getEventDatePolls(EventFilter eventFilter, ZoneId userTimeZone, long attendeeId) throws IllegalAccessException
      Retrieves the list of pending date polls where the current user is invited
      Parameters:
      eventFilter - a filter used to define criteria to get list of objects
      userTimeZone - used to compute events dates switch given time zone
      attendeeId - user Identity identifier
      Returns:
      List date poll Event for user
      Throws:
      IllegalAccessException - when user is not an allowed to access one of ownerIds events

    • countEventDatePolls

      long countEventDatePolls(List<Long> ownerIds, long attendeeId) throws IllegalAccessException
      Count pending date polls where the current user is invited
      Parameters:
      ownerIds - List of Identity technical identifier
      attendeeId - user Identity identifier
      Returns:
      List date poll Event for user
      Throws:
      IllegalAccessException - when user is not an allowed to access one of ownerIds events

    • getPendingEvents

      List<Event> getPendingEvents(List<Long> ownerIds, long userIdentityId, ZoneId userTimeZone, int offset, int limit) throws Exception
      Retrieve pending events that the selected user didn't answered yet
      Parameters:
      ownerIds - List of Identity technical identifier
      userIdentityId - user Identity identifier
      userTimeZone - User time zone
      offset - offset of the events to retrieve
      limit - Limit of events to retrieve
      Returns:
      List of Event
      Throws:
      IllegalAccessException - when user is not an allowed to access one of ownerIds events
      Exception

    • countPendingEvents

      long countPendingEvents(List<Long> ownerIds, long userIdentityId) throws Exception
      Count pending events that the selected user didn't answered yet
      Parameters:
      ownerIds - List of Identity technical identifier
      userIdentityId - user Identity identifier
      Returns:
      pending events count
      Throws:
      IllegalAccessException - when user is not an allowed to access one of ownerIds events
      Exception