ui/SuiteApp.java

   1 package org.argeo.suite.ui;
   2
   3 import static org.argeo.cms.ui.CmsView.CMS_VIEW_UID_PROPERTY;
   4
   5 import java.util.Collections;
   6 import java.util.HashMap;
   7 import java.util.HashSet;
   8 import java.util.List;
   9 import java.util.Locale;
  10 import java.util.Map;
  11 import java.util.Set;
  12 import java.util.TreeMap;
  13 import java.util.TreeSet;
  14
  15 import javax.jcr.Node;
  16 import javax.jcr.RepositoryException;
  17 import javax.jcr.Session;
  18 import javax.jcr.nodetype.NodeType;
  19 import javax.naming.InvalidNameException;
  20 import javax.naming.ldap.LdapName;
  21
  22 import org.apache.commons.logging.Log;
  23 import org.apache.commons.logging.LogFactory;
  24 import org.argeo.api.NodeUtils;
  25 import org.argeo.cms.CmsUserManager;
  26 import org.argeo.cms.LocaleUtils;
  27 import org.argeo.cms.Localized;
  28 import org.argeo.cms.auth.CmsSession;
  29 import org.argeo.cms.ui.AbstractCmsApp;
  30 import org.argeo.cms.ui.CmsTheme;
  31 import org.argeo.cms.ui.CmsUiProvider;
  32 import org.argeo.cms.ui.CmsView;
  33 import org.argeo.cms.ui.dialogs.CmsFeedback;
  34 import org.argeo.cms.ui.util.CmsUiUtils;
  35 import org.argeo.eclipse.ui.specific.UiContext;
  36 import org.argeo.entity.EntityConstants;
  37 import org.argeo.entity.EntityNames;
  38 import org.argeo.entity.EntityType;
  39 import org.argeo.jcr.Jcr;
  40 import org.argeo.jcr.JcrException;
  41 import org.argeo.suite.RankedObject;
  42 import org.argeo.suite.SuiteUtils;
  43 import org.argeo.util.LangUtils;
  44 import org.eclipse.swt.SWT;
  45 import org.eclipse.swt.widgets.Composite;
  46 import org.osgi.framework.Constants;
  47 import org.osgi.service.event.Event;
  48 import org.osgi.service.event.EventHandler;
  49 import org.osgi.service.useradmin.User;
  50
  51 /** The Argeo Suite App. */
  52 public class SuiteApp extends AbstractCmsApp implements EventHandler {
  53         private final static Log log = LogFactory.getLog(SuiteApp.class);
  54
  55         public final static String PUBLIC_BASE_PATH_PROPERTY = "publicBasePath";
  56         public final static String DEFAULT_UI_NAME_PROPERTY = "defaultUiName";
  57         public final static String DEFAULT_THEME_ID_PROPERTY = "defaultThemeId";
  58         public final static String DEFAULT_LAYER_PROPERTY = "defaultLayer";
  59         private final static String LOGIN = "login";
  60
  61         private String publicBasePath = null;
  62
  63         private String pidPrefix;
  64         private String headerPid;
  65         private String footerPid;
  66         private String leadPanePid;
  67         private String loginScreenPid;
  68
  69         private String defaultLayerPid = "argeo.suite.ui.dashboardLayer";
  70
  71         private String defaultUiName = "app";
  72         private String defaultThemeId = "org.argeo.suite.theme.default";
  73
  74         private Map<String, RankedObject<CmsUiProvider>> uiProvidersByPid = Collections.synchronizedMap(new HashMap<>());
  75         private Map<String, RankedObject<CmsUiProvider>> uiProvidersByType = Collections.synchronizedMap(new HashMap<>());
  76         private Map<String, RankedObject<SuiteLayer>> layersByPid = Collections.synchronizedSortedMap(new TreeMap<>());
  77         private Map<String, RankedObject<SuiteLayer>> layersByType = Collections.synchronizedSortedMap(new TreeMap<>());
  78
  79         private CmsUserManager cmsUserManager;
  80
  81         // TODO make more optimal or via CmsSession/CmsView
  82         private Map<String, SuiteUi> managedUis = new HashMap<>();
  83
  84         public void init(Map<String, Object> properties) {
  85                 if (log.isDebugEnabled())
  86                         log.info("Argeo Suite App started");
  87
  88                 if (properties.containsKey(DEFAULT_UI_NAME_PROPERTY))
  89                         defaultUiName = LangUtils.get(properties, DEFAULT_UI_NAME_PROPERTY);
  90                 if (properties.containsKey(DEFAULT_THEME_ID_PROPERTY))
  91                         defaultThemeId = LangUtils.get(properties, DEFAULT_THEME_ID_PROPERTY);
  92                 if (properties.containsKey(DEFAULT_LAYER_PROPERTY))
  93                         defaultLayerPid = LangUtils.get(properties, DEFAULT_LAYER_PROPERTY);
  94                 publicBasePath = LangUtils.get(properties, PUBLIC_BASE_PATH_PROPERTY);
  95
  96                 if (properties.containsKey(Constants.SERVICE_PID)) {
  97                         String servicePid = properties.get(Constants.SERVICE_PID).toString();
  98                         if (servicePid.endsWith(".app")) {
  99                                 pidPrefix = servicePid.substring(0, servicePid.length() - "app".length());
 100                         }
 101                 }
 102
 103                 if (pidPrefix == null)
 104                         throw new IllegalArgumentException("PID prefix must be set.");
 105
 106                 headerPid = pidPrefix + "header";
 107                 footerPid = pidPrefix + "footer";
 108                 leadPanePid = pidPrefix + "leadPane";
 109                 loginScreenPid = pidPrefix + "loginScreen";
 110         }
 111
 112         public void destroy(Map<String, Object> properties) {
 113                 for (SuiteUi ui : managedUis.values())
 114                         if (!ui.isDisposed())
 115                                 ui.dispose();
 116                 if (log.isDebugEnabled())
 117                         log.info("Argeo Suite App stopped");
 118
 119         }
 120
 121         @Override
 122         public Set<String> getUiNames() {
 123                 HashSet<String> uiNames = new HashSet<>();
 124                 uiNames.add(defaultUiName);
 125                 return uiNames;
 126         }
 127
 128         @Override
 129         public Composite initUi(Composite parent) {
 130                 String uiName = parent.getData(UI_NAME_PROPERTY) != null ? parent.getData(UI_NAME_PROPERTY).toString() : null;
 131                 CmsView cmsView = CmsView.getCmsView(parent);
 132                 if (cmsView == null)
 133                         throw new IllegalStateException("No CMS view is registered.");
 134                 CmsTheme theme = getTheme(uiName);
 135                 if (theme != null)
 136                         CmsTheme.registerCmsTheme(parent.getShell(), theme);
 137                 SuiteUi argeoSuiteUi = new SuiteUi(parent, SWT.INHERIT_DEFAULT);
 138                 String uid = cmsView.getUid();
 139                 managedUis.put(uid, argeoSuiteUi);
 140                 argeoSuiteUi.addDisposeListener((e) -> {
 141                         managedUis.remove(uid);
 142                         if (log.isDebugEnabled())
 143                                 log.debug("Suite UI " + uid + " has been disposed.");
 144                 });
 145                 return argeoSuiteUi;
 146         }
 147
 148         @Override
 149         public String getThemeId(String uiName) {
 150                 return defaultThemeId;
 151         }
 152
 153         @Override
 154         public void refreshUi(Composite parent, String state) {
 155                 try {
 156                         Node context = null;
 157                         SuiteUi ui = (SuiteUi) parent;
 158                         CmsView cmsView = CmsView.getCmsView(parent);
 159                         CmsUiProvider headerUiProvider = findUiProvider(headerPid);
 160                         CmsUiProvider footerUiProvider = findUiProvider(footerPid);
 161                         CmsUiProvider leadPaneUiProvider = findUiProvider(leadPanePid);
 162
 163                         Localized appTitle = null;
 164                         if (headerUiProvider instanceof DefaultHeader) {
 165                                 appTitle = ((DefaultHeader) headerUiProvider).getTitle();
 166                         }
 167                         ui.setTitle(appTitle);
 168
 169                         if (cmsView.isAnonymous() && publicBasePath == null) {// internal app, must login
 170                                 ui.logout();
 171                                 if (headerUiProvider != null)
 172                                         refreshPart(headerUiProvider, ui.getHeader(), context);
 173                                 ui.refreshBelowHeader(false);
 174                                 refreshPart(findUiProvider(loginScreenPid), ui.getBelowHeader(), context);
 175                                 if (footerUiProvider != null)
 176                                         refreshPart(footerUiProvider, ui.getFooter(), context);
 177                                 ui.layout(true, true);
 178                                 setState(ui, LOGIN);
 179                         } else {
 180                                 if (LOGIN.equals(state))
 181                                         state = null;
 182                                 CmsSession cmsSession = cmsView.getCmsSession();
 183                                 if (ui.getUserDir() == null) {
 184                                         // FIXME NPE on CMSSession when logging in from anonymous
 185                                         if (cmsSession == null || cmsView.isAnonymous()) {
 186                                                 assert publicBasePath != null;
 187                                                 ui.initSessions(getRepository(), publicBasePath);
 188                                         } else {
 189                                                 Session adminSession = null;
 190                                                 try {
 191                                                         adminSession = NodeUtils.openDataAdminSession(getRepository(), null);
 192                                                         Node userDir = SuiteUtils.getOrCreateCmsSessionNode(adminSession, cmsSession);
 193                                                         ui.initSessions(getRepository(), userDir.getPath());
 194                                                 } finally {
 195                                                         Jcr.logout(adminSession);
 196                                                 }
 197                                         }
 198                                 }
 199                                 initLocale(cmsSession);
 200                                 context = stateToNode(ui, state);
 201                                 if (context == null)
 202                                         context = ui.getUserDir();
 203
 204                                 if (headerUiProvider != null)
 205                                         refreshPart(headerUiProvider, ui.getHeader(), context);
 206                                 ui.refreshBelowHeader(true);
 207                                 for (String key : layersByPid.keySet()) {
 208                                         SuiteLayer layer = layersByPid.get(key).get();
 209                                         ui.addLayer(key, layer);
 210                                 }
 211
 212                                 if (leadPaneUiProvider != null)
 213                                         refreshPart(leadPaneUiProvider, ui.getLeadPane(), context);
 214                                 if (footerUiProvider != null)
 215                                         refreshPart(footerUiProvider, ui.getFooter(), context);
 216                                 ui.layout(true, true);
 217                                 setState(parent, state != null ? state : defaultLayerPid);
 218                         }
 219                 } catch (Exception e) {
 220                         CmsFeedback.show("Unexpected exception", e);
 221                 }
 222         }
 223
 224         private void initLocale(CmsSession cmsSession) {
 225                 if (cmsSession == null)
 226                         return;
 227                 Locale locale = cmsSession.getLocale();
 228                 UiContext.setLocale(locale);
 229                 LocaleUtils.setThreadLocale(locale);
 230
 231         }
 232
 233         private void refreshPart(CmsUiProvider uiProvider, Composite part, Node context) {
 234                 CmsUiUtils.clear(part);
 235                 uiProvider.createUiPart(part, context);
 236         }
 237
 238         private CmsUiProvider findUiProvider(String pid) {
 239                 if (!uiProvidersByPid.containsKey(pid))
 240                         return null;
 241                 return uiProvidersByPid.get(pid).get();
 242         }
 243
 244         private SuiteLayer findLayer(String pid) {
 245                 if (!layersByPid.containsKey(pid))
 246                         return null;
 247                 return layersByPid.get(pid).get();
 248         }
 249
 250         private <T> T findByType(Map<String, RankedObject<T>> byType, Node context) {
 251                 if (context == null)
 252                         throw new IllegalArgumentException("A node should be provided");
 253                 try {
 254                         // mixins
 255                         Set<String> types = new TreeSet<>();
 256                         for (NodeType mixinType : context.getMixinNodeTypes()) {
 257                                 String mixinTypeName = mixinType.getName();
 258                                 if (byType.containsKey(mixinTypeName)) {
 259                                         types.add(mixinTypeName);
 260                                 }
 261                                 for (NodeType superType : mixinType.getDeclaredSupertypes()) {
 262                                         if (byType.containsKey(superType.getName())) {
 263                                                 types.add(superType.getName());
 264                                         }
 265                                 }
 266                         }
 267                         // primary node type
 268                         NodeType primaryType = context.getPrimaryNodeType();
 269                         String primaryTypeName = primaryType.getName();
 270                         if (byType.containsKey(primaryTypeName)) {
 271                                 types.add(primaryTypeName);
 272                         }
 273                         for (NodeType superType : primaryType.getDeclaredSupertypes()) {
 274                                 if (byType.containsKey(superType.getName())) {
 275                                         types.add(superType.getName());
 276                                 }
 277                         }
 278                         // entity type
 279                         if (context.isNodeType(EntityType.entity.get())) {
 280                                 if (context.hasProperty(EntityNames.ENTITY_TYPE)) {
 281                                         String entityTypeName = context.getProperty(EntityNames.ENTITY_TYPE).getString();
 282                                         if (byType.containsKey(entityTypeName)) {
 283                                                 types.add(entityTypeName);
 284                                         }
 285                                 }
 286                         }
 287
 288 //                      if (context.getPath().equals("/")) {// root node
 289 //                              types.add("nt:folder");
 290 //                      }
 291                         if (NodeUtils.isUserHome(context) && byType.containsKey("nt:folder")) {// home node
 292                                 types.add("nt:folder");
 293                         }
 294
 295                         if (types.size() == 0)
 296                                 throw new IllegalArgumentException("No type found for " + context + " (" + listTypes(context) + ")");
 297                         String type = types.iterator().next();
 298                         if (!byType.containsKey(type))
 299                                 throw new IllegalArgumentException("No component found for " + context + " with type " + type);
 300                         return byType.get(type).get();
 301                 } catch (RepositoryException e) {
 302                         throw new IllegalStateException(e);
 303                 }
 304         }
 305
 306         private static String listTypes(Node context) {
 307                 try {
 308                         StringBuilder sb = new StringBuilder();
 309                         sb.append(context.getPrimaryNodeType().getName());
 310                         for (NodeType superType : context.getPrimaryNodeType().getDeclaredSupertypes()) {
 311                                 sb.append(' ');
 312                                 sb.append(superType.getName());
 313                         }
 314
 315                         for (NodeType nodeType : context.getMixinNodeTypes()) {
 316                                 sb.append(' ');
 317                                 sb.append(nodeType.getName());
 318                                 if (nodeType.getName().equals(EntityType.local.get()))
 319                                         sb.append('/').append(context.getProperty(EntityNames.ENTITY_TYPE).getString());
 320                                 for (NodeType superType : nodeType.getDeclaredSupertypes()) {
 321                                         sb.append(' ');
 322                                         sb.append(superType.getName());
 323                                 }
 324                         }
 325                         return sb.toString();
 326                 } catch (RepositoryException e) {
 327                         throw new JcrException(e);
 328                 }
 329         }
 330
 331         @Override
 332         public void setState(Composite parent, String state) {
 333                 if (state == null)
 334                         return;
 335                 if (!state.startsWith("/")) {
 336                         if (parent instanceof SuiteUi) {
 337                                 SuiteUi ui = (SuiteUi) parent;
 338                                 if (LOGIN.equals(state) || state.equals("~")) {
 339                                         String appTitle = "";
 340                                         if (ui.getTitle() != null)
 341                                                 appTitle = ui.getTitle().lead();
 342                                         ui.getCmsView().stateChanged(state, appTitle);
 343                                         return;
 344                                 }
 345                                 String currentLayerId = ui.getCurrentLayerId();
 346                                 if (state.equals(currentLayerId))
 347                                         return; // does nothing
 348                                 else {
 349                                         Map<String, Object> properties = new HashMap<>();
 350                                         properties.put(SuiteEvent.LAYER, state);
 351                                         ui.getCmsView().sendEvent(SuiteEvent.switchLayer.topic(), properties);
 352                                 }
 353                         }
 354                         return;
 355                 }
 356                 SuiteUi suiteUi = (SuiteUi) parent;
 357                 Node node = stateToNode(suiteUi, state);
 358                 if (node == null) {
 359                         suiteUi.getCmsView().navigateTo("~");
 360                 } else {
 361                         suiteUi.getCmsView().sendEvent(SuiteEvent.switchLayer.topic(), SuiteEvent.eventProperties(node));
 362                         suiteUi.getCmsView().sendEvent(SuiteEvent.refreshPart.topic(), SuiteEvent.eventProperties(node));
 363                 }
 364         }
 365
 366         private String nodeToState(Node node) {
 367                 return '/' + Jcr.getWorkspaceName(node) + Jcr.getPath(node);
 368         }
 369
 370         private Node stateToNode(SuiteUi suiteUi, String state) {
 371                 if (suiteUi == null)
 372                         return null;
 373                 if (state == null || !state.startsWith("/"))
 374                         return null;
 375
 376                 String path = state.substring(1);
 377                 String workspace;
 378                 if (path.equals("")) {
 379                         workspace = null;
 380                         path = "/";
 381                 } else {
 382                         int index = path.indexOf('/');
 383                         if (index == 0) {
 384                                 log.error("Cannot interpret " + state);
 385 //                              cmsView.navigateTo("~");
 386                                 return null;
 387                         } else if (index > 0) {
 388                                 workspace = path.substring(0, index);
 389                                 path = path.substring(index);
 390                         } else {// index<0, assuming root node
 391                                 workspace = path;
 392                                 path = "/";
 393                         }
 394                 }
 395                 Session session = suiteUi.getSession(workspace);
 396                 if (session == null)
 397                         return null;
 398                 Node node = Jcr.getNode(session, path);
 399                 return node;
 400         }
 401
 402         /*
 403          * Events management
 404          */
 405
 406         @Override
 407         public void handleEvent(Event event) {
 408
 409                 // Specific UI related events
 410                 SuiteUi ui = getRelatedUi(event);
 411                 if (ui == null)
 412                         return;
 413                 try {
 414                         String appTitle = "";
 415                         if (ui.getTitle() != null)
 416                                 appTitle = ui.getTitle().lead() + " - ";
 417
 418 //                      String currentLayerId = ui.getCurrentLayerId();
 419 //                      SuiteLayer currentLayer = currentLayerId != null ? layersByPid.get(currentLayerId).get() : null;
 420                         if (SuiteUiUtils.isTopic(event, SuiteEvent.refreshPart)) {
 421                                 Node node = getNode(ui, event);
 422                                 if (node == null)
 423                                         return;
 424                                 CmsUiProvider uiProvider = findByType(uiProvidersByType, node);
 425                                 SuiteLayer layer = findByType(layersByType, node);
 426                                 ui.switchToLayer(layer, node);
 427                                 ui.getCmsView().runAs(() -> layer.view(uiProvider, ui.getCurrentWorkArea(), node));
 428                                 ui.getCmsView().stateChanged(nodeToState(node), appTitle + Jcr.getTitle(node));
 429                         } else if (SuiteUiUtils.isTopic(event, SuiteEvent.openNewPart)) {
 430                                 Node node = getNode(ui, event);
 431                                 if (node == null)
 432                                         return;
 433                                 CmsUiProvider uiProvider = findByType(uiProvidersByType, node);
 434                                 SuiteLayer layer = findByType(layersByType, node);
 435                                 ui.switchToLayer(layer, node);
 436                                 ui.getCmsView().runAs(() -> layer.open(uiProvider, ui.getCurrentWorkArea(), node));
 437                                 ui.getCmsView().stateChanged(nodeToState(node), appTitle + Jcr.getTitle(node));
 438                         } else if (SuiteUiUtils.isTopic(event, SuiteEvent.switchLayer)) {
 439                                 String layerId = get(event, SuiteEvent.LAYER);
 440                                 if (layerId != null) {
 441 //                                      ui.switchToLayer(layerId, ui.getUserDir());
 442                                         SuiteLayer suiteLayer = findLayer(layerId);
 443                                         Localized layerTitle = suiteLayer.getTitle();
 444                                         ui.getCmsView().runAs(() -> ui.switchToLayer(layerId, ui.getUserDir()));
 445                                         String title = null;
 446                                         if (layerTitle != null)
 447                                                 title = layerTitle.lead();
 448                                         ui.getCmsView().stateChanged(layerId, appTitle + title);
 449                                 } else {
 450                                         Node node = getNode(ui, event);
 451                                         if (node != null) {
 452                                                 SuiteLayer layer = findByType(layersByType, node);
 453                                                 ui.getCmsView().runAs(() -> ui.switchToLayer(layer, node));
 454                                         }
 455                                 }
 456                         }
 457                 } catch (Exception e) {
 458                         log.error("Cannot handle event " + event, e);
 459 //                      CmsView.getCmsView(ui).exception(e);
 460                 }
 461
 462         }
 463
 464         private Node getNode(SuiteUi ui, Event event) {
 465                 String nodePath = get(event, SuiteEvent.NODE_PATH);
 466                 String workspaceName = get(event, SuiteEvent.WORKSPACE);
 467                 Session session = ui.getSession(workspaceName);
 468                 Node node;
 469                 if (nodePath == null) {
 470                         // look for a user
 471                         String username = get(event, SuiteEvent.USERNAME);
 472                         if (username == null)
 473                                 return null;
 474                         User user = cmsUserManager.getUser(username);
 475                         if (user == null)
 476                                 return null;
 477                         LdapName userDn;
 478                         try {
 479                                 userDn = new LdapName(user.getName());
 480                         } catch (InvalidNameException e) {
 481                                 throw new IllegalArgumentException("Badly formatted username", e);
 482                         }
 483                         String userNodePath = SuiteUtils.getUserNodePath(userDn);
 484                         if (Jcr.itemExists(session, userNodePath))
 485                                 node = Jcr.getNode(session, userNodePath);
 486                         else {
 487                                 Session adminSession = null;
 488                                 try {
 489                                         adminSession = NodeUtils.openDataAdminSession(getRepository(), workspaceName);
 490                                         SuiteUtils.getOrCreateUserNode(adminSession, userDn);
 491                                 } finally {
 492                                         Jcr.logout(adminSession);
 493                                 }
 494                                 node = Jcr.getNode(session, userNodePath);
 495                         }
 496                 } else {
 497                         node = Jcr.getNode(session, nodePath);
 498                 }
 499                 return node;
 500         }
 501
 502         private SuiteUi getRelatedUi(Event event) {
 503                 return managedUis.get(get(event, CMS_VIEW_UID_PROPERTY));
 504         }
 505
 506         public static String get(Event event, String key) {
 507                 Object value = event.getProperty(key);
 508                 if (value == null)
 509                         return null;
 510 //                      throw new IllegalArgumentException("Property " + key + " must be set");
 511                 return value.toString();
 512
 513         }
 514
 515         /*
 516          * Dependency injection.
 517          */
 518
 519         public void addUiProvider(CmsUiProvider uiProvider, Map<String, Object> properties) {
 520                 if (properties.containsKey(Constants.SERVICE_PID)) {
 521                         String pid = (String) properties.get(Constants.SERVICE_PID);
 522                         RankedObject.putIfHigherRank(uiProvidersByPid, pid, uiProvider, properties);
 523                 }
 524                 if (properties.containsKey(EntityConstants.TYPE)) {
 525                         List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
 526                         for (String type : types)
 527                                 RankedObject.putIfHigherRank(uiProvidersByType, type, uiProvider, properties);
 528                 }
 529         }
 530
 531         public void removeUiProvider(CmsUiProvider uiProvider, Map<String, Object> properties) {
 532                 if (properties.containsKey(Constants.SERVICE_PID)) {
 533                         String pid = (String) properties.get(Constants.SERVICE_PID);
 534                         if (uiProvidersByPid.containsKey(pid)) {
 535                                 if (uiProvidersByPid.get(pid).equals(new RankedObject<CmsUiProvider>(uiProvider, properties))) {
 536                                         uiProvidersByPid.remove(pid);
 537                                 }
 538                         }
 539                 }
 540                 if (properties.containsKey(EntityConstants.TYPE)) {
 541                         List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
 542                         for (String type : types) {
 543                                 if (uiProvidersByType.containsKey(type)) {
 544                                         if (uiProvidersByType.get(type).equals(new RankedObject<CmsUiProvider>(uiProvider, properties))) {
 545                                                 uiProvidersByType.remove(type);
 546                                         }
 547                                 }
 548                         }
 549                 }
 550         }
 551
 552         public void addLayer(SuiteLayer layer, Map<String, Object> properties) {
 553                 if (properties.containsKey(Constants.SERVICE_PID)) {
 554                         String pid = (String) properties.get(Constants.SERVICE_PID);
 555                         RankedObject.putIfHigherRank(layersByPid, pid, layer, properties);
 556                 }
 557                 if (properties.containsKey(EntityConstants.TYPE)) {
 558                         List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
 559                         for (String type : types)
 560                                 RankedObject.putIfHigherRank(layersByType, type, layer, properties);
 561                 }
 562         }
 563
 564         public void removeLayer(SuiteLayer layer, Map<String, Object> properties) {
 565                 if (properties.containsKey(Constants.SERVICE_PID)) {
 566                         String pid = (String) properties.get(Constants.SERVICE_PID);
 567                         if (layersByPid.containsKey(pid)) {
 568                                 if (layersByPid.get(pid).equals(new RankedObject<SuiteLayer>(layer, properties))) {
 569                                         layersByPid.remove(pid);
 570                                 }
 571                         }
 572                 }
 573                 if (properties.containsKey(EntityConstants.TYPE)) {
 574                         List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
 575                         for (String type : types) {
 576                                 if (layersByType.containsKey(type)) {
 577                                         if (layersByType.get(type).equals(new RankedObject<CmsUiProvider>(layer, properties))) {
 578                                                 layersByType.remove(type);
 579                                         }
 580                                 }
 581                         }
 582                 }
 583         }
 584
 585         public void setCmsUserManager(CmsUserManager cmsUserManager) {
 586                 this.cmsUserManager = cmsUserManager;
 587         }
 588
 589 }