import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testClosingAllPlacesIncludesCustomPanels() throws Exception {
    HasWidgets any = any(HasWidgets.class);
    CustomPanelDefinitionImpl customPanelDef = new CustomPanelDefinitionImpl(
            UnanchoredStaticWorkbenchPanelPresenter.class.getName(),
            any);
    when(panelManager.addCustomPanel(any,
                                     eq(UnanchoredStaticWorkbenchPanelPresenter.class.getName())))
            .thenReturn(customPanelDef);

    PlaceRequest emeraldCityPlace = new DefaultPlaceRequest("emerald_city");
    createWorkbenchScreenActivity(emeraldCityPlace);

    HasWidgets customContainer = mock(HasWidgets.class);

    placeManager.goTo(emeraldCityPlace,
                      customContainer);
    placeManager.closeAllPlaces();

    assertTrue(customPanelDef.getParts().isEmpty());
    verify(panelManager).removeWorkbenchPanel(customPanelDef);
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Override
public void goTo(final PartDefinition part,
                 final PanelDefinition panel) {
    final PlaceRequest place = part.getPlace();
    if (place == null) {
        return;
    }
    final ResolvedRequest resolved = resolveActivity(place);

    if (resolved.getActivity() != null) {
        final Activity activity = resolved.getActivity();

        if (activity.isType(ActivityResourceType.EDITOR.name()) || activity.isType(ActivityResourceType.SCREEN.name())) {
            final WorkbenchActivity workbenchActivity = (WorkbenchActivity) activity;
            launchWorkbenchActivityInPanel(place,
                                           workbenchActivity,
                                           part,
                                           panel);
        } else {
            throw new IllegalArgumentException("placeRequest does not represent a WorkbenchActivity. Only WorkbenchActivities can be launched in a specific targetPanel.");
        }
    } else {
        goTo(resolved.getPlaceRequest());
    }
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testOnStartupWithRepositoryWithProjectNoModel() throws Exception {
    when(workbenchContext.getActiveOrganizationalUnit()).thenReturn(organizationalUnit);
    when(workbenchContext.getActiveRepository()).thenReturn(repository);
    when(workbenchContext.getActiveProject()).thenReturn(project);

    final RepositoryStructureModel model = null;
    when(repositoryStructureService.load(eq(repository),
                                         anyString())).thenReturn(model);

    final PlaceRequest placeRequest = mock(PlaceRequest.class);

    presenter.onStartup(placeRequest);

    verify(view,
           times(1)).setModulesViewVisible(eq(false));
    verify(view,
           times(1)).clearDataView();
    verify(modulesView,
           times(1)).enableActions(eq(true));
    verify(view,
           times(1)).showBusyIndicator(Constants.INSTANCE.Loading());
    verify(view,
           times(1)).hideBusyIndicator();
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
/**
 * Adds all the ToolBar items associated with the given place to this
 * toolbar. The exact list of items added is remembered, and can be removed
 * later by a call to {@link #removeItemsFor(PlaceRequest)}.
 * <p>
 * The toolbar items are filtered for the current user subject to their
 * security requirements.
 * <p>
 * This method becomes a no-op when any of the following is true:
 * <ul>
 * <li>The place doesn't have an associated {@link Activity}
 * <li>The place's Activity is not a {@link WorkbenchActivity}
 * <li>The place's WorkbenchActivity doesn't have a {@link ToolBar}
 * </ul>
 */
public void addItemsFor(final PlaceRequest place) {
    final Activity activity = placeManager.getActivity(place);
    if (activity == null) {
        return;
    }
    if (!(activity instanceof WorkbenchActivity)) {
        return;
    }
    final WorkbenchActivity wbActivity = (WorkbenchActivity) activity;

    final ToolBar toolBar = wbActivity.getToolBar();
    if (toolBar == null) {
        return;
    }

    final ToolBar filteredToolBar = filterToolBarItemsByPermission(toolBar);

    if (!filteredToolBar.getItems().isEmpty()) {
        workbenchContextItems.put(place,
                                  filteredToolBar);
        view.addToolBar(filteredToolBar);
    }
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void createPlaceRequest() throws Exception {
    String url = " http://127.0.0.1:8888/org.uberfire.UberfireShowcase/out.16590-4829.erraiBus?z=12&clientId=16590-4829";
    PlaceRequest placeRequest = placeRequestHistoryMapper.getPlaceRequest(url);
    assertEquals(url.substring(0,
                               url.indexOf("?")),
                 placeRequest.getIdentifier());

    Map<String, String> parameters = placeRequest.getParameters();

    assertFalse(parameters.isEmpty());
    assertTrue(parameters.containsKey("z"));
    assertTrue(parameters.containsKey("clientId"));
    assertEquals("12",
                 parameters.get("z"));
    assertEquals("16590-4829",
                 parameters.get("clientId"));
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@OnStartup
public void onStartup(final ObservablePath path,
                      final PlaceRequest place) {
    init(path,
         place,
         resourceType,
         true,
         false,
         SAVE,
         COPY,
         RENAME,
         DELETE);

    // This is only used to define the "name" used by @WorkbenchPartTitle which is called by Uberfire after @OnStartup
    // but before the async call in "loadContent()" has returned. When the *real* plugin is loaded this is overwritten
    this.plugin = new Plugin(place.getParameter("name",
                                                ""),
                             PluginType.DYNAMIC_MENU,
                             path);
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
private void equals(final PlaceRequest placeRequest1,
                    final PlaceRequest placeRequest2) {
    assertTrue(placeRequest1.equals(placeRequest2));
    assertTrue(placeRequest2.equals(placeRequest1));
    assertEquals(placeRequest1.hashCode(),
                 placeRequest2.hashCode());
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testLaunchingPopupThatIsAlreadyOpen() throws Exception {

    final PlaceRequest popupPlace = new DefaultPlaceRequest("Somewhere");
    final AbstractPopupActivity popupActivity = mock(AbstractPopupActivity.class);

    when(activityManager.getActivities(popupPlace)).thenReturn(singleton((Activity) popupActivity));
    when(popupActivity.isType(ActivityResourceType.POPUP.name())).thenReturn(true);

    placeManager.goTo(popupPlace);
    placeManager.goTo(popupPlace);

    verify(popupActivity,
           never()).onStartup(any(PlaceRequest.class));
    verify(popupActivity,
           times(1)).onOpen();
    assertEquals(PlaceStatus.OPEN,
                 placeManager.getStatus(popupPlace));
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
private ResolvedRequest resolveExistingParts(final PlaceRequest place) {
    final Activity activity = getActivity(place);

    if (activity != null) {
        return new ResolvedRequest(activity,
                                   place);
    }

    if (place instanceof PathPlaceRequest) {
        final ObservablePath path = ((PathPlaceRequest) place).getPath();

        for (final Map.Entry<PlaceRequest, PartDefinition> entry : visibleWorkbenchParts.entrySet()) {
            final PlaceRequest pr = entry.getKey();
            if (pr instanceof PathPlaceRequest) {
                final Path visiblePath = ((PathPlaceRequest) pr).getPath();
                final String visiblePathURI = visiblePath.toURI();
                if ((visiblePathURI != null && visiblePathURI.compareTo(path.toURI()) == 0) || visiblePath.compareTo(path) == 0) {
                    return new ResolvedRequest(getActivity(pr),
                                               pr);
                }
            }
        }
    }

    return null;
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testAddPerspective() {
    final String perspectiveId = "perspectiveId";
    final Menus menus = MenuFactory.newSimpleItem("test").perspective(perspectiveId).endMenu().build();
    final PlaceRequest placeRequest = new DefaultPlaceRequest("anyId");
    final PerspectiveActivity perspectiveActivity = mock(PerspectiveActivity.class);

    when(perspectiveActivity.getPlace()).thenReturn(placeRequest);
    when(perspectiveManager.getCurrentPerspective()).thenReturn(perspectiveActivity);
    when(authzManager.authorize(any(Resource.class),
                                eq(identity))).thenReturn(true);

    presenter.addMenus(menus);

    verify(view,
           never()).selectMenuItem(perspectiveId);
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testGoToConditionalPlaceByIdOrElse() throws Exception {

    DefaultPlaceRequest other = new DefaultPlaceRequest("other");
    PlaceRequest dora = new ConditionalPlaceRequest("dora").when(p -> false)
            .orElse(other);

    WorkbenchScreenActivity doraActivity = mock(WorkbenchScreenActivity.class);
    WorkbenchScreenActivity otherActivity = mock(WorkbenchScreenActivity.class);
    when(doraActivity.isType(ActivityResourceType.SCREEN.name())).thenReturn(true);
    when(otherActivity.isType(ActivityResourceType.SCREEN.name())).thenReturn(true);
    when(activityManager.getActivities(dora)).thenReturn(singleton((Activity) doraActivity));
    when(activityManager.getActivities(other)).thenReturn(singleton((Activity) otherActivity));

    placeManager.goTo(dora);

    verify(doraActivity,
           never()).onOpen();
    verify(otherActivity).onOpen();

    verifyActivityLaunchSideEffects(other,
                                    otherActivity,
                                    null);
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
private BreadcrumbsPresenter createBreadCrumb(final String perspective,
                                              final String label,
                                              final PlaceRequest placeRequest,
                                              final HasWidgets addTo,
                                              final Command command) {

    BreadcrumbsPresenter breadCrumb = breadcrumbsPresenters.get();
    breadCrumb.setup(label,
                     placeRequest,
                     generateBreadCrumbSelectCommand(perspective,
                                                     breadCrumb,
                                                     placeRequest,
                                                     addTo,
                                                     command));
    breadCrumb.activate();
    return breadCrumb;
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
Command generateBreadCrumbSelectCommand(final String perspective,
                                        final BreadcrumbsPresenter breadCrumb,
                                        final PlaceRequest placeRequest,
                                        final HasWidgets addTo,
                                        final Command command) {
    return () -> {
        removeDeepLevelBreadcrumbs(perspective,
                                   breadCrumb);
        breadCrumb.activate();
        if (placeRequest != null) {
            goToBreadCrumb(placeRequest,
                           addTo);
        }
        updateView();
        if (command != null) {
            command.execute();
        }
    };
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
public void registerClose(Activity activity,
                          PlaceRequest place) {
    if (place.isUpdateLocationBarAllowed()) {
        if (place instanceof PathPlaceRequest) {
            // handle editors
            currentBookmarkableURLStatus =
                    BookmarkableUrlHelper.registerCloseEditor(currentBookmarkableURLStatus,
                                                              place);
        } else {
            final String id = place.getIdentifier();
            if (activity.isType(ActivityResourceType.SCREEN.name())) {
                final String token = BookmarkableUrlHelper.getUrlToken(currentBookmarkableURLStatus,
                                                                       id);

                currentBookmarkableURLStatus =
                        BookmarkableUrlHelper.registerClose(currentBookmarkableURLStatus,
                                                            token);
            }
        }
        updateHistoryBar();
    }
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
/**
 * Remove the editor reference from the URL
 * @param currentBookmarkableURLStatus
 * @param place
 * @return
 */
public static String registerCloseEditor(final String currentBookmarkableURLStatus,
                                         final PlaceRequest place) {
    if (place != null
            && place instanceof PathPlaceRequest) {
        final String path = place.getFullIdentifier();
        final String pathWithSep = path.concat(SEPARATOR);

        if (currentBookmarkableURLStatus.contains(pathWithSep)) {
            return currentBookmarkableURLStatus.replace(pathWithSep,
                                                        "");
        }
        return currentBookmarkableURLStatus.replace(path,
                                                    "");
    }
    return currentBookmarkableURLStatus;
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@OnStartup
public void onStartup(final PlaceRequest placeRequest) {
    final String activeTab = placeRequest.getParameter(ACTIVE_TAB,
                                                       ROLES_TAB);

    userSystemManager.waitForInitialization(() -> {
        if (userSystemManager.isActive()) {
            groupsExplorer.show();
            usersExplorer.show();
            view.groupsEnabled(true);
            view.usersEnabled(true);

            if (activeTab.equals(USERS_TAB)) {
                view.rolesActive(false);
                view.groupsActive(false);
                view.usersActive(true);
            } else if (activeTab.equals(GROUPS_TAB)) {
                view.rolesActive(false);
                view.groupsActive(true);
                view.usersActive(false);
            }
        }
    });
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void getPerspectiveWithStartupTest() {
    this.perspective.onStartup(mock(PlaceRequest.class));

    verify(perspective,
           times(1)).createPerspectiveDefinition();
    verify(perspective,
           times(1)).configurePerspective(any(PlaceRequest.class));

    final PerspectiveDefinition perspectiveDefinition = perspective.getPerspective();

    verify(perspective,
           times(1)).createPerspectiveDefinition();
    verify(perspective,
           times(1)).configurePerspective(any(PlaceRequest.class));

    assertNotNull(perspectiveDefinition);
    assertNotNull(perspectiveDefinition.getName());
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@OnStartup
public void onStartup(final PlaceRequest placeRequest) {
    screen = placeRequest.getParameter("screen",
                                       adminPage.getDefaultScreen());
    perspectiveIdentifierToGoBackTo = placeRequest.getParameter("perspectiveIdentifierToGoBackTo",
                                                                null);

    view.init(this);

    if (screen == null) {
        notification.fire(new NotificationEvent(view.getNoScreenParameterError(),
                                                NotificationEvent.NotificationType.ERROR));
    } else {
        init(screen);
    }
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testPerspectiveFromUrlWithHistory() {
    final String REQUEST = "perspective|secreenOne,~screenTwo$screenThree";

    PlaceRequest req = new DefaultPlaceRequest(REQUEST);

    PlaceRequest place = BookmarkableUrlHelper.getPerspectiveFromPlace(req);
    assertNotNull(place);
    assertEquals("perspective",
                 place.getIdentifier());
    assertNotSame(place,
                  req);
}
 

import org.uberfire.mvp.PlaceRequest; //导入依赖的package包/类
@Test
public void testSwitchingPerspectives() throws Exception {
    PerspectiveActivity ozPerspectiveActivity = mock(PerspectiveActivity.class);
    PlaceRequest ozPerspectivePlace = new DefaultPlaceRequest("oz_perspective");
    PerspectiveDefinition ozPerspectiveDef = new PerspectiveDefinitionImpl();

    when(activityManager.getActivities(ozPerspectivePlace))
            .thenReturn(singleton((Activity) ozPerspectiveActivity));
    when(ozPerspectiveActivity.getDefaultPerspectiveLayout()).thenReturn(ozPerspectiveDef);
    when(ozPerspectiveActivity.getPlace()).thenReturn(ozPerspectivePlace);
    when(ozPerspectiveActivity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true);
    when(kansasActivity.isType(ActivityResourceType.SCREEN.name())).thenReturn(true);

    // we'll pretend we started in kansas
    PerspectiveActivity kansasPerspectiveActivity = mock(PerspectiveActivity.class);
    when(perspectiveManager.getCurrentPerspective()).thenReturn(kansasPerspectiveActivity);

    placeManager.goTo(ozPerspectivePlace);

    // verify proper shutdown of kansasPerspective and its contents
    InOrder inOrder = inOrder(activityManager,
                              kansasPerspectiveActivity,
                              kansasActivity,
                              workbenchLayout);

    // shut down the screens first
    inOrder.verify(kansasActivity).onClose();
    inOrder.verify(activityManager).destroyActivity(kansasActivity);

    // then the perspective
    inOrder.verify(kansasPerspectiveActivity).onClose();
    inOrder.verify(activityManager).destroyActivity(kansasPerspectiveActivity);
    inOrder.verify(workbenchLayout).onResize();
}