* Copyright (c) 2011-2012 Lockheed Martin Corporation

*

* 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,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Activity Page.

*/

    /** Text displayed for locked users. */

    private static final String LOCKED_USER_TEXT = "This employee has no profile in Eureka Streams.  This could be due"

            + " to an incorrect or outdated link, a change in assignment within the company, or leaving the company.";

    /** Amount of time to wait after a key is pressed before performing a search. */

    private static final int SEARCH_UPDATE_DELAY = 500;

    /** Amount of time to wait after a key is pressed to update the URL with the search term. */

    private static final int SEARCH_URL_UPDATE_DELAY = 2000;

    /** Binder for building UI. */

    private static LocalUiBinder binder = GWT.create(LocalUiBinder.class);

    /**

     * CSS resource.

     */

    interface ActivityStyle extends CssResource

    {

        /**

         * Active sort style.

         *

         * @return Active sort style

         */

        String activeSort();

        /**

         * Active stream style.

         *

         * @return Active stream style.

         */

        String activeStream();

        /**

         * Stream options child.

         *

         * @return Stream options child.

         */

        String streamOptionChild();

        /**

         * Delete bookmark.

         *

         * @return delete bookmark.

         */

        String deleteBookmark();

        /**

         * Edit custom stream.

         *

         * @return edit custom stream.

         */

        String editCustomStream();

        /**

         * The stream name style.

         *

         * @return the stream name style.

         */

        String streamName();

        /**

         * Active search style.

         *

         * @return active search style.

         */

        String activeSearch();

        /**

         * Current user link style.

         *

         * @return current user stream style.

         */

        String currentUserStreamLink();

        /**

         * Small avatar.

         *

         * @return small avatar style.

         */

        String smallAvatar();

        /**

         * Current user configure link.

         *

         * @return current user configure link.

         */

        String currentUserConfLink();

        /**

         * Message when no bookmarks exist.

         *

         * @return message when no bookmarks exist.

         */

        String noBookmarksMessage();

        /** @return The stream container panel. */

        @ClassName("stream-container-panel")

        String streamContainerPanel();

    }

    /**

     * CSS style.

     */

    @UiField

    ActivityStyle style;

    /**

     * Stream details.

     */

    @UiField

    StreamDetailsComposite streamDetailsComposite;

    /**

     * No results panel.

     */

    @UiField

    DivElement noResults;

    /**

     * Search container.

     */

    @UiField

    DivElement searchContainer;

    /**

     * UI element for streams.

     */

    @UiField

    FlowPanel streamPanel;

    /**

     * UI element for bookmarks.

     */

    @UiField

    FlowPanel bookmarkList;

    /**

     * UI element for stream container.

     */

    @UiField

    HTMLPanel streamContainerPanel;

    /**

     * UI element for filters.

     */

    @UiField

    FlowPanel filterList;

    /**

     * UI element for default streams.

     */

    @UiField

    FlowPanel defaultList;

    /**

     * UI element for default streams.

     */

    @UiField

    FlowPanel errorPanel;

    /**

     * UI element for recent sort.

     */

    @UiField

    Hyperlink recentSort;

    /**

     * UI element for popular sort.

     */

    @UiField

    Hyperlink popularSort;

    /**

     * UI element for active sort.

     */

    @UiField

    Hyperlink activeSort;

    /**

     * UI element for activity loading spinner.

     */

    @UiField

    DivElement activitySpinner;

    /**

     * Feed link.

     */

    @UiField

    Label feedLink;

    /**

     * UI element for more spinner.

     */

    @UiField

    DivElement moreSpinner;

    /**

     * UI element for more link.

     */

    @UiField

    Label moreLink;

    /**

     * UI element for adding a bookmark.

     */

    @UiField

    Label addBookmark;

    /**

     * UI element for adding a a stream to the start page.

     */

    @UiField

    Label addToStartPage;

    /**

     * Create Filter.

     */

    @UiField

    Label createFilter;

    /**

     * Subscribe via email.

     */

    @UiField

    Label subscribeViaEmail;

    /**

     * Stream search status widget.

     */

    @UiField

    StreamSearchStatusWidget streamSearchStatusWidget;

    /** Link to get contact for emailing to stream. */

    //@UiField

    //Anchor getEmailContactLink;

    /**

     * Panel for unseen activity notifications - hidden when viewing a single activity.

     */

    @UiField

    UnseenActivityNotificationPanel unseenActivityNotificationPanel;

    /**

     * Message Renderer.

     */

    StreamMessageItemRenderer renderer = new StreamMessageItemRenderer(ShowRecipient.YES);

    /** Sticky activity renderer (for groups only). */

    private static StickyActivityRenderer stickyActivityRenderer = new StickyActivityRenderer();

    /**

     * Newest activity ID.

     */

    private long longNewestActivityId = 0L;

    /**

     * Oldest Activity ID.

     */

    private long longOldestActivityId = 0;

    /**

     * Current Request.

     */

    private JSONObject currentRequestObj = null;

    /**

     * Search Box.

     */

    @UiField

    TextBox searchBox;

    /**

     * Stream options panel.

     */

    @UiField

    DivElement streamOptionsPanel;

    /**

     * Current stream scope.

     */

    private StreamScope currentStream;

    /**

     * Current scope id.

     */

    private long currentScopeId;

    /**

     * Current stream display name.

     */

    private String currentDisplayName;

    /**

     * Entity for the current stream. Used by the sticky activity logic to determine if any stick/unstick events pertain

     * to the current view. Would use currentStream, but there is other code that clobbers the entity type if the stream

     * isn't postable and thus renders currentStream useless for the purpose.

     */

    private Identifiable currentStreamEntity;

    /**

     * New activity polling.

     */

    private static final int NEW_ACTIVITY_POLLING_DELAY = 1200000;

    /**

     * Custom streams map.

     */

    private final HashMap<Long, StreamNamePanel> customStreamWidgetMap = new HashMap<Long, StreamNamePanel>();

    /**

     * Stream bookmarks map.

     */

    private final HashMap<String, StreamNamePanel> bookmarksWidgetMap = new HashMap<String, StreamNamePanel>();

    /**

     * Currently active stream.

     */

    private Panel currentlyActiveStream = null;

    /**

     * Following filter panel.

     */

    private Panel followingFilterPanel = null;

    /**

     * Everyone filter panel.

     */

    private Panel everyoneFilterPanel = null;

    /**

     * Is subscribed.

     */

    private boolean isSubscribed = false;

    /**

     * Post Box.

     */

    @UiField

    PostBoxComposite postBox;

    /**

     * User panel.

     */

    @UiField

    FlowPanel userPanel;

    /**

     * Current sort keyword.

     */

    private String sortKeyword = "";

    /**

     * Single activity mode.

     */

    private boolean singleActivityMode;

    /**

     * Bookmarks initially loaded.

     */

    private boolean bookmarksLoaded = false;

    /**

     * Bookmarks initially loaded.

     */

    private boolean customStreamsLoaded = false;

    /**

     * If the page has ran init.

     */

    private boolean hasInited = false;

    /** Stream to URL transformer. */

    private static final StreamToUrlTransformer STREAM_URL_TRANSFORMER = new StreamToUrlTransformer();

    /**

     * If the entity still needs to be received before making the activity query.

     *

     * Explanation: Fetching the activities for a group requires knowing which activity is sticky so it can be excluded

     * on the query. So the query must be built in loadStream and the DomainGroupModelView must be recieved.

     * Unfortunately, the event bus notifies inline instead of queuing, thus the call to the GroupModel in loadStream

     * may fire its event immediately (if the group is in cache), causing the group to be received before loadStream

     * finishes. So we have to handle two different possible orders. The approach taken is to set this flag and the one

     * below; whenever they are both reset, the activity query is sent.

     */

    private boolean deferLoadAwaitingEntityReceived;

    /**

     * If the activity query isn't done being constructed yet (before making the activity query). See

     * deferLoadAwaitingEntityReceived.

     */

    private boolean deferLoadAwaitingQueryBuilt;

    /** Place to put sticky activity. */

    @UiField

    SimplePanel stickyActivityHolder;

    /** Area containing the sticky activity. */

    @UiField

    DivElement stickyActivityArea;

    /** Views used to load the current stream. */

    List<String> loadedViews = Collections.singletonList("[do not match]");

    /** So results for the wrong stream can be detected and ignored. */

    private String currentStreamRequest;

    /** Search term used to load the current stream. */

    String loadedSearchTerm = "";

    /** Timer to delay progressive search until the user pauses. */

    private final Timer searchTimer = new Timer()

    {

        @Override

        public void run()

        {

            String searchText = searchBox.getText();

            loadStream(Session.getInstance().getUrlViews(), searchText);

            searchUrlTimer.schedule(SEARCH_URL_UPDATE_DELAY);

        }

    };

    /** Timer to update the URL with the search term. */

    private final Timer searchUrlTimer = new Timer()

    {

        @Override

        public void run()

        {

            updateUrlWithSearchTerm();

        }

    };

    /**

     * Default constructor.

     */

    public ActivityContent()

    {

        initWidget(binder.createAndBindUi(this));

        buildPage();

    }

    /**

     * Build the page.

     */

    private void buildPage()

    {

        addEventHandlers();

        addObservers();

        setupStreamsAndBookmarks();

        moreLink.setVisible(false);

        streamSearchStatusWidget.setVisible(false);

        errorPanel.setVisible(false);

        followingFilterPanel = createPanel("Following", "following", "style/images/customStream.png", null, "", "",

                false);

        everyoneFilterPanel = createPanel("Everyone", "everyone", "style/images/customStream.png", null, "", "", false);

        defaultList.add(followingFilterPanel);

        defaultList.add(everyoneFilterPanel);

        final PersonModelView currentPerson = Session.getInstance().getCurrentPerson();

        AvatarLinkPanel userAvatar = new AvatarLinkPanel(currentPerson.getEntityType(), currentPerson.getAccountId(),

                currentPerson.getAvatarId(), Size.Small, currentPerson.getDisplayName());

        userPanel.add(userAvatar);

        FlowPanel userLinkPanel = new FlowPanel();

        String nameUrl = Session.getInstance().generateUrl(

                new CreateUrlRequest(Page.PEOPLE, currentPerson.getAccountId()));

        Hyperlink name = new Hyperlink(currentPerson.getDisplayName(), nameUrl);

        name.setTitle(currentPerson.getDisplayName());

        name.addStyleName(style.currentUserStreamLink());

        name.addStyleName(StaticResourceBundle.INSTANCE.coreCss().ellipsisChild());

        userLinkPanel.add(name);

        String confUrl = Session.getInstance().generateUrl(

                new CreateUrlRequest(Page.PERSONAL_SETTINGS, currentPerson.getAccountId()));

        Hyperlink conf = new Hyperlink("Configure My Stream", confUrl);

        conf.addStyleName(style.currentUserConfLink());

        userLinkPanel.add(conf);

        userPanel.add(userLinkPanel);

        CustomStreamModel.getInstance().fetch(null, true);

        StreamBookmarksModel.getInstance().fetch(null, true);

        moreSpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

        noResults.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

        unseenActivityNotificationPanel.setActive(true);

    }

    /**

     * Got activity.

     *

     * @param event

     *            the event.

     */

    private void gotActivity(final GotActivityResponseEvent event)

    {

        streamPanel.clear();

        unseenActivityNotificationPanel.setActive(false);

        activitySpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

        if (event.getResponse() != null)

        {

            EntityType actorType = event.getResponse().getDestinationStream().getEntityType();

            String actorName = event.getResponse().getDestinationStream().getUniqueId();

            if (actorType.equals(EntityType.GROUP))

            {

                GroupModel.getInstance().fetch(actorName, false);

            }

            else if (actorType.equals(EntityType.PERSON))

            {

                PersonalInformationModel.getInstance().fetch(actorName, false);

            }

        }

        streamPanel.add(new ActivityDetailPanel(event.getResponse(), ShowRecipient.YES));

        streamPanel.removeStyleName(StaticResourceBundle.INSTANCE.coreCss().hidden());

    }

    /**

     * Add events.

     */

    private void addObservers()

    {

        final EventBus eventBus = EventBus.getInstance();

        eventBus.addObserver(GotActivityResponseEvent.class, new Observer<GotActivityResponseEvent>()

        {

            public void update(final GotActivityResponseEvent event)

            {

                gotActivity(event);

            }

        });

        eventBus.addObserver(GotStreamResponseEvent.class, new Observer<GotStreamResponseEvent>()

        {

            public void update(final GotStreamResponseEvent event)

            {

                // throw out results if for the wrong stream (or we don't want the results)

                if (currentStreamRequest == null || !currentStreamRequest.equals(event.getRequest()))

                {

                    return;

                }

                final PagedSet<ActivityDTO> activitySet = event.getStream();

                if (activitySet.getPagedSet().size() > 0)

                {

                    longNewestActivityId = activitySet.getPagedSet().get(0).getEntityId();

                    longOldestActivityId = activitySet.getPagedSet().get(activitySet.getPagedSet().size() - 1)

                            .getEntityId();

                }

                if (StreamJsonRequestFactory.getJSONRequest(event.getJsonRequest()).containsKey("minId"))

                {

                    for (int i = activitySet.getPagedSet().size(); i > 0; i--)

                    {

                        appendActivity(activitySet.getPagedSet().get(i - 1));

                    }

                }

                else if (StreamJsonRequestFactory.getJSONRequest(event.getJsonRequest()).containsKey("maxId"))

                {

                    moreSpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                    for (ActivityDTO activity : activitySet.getPagedSet())

                    {

                        streamPanel.add(renderer.render(activity));

                    }

                    moreLink.setVisible(activitySet.getTotal() > activitySet.getPagedSet().size());

                }

                else

                {

                    streamPanel.clear();

                    unseenActivityNotificationPanel.setActive(true);

                    activitySpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                    streamPanel.removeStyleName(StaticResourceBundle.INSTANCE.coreCss().hidden());

                    List<ActivityDTO> activities = activitySet.getPagedSet();

                    for (ActivityDTO activity : activities)

                    {

                        streamPanel.add(renderer.render(activity));

                    }

                    if (activities.size() == 0)

                    {

                        noResults.removeClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                    }

                    moreLink.setVisible(activitySet.getTotal() > activities.size());

                }

                if (activitySet.getPagedSet().size() > 0)

                {

                    noResults.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                }

            }

        });

        // users are not initially subscribed for emails when following a person/group, so set the status properly (else

        // if you were following and unsubscribed, then re-subscribed, the status would be old and wrong)

        eventBus.addObserver(InsertedPersonFollowerResponseEvent.class,

                new Observer<InsertedPersonFollowerResponseEvent>()

                {

                    public void update(final InsertedPersonFollowerResponseEvent ev)

                    {

                        setSubscribeStatus(false);

                    }

                });

        eventBus.addObserver(InsertedGroupMemberResponseEvent.class, new Observer<InsertedGroupMemberResponseEvent>()

        {

            public void update(final InsertedGroupMemberResponseEvent ev)

            {

                setSubscribeStatus(false);

            }

        });

        eventBus.addObserver(GotPersonFollowerStatusResponseEvent.class,

                new Observer<GotPersonFollowerStatusResponseEvent>()

                {

                    public void update(final GotPersonFollowerStatusResponseEvent event)

                    {

                        subscribeViaEmail.setVisible(event.getResponse().equals(FollowerStatus.FOLLOWING));

                    }

                });

        eventBus.addObserver(HistoryViewsChangedEvent.class, new Observer<HistoryViewsChangedEvent>()

        {

            public void update(final HistoryViewsChangedEvent event)

            {

                searchTimer.cancel();

                searchUrlTimer.cancel();

                handleViewsChanged(event.getViews());

                final String searchText = Session.getInstance().getParameterValue("search");

                if (!searchBox.getText().equals(searchText))

                {

                    searchBox.setText(searchText);

                }

            }

        });

        eventBus.addObserver(MessageStreamAppendEvent.class, new Observer<MessageStreamAppendEvent>()

        {

            public void update(final MessageStreamAppendEvent event)

            {

                longNewestActivityId = event.getMessage().getId();

                if (sortKeyword.equals("date"))

                {

                    appendActivity(event.getMessage());

                    noResults.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                }

                else

                {

                    recentSort.getElement().dispatchEvent(

                            Document.get().createClickEvent(1, 0, 0, 0, 0, false, false, false, false));

                }

            }

        });

        eventBus.addObserver(CustomStreamCreatedEvent.class, new Observer<CustomStreamCreatedEvent>()

        {

            public void update(final CustomStreamCreatedEvent event)

            {

                CustomStreamModel.getInstance().fetch(null, true);

            }

        });

        eventBus.addObserver(CustomStreamDeletedEvent.class, new Observer<CustomStreamDeletedEvent>()

        {

            public void update(final CustomStreamDeletedEvent event)

            {

                CustomStreamModel.getInstance().fetch(null, true);

            }

        });

        eventBus.addObserver(CustomStreamUpdatedEvent.class, new Observer<CustomStreamUpdatedEvent>()

        {

            public void update(final CustomStreamUpdatedEvent event)

            {

                CustomStreamModel.getInstance().fetch(null, true);

            }

        });

        eventBus.addObserver(StreamReinitializeRequestEvent.class, new Observer<StreamReinitializeRequestEvent>()

        {

            public void update(final StreamReinitializeRequestEvent event)

            {

                loadStream(Session.getInstance().getUrlViews(), Session.getInstance().getParameterValue("search"));

            }

        });

        eventBus.addObserver(UpdatedHistoryParametersEvent.class, new Observer<UpdatedHistoryParametersEvent>()

        {

            public void update(final UpdatedHistoryParametersEvent event)

            {

                searchTimer.cancel();

                searchUrlTimer.cancel();

                if (!event.getViewChanged())

                {

                    handleViewsChanged(Session.getInstance().getUrlViews());

                }

            }

        });

        eventBus.addObserver(AddedFeaturedStreamResponseEvent.class, new Observer<AddedFeaturedStreamResponseEvent>()

        {

            public void update(final AddedFeaturedStreamResponseEvent event)

            {

                eventBus.notifyObservers(new ShowNotificationEvent(new Notification("Stream has been featured.")));

            }

        });

        eventBus.addObserver(UpdatedGroupStickyActivityEvent.class, new Observer<UpdatedGroupStickyActivityEvent>()

        {

            public void update(final UpdatedGroupStickyActivityEvent ev)

            {

                // make sure event applies to the current view (since current view may not even be a group)

                if (currentStreamEntity != null && currentStreamEntity.getEntityType() == EntityType.GROUP

                        && ev.getGroupId() == currentStreamEntity.getEntityId() && !singleActivityMode)

                {

                    if (ev.getActivity() == null)

                    {

                        stickyActivityHolder.clear();

                        UIObject.setVisible(stickyActivityArea, false);

                    }

                    else

                    {

                        stickyActivityHolder.clear();

                        stickyActivityHolder.add(stickyActivityRenderer.render(ev.getActivity()));

                        UIObject.setVisible(stickyActivityArea, true);

                    }

                    // reload the stream to get prior sticky activities back in it (and a freshly stuck activity out)

                    eventBus.notifyObservers(StreamReinitializeRequestEvent.getEvent());

                }

            }

        });

        addEntityObservers();

    }

    /**

     * Add entity observers.

     */

    private void addEntityObservers()

    {

        EventBus.getInstance().addObserver(GotPersonalInformationResponseEvent.class,

                new Observer<GotPersonalInformationResponseEvent>()

                {

                    public void update(final GotPersonalInformationResponseEvent event)

                    {

                        PersonModelView person = event.getResponse();

                        currentDisplayName = person.getDisplayName();

                        currentScopeId = person.getStreamId();

                        if (person.isAccountLocked())

                        {

                            streamOptionsPanel.getStyle().setDisplay(Display.NONE);

                            currentStream.setScopeType(null);

                            errorPanel.clear();

                            errorPanel.setVisible(true);

                            activitySpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                            errorPanel.add(new Label("Employee profile not found"));

                            errorPanel.add(new Label(LOCKED_USER_TEXT));

                            streamPanel.removeStyleName(StaticResourceBundle.INSTANCE.coreCss().hidden());

                            streamDetailsComposite.setVisible(false);

                            currentStream.setScopeType(null);

                            // block display of activities

                            currentStreamRequest = null;

                            streamPanel.clear();

                            unseenActivityNotificationPanel.setActive(false);

                            activitySpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                            streamPanel.addStyleName(StaticResourceBundle.INSTANCE.coreCss().hidden());

                            noResults.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

                            moreLink.setVisible(false);

                        }

                        else

                        {

                            currentStream.setDisplayName(person.getDisplayName());

                            streamDetailsComposite.setVisible(true);

                        }

                        if (!person.isStreamPostable()

                                && !person.getAccountId().equals(

                                        Session.getInstance().getCurrentPerson().getAccountId()))

                        {

                            currentStream.setScopeType(null);

                        }

                        /*if (currentStream.getScopeType() != null)

                        {

                            getEmailContactLink.setHref("/resources/emailcontact/stream/person/" + person.getId());

                            getEmailContactLink.setVisible(true);

                        }*/

                        if (!singleActivityMode)

                        {

                            EventBus.getInstance().notifyObservers(new PostableStreamScopeChangeEvent(currentStream));

                        }

                    }

                });

        EventBus.getInstance().addObserver(GotGroupModelViewInformationResponseEvent.class,

                new Observer<GotGroupModelViewInformationResponseEvent>()

                {

                    public void update(final GotGroupModelViewInformationResponseEvent event)

                    {

                        onGroupModelViewReceived(event.getResponse());

                    }

                });

    }

    /**

     * Processing when group information is received.

     *

     * @param group

     *            The group.

     */

    private void onGroupModelViewReceived(final DomainGroupModelView group)

    {

      // If group is null, then that means that the group

      // was not found. As a result, a "Group not found"

      // page should be displayed.

      // This page is very similar to the "Activity not found" page

      if (group == null)

      { 

        showGroupNotFoundPage();

      }

      else

      {

        currentDisplayName = group.getDisplayName();

          currentScopeId = group.getStreamId();

 

          currentStream.setDisplayName(group.getName());

          streamDetailsComposite.setVisible(true);

 

          if (group.isRestricted())

          {

              streamOptionsPanel.getStyle().setDisplay(Display.NONE);

              currentStream.setScopeType(null);

              postBox.setVisible(false);

 

              errorPanel.clear();

              errorPanel.setVisible(true);

              activitySpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

              errorPanel.add(new Label("Access to this group is restricted"));

              errorPanel.add(new Label("To view this group's stream please request access from its coordinator"));

 

              final SpinnerLabelButton button = new SpinnerLabelButton(new ClickHandler()

              {

                  public void onClick(final ClickEvent inArg0)

                  {

                      GroupMembershipRequestModel.getInstance().insert(group.getShortName());

                  }

              });

 

              EventBus.getInstance().addObserver(InsertedRequestForGroupMembershipResponseEvent.class,

                      new Observer<InsertedRequestForGroupMembershipResponseEvent>()

                      {

                          public void update(final InsertedRequestForGroupMembershipResponseEvent inArg1)

                          {

                              button.disable();

                              EventBus.getInstance()

                                      .notifyObservers(

                                              new ShowNotificationEvent(new Notification(

                                                      "Your request for access has been sent")));

                          }

                      });

 

              button.addStyleName(StaticResourceBundle.INSTANCE.coreCss().requestAccessButton());

              errorPanel.add(button);

 

              streamPanel.clear();

              unseenActivityNotificationPanel.setActive(true);

          }

          else

          {

              currentStreamEntity = group;

 

              if (group.getStickyActivity() != null && !singleActivityMode

                      && (loadedSearchTerm == null || loadedSearchTerm == ""))

              {

                  stickyActivityHolder.add(stickyActivityRenderer.render(group.getStickyActivity()));

                  UIObject.setVisible(stickyActivityArea, true);

              }

          }

          boolean isCoordinator = false;

 

          for (PersonModelView coordinator : group.getCoordinators())

          {

              AvatarBadgeManager.getInstance().setBadge(style.streamContainerPanel(), coordinator.getUniqueId());

              if (coordinator.getAccountId().equals(Session.getInstance().getCurrentPerson().getAccountId()))

              {

                  isCoordinator = true;

              }

          }

          if (!group.isStreamPostable() && !isCoordinator)

          {

              currentStream.setScopeType(null);

          }

          /*else

          {

              getEmailContactLink.setHref("/resources/emailcontact/stream/group/" + group.getId());

              getEmailContactLink.setVisible(true);

          }*/

 

          if (!singleActivityMode)

          {

              if (Session.getInstance().getCurrentPersonRoles().contains(Role.SYSTEM_ADMIN) || isCoordinator)

              {

                  streamContainerPanel.addStyleName(StaticResourceBundle.INSTANCE.coreCss().hasOwnerRights());

              }

 

              EventBus.getInstance().notifyObservers(new PostableStreamScopeChangeEvent(currentStream));

          }

 

          if (deferLoadAwaitingEntityReceived)

          {

              deferLoadAwaitingEntityReceived = false;

              currentRequestObj = StreamJsonRequestFactory.setExcludeId(group.getStickyActivityId(),

                  currentRequestObj);

              if (!deferLoadAwaitingQueryBuilt)

              {

                  fetchStream(currentRequestObj);

              }

          }

      }

    }

   

    /**

     * Shows a "not found" message.

     */

    private void showGroupNotFoundPage()

    {

      activitySpinner.addClassName(StaticResourceBundle.INSTANCE.coreCss().displayNone());

      streamPanel.clear();

    errorPanel.clear();

    postBox.setVisible(false);

   

      Panel errorReport = new FlowPanel();

        errorReport.addStyleName(StaticResourceBundle.INSTANCE.coreCss().warningReport());

        FlowPanel centeringPanel = new FlowPanel();

        centeringPanel.addStyleName(StaticResourceBundle.INSTANCE.coreCss().warningReportContainer());

        centeringPanel.add(errorReport);

        streamPanel.add(centeringPanel);

        FlowPanel msgPanel = new FlowPanel();

        Label msgHeader = new Label("Group not found");

        msgHeader.addStyleName(StaticResourceBundle.INSTANCE.coreCss().warningMessage());

        Label msgText = new Label("The group you were looking for has been deleted or could not be found.");

        FlowPanel text = new FlowPanel();

        text.add(msgText);

        text.addStyleName(StaticResourceBundle.INSTANCE.coreCss().errorMessageText());

        msgPanel.add(msgHeader);

        msgPanel.add(msgText);

        streamPanel.removeStyleName(StaticResourceBundle.INSTANCE.coreCss().hidden());

       

    streamPanel.setVisible(true);

    streamContainerPanel.setVisible(true);

        errorReport.add(msgPanel);

    errorPanel.setVisible(true);

    errorReport.setVisible(true);

    centeringPanel.setVisible(true);

    msgPanel.setVisible(true);

    }

   

    /**

     * Handle views changed.

     *

     * @param inViews

     *            the views.

     */

    protected void handleViewsChanged(final List<String> inViews)

    {

        String search = Session.getInstance().getParameterValue("search");

        // prevent reloading the same content

        if (!loadedViews.equals(inViews) || !loadedSearchTerm.equals(search))

        {

            loadStream(inViews, search);

        }

        List<String> views = new ArrayList<String>(inViews);

        if (views.size() < 2 || !"sort".equals(views.get(views.size() - 2)))

        {

            views.add("sort");

            views.add("recent");

        }

        Map<String, String> params = (search == null || search.isEmpty()) ? Collections.EMPTY_MAP : Collections

                .singletonMap("search", search);

        views.set(views.size() - 1, "recent");

        recentSort.setTargetHistoryToken(Session.getInstance().generateUrl(

                new CreateUrlRequest(Page.ACTIVITY, views, params)));

        views.set(views.size() - 1, "popular");

        popularSort.setTargetHistoryToken(Session.getInstance().generateUrl(

                new CreateUrlRequest(Page.ACTIVITY, views, params)));

        views.set(views.size() - 1, "active");

        activeSort.setTargetHistoryToken(Session.getInstance().generateUrl(

                new CreateUrlRequest(Page.ACTIVITY, views, params)));

    }

    /**

     * Setup bookmarks and custom streams.

     */

    private void setupStreamsAndBookmarks()

    {

        final EventBus eventBus = EventBus.getInstance();

        eventBus.addObserver(GotCurrentUserStreamBookmarks.class, new Observer<GotCurrentUserStreamBookmarks>()

        {

            private final AvatarUrlGenerator groupUrlGen = new AvatarUrlGenerator(EntityType.GROUP);

            private final AvatarUrlGenerator personUrlGen = new AvatarUrlGenerator(EntityType.PERSON);

            public void update(final GotCurrentUserStreamBookmarks event)

            {

                bookmarkList.clear();

                bookmarksWidgetMap.clear();

                List<StreamFilter> sortedStreamFilters = event.getResponse();

                Collections.sort(sortedStreamFilters, new StreamFilterNameComparator());

                for (final StreamFilter filter : sortedStreamFilters)

                {

                    JSONObject req = StreamJsonRequestFactory.getJSONRequest(filter.getRequest());

                    String uniqueId = null;

                    String entityType = null;

                    String imgUrl = "";

                    if (req.containsKey("query"))

                    {

                        JSONObject query = req.get("query").isObject();

                        if (query.containsKey(StreamJsonRequestFactory.RECIPIENT_KEY))

                        {

                            JSONArray recipient = query.get(StreamJsonRequestFactory.RECIPIENT_KEY).isArray();

                            if (recipient.size() > 0)

                            {

                                JSONObject recipientObj = recipient.get(0).isObject();

                                uniqueId = recipientObj.get("name").isString().stringValue();

                                entityType = recipientObj.get("type").isString().stringValue().toLowerCase();

                                AvatarUrlGenerator urlGen = groupUrlGen;

                                if ("person".equals(entityType))

                                {

                                    urlGen = personUrlGen;

                                }

                                imgUrl = urlGen.getSmallAvatarUrl(filter.getOwnerAvatarId());

                            }

                        }

                    }

                    if (uniqueId != null && entityType != null)

                    {

                        String bookmarkUrl = entityType + "/" + uniqueId;

                        StreamNamePanel bookmarkFilter = createPanel(filter.getName(), bookmarkUrl, imgUrl,

                                new ClickHandler()

                                {

                                    public void onClick(final ClickEvent event)

                                    {

                                        if (new WidgetJSNIFacadeImpl()

                                                .confirm("Are you sure you want to delete this bookmark?"))

                                        {

                                            StreamBookmarksModel.getInstance().delete(filter.getId());

                                        }

                                        event.stopPropagation();

                                    }

                                }, style.deleteBookmark(), "", true);

                        bookmarkList.add(bookmarkFilter);

                        bookmarksWidgetMap.put(bookmarkUrl, bookmarkFilter);

                    }

                }

                if (sortedStreamFilters.size() == 0)

                {

                    Label defaultLabel = new Label("Bookmarks allow you to quickly jump to any stream in Eureka.");

                    defaultLabel.addStyleName(style.noBookmarksMessage());

                    bookmarkList.add(defaultLabel);

                }

                bookmarksLoaded = true;

                checkInit();

            }

        });

        eventBus.addObserver(StreamActivitySubscriptionChangedEvent.class,

                new Observer<StreamActivitySubscriptionChangedEvent>()

                {

                    public void update(final StreamActivitySubscriptionChangedEvent ev)

                    {

                        boolean newStatus = ev.getResponse().getReceiveNewActivityNotifications();

                        setSubscribeStatus(newStatus);

                        String msg = newStatus ? "You will now receive emails for new activities to this stream"

                                : "You will no longer receive emails for new activities to this stream";

                        eventBus.notifyObservers(new ShowNotificationEvent(new Notification(msg)));

                    }

                });

        eventBus.addObserver(GotStreamActivitySubscriptionResponseEvent.class,

                new Observer<GotStreamActivitySubscriptionResponseEvent>()

                {

                    public void update(final GotStreamActivitySubscriptionResponseEvent result)

                    {

                        setSubscribeStatus(result.isSubscribed());

                    }

                });

        eventBus.addObserver(GotCurrentUserCustomStreamsResponseEvent.class,

                new Observer<GotCurrentUserCustomStreamsResponseEvent>()

                {

                    public void update(final GotCurrentUserCustomStreamsResponseEvent event)

                    {

                        filterList.clear();

                        customStreamWidgetMap.clear();

                        StreamNamePanel savedBy = createPanel("My Saved Items", "custom/0/"

                                + "{\"query\":{\"savedBy\":\""

                                + Session.getInstance().getCurrentPerson().getAccountId() + "\"}}",

                                "style/images/customStream.png", null, "", "", false);

                        filterList.add(savedBy);

                        customStreamWidgetMap.put(0L, savedBy);

                        StreamNamePanel likedBy = createPanel("My Liked Items", "custom/1/"

                                + "{\"query\":{\"likedBy\":[{\"type\":\"PERSON\", \"name\":\""

                                + Session.getInstance().getCurrentPerson().getAccountId() + "\"}]}}/My Liked Items",

                                "style/images/customStream.png", null, "", "", false);

                        filterList.add(likedBy);

                        customStreamWidgetMap.put(1L, likedBy);

                        for (final StreamFilter filter : event.getResponse().getStreamFilters())

                        {

                            StreamNamePanel filterPanel = createPanel(

                                    filter.getName(),

                                    "custom/"

                                            + filter.getId()

                                            + "/"

                                            + URL.encodeComponent(filter.getRequest().

                                                        replace("%%CURRENT_USER_ACCOUNT_ID%%",

                                                            Session.getInstance().getCurrentPerson().getAccountId())),

                                    "style/images/customStream.png", new ClickHandler()

                                    {

                                        public void onClick(final ClickEvent event)

                                        {

                                            Dialog.showCentered(new CustomStreamDialogContent((Stream) filter));

                                            event.stopPropagation();

                                        }

                                    }, style.editCustomStream(), "edit", false);

                            filterList.add(filterPanel);